14872145375

Committed 06 May 2025 09:07PM UTC coverage: 72.232% (+0.02%) from 72.214%

Build # 14872145375

Build Type

push

github

Committed by

DaanDeMeyer

Commit Message

string-table: annotate _to_string and _from_string with _const_ and _pure_, respectively

Follow-up for c94f6ab1b

Coverage Stats

297286 of 411572 relevant lines covered (72.23%)

695615.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.84

/src/shared/parse-argument.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include "format-table.h"
#include "log.h"
#include "parse-argument.h"
#include "parse-util.h"
#include "path-util.h"
#include "signal-util.h"
#include "stdio-util.h"
#include "string-table.h"
#include "string-util.h"

/* All functions in this file emit warnings. */

int parse_boolean_argument(const char *optname, const char *s, bool *ret) {
        int r;

        /* Returns the result through *ret and the return value. */

        if (s) {
                r = parse_boolean(s);
                if (r < 0)
                        return log_error_errno(r, "Failed to parse boolean argument to %s: %s.", optname, s);

                if (ret)
                        *ret = r;
                return r;
        } else {
                /* s may be NULL. This is controlled by getopt_long() parameters. */
                if (ret)
                        *ret = true;
                return true;
        }
}

int parse_tristate_argument(const char *optname, const char *s, int *ret) {
        int r;

        if (s) {
                r = parse_boolean(s);
                if (r < 0)
                        return log_error_errno(r, "Failed to parse boolean argument to %s: %s.", optname, s);

                if (ret)
                        *ret = r;

                return r;
        } else {
                if (ret)
                        *ret = -1;

                return 0;
        }
}

int parse_json_argument(const char *s, sd_json_format_flags_t *ret) {
        assert(s);
        assert(ret);

        if (streq(s, "pretty"))
                *ret = SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_COLOR_AUTO;
        else if (streq(s, "short"))
                *ret = SD_JSON_FORMAT_NEWLINE;
        else if (streq(s, "off"))
                *ret = SD_JSON_FORMAT_OFF;
        else if (streq(s, "help")) {
                puts("pretty\n"
                     "short\n"
                     "off");
                return 0; /* 0 means → we showed a brief help, exit now */
        } else
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown argument to --json= switch: %s", s);

        return 1; /* 1 means → properly parsed */
}

int parse_path_argument(const char *path, bool suppress_root, char **arg) {
        char *p;
        int r;

        /*
         * This function is intended to be used in command line parsers, to handle paths that are passed
         * in. It makes the path absolute, and reduces it to NULL if omitted or root (the latter optionally).
         *
         * NOTE THAT THIS WILL FREE THE PREVIOUS ARGUMENT POINTER ON SUCCESS!
         * Hence, do not pass in uninitialized pointers.
         */

        if (isempty(path)) {
                *arg = mfree(*arg);
                return 0;
        }

        r = path_make_absolute_cwd(path, &p);
        if (r < 0)
                return log_error_errno(r, "Failed to parse path \"%s\" and make it absolute: %m", path);

        path_simplify(p);
        if (suppress_root && empty_or_root(p))
                p = mfree(p);

        return free_and_replace(*arg, p);
}

