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

« back to all changes in this revision

Viewing changes to src/skels/c_source.cc

  • 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:
1
1
/*
2
2
 * File automatically generated by
3
 
 * gengen 1.1 by Lorenzo Bettini 
 
3
 * gengen 1.2 by Lorenzo Bettini 
4
4
 * http://www.gnu.org/software/gengen
5
5
 */
6
6
 
97
97
  stream << indent_str;
98
98
  stream << "const char *";
99
99
  generate_string (args_info, stream, indent + indent_str.length ());
100
 
  stream << "_usage = \"Usage:";
 
100
  stream << "_usage = \"Usage: ";
101
101
  if (no_package)
102
102
    {
103
 
      stream << " \" ";
 
103
      stream << "\" ";
104
104
      generate_string (package_var_name, stream, indent + indent_str.length ());
105
105
      stream << " \"";
106
106
    }
107
 
  stream << " ";
108
107
  generate_string (usage_string, stream, indent + indent_str.length ());
109
108
  stream << "\";";
110
109
  stream << "\n";
120
119
  stream << indent_str;
121
120
  stream << "\n";
122
121
  stream << indent_str;
123
 
  stream << "const char *";
124
 
  generate_string (args_info, stream, indent + indent_str.length ());
125
 
  stream << "_help[] = {";
126
 
  stream << "\n";
127
 
  stream << indent_str;
128
 
  indent = 2;
129
 
  stream << "  ";
130
 
  if (help_option_print.size () > 0)
131
 
    generate_string (help_option_print, stream, indent + indent_str.length ());
 
122
  if (( has_hidden || has_details ))
 
123
    {
 
124
      if (has_details)
 
125
        {
 
126
          stream << "const char *";
 
127
          generate_string (args_info, stream, indent + indent_str.length ());
 
128
          stream << "_detailed_help[] = {";
 
129
          stream << "\n";
 
130
          stream << indent_str;
 
131
          indent = 2;
 
132
          stream << "  ";
 
133
          if (detailed_help_option_print.size () > 0)
 
134
            generate_string (detailed_help_option_print, stream, indent + indent_str.length ());
 
135
          else
 
136
            generate_detailed_help_option_print (stream, indent + indent_str.length ());
 
137
          stream << "  0";
 
138
          indent = 0;
 
139
          stream << "\n";
 
140
          stream << indent_str;
 
141
          stream << "};";
 
142
          stream << "\n";
 
143
          stream << indent_str;
 
144
          if (has_hidden)
 
145
            {
 
146
              stream << "static void";
 
147
              stream << "\n";
 
148
              stream << indent_str;
 
149
              stream << "init_full_help_array(void)";
 
150
              stream << "\n";
 
151
              stream << indent_str;
 
152
              stream << "{";
 
153
              stream << "\n";
 
154
              stream << indent_str;
 
155
              indent = 2;
 
156
              stream << "  ";
 
157
              if (full_help_option_print.size () > 0)
 
158
                generate_string (full_help_option_print, stream, indent + indent_str.length ());
 
159
              else
 
160
                generate_full_help_option_print (stream, indent + indent_str.length ());
 
161
              indent = 0;
 
162
              stream << "\n";
 
163
              stream << indent_str;
 
164
              stream << "}";
 
165
              stream << "\n";
 
166
              stream << indent_str;
 
167
              stream << "\n";
 
168
              stream << indent_str;
 
169
              stream << "const char *";
 
170
              generate_string (args_info, stream, indent + indent_str.length ());
 
171
              stream << "_full_help[";
 
172
              generate_string (help_string_num, stream, indent + indent_str.length ());
 
173
              stream << "];";
 
174
              stream << "\n";
 
175
              stream << indent_str;
 
176
            }
 
177
        }
 
178
      else
 
179
        {
 
180
          if (has_hidden)
 
181
            {
 
182
              stream << "const char *";
 
183
              generate_string (args_info, stream, indent + indent_str.length ());
 
184
              stream << "_full_help[] = {";
 
185
              stream << "\n";
 
186
              stream << indent_str;
 
187
              indent = 2;
 
188
              stream << "  ";
 
189
              if (full_help_option_print.size () > 0)
 
190
                generate_string (full_help_option_print, stream, indent + indent_str.length ());
 
191
              else
 
192
                generate_full_help_option_print (stream, indent + indent_str.length ());
 
193
              stream << "  0";
 
194
              indent = 0;
 
195
              stream << "\n";
 
196
              stream << indent_str;
 
197
              stream << "};";
 
198
              stream << "\n";
 
199
              stream << indent_str;
 
200
            }
 
201
        }
 
202
      stream << "\n";
 
203
      stream << indent_str;
 
204
      stream << "static void";
 
205
      stream << "\n";
 
206
      stream << indent_str;
 
207
      stream << "init_help_array(void)";
 
208
      stream << "\n";
 
209
      stream << indent_str;
 
210
      stream << "{";
 
211
      stream << "\n";
 
212
      stream << indent_str;
 
213
      indent = 2;
 
214
      stream << "  ";
 
215
      if (help_option_print.size () > 0)
 
216
        generate_string (help_option_print, stream, indent + indent_str.length ());
 
217
      else
 
218
        generate_help_option_print (stream, indent + indent_str.length ());
 
219
      indent = 0;
 
220
      stream << "\n";
 
221
      stream << indent_str;
 
222
      stream << "}";
 
223
      stream << "\n";
 
224
      stream << indent_str;
 
225
      stream << "\n";
 
226
      stream << indent_str;
 
227
      stream << "const char *";
 
228
      generate_string (args_info, stream, indent + indent_str.length ());
 
229
      stream << "_help[";
 
230
      generate_string (help_string_num, stream, indent + indent_str.length ());
 
231
      stream << "];";
 
232
      stream << "\n";
 
233
      stream << indent_str;
 
234
    }
132
235
  else
133
 
    generate_help_option_print (stream, indent + indent_str.length ());
134
 
  stream << "  0";
135
 
  indent = 0;
136
 
  stream << "\n";
137
 
  stream << indent_str;
138
 
  stream << "};";
139
 
  stream << "\n";
140
 
  stream << indent_str;
141
 
  if (has_hidden)
142
236
    {
143
237
      stream << "const char *";
144
238
      generate_string (args_info, stream, indent + indent_str.length ());
145
 
      stream << "_full_help[] = {";
 
239
      stream << "_help[] = {";
146
240
      stream << "\n";
147
241
      stream << indent_str;
148
242
      indent = 2;
149
243
      stream << "  ";
150
 
      if (full_help_option_print.size () > 0)
151
 
        generate_string (full_help_option_print, stream, indent + indent_str.length ());
 
244
      if (help_option_print.size () > 0)
 
245
        generate_string (help_option_print, stream, indent + indent_str.length ());
152
246
      else
153
 
        generate_full_help_option_print (stream, indent + indent_str.length ());
 
247
        generate_help_option_print (stream, indent + indent_str.length ());
154
248
      stream << "  0";
155
249
      indent = 0;
156
250
      stream << "\n";
161
255
    }
162
256
  stream << "\n";
163
257
  stream << indent_str;
 
258
  stream << "typedef enum {ARG_NO";
 
259
  stream << "\n";
 
260
  stream << indent_str;
 
261
  if (has_arg_flag)
 
262
    {
 
263
      stream << "  , ARG_FLAG";
 
264
      stream << "\n";
 
265
      stream << indent_str;
 
266
    }
 
267
  if (has_arg_string)
 
268
    {
 
269
      stream << "  , ARG_STRING";
 
270
      stream << "\n";
 
271
      stream << indent_str;
 
272
    }
 
273
  if (has_arg_int)
 
274
    {
 
275
      stream << "  , ARG_INT";
 
276
      stream << "\n";
 
277
      stream << indent_str;
 
278
    }
 
279
  if (has_arg_short)
 
280
    {
 
281
      stream << "  , ARG_SHORT";
 
282
      stream << "\n";
 
283
      stream << indent_str;
 
284
    }
 
285
  if (has_arg_long)
 
286
    {
 
287
      stream << "  , ARG_LONG";
 
288
      stream << "\n";
 
289
      stream << indent_str;
 
290
    }
 
291
  if (has_arg_float)
 
292
    {
 
293
      stream << "  , ARG_FLOAT";
 
294
      stream << "\n";
 
295
      stream << indent_str;
 
296
    }
 
297
  if (has_arg_double)
 
298
    {
 
299
      stream << "  , ARG_DOUBLE";
 
300
      stream << "\n";
 
301
      stream << indent_str;
 
302
    }
 
303
  if (has_arg_longdouble)
 
304
    {
 
305
      stream << "  , ARG_LONGDOUBLE";
 
306
      stream << "\n";
 
307
      stream << indent_str;
 
308
    }
 
309
  if (has_arg_longlong)
 
310
    {
 
311
      stream << "  , ARG_LONGLONG";
 
312
      stream << "\n";
 
313
      stream << indent_str;
 
314
    }
 
315
  if (has_arg_enum)
 
316
    {
 
317
      stream << "  , ARG_ENUM";
 
318
      stream << "\n";
 
319
      stream << indent_str;
 
320
    }
 
321
  stream << "} ";
 
322
  generate_string (parser_name, stream, indent + indent_str.length ());
 
323
  stream << "_arg_type;";
 
324
  stream << "\n";
 
325
  stream << indent_str;
 
326
  stream << "\n";
 
327
  stream << indent_str;
164
328
  stream << "static";
165
329
  stream << "\n";
166
330
  stream << indent_str;
281
445
    }
282
446
  stream << "\n";
283
447
  stream << indent_str;
284
 
  if (struct_def.size () > 0)
285
 
    generate_string (struct_def, stream, indent + indent_str.length ());
286
 
  else
287
 
    generate_struct_def (stream, indent + indent_str.length ());
288
 
  stream << indent_str;
289
448
  if (option_values.size () > 0)
290
449
    generate_string (option_values, stream, indent + indent_str.length ());
291
450
  else
361
520
  stream << "{";
362
521
  stream << "\n";
363
522
  stream << indent_str;
 
523
  if (( has_hidden && has_details ))
 
524
    {
 
525
      stream << "  init_full_help_array(); ";
 
526
    }
 
527
  stream << "\n";
 
528
  stream << indent_str;
 
529
  if (( has_hidden || has_details ))
 
530
    {
 
531
      stream << "  init_help_array(); ";
 
532
    }
 
533
  stream << "\n";
 
534
  stream << indent_str;
364
535
  indent = 2;
365
536
  stream << "  ";
366
537
  if (init_args_info.size () > 0)
397
568
  stream << indent_str;
398
569
  stream << "\n";
399
570
  stream << indent_str;
400
 
  stream << "void";
401
 
  stream << "\n";
402
 
  stream << indent_str;
403
 
  generate_string (parser_name, stream, indent + indent_str.length ());
404
 
  stream << "_print_help (void)";
405
 
  stream << "\n";
406
 
  stream << indent_str;
407
 
  stream << "{";
408
 
  stream << "\n";
409
 
  stream << indent_str;
410
 
  stream << "  int i = 0;";
 
571
  stream << "static void print_help_common(void) {";
411
572
  stream << "\n";
412
573
  stream << indent_str;
413
574
  indent = 2;
431
592
  stream << indent_str;
432
593
  stream << "\n";
433
594
  stream << indent_str;
434
 
  stream << "  printf(\"\\n%s\\n\\n\", ";
 
595
  stream << "  if (strlen(";
 
596
  generate_string (args_info, stream, indent + indent_str.length ());
 
597
  stream << "_usage) > 0)";
 
598
  stream << "\n";
 
599
  stream << indent_str;
 
600
  stream << "    printf(\"\\n%s\\n\", ";
435
601
  generate_string (args_info, stream, indent + indent_str.length ());
436
602
  stream << "_usage);";
437
603
  stream << "\n";
438
604
  stream << indent_str;
439
605
  stream << "\n";
440
606
  stream << indent_str;
 
607
  stream << "  printf(\"\\n\");";
 
608
  stream << "\n";
 
609
  stream << indent_str;
 
610
  stream << "\n";
 
611
  stream << indent_str;
441
612
  stream << "  if (strlen(";
442
613
  generate_string (args_info, stream, indent + indent_str.length ());
443
614
  stream << "_description) > 0)";
448
619
  stream << "_description);";
449
620
  stream << "\n";
450
621
  stream << indent_str;
 
622
  stream << "}";
 
623
  stream << "\n";
 
624
  stream << indent_str;
 
625
  stream << "\n";
 
626
  stream << indent_str;
 
627
  stream << "void";
 
628
  stream << "\n";
 
629
  stream << indent_str;
 
630
  generate_string (parser_name, stream, indent + indent_str.length ());
 
631
  stream << "_print_help (void)";
 
632
  stream << "\n";
 
633
  stream << indent_str;
 
634
  stream << "{";
 
635
  stream << "\n";
 
636
  stream << indent_str;
 
637
  stream << "  int i = 0;";
 
638
  stream << "\n";
 
639
  stream << indent_str;
 
640
  stream << "  print_help_common();";
451
641
  stream << "\n";
452
642
  stream << indent_str;
453
643
  stream << "  while (";
480
670
      stream << "  int i = 0;";
481
671
      stream << "\n";
482
672
      stream << indent_str;
483
 
      indent = 2;
484
 
      stream << "  ";
485
 
      generate_string (parser_name, stream, indent + indent_str.length ());
486
 
      stream << "_print_version ();";
487
 
      indent = 0;
488
 
      stream << "\n";
489
 
      stream << indent_str;
490
 
      stream << "\n";
491
 
      stream << indent_str;
492
 
      stream << "  if (strlen(";
493
 
      generate_string (args_info, stream, indent + indent_str.length ());
494
 
      stream << "_purpose) > 0)";
495
 
      stream << "\n";
496
 
      stream << indent_str;
497
 
      stream << "    printf(\"\\n%s\\n\", ";
