← Back to branch summary

~ubuntu-branches/ubuntu/hardy/gengetopt/hardy

« back to all changes in this revision

Viewing changes to tests/test_groups_cmd.c.test

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2008-01-29 14:55:40 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20080129145540-bkah1bl330gpelmh
Tags: 2.22-1ubuntu1
* Merge with Debian; remaining changes:
  - Fix build failures with g++-4.3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_groups_cmd.c.test
42
42
    0
43
43
};
44
44
 
 
45
typedef enum {ARG_NO
 
46
  , ARG_STRING
 
47
} test_groups_cmd_parser_arg_type;
 
48
 
45
49
static
46
50
void clear_given (struct gengetopt_args_info *args_info);
47
51
static
54
58
static int
55
59
test_groups_cmd_parser_required2 (struct gengetopt_args_info *args_info, const char *prog_name, const char *additional_error);
56
60
 
57
 
struct string_list
58
 
{
59
 
  char * arg;
60
 
  char *orig;
61
 
  struct string_list * next;
62
 
};
63
 
 
64
61
static char *
65
62
gengetopt_strdup (const char *s);
66
63
 
92
89
static
93
90
void init_args_info(struct gengetopt_args_info *args_info)
94
91
{
 
92
 
 
93
 
95
94
  args_info->help_help = gengetopt_args_info_help[0] ;
96
95
  args_info->version_help = gengetopt_args_info_help[1] ;
97
 
  args_info->opta_help = gengetopt_args_info_help[3] ;
 
96
  args_info->opta_help = gengetopt_args_info_help[4] ;
98
97
  args_info->opta_min = -1;
99
98
  args_info->opta_max = -1;
100
 
  args_info->optA_help = gengetopt_args_info_help[4] ;
101
 
  args_info->optAmul_help = gengetopt_args_info_help[5] ;
 
99
  args_info->optA_help = gengetopt_args_info_help[5] ;
 
100
  args_info->optAmul_help = gengetopt_args_info_help[6] ;
102
101
  args_info->optAmul_min = -1;
103
102
  args_info->optAmul_max = -1;
104
 
  args_info->optb_help = gengetopt_args_info_help[6] ;
105
 
  args_info->optc_help = gengetopt_args_info_help[7] ;
106
 
  args_info->optd_help = gengetopt_args_info_help[8] ;
 
103
  args_info->optb_help = gengetopt_args_info_help[7] ;
 
104
  args_info->optc_help = gengetopt_args_info_help[9] ;
 
105
  args_info->optd_help = gengetopt_args_info_help[10] ;
107
106
  
108
107
}
109
108
 
113
112
  printf ("%s %s\n", TEST_GROUPS_CMD_PARSER_PACKAGE, TEST_GROUPS_CMD_PARSER_VERSION);
114
113
}
115
114
 
116
 
void
117
 
test_groups_cmd_parser_print_help (void)
118
 
{
119
 
  int i = 0;
 
115
static void print_help_common(void) {
120
116
  test_groups_cmd_parser_print_version ();
121
117
 
122
118
  if (strlen(gengetopt_args_info_purpose) > 0)
123
119
    printf("\n%s\n", gengetopt_args_info_purpose);
124
120
 
125
 
  printf("\n%s\n\n", gengetopt_args_info_usage);
 
121
  if (strlen(gengetopt_args_info_usage) > 0)
 
122
    printf("\n%s\n", gengetopt_args_info_usage);
 
123
 
 
124
  printf("\n");
126
125
 
127
126
  if (strlen(gengetopt_args_info_description) > 0)
128
127
    printf("%s\n", gengetopt_args_info_description);
 
128
}
129
129
 
 
130
void
 
131
test_groups_cmd_parser_print_help (void)
 
132
{
 
133
  int i = 0;
 
134
  print_help_common();
130
135
  while (gengetopt_args_info_help[i])
131
136
    printf("%s\n", gengetopt_args_info_help[i++]);
132
137
}
142
147
  args_info->inputs_num = 0;
143
148
}
144
149
 
145
 
struct test_groups_cmd_parser_params *
146
 
test_groups_cmd_parser_params_init()
 
150
void
 
151
test_groups_cmd_parser_params_init(struct test_groups_cmd_parser_params *params)
147
152
{
148
 
  struct test_groups_cmd_parser_params *params = 
149
 
    (struct test_groups_cmd_parser_params *)malloc(sizeof(struct test_groups_cmd_parser_params));
150
 
 
151
153
  if (params)
152
154
    { 
153
155
      params->override = 0;
154
 
      params->initialize = 0;
155
 
      params->check_required = 0;
 
156
      params->initialize = 1;
 
157
      params->check_required = 1;
156
158
      params->check_ambiguity = 0;
 
159
      params->print_errors = 1;
157
160
    }
158
 
    
 
161
}
 
