Commit | Line | Data |
---|---|---|
6e3d8d67 OM |
1 | //----------------------------------------------------------------------------- |
2 | // Copyright (C) 2017 Merlok | |
3 | // | |
4 | // This code is licensed to you under the terms of the GNU GPL, version 2 or, | |
5 | // at your option, any later version. See the LICENSE.txt file for the text of | |
6 | // the license. | |
7 | //----------------------------------------------------------------------------- | |
8 | // Command line parser core commands | |
9 | //----------------------------------------------------------------------------- | |
10 | ||
11 | #include "cliparser.h" | |
12 | #include <stdio.h> | |
13 | #include <string.h> | |
14 | ||
15 | void **argtable = NULL; | |
16 | size_t argtableLen = 0; | |
17 | char *programName = NULL; | |
18 | char *programHint = NULL; | |
19 | char *programHelp = NULL; | |
20 | char buf[500] = {0}; | |
21 | ||
22 | int CLIParserInit(char *vprogramName, char *vprogramHint, char *vprogramHelp) { | |
23 | argtable = NULL; | |
24 | argtableLen = 0; | |
25 | programName = vprogramName; | |
26 | programHint = vprogramHint; | |
27 | programHelp = vprogramHelp; | |
28 | memset(buf, 0x00, 500); | |
29 | ||
30 | return 0; | |
31 | } | |
32 | ||
33 | int CLIParserParseArg(int argc, char **argv, void* vargtable[], size_t vargtableLen, bool allowEmptyExec) { | |
34 | int nerrors; | |
35 | ||
36 | argtable = vargtable; | |
37 | argtableLen = vargtableLen; | |
38 | ||
39 | /* verify the argtable[] entries were allocated sucessfully */ | |
40 | if (arg_nullcheck(argtable) != 0) { | |
41 | /* NULL entries were detected, some allocations must have failed */ | |
42 | printf("ERROR: Insufficient memory\n"); | |
43 | return 2; | |
44 | } | |
45 | /* Parse the command line as defined by argtable[] */ | |
46 | nerrors = arg_parse(argc, argv, argtable); | |
47 | ||
48 | /* special case: '--help' takes precedence over error reporting */ | |
49 | if ((argc < 2 && !allowEmptyExec) ||((struct arg_lit *)argtable[0])->count > 0) { // help must be the first record | |
50 | printf("Usage: %s", programName); | |
51 | arg_print_syntaxv(stdout, argtable, "\n"); | |
52 | if (programHint) | |
53 | printf("%s\n\n", programHint); | |
54 | arg_print_glossary(stdout, argtable, " %-20s %s\n"); | |
55 | printf("\n"); | |
56 | if (programHelp) | |
57 | printf("%s \n", programHelp); | |
58 | ||
59 | return 1; | |
60 | } | |
61 | ||
62 | /* If the parser returned any errors then display them and exit */ | |
63 | if (nerrors > 0) { | |
64 | /* Display the error details contained in the arg_end struct.*/ | |
65 | arg_print_errors(stdout, ((struct arg_end *)argtable[vargtableLen - 1]), programName); | |
66 | printf("Try '%s --help' for more information.\n", programName); | |
67 | ||
68 | return 3; | |
69 | } | |
70 | ||
71 | return 0; | |
72 | } | |
73 | ||
74 | enum ParserState { | |
75 | PS_FIRST, | |
76 | PS_ARGUMENT, | |
77 | PS_OPTION, | |
78 | }; | |
79 | ||
80 | #define isSpace(c)(c == ' ' || c == '\t') | |
81 | ||
82 | int CLIParserParseString(const char* str, void* vargtable[], size_t vargtableLen, bool allowEmptyExec) { | |
11146fc1 OM |
83 | return CLIParserParseStringEx(str, vargtable, vargtableLen, allowEmptyExec, false); |
84 | } | |
85 | ||
86 | int CLIParserParseStringEx(const char* str, void* vargtable[], size_t vargtableLen, bool allowEmptyExec, bool clueData) { | |
6e3d8d67 OM |
87 | int argc = 0; |
88 | char *argv[200] = {NULL}; | |
89 | ||
90 | int len = strlen(str); | |
91 | char *bufptr = buf; | |
92 | char *spaceptr = NULL; | |
93 | enum ParserState state = PS_FIRST; | |
94 | ||
95 | argv[argc++] = bufptr; | |
96 | // param0 = program name | |
97 | memcpy(buf, programName, strlen(programName) + 1); // with 0x00 | |
98 | bufptr += strlen(programName) + 1; | |
99 | if (len) | |
100 | argv[argc++] = bufptr; | |
101 | ||
102 | // parse params | |
103 | for (int i = 0; i < len; i++) { | |
104 | switch(state){ | |
105 | case PS_FIRST: // first char | |
11146fc1 | 106 | if (!clueData || str[i] == '-'){ // first char before space is '-' - next element - option OR not "clueData" for not-option fields |
6e3d8d67 OM |
107 | state = PS_OPTION; |
108 | ||
109 | if (spaceptr) { | |
110 | bufptr = spaceptr; | |
111 | *bufptr = 0x00; | |
112 | bufptr++; | |
113 | argv[argc++] = bufptr; | |
114 | } | |
115 | } | |
116 | spaceptr = NULL; | |
117 | case PS_ARGUMENT: | |
118 | if (state == PS_FIRST) | |
119 | state = PS_ARGUMENT; | |
120 | if (isSpace(str[i])) { | |
121 | spaceptr = bufptr; | |
122 | state = PS_FIRST; | |
123 | } | |
124 | *bufptr = str[i]; | |
125 | bufptr++; | |
126 | break; | |
127 | case PS_OPTION: | |
128 | if (isSpace(str[i])){ | |
129 | state = PS_FIRST; | |
130 | ||
131 | *bufptr = 0x00; | |
132 | bufptr++; | |
133 | argv[argc++] = bufptr; | |
134 | break; | |
135 | } | |
136 | ||
137 | *bufptr = str[i]; | |
138 | bufptr++; | |
139 | break; | |
140 | } | |
141 | } | |
142 | ||
143 | return CLIParserParseArg(argc, argv, vargtable, vargtableLen, allowEmptyExec); | |
144 | } | |
145 | ||
146 | void CLIParserFree() { | |
147 | arg_freetable(argtable, argtableLen); | |
148 | argtable = NULL; | |
149 | ||
150 | return; | |
151 | } | |
152 | ||
153 | // convertors | |
154 | int CLIParamHexToBuf(struct arg_str *argstr, uint8_t *data, int maxdatalen, int *datalen) { | |
f23565c3 | 155 | *datalen = 0; |
95b697f0 OM |
156 | |
157 | int ibuf = 0; | |
158 | uint8_t buf[256] = {0}; | |
ae3340a0 | 159 | int res = CLIParamStrToBuf(argstr, buf, maxdatalen * 2, &ibuf); // *2 because here HEX |
95b697f0 OM |
160 | if (res || !ibuf) |
161 | return res; | |
162 | ||
163 | switch(param_gethex_to_eol((char *)buf, 0, data, maxdatalen, datalen)) { | |
164 | case 1: | |
165 | printf("Parameter error: Invalid HEX value.\n"); | |
166 | return 1; | |
167 | case 2: | |
168 | printf("Parameter error: parameter too large.\n"); | |
169 | return 2; | |
170 | case 3: | |
171 | printf("Parameter error: Hex string must have even number of digits.\n"); | |
172 | return 3; | |
173 | } | |
174 | ||
175 | return 0; | |
176 | } | |
177 | ||
178 | int CLIParamStrToBuf(struct arg_str *argstr, uint8_t *data, int maxdatalen, int *datalen) { | |
179 | *datalen = 0; | |
11146fc1 OM |
180 | if (!argstr->count) |
181 | return 0; | |
182 | ||
95b697f0 | 183 | uint8_t buf[256] = {0}; |
11146fc1 OM |
184 | int ibuf = 0; |
185 | ||
186 | for (int i = 0; i < argstr->count; i++) { | |
187 | int len = strlen(argstr->sval[i]); | |
188 | memcpy(&buf[ibuf], argstr->sval[i], len); | |
189 | ibuf += len; | |
190 | } | |
191 | buf[ibuf] = 0; | |
192 | ||
193 | if (!ibuf) | |
f23565c3 | 194 | return 0; |
95b697f0 OM |
195 | |
196 | if (ibuf > maxdatalen) | |
6e3d8d67 | 197 | return 2; |
95b697f0 OM |
198 | |
199 | memcpy(data, buf, ibuf); | |
200 | *datalen = ibuf; | |
6e3d8d67 OM |
201 | |
202 | return 0; | |
203 | } | |
204 | ||
205 |