498
 
      generate_string (args_info, stream, indent + indent_str.length ());
499
 
      stream << "_purpose);";
500
 
      stream << "\n";
501
 
      stream << indent_str;
502
 
      stream << "\n";
503
 
      stream << indent_str;
504
 
      stream << "  printf(\"\\n%s\\n\\n\", ";
505
 
      generate_string (args_info, stream, indent + indent_str.length ());
506
 
      stream << "_usage);";
507
 
      stream << "\n";
508
 
      stream << indent_str;
509
 
      stream << "\n";
510
 
      stream << indent_str;
511
 
      stream << "  if (strlen(";
512
 
      generate_string (args_info, stream, indent + indent_str.length ());
513
 
      stream << "_description) > 0)";
514
 
      stream << "\n";
515
 
      stream << indent_str;
516
 
      stream << "    printf(\"%s\\n\", ";
517
 
      generate_string (args_info, stream, indent + indent_str.length ());
518
 
      stream << "_description);";
519
 
      stream << "\n";
520
 
      stream << indent_str;
 
673
      stream << "  print_help_common();";
521
674
      stream << "\n";
522
675
      stream << indent_str;
523
676
      stream << "  while (";
536
689
      stream << "\n";
537
690
      stream << indent_str;
538
691
    }
 
692
  if (has_details)
 
693
    {
 
694
      stream << "void";
 
695
      stream << "\n";
 
696
      stream << indent_str;
 
697
      generate_string (parser_name, stream, indent + indent_str.length ());
 
698
      stream << "_print_detailed_help (void)";
 
699
      stream << "\n";
 
700
      stream << indent_str;
 
701
      stream << "{";
 
702
      stream << "\n";
 
703
      stream << indent_str;
 
704
      stream << "  int i = 0;";
 
705
      stream << "\n";
 
706
      stream << indent_str;
 
707
      stream << "  print_help_common();";
 
708
      stream << "\n";
 
709
      stream << indent_str;
 
710
      stream << "  while (";
 
711
      generate_string (args_info, stream, indent + indent_str.length ());
 
712
      stream << "_detailed_help[i])";
 
713
      stream << "\n";
 
714
      stream << indent_str;
 
715
      stream << "    printf(\"%s\\n\", ";
 
716
      generate_string (args_info, stream, indent + indent_str.length ());
 
717
      stream << "_detailed_help[i++]);";
 
718
      stream << "\n";
 
719
      stream << indent_str;
 
720
      stream << "}";
 
721
      stream << "\n";
 
722
      stream << indent_str;
 
723
      stream << "\n";
 
724
      stream << indent_str;
 
725
    }
539
726
  stream << "void";
540
727
  stream << "\n";
541
728
  stream << indent_str;
573
760
  stream << indent_str;
574
761
  stream << "\n";
575
762
  stream << indent_str;
 
763
  stream << "void";
 
764
  stream << "\n";
 
765
  stream << indent_str;
 
766
  generate_string (parser_name, stream, indent + indent_str.length ());
 
767
  stream << "_params_init(struct ";
 
768
  generate_string (parser_name, stream, indent + indent_str.length ());
 
769
  stream << "_params *params)";
 
770
  stream << "\n";
 
771
  stream << indent_str;
 
772
  stream << "{";
 
773
  stream << "\n";
 
774
  stream << indent_str;
 
775
  stream << "  if (params)";
 
776
  stream << "\n";
 
777
  stream << indent_str;
 
778
  stream << "    { ";
 
779
  stream << "\n";
 
780
  stream << indent_str;
 
781
  stream << "      params->override = 0;";
 
782
  stream << "\n";
 
783
  stream << indent_str;
 
784
  stream << "      params->initialize = 1;";
 
785
  stream << "\n";
 
786
  stream << indent_str;
 
787
  stream << "      params->check_required = 1;";
 
788
  stream << "\n";
 
789
  stream << indent_str;
 
790
  stream << "      params->check_ambiguity = 0;";
 
791
  stream << "\n";
 
792
  stream << indent_str;
 
793
  stream << "      params->print_errors = 1;";
 
794
  stream << "\n";
 
795
  stream << indent_str;
 
796
  stream << "    }";
 
797
  stream << "\n";
 
798
  stream << indent_str;
 
799
  stream << "}";
 
800
  stream << "\n";
 
801
  stream << indent_str;
 
802
  stream << "\n";
 
803
  stream << indent_str;
576
804
  stream << "struct ";
577
805
  generate_string (parser_name, stream, indent + indent_str.length ());
578
806
  stream << "_params *";
579
807
  stream << "\n";
580
808
  stream << indent_str;
581
809
  generate_string (parser_name, stream, indent + indent_str.length ());
582
 
  stream << "_params_init()";
 
810
  stream << "_params_create(void)";
583
811
  stream << "\n";
584
812
  stream << indent_str;
585
813
  stream << "{";
597
825
  stream << "_params));";
598
826
  stream << "\n";
599
827
  stream << indent_str;
600
 
  stream << "\n";
601
 
  stream << indent_str;
602
 
  stream << "  if (params)";
603
 
  stream << "\n";
604
 
  stream << indent_str;
605
 
  stream << "    { ";
606
 
  stream << "\n";
607
 
  stream << indent_str;
608
 
  stream << "      params->override = 0;";
609
 
  stream << "\n";
610
 
  stream << indent_str;
611
 
  stream << "      params->initialize = 0;";
612
 
  stream << "\n";
613
 
  stream << indent_str;
614
 
  stream << "      params->check_required = 0;";
615
 
  stream << "\n";
616
 
  stream << indent_str;
617
 
  stream << "      params->check_ambiguity = 0;";
618
 
  stream << "\n";
619
 
  stream << indent_str;
620
 
  stream << "    }";
621
 
  stream << "\n";
622
 
  stream << indent_str;
623
 
  indent = 4;
624
 
  stream << "    ";
 
828
  indent = 2;
 
829
  stream << "  ";
 
830
  generate_string (parser_name, stream, indent + indent_str.length ());
 
831
  stream << "_params_init(params);  ";
625
832
  indent = 0;
626
833
  stream << "\n";
627
834
  stream << indent_str;
633
840
  stream << indent_str;
634
841
  stream << "\n";
635
842
  stream << indent_str;
 
843
  if (has_typed_options)
 
844
    {
 
845
      stream << "static void";
 
846
      stream << "\n";
 
847
      stream << indent_str;
 
848
      stream << "free_string_field (char **s)";
 
849
      stream << "\n";
 
850
      stream << indent_str;
 
851
      stream << "{";
 
852
      stream << "\n";
 
853
      stream << indent_str;
 
854
      stream << "  if (*s)";
 
855
      stream << "\n";
 
856
      stream << indent_str;
 
857
      stream << "    {";
 
858
      stream << "\n";
 
859
      stream << indent_str;
 
860
      stream << "      free (*s);";
 
861
      stream << "\n";
 
862
      stream << indent_str;
 
863
      stream << "      *s = 0;";
 
864
      stream << "\n";
 
865
      stream << indent_str;
 
866
      stream << "    }";
 
867
      stream << "\n";
 
868
      stream << indent_str;
 
869
      stream << "}";
 
870
      stream << "\n";
 
871
      stream << indent_str;
 
872
    }
 
873
  stream << "\n";
 
874
  stream << indent_str;
 
875
  if (multiple_token_functions)
 
876
    {
 
877
      stream << "/** ";
 
878
      stream << "@";
 
879
      stream << "brief generic value variable */";
 
880
      stream << "\n";
 
881
      stream << indent_str;
 
882
      stream << "union generic_value {";
 
883
      stream << "\n";
 
884
      stream << indent_str;
 
885
      if (( has_arg_int || has_arg_enum ))
 
886
        {
 
887
          stream << "    int int_arg;";
 
888
          stream << "\n";
 
889
          stream << indent_str;
 
890
        }
 
891
      if (has_arg_short)
 
892
        {
 
893
          stream << "    short short_arg;";
 
894
          stream << "\n";
 
895
          stream << indent_str;
 
896
        }
 
897
      if (has_arg_long)
 
898
        {
 
899
          stream << "    long long_arg;";
 
900
          stream << "\n";
 
901
          stream << indent_str;
 
902
        }
 
903
      if (has_arg_float)
 
904
        {
 
905
          stream << "    float float_arg;";
 
906
          stream << "\n";
 
907
          stream << indent_str;
 
908
        }
 
909
      if (has_arg_double)
 
910
        {
 
911
          stream << "    double double_arg;";
 
912
          stream << "\n";
 
913
          stream << indent_str;
 
914
        }
 
915
      if (has_arg_longdouble)
 
916
        {
 
917
          stream << "    long double longdouble_arg;";
 
918
          stream << "\n";
 
919
          stream << indent_str;
 
920
        }
 
921
      if (has_arg_longlong)
 
922
        {
 
923
          stream << "#ifdef HAVE_LONG_LONG";
 
924
          stream << "\n";
 
925
          stream << indent_str;
 
926
          stream << "    long long int longlong_arg;";
 
927
          stream << "\n";
 
928
          stream << indent_str;
 
929
          stream << "#else";
 
930
          stream << "\n";
 
931
          stream << indent_str;
 
932
          stream << "    long longlong_arg;";
 
933
          stream << "\n";
 
934
          stream << indent_str;
 
935
          stream << "#endif";
 
936
          stream << "\n";
 
937
          stream << indent_str;
 
938
        }
 
939
      stream << "    char *string_arg;";
 
940
      stream << "\n";
 
941
      stream << indent_str;
 
942
      stream << "};";
 
943
      stream << "\n";
 
944
      stream << indent_str;
 
945
      stream << "\n";
 
946
      stream << indent_str;
 
947
      stream << "/** ";
 
948
      stream << "@";
 
949
      stream << "brief holds temporary values for multiple options */";
 
950
      stream << "\n";
 
951
      stream << indent_str;
 
952
      stream << "struct generic_list";
 
953
      stream << "\n";
 
954
      stream << indent_str;
 
955
      stream << "{";
 
956
      stream << "\n";
 
957
      stream << indent_str;
 
958
      stream << "  union generic_value arg;";
 
959
      stream << "\n";
 
960
      stream << indent_str;
 
961
      stream << "  char *orig;";
 
962
      stream << "\n";
 
963
      stream << indent_str;
 
964
      stream << "  struct generic_list *next;";
 
965
      stream << "\n";
 
966
      stream << indent_str;
 
967
      stream << "};";
 
968
      stream << "\n";
 
969
      stream << indent_str;
 
970
      stream << "\n";
 
971
      stream << indent_str;
 
972
      stream << "/**";
 
973
      stream << "\n";
 
974
      stream << indent_str;
 
975
      stream << " * ";
 
976
      stream << "@";
 
977
      stream << "brief add a node at the head of the list ";
 
978
      stream << "\n";
 
979
      stream << indent_str;
 
980
      stream << " */";
 
981
      stream << "\n";
 
982
      stream << indent_str;
 
983
      stream << "static void add_node(struct generic_list **list) {";
 
984
      stream << "\n";
 
985
      stream << indent_str;
 
986
      stream << "  struct generic_list *new_node = (struct generic_list *) malloc (sizeof (struct generic_list));";
 
987
      stream << "\n";
 
988
      stream << indent_str;
 
989
      stream << "  new_node->next = *list;";
 
990
      stream << "\n";
 
991
      stream << indent_str;
 
992
      stream << "  *list = new_node;";
 
993
      stream << "\n";
 
994
      stream << indent_str;
 
995
      stream << "  new_node->arg.string_arg = NULL;";
 
996
      stream << "\n";
 
997
      stream << indent_str;
 
998
      stream << "  new_node->orig = NULL;";
 
999
      stream << "\n";
 
1000
      stream << indent_str;
 
1001
      stream << "}";
 
1002
      stream << "\n";
 
1003
      stream << indent_str;
 
1004
      stream << "\n";
 
1005
      stream << indent_str;
 
1006
      if (( ( ! multiple_options_all_string ) && multiple_token_functions ))
 
1007
        {
 
1008
          stream << "static void";
 
1009
          stream << "\n";
 
1010
          stream << indent_str;
 
1011
          stream << "free_multiple_field(unsigned int len, void **arg, char ***orig)";
 
1012
          stream << "\n";
 
1013
          stream << indent_str;
 
1014
          stream << "{";
 
1015
          stream << "\n";
 
1016
          stream << indent_str;
 
1017
          stream << "  unsigned int i;";
 
1018
          stream << "\n";
 
1019
          stream << indent_str;
 
1020
          stream << "  if (*arg) {";
 
1021
          stream << "\n";
 
1022
          stream << indent_str;
 
1023
          stream << "    for (i = 0; i < len; ++i)";
 
1024
          stream << "\n";
 
1025
          stream << indent_str;
 
1026
          stream << "      {";
 
1027
          stream << "\n";
 
1028
          stream << indent_str;
 
1029
          stream << "        free_string_field(&((*orig)[i]));";
 
1030
          stream << "\n";
 
1031
          stream << indent_str;
 
1032
          stream << "      }";
 
1033
          stream << "\n";
 
1034
          stream << indent_str;
 
1035
          stream << "\n";
 
1036
          stream << indent_str;
 
1037
          stream << "    free (*arg);";
 
1038
          stream << "\n";
 
1039
          stream << indent_str;
 
1040
          stream << "    *arg = 0;";
 
1041
          stream << "\n";
 
1042
          stream << indent_str;
 
1043
          stream << "    free (*orig);";
 
1044
          stream << "\n";
 
1045
          stream << indent_str;
 
1046
          stream << "    *orig = 0;";
 
1047
          stream << "\n";
 
1048
          stream << indent_str;
 
1049
          stream << "  }";
 
1050
          stream << "\n";
 
1051
          stream << indent_str;
 
1052
          stream << "}";
 
1053
          stream << "\n";
 
1054
          stream << indent_str;
 
1055
        }
 
1056
      stream << "\n";
 
1057
      stream << indent_str;
 
1058
      if (multiple_options_string)
 
1059
        {
 
1060
          stream << "static void";
 
1061
          stream << "\n";
 
1062
          stream << indent_str;
 
1063
          stream << "free_multiple_string_field(unsigned int len, char ***arg, char ***orig)";
 
1064
          stream << "\n";
 
1065
          stream << indent_str;
 
1066
          stream << "{";
 
1067
          stream << "\n";
 
1068
          stream << indent_str;
 
1069
          stream << "  unsigned int i;";
 
1070
          stream << "\n";
 
1071
          stream << indent_str;
 
1072
          stream << "  if (*arg) {";
 
1073
          stream << "\n";
 
1074
          stream << indent_str;
 
1075
          stream << "    for (i = 0; i < len; ++i)";
 
1076
          stream << "\n";
 
1077
          stream << indent_str;
 
1078
          stream << "      {";
 
1079
          stream << "\n";
 
1080
          stream << indent_str;
 
1081
          stream << "        free_string_field(&((*arg)[i]));";
 
1082
          stream << "\n";
 
1083
          stream << indent_str;
 
1084
          stream << "        free_string_field(&((*orig)[i]));";
 
1085
          stream << "\n";
 
1086
          stream << indent_str;
 
1087
          stream << "      }";
 
1088
          stream << "\n";
 
1089
          stream << indent_str;
 
1090
          stream << "    free_string_field(&((*arg)[0])); /* free default string */";
 
1091
          stream << "\n";
 
1092
          stream << indent_str;
 
1093
          stream << "\n";
 
1094
          stream << indent_str;
 
1095
          stream << "    free (*arg);";
 
1096
          stream << "\n";
 
1097
          stream << indent_str;
 
1098
          stream << "    *arg = 0;";
 
1099
          stream << "\n";
 
1100
          stream << indent_str;
 
1101
          stream << "    free (*orig);";
 
1102
          stream << "\n";
 
1103
          stream << indent_str;
 
1104
          stream << "    *orig = 0;";
 
1105
          stream << "\n";
 
1106
          stream << indent_str;
 
1107
          stream << "  }";
 
1108
          stream << "\n";
 
1109
          stream << indent_str;
 
1110
          stream << "}";
 
1111
          stream << "\n";
 
1112
          stream << indent_str;
 
1113
        }
 
1114
    }
 
