介绍

代码


1#include <stdio.h>
2#include <stdlib.h>
3#include <string.h>
4
5// 是否打印debug信息
6static int g_arg_deg=1;
7
8typedef struct arg_pair_t {
9  char* sk;  // single key like -t      => t
10  char* dk;  // double key like --help  => help
11  char* v;   // the value
12  struct arg_pair_t* next;
13} arg_pair;
14
15typedef struct arg_struct_t {
16  arg_pair* data;
17} arg_struct;
18
19int destroy_arg_struct(arg_struct* p) {
20  arg_pair* pp0;
21  arg_pair* pp1;
22  if(p==NULL) {
23    return 0;
24  }
25
26  pp0=p->data;
27  while(pp0!=NULL) {
28    pp1=pp0->next;
29    if(pp0->sk!=NULL) { free(pp0->sk); }
30    if(pp0->dk!=NULL) { free(pp0->dk); }
31    if(pp0->v!=NULL)  { free(pp0->v);  }
32    free(pp0);
33    pp0=pp1;
34  }
35
36  free(p);
37  return 0;
38}
39
40static int add_v(arg_struct* p, char* p0, char* p1) {
41  int len;
42  arg_pair* pnode;
43  char* sdata;
44  arg_pair* pnode_old;
45  if(p==NULL || p0==NULL || p1==NULL) {
46    return -1;
47  }
48
49  if(p1<p0) {
50    return -1;
51  }
52
53  len=p1-p0+1;
54
55  pnode=(arg_pair*)malloc(sizeof(arg_pair));
56  if(pnode==NULL) {
57    return -1;
58  }
59  else {
60    memset(pnode, 0, sizeof(arg_pair));
61  }
62
63  sdata=(char*)malloc(sizeof(char)*(len+1));
64  if(sdata==NULL) {
65    free(pnode);
66    return -1;
67  }
68  else {
69    memset(sdata, 0, sizeof(char)*(len+1));
70  }
71
72  pnode_old=p->data;
73  if(pnode_old==NULL) {
74    p->data=pnode;
75  }
76  else {
77    while(pnode_old->next!=NULL) {
78      pnode_old=pnode_old->next;
79    }
80    pnode_old->next=pnode;
81  }
82
83  memcpy(sdata, p0, len);
84  pnode->v=sdata;
85
86  if(g_arg_deg) {
87    printf("add_v, = %s\n", sdata);
88  }
89
90  return 0;
91}
92
93static int add_sk(arg_struct* p, char* p0, char* p1) {
94  int len;
95  arg_pair* pnode;
96  char* sdata;
97  arg_pair* pnode_old;
98  if(p==NULL || p0==NULL || p1==NULL) {
99    return -1;
100  }
101
102  if(p1<p0) {
103    return -1;
104  }
105
106  len=p1-p0+1;
107
108  pnode=(arg_pair*)malloc(sizeof(arg_pair));
109  if(pnode==NULL) {
110    return -1;
111  }
112  else {
113    memset(pnode, 0, sizeof(arg_pair));
114  }
115
116  sdata=(char*)malloc(sizeof(char)*(len+1));
117  if(sdata==NULL) {
118    free(pnode);
119    return -1;
120  }
121  else {
122    memset(sdata, 0, sizeof(char)*(len+1));
123  }
124
125  pnode_old=p->data;
126  if(pnode_old==NULL) {
127    p->data=pnode;
128  }
129  else {
130    while(pnode_old->next!=NULL) {
131      pnode_old=pnode_old->next;
132    }
133    pnode_old->next=pnode;
134  }
135
136  memcpy(sdata, p0, len);
137  pnode->sk=sdata;
138
139  if(g_arg_deg) {
140    printf("add_sk, = %s\n", sdata);
141  }
142
143  return 0;
144}
145
146static int append_sk_v(arg_struct* p, char* p0, char* p1) {
147  int len;
148  arg_pair* pnode;
149  char* sdata;
150  arg_pair* pnode_old;
151  if(p==NULL || p0==NULL || p1==NULL) {
152    return -1;
153  }
154
155  if(p1<p0) {
156    return -1;
157  }
158
159  len=p1-p0+1;
160
161  sdata=(char*)malloc(sizeof(char)*(len+1));
162  if(sdata==NULL) {
163    return -1;
164  }
165  else {
166    memset(sdata, 0, sizeof(char)*(len+1));
167  }
168
169  pnode=p->data;
170  if(pnode==NULL) {
171    free(sdata);
172    return -1;
173  }
174  else {
175    while(pnode->next!=NULL) {
176      pnode=pnode_old->next;
177    }
178  }
179
180  if(pnode->sk==NULL) {
181    free(sdata);
182    return -1;
183  }
184
185  memcpy(sdata, p0, len);
186  pnode->v=sdata;
187
188  if(g_arg_deg) {
189    printf("append_sk_v, = %s\n", sdata);
190  }
191
192  return 0;
193}
194
195static int add_dk(arg_struct* p, char* p0, char* p1) {
196  int len;
197  arg_pair* pnode;
198  char* sdata;
199  arg_pair* pnode_old;
200  if(p==NULL || p0==NULL || p1==NULL) {
201    return -1;
202  }
203
204  if(p1<p0) {
205    return -1;
206  }
207
208  len=p1-p0+1;
209
210  pnode=(arg_pair*)malloc(sizeof(arg_pair));
211  if(pnode==NULL) {
212    return -1;
213  }
214  else {
215    memset(pnode, 0, sizeof(arg_pair));
216  }
217
218  sdata=(char*)malloc(sizeof(char)*(len+1));
219  if(sdata==NULL) {
220    free(pnode);
221    return -1;
222  }
223  else {
224    memset(sdata, 0, sizeof(char)*(len+1));
225  }
226
227  pnode_old=p->data;
228  if(pnode_old==NULL) {
229    p->data=pnode;
230  }
231  else {
232    while(pnode_old->next!=NULL) {
233      pnode_old=pnode_old->next;
234    }
235    pnode_old->next=pnode;
236  }
237
238  memcpy(sdata, p0, len);
239  pnode->dk=sdata;
240
241  if(g_arg_deg) {
242    printf("add_dk, = %s\n", sdata);
243  }
244
245  return 0;
246}
247
248static int append_dk_v(arg_struct* p, char* p0, char* p1) {
249  int len;
250  arg_pair* pnode;
251  char* sdata;
252  arg_pair* pnode_old;
253  if(p==NULL || p0==NULL || p1==NULL) {
254    return -1;
255  }
256
257  if(p1<p0) {
258    return -1;
259  }
260
261  len=p1-p0+1;
262
263  sdata=(char*)malloc(sizeof(char)*(len+1));
264  if(sdata==NULL) {
265    return -1;
266  }
267  else {
268    memset(sdata, 0, sizeof(char)*(len+1));
269  }
270
271  pnode=p->data;
272  if(pnode==NULL) {
273    free(sdata);
274    return -1;
275  }
276  else {
277    while(pnode->next!=NULL) {
278      pnode=pnode_old->next;
279    }
280  }
281
282  if(pnode->dk==NULL) {
283    free(sdata);
284    return -1;
285  }
286
287  memcpy(sdata, p0, len);
288  pnode->v=sdata;
289
290  if(g_arg_deg) {
291    printf("append_dk_v, = %s\n", sdata);
292  }
293
294  return 0;
295}
296
297int dump_arg_struct(arg_struct* p) {
298  arg_pair* pp0;
299  arg_pair* pp1;
300
301  printf("==== start dump ====\n");
302  while(1) {
303    if(p==NULL || p->data==NULL) {
304      break;
305    }
306
307    pp0=p->data;
308    while(pp0!=NULL) {
309      pp1=pp0->next;
310      printf("[ ");
311      if(pp0->sk!=NULL) {
312        printf("\"%s\", ", pp0->sk);
313      }
314      else {
315        printf("NULL, ");
316      }
317
318      if(pp0->dk!=NULL) {
319        printf("\"%s\", ", pp0->dk);
320      }
321      else {
322        printf("NULL, ");
323      }
324
325      if(pp0->v!=NULL) {
326        printf("\"%s\" ]\n", pp0->v);
327      }
328      else {
329        printf("NULL ]\n");
330      }
331      pp0=pp1;
332    }
333
334    break;
335  }
336
337  printf("==== end   dump ====\n");
338
339  return 0;
340}
341
342/* Description:
343 *   it parse the argument with one line
344 */
345arg_struct* parse_argument_single(char* arg_line) {
346  int state=0;
347  char* p=NULL;
348  char* p0;
349  char* p1;
350  arg_struct* ret=NULL;
351
352  if(arg_line==0 || arg_line[0]=='\0') {
353    return 0;
354  }
355
356  ret=(arg_struct*)malloc(sizeof(arg_struct));
357  if(ret==NULL) {
358    return NULL;
359  }
360  else {
361    ret->data=NULL;
362  }
363
364  p=arg_line;
365  while((*p)!='\0') {
366    switch(state) {
367    case 0:                            // has got "", one pair is done
368      {
369        if((*p)=='-') {                // has got "-"
370          state=100;
371        }
372        else if((*p)==' ' || (*p)=='\t') { // has got " "
373          state=0;
374        }
375        else {                         // has got "a"
376          state=300;
377          p0=p;
378        }
379      }
380      break;
381
382    case 100:                          // has got "-"
383      {
384        if((*p)=='-') {                // has got "--"
385          state=200;
386        }
387        else if((*p)==' ' || (*p)=='\t') { // has got "- ", ignore it, but it's illegal
388
389        }
390        else {                         // has got "-a"
391          state=101;
392          p0=p;
393        }
394
395      }
396      break;
397
398    case 101:
399      {
400        if((*p)==' ' || (*p)=='\t') {  // has got "-a "
401          p1=p-1;
402          add_sk(ret, p0, p1);
403          state=110;
404        }
405        else {                         // has got "-ab", do nothing
406        }
407      }
408      break;
409
410    case 110:                          // has got "-a "
411      {
412        if((*p)==' ' || (*p)=='\t') {  // nothing to do
413        }
414        else if((*p)=='-') {           // has end last pair
415          state=100;
416        }
417        else {                         // process the value
418          state=111;
419          p0=p;
420        }
421      }
422      break;
423
424    case 111:                          // has got "-t a"
425      {
426        if((*p)==' ' || (*p)=='\t') {  // has got "-t a "
427          p1=p-1;
428          state=0;
429          append_sk_v(ret, p0, p1);
430        }
431        else {                         // has got "-t ab", do nothing
432        }
433      }
434      break;
435
436    case 200:                          // has got "--"
437      {
438        if((*p)=='-') {                // has got "---", illegal and ignored
439          state=0;
440        }
441        else if((*p)==' ' || (*p)=='\t') {   // has got "-- ", illegal and ignore
442          state=0;
443        }
444        else {                         // has got "--a"
445          p0=p;
446          state=201;
447        }
448      }
449      break;
450
451    case 201:                          // has got "--a"
452      {
453        if((*p)==' ' || (*p)=='\t') {  // has got "--abc "
454          state=210;
455          p1=p-1;
456          add_dk(ret, p0, p1);
457        }
458        else {                         // has got "--abcd"
459
460        }
461      }
462      break;
463
464    case 210:                          // has got "--abc "
465      {
466        if((*p)==' ' || (*p)=='\t') {  // has got "--abc  "
467
468        }
469        else if((*p)=='-') {           // has got "--abc -", end of the pair
470          state=100;
471        }
472        else {                         // has got "--abc a"
473          p0=p;
474          state=211;
475        }
476      }
477      break;
478
479    case 211:                          // has got "--abc a"
480      {
481        if((*p)==' ' || (*p)=='\t') {  // has got "--abc a "
482          p1=p-1;
483          append_dk_v(ret, p0, p1);
484          state=0;
485        }
486        else {                         // has got "--abc ab"
487        }
488      }
489      break;
490
491    case 300:                          // has got "a"
492      {
493        if((*p)==' ' || (*p)=='\t') {    // has got "a "
494          p1=p-1;
495          add_v(ret, p0, p1);
496          state=0;
497        }
498        else {                         // has got "ab"
499        }
500
501      }
502      break;
503
504    default:
505      break;
506    }
507
508
509    p++;
510  }
511
512  p1=p-1;
513  switch(state) {
514    case 300:
515      {
516        add_v(ret, p0, p1);
517      }
518      break;
519
520    case 211:
521      {
522        append_dk_v(ret, p0, p1);
523      }
524      break;
525
526    case 201:
527      {
528        add_dk(ret, p0, p1);
529      }
530      break;
531
532    case 111:
533      {
534        append_sk_v(ret, p0, p1);
535      }
536      break;
537
538    case 101:
539      {
540        add_sk(ret, p0, p1);
541      }
542      break;
543
544    default:
545      break;
546  }
547
548  return ret;
549
550}
551
552int unit_test_1() {
553  arg_struct* r;
554  r=parse_argument_single("-t");
555  dump_arg_struct(r);       // [ "t", NULL, NULL ]  
556  destroy_arg_struct(r);
557  printf("\n");
558
559
560  r=parse_argument_single("-t abc");
561  dump_arg_struct(r);      // [ "t", NULL, "abc" ]
562  destroy_arg_struct(r);
563  printf("\n");
564
565  r=parse_argument_single("-tt abc");
566  dump_arg_struct(r);      // [ "tt", NULL, "abc" ]
567  destroy_arg_struct(r);
568  printf("\n");
569
570  r=parse_argument_single("--abc");
571  dump_arg_struct(r);      // [ NULL, "abc", NULL ]
572  destroy_arg_struct(r);
573  printf("\n");
574
575  r=parse_argument_single("abc etf");
576  dump_arg_struct(r);      // [ NULL, NULL, "abc" ]
577                           // [ NULL, NULL, "etf" ]
578  destroy_arg_struct(r);
579  printf("\n");
580
581  r=parse_argument_single(" -t --time -g -a abc   etf -p ");
582  dump_arg_struct(r);      // [ "t", NULL, NULL ]
583                           // [ NULL, "time", NULL ]
584                           // [ "g", NULL, NULL ]
585                           // [ "a", NULL, "abc" ]
586                           // [ NULL, NULL, "etf" ]
587                           // [ "p", NULL, NULL ]
588  destroy_arg_struct(r);
589  printf("\n");
590
591  return 0;
592}
593
594arg_struct* parse_argument_list(int argc, char* argv[]) {
595  int i;
596  arg_struct* ret=NULL;
597
598  if(argc<1 || argv==NULL) {
599    return NULL;
600  }
601
602  ret=(arg_struct*)malloc(sizeof(arg_struct));
603  if(ret==NULL) {
604    return NULL;
605  }
606  else {
607    ret->data=NULL;
608  }
609  
610  for(i=0; i<argc; i++) {
611    if(argv[i][0]=='-' && argv[i][1]=='-') {
612    add_dk(ret, &argv[i][2], &(argv[i][strlen(argv[i])-1]));
613    if(i<(argc-1) && argv[i+1][0]!='-') {
614      i++;
615    append_dk_v(ret, &argv[i][0], &(argv[i][strlen(argv[i])-1]));
616    }
617  }
618  else if(argv[i][0]=='-') {
619    add_sk(ret, &argv[i][1], &(argv[i][strlen(argv[i])-1]));
620    if(i<(argc-1) && argv[i+1][0]!='-') {
621      i++;
622    append_sk_v(ret, &argv[i][0], &(argv[i][strlen(argv[i])-1]));
623    }
624  }
625  else {
626    add_v(ret, &argv[i][0], &(argv[i][strlen(argv[i])-1]));
627  }
628  }
629
630  return ret;
631}
632
633int unit_test_2(int argc, char* argv[]) {
634  arg_struct* r;
635  r=parse_argument_list(argc, argv);
636  dump_arg_struct(r);
637  destroy_arg_struct(r);
638  printf("\n");
639
640
641  return 0;
642}
643
644int main(int argc, char* argv[]) {
645  unit_test_2(argc-1, &(argv[1]));
646  return 0;
647}
648
649
650
651
#include <stdio.h>