162
 
 
163
struct test_groups_cmd_parser_params *
 
164
test_groups_cmd_parser_params_create(void)
 
165
{
 
166
  struct test_groups_cmd_parser_params *params = 
 
167
    (struct test_groups_cmd_parser_params *)malloc(sizeof(struct test_groups_cmd_parser_params));
 
168
  test_groups_cmd_parser_params_init(params);  
159
169
  return params;
160
170
}
161
171
 
162
172
static void
 
173
free_string_field (char **s)
 
174
{
 
175
  if (*s)
 
176
    {
 
177
      free (*s);
 
178
      *s = 0;
 
179
    }
 
180
}
 
181
 
 
182
/** @brief generic value variable */
 
183
union generic_value {
 
184
    char *string_arg;
 
185
};
 
186
 
 
187
/** @brief holds temporary values for multiple options */
 
188
struct generic_list
 
189
{
 
190
  union generic_value arg;
 
191
  char *orig;
 
192
  struct generic_list *next;
 
193
};
 
194
 
 
195
/**
 
196
 * @brief add a node at the head of the list 
 
197
 */
 
198
static void add_node(struct generic_list **list) {
 
199
  struct generic_list *new_node = (struct generic_list *) malloc (sizeof (struct generic_list));
 
200
  new_node->next = *list;
 
201
  *list = new_node;
 
202
  new_node->arg.string_arg = NULL;
 
203
  new_node->orig = NULL;
 
204
}
 
205
 
 
206
 
 
207
static void
 
208
free_multiple_string_field(unsigned int len, char ***arg, char ***orig)
 
209
{
 
210
  unsigned int i;
 
211
  if (*arg) {
 
212
    for (i = 0; i < len; ++i)
 
213
      {
 
214
        free_string_field(&((*arg)[i]));
 
215
        free_string_field(&((*orig)[i]));
 
216
      }
 
217
    free_string_field(&((*arg)[0])); /* free default string */
 
218
 
 
219
    free (*arg);
 
220
    *arg = 0;
 
221
    free (*orig);
 
222
    *orig = 0;
 
223
  }
 
224
}
 
225
 
 
226
static void
163
227
test_groups_cmd_parser_release (struct gengetopt_args_info *args_info)
164
228
{
165
 
  
166
229
  unsigned int i;
167
 
  if (args_info->optA_arg)
168
 
    {
169
 
      free (args_info->optA_arg); /* free previous argument */
170
 
      args_info->optA_arg = 0;
171
 
    }
172
 
  if (args_info->optA_orig)
173
 
    {
174
 
      free (args_info->optA_orig); /* free previous argument */
175
 
      args_info->optA_orig = 0;
176
 
    }
177
 
  if (args_info->optAmul_arg)
178
 
    {
179
 
      for (i = 0; i < args_info->optAmul_given; ++i)
180
 
        {
181
 
          if (args_info->optAmul_arg [i])
182
 
            {
183
 
              free (args_info->optAmul_arg [i]); /* free previous argument */
184
 
              args_info->optAmul_arg [i] = 0;
185
 
            }
186
 
          if (args_info->optAmul_orig [i])
187
 
            {
188
 
              free (args_info->optAmul_orig [i]); /* free previous argument */
189
 
              args_info->optAmul_orig [i] = 0;
190
 
            }
191
 
        }
192
 
      if (args_info->optAmul_arg [0])
193
 
        free (args_info->optAmul_arg [0]); /* free default string */
194
 
      free (args_info->optAmul_arg); /* free previous argument */
195
 
      args_info->optAmul_arg = 0;
196
 
      free (args_info->optAmul_orig); /* free previous argument */
197
 
      args_info->optAmul_orig = 0;
198
 
    }
 
230
  free_string_field (&(args_info->optA_arg));
 
231
  free_string_field (&(args_info->optA_orig));
 
232
  free_multiple_string_field (args_info->optAmul_given, &(args_info->optAmul_arg), &(args_info->optAmul_orig));
 
233
  
199
234
  
200
235
  for (i = 0; i < args_info->inputs_num; ++i)
201
236
    free (args_info->inputs [i]);
202
 
  
 
237
 
203
238
  if (args_info->inputs_num)
204
239
    free (args_info->inputs);
205
 
  
 
240
 
206
241
  clear_given (args_info);
207
242
}
208
243
 
 
244
 
 
245
static void
 
246
write_into_file(FILE *outfile, const char *opt, const char *arg, char *values[])
 
247
{
 
248
  if (arg) {
 
249
    fprintf(outfile, "%s=\"%s\"\n", opt, arg);
 
250
  } else {
 
251
    fprintf(outfile, "%s\n", opt);
 
252
  }
 
253
}
 
254
 
 
255
static void
 
256
write_multiple_into_file(FILE *outfile, int len, const char *opt, char **arg, char *values[])
 
257
{
 
258
  int i;
 
259
  
 
260
  for (i = 0; i < len; ++i)
 
261
    write_into_file(outfile, opt, (arg ? arg[i] : 0), values);
 
262
}
 
263
 
 
264
int
 
265
test_groups_cmd_parser_dump(FILE *outfile, struct gengetopt_args_info *args_info)
 
266
{
 
267
  int i = 0;
 
268
 
 
269
  if (!outfile)
 
270
    {
 
271
      fprintf (stderr, "%s: cannot dump options to stream\n", TEST_GROUPS_CMD_PARSER_PACKAGE);
 
272
      return EXIT_FAILURE;
 
273
    }
 
274
 
 
275
  if (args_info->help_given)
 
276
    write_into_file(outfile, "help", 0, 0 );
 
277
  if (args_info->version_given)
 
278
    write_into_file(outfile, "version", 0, 0 );
 
279
  write_multiple_into_file(outfile, args_info->opta_given, "opta", 0, 0);
 
280
  if (args_info->optA_given)
 
281
    write_into_file(outfile, "optA", args_info->optA_orig, 0);
 
282
  write_multiple_into_file(outfile, args_info->optAmul_given, "optAmul", args_info->optAmul_orig, 0);
 
283
  if (args_info->optb_given)
 
284
    write_into_file(outfile, "optb", 0, 0 );
 
285
  if (args_info->optc_given)
 
286
    write_into_file(outfile, "optc", 0, 0 );
 
287
  if (args_info->optd_given)
 
288
    write_into_file(outfile, "optd", 0, 0 );
 
289
  
 
290
 
 
291
  i = EXIT_SUCCESS;
 
292
  return i;
 
293
}
 
294
 
209
295
int
210
296
test_groups_cmd_parser_file_save(const char *filename, struct gengetopt_args_info *args_info)
211
297
{
220
306
      return EXIT_FAILURE;
221
307
    }
222
308
 
223
 
  if (args_info->help_given) {
224
 
    fprintf(outfile, "%s\n", "help");
225
 
  }
226
 
  if (args_info->version_given) {
227
 
    fprintf(outfile, "%s\n", "version");
228
 
  }
229
 
  for (i = 0; i < args_info->opta_given; ++i)
230
 
    {
231
 
      fprintf(outfile, "%s\n", "opta");
232
 
      
233
 
    }
234
 
  if (args_info->optA_given) {
235
 
    if (args_info->optA_orig) {
236
 
      fprintf(outfile, "%s=\"%s\"\n", "optA", args_info->optA_orig);
237
 
    } else {
238
 
      fprintf(outfile, "%s\n", "optA");
239
 
    }
240
 
  }
241
 
  if (args_info->optAmul_orig)
242
 
    {
243
 
      for (i = 0; i < args_info->optAmul_given; ++i)
244
 
        {
245
 
          if (args_info->optAmul_orig [i])
246
 
            {
247
 
              fprintf(outfile, "%s=\"%s\"\n", "optAmul", args_info->optAmul_orig [i]);
248
 
            }
249
 
        }
250
 
    }
251
 
  if (args_info->optb_given) {
252
 
    fprintf(outfile, "%s\n", "optb");
253
 
  }
254
 
  if (args_info->optc_given) {
255
 
    fprintf(outfile, "%s\n", "optc");
256
 
  }
257
 
  if (args_info->optd_given) {
258
 
    fprintf(outfile, "%s\n", "optd");
259
 
  }
260
 
  
 
309
  i = test_groups_cmd_parser_dump(outfile, args_info);
261
310
  fclose (outfile);
262
311
 
263
 
  i = EXIT_SUCCESS;
264
312
  return i;
265
313
}
266
314
 
270
318
  test_groups_cmd_parser_release (args_info);
271
319
}
272
320
 
273
 
 
274
 
/* gengetopt_strdup() */
275
 
/* strdup.c replacement of strdup, which is not standard */
 
321
/** @brief replacement of strdup, which is not standard */
276
322
char *
277
323
gengetopt_strdup (const char *s)
278
324
{
423
469
  return error;
424
470
}
425
471
static void
426
 
reset_group_grp1(struct gengetopt_args_info *args_info);
427
 
 
428
 
static void
429
472
reset_group_grp1(struct gengetopt_args_info *args_info)
430
473
{
431
 
  unsigned int i;
432
474
  if (! args_info->grp1_group_counter)
433
475
    return;
434
476
  
435
477
  args_info->opta_given = 0 ; args_info->opta_group = 0 ;
436
478
  args_info->optA_given = 0 ;
437
 
  if (args_info->optA_arg)
438
 
    {
439
 
      free (args_info->optA_arg); /* free previous argument */
440
 
      args_info->optA_arg = 0;
441
 
    }
442
 
  if (args_info->optA_orig)
443
 
    {
444
 
      free (args_info->optA_orig); /* free previous argument */
445
 
      args_info->optA_orig = 0;
446
 
    }
 
479
  free_string_field (&(args_info->optA_arg));
 
480
  free_string_field (&(args_info->optA_orig));
447
481
  args_info->optAmul_given = 0 ; args_info->optAmul_group = 0 ;
448
 
  if (args_info->optAmul_arg)
449
 
    {
450
 
      for (i = 0; i < args_info->optAmul_given; ++i)
451
 
        {
452
 
          if (args_info->optAmul_arg [i])
453
 
            {
454
 
              free (args_info->optAmul_arg [i]); /* free previous argument */
455
 
              args_info->optAmul_arg [i] = 0;
456
 
            }
457
 
          if (args_info->optAmul_orig [i])
458
 
            {
459
 
              free (args_info->optAmul_orig [i]); /* free previous argument */
460
 
              args_info->optAmul_orig [i] = 0;
461
 
            }
462
 
        }
463
 
      if (args_info->optAmul_arg [0])
464
 
        free (args_info->optAmul_arg [0]); /* free default string */
465
 
      free (args_info->optAmul_arg); /* free previous argument */
466
 
      args_info->optAmul_arg = 0;
467
 
      free (args_info->optAmul_orig); /* free previous argument */
468
 
      args_info->optAmul_orig = 0;
469
 
    }
 
482
  free_multiple_string_field (args_info->optAmul_given, &(args_info->optAmul_arg), &(args_info->optAmul_orig));
470
483
  args_info->optb_given = 0 ;
471
484
 
472
485
  args_info->grp1_group_counter = 0;
473
486
}
474
487
 
475
488
static void
476
 
reset_group_my_grp2(struct gengetopt_args_info *args_info);
477
 
 
478
 
static void
479
489
reset_group_my_grp2(struct gengetopt_args_info *args_info)
480
490
{
481
491
  if (! args_info->my_grp2_group_counter)
519
529
  params.initialize = initialize;
520
530
  params.check_required = check_required;
521
531
  params.check_ambiguity = 0;
 
532
  params.print_errors = 1;
522
533
 
523
534
  result = test_groups_cmd_parser_internal (argc, argv, args_info, &params, NULL);
524
535
 
572
583
  return error;
573
584
}
574
585
 
 
586
 
 
587
static char *package_name = 0;
 
588
 
 
589
/**
 
590
 * @brief updates an option
 
591
 * @param field the generic pointer to the field to update
 
592
 * @param orig_field the pointer to the orig field
 
593
 * @param field_given the pointer to the number of occurrence of this option
 
594
 * @param prev_given the pointer to the number of occurrence already seen
 
595
 * @param value the argument for this option (if null no arg was specified)
 
596
 * @param possible_values the possible values for this option (if specified)
 
597
 * @param default_value the default value (in case the option only accepts fixed values)
 
598
 * @param arg_type the type of this option
 
599
 * @param check_ambiguity @see test_groups_cmd_parser_params.check_ambiguity
 
600
 * @param override @see test_groups_cmd_parser_params.override
 
601
 * @param no_free whether to free a possible previous value
 
602
 * @param multiple_option whether this is a multiple option
 
603
 * @param long_opt the corresponding long option
 
604
 * @param short_opt the corresponding short option (or '-' if none)
 
605
 * @param additional_error possible further error specification
 
606
 */
 
607
static
 
608
int update_arg(void *field, char **orig_field,
 
609
               unsigned int *field_given, unsigned int *prev_given, 
 
610
               char *value, char *possible_values[], const char *default_value,
 
611
               test_groups_cmd_parser_arg_type arg_type,
 
612
               int check_ambiguity, int override,
 
613
               int no_free, int multiple_option,
 
614
               const char *long_opt, char short_opt,
 
615
               const char *additional_error)
 
616
{
 
617
  char *stop_char = 0;
 
618
  const char *val = value;
 
619
  int found;
 
620
  char **string_field;
 
621
 
 
622
  stop_char = 0;
 
623
  found = 0;
 
624
 
 
625
  if (!multiple_option && prev_given && (*prev_given || (check_ambiguity && *field_given)))
 
626
    {
 
627
      if (short_opt != '-')
 
628
        fprintf (stderr, "%s: `--%s' (`-%c') option given more than once%s\n", 
 
629
               package_name, long_opt, short_opt,
 
630
               (additional_error ? additional_error : ""));
 
631
      else
 
632
        fprintf (stderr, "%s: `--%s' option given more than once%s\n", 
 
633
               package_name, long_opt,
 
634
               (additional_error ? additional_error : ""));
 
635
      return 1; /* failure */
 
636
    }
 
637
 
 
638
    
 
639
  if (field_given && *field_given && ! override)
 
640
    return 0;
 
641
  if (prev_given)
 
642
    (*prev_given)++;
 
643
  if (field_given)
 
644
    (*field_given)++;
 
645
  if (possible_values)
 
646
    val = possible_values[found];
 
647
 
 
648
  switch(arg_type) {
 
649
  case ARG_STRING:
 
650
    if (val) {
 
651
      string_field = (char **)field;
 
652
      if (!no_free && *string_field)
 
653
        free (*string_field); /* free previous string */
 
654
      *string_field = gengetopt_strdup (val);
 
655
    }
 
656
    break;
 
657
  default:
 
658
    break;
 
659
  };
 
660
 
 
661
 
 
662
  /* store the original value */
 
663
  switch(arg_type) {
 
664
  case ARG_NO:
 
665
    break;
 
666
  default:
 
667
    if (value && orig_field) {
 
668
      if (no_free) {
 
669
        *orig_field = value;
 
670
      } else {
 
671
        if (*orig_field)
 
672
          free (*orig_field); /* free previous string */
 
673
        *orig_field = gengetopt_strdup (value);
 
674
      }
 
675
    }
 
676
  };
 
677
 
 
678
  return 0; /* OK */
 
679
}
 
680
 
 
681
/**
 
682
 * @brief store information about a multiple option in a temporary list
 
683
 * @param list where to (temporarily) store multiple options
 
684
 */
 
685
static
 
686
int update_multiple_arg_temp(struct generic_list **list,
 
687
               unsigned int *prev_given, const char *val,
 
688
               char *possible_values[], const char *default_value,
 
689
               test_groups_cmd_parser_arg_type arg_type,
 
690
               const char *long_opt, char short_opt,
 
691
               const char *additional_error)
 
692
{
 
693
  char *multi_token, *multi_next; /* store single arguments */
 
694
 
 
695
  if (arg_type == ARG_NO) {
 
696
    (*prev_given)++;
 
697
    return 0; /* OK */
 
698
  }
 
699
 
 
700
  multi_token = get_multiple_arg_token(val);
 
701
  multi_next = get_multiple_arg_token_next (val);
 
702
 
 
703
  while (1)
 
704
    {
 
705
      add_node (list);
 
706
      if (update_arg((void *)&((*list)->arg), &((*list)->orig), 0,
 
707
          prev_given, multi_token, possible_values, default_value, 
 
708
          arg_type, 0, 1, 1, 1, long_opt, short_opt, additional_error)) {
 
709
        if (multi_token) free(multi_token);
 
710
        return 1; /* failure */
 
711
      }
 
712
 
 
713
      if (multi_next)
 
714
        {
 
715
          multi_token = get_multiple_arg_token(multi_next);
 
716
          multi_next = get_multiple_arg_token_next (multi_next);
 
717
        }
 
718
      else
 
719
        break;
 
720
    }
 
721
 
 
722
  return 0; /* OK */
 
723
}
 
724
 
 
725
/**
 
726
 * @brief free the passed list (including possible string argument)
 
727
 */
 
728
static
 
729
void free_list(struct generic_list *list, short string_arg)
 
730
{
 
731
  if (list) {
 
732
    struct generic_list *tmp;
 
733
    while (list)
 
734
      {
 
735
        tmp = list;
 
736
        if (string_arg && list->arg.string_arg)
 
737
          free (list->arg.string_arg);
 
738
        if (list->orig)
 
739
          free (list->orig);
 
740
        list = list->next;
 
741
        free (tmp);
 
742
      }
 
743
  }
 
744
}
 
745
 
 
746
/**
 
747
 * @brief updates a multiple option starting from the passed list
 
748
 */
 
749
static
 
750
void update_multiple_arg(void *field, char ***orig_field,
 
751
               unsigned int field_given, unsigned int prev_given, union generic_value *default_value,
 
752
               test_groups_cmd_parser_arg_type arg_type,
 
753
               struct generic_list *list)
 
754
{
 
755
  int i;
 
756
  struct generic_list *tmp;
 
757
 
 
758
  if (prev_given && list) {
 
759
    *orig_field = (char **) realloc (*orig_field, (field_given + prev_given) * sizeof (char *));
 
760
 
 
761
    switch(arg_type) {
 
762
    case ARG_STRING:
 
763
      *((char ***)field) = (char **)realloc (*((char ***)field), (field_given + prev_given) * sizeof (char *)); break;
 
764
    default:
 
765
      break;
 
766
    };
 
767
    
 
768
    for (i = (prev_given - 1); i >= 0; --i)
 
769
      {
 
770
        tmp = list;
 
771
        
 
772
        switch(arg_type) {
 
773
        case ARG_STRING:
 
774
          (*((char ***)field))[i + field_given] = tmp->arg.string_arg; break;
 
775
        default:
 
776
          break;
 
777
        }        
 
778
        (*orig_field) [i + field_given] = list->orig;
 
779
        list = list->next;
 
780
        free (tmp);
 
781
      }
 
782
  } else { /* set the default value */
 
783
    if (default_value && ! field_given) {
 
784
      switch(arg_type) {
 
785
      case ARG_STRING:
 
786
        if (! *((char ***)field)) {
 
787
          *((char ***)field) = (char **)malloc (sizeof (char *));
 
788
          (*((char ***)field))[0] = gengetopt_strdup(default_value->string_arg);
 
789
        }
 
790
        break;
 
791
      default: break;
 
792
      }
 
793
      if (!(*orig_field)) {
 
794
        *orig_field = (char **) malloc (sizeof (char *));
 
795
        (*orig_field)[0] = NULL;
 
796
      }
 
797
    }
 
798
  }
 
799
}
 
800
 
575
801
int
576
802
test_groups_cmd_parser_internal (int argc, char * const *argv, struct gengetopt_args_info *args_info,
577
803
                        struct test_groups_cmd_parser_params *params, const char *additional_error)
578
804
{
579
805
  int c;        /* Character of the parsed option.  */
580
 
  char *multi_token, *multi_next; /* for multiple options */
581
 
 
582
 
  int i;        /* Counter */
583
 
 
584
 
  struct string_list * optAmul_list = NULL,* optAmul_new = NULL;
 
806
 
 
807
  struct generic_list * optAmul_list = NULL;
585
808
  int error = 0;
586
809
  struct gengetopt_args_info local_args_info;
587
810
  
590
813
  int check_required;
591
814
  int check_ambiguity;
592
815
  
 
816
  package_name = argv[0];
 
817
  
593
818
  override = params->override;
594
819
  initialize = params->initialize;
595
820
  check_required = params->check_required;
602
827
 
603
828
  optarg = 0;
604
829
  optind = 0;
605
 
  opterr = 1;
 
830
  opterr = params->print_errors;
606
831
  optopt = '?';
607
832
 
608
833
  while (1)
609
834
    {
610
835
      int option_index = 0;
611
 
      char *stop_char;
612
836
 
613
837
      static struct option long_options[] = {
614
838
        { "help",       0, NULL, 'h' },
622
846
        { NULL, 0, NULL, 0 }
623
847
      };
624
848
 
625
 
      stop_char = 0;
626
849
      c = getopt_long (argc, argv, "hVaA::M::bd", long_options, &option_index);
627
850
 
628
851
      if (c == -1) break;       /* Exit from `while (1)' loop.  */
640
863
          exit (EXIT_SUCCESS);
641
864
 
642
865
        case 'a':       /* string a.  */
 
866
        
643
867
          local_args_info.opta_given++;
644
 
        
645
868
          if (!args_info->opta_group)
646
869
            {
647
870
              args_info->opta_group = 1;
648
871
              args_info->grp1_group_counter += 1;
649
872
            }
 
873
        
650
874
          break;
651
 
 
652
875
        case 'A':       /* string A.  */
653
 
          if (local_args_info.optA_given || (check_ambiguity && args_info->optA_given))
654
 
            {
655
 
              fprintf (stderr, "%s: `--optA' (`-A') option given more than once%s\n", argv[0], (additional_error ? additional_error : ""));
656
 
              goto failure;
657
 
            }
658
 
          if (args_info->optA_given && ! override)
659
 
            continue;
660
 
          local_args_info.optA_given = 1;
661
 
          args_info->optA_given = 1;
 
876
        
662
877
          if (args_info->grp1_group_counter && override)
663
878
            reset_group_grp1 (args_info);
664
879
          args_info->grp1_group_counter += 1;
665
 
          if (optarg)
666
 
            {
667
 
              if (args_info->optA_arg)
668
 
                free (args_info->optA_arg); /* free previous string */
669
 
              args_info->optA_arg = gengetopt_strdup (optarg);
670
 
              if (args_info->optA_orig)
671
 
                free (args_info->optA_orig); /* free previous string */
672
 
              args_info->optA_orig = gengetopt_strdup (optarg);
673
 
            }
 
880
        
 
881
          if (update_arg( (void *)&(args_info->optA_arg), 
 
882
               &(args_info->optA_orig), &(args_info->optA_given),
 
883
              &(local_args_info.optA_given), optarg, 0, 0, ARG_STRING,
 
884
              check_ambiguity, override, 0, 0,
 
885
              "optA", 'A',
 
886
              additional_error))
 
887
            goto failure;
 
888
        
674
889
          break;
675
 
 
676
890
        case 'M':       /* string M.  */
677
 
          local_args_info.optAmul_given++;
678
 
        
679
 
          multi_token = get_multiple_arg_token(optarg);
680
 
          multi_next = get_multiple_arg_token_next (optarg);
681
 
        
682
 
          while (1)
683
 
            {
684
 
              optAmul_new = (struct string_list *) malloc (sizeof (struct string_list));
685
 
              optAmul_new->next = optAmul_list;
686
 
              optAmul_list = optAmul_new;
687
 
              optAmul_new->arg = gengetopt_strdup (NULL);
688
 
              optAmul_new->orig = NULL;
689
 
              if (multi_token)
690
 
                {
691
 
                  optAmul_new->arg = gengetopt_strdup (multi_token);
692
 
                  optAmul_new->orig = multi_token;
693
 
                }
694
 
        
695
 
              if (multi_next)
696
 
                {
697
 
                  multi_token = get_multiple_arg_token(multi_next);
698
 
                  multi_next = get_multiple_arg_token_next (multi_next);
699
 
                  local_args_info.optAmul_given++;
700
 
                }
701
 
              else
702
 
                break;
703
 
            }
 
891
        
 
892
          if (update_multiple_arg_temp(&optAmul_list, 
 
893
              &(local_args_info.optAmul_given), optarg, 0, 0, ARG_STRING,
 
894
              "optAmul", 'M',
 
895
              additional_error))
 
896
            goto failure;
704
897
          if (!args_info->optAmul_group)
705
898
            {
706
899
              args_info->optAmul_group = 1;
707
900
              args_info->grp1_group_counter += 1;
708
901
            }
 
902
        
709
903
          break;
710
 
 
711
904
        case 'b':       /* string b.  */
712
 
          if (local_args_info.optb_given || (check_ambiguity && args_info->optb_given))
713
 
            {
714
 
              fprintf (stderr, "%s: `--optb' (`-b') option given more than once%s\n", argv[0], (additional_error ? additional_error : ""));
715
 
              goto failure;
716
 
            }
717
 
          if (args_info->optb_given && ! override)
718
 
            continue;
719
 
          local_args_info.optb_given = 1;
720
 
          args_info->optb_given = 1;
 
905
        
721
906
          if (args_info->grp1_group_counter && override)
722
907
            reset_group_grp1 (args_info);
723
908
          args_info->grp1_group_counter += 1;
 
909
        
 
910
          if (update_arg( 0 , 
 
911
               0 , &(args_info->optb_given),
 
912
              &(local_args_info.optb_given), optarg, 0, 0, ARG_NO,
 
913
              check_ambiguity, override, 0, 0,
 
914
              "optb", 'b',
 
915
              additional_error))
 
916
            goto failure;
 
917
        
724
918
          break;
725
 
 
726
919
        case 'd':       /* string d.  */
727
 
          if (local_args_info.optd_given || (check_ambiguity && args_info->optd_given))
728
 
            {
729
 
              fprintf (stderr, "%s: `--optd' (`-d') option given more than once%s\n", argv[0], (additional_error ? additional_error : ""));
730
 
              goto failure;
731
 
            }
732
 
          if (args_info->optd_given && ! override)
733
 
            continue;
734
 
          local_args_info.optd_given = 1;
735
 
          args_info->optd_given = 1;
 
920
        
736
921
          if (args_info->my_grp2_group_counter && override)
737
922
            reset_group_my_grp2 (args_info);
738
923
          args_info->my_grp2_group_counter += 1;
 
924
        
 
925
          if (update_arg( 0 , 
 
926
               0 , &(args_info->optd_given),
 
927
              &(local_args_info.optd_given), optarg, 0, 0, ARG_NO,
 
928
              check_ambiguity, override, 0, 0,
 
929
              "optd", 'd',
 
930
              additional_error))
 
931
            goto failure;
 
932
        
739
933
          break;
740
934
 
741
 
 
742
935
        case 0: /* Long option with no short option */
743
936
          /* string c.  */
744
937
          if (strcmp (long_options[option_index].name, "optc") == 0)
745
938
          {
746
 
            if (local_args_info.optc_given || (check_ambiguity && args_info->optc_given))
747
 
              {
748
 
                fprintf (stderr, "%s: `--optc' option given more than once%s\n", argv[0], (additional_error ? additional_error : ""));
749
 
                goto failure;
750
 
              }
751
 
            if (args_info->optc_given && ! override)
752
 
              continue;
753
 
            local_args_info.optc_given = 1;
754
 
            args_info->optc_given = 1;
 
939
          
755
940
            if (args_info->my_grp2_group_counter && override)
756
941
              reset_group_my_grp2 (args_info);
757
942
            args_info->my_grp2_group_counter += 1;
758
 
            break;
 
943
          
 
944
            if (update_arg( 0 , 
 
945
                 0 , &(args_info->optc_given),
 
946
                &(local_args_info.optc_given), optarg, 0, 0, ARG_NO,
 
947
                check_ambiguity, override, 0, 0,
 
948
                "optc", '-',
 
949
                additional_error))
 
950
              goto failure;
 
951
          
759
952
          }
760
953
          
761
954
          break;
782
975
    }
783
976
  
784
977
 
785
 
  if (local_args_info.optAmul_given && optAmul_list)
786
 
    {
787
 
      struct string_list *tmp;
788
 
      args_info->optAmul_arg = (char * *) realloc (args_info->optAmul_arg, (args_info->optAmul_given + local_args_info.optAmul_given) * sizeof (char *));
789
 
      args_info->optAmul_orig = (char **) realloc (args_info->optAmul_orig, (args_info->optAmul_given + local_args_info.optAmul_given) * sizeof (char *));
790
 
      for (i = (local_args_info.optAmul_given - 1); i >= 0; --i)
791
 
        {
792
 
          tmp = optAmul_list;
793
 
          args_info->optAmul_arg [i + args_info->optAmul_given] = optAmul_list->arg;
794
 
          args_info->optAmul_orig [i + args_info->optAmul_given] = optAmul_list->orig;
795
 
          optAmul_list = optAmul_list->next;
796
 
          free (tmp);
797
 
        }
798
 
    }
799
 
  
 
978
  update_multiple_arg((void *)&(args_info->optAmul_arg),
 
979
    &(args_info->optAmul_orig), args_info->optAmul_given,
 
980
    local_args_info.optAmul_given, 0 , 
 
981
    ARG_STRING, optAmul_list);
800
982
 
801
983
  args_info->opta_given += local_args_info.opta_given;
802
984
  local_args_info.opta_given = 0;
840
1022
  return 0;
841
1023
 
842
1024
failure:
843
 
  if (optAmul_list)
844
 
    {
845
 
      struct string_list *tmp;
846
 
      while (optAmul_list)
847
 
        {
848
 
          tmp = optAmul_list;
849
 
          free (optAmul_list->arg);
850
 
          free (optAmul_list->orig);
851
 
          optAmul_list = optAmul_list->next;
852
 
          free (tmp);
853
 
        }
854
 
    }
 
1025
  free_list (optAmul_list, 1 );
855
1026
  
856
1027
  test_groups_cmd_parser_release (&local_args_info);
857
1028
  return (EXIT_FAILURE);