1115
  stream << "\n";
 
1116
  stream << indent_str;
636
1117
  stream << "static void";
637
1118
  stream << "\n";
638
1119
  stream << indent_str;
645
1126
  stream << "{";
646
1127
  stream << "\n";
647
1128
  stream << indent_str;
 
1129
  if (handle_unamed)
 
1130
    {
 
1131
      stream << "  unsigned int i;";
 
1132
    }
 
1133
  stream << "\n";
 
1134
  stream << indent_str;
648
1135
  indent = 2;
649
1136
  stream << "  ";
650
1137
  if (free.size () > 0)
654
1141
  indent = 0;
655
1142
  stream << "\n";
656
1143
  stream << indent_str;
 
1144
  indent = 2;
 
1145
  stream << "  ";
 
1146
  indent = 0;
 
1147
  stream << "\n";
 
1148
  stream << indent_str;
 
1149
  if (handle_unamed)
 
1150
    {
 
1151
      stream << "  for (i = 0; i < args_info->inputs_num; ++i)";
 
1152
      stream << "\n";
 
1153
      stream << indent_str;
 
1154
      stream << "    free (args_info->inputs [i]);";
 
1155
      stream << "\n";
 
1156
      stream << indent_str;
 
1157
      stream << "\n";
 
1158
      stream << indent_str;
 
1159
      stream << "  if (args_info->inputs_num)";
 
1160
      stream << "\n";
 
1161
      stream << indent_str;
 
1162
      stream << "    free (args_info->inputs);";
 
1163
      stream << "\n";
 
1164
      stream << indent_str;
 
1165
    }
 
1166
  stream << "\n";
 
1167
  stream << indent_str;
657
1168
  stream << "  clear_given (args_info);";
658
1169
  stream << "\n";
659
1170
  stream << indent_str;
662
1173
  stream << indent_str;
663
1174
  stream << "\n";
664
1175
  stream << indent_str;
665
 
  stream << "int";
666
 
  stream << "\n";
667
 
  stream << indent_str;
668
 
  generate_string (parser_name, stream, indent + indent_str.length ());
669
 
  stream << "_file_save(const char *filename, struct ";
670
 
  generate_string (args_info, stream, indent + indent_str.length ());
671
 
  stream << " *args_info)";
672
 
  stream << "\n";
673
 
  stream << indent_str;
674
 
  stream << "{";
675
 
  stream << "\n";
676
 
  stream << indent_str;
677
 
  stream << "  FILE *outfile;";
678
 
  stream << "\n";
679
 
  stream << indent_str;
680
 
  stream << "  int i = 0;";
681
 
  stream << "\n";
682
 
  stream << indent_str;
683
 
  stream << "\n";
684
 
  stream << indent_str;
685
 
  stream << "  outfile = fopen(filename, \"w\");";
686
 
  stream << "\n";
687
 
  stream << indent_str;
688
 
  stream << "\n";
689
 
  stream << indent_str;
690
 
  stream << "  if (!outfile)";
691
 
  stream << "\n";
692
 
  stream << indent_str;
693
 
  stream << "    {";
694
 
  stream << "\n";
695
 
  stream << indent_str;
696
 
  stream << "      fprintf (stderr, \"%s: cannot open file for writing: %s\\n\", ";
697
 
  generate_string (package_var_name, stream, indent + indent_str.length ());
698
 
  stream << ", filename);";
699
 
  stream << "\n";
700
 
  stream << indent_str;
701
 
  stream << "      return EXIT_FAILURE;";
702
 
  stream << "\n";
703
 
  stream << indent_str;
704
 
  stream << "    }";
705
 
  stream << "\n";
706
 
  stream << indent_str;
707
 
  stream << "\n";
708
 
  stream << indent_str;
709
 
  indent = 2;
710
 
  stream << "  ";
711
 
  if (file_save_loop.size () > 0)
712
 
    generate_string (file_save_loop, stream, indent + indent_str.length ());
713
 
  else
714
 
    generate_file_save_loop (stream, indent + indent_str.length ());
715
 
  indent = 0;
716
 
  stream << "\n";
717
 
  stream << indent_str;
718
 
  stream << "  fclose (outfile);";
719
 
  stream << "\n";
720
 
  stream << indent_str;
721
 
  stream << "\n";
722
 
  stream << indent_str;
723
 
  stream << "  i = EXIT_SUCCESS;";
724
 
  stream << "\n";
725
 
  stream << indent_str;
726
 
  stream << "  return i;";
727
 
  stream << "\n";
728
 
  stream << indent_str;
729
 
  stream << "}";
730
 
  stream << "\n";
731
 
  stream << indent_str;
732
 
  stream << "\n";
733
 
  stream << indent_str;
734
 
  stream << "void";
735
 
  stream << "\n";
736
 
  stream << indent_str;
737
 
  generate_string (parser_name, stream, indent + indent_str.length ());
738
 
  stream << "_free (struct ";
739
 
  generate_string (args_info, stream, indent + indent_str.length ());
740
 
  stream << " *args_info)";
741
 
  stream << "\n";
742
 
  stream << indent_str;
743
 
  stream << "{";
744
 
  stream << "\n";
745
 
  stream << indent_str;
746
 
  indent = 2;
747
 
  stream << "  ";
748
 
  generate_string (parser_name, stream, indent + indent_str.length ());
749
 
  stream << "_release (args_info);";
750
 
  indent = 0;
751
 
  stream << "\n";
752
 
  stream << indent_str;
753
 
  stream << "}";
754
 
  stream << "\n";
755
 
  stream << indent_str;
756
 
  stream << "\n";
757
 
  stream << indent_str;
758
1176
  if (check_possible_values)
759
1177
    {
760
 
      stream << "/*";
761
 
      stream << "\n";
762
 
      stream << indent_str;
763
 
      stream << " * Returns:";
764
 
      stream << "\n";
765
 
      stream << indent_str;
766
 
      stream << " * - the index of the matched value";
767
 
      stream << "\n";
768
 
      stream << indent_str;
769
 
      stream << " * - -1 if no argument has been specified";
770
 
      stream << "\n";
771
 
      stream << indent_str;
772
 
      stream << " * - -2 if more than one value has matched";
 
1178
      stream << "/**";
 
1179
      stream << "\n";
 
1180
      stream << indent_str;
 
1181
      stream << " * ";
 
1182
      stream << "@";
 
1183
      stream << "param val the value to check";
 
1184
      stream << "\n";
 
1185
      stream << indent_str;
 
1186
      stream << " * ";
 
1187
      stream << "@";
 
1188
      stream << "param values the possible values";
 
1189
      stream << "\n";
 
1190
      stream << indent_str;
 
1191
      stream << " * ";
 
1192
      stream << "@";
 
1193
      stream << "return the index of the matched value:";
 
1194
      stream << "\n";
 
1195
      stream << indent_str;
 
1196
      stream << " * -1 if no value matched,";
 
1197
      stream << "\n";
 
1198
      stream << indent_str;
 
1199
      stream << " * -2 if more than one value has matched";
773
1200
      stream << "\n";
774
1201
      stream << indent_str;
775
1202
      stream << " */";
845
1272
      stream << indent_str;
846
1273
      stream << "\n";
847
1274
      stream << indent_str;
848
 
      stream << "  return (found ? -2 : -1); /* return many values are matched */";
849
 
      stream << "\n";
850
 
      stream << indent_str;
851
 
      stream << "}";
852
 
      stream << "\n";
853
 
      stream << indent_str;
854
 
      stream << "\n";
855
 
      stream << indent_str;
856
 
    }
 
1275
      stream << "  return (found ? -2 : -1); /* return many values or none matched */";
 
1276
      stream << "\n";
 
1277
      stream << indent_str;
 
1278
      stream << "}";
 
1279
      stream << "\n";
 
1280
      stream << indent_str;
 
1281
      stream << "\n";
 
1282
      stream << indent_str;
 
1283
    }
 
1284
  stream << "\n";
 
1285
  stream << indent_str;
 
1286
  stream << "static void";
 
1287
  stream << "\n";
 
1288
  stream << indent_str;
 
1289
  stream << "write_into_file(FILE *outfile, const char *opt, const char *arg, char *values[])";
 
1290
  stream << "\n";
 
1291
  stream << indent_str;
 
1292
  stream << "{";
 
1293
  stream << "\n";
 
1294
  stream << indent_str;
 
1295
  if (check_possible_values)
 
1296
    {
 
1297
      stream << "  int found = -1;";
 
1298
      stream << "\n";
 
1299
      stream << indent_str;
 
1300
    }
 
1301
  stream << "  if (arg) {";
 
1302
  stream << "\n";
 
1303
  stream << indent_str;
 
1304
  if (check_possible_values)
 
1305
    {
 
1306
      stream << "    if (values) {";
 
1307
      stream << "\n";
 
1308
      stream << indent_str;
 
1309
      stream << "      found = check_possible_values(arg, values);      ";
 
1310
      stream << "\n";
 
1311
      stream << indent_str;
 
1312
      stream << "    }";
 
1313
      stream << "\n";
 
1314
      stream << indent_str;
 
1315
      stream << "    if (found >= 0)";
 
1316
      stream << "\n";
 
1317
      stream << indent_str;
 
1318
      stream << "      fprintf(outfile, \"%s=\\\"%s\\\" # %s\\n\", opt, arg, values[found]);";
 
1319
      stream << "\n";
 
1320
      stream << indent_str;
 
1321
      stream << "    else";
 
1322
      stream << "\n";
 
1323
      stream << indent_str;
 
1324
      stream << "      fprintf(outfile, \"%s=\\\"%s\\\"\\n\", opt, arg);";
 
1325
      stream << "\n";
 
1326
      stream << indent_str;
 
1327
    }
 
1328
  else
 
1329
    {
 
1330
      stream << "    fprintf(outfile, \"%s=\\\"%s\\\"\\n\", opt, arg);";
 
1331
      stream << "\n";
 
1332
      stream << indent_str;
 
1333
    }
 
1334
  stream << "  } else {";
 
1335
  stream << "\n";
 
1336
  stream << indent_str;
 
1337
  stream << "    fprintf(outfile, \"%s\\n\", opt);";
 
1338
  stream << "\n";
 
1339
  stream << indent_str;
 
1340
  stream << "  }";
 
1341
  stream << "\n";
 
1342
  stream << indent_str;
 
1343
  stream << "}";
 
1344
  stream << "\n";
 
1345
  stream << indent_str;
 
1346
  stream << "\n";
 
1347
  stream << indent_str;
 
1348
  if (multiple_options)
 
1349
    {
 
1350
      stream << "static void";
 
1351
      stream << "\n";
 
1352
      stream << indent_str;
 
1353
      stream << "write_multiple_into_file(FILE *outfile, int len, const char *opt, char **arg, char *values[])";
 
1354
      stream << "\n";
 
1355
      stream << indent_str;
 
1356
      stream << "{";
 
1357
      stream << "\n";
 
1358
      stream << indent_str;
 
1359
      stream << "  int i;";
 
1360
      stream << "\n";
 
1361
      stream << indent_str;
 
1362
      indent = 2;
 
1363
      stream << "  ";
 
1364
      indent = 0;
 
1365
      stream << "\n";
 
1366
      stream << indent_str;
 
1367
      stream << "  for (i = 0; i < len; ++i)";
 
1368
      stream << "\n";
 
1369
      stream << indent_str;
 
1370
      stream << "    write_into_file(outfile, opt, (arg ? arg[i] : 0), values);";
 
1371
      stream << "\n";
 
1372
      stream << indent_str;
 
1373
      stream << "}";
 
1374
      stream << "\n";
 
1375
      stream << indent_str;
 
1376
    }
 