#include <stdlib.h>

#include <string.h>



// 是否打印debug信息

static int g_arg_deg=1;



typedef struct arg_pair_t {

  char* sk;  // single key like -t      => t

  char* dk;  // double key like --help  => help

  char* v;   // the value

  struct arg_pair_t* next;

} arg_pair;



typedef struct arg_struct_t {

  arg_pair* data;

} arg_struct;



int destroy_arg_struct(arg_struct* p) {

  arg_pair* pp0;

  arg_pair* pp1;

  if(p==NULL) {

    return 0;

  }



  pp0=p->data;

  while(pp0!=NULL) {

    pp1=pp0->next;

    if(pp0->sk!=NULL) { free(pp0->sk); }

    if(pp0->dk!=NULL) { free(pp0->dk); }

    if(pp0->v!=NULL)  { free(pp0->v);  }

    free(pp0);

    pp0=pp1;

  }



  free(p);

  return 0;

}



static int add_v(arg_struct* p, char* p0, char* p1) {

  int len;

  arg_pair* pnode;

  char* sdata;

  arg_pair* pnode_old;

  if(p==NULL || p0==NULL || p1==NULL) {

    return -1;

  }



  if(p1<p0) {

    return -1;

  }



  len=p1-p0+1;



  pnode=(arg_pair*)malloc(sizeof(arg_pair));

  if(pnode==NULL) {

    return -1;

  }

  else {

    memset(pnode, 0, sizeof(arg_pair));

  }



  sdata=(char*)malloc(sizeof(char)*(len+1));

  if(sdata==NULL) {

    free(pnode);

    return -1;

  }

  else {

    memset(sdata, 0, sizeof(char)*(len+1));

  }



  pnode_old=p->data;

  if(pnode_old==NULL) {

    p->data=pnode;

  }

  else {

    while(pnode_old->next!=NULL) {

      pnode_old=pnode_old->next;

    }

    pnode_old->next=pnode;

  }



  memcpy(sdata, p0, len);

  pnode->v=sdata;



  if(g_arg_deg) {

    printf("add_v, = %s\n", sdata);

  }



  return 0;

}