int parse_signal_argument(const char *s, int *ret) {
        int r;

        assert(s);
        assert(ret);

        if (streq(s, "help")) {
                DUMP_STRING_TABLE(signal, int, _NSIG);
                return 0;
        }

        if (streq(s, "list")) {
                _cleanup_(table_unrefp) Table *table = NULL;

                table = table_new("signal", "name");
                if (!table)
                        return log_oom();

                for (int i = 1; i < _NSIG; i++) {
                        r = table_add_many(
                                        table,
                                        TABLE_INT, i,
                                        TABLE_SIGNAL, i);
                        if (r < 0)
                                return table_log_add_error(r);
                }

                r = table_print(table, NULL);
                if (r < 0)
                        return table_log_print_error(r);

                return 0;
        }

        r = signal_from_string(s);
        if (r < 0)
                return log_error_errno(r, "Failed to parse signal string \"%s\".", s);

        *ret = r;
        return 1; /* work to do */
}

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include "format-table.h"
4	#include "log.h"
5	#include "parse-argument.h"
6	#include "parse-util.h"
7	#include "path-util.h"
8	#include "signal-util.h"
9	#include "stdio-util.h"
10	#include "string-table.h"
11	#include "string-util.h"
12
13	/* All functions in this file emit warnings. */
14
15	int parse_boolean_argument(const char optname, const char s, bool *ret) {	1,087✔
16	int r;	1,087✔
17
18	/* Returns the result through ret and the return value. /
19
20	if (s) {	1,087✔
21	r = parse_boolean(s);	1,082✔
22	if (r < 0)	1,082✔
23	return log_error_errno(r, "Failed to parse boolean argument to %s: %s.", optname, s);	33✔
24
25	if (ret)	1,049✔
26	*ret = r;	822✔
27	return r;	1,049✔
28	} else {
29	/* s may be NULL. This is controlled by getopt_long() parameters. */
30	if (ret)	5✔
31	*ret = true;	5✔
32	return true;	5✔
33	}
34	}
35
36	int parse_tristate_argument(const char optname, const char s, int *ret) {	2✔
37	int r;	2✔
38
39	if (s) {	2✔
40	r = parse_boolean(s);	2✔
41	if (r < 0)	2✔
42	return log_error_errno(r, "Failed to parse boolean argument to %s: %s.", optname, s);	×
43
44	if (ret)	2✔
45	*ret = r;	2✔
46
47	return r;	2✔
48	} else {
49	if (ret)	×
50	*ret = -1;	×
51
52	return 0;	×
53	}
54	}
55
56	int parse_json_argument(const char s, sd_json_format_flags_t ret) {	290✔
57	assert(s);	290✔
58	assert(ret);	290✔
59
60	if (streq(s, "pretty"))	290✔
61	*ret = SD_JSON_FORMAT_PRETTY\|SD_JSON_FORMAT_COLOR_AUTO;	98✔
62	else if (streq(s, "short"))	192✔
63	*ret = SD_JSON_FORMAT_NEWLINE;	170✔
64	else if (streq(s, "off"))	22✔
65	*ret = SD_JSON_FORMAT_OFF;	11✔
66	else if (streq(s, "help")) {	11✔
67	puts("pretty\n"	3✔
68	"short\n"
69	"off");
70	return 0; /* 0 means → we showed a brief help, exit now */	3✔
71	} else
72	return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown argument to --json= switch: %s", s);	8✔
73
74	return 1; /* 1 means → properly parsed */
75	}
76
77	int parse_path_argument(const char path, bool suppress_root, char *arg) {	2,111✔
78	char *p;	2,111✔
79	int r;	2,111✔
80
81	/*
82	* This function is intended to be used in command line parsers, to handle paths that are passed
83	* in. It makes the path absolute, and reduces it to NULL if omitted or root (the latter optionally).
84	*
85	* NOTE THAT THIS WILL FREE THE PREVIOUS ARGUMENT POINTER ON SUCCESS!
86	* Hence, do not pass in uninitialized pointers.
87	*/
88
89	if (isempty(path)) {	2,111✔
90	arg = mfree(arg);	8✔
91	return 0;	8✔
92	}
93
94	r = path_make_absolute_cwd(path, &p);	2,103✔
95	if (r < 0)	2,103✔
96	return log_error_errno(r, "Failed to parse path \"%s\" and make it absolute: %m", path);	×
97
98	path_simplify(p);	2,103✔
99	if (suppress_root && empty_or_root(p))	2,103✔
100	p = mfree(p);	3✔
101
102	return free_and_replace(*arg, p);	2,103✔
103	}
104
105	int parse_signal_argument(const char s, int ret) {	30✔
106	int r;	30✔
107
108	assert(s);	30✔
109	assert(ret);	30✔
110
111	if (streq(s, "help")) {	30✔
112	DUMP_STRING_TABLE(signal, int, _NSIG);	132✔
113	return 0;	2✔
114	}
115
116	if (streq(s, "list")) {	28✔
117	_cleanup_(table_unrefp) Table *table = NULL;	1✔
118
119	table = table_new("signal", "name");	1✔
120	if (!table)	1✔
121	return log_oom();	×
122
123	for (int i = 1; i < _NSIG; i++) {	65✔
124	r = table_add_many(	64✔
125	table,
126	TABLE_INT, i,
127	TABLE_SIGNAL, i);
128	if (r < 0)	64✔
129	return table_log_add_error(r);	×
130	}
131
132	r = table_print(table, NULL);	1✔
133	if (r < 0)	1✔
134	return table_log_print_error(r);	×
135
136	return 0;
137	}
138
139	r = signal_from_string(s);	27✔
140	if (r < 0)	27✔
141	return log_error_errno(r, "Failed to parse signal string \"%s\".", s);	×
142
143	*ret = r;	27✔
144	return 1; /* work to do */	27✔
145	}

systemd / systemd / 14872145375

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous