lib: Revert use of fallthrough pseudo-keyword in lib/
[linux-2.6-microblaze.git] / lib / cmdline.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * linux/lib/cmdline.c
4  * Helper functions generally used for parsing kernel command line
5  * and module options.
6  *
7  * Code and copyrights come from init/main.c and arch/i386/kernel/setup.c.
8  *
9  * GNU Indent formatting options for this file: -kr -i8 -npsl -pcs
10  */
11
12 #include <linux/export.h>
13 #include <linux/kernel.h>
14 #include <linux/string.h>
15 #include <linux/ctype.h>
16
17 /*
18  *      If a hyphen was found in get_option, this will handle the
19  *      range of numbers, M-N.  This will expand the range and insert
20  *      the values[M, M+1, ..., N] into the ints array in get_options.
21  */
22
23 static int get_range(char **str, int *pint, int n)
24 {
25         int x, inc_counter, upper_range;
26
27         (*str)++;
28         upper_range = simple_strtol((*str), NULL, 0);
29         inc_counter = upper_range - *pint;
30         for (x = *pint; n && x < upper_range; x++, n--)
31                 *pint++ = x;
32         return inc_counter;
33 }
34
35 /**
36  *      get_option - Parse integer from an option string
37  *      @str: option string
38  *      @pint: (output) integer value parsed from @str
39  *
40  *      Read an int from an option string; if available accept a subsequent
41  *      comma as well.
42  *
43  *      Return values:
44  *      0 - no int in string
45  *      1 - int found, no subsequent comma
46  *      2 - int found including a subsequent comma
47  *      3 - hyphen found to denote a range
48  */
49
50 int get_option(char **str, int *pint)
51 {
52         char *cur = *str;
53
54         if (!cur || !(*cur))
55                 return 0;
56         *pint = simple_strtol(cur, str, 0);
57         if (cur == *str)
58                 return 0;
59         if (**str == ',') {
60                 (*str)++;
61                 return 2;
62         }
63         if (**str == '-')
64                 return 3;
65
66         return 1;
67 }
68 EXPORT_SYMBOL(get_option);
69
70 /**
71  *      get_options - Parse a string into a list of integers
72  *      @str: String to be parsed
73  *      @nints: size of integer array
74  *      @ints: integer array
75  *
76  *      This function parses a string containing a comma-separated
77  *      list of integers, a hyphen-separated range of _positive_ integers,
78  *      or a combination of both.  The parse halts when the array is
79  *      full, or when no more numbers can be retrieved from the
80  *      string.
81  *
82  *      Return value is the character in the string which caused
83  *      the parse to end (typically a null terminator, if @str is
84  *      completely parseable).
85  */
86
87 char *get_options(const char *str, int nints, int *ints)
88 {
89         int res, i = 1;
90
91         while (i < nints) {
92                 res = get_option((char **)&str, ints + i);
93                 if (res == 0)
94                         break;
95                 if (res == 3) {
96                         int range_nums;
97                         range_nums = get_range((char **)&str, ints + i, nints - i);
98                         if (range_nums < 0)
99                                 break;
100                         /*
101                          * Decrement the result by one to leave out the
102                          * last number in the range.  The next iteration
103                          * will handle the upper number in the range
104                          */
105                         i += (range_nums - 1);
106                 }
107                 i++;
108                 if (res == 1)
109                         break;
110         }
111         ints[0] = i - 1;
112         return (char *)str;
113 }
114 EXPORT_SYMBOL(get_options);
115
116 /**
117  *      memparse - parse a string with mem suffixes into a number
118  *      @ptr: Where parse begins
119  *      @retptr: (output) Optional pointer to next char after parse completes
120  *
121  *      Parses a string into a number.  The number stored at @ptr is
122  *      potentially suffixed with K, M, G, T, P, E.
123  */
124
125 unsigned long long memparse(const char *ptr, char **retptr)
126 {
127         char *endptr;   /* local pointer to end of parsed string */
128
129         unsigned long long ret = simple_strtoull(ptr, &endptr, 0);
130
131         switch (*endptr) {
132         case 'E':
133         case 'e':
134                 ret <<= 10;
135                 /* fall through */
136         case 'P':
137         case 'p':
138                 ret <<= 10;
139                 /* fall through */
140         case 'T':
141         case 't':
142                 ret <<= 10;
143                 /* fall through */
144         case 'G':
145         case 'g':
146                 ret <<= 10;
147                 /* fall through */
148         case 'M':
149         case 'm':
150                 ret <<= 10;
151                 /* fall through */
152         case 'K':
153         case 'k':
154                 ret <<= 10;
155                 endptr++;
156         default:
157                 break;
158         }
159
160         if (retptr)
161                 *retptr = endptr;
162
163         return ret;
164 }
165 EXPORT_SYMBOL(memparse);
166
167 /**
168  *      parse_option_str - Parse a string and check an option is set or not
169  *      @str: String to be parsed
170  *      @option: option name
171  *
172  *      This function parses a string containing a comma-separated list of
173  *      strings like a=b,c.
174  *
175  *      Return true if there's such option in the string, or return false.
176  */
177 bool parse_option_str(const char *str, const char *option)
178 {
179         while (*str) {
180                 if (!strncmp(str, option, strlen(option))) {
181                         str += strlen(option);
182                         if (!*str || *str == ',')
183                                 return true;
184                 }
185
186                 while (*str && *str != ',')
187                         str++;
188
189                 if (*str == ',')
190                         str++;
191         }
192
193         return false;
194 }
195
196 /*
197  * Parse a string to get a param value pair.
198  * You can use " around spaces, but can't escape ".
199  * Hyphens and underscores equivalent in parameter names.
200  */
201 char *next_arg(char *args, char **param, char **val)
202 {
203         unsigned int i, equals = 0;
204         int in_quote = 0, quoted = 0;
205         char *next;
206
207         if (*args == '"') {
208                 args++;
209                 in_quote = 1;
210                 quoted = 1;
211         }
212
213         for (i = 0; args[i]; i++) {
214                 if (isspace(args[i]) && !in_quote)
215                         break;
216                 if (equals == 0) {
217                         if (args[i] == '=')
218                                 equals = i;
219                 }
220                 if (args[i] == '"')
221                         in_quote = !in_quote;
222         }
223
224         *param = args;
225         if (!equals)
226                 *val = NULL;
227         else {
228                 args[equals] = '\0';
229                 *val = args + equals + 1;
230
231                 /* Don't include quotes in value. */
232                 if (**val == '"') {
233                         (*val)++;
234                         if (args[i-1] == '"')
235                                 args[i-1] = '\0';
236                 }
237         }
238         if (quoted && args[i-1] == '"')
239                 args[i-1] = '\0';
240
241         if (args[i]) {
242                 args[i] = '\0';
243                 next = args + i + 1;
244         } else
245                 next = args + i;
246
247         /* Chew up trailing spaces. */
248         return skip_spaces(next);
249 }