static int add_sk(arg_struct* p, char* p0, char* p1) {

  int len;

  arg_pair* pnode;

  char* sdata;

  arg_pair* pnode_old;

  if(p==NULL || p0==NULL || p1==NULL) {

    return -1;

  }



  if(p1<p0) {

    return -1;

  }



  len=p1-p0+1;



  pnode=(arg_pair*)malloc(sizeof(arg_pair));

  if(pnode==NULL) {

    return -1;

  }

  else {

    memset(pnode, 0, sizeof(arg_pair));

  }



  sdata=(char*)malloc(sizeof(char)*(len+1));

  if(sdata==NULL) {

    free(pnode);

    return -1;

  }

  else {

    memset(sdata, 0, sizeof(char)*(len+1));

  }



  pnode_old=p->data;

  if(pnode_old==NULL) {

    p->data=pnode;

  }

  else {

    while(pnode_old->next!=NULL) {

      pnode_old=pnode_old->next;

    }

    pnode_old->next=pnode;

  }



  memcpy(sdata, p0, len);

  pnode->sk=sdata;



  if(g_arg_deg) {

    printf("add_sk, = %s\n", sdata);

  }



  return 0;

}



static int append_sk_v(arg_struct* p, char* p0, char* p1) {

  int len;

  arg_pair* pnode;

  char* sdata;

  arg_pair* pnode_old;

  if(p==NULL || p0==NULL || p1==NULL) {

    return -1;

  }



  if(p1<p0) {

    return -1;

  }



  len=p1-p0+1;



  sdata=(char*)malloc(sizeof(char)*(len+1));

  if(sdata==NULL) {

    return -1;

  }

  else {

    memset(sdata, 0, sizeof(char)*(len+1));

  }



  pnode=p->data;

  if(pnode==NULL) {

    free(sdata);

    return -1;

  }

  else {

    while(pnode->next!=NULL) {

      pnode=pnode_old->next;

    }

  }



  if(pnode->sk==NULL) {

    free(sdata);

    return -1;

  }



  memcpy(sdata, p0, len);

  pnode->v=sdata;



  if(g_arg_deg) {

    printf("append_sk_v, = %s\n", sdata);

  }



  return 0;

}



