/src/systemd/src/libsystemd/sd-bus/bus-type.c

Source (jump to first uncovered line)
/* SPDX-License-Identifier: LGPL-2.1+ */

#include <errno.h>

#include "sd-bus.h"

#include "bus-type.h"

bool bus_type_is_valid(char c) {
        static const char valid[] = {
                SD_BUS_TYPE_BYTE,
                SD_BUS_TYPE_BOOLEAN,
                SD_BUS_TYPE_INT16,
                SD_BUS_TYPE_UINT16,
                SD_BUS_TYPE_INT32,
                SD_BUS_TYPE_UINT32,
                SD_BUS_TYPE_INT64,
                SD_BUS_TYPE_UINT64,
                SD_BUS_TYPE_DOUBLE,
                SD_BUS_TYPE_STRING,
                SD_BUS_TYPE_OBJECT_PATH,
                SD_BUS_TYPE_SIGNATURE,
                SD_BUS_TYPE_ARRAY,
                SD_BUS_TYPE_VARIANT,
                SD_BUS_TYPE_STRUCT,
                SD_BUS_TYPE_DICT_ENTRY,
                SD_BUS_TYPE_UNIX_FD
        };

        return !!memchr(valid, c, sizeof(valid));
}

bool bus_type_is_basic(char c) {
        static const char valid[] = {
                SD_BUS_TYPE_BYTE,
                SD_BUS_TYPE_BOOLEAN,
                SD_BUS_TYPE_INT16,
                SD_BUS_TYPE_UINT16,
                SD_BUS_TYPE_INT32,
                SD_BUS_TYPE_UINT32,
                SD_BUS_TYPE_INT64,
                SD_BUS_TYPE_UINT64,
                SD_BUS_TYPE_DOUBLE,
                SD_BUS_TYPE_STRING,
                SD_BUS_TYPE_OBJECT_PATH,
                SD_BUS_TYPE_SIGNATURE,
                SD_BUS_TYPE_UNIX_FD
        };

        return !!memchr(valid, c, sizeof(valid));
}

bool bus_type_is_trivial(char c) {
        static const char valid[] = {
                SD_BUS_TYPE_BYTE,
                SD_BUS_TYPE_BOOLEAN,
                SD_BUS_TYPE_INT16,
                SD_BUS_TYPE_UINT16,
                SD_BUS_TYPE_INT32,
                SD_BUS_TYPE_UINT32,
                SD_BUS_TYPE_INT64,
                SD_BUS_TYPE_UINT64,
                SD_BUS_TYPE_DOUBLE
        };

        return !!memchr(valid, c, sizeof(valid));
}

bool bus_type_is_container(char c) {
        static const char valid[] = {
                SD_BUS_TYPE_ARRAY,
                SD_BUS_TYPE_VARIANT,
                SD_BUS_TYPE_STRUCT,
                SD_BUS_TYPE_DICT_ENTRY
        };

        return !!memchr(valid, c, sizeof(valid));
}

int bus_type_get_alignment(char c) {

        switch (c) {
        case SD_BUS_TYPE_BYTE:
        case SD_BUS_TYPE_SIGNATURE:
        case SD_BUS_TYPE_VARIANT:
                return 1;

        case SD_BUS_TYPE_INT16:
        case SD_BUS_TYPE_UINT16:
                return 2;

        case SD_BUS_TYPE_BOOLEAN:
        case SD_BUS_TYPE_INT32:
        case SD_BUS_TYPE_UINT32:
        case SD_BUS_TYPE_STRING:
        case SD_BUS_TYPE_OBJECT_PATH:
        case SD_BUS_TYPE_ARRAY:
        case SD_BUS_TYPE_UNIX_FD:
                return 4;

        case SD_BUS_TYPE_INT64:
        case SD_BUS_TYPE_UINT64:
        case SD_BUS_TYPE_DOUBLE:
        case SD_BUS_TYPE_STRUCT:
        case SD_BUS_TYPE_STRUCT_BEGIN:
        case SD_BUS_TYPE_DICT_ENTRY:
        case SD_BUS_TYPE_DICT_ENTRY_BEGIN:
                return 8;
        }

        return -EINVAL;
}

int bus_type_get_size(char c) {

        switch (c) {
        case SD_BUS_TYPE_BYTE:
                return 1;

        case SD_BUS_TYPE_INT16:
        case SD_BUS_TYPE_UINT16:
                return 2;

        case SD_BUS_TYPE_BOOLEAN:
        case SD_BUS_TYPE_INT32:
        case SD_BUS_TYPE_UINT32:
        case SD_BUS_TYPE_UNIX_FD:
                return 4;

        case SD_BUS_TYPE_INT64:
        case SD_BUS_TYPE_UINT64:
        case SD_BUS_TYPE_DOUBLE:
                return 8;
        }

        return -EINVAL;
}