1377
  stream << "\n";
 
1378
  stream << indent_str;
 
1379
  stream << "int";
 
1380
  stream << "\n";
 
1381
  stream << indent_str;
 
1382
  generate_string (parser_name, stream, indent + indent_str.length ());
 
1383
  stream << "_dump(FILE *outfile, struct ";
 
1384
  generate_string (args_info, stream, indent + indent_str.length ());
 
1385
  stream << " *args_info)";
 
1386
  stream << "\n";
 
1387
  stream << indent_str;
 
1388
  stream << "{";
 
1389
  stream << "\n";
 
1390
  stream << indent_str;
 
1391
  stream << "  int i = 0;";
 
1392
  stream << "\n";
 
1393
  stream << indent_str;
 
1394
  stream << "\n";
 
1395
  stream << indent_str;
 
1396
  stream << "  if (!outfile)";
 
1397
  stream << "\n";
 
1398
  stream << indent_str;
 
1399
  stream << "    {";
 
1400
  stream << "\n";
 
1401
  stream << indent_str;
 
1402
  stream << "      fprintf (stderr, \"%s: cannot dump options to stream\\n\", ";
 
1403
  generate_string (package_var_name, stream, indent + indent_str.length ());
 
1404
  stream << ");";
 
1405
  stream << "\n";
 
1406
  stream << indent_str;
 
1407
  stream << "      return EXIT_FAILURE;";
 
1408
  stream << "\n";
 
1409
  stream << indent_str;
 
1410
  stream << "    }";
 
1411
  stream << "\n";
 
1412
  stream << indent_str;
 
1413
  stream << "\n";
 
1414
  stream << indent_str;
 
1415
  indent = 2;
 
1416
  stream << "  ";
 
1417
  if (file_save_loop.size () > 0)
 
1418
    generate_string (file_save_loop, stream, indent + indent_str.length ());
 
1419
  else
 
1420
    generate_file_save_loop (stream, indent + indent_str.length ());
 
1421
  indent = 0;
 
1422
  stream << "\n";
 
1423
  stream << indent_str;
 
1424
  stream << "\n";
 
1425
  stream << indent_str;
 
1426
  stream << "  i = EXIT_SUCCESS;";
 
1427
  stream << "\n";
 
1428
  stream << indent_str;
 
1429
  stream << "  return i;";
 
1430
  stream << "\n";
 
1431
  stream << indent_str;
 
1432
  stream << "}";
 
1433
  stream << "\n";
 
1434
  stream << indent_str;
 
1435
  stream << "\n";
 
1436
  stream << indent_str;
 
1437
  stream << "int";
 
1438
  stream << "\n";
 
1439
  stream << indent_str;
 
1440
  generate_string (parser_name, stream, indent + indent_str.length ());
 
1441
  stream << "_file_save(const char *filename, struct ";
 
1442
  generate_string (args_info, stream, indent + indent_str.length ());
 
1443
  stream << " *args_info)";
 
1444
  stream << "\n";
 
1445
  stream << indent_str;
 
1446
  stream << "{";
 
1447
  stream << "\n";
 
1448
  stream << indent_str;
 
1449
  stream << "  FILE *outfile;";
 
1450
  stream << "\n";
 
1451
  stream << indent_str;
 
1452
  stream << "  int i = 0;";
 
1453
  stream << "\n";
 
1454
  stream << indent_str;
 
1455
  stream << "\n";
 
1456
  stream << indent_str;
 
1457
  stream << "  outfile = fopen(filename, \"w\");";
 
1458
  stream << "\n";
 
1459
  stream << indent_str;
 
1460
  stream << "\n";
 
1461
  stream << indent_str;
 
1462
  stream << "  if (!outfile)";
 
1463
  stream << "\n";
 
1464
  stream << indent_str;
 
1465
  stream << "    {";
 
1466
  stream << "\n";
 
1467
  stream << indent_str;
 
1468
  stream << "      fprintf (stderr, \"%s: cannot open file for writing: %s\\n\", ";
 
1469
  generate_string (package_var_name, stream, indent + indent_str.length ());
 
1470
  stream << ", filename);";
 
1471
  stream << "\n";
 
1472
  stream << indent_str;
 
1473
  stream << "      return EXIT_FAILURE;";
 
1474
  stream << "\n";
 
1475
  stream << indent_str;
 
1476
  stream << "    }";
 
1477
  stream << "\n";
 
1478
  stream << indent_str;
 
1479
  stream << "\n";
 
1480
  stream << indent_str;
 
1481
  stream << "  i = ";
 
1482
  generate_string (parser_name, stream, indent + indent_str.length ());
 
1483
  stream << "_dump(outfile, args_info);";
 
1484
  stream << "\n";
 
1485
  stream << indent_str;
 
1486
  stream << "  fclose (outfile);";
 
1487
  stream << "\n";
 
1488
  stream << indent_str;
 
1489
  stream << "\n";
 
1490
  stream << indent_str;
 
1491
  stream << "  return i;";
 
1492
  stream << "\n";
 
1493
  stream << indent_str;
 
1494
  stream << "}";
 
1495
  stream << "\n";
 
1496
  stream << indent_str;
 
1497
  stream << "\n";
 
1498
  stream << indent_str;
 
1499
  stream << "void";
 
1500
  stream << "\n";
 
1501
  stream << indent_str;
 
1502
  generate_string (parser_name, stream, indent + indent_str.length ());
 
1503
  stream << "_free (struct ";
 
1504
  generate_string (args_info, stream, indent + indent_str.length ());
 
1505
  stream << " *args_info)";
 
1506
  stream << "\n";
 
1507
  stream << indent_str;
 
1508
  stream << "{";
 
1509
  stream << "\n";
 
1510
  stream << indent_str;
 
1511
  indent = 2;
 
1512
  stream << "  ";
 
1513
  generate_string (parser_name, stream, indent + indent_str.length ());
 
1514
  stream << "_release (args_info);";
 
1515
  indent = 0;
 
1516
  stream << "\n";
 
1517
  stream << indent_str;
 
1518
  stream << "}";
 
1519
  stream << "\n";
 
1520
  stream << indent_str;
857
1521
  stream << "\n";
858
1522
  stream << indent_str;
859
1523
  if (do_generate_strdup)
860
1524
    {
861
 
      stream << "/* gengetopt_strdup() */";
862
 
      stream << "\n";
863
 
      stream << indent_str;
864
 
      stream << "/* strdup.c replacement of strdup, which is not standard */";
 
1525
      stream << "/** ";
 
1526
      stream << "@";
 
1527
      stream << "brief replacement of strdup, which is not standard */";
865
1528
      stream << "\n";
866
1529
      stream << indent_str;
867
1530
      stream << "char *";
919
1582
      stream << "  char *tok, *ret;";
920
1583
      stream << "\n";
921
1584
      stream << indent_str;
922
 
      stream << "  size_t len, num_of_escape;";
923
 
      stream << "\n";
924
 
      stream << indent_str;
925
 
      stream << "  int i, j;";
 
1585
      stream << "  size_t len, num_of_escape, i, j;";
926
1586
      stream << "\n";
927
1587
      stream << indent_str;
928
1588
      stream << "\n";
1401
2061
  stream << "  params.check_ambiguity = 0;";
1402
2062
  stream << "\n";
1403
2063
  stream << indent_str;
 
2064
  stream << "  params.print_errors = 1;";
 
2065
  stream << "\n";
 
2066
  stream << indent_str;
1404
2067
  stream << "\n";
1405
2068
  stream << indent_str;
1406
2069
  stream << "  result = ";
1529
2192
      stream << "\n";
1530
2193
      stream << indent_str;
1531
2194
    }
 
2195
  stream << "\n";
 
2196
  stream << indent_str;
 
2197
  stream << "static char *package_name = 0;";
 
2198
  stream << "\n";
 
2199
  stream << indent_str;
 
2200
  stream << "\n";
 
2201
  stream << indent_str;
 
2202
  if (( ! no_options ))
 