static int add_dk(arg_struct* p, char* p0, char* p1) {

  int len;

  arg_pair* pnode;

  char* sdata;

  arg_pair* pnode_old;

  if(p==NULL || p0==NULL || p1==NULL) {

    return -1;

  }



  if(p1<p0) {

    return -1;

  }



  len=p1-p0+1;



  pnode=(arg_pair*)malloc(sizeof(arg_pair));

  if(pnode==NULL) {

    return -1;

  }

  else {

    memset(pnode, 0, sizeof(arg_pair));

  }



  sdata=(char*)malloc(sizeof(char)*(len+1));

  if(sdata==NULL) {

    free(pnode);

    return -1;

  }

  else {

    memset(sdata, 0, sizeof(char)*(len+1));

  }



  pnode_old=p->data;

  if(pnode_old==NULL) {

    p->data=pnode;

  }

  else {

    while(pnode_old->next!=NULL) {

      pnode_old=pnode_old->next;

    }

    pnode_old->next=pnode;

  }



  memcpy(sdata, p0, len);

  pnode->dk=sdata;



  if(g_arg_deg) {

    printf("add_dk, = %s\n", sdata);

  }



  return 0;

}



static int append_dk_v(arg_struct* p, char* p0, char* p1) {

  int len;

  arg_pair* pnode;

  char* sdata;

  arg_pair* pnode_old;

  if(p==NULL || p0==NULL || p1==NULL) {

    return -1;

  }



  if(p1<p0) {

    return -1;

  }



  len=p1-p0+1;



  sdata=(char*)malloc(sizeof(char)*(len+1));

  if(sdata==NULL) {

    return -1;

  }

  else {

    memset(sdata, 0, sizeof(char)*(len+1));

  }



  pnode=p->data;

  if(pnode==NULL) {

    free(sdata);

    return -1;

  }

  else {

    while(pnode->next!=NULL) {

      pnode=pnode_old->next;

    }

  }



  if(pnode->dk==NULL) {

    free(sdata);

    return -1;

  }



  memcpy(sdata, p0, len);

  pnode->v=sdata;



  if(g_arg_deg) {

    printf("append_dk_v, = %s\n", sdata);

  }



  return 0;

}



