Raw File
1 #include <stdio.h>
2 #include <ctype.h>
3 #include <string.h>
4
5 #include "getcmd.h"
6
7 int getData(char line[],
8 int* index,
9 int len,
10 int* data_start,
11 int* data_end,
12 int complex_parse
13 ) {
14 int alpha = FALSE;
15 int done = FALSE;
16
17 *data_start = *index;
18
19 while(*index < len && done != TRUE) {
20 // I'm going to assume either
21 // a number
22 // a string with a space
23 switch(line[*index]) {
24 case ' ':
25 if(!complex_parse && *index != *data_start) {
26 // leave space, next call will skip it.
27 done = TRUE;
28 } else if(*index != *data_start) {
29 // we are complex, add the space and continue.
30 (*index)++;
31 } else {
32 // we have not started, eat space and continue.
33 (*index)++;
34 *data_start = *index;
35 }
36 break;
37 case 0:
38 done = TRUE;
39 break;
40 case '0':
41 case '1':
42 case '2':
43 case '3':
44 case '4':
45 case '5':
46 case '6':
47 case '7':
48 case '8':
49 case '9': // isnum
50 (*index)++;
51 break;
52 default:
53 if(!complex_parse && *index != *data_start && 0 == alpha) {
54 // we were a number, but we've hit an alpha 'S0=137S...'
55 done = TRUE;
56 } else {
57 (*index)++;
58 alpha = TRUE;
59 }
60 break;
61 }
62 }
63 *data_end = (*index);
64 return 0;
65 }
66
67 int getNumber(char line[], int *index, int len) {
68 int num = 0;
69 int found = FALSE;
70
71 while(*index < len && 0 != isdigit((int)line[*index])) {
72 num = num * 10 + line[(*index)++] - '0';
73 found = 1;
74 }
75 if(FALSE == found)
76 return -1;
77 return num;
78 }
79
80 int skip(char line[], int *index, int len, char ch) {
81 while(*index < len && ch == line[*index])
82 (*index)++;
83 return 0;
84
85 }
86
87 int getCommand(char line[],
88 int flags,
89 int* index,
90 int* num,
91 int len
92 ) {
93 int cmd = line[(*index)++];
94
95 *num = getNumber(line, index, len);
96 return cmd;
97 }
98
99 int parseCommand(char line[],
100 int flags,
101 int *index,
102 int *num,
103 int len
104 ) {
105 int cmd = getCommand(line, flags, index, num, len);
106
107 if(0 < cmd && 0 > *num)
108 *num = 0;
109 return toupper(cmd) | flags;
110 }
111
112 int parseRegister(char line[],
113 int flags,
114 int *index,
115 int *num,
116 int len,
117 int *data_start,
118 int *data_end,
119 int complex_parse
120 ) {
121 // need to handle S<num>?, which queries that S register.
122 int cmd = 0;
123
124 cmd = getCommand(line, flags, index, num, len);
125 if(0 > num)
126 return AT_CMD_ERR;
127 skip(line, index, len, ' ');
128 if(len == *index)
129 return AT_CMD_ERR;
130 switch (line[(*index)++]) {
131 case '=':
132 // set a register
133 skip(line, index, len, ' ');
134 if(0 > getData(line, index, len, data_start, data_end, complex_parse))
135 return AT_CMD_ERR;
136 break;
137 case '?':
138 // query a register
139 flags |= AT_CMD_FLAG_QUERY;
140 if(*num < 0)
141 *num = 0;
142 break;
143 default:
144 return AT_CMD_ERR;
145 }
146 return toupper(cmd) | flags;
147 }
148
149 int getcmd(char line[],
150 int len,
151 int *index,
152 int *num,
153 int *data_start,
154 int *data_end
155 ) {
156 int cmd = AT_CMD_END;
157
158 *num = 0;
159 *data_start = 0;
160 *data_end = 0;
161
162 if(line == NULL)
163 return AT_CMD_NONE;
164 while(*index < len) {
165 cmd = toupper(line[*index]);
166 switch (cmd) {
167 case ' ':
168 break;
169 case 0:
170 return AT_CMD_END;
171 case '%':
172 (*index)++;
173 while(*index < len) {
174 switch(toupper(line[*index])) {
175 case ' ':
176 break;
177 case 0:
178 return AT_CMD_ERR;
179 default:
180 return parseCommand(line, AT_CMD_FLAG_PRO_PCT, index, num, len);
181 }
182 (*index)++;
183 }
184 break;
185 case '\\':
186 (*index)++;
187 while(*index < len) {
188 switch(toupper(line[*index])) {
189 case ' ':
190 break;
191 case 0:
192 return AT_CMD_ERR;
193 default:
194 return parseCommand(line, AT_CMD_FLAG_PRO_BACK, index, num, len);
195 }
196 (*index)++;
197 }
198 break;
199 case ':':
200 (*index)++;
201 while(*index < len) {
202 switch(toupper(line[*index])) {
203 case ' ':
204 break;
205 case 0:
206 return AT_CMD_ERR;
207 default:
208 return parseCommand(line, AT_CMD_FLAG_PRO_COLON, index, num, len);
209 }
210 (*index)++;
211 }
212 break;
213 case '-':
214 (*index)++;
215 while(*index < len) {
216 switch(toupper(line[*index])) {
217 case ' ':
218 break;
219 case 0:
220 return AT_CMD_ERR;
221 default:
222 return parseCommand(line, AT_CMD_FLAG_PRO_MINUS, index, num, len);
223 }
224 (*index)++;
225 }
226 break;
227 case '&':
228 (*index)++;
229 while(*index < len) {
230 switch(toupper(line[*index])) {
231 case ' ':
232 break;
233 case 0:
234 return AT_CMD_ERR;
235 case 'Z':
236 return parseRegister(line, AT_CMD_FLAG_EXT, index, num, len, data_start, data_end, TRUE);
237 default:
238 return parseCommand(line, AT_CMD_FLAG_EXT, index, num, len);
239 }
240 (*index)++;
241 }
242 break;
243 case 'D': // handle Dialing.
244 (*index)++;
245 *num = 0;
246 while(*index < len) {
247 switch(toupper(line[*index])) {
248 case 0:
249 return cmd;
250 case 'T':
251 case 'P':
252 case 'L':
253 *num = toupper(line[*index]);
254 (*index)++;
255 default:
256 getData(line, index, len, data_start, data_end, TRUE);
257 return cmd;
258 }
259 (*index)++;
260 }
261 return cmd;
262 case 'S':
263 return parseRegister(line, AT_CMD_FLAG_BAS, index, num, len, data_start, data_end, FALSE);
264 default:
265 return parseCommand(line, AT_CMD_FLAG_BAS, index, num, len);
266 }
267 (*index)++;
268 }
269 return cmd;
270 }
271
272 int main_getcmd(int argc, char **argv) {
273 char data[] = "DT 555-1212";
274 int index = 0, num = 0, start = 0, end = 0;
275 int cmd = 0;
276
277 while(cmd != AT_CMD_END) {
278 cmd = getcmd(data, strlen(data), &index, &num, &start, &end);
279 printf("Cmd: %c Index: %d Num: %d Start: %d End: %d\n", cmd, index, num, start, end);
280 }
281 return 0;
282 }
283
Generated by GNU Enscript 1.6.6, and GophHub 1.3.