2203
    {
 
2204
      stream << "/**";
 
2205
      stream << "\n";
 
2206
      stream << indent_str;
 
2207
      stream << " * ";
 
2208
      stream << "@";
 
2209
      stream << "brief updates an option";
 
2210
      stream << "\n";
 
2211
      stream << indent_str;
 
2212
      stream << " * ";
 
2213
      stream << "@";
 
2214
      stream << "param field the generic pointer to the field to update";
 
2215
      stream << "\n";
 
2216
      stream << indent_str;
 
2217
      stream << " * ";
 
2218
      stream << "@";
 
2219
      stream << "param orig_field the pointer to the orig field";
 
2220
      stream << "\n";
 
2221
      stream << indent_str;
 
2222
      stream << " * ";
 
2223
      stream << "@";
 
2224
      stream << "param field_given the pointer to the number of occurrence of this option";
 
2225
      stream << "\n";
 
2226
      stream << indent_str;
 
2227
      stream << " * ";
 
2228
      stream << "@";
 
2229
      stream << "param prev_given the pointer to the number of occurrence already seen";
 
2230
      stream << "\n";
 
2231
      stream << indent_str;
 
2232
      stream << " * ";
 
2233
      stream << "@";
 
2234
      stream << "param value the argument for this option (if null no arg was specified)";
 
2235
      stream << "\n";
 
2236
      stream << indent_str;
 
2237
      stream << " * ";
 
2238
      stream << "@";
 
2239
      stream << "param possible_values the possible values for this option (if specified)";
 
2240
      stream << "\n";
 
2241
      stream << indent_str;
 
2242
      stream << " * ";
 
2243
      stream << "@";
 
2244
      stream << "param default_value the default value (in case the option only accepts fixed values)";
 
2245
      stream << "\n";
 
2246
      stream << indent_str;
 
2247
      stream << " * ";
 
2248
      stream << "@";
 
2249
      stream << "param arg_type the type of this option";
 
2250
      stream << "\n";
 
2251
      stream << indent_str;
 
2252
      stream << " * ";
 
2253
      stream << "@";
 
2254
      stream << "param check_ambiguity ";
 
2255
      stream << "@";
 
2256
      stream << "see ";
 
2257
      generate_string (parser_name, stream, indent + indent_str.length ());
 
2258
      stream << "_params.check_ambiguity";
 
2259
      stream << "\n";
 
2260
      stream << indent_str;
 
2261
      stream << " * ";
 
2262
      stream << "@";
 
2263
      stream << "param override ";
 
2264
      stream << "@";
 
2265
      stream << "see ";
 
2266
      generate_string (parser_name, stream, indent + indent_str.length ());
 
2267
      stream << "_params.override";
 
2268
      stream << "\n";
 
2269
      stream << indent_str;
 
2270
      stream << " * ";
 
2271
      stream << "@";
 
2272
      stream << "param no_free whether to free a possible previous value";
 
2273
      stream << "\n";
 
2274
      stream << indent_str;
 
2275
      stream << " * ";
 
2276
      stream << "@";
 
2277
      stream << "param multiple_option whether this is a multiple option";
 
2278
      stream << "\n";
 
2279
      stream << indent_str;
 
2280
      stream << " * ";
 
2281
      stream << "@";
 
2282
      stream << "param long_opt the corresponding long option";
 
2283
      stream << "\n";
 
2284
      stream << indent_str;
 
2285
      stream << " * ";
 
2286
      stream << "@";
 
2287
      stream << "param short_opt the corresponding short option (or '-' if none)";
 
2288
      stream << "\n";
 
2289
      stream << indent_str;
 
2290
      stream << " * ";
 
2291
      stream << "@";
 
2292
      stream << "param additional_error possible further error specification";
 
2293
      stream << "\n";
 
2294
      stream << indent_str;
 
2295
      stream << " */";
 
2296
      stream << "\n";
 
2297
      stream << indent_str;
 
2298
      stream << "static";
 
2299
      stream << "\n";
 
2300
      stream << indent_str;
 
2301
      stream << "int update_arg(void *field, char **orig_field,";
 
2302
      stream << "\n";
 
2303
      stream << indent_str;
 
2304
      stream << "               unsigned int *field_given, unsigned int *prev_given, ";
 
2305
      stream << "\n";
 
2306
      stream << indent_str;
 
2307
      stream << "               char *value, char *possible_values[], const char *default_value,";
 
2308
      stream << "\n";
 
2309
      stream << indent_str;
 
2310
      indent = 15;
 
2311
      stream << "               ";
 
2312
      generate_string (parser_name, stream, indent + indent_str.length ());
 
2313
      stream << "_arg_type arg_type,";
 
2314
      indent = 0;
 
2315
      stream << "\n";
 
2316
      stream << indent_str;
 
2317
      stream << "               int check_ambiguity, int override,";
 
2318
      stream << "\n";
 
2319
      stream << indent_str;
 
2320
      stream << "               int no_free, int multiple_option,";
 
2321
      stream << "\n";
 
2322
      stream << indent_str;
 
2323
      stream << "               const char *long_opt, char short_opt,";
 
2324
      stream << "\n";
 
2325
      stream << indent_str;
 
2326
      stream << "               const char *additional_error)";
 
2327
      stream << "\n";
 
2328
      stream << indent_str;
 
2329
      stream << "{";
 
2330
      stream << "\n";
 
2331
      stream << indent_str;
 
2332
      stream << "  char *stop_char = 0;";
 
2333
      stream << "\n";
 
2334
      stream << indent_str;
 
2335
      stream << "  const char *val = value;";
 
2336
      stream << "\n";
 
2337
      stream << indent_str;
 
2338
      stream << "  int found;";
 
2339
      stream << "\n";
 
2340
      stream << indent_str;
 
2341
      if (has_arg_string)
 
2342
        {
 
2343
          stream << "  char **string_field;";
 
2344
          stream << "\n";
 
2345
          stream << indent_str;
 
2346
        }
 
2347
      stream << "\n";
 
2348
      stream << indent_str;
 
2349
      stream << "  stop_char = 0;";
 
2350
      stream << "\n";
 
2351
      stream << indent_str;
 
2352
      stream << "  found = 0;";
 
2353
      stream << "\n";
 
2354
      stream << indent_str;
 
2355
      stream << "\n";
 
2356
      stream << indent_str;
 
2357
      stream << "  if (!multiple_option && prev_given && (*prev_given || (check_ambiguity && *field_given)))";
 
2358
      stream << "\n";
 
2359
      stream << indent_str;
 
2360
      stream << "    {";
 
2361
      stream << "\n";
 
2362
      stream << indent_str;
 
2363
      stream << "      if (short_opt != '-')";
 
2364
      stream << "\n";
 
2365
      stream << indent_str;
 
2366
      stream << "        fprintf (stderr, \"%s: `--%s' (`-%c') option given more than once%s\\n\", ";
 
2367
      stream << "\n";
 
2368
      stream << indent_str;
 
2369
      stream << "               package_name, long_opt, short_opt,";
 
2370
      stream << "\n";
 
2371
      stream << indent_str;
 
2372
      stream << "               (additional_error ? additional_error : \"\"));";
 
2373
      stream << "\n";
 
2374
      stream << indent_str;
 
2375
      stream << "      else";
 
2376
      stream << "\n";
 
2377
      stream << indent_str;
 
2378
      stream << "        fprintf (stderr, \"%s: `--%s' option given more than once%s\\n\", ";
 
2379
      stream << "\n";
 
2380
      stream << indent_str;
 
2381
      stream << "               package_name, long_opt,";
 
2382
      stream << "\n";
 
2383
      stream << indent_str;
 
2384
      stream << "               (additional_error ? additional_error : \"\"));";
 
2385
      stream << "\n";
 
2386
      stream << indent_str;
 
2387
      stream << "      return 1; /* failure */";
 
2388
      stream << "\n";
 
2389
      stream << indent_str;
 
2390
      stream << "    }";
 
2391
      stream << "\n";
 
2392
      stream << indent_str;
 
2393
      stream << "\n";
 
2394
      stream << indent_str;
 
2395
      if (check_possible_values)
 
2396
        {
 
2397
          stream << "  if (possible_values && (found = check_possible_values((value ? value : default_value), possible_values)) < 0)";
 
2398
          stream << "\n";
 
2399
          stream << indent_str;
 
2400
          stream << "    {";
 
2401
          stream << "\n";
 
2402
          stream << indent_str;
 
2403
          stream << "      if (short_opt != '-')";
 
2404
          stream << "\n";
 
2405
          stream << indent_str;
 
2406
          stream << "        fprintf (stderr, \"%s: %s argument, \\\"%s\\\", for option `--%s' (`-%c')%s\\n\", ";
 
2407
          stream << "\n";
 
2408
          stream << indent_str;
 
2409
          stream << "          package_name, (found == -2) ? \"ambiguous\" : \"invalid\", value, long_opt, short_opt,";
 
2410
          stream << "\n";
 
2411
          stream << indent_str;
 
2412
          stream << "          (additional_error ? additional_error : \"\"));";
 
2413
          stream << "\n";
 
2414
          stream << indent_str;
 
2415
          stream << "      else";
 
2416
          stream << "\n";
 
2417
          stream << indent_str;
 
2418
          stream << "        fprintf (stderr, \"%s: %s argument, \\\"%s\\\", for option `--%s'%s\\n\", ";
 
2419
          stream << "\n";
 
2420
          stream << indent_str;
 
2421
          stream << "          package_name, (found == -2) ? \"ambiguous\" : \"invalid\", value, long_opt,";
 
2422
          stream << "\n";
 
2423
          stream << indent_str;
 
2424
          stream << "          (additional_error ? additional_error : \"\"));";
 
2425
          stream << "\n";
 
2426
          stream << indent_str;
 
2427
          stream << "      return 1; /* failure */";
 
2428
          stream << "\n";
 
2429
          stream << indent_str;
 
2430
          stream << "    }";
 
2431
          stream << "\n";
 
2432
          stream << indent_str;
 
2433
        }
 
2434
      stream << "    ";
 
2435
      stream << "\n";
 
2436
      stream << indent_str;
 
2437
      stream << "  if (field_given && *field_given && ! override)";
 
2438
      stream << "\n";
 
2439
      stream << indent_str;
 
2440
      stream << "    return 0;";
 
2441
      stream << "\n";
 
2442
      stream << indent_str;
 
2443
      stream << "  if (prev_given)";
 
2444
      stream << "\n";
 
2445
      stream << indent_str;
 
2446
      stream << "    (*prev_given)++;";
 
2447
      stream << "\n";
 
2448
      stream << indent_str;
 
2449
      stream << "  if (field_given)";
 
2450
      stream << "\n";
 
2451
      stream << indent_str;
 
2452
      stream << "    (*field_given)++;";
 
2453
      stream << "\n";
 
2454
      stream << indent_str;
 
2455
      stream << "  if (possible_values)";
 
2456
      stream << "\n";
 
2457
      stream << indent_str;
 
2458
      stream << "    val = possible_values[found];";
 
2459
      stream << "\n";
 
2460
      stream << indent_str;
 
2461
      stream << "\n";
 
2462
      stream << indent_str;
 
2463
      stream << "  switch(arg_type) {";
 
2464
      stream << "\n";
 
2465
      stream << indent_str;
 
2466
      if (has_arg_flag)
 
2467
        {
 
2468
          stream << "  case ARG_FLAG:";
 
2469
          stream << "\n";
 
2470
          stream << indent_str;
 
2471
          stream << "    *((int *)field) = !*((int *)field);";
 
2472
          stream << "\n";
 
2473
          stream << indent_str;
 
2474
          stream << "    break;";
 
2475
          stream << "\n";
 
2476
          stream << indent_str;
 
2477
        }
 
2478
      if (has_arg_int)
 
2479
        {
 
2480
          stream << "  case ARG_INT:";
 
2481
          stream << "\n";
 
2482
          stream << indent_str;
 
2483
          stream << "    if (val) *((int *)field) = strtol (val, &stop_char, 0);";
 
2484
          stream << "\n";
 
2485
          stream << indent_str;
 
2486
          stream << "    break;";
 
2487
          stream << "\n";
 
2488
          stream << indent_str;
 
2489
        }
 
2490
      if (has_arg_short)
 
2491
        {
 
2492
          stream << "  case ARG_SHORT:";
 
2493
          stream << "\n";
 
2494
          stream << indent_str;
 
2495
          stream << "    if (val) *((short *)field) = (short)strtol (val, &stop_char, 0);";
 
2496
          stream << "\n";
 
2497
          stream << indent_str;
 
2498
          stream << "    break;";
 
2499
          stream << "\n";
 
2500
          stream << indent_str;
 
2501
        }
 
2502
      if (has_arg_long)
 
2503
        {
 
2504
          stream << "  case ARG_LONG:";
 
2505
          stream << "\n";
 
2506
          stream << indent_str;
 
2507
          stream << "    if (val) *((long *)field) = (long)strtol (val, &stop_char, 0);";
 
2508
          stream << "\n";
 
2509
          stream << indent_str;
 
2510
          stream << "    break;";
 
2511
          stream << "\n";
 
2512
          stream << indent_str;
 
2513
        }
 
2514
      if (has_arg_float)
 
2515
        {
 
2516
          stream << "  case ARG_FLOAT:";
 
2517
          stream << "\n";
 
2518
          stream << indent_str;
 
2519
          stream << "    if (val) *((float *)field) = (float)strtod (val, &stop_char);";
 
2520
          stream << "\n";
 
2521
          stream << indent_str;
 
2522
          stream << "    break;";
 
2523
          stream << "\n";
 
2524
          stream << indent_str;
 
2525
        }
 
2526
      if (has_arg_double)
 
2527
        {
 
2528
          stream << "  case ARG_DOUBLE:";
 
2529
          stream << "\n";
 
2530
          stream << indent_str;
 
2531
          stream << "    if (val) *((double *)field) = strtod (val, &stop_char);";
 
2532
          stream << "\n";
 
2533
          stream << indent_str;
 
2534
          stream << "    break;";
 
2535
          stream << "\n";
 
2536
          stream << indent_str;
 
2537
        }
 
2538
      if (has_arg_longdouble)
 
2539
        {
 
2540
          stream << "  case ARG_LONGDOUBLE:";
 
2541
          stream << "\n";
 
2542
          stream << indent_str;
 
2543
          stream << "    if (val) *((long double *)field) = (long double)strtod (val, &stop_char);";
 
2544
          stream << "\n";
 
2545
          stream << indent_str;
 
2546
          stream << "    break;";
 
2547
          stream << "\n";
 
2548
          stream << indent_str;
 
2549
        }
 
2550
      if (has_arg_longlong)
 
2551
        {
 
2552
          stream << "  case ARG_LONGLONG:";
 
2553
          stream << "\n";
 
2554
          stream << indent_str;
 
2555
          stream << "#ifdef HAVE_LONG_LONG";
 
2556
          stream << "\n";
 
2557
          stream << indent_str;
 
2558
          stream << "    if (val) *((long long int*)field) = (long long int) strtol (val, &stop_char, 0);";
 
2559
          stream << "\n";
 
2560
          stream << indent_str;
 
2561
          stream << "#else";
 
2562
          stream << "\n";
 
2563
          stream << indent_str;
 
2564
          stream << "    if (val) *((long *)field) = (long)strtol (val, &stop_char, 0);";
 
2565
          stream << "\n";
 
2566
          stream << indent_str;
 
2567
          stream << "#endif";
 
2568
          stream << "\n";
 
2569
          stream << indent_str;
 
2570
          stream << "    break;";
 
2571
          stream << "\n";
 
2572
          stream << indent_str;
 
2573
        }
 
2574
      if (has_arg_enum)
 
2575
        {
 
2576
          stream << "  case ARG_ENUM:";
 
2577
          stream << "\n";
 
2578
          stream << indent_str;
 
2579
          stream << "    if (val) *((int *)field) = found;";
 
2580
          stream << "\n";
 
2581
          stream << indent_str;
 
2582
          stream << "    break;";
 
2583
          stream << "\n";
 
2584
          stream << indent_str;
 
2585
        }
 
2586
      if (has_arg_string)
 
2587
        {
 
2588
          stream << "  case ARG_STRING:";
 
2589
          stream << "\n";
 
2590
          stream << indent_str;
 
2591
          stream << "    if (val) {";
 
2592
          stream << "\n";
 
2593
          stream << indent_str;
 
2594
          stream << "      string_field = (char **)field;";
 
2595
          stream << "\n";
 
2596
          stream << indent_str;
 
2597
          stream << "      if (!no_free && *string_field)";
 
2598
          stream << "\n";
 
2599
          stream << indent_str;
 
2600
          stream << "        free (*string_field); /* free previous string */";
 
2601
          stream << "\n";
 
2602
          stream << indent_str;
 
2603
          stream << "      *string_field = gengetopt_strdup (val);";
 
2604
          stream << "\n";
 
2605
          stream << indent_str;
 
2606
          stream << "    }";
 
2607
          stream << "\n";
 
2608
          stream << indent_str;
 
2609
          stream << "    break;";
 
2610
          stream << "\n";
 
2611
          stream << indent_str;
 
2612
        }
 
2613
      stream << "  default:";
 
2614
      stream << "\n";
 
2615
      stream << indent_str;
 
2616
      stream << "    break;";
 
2617
      stream << "\n";
 
2618
      stream << indent_str;
 
2619
      stream << "  };";
 
2620
      stream << "\n";
 
2621
      stream << indent_str;
 
2622
      stream << "\n";
 
2623
      stream << indent_str;
 
2624
      if (( ( ( ( ( ( has_arg_int || has_arg_short ) || has_arg_long ) || has_arg_float ) || has_arg_double ) || has_arg_longdouble ) || has_arg_longlong ))
 
2625
        {
 
2626
          stream << "  /* check numeric conversion */";
 
2627
          stream << "\n";
 
2628
          stream << indent_str;
 
2629
          stream << "  switch(arg_type) {";
 
2630
          stream << "\n";
 
2631
          stream << indent_str;
 
2632
          if (has_arg_int)
 
2633
            {
 
2634
              stream << "  case ARG_INT:";
 
2635
              stream << "\n";
 
2636
              stream << indent_str;
 
2637
            }
 
2638
          if (has_arg_short)
 
2639
            {
 
2640
              stream << "  case ARG_SHORT:";
 
2641
              stream << "\n";
 
2642
              stream << indent_str;
 
2643
            }
 
2644
          if (has_arg_long)
 
2645
            {
 
2646
              stream << "  case ARG_LONG:";
 
2647
              stream << "\n";
 
2648
              stream << indent_str;
 
2649
            }
 
2650
          if (has_arg_float)
 
2651
            {
 
2652
              stream << "  case ARG_FLOAT:";
 
2653
              stream << "\n";
 
2654
              stream << indent_str;
 
2655
            }
 
2656
          if (has_arg_double)
 
2657
            {
 
2658
              stream << "  case ARG_DOUBLE:";
 
2659
              stream << "\n";
 
2660
              stream << indent_str;
 
2661
            }
 
2662
          if (has_arg_longdouble)
 
2663
            {
 
2664
              stream << "  case ARG_LONGDOUBLE:";
 
2665
              stream << "\n";
 
2666
              stream << indent_str;
 
2667
            }
 
2668
          if (has_arg_longlong)
 
2669
            {
 
2670
              stream << "  case ARG_LONGLONG:";
 
2671
              stream << "\n";
 
2672
              stream << indent_str;
 
2673
            }
 
2674
          stream << "    if (val && !(stop_char && *stop_char == '\\0')) {";
 
2675
          stream << "\n";
 
2676
          stream << indent_str;
 
2677
          stream << "      fprintf(stderr, \"%s: invalid numeric value: %s\\n\", package_name, val);";
 
2678
          stream << "\n";
 
2679
          stream << indent_str;
 
2680
          stream << "      return 1; /* failure */";
 
2681
          stream << "\n";
 
2682
          stream << indent_str;
 
2683
          stream << "    }";
 
2684
          stream << "\n";
 
2685
          stream << indent_str;
 
2686
          stream << "    break;";
 
2687
          stream << "\n";
 
2688
          stream << indent_str;
 
2689
          stream << "  default:";
 
2690
          stream << "\n";
 
2691
          stream << indent_str;
 
2692
          stream << "    ;";
 
2693
          stream << "\n";
 
2694
          stream << indent_str;
 
2695
          stream << "  };";
 
2696
          stream << "\n";
 
2697
          stream << indent_str;
 
2698
        }
 
2699
      stream << "\n";
 
2700
      stream << indent_str;
 
2701
      stream << "  /* store the original value */";
 
2702
      stream << "\n";
 
2703
      stream << indent_str;
 
2704
      stream << "  switch(arg_type) {";
 
2705
      stream << "\n";
 
2706
      stream << indent_str;
 
2707
      stream << "  case ARG_NO:";
 
2708
      stream << "\n";
 
2709
      stream << indent_str;
 
2710
      if (has_arg_flag)
 
2711
        {
 
2712
          stream << "  case ARG_FLAG:";
 
2713
          stream << "\n";
 
2714
          stream << indent_str;
 
2715
        }
 
2716
      stream << "    break;";
 
2717
      stream << "\n";
 
2718
      stream << indent_str;
 
2719
      stream << "  default:";
 
2720
      stream << "\n";
 
2721
      stream << indent_str;
 
2722
      stream << "    if (value && orig_field) {";
 
2723
      stream << "\n";
 
2724
      stream << indent_str;
 
2725
      stream << "      if (no_free) {";
 
2726
      stream << "\n";
 
2727
      stream << indent_str;
 
2728
      stream << "        *orig_field = value;";
 
2729
      stream << "\n";
 
2730
      stream << indent_str;
 
2731
      stream << "      } else {";
 
2732
      stream << "\n";
 
2733
      stream << indent_str;
 
2734
      stream << "        if (*orig_field)";
 
2735
      stream << "\n";
 
2736
      stream << indent_str;
 
2737
      stream << "          free (*orig_field); /* free previous string */";
 
2738
      stream << "\n";
 
2739
      stream << indent_str;
 
2740
      stream << "        *orig_field = gengetopt_strdup (value);";
 
2741
      stream << "\n";
 
2742
      stream << indent_str;
 
2743
      stream << "      }";
 
2744
      stream << "\n";
 
2745
      stream << indent_str;
 
2746
      stream << "    }";
 
2747
      stream << "\n";
 
2748
      stream << indent_str;
 
2749
      stream << "  };";
 
2750
      stream << "\n";
 
2751
      stream << indent_str;
 
2752
      stream << "\n";
 
2753
      stream << indent_str;
 
2754
      stream << "  return 0; /* OK */";
 
2755
      stream << "\n";
 
2756
      stream << indent_str;
 
2757
      stream << "}";
 
2758
      stream << "\n";
 
2759
      stream << indent_str;
 
2760
    }
 
2761
  stream << "\n";
 
2762
  stream << indent_str;
 
2763
  if (multiple_token_functions)
 
2764
    {
 
2765
      stream << "/**";
 
2766
      stream << "\n";
 
2767
      stream << indent_str;
 
2768
      stream << " * ";
 
2769
      stream << "@";
 
2770
      stream << "brief store information about a multiple option in a temporary list";
 
2771
      stream << "\n";
 
2772
      stream << indent_str;
 
2773
      stream << " * ";
 
2774
      stream << "@";
 
2775
      stream << "param list where to (temporarily) store multiple options";
 
2776
      stream << "\n";
 
2777
      stream << indent_str;
 
2778
      stream << " */";
 
2779
      stream << "\n";
 
2780
      stream << indent_str;
 
2781
      stream << "static";
 
2782
      stream << "\n";
 
2783
      stream << indent_str;
 
2784
      stream << "int update_multiple_arg_temp(struct generic_list **list,";
 
2785
      stream << "\n";
 
2786
      stream << indent_str;
 
2787
      stream << "               unsigned int *prev_given, const char *val,";
 
2788
      stream << "\n";
 
2789
      stream << indent_str;
 
2790
      stream << "               char *possible_values[], const char *default_value,";
 
2791
      stream << "\n";
 
2792
      stream << indent_str;
 
2793
      indent = 15;
 
2794
      stream << "               ";
 
2795
      generate_string (parser_name, stream, indent + indent_str.length ());
 
2796
      stream << "_arg_type arg_type,";
 
2797
      indent = 0;
 
2798
      stream << "\n";
 
2799
      stream << indent_str;
 
2800
      stream << "               const char *long_opt, char short_opt,";
 
2801
      stream << "\n";
 
2802
      stream << indent_str;
 
2803
      stream << "               const char *additional_error)";
 
2804
      stream << "\n";
 
2805
      stream << indent_str;
 
2806
      stream << "{";
 
2807
      stream << "\n";
 
2808
      stream << indent_str;
 
2809
      stream << "  char *multi_token, *multi_next; /* store single arguments */";
 
2810
      stream << "\n";
 
2811
      stream << indent_str;
 
2812
      stream << "\n";
 
2813
      stream << indent_str;
 
2814
      stream << "  if (arg_type == ARG_NO) {";
 
2815
      stream << "\n";
 
2816
      stream << indent_str;
 
2817
      stream << "    (*prev_given)++;";
 
2818
      stream << "\n";
 
2819
      stream << indent_str;
 
2820
      stream << "    return 0; /* OK */";
 
2821
      stream << "\n";
 
2822
      stream << indent_str;
 
2823
      stream << "  }";
 
2824
      stream << "\n";
 
2825
      stream << indent_str;
 
2826
      stream << "\n";
 
2827
      stream << indent_str;
 
2828
      stream << "  multi_token = get_multiple_arg_token(val);";
 
2829
      stream << "\n";
 
2830
      stream << indent_str;
 
2831
      stream << "  multi_next = get_multiple_arg_token_next (val);";
 
2832
      stream << "\n";
 
2833
      stream << indent_str;
 
2834
      stream << "\n";
 
2835
      stream << indent_str;
 
2836
      stream << "  while (1)";
 
2837
      stream << "\n";
 
2838
      stream << indent_str;
 
2839
      stream << "    {";
 
2840
      stream << "\n";
 
2841
      stream << indent_str;
 
2842
      stream << "      add_node (list);";
 
2843
      stream << "\n";
 
2844
      stream << indent_str;
 
2845
      stream << "      if (update_arg((void *)&((*list)->arg), &((*list)->orig), 0,";
 
2846
      stream << "\n";
 
2847
      stream << indent_str;
 
2848
      stream << "          prev_given, multi_token, possible_values, default_value, ";
 
2849
      stream << "\n";
 
2850
      stream << indent_str;
 
2851
      stream << "          arg_type, 0, 1, 1, 1, long_opt, short_opt, additional_error)) {";
 
2852
      stream << "\n";
 
2853
      stream << indent_str;
 
2854
      stream << "        if (multi_token) free(multi_token);";
 
2855
      stream << "\n";
 
2856
      stream << indent_str;
 
2857
      stream << "        return 1; /* failure */";
 
2858
      stream << "\n";
 
2859
      stream << indent_str;
 
2860
      stream << "      }";
 
2861
      stream << "\n";
 
2862
      stream << indent_str;
 
2863
      stream << "\n";
 
2864
      stream << indent_str;
 
2865
      stream << "      if (multi_next)";
 
2866
      stream << "\n";
 
2867
      stream << indent_str;
 
2868
      stream << "        {";
 
2869
      stream << "\n";
 
2870
      stream << indent_str;
 
2871
      stream << "          multi_token = get_multiple_arg_token(multi_next);";
 
2872
      stream << "\n";
 
2873
      stream << indent_str;
 
2874
      stream << "          multi_next = get_multiple_arg_token_next (multi_next);";
 
2875
      stream << "\n";
 
2876
      stream << indent_str;
 
2877
      stream << "        }";
 
2878
      stream << "\n";
 
2879
      stream << indent_str;
 
2880
      stream << "      else";
 
2881
      stream << "\n";
 
2882
      stream << indent_str;
 
2883
      stream << "        break;";
 
2884
      stream << "\n";
 
2885
      stream << indent_str;
 
2886
      stream << "    }";
 
2887
      stream << "\n";
 
2888
      stream << indent_str;
 
2889
      stream << "\n";
 
2890
      stream << indent_str;
 
2891
      stream << "  return 0; /* OK */";
 
2892
      stream << "\n";
 
2893
      stream << indent_str;
 
2894
      stream << "}";
 
2895
      stream << "\n";
 
2896
      stream << indent_str;
 
2897
      stream << "\n";
 
2898
      stream << indent_str;
 
2899
      stream << "/**";
 
2900
      stream << "\n";
 
2901
      stream << indent_str;
 
2902
      stream << " * ";
 
2903
      stream << "@";
 
2904
      stream << "brief free the passed list (including possible string argument)";
 
2905
      stream << "\n";
 
2906
      stream << indent_str;
 
2907
      stream << " */";
 
2908
      stream << "\n";
 
2909
      stream << indent_str;
 
2910
      stream << "static";
 
2911
      stream << "\n";
 
2912
      stream << indent_str;
 
2913
      stream << "void free_list(struct generic_list *list, short string_arg)";
 
2914
      stream << "\n";
 
2915
      stream << indent_str;
 
2916
      stream << "{";
 
2917
      stream << "\n";
 
2918
      stream << indent_str;
 
2919
      stream << "  if (list) {";
 
2920
      stream << "\n";
 
2921
      stream << indent_str;
 
2922
      stream << "    struct generic_list *tmp;";
 
2923
      stream << "\n";
 
2924
      stream << indent_str;
 
2925
      stream << "    while (list)";
 
2926
      stream << "\n";
 
2927
      stream << indent_str;
 
2928
      stream << "      {";
 
2929
      stream << "\n";
 
2930
      stream << indent_str;
 
2931
      stream << "        tmp = list;";
 
2932
      stream << "\n";
 
2933
      stream << indent_str;
 
2934
      stream << "        if (string_arg && list->arg.string_arg)";
 
2935
      stream << "\n";
 
2936
      stream << indent_str;
 
2937
      stream << "          free (list->arg.string_arg);";
 
2938
      stream << "\n";
 
2939
      stream << indent_str;
 
2940
      stream << "        if (list->orig)";
 
2941
      stream << "\n";
 
2942
      stream << indent_str;
 
2943
      stream << "          free (list->orig);";
 
2944
      stream << "\n";
 
2945
      stream << indent_str;
 
2946
      stream << "        list = list->next;";
 
2947
      stream << "\n";
 
2948
      stream << indent_str;
 
2949
      stream << "        free (tmp);";
 
2950
      stream << "\n";
 
2951
      stream << indent_str;
 
2952
      stream << "      }";
 
2953
      stream << "\n";
 
2954
      stream << indent_str;
 
2955
      stream << "  }";
 
2956
      stream << "\n";
 
2957
      stream << indent_str;
 
2958
      stream << "}";
 
2959
      stream << "\n";
 
2960
      stream << indent_str;
 
2961
      stream << "\n";
 
2962
      stream << indent_str;
 
2963
      stream << "/**";
 
2964
      stream << "\n";
 
2965
      stream << indent_str;
 
2966
      stream << " * ";
 
2967
      stream << "@";
 
2968
      stream << "brief updates a multiple option starting from the passed list";
 
2969
      stream << "\n";
 
2970
      stream << indent_str;
 
2971
      stream << " */";
 
2972
      stream << "\n";
 
2973
      stream << indent_str;
 
2974
      stream << "static";
 
2975
      stream << "\n";
 
2976
      stream << indent_str;
 
2977
      stream << "void update_multiple_arg(void *field, char ***orig_field,";
 
2978
      stream << "\n";
 
2979
      stream << indent_str;
 
2980
      stream << "               unsigned int field_given, unsigned int prev_given, union generic_value *default_value,";
 
2981
      stream << "\n";
 
2982
      stream << indent_str;
 
2983
      indent = 15;
 
2984
      stream << "               ";
 
2985
      generate_string (parser_name, stream, indent + indent_str.length ());
 
2986
      stream << "_arg_type arg_type,";
 
2987
      indent = 0;
 
2988
      stream << "\n";
 
2989
      stream << indent_str;
 
2990
      stream << "               struct generic_list *list)";
 
2991
      stream << "\n";
 
2992
      stream << indent_str;
 
2993
      stream << "{";
 
2994
      stream << "\n";
 
2995
      stream << indent_str;
 
2996
      stream << "  int i;";
 
2997
      stream << "\n";
 
2998
      stream << indent_str;
 
2999
      stream << "  struct generic_list *tmp;";
 
3000
      stream << "\n";
 
3001
      stream << indent_str;
 
3002
      stream << "\n";
 
3003
      stream << indent_str;
 
3004
      stream << "  if (prev_given && list) {";
 
3005
      stream << "\n";
 
3006
      stream << indent_str;
 
3007
      stream << "    *orig_field = (char **) realloc (*orig_field, (field_given + prev_given) * sizeof (char *));";
 
3008
      stream << "\n";
 
3009
      stream << indent_str;
 
3010
      stream << "\n";
 
3011
      stream << indent_str;
 
3012
      stream << "    switch(arg_type) {";
 
3013
      stream << "\n";
 
3014
      stream << indent_str;
 
3015
      if (( has_arg_int || has_arg_enum ))
 
3016
        {
 
3017
          if (has_arg_int)
 
3018
            {
 
3019
              stream << "    case ARG_INT:";
 
3020
              stream << "\n";
 
3021
              stream << indent_str;
 
3022
            }
 
3023
          if (has_arg_enum)
 
3024
            {
 
3025
              stream << "    case ARG_ENUM:";
 
3026
              stream << "\n";
 
3027
              stream << indent_str;
 
3028
            }
 
3029
          stream << "      *((int **)field) = (int *)realloc (*((int **)field), (field_given + prev_given) * sizeof (int)); break;";
 
3030
          stream << "\n";
 
3031
          stream << indent_str;
 
3032
        }
 
3033
      if (has_arg_short)
 
3034
        {
 
3035
          stream << "    case ARG_SHORT:";
 
3036
          stream << "\n";
 
3037
          stream << indent_str;
 
3038
          stream << "      *((short **)field) = (short *)realloc (*((short **)field), (field_given + prev_given) * sizeof (short)); break;";
 
3039
          stream << "\n";
 
3040
          stream << indent_str;
 
3041
        }
 
3042
      if (has_arg_long)
 
3043
        {
 
3044
          stream << "    case ARG_LONG:";
 
3045
          stream << "\n";
 
3046
          stream << indent_str;
 
3047
          stream << "      *((long **)field) = (long *)realloc (*((long **)field), (field_given + prev_given) * sizeof (long)); break;";
 
3048
          stream << "\n";
 
3049
          stream << indent_str;
 
3050
        }
 
3051
      if (has_arg_float)
 
3052
        {
 
3053
          stream << "    case ARG_FLOAT:";
 
3054
          stream << "\n";
 
3055
          stream << indent_str;
 
3056
          stream << "      *((float **)field) = (float *)realloc (*((float **)field), (field_given + prev_given) * sizeof (float)); break;";
 
3057
          stream << "\n";
 
3058
          stream << indent_str;
 
3059
        }
 
3060
      if (has_arg_double)
 
3061
        {
 
3062
          stream << "    case ARG_DOUBLE:";
 
3063
          stream << "\n";
 
3064
          stream << indent_str;
 
3065
          stream << "      *((double **)field) = (double *)realloc (*((double **)field), (field_given + prev_given) * sizeof (double)); break;";
 
3066
          stream << "\n";
 
3067
          stream << indent_str;
 
3068
        }
 
3069
      if (has_arg_longdouble)
 
3070
        {
 
3071
          stream << "    case ARG_LONGDOUBLE:";
 
3072
          stream << "\n";
 
3073
          stream << indent_str;
 
3074
          stream << "      *((long double **)field) = (long double *)realloc (*((long double **)field), (field_given + prev_given) * sizeof (long double)); break;";
 
3075
          stream << "\n";
 
3076
          stream << indent_str;
 
3077
        }
 
3078
      if (has_arg_longlong)
 
3079
        {
 
3080
          stream << "    case ARG_LONGLONG:";
 
3081
          stream << "\n";
 
3082
          stream << indent_str;
 
3083
          stream << "#ifdef HAVE_LONG_LONG";
 
3084
          stream << "\n";
 
3085
          stream << indent_str;
 
3086
          stream << "      *((long long int **)field) = (long long int *)realloc (*((long long int **)field), (field_given + prev_given) * sizeof (long long int)); break;";
 
3087
          stream << "\n";
 
3088
          stream << indent_str;
 
3089
          stream << "#else";
 
3090
          stream << "\n";
 
3091
          stream << indent_str;
 
3092
          stream << "      *((long **)field) = (long *)realloc (*((long **)field), (field_given + prev_given) * sizeof (long)); break;";
 
3093
          stream << "\n";
 
3094
          stream << indent_str;
 
3095
          stream << "#endif";
 
3096
          stream << "\n";
 
3097
          stream << indent_str;
 
3098
        }
 
3099
      if (has_arg_string)
 
3100
        {
 
3101
          stream << "    case ARG_STRING:";
 
3102
          stream << "\n";
 
3103
          stream << indent_str;
 
3104
          stream << "      *((char ***)field) = (char **)realloc (*((char ***)field), (field_given + prev_given) * sizeof (char *)); break;";
 
3105
          stream << "\n";
 
3106
          stream << indent_str;
 
3107
        }
 
3108
      stream << "    default:";
 
3109
      stream << "\n";
 
3110
      stream << indent_str;
 
3111
      stream << "      break;";
 
3112
      stream << "\n";
 
3113
      stream << indent_str;
 
3114
      stream << "    };";
 
3115
      stream << "\n";
 
3116
      stream << indent_str;
 
3117
      indent = 4;
 
3118
      stream << "    ";
 
3119
      indent = 0;
 
3120
      stream << "\n";
 
3121
      stream << indent_str;
 
3122
      stream << "    for (i = (prev_given - 1); i >= 0; --i)";
 
3123
      stream << "\n";
 
3124
      stream << indent_str;
 
3125
      stream << "      {";
 
3126
      stream << "\n";
 
3127
      stream << indent_str;
 
3128
      stream << "        tmp = list;";
 
3129
      stream << "\n";
 
3130
      stream << indent_str;
 
3131
      indent = 8;
 
3132
      stream << "        ";
 
3133
      indent = 0;
 
3134
      stream << "\n";
 
3135
      stream << indent_str;
 
3136
      stream << "        switch(arg_type) {";
 
3137
      stream << "\n";
 
3138
      stream << indent_str;
 
3139
      if (has_arg_int)
 
3140
        {
 
3141
          stream << "        case ARG_INT:";
 
3142
          stream << "\n";
 
3143
          stream << indent_str;
 
3144
          stream << "          (*((int **)field))[i + field_given] = tmp->arg.int_arg; break;";
 
3145
          stream << "\n";
 
3146
          stream << indent_str;
 
3147
        }
 
3148
      if (has_arg_short)
 
3149
        {
 
3150
          stream << "        case ARG_SHORT:";
 
3151
          stream << "\n";
 
3152
          stream << indent_str;
 
3153
          stream << "          (*((short **)field))[i + field_given] = tmp->arg.short_arg; break;";
 
3154
          stream << "\n";
 
3155
          stream << indent_str;
 
3156
        }
 
3157
      if (has_arg_long)
 
3158
        {
 
3159
          stream << "        case ARG_LONG:";
 
3160
          stream << "\n";
 
3161
          stream << indent_str;
 
3162
          stream << "          (*((long **)field))[i + field_given] = tmp->arg.long_arg; break;";
 
3163
          stream << "\n";
 
3164
          stream << indent_str;
 
3165
        }
 
3166
      if (has_arg_float)
 
3167
        {
 
3168
          stream << "        case ARG_FLOAT:";
 
3169
          stream << "\n";
 
3170
          stream << indent_str;
 
3171
          stream << "          (*((float **)field))[i + field_given] = tmp->arg.float_arg; break;";
 
3172
          stream << "\n";
 
3173
          stream << indent_str;
 
3174
        }
 
3175
      if (has_arg_double)
 
3176
        {
 
3177
          stream << "        case ARG_DOUBLE:";
 
3178
          stream << "\n";
 
3179
          stream << indent_str;
 
3180
          stream << "          (*((double **)field))[i + field_given] = tmp->arg.double_arg; break;";
 
3181
          stream << "\n";
 
3182
          stream << indent_str;
 
3183
        }
 
3184
      if (has_arg_longdouble)
 
3185
        {
 
3186
          stream << "        case ARG_LONGDOUBLE:";
 
3187
          stream << "\n";
 
3188
          stream << indent_str;
 
3189
          stream << "          (*((long double **)field))[i + field_given] = tmp->arg.longdouble_arg; break;";
 
3190
          stream << "\n";
 
3191
          stream << indent_str;
 
3192
        }
 
3193
      if (has_arg_longlong)
 
3194
        {
 
3195
          stream << "        case ARG_LONGLONG:";
 
3196
          stream << "\n";
 
3197
          stream << indent_str;
 
3198
          stream << "#ifdef HAVE_LONG_LONG";
 
3199
          stream << "\n";
 
3200
          stream << indent_str;
 
3201
          stream << "          (*((long long int **)field))[i + field_given] = tmp->arg.longlong_arg; break;";
 
3202
          stream << "\n";
 
3203
          stream << indent_str;
 
3204
          stream << "#else";
 
3205
          stream << "\n";
 
3206
          stream << indent_str;
 
3207
          stream << "          (*((long **)field))[i + field_given] = tmp->arg.longlong_arg; break;";
 
3208
          stream << "\n";
 
3209
          stream << indent_str;
 
3210
          stream << "#endif";
 
3211
          stream << "\n";
 
3212
          stream << indent_str;
 
3213
        }
 
3214
      if (has_arg_enum)
 
3215
        {
 
3216
          stream << "        case ARG_ENUM:";
 
3217
          stream << "\n";
 
3218
          stream << indent_str;
 
3219
          stream << "          (*((int **)field))[i + field_given] = tmp->arg.int_arg; break;";
 
3220
          stream << "\n";
 
3221
          stream << indent_str;
 
3222
        }
 
3223
      if (has_arg_string)
 
3224
        {
 
3225
          stream << "        case ARG_STRING:";
 
3226
          stream << "\n";
 
3227
          stream << indent_str;
 
3228
          stream << "          (*((char ***)field))[i + field_given] = tmp->arg.string_arg; break;";
 
3229
          stream << "\n";
 
3230
          stream << indent_str;
 
3231
        }
 
3232
      stream << "        default:";
 
3233
      stream << "\n";
 
3234
      stream << indent_str;
 
3235
      stream << "          break;";
 
3236
      stream << "\n";
 
3237
      stream << indent_str;
 
3238
      stream << "        }        ";
 
3239
      stream << "\n";
 
3240
      stream << indent_str;
 
3241
      stream << "        (*orig_field) [i + field_given] = list->orig;";
 
3242
      stream << "\n";
 
3243
      stream << indent_str;
 
3244
      stream << "        list = list->next;";
 
3245
      stream << "\n";
 
3246
      stream << indent_str;
 
3247
      stream << "        free (tmp);";
 
3248
      stream << "\n";
 
3249
      stream << indent_str;
 
3250
      stream << "      }";
 
3251
      stream << "\n";
 
3252
      stream << indent_str;
 
3253
      stream << "  } else { /* set the default value */";
 
3254
      stream << "\n";
 
3255
      stream << indent_str;
 
3256
      stream << "    if (default_value && ! field_given) {";
 
3257
      stream << "\n";
 
3258
      stream << indent_str;
 
3259
      stream << "      switch(arg_type) {";
 
3260
      stream << "\n";
 
3261
      stream << indent_str;
 
3262
      if (( has_arg_int || has_arg_enum ))
 
3263
        {
 
3264
          if (has_arg_int)
 
3265
            {
 
3266
              stream << "      case ARG_INT:";
 
3267
              stream << "\n";
 
3268
              stream << indent_str;
 
3269
            }
 
3270
          if (has_arg_enum)
 
3271
            {
 
3272
              stream << "      case ARG_ENUM:";
 
3273
              stream << "\n";
 
3274
              stream << indent_str;
 
3275
            }
 
3276
          stream << "        if (! *((int **)field)) {";
 
3277
          stream << "\n";
 
3278
          stream << indent_str;
 
3279
          stream << "          *((int **)field) = (int *)malloc (sizeof (int));";
 
3280
          stream << "\n";
 
3281
          stream << indent_str;
 
3282
          stream << "          (*((int **)field))[0] = default_value->int_arg; ";
 
3283
          stream << "\n";
 
3284
          stream << indent_str;
 
3285
          stream << "        }";
 
3286
          stream << "\n";
 
3287
          stream << indent_str;
 
3288
          stream << "        break;";
 
3289
          stream << "\n";
 
3290
          stream << indent_str;
 
3291
        }
 
3292
      if (has_arg_short)
 
3293
        {
 
3294
          stream << "      case ARG_SHORT:";
 
3295
          stream << "\n";
 
3296
          stream << indent_str;
 
3297
          stream << "        if (! *((short **)field)) {";
 
3298
          stream << "\n";
 
3299
          stream << indent_str;
 
3300
          stream << "          *((short **)field) = (short *)malloc (sizeof (short));";
 
3301
          stream << "\n";
 
3302
          stream << indent_str;
 
3303
          stream << "          (*((short **)field))[0] = default_value->short_arg;";
 
3304
          stream << "\n";
 
3305
          stream << indent_str;
 
3306
          stream << "        }";
 
3307
          stream << "\n";
 
3308
          stream << indent_str;
 
3309
          stream << "        break;";
 
3310
          stream << "\n";
 
3311
          stream << indent_str;
 
3312
        }
 
3313
      if (has_arg_long)
 
3314
        {
 
3315
          stream << "      case ARG_LONG:";
 
3316
          stream << "\n";
 
3317
          stream << indent_str;
 
3318
          stream << "        if (! *((long **)field)) {";
 
3319
          stream << "\n";
 
3320
          stream << indent_str;
 
3321
          stream << "          *((long **)field) = (long *)malloc (sizeof (long));";
 
3322
          stream << "\n";
 
3323
          stream << indent_str;
 
3324
          stream << "          (*((long **)field))[0] = default_value->long_arg;";
 
3325
          stream << "\n";
 
3326
          stream << indent_str;
 
3327
          stream << "        }";
 
3328
          stream << "\n";
 
3329
          stream << indent_str;
 
3330
          stream << "        break;";
 
3331
          stream << "\n";
 
3332
          stream << indent_str;
 
3333
        }
 
3334
      if (has_arg_float)
 
3335
        {
 
3336
          stream << "      case ARG_FLOAT:";
 
3337
          stream << "\n";
 
3338
          stream << indent_str;
 
3339
          stream << "        if (! *((float **)field)) {";
 
3340
          stream << "\n";
 
3341
          stream << indent_str;
 
3342
          stream << "          *((float **)field) = (float *)malloc (sizeof (float));";
 
3343
          stream << "\n";
 
3344
          stream << indent_str;
 
3345
          stream << "          (*((float **)field))[0] = default_value->float_arg;";
 
3346
          stream << "\n";
 
3347
          stream << indent_str;
 
3348
          stream << "        }";
 
3349
          stream << "\n";
 
3350
          stream << indent_str;
 
3351
          stream << "        break;";
 
3352
          stream << "\n";
 
3353
          stream << indent_str;
 
3354
        }
 
3355
      if (has_arg_double)
 
3356
        {
 
3357
          stream << "      case ARG_DOUBLE:";
 
3358
          stream << "\n";
 
3359
          stream << indent_str;
 
3360
          stream << "        if (! *((double **)field)) {";
 
3361
          stream << "\n";
 
3362
          stream << indent_str;
 
3363
          stream << "          *((double **)field) = (double *)malloc (sizeof (double));";
 
3364
          stream << "\n";
 
3365
          stream << indent_str;
 
3366
          stream << "          (*((double **)field))[0] = default_value->double_arg;";
 
3367
          stream << "\n";
 
3368
          stream << indent_str;
 
3369
          stream << "        }";
 
3370
          stream << "\n";
 
3371
          stream << indent_str;
 
3372
          stream << "        break;";
 
3373
          stream << "\n";
 
3374
          stream << indent_str;
 
3375
        }
 
3376
      if (has_arg_longdouble)
 
3377
        {
 
3378
          stream << "      case ARG_LONGDOUBLE:";
 
3379
          stream << "\n";
 
3380
          stream << indent_str;
 
3381
          stream << "        if (! *((long double **)field)) {";
 
3382
          stream << "\n";
 
3383
          stream << indent_str;
 
3384
          stream << "          *((long double **)field) = (long double *)malloc (sizeof (long double));";
 
3385
          stream << "\n";
 
3386
          stream << indent_str;
 
3387
          stream << "          (*((long double **)field))[0] = default_value->longdouble_arg;";
 
3388
          stream << "\n";
 
3389
          stream << indent_str;
 
3390
          stream << "        }";
 
3391
          stream << "\n";
 
3392
          stream << indent_str;
 
3393
          stream << "        break;";
 
3394
          stream << "\n";
 
3395
          stream << indent_str;
 
3396
        }
 
3397
      if (has_arg_longlong)
 
3398
        {
 
3399
          stream << "      case ARG_LONGLONG:";
 
3400
          stream << "\n";
 
3401
          stream << indent_str;
 
3402
          stream << "#ifdef HAVE_LONG_LONG";
 
3403
          stream << "\n";
 
3404
          stream << indent_str;
 
3405
          stream << "        if (! *((long long int **)field)) {";
 
3406
          stream << "\n";
 
3407
          stream << indent_str;
 
3408
          stream << "          *((long long int **)field) = (long long int *)malloc (sizeof (long long int));";
 
3409
          stream << "\n";
 
3410
          stream << indent_str;
 
3411
          stream << "          (*((long long int **)field))[0] = default_value->longlong_arg;";
 
3412
          stream << "\n";
 
3413
          stream << indent_str;
 
3414
          stream << "        }";
 
3415
          stream << "\n";
 
3416
          stream << indent_str;
 
3417
          stream << "#else";
 
3418
          stream << "\n";
 
3419
          stream << indent_str;
 
3420
          stream << "        if (! *((long **)field)) {";
 
3421
          stream << "\n";
 
3422
          stream << indent_str;
 
3423
          stream << "          *((long **)field) = (long *)malloc (sizeof (long));";
 
3424
          stream << "\n";
 
3425
          stream << indent_str;
 
3426
          stream << "          (*((long **)field))[0] = default_value->longlong_arg;";
 
3427
          stream << "\n";
 
3428
          stream << indent_str;
 
3429
          stream << "        }";
 
3430
          stream << "\n";
 
3431
          stream << indent_str;
 
3432
          stream << "#endif";
 
3433
          stream << "\n";
 
3434
          stream << indent_str;
 
3435
          stream << "        break;";
 
3436
          stream << "\n";
 
3437
          stream << indent_str;
 
3438
        }
 
3439
      if (has_arg_string)
 
3440
        {
 
3441
          stream << "      case ARG_STRING:";
 
3442
          stream << "\n";
 
3443
          stream << indent_str;
 
3444
          stream << "        if (! *((char ***)field)) {";
 
3445
          stream << "\n";
 
3446
          stream << indent_str;
 
3447
          stream << "          *((char ***)field) = (char **)malloc (sizeof (char *));";
 
3448
          stream << "\n";
 
3449
          stream << indent_str;
 
3450
          stream << "          (*((char ***)field))[0] = gengetopt_strdup(default_value->string_arg);";
 
3451
          stream << "\n";
 
3452
          stream << indent_str;
 
3453
          stream << "        }";
 
3454
          stream << "\n";
 
3455
          stream << indent_str;
 
3456
          stream << "        break;";
 
3457
          stream << "\n";
 
3458
          stream << indent_str;
 
3459
        }
 
3460
      stream << "      default: break;";
 
3461
      stream << "\n";
 
3462
      stream << indent_str;
 
3463
      stream << "      }";
 
3464
      stream << "\n";
 
3465
      stream << indent_str;
 
3466
      stream << "      if (!(*orig_field)) {";
 
3467
      stream << "\n";
 
3468
      stream << indent_str;
 
3469
      stream << "        *orig_field = (char **) malloc (sizeof (char *));";
 
3470
      stream << "\n";
 
3471
      stream << indent_str;
 
3472
      stream << "        (*orig_field)[0] = NULL;";
 
3473
      stream << "\n";
 
3474
      stream << indent_str;
 
3475
      stream << "      }";
 
3476
      stream << "\n";
 
3477
      stream << indent_str;
 
3478
      stream << "    }";
 
3479
      stream << "\n";
 
3480
      stream << indent_str;
 
3481
      stream << "  }";
 
3482
      stream << "\n";
 
3483
      stream << indent_str;
 
3484
      stream << "}";
 
3485
      stream << "\n";
 
3486
      stream << indent_str;
 
3487
    }
 
3488
  if (has_modes)
 
3489
    {
 
3490
      stream << "\n";
 
3491
      stream << indent_str;
 
3492
      stream << "static int check_modes(int given1[], const char *options1[],";
 
3493
      stream << "\n";
 
3494
      stream << indent_str;
 
3495
      stream << "                       int given2[], const char *options2[])";
 
3496
      stream << "\n";
 
3497
      stream << indent_str;
 
3498
      stream << "{";
 
3499
      stream << "\n";
 
3500
      stream << indent_str;
 
3501
      stream << "  int i = 0, j = 0, errors = 0;";
 
3502
      stream << "\n";
 
3503
      stream << indent_str;
 
3504
      indent = 2;
 
3505
      stream << "  ";
 
3506
      indent = 0;
 
3507
      stream << "\n";
 
3508
      stream << indent_str;
 
3509
      stream << "  while (given1[i] >= 0) {";
 
3510
      stream << "\n";
 
3511
      stream << indent_str;
 
3512
      stream << "    if (given1[i]) {";
 
3513
      stream << "\n";
 
3514
      stream << indent_str;
 
3515
      stream << "      while (given2[j] >= 0) {";
 
3516
      stream << "\n";
 
3517
      stream << indent_str;
 
3518
      stream << "        if (given2[j]) {";
 
3519
      stream << "\n";
 
3520
      stream << indent_str;
 
3521
      stream << "          ++errors;";
 
3522
      stream << "\n";
 
3523
      stream << indent_str;
 
3524
      stream << "          fprintf(stderr, \"%s: option %s conflicts with option %s\\n\",";
 
3525
      stream << "\n";
 
3526
      stream << indent_str;
 
3527
      stream << "                  package_name, options1[i], options2[j]);";
 
3528
      stream << "\n";
 
3529
      stream << indent_str;
 
3530
      stream << "        }";
 
3531
      stream << "\n";
 
3532
      stream << indent_str;
 
3533
      stream << "        ++j;";
 
3534
      stream << "\n";
 
3535
      stream << indent_str;
 
3536
      stream << "      }";
 
3537
      stream << "\n";
 
3538
      stream << indent_str;
 
3539
      stream << "    }";
 
3540
      stream << "\n";
 
3541
      stream << indent_str;
 
3542
      stream << "    ++i;";
 
3543
      stream << "\n";
 
3544
      stream << indent_str;
 
3545
      stream << "  }";
 
3546
      stream << "\n";
 
3547
      stream << indent_str;
 
3548
      indent = 2;
 
3549
      stream << "  ";
 
3550
      indent = 0;
 
3551
      stream << "\n";
 
3552
      stream << indent_str;
 
3553
      stream << "  return errors;";
 
3554
      stream << "\n";
 
3555
      stream << indent_str;
 
3556
      stream << "}";
 
3557
      stream << "\n";
 
3558
      stream << indent_str;
 
3559
    }
 
3560
  stream << "\n";
 
3561
  stream << indent_str;
1532
3562
  stream << "int";
1533
3563
  stream << "\n";
1534
3564
  stream << indent_str;
1549
3579
  stream << "  int c;   /* Character of the parsed option.  */";
1550
3580
  stream << "\n";
1551
3581
  stream << indent_str;
1552
 
  if (multiple_token_vars)
 
3582
  if (multiple_options_with_default)
1553
3583
    {
1554
 
      stream << "  char *multi_token, *multi_next; /* for multiple options */";
 
3584
      stream << "  union generic_value multiple_default_value;";
1555
3585
      stream << "\n";
1556
3586
      stream << indent_str;
1557
3587
    }
1594
3624
  indent = 0;
1595
3625
  stream << "\n";
1596
3626
  stream << indent_str;
 
3627
  stream << "  package_name = argv[0];";
 
3628
  stream << "\n";
 
3629
  stream << indent_str;
 
3630
  indent = 2;
 
3631
  stream << "  ";
 
3632
  indent = 0;
 
3633
  stream << "\n";
 
3634
  stream << indent_str;
1597
3635
  stream << "  override = params->override;";
1598
3636
  stream << "\n";
1599
3637
  stream << indent_str;
1635
3673
  stream << "  optind = 0;";
1636
3674
  stream << "\n";
1637
3675
  stream << indent_str;
1638
 
  stream << "  opterr = 1;";
 
3676
  stream << "  opterr = params->print_errors;";
1639
3677
  stream << "\n";
1640
3678
  stream << indent_str;
1641
3679
  stream << "  optopt = '?';";
1649
3687
  stream << "    {";
1650
3688
  stream << "\n";
1651
3689
  stream << indent_str;
1652
 
  if (check_possible_values)
1653
 
    {
1654
 
      stream << "      int found = 0;";
1655
 
      stream << "\n";
1656
 
      stream << indent_str;
1657
 
    }
1658
3690
  stream << "      int option_index = 0;";
1659
3691
  stream << "\n";
1660
3692
  stream << indent_str;
1661
 
  stream << "      char *stop_char;";
1662
 
  stream << "\n";
1663
 
  stream << indent_str;
1664
3693
  stream << "\n";
1665
3694
  stream << indent_str;
1666
3695
  stream << "      static struct option long_options[] = {";
1681
3710
  stream << indent_str;
1682
3711
  stream << "\n";
1683
3712
  stream << indent_str;
1684
 
  stream << "      stop_char = 0;";
1685
 
  stream << "\n";
1686
 
  stream << indent_str;
1687
3713
  if (include_getopt)
1688
3714
    {
1689
3715
      stream << "      custom_optarg = optarg;";
1760
3786
    generate_handle_no_short_option (stream, indent + indent_str.length ());
1761
3787
  indent = 0;
1762
3788
  stream << indent_str;
1763
 
  stream << "        case '?':  /* Invalid option.  */";
1764
 
  stream << "\n";
1765
 
  stream << indent_str;
1766
 
  stream << "          /* `getopt_long' already printed an error message.  */";
1767
 
  stream << "\n";
1768
 
  stream << indent_str;
1769
 
  stream << "          goto failure;";
1770
 
  stream << "\n";
1771
 
  stream << indent_str;
 
3789
  if (handle_question_mark)
 
3790
    {
 
3791
      stream << "        case '?':      /* Invalid option.  */";
 
3792
      stream << "\n";
 
3793
      stream << indent_str;
 
3794
      stream << "          /* `getopt_long' already printed an error message.  */";
 
3795
      stream << "\n";
 
3796
      stream << indent_str;
 
3797
      stream << "          goto failure;";
 
3798
      stream << "\n";
 
3799
      stream << indent_str;
 
3800
    }
1772
3801
  stream << "\n";
1773
3802
  stream << indent_str;
1774
3803
  stream << "        default:   /* bug: option not considered.  */";
1813
3842
    generate_update_multiple_given (stream, indent + indent_str.length ());
1814
3843
  indent = 0;
1815
3844
  stream << indent_str;
 
3845
  indent = 2;
 
3846
  if (check_modes.size () > 0)
 
3847
    generate_string (check_modes, stream, indent + indent_str.length ());
 
3848
  else
 
3849
    generate_check_modes (stream, indent + indent_str.length ());
 
3850
  indent = 0;
 
3851
  stream << indent_str;
1816
3852
  stream << "\n";
1817
3853
  stream << indent_str;
1818
3854
  if (check_required_options)
2451
4487
      stream << "  params.check_ambiguity = 0;";
2452
4488
      stream << "\n";
2453
4489
      stream << indent_str;
 
4490
      stream << "  params.print_errors = 1;";
 
4491
      stream << "\n";
 
4492
      stream << indent_str;
2454
4493
      indent = 2;
2455
4494
      stream << "  ";
2456
4495
      indent = 0;
2837
4876
      stream << "  params.check_ambiguity = 0;";
2838
4877
      stream << "\n";
2839
4878
      stream << indent_str;
 
4879
      stream << "  params.print_errors = 1;";
 
4880
      stream << "\n";
 
4881
      stream << indent_str;
2840
4882
      stream << "\n";
2841
4883
      stream << indent_str;
2842
4884
      stream << "  return ";