int dump_arg_struct(arg_struct* p) {

  arg_pair* pp0;

  arg_pair* pp1;



  printf("==== start dump ====\n");

  while(1) {

    if(p==NULL || p->data==NULL) {

      break;

    }



    pp0=p->data;

    while(pp0!=NULL) {

      pp1=pp0->next;

      printf("[ ");

      if(pp0->sk!=NULL) {

        printf("\"%s\", ", pp0->sk);

      }

      else {

        printf("NULL, ");

      }



      if(pp0->dk!=NULL) {

        printf("\"%s\", ", pp0->dk);

      }

      else {

        printf("NULL, ");

      }



      if(pp0->v!=NULL) {

        printf("\"%s\" ]\n", pp0->v);

      }

      else {

        printf("NULL ]\n");

      }

      pp0=pp1;

    }



    break;

  }



  printf("==== end   dump ====\n");



  return 0;

}



/* Description:

 *   it parse the argument with one line

 */

arg_struct* parse_argument_single(char* arg_line) {

  int state=0;

  char* p=NULL;

  char* p0;

  char* p1;

  arg_struct* ret=NULL;



  if(arg_line==0 || arg_line[0]=='\0') {

    return 0;

  }



  ret=(arg_struct*)malloc(sizeof(arg_struct));

  if(ret==NULL) {

    return NULL;

  }

  else {

    ret->data=NULL;

  }



  p=arg_line;

  while((*p)!='\0') {

    switch(state) {

    case 0:                            // has got "", one pair is done

      {

        if((*p)=='-') {                // has got "-"

          state=100;

        }

        else if((*p)==' ' || (*p)=='\t') { // has got " "

          state=0;

        }

        else {                         // has got "a"

          state=300;

          p0=p;

        }

      }

      break;



    case 100:                          // has got "-"

      {

        if((*p)=='-') {                // has got "--"

          state=200;

        }

        else if((*p)==' ' || (*p)=='\t') { // has got "- ", ignore it, but it's illegal



        }

        else {                         // has got "-a"

          state=101;

          p0=p;

        }



      }

      break;



    case 101:

      {

        if((*p)==' ' || (*p)=='\t') {  // has got "-a "

          p1=p-1;

          add_sk(ret, p0, p1);

          state=110;

        }

        else {                         // has got "-ab", do nothing

        }

      }

      break;



    case 110:                          // has got "-a "

      {

        if((*p)==' ' || (*p)=='\t') {  // nothing to do

        }

        else if((*p)=='-') {           // has end last pair

          state=100;

        }

        else {                         // process the value

          state=111;

          p0=p;

        }

      }

      break;



    case 111:                          // has got "-t a"

      {

        if((*p)==' ' || (*p)=='\t') {  // has got "-t a "

          p1=p-1;

          state=0;

          append_sk_v(ret, p0, p1);

        }

        else {                         // has got "-t ab", do nothing

        }

      }

      break;



    case 200:                          // has got "--"

      {

        if((*p)=='-') {                // has got "---", illegal and ignored

          state=0;

        }

        else if((*p)==' ' || (*p)=='\t') {   // has got "-- ", illegal and ignore

          state=0;

        }

        else {                         // has got "--a"

          p0=p;

          state=201;

        }

      }

      break;



    case 201:                          // has got "--a"

      {

        if((*p)==' ' || (*p)=='\t') {  // has got "--abc "

          state=210;

          p1=p-1;

          add_dk(ret, p0, p1);

        }

        else {                         // has got "--abcd"



        }

      }

      break;



    case 210:                          // has got "--abc "

      {

        if((*p)==' ' || (*p)=='\t') {  // has got "--abc  "



        }

        else if((*p)=='-') {           // has got "--abc -", end of the pair

          state=100;

        }

        else {                         // has got "--abc a"

          p0=p;

          state=211;

        }

      }

      break;



    case 211:                          // has got "--abc a"

      {

        if((*p)==' ' || (*p)=='\t') {  // has got "--abc a "

          p1=p-1;

          append_dk_v(ret, p0, p1);

          state=0;

        }

        else {                         // has got "--abc ab"

        }

      }

      break;



    case 300:                          // has got "a"

      {

        if((*p)==' ' || (*p)=='\t') {    // has got "a "

          p1=p-1;

          add_v(ret, p0, p1);

          state=0;

        }

        else {                         // has got "ab"

        }



      }

      break;



    default:

      break;

    }





    p++;

  }



  p1=p-1;

  switch(state) {

    case 300:

      {

        add_v(ret, p0, p1);

      }

      break;



    case 211:

      {

        append_dk_v(ret, p0, p1);

      }

      break;



    case 201:

      {

        add_dk(ret, p0, p1);

      }

      break;



    case 111:

      {

        append_sk_v(ret, p0, p1);

      }

      break;



    case 101:

      {

        add_sk(ret, p0, p1);

      }

      break;



    default:

      break;

  }



  return ret;



}



