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	}