Line	Count	Source (jump to first uncovered line)
1		/* SPDX-License-Identifier: LGPL-2.1+ */
2
3		#include <errno.h>
4
5		#include "sd-bus.h"
6
7		#include "bus-type.h"
8
9	0	bool bus_type_is_valid(char c) {
10	0	static const char valid[] = {
11	0	SD_BUS_TYPE_BYTE,
12	0	SD_BUS_TYPE_BOOLEAN,
13	0	SD_BUS_TYPE_INT16,
14	0	SD_BUS_TYPE_UINT16,
15	0	SD_BUS_TYPE_INT32,
16	0	SD_BUS_TYPE_UINT32,
17	0	SD_BUS_TYPE_INT64,
18	0	SD_BUS_TYPE_UINT64,
19	0	SD_BUS_TYPE_DOUBLE,
20	0	SD_BUS_TYPE_STRING,
21	0	SD_BUS_TYPE_OBJECT_PATH,
22	0	SD_BUS_TYPE_SIGNATURE,
23	0	SD_BUS_TYPE_ARRAY,
24	0	SD_BUS_TYPE_VARIANT,
25	0	SD_BUS_TYPE_STRUCT,
26	0	SD_BUS_TYPE_DICT_ENTRY,
27	0	SD_BUS_TYPE_UNIX_FD
28	0	};
29	0
30	0	return !!memchr(valid, c, sizeof(valid));
31	0	}
32
33	64.7M	bool bus_type_is_basic(char c) {
34	64.7M	static const char valid[] = {
35	64.7M	SD_BUS_TYPE_BYTE,
36	64.7M	SD_BUS_TYPE_BOOLEAN,
37	64.7M	SD_BUS_TYPE_INT16,
38	64.7M	SD_BUS_TYPE_UINT16,
39	64.7M	SD_BUS_TYPE_INT32,
40	64.7M	SD_BUS_TYPE_UINT32,
41	64.7M	SD_BUS_TYPE_INT64,
42	64.7M	SD_BUS_TYPE_UINT64,
43	64.7M	SD_BUS_TYPE_DOUBLE,
44	64.7M	SD_BUS_TYPE_STRING,
45	64.7M	SD_BUS_TYPE_OBJECT_PATH,
46	64.7M	SD_BUS_TYPE_SIGNATURE,
47	64.7M	SD_BUS_TYPE_UNIX_FD
48	64.7M	};
49	64.7M
50	64.7M	return !!memchr(valid, c, sizeof(valid));
51	64.7M	}
52
53	0	bool bus_type_is_trivial(char c) {
54	0	static const char valid[] = {
55	0	SD_BUS_TYPE_BYTE,
56	0	SD_BUS_TYPE_BOOLEAN,
57	0	SD_BUS_TYPE_INT16,
58	0	SD_BUS_TYPE_UINT16,
59	0	SD_BUS_TYPE_INT32,
60	0	SD_BUS_TYPE_UINT32,
61	0	SD_BUS_TYPE_INT64,
62	0	SD_BUS_TYPE_UINT64,
63	0	SD_BUS_TYPE_DOUBLE
64	0	};
65	0
66	0	return !!memchr(valid, c, sizeof(valid));
67	0	}
68
69	2.84M	bool bus_type_is_container(char c) {
70	2.84M	static const char valid[] = {
71	2.84M	SD_BUS_TYPE_ARRAY,
72	2.84M	SD_BUS_TYPE_VARIANT,
73	2.84M	SD_BUS_TYPE_STRUCT,
74	2.84M	SD_BUS_TYPE_DICT_ENTRY
75	2.84M	};
76	2.84M
77	2.84M	return !!memchr(valid, c, sizeof(valid));
78	2.84M	}
79
80	5.59k	int bus_type_get_alignment(char c) {
81	5.59k
82	5.59k	switch (c) {
83	5.59k	case SD_BUS_TYPE_BYTE:
84	1.52k	case SD_BUS_TYPE_SIGNATURE:
85	1.52k	case SD_BUS_TYPE_VARIANT:
86	1.52k	return 1;
87	1.52k
88	1.52k	case SD_BUS_TYPE_INT16:
89	1.10k	case SD_BUS_TYPE_UINT16:
90	1.10k	return 2;
91	1.10k
92	2.31k	case SD_BUS_TYPE_BOOLEAN:
93	2.31k	case SD_BUS_TYPE_INT32:
94	2.31k	case SD_BUS_TYPE_UINT32:
95	2.31k	case SD_BUS_TYPE_STRING:
96	2.31k	case SD_BUS_TYPE_OBJECT_PATH:
97	2.31k	case SD_BUS_TYPE_ARRAY:
98	2.31k	case SD_BUS_TYPE_UNIX_FD:
99	2.31k	return 4;
100	2.31k
101	2.31k	case SD_BUS_TYPE_INT64:
102	657	case SD_BUS_TYPE_UINT64:
103	657	case SD_BUS_TYPE_DOUBLE:
104	657	case SD_BUS_TYPE_STRUCT:
105	657	case SD_BUS_TYPE_STRUCT_BEGIN:
106	657	case SD_BUS_TYPE_DICT_ENTRY:
107	657	case SD_BUS_TYPE_DICT_ENTRY_BEGIN:
108	657	return 8;
109	0	}
110	0
111	0	return -EINVAL;
112	0	}
113
114	3.66k	int bus_type_get_size(char c) {
115	3.66k
116	3.66k	switch (c) {
117	3.66k	case SD_BUS_TYPE_BYTE:
118	994	return 1;
119	3.66k
120	3.66k	case SD_BUS_TYPE_INT16:
121	1.07k	case SD_BUS_TYPE_UINT16:
122	1.07k	return 2;
123	1.07k
124	1.13k	case SD_BUS_TYPE_BOOLEAN:
125	1.13k	case SD_BUS_TYPE_INT32:
126	1.13k	case SD_BUS_TYPE_UINT32:
127	1.13k	case SD_BUS_TYPE_UNIX_FD:
128	1.13k	return 4;
129	1.13k
130	1.13k	case SD_BUS_TYPE_INT64:
131	453	case SD_BUS_TYPE_UINT64:
132	453	case SD_BUS_TYPE_DOUBLE:
133	453	return 8;
134	0	}
135	0
136	0	return -EINVAL;
137	0	}

Coverage Report

Created: 2019-06-19 13:33