int unit_test_1() {

  arg_struct* r;

  r=parse_argument_single("-t");

  dump_arg_struct(r);       // [ "t", NULL, NULL ]  

  destroy_arg_struct(r);

  printf("\n");





  r=parse_argument_single("-t abc");

  dump_arg_struct(r);      // [ "t", NULL, "abc" ]

  destroy_arg_struct(r);

  printf("\n");



  r=parse_argument_single("-tt abc");

  dump_arg_struct(r);      // [ "tt", NULL, "abc" ]

  destroy_arg_struct(r);

  printf("\n");



  r=parse_argument_single("--abc");

  dump_arg_struct(r);      // [ NULL, "abc", NULL ]

  destroy_arg_struct(r);

  printf("\n");



  r=parse_argument_single("abc etf");

  dump_arg_struct(r);      // [ NULL, NULL, "abc" ]

                           // [ NULL, NULL, "etf" ]

  destroy_arg_struct(r);

  printf("\n");



  r=parse_argument_single(" -t --time -g -a abc   etf -p ");

  dump_arg_struct(r);      // [ "t", NULL, NULL ]

                           // [ NULL, "time", NULL ]

                           // [ "g", NULL, NULL ]

                           // [ "a", NULL, "abc" ]

                           // [ NULL, NULL, "etf" ]

                           // [ "p", NULL, NULL ]

  destroy_arg_struct(r);

  printf("\n");



  return 0;

}



arg_struct* parse_argument_list(int argc, char* argv[]) {

  int i;

  arg_struct* ret=NULL;



  if(argc<1 || argv==NULL) {

    return NULL;

  }



  ret=(arg_struct*)malloc(sizeof(arg_struct));

  if(ret==NULL) {

    return NULL;

  }

  else {

    ret->data=NULL;

  }

  

  for(i=0; i<argc; i++) {

    if(argv[i][0]=='-' && argv[i][1]=='-') {

	  add_dk(ret, &argv[i][2], &(argv[i][strlen(argv[i])-1]));

	  if(i<(argc-1) && argv[i+1][0]!='-') {

	    i++;

		append_dk_v(ret, &argv[i][0], &(argv[i][strlen(argv[i])-1]));

	  }

	}

	else if(argv[i][0]=='-') {

	  add_sk(ret, &argv[i][1], &(argv[i][strlen(argv[i])-1]));

	  if(i<(argc-1) && argv[i+1][0]!='-') {

	    i++;

		append_sk_v(ret, &argv[i][0], &(argv[i][strlen(argv[i])-1]));

	  }

	}

	else {

	  add_v(ret, &argv[i][0], &(argv[i][strlen(argv[i])-1]));

	}

  }



  return ret;

}



int unit_test_2(int argc, char* argv[]) {

  arg_struct* r;

  r=parse_argument_list(argc, argv);

  dump_arg_struct(r);

  destroy_arg_struct(r);

  printf("\n");





  return 0;

}



int main(int argc, char* argv[]) {

  unit_test_2(argc-1, &(argv[1]));

  return 0;

}








运行结果

$ ./a.exe -t
[ "t", NULL, NULL ]

$ ./a.exe -t -tt
[ "t", NULL, NULL ]
[ "tt", NULL, NULL ]

$ ./a.exe -t -tt abc
[ "t", NULL, NULL ]
[ "tt", NULL, "abc" ]

$ ./a.exe -t -tt abc def
[ "t", NULL, NULL ]
[ "tt", NULL, "abc" ]
[ NULL, NULL, "def" ]

基础函数