1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
<title>LibOFX: getopt.c Source File</title>
<link href="doxygen.css" rel="stylesheet" type="text/css">
<link href="tabs.css" rel="stylesheet" type="text/css">
</head><body>
<!-- Generated by Doxygen 1.5.3 -->
<div class="tabs">
<ul>
<li><a href="main.html"><span>Main Page</span></a></li>
<li><a href="namespaces.html"><span>Namespaces</span></a></li>
<li><a href="annotated.html"><span>Data Structures</span></a></li>
<li class="current"><a href="files.html"><span>Files</span></a></li>
</ul>
</div>
<h1>getopt.c</h1><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 <span class="comment">/* Getopt for GNU.</span>
<a name="l00002"></a>00002 <span class="comment"> NOTE: getopt is now part of the C library, so if you don't know what</span>
<a name="l00003"></a>00003 <span class="comment"> "Keep this file name-space clean" means, talk to drepper@gnu.org</span>
<a name="l00004"></a>00004 <span class="comment"> before changing it!</span>
<a name="l00005"></a>00005 <span class="comment"> Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001</span>
<a name="l00006"></a>00006 <span class="comment"> Free Software Foundation, Inc.</span>
<a name="l00007"></a>00007 <span class="comment"> This file is part of the GNU C Library.</span>
<a name="l00008"></a>00008 <span class="comment"></span>
<a name="l00009"></a>00009 <span class="comment"> The GNU C Library is free software; you can redistribute it and/or</span>
<a name="l00010"></a>00010 <span class="comment"> modify it under the terms of the GNU Lesser General Public</span>
<a name="l00011"></a>00011 <span class="comment"> License as published by the Free Software Foundation; either</span>
<a name="l00012"></a>00012 <span class="comment"> version 2.1 of the License, or (at your option) any later version.</span>
<a name="l00013"></a>00013 <span class="comment"></span>
<a name="l00014"></a>00014 <span class="comment"> The GNU C Library is distributed in the hope that it will be useful,</span>
<a name="l00015"></a>00015 <span class="comment"> but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<a name="l00016"></a>00016 <span class="comment"> MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU</span>
<a name="l00017"></a>00017 <span class="comment"> Lesser General Public License for more details.</span>
<a name="l00018"></a>00018 <span class="comment"></span>
<a name="l00019"></a>00019 <span class="comment"> You should have received a copy of the GNU Lesser General Public</span>
<a name="l00020"></a>00020 <span class="comment"> License along with the GNU C Library; if not, write to the Free</span>
<a name="l00021"></a>00021 <span class="comment"> Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA</span>
<a name="l00022"></a>00022 <span class="comment"> 02111-1307 USA. */</span>
<a name="l00023"></a>00023
<a name="l00024"></a>00024 <span class="comment">/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.</span>
<a name="l00025"></a>00025 <span class="comment"> Ditto for AIX 3.2 and <stdlib.h>. */</span>
<a name="l00026"></a>00026 <span class="preprocessor">#ifndef _NO_PROTO</span>
<a name="l00027"></a>00027 <span class="preprocessor"></span><span class="preprocessor"># define _NO_PROTO</span>
<a name="l00028"></a>00028 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00029"></a>00029 <span class="preprocessor"></span>
<a name="l00030"></a>00030 <span class="preprocessor">#ifdef HAVE_CONFIG_H</span>
<a name="l00031"></a>00031 <span class="preprocessor"></span><span class="preprocessor"># include <config.h></span>
<a name="l00032"></a>00032 <span class="preprocessor">#endif</span>
<a name="l00033"></a>00033 <span class="preprocessor"></span>
<a name="l00034"></a>00034 <span class="preprocessor">#if !defined __STDC__ || !__STDC__</span>
<a name="l00035"></a>00035 <span class="preprocessor"></span><span class="comment">/* This is a separate conditional since some stdc systems</span>
<a name="l00036"></a>00036 <span class="comment"> reject `defined (const)'. */</span>
<a name="l00037"></a>00037 <span class="preprocessor"># ifndef const</span>
<a name="l00038"></a>00038 <span class="preprocessor"></span><span class="preprocessor"># define const</span>
<a name="l00039"></a>00039 <span class="preprocessor"></span><span class="preprocessor"># endif</span>
<a name="l00040"></a>00040 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00041"></a>00041 <span class="preprocessor"></span>
<a name="l00042"></a>00042 <span class="preprocessor">#include <stdio.h></span>
<a name="l00043"></a>00043
<a name="l00044"></a>00044 <span class="comment">/* Comment out all this code if we are using the GNU C Library, and are not</span>
<a name="l00045"></a>00045 <span class="comment"> actually compiling the library itself. This code is part of the GNU C</span>
<a name="l00046"></a>00046 <span class="comment"> Library, but also included in many other GNU distributions. Compiling</span>
<a name="l00047"></a>00047 <span class="comment"> and linking in this code is a waste when using the GNU C library</span>
<a name="l00048"></a>00048 <span class="comment"> (especially if it is a shared library). Rather than having every GNU</span>
<a name="l00049"></a>00049 <span class="comment"> program understand `configure --with-gnu-libc' and omit the object files,</span>
<a name="l00050"></a>00050 <span class="comment"> it is simpler to just do this in the source for each such file. */</span>
<a name="l00051"></a>00051
<a name="l00052"></a>00052 <span class="preprocessor">#define GETOPT_INTERFACE_VERSION 2</span>
<a name="l00053"></a>00053 <span class="preprocessor"></span><span class="preprocessor">#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2</span>
<a name="l00054"></a>00054 <span class="preprocessor"></span><span class="preprocessor"># include <gnu-versions.h></span>
<a name="l00055"></a>00055 <span class="preprocessor"># if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION</span>
<a name="l00056"></a>00056 <span class="preprocessor"></span><span class="preprocessor"># define ELIDE_CODE</span>
<a name="l00057"></a>00057 <span class="preprocessor"></span><span class="preprocessor"># endif</span>
<a name="l00058"></a>00058 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00059"></a>00059 <span class="preprocessor"></span>
<a name="l00060"></a>00060 <span class="preprocessor">#ifndef ELIDE_CODE</span>
<a name="l00061"></a>00061 <span class="preprocessor"></span>
<a name="l00062"></a>00062
<a name="l00063"></a>00063 <span class="comment">/* This needs to come after some library #include</span>
<a name="l00064"></a>00064 <span class="comment"> to get __GNU_LIBRARY__ defined. */</span>
<a name="l00065"></a>00065 <span class="preprocessor">#ifdef __GNU_LIBRARY__</span>
<a name="l00066"></a>00066 <span class="preprocessor"></span><span class="comment">/* Don't include stdlib.h for non-GNU C libraries because some of them</span>
<a name="l00067"></a>00067 <span class="comment"> contain conflicting prototypes for getopt. */</span>
<a name="l00068"></a>00068 <span class="preprocessor"># include <stdlib.h></span>
<a name="l00069"></a>00069 <span class="preprocessor"># include <unistd.h></span>
<a name="l00070"></a>00070 <span class="preprocessor">#endif </span><span class="comment">/* GNU C library. */</span>
<a name="l00071"></a>00071
<a name="l00072"></a>00072 <span class="preprocessor">#ifdef VMS</span>
<a name="l00073"></a>00073 <span class="preprocessor"></span><span class="preprocessor"># include <unixlib.h></span>
<a name="l00074"></a>00074 <span class="preprocessor"># if HAVE_STRING_H - 0</span>
<a name="l00075"></a>00075 <span class="preprocessor"></span><span class="preprocessor"># include <string.h></span>
<a name="l00076"></a>00076 <span class="preprocessor"># endif</span>
<a name="l00077"></a>00077 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00078"></a>00078 <span class="preprocessor"></span>
<a name="l00079"></a>00079 <span class="preprocessor">#ifndef _</span>
<a name="l00080"></a>00080 <span class="preprocessor"></span><span class="comment">/* This is for other GNU distributions with internationalized messages. */</span>
<a name="l00081"></a>00081 <span class="preprocessor"># if defined HAVE_LIBINTL_H || defined _LIBC</span>
<a name="l00082"></a>00082 <span class="preprocessor"></span><span class="preprocessor"># include <libintl.h></span>
<a name="l00083"></a>00083 <span class="preprocessor"># ifndef _</span>
<a name="l00084"></a>00084 <span class="preprocessor"></span><span class="preprocessor"># define _(msgid) gettext (msgid)</span>
<a name="l00085"></a>00085 <span class="preprocessor"></span><span class="preprocessor"># endif</span>
<a name="l00086"></a>00086 <span class="preprocessor"></span><span class="preprocessor"># else</span>
<a name="l00087"></a>00087 <span class="preprocessor"></span><span class="preprocessor"># define _(msgid) (msgid)</span>
<a name="l00088"></a>00088 <span class="preprocessor"></span><span class="preprocessor"># endif</span>
<a name="l00089"></a>00089 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00090"></a>00090 <span class="preprocessor"></span>
<a name="l00091"></a>00091 <span class="comment">/* This version of `getopt' appears to the caller like standard Unix `getopt'</span>
<a name="l00092"></a>00092 <span class="comment"> but it behaves differently for the user, since it allows the user</span>
<a name="l00093"></a>00093 <span class="comment"> to intersperse the options with the other arguments.</span>
<a name="l00094"></a>00094 <span class="comment"></span>
<a name="l00095"></a>00095 <span class="comment"> As `getopt' works, it permutes the elements of ARGV so that,</span>
<a name="l00096"></a>00096 <span class="comment"> when it is done, all the options precede everything else. Thus</span>
<a name="l00097"></a>00097 <span class="comment"> all application programs are extended to handle flexible argument order.</span>
<a name="l00098"></a>00098 <span class="comment"></span>
<a name="l00099"></a>00099 <span class="comment"> Setting the environment variable POSIXLY_CORRECT disables permutation.</span>
<a name="l00100"></a>00100 <span class="comment"> Then the behavior is completely standard.</span>
<a name="l00101"></a>00101 <span class="comment"></span>
<a name="l00102"></a>00102 <span class="comment"> GNU application programs can use a third alternative mode in which</span>
<a name="l00103"></a>00103 <span class="comment"> they can distinguish the relative order of options and other arguments. */</span>
<a name="l00104"></a>00104
<a name="l00105"></a>00105 <span class="preprocessor">#include "getopt.h"</span>
<a name="l00106"></a>00106
<a name="l00107"></a>00107 <span class="comment">/* For communication from `getopt' to the caller.</span>
<a name="l00108"></a>00108 <span class="comment"> When `getopt' finds an option that takes an argument,</span>
<a name="l00109"></a>00109 <span class="comment"> the argument value is returned here.</span>
<a name="l00110"></a>00110 <span class="comment"> Also, when `ordering' is RETURN_IN_ORDER,</span>
<a name="l00111"></a>00111 <span class="comment"> each non-option ARGV-element is returned here. */</span>
<a name="l00112"></a>00112
<a name="l00113"></a>00113 <span class="keywordtype">char</span> *optarg;
<a name="l00114"></a>00114
<a name="l00115"></a>00115 <span class="comment">/* Index in ARGV of the next element to be scanned.</span>
<a name="l00116"></a>00116 <span class="comment"> This is used for communication to and from the caller</span>
<a name="l00117"></a>00117 <span class="comment"> and for communication between successive calls to `getopt'.</span>
<a name="l00118"></a>00118 <span class="comment"></span>
<a name="l00119"></a>00119 <span class="comment"> On entry to `getopt', zero means this is the first call; initialize.</span>
<a name="l00120"></a>00120 <span class="comment"></span>
<a name="l00121"></a>00121 <span class="comment"> When `getopt' returns -1, this is the index of the first of the</span>
<a name="l00122"></a>00122 <span class="comment"> non-option elements that the caller should itself scan.</span>
<a name="l00123"></a>00123 <span class="comment"></span>
<a name="l00124"></a>00124 <span class="comment"> Otherwise, `optind' communicates from one call to the next</span>
<a name="l00125"></a>00125 <span class="comment"> how much of ARGV has been scanned so far. */</span>
<a name="l00126"></a>00126
<a name="l00127"></a>00127 <span class="comment">/* 1003.2 says this must be 1 before any call. */</span>
<a name="l00128"></a>00128 <span class="keywordtype">int</span> optind = 1;
<a name="l00129"></a>00129
<a name="l00130"></a>00130 <span class="comment">/* Formerly, initialization of getopt depended on optind==0, which</span>
<a name="l00131"></a>00131 <span class="comment"> causes problems with re-calling getopt as programs generally don't</span>
<a name="l00132"></a>00132 <span class="comment"> know that. */</span>
<a name="l00133"></a>00133
<a name="l00134"></a>00134 <span class="keywordtype">int</span> __getopt_initialized;
<a name="l00135"></a>00135
<a name="l00136"></a>00136 <span class="comment">/* The next char to be scanned in the option-element</span>
<a name="l00137"></a>00137 <span class="comment"> in which the last option character we returned was found.</span>
<a name="l00138"></a>00138 <span class="comment"> This allows us to pick up the scan where we left off.</span>
<a name="l00139"></a>00139 <span class="comment"></span>
<a name="l00140"></a>00140 <span class="comment"> If this is zero, or a null string, it means resume the scan</span>
<a name="l00141"></a>00141 <span class="comment"> by advancing to the next ARGV-element. */</span>
<a name="l00142"></a>00142
<a name="l00143"></a>00143 <span class="keyword">static</span> <span class="keywordtype">char</span> *nextchar;
<a name="l00144"></a>00144
<a name="l00145"></a>00145 <span class="comment">/* Callers store zero here to inhibit the error message</span>
<a name="l00146"></a>00146 <span class="comment"> for unrecognized options. */</span>
<a name="l00147"></a>00147
<a name="l00148"></a>00148 <span class="keywordtype">int</span> opterr = 1;
<a name="l00149"></a>00149
<a name="l00150"></a>00150 <span class="comment">/* Set to an option character which was unrecognized.</span>
<a name="l00151"></a>00151 <span class="comment"> This must be initialized on some systems to avoid linking in the</span>
<a name="l00152"></a>00152 <span class="comment"> system's own getopt implementation. */</span>
<a name="l00153"></a>00153
<a name="l00154"></a>00154 <span class="keywordtype">int</span> optopt = <span class="charliteral">'?'</span>;
<a name="l00155"></a>00155
<a name="l00156"></a>00156 <span class="comment">/* Describe how to deal with options that follow non-option ARGV-elements.</span>
<a name="l00157"></a>00157 <span class="comment"></span>
<a name="l00158"></a>00158 <span class="comment"> If the caller did not specify anything,</span>
<a name="l00159"></a>00159 <span class="comment"> the default is REQUIRE_ORDER if the environment variable</span>
<a name="l00160"></a>00160 <span class="comment"> POSIXLY_CORRECT is defined, PERMUTE otherwise.</span>
<a name="l00161"></a>00161 <span class="comment"></span>
<a name="l00162"></a>00162 <span class="comment"> REQUIRE_ORDER means don't recognize them as options;</span>
<a name="l00163"></a>00163 <span class="comment"> stop option processing when the first non-option is seen.</span>
<a name="l00164"></a>00164 <span class="comment"> This is what Unix does.</span>
<a name="l00165"></a>00165 <span class="comment"> This mode of operation is selected by either setting the environment</span>
<a name="l00166"></a>00166 <span class="comment"> variable POSIXLY_CORRECT, or using `+' as the first character</span>
<a name="l00167"></a>00167 <span class="comment"> of the list of option characters.</span>
<a name="l00168"></a>00168 <span class="comment"></span>
<a name="l00169"></a>00169 <span class="comment"> PERMUTE is the default. We permute the contents of ARGV as we scan,</span>
<a name="l00170"></a>00170 <span class="comment"> so that eventually all the non-options are at the end. This allows options</span>
<a name="l00171"></a>00171 <span class="comment"> to be given in any order, even with programs that were not written to</span>
<a name="l00172"></a>00172 <span class="comment"> expect this.</span>
<a name="l00173"></a>00173 <span class="comment"></span>
<a name="l00174"></a>00174 <span class="comment"> RETURN_IN_ORDER is an option available to programs that were written</span>
<a name="l00175"></a>00175 <span class="comment"> to expect options and other ARGV-elements in any order and that care about</span>
<a name="l00176"></a>00176 <span class="comment"> the ordering of the two. We describe each non-option ARGV-element</span>
<a name="l00177"></a>00177 <span class="comment"> as if it were the argument of an option with character code 1.</span>
<a name="l00178"></a>00178 <span class="comment"> Using `-' as the first character of the list of option characters</span>
<a name="l00179"></a>00179 <span class="comment"> selects this mode of operation.</span>
<a name="l00180"></a>00180 <span class="comment"></span>
<a name="l00181"></a>00181 <span class="comment"> The special argument `--' forces an end of option-scanning regardless</span>
<a name="l00182"></a>00182 <span class="comment"> of the value of `ordering'. In the case of RETURN_IN_ORDER, only</span>
<a name="l00183"></a>00183 <span class="comment"> `--' can cause `getopt' to return -1 with `optind' != ARGC. */</span>
<a name="l00184"></a>00184
<a name="l00185"></a>00185 <span class="keyword">static</span> <span class="keyword">enum</span>
<a name="l00186"></a>00186 {
<a name="l00187"></a>00187 REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
<a name="l00188"></a>00188 } ordering;
<a name="l00189"></a>00189
<a name="l00190"></a>00190 <span class="comment">/* Value of POSIXLY_CORRECT environment variable. */</span>
<a name="l00191"></a>00191 <span class="keyword">static</span> <span class="keywordtype">char</span> *posixly_correct;
<a name="l00192"></a>00192
<a name="l00193"></a>00193 <span class="preprocessor">#ifdef __GNU_LIBRARY__</span>
<a name="l00194"></a>00194 <span class="preprocessor"></span><span class="comment">/* We want to avoid inclusion of string.h with non-GNU libraries</span>
<a name="l00195"></a>00195 <span class="comment"> because there are many ways it can cause trouble.</span>
<a name="l00196"></a>00196 <span class="comment"> On some systems, it contains special magic macros that don't work</span>
<a name="l00197"></a>00197 <span class="comment"> in GCC. */</span>
<a name="l00198"></a>00198 <span class="preprocessor"># include <string.h></span>
<a name="l00199"></a>00199 <span class="preprocessor"># define my_index strchr</span>
<a name="l00200"></a>00200 <span class="preprocessor"></span><span class="preprocessor">#else</span>
<a name="l00201"></a>00201 <span class="preprocessor"></span>
<a name="l00202"></a>00202 <span class="preprocessor"># if HAVE_STRING_H</span>
<a name="l00203"></a>00203 <span class="preprocessor"></span><span class="preprocessor"># include <string.h></span>
<a name="l00204"></a>00204 <span class="preprocessor"># else</span>
<a name="l00205"></a>00205 <span class="preprocessor"></span><span class="preprocessor"># include <strings.h></span>
<a name="l00206"></a>00206 <span class="preprocessor"># endif</span>
<a name="l00207"></a>00207 <span class="preprocessor"></span>
<a name="l00208"></a>00208 <span class="comment">/* Avoid depending on library functions or files</span>
<a name="l00209"></a>00209 <span class="comment"> whose names are inconsistent. */</span>
<a name="l00210"></a>00210
<a name="l00211"></a>00211 <span class="preprocessor">#ifndef getenv</span>
<a name="l00212"></a>00212 <span class="preprocessor"></span><span class="keyword">extern</span> <span class="keywordtype">char</span> *getenv ();
<a name="l00213"></a>00213 <span class="preprocessor">#endif</span>
<a name="l00214"></a>00214 <span class="preprocessor"></span>
<a name="l00215"></a>00215 <span class="keyword">static</span> <span class="keywordtype">char</span> *
<a name="l00216"></a>00216 my_index (str, chr)
<a name="l00217"></a>00217 const <span class="keywordtype">char</span> *str;
<a name="l00218"></a>00218 <span class="keywordtype">int</span> chr;
<a name="l00219"></a>00219 {
<a name="l00220"></a>00220 <span class="keywordflow">while</span> (*str)
<a name="l00221"></a>00221 {
<a name="l00222"></a>00222 <span class="keywordflow">if</span> (*str == chr)
<a name="l00223"></a>00223 <span class="keywordflow">return</span> (<span class="keywordtype">char</span> *) str;
<a name="l00224"></a>00224 str++;
<a name="l00225"></a>00225 }
<a name="l00226"></a>00226 <span class="keywordflow">return</span> 0;
<a name="l00227"></a>00227 }
<a name="l00228"></a>00228
<a name="l00229"></a>00229 <span class="comment">/* If using GCC, we can safely declare strlen this way.</span>
<a name="l00230"></a>00230 <span class="comment"> If not using GCC, it is ok not to declare it. */</span>
<a name="l00231"></a>00231 <span class="preprocessor">#ifdef __GNUC__</span>
<a name="l00232"></a>00232 <span class="preprocessor"></span><span class="comment">/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.</span>
<a name="l00233"></a>00233 <span class="comment"> That was relevant to code that was here before. */</span>
<a name="l00234"></a>00234 <span class="preprocessor"># if (!defined __STDC__ || !__STDC__) && !defined strlen</span>
<a name="l00235"></a>00235 <span class="preprocessor"></span><span class="comment">/* gcc with -traditional declares the built-in strlen to return int,</span>
<a name="l00236"></a>00236 <span class="comment"> and has done so at least since version 2.4.5. -- rms. */</span>
<a name="l00237"></a>00237 <span class="keyword">extern</span> <span class="keywordtype">int</span> strlen (<span class="keyword">const</span> <span class="keywordtype">char</span> *);
<a name="l00238"></a>00238 <span class="preprocessor"># endif </span><span class="comment">/* not __STDC__ */</span>
<a name="l00239"></a>00239 <span class="preprocessor">#endif </span><span class="comment">/* __GNUC__ */</span>
<a name="l00240"></a>00240
<a name="l00241"></a>00241 <span class="preprocessor">#endif </span><span class="comment">/* not __GNU_LIBRARY__ */</span>
<a name="l00242"></a>00242
<a name="l00243"></a>00243 <span class="comment">/* Handle permutation of arguments. */</span>
<a name="l00244"></a>00244
<a name="l00245"></a>00245 <span class="comment">/* Describe the part of ARGV that contains non-options that have</span>
<a name="l00246"></a>00246 <span class="comment"> been skipped. `first_nonopt' is the index in ARGV of the first of them;</span>
<a name="l00247"></a>00247 <span class="comment"> `last_nonopt' is the index after the last of them. */</span>
<a name="l00248"></a>00248
<a name="l00249"></a>00249 <span class="keyword">static</span> <span class="keywordtype">int</span> first_nonopt;
<a name="l00250"></a>00250 <span class="keyword">static</span> <span class="keywordtype">int</span> last_nonopt;
<a name="l00251"></a>00251
<a name="l00252"></a>00252 <span class="preprocessor">#ifdef _LIBC</span>
<a name="l00253"></a>00253 <span class="preprocessor"></span><span class="comment">/* Stored original parameters.</span>
<a name="l00254"></a>00254 <span class="comment"> XXX This is no good solution. We should rather copy the args so</span>
<a name="l00255"></a>00255 <span class="comment"> that we can compare them later. But we must not use malloc(3). */</span>
<a name="l00256"></a>00256 <span class="keyword">extern</span> <span class="keywordtype">int</span> __libc_argc;
<a name="l00257"></a>00257 <span class="keyword">extern</span> <span class="keywordtype">char</span> **__libc_argv;
<a name="l00258"></a>00258
<a name="l00259"></a>00259 <span class="comment">/* Bash 2.0 gives us an environment variable containing flags</span>
<a name="l00260"></a>00260 <span class="comment"> indicating ARGV elements that should not be considered arguments. */</span>
<a name="l00261"></a>00261
<a name="l00262"></a>00262 <span class="preprocessor"># ifdef USE_NONOPTION_FLAGS</span>
<a name="l00263"></a>00263 <span class="preprocessor"></span><span class="comment">/* Defined in getopt_init.c */</span>
<a name="l00264"></a>00264 <span class="keyword">extern</span> <span class="keywordtype">char</span> *__getopt_nonoption_flags;
<a name="l00265"></a>00265
<a name="l00266"></a>00266 <span class="keyword">static</span> <span class="keywordtype">int</span> nonoption_flags_max_len;
<a name="l00267"></a>00267 <span class="keyword">static</span> <span class="keywordtype">int</span> nonoption_flags_len;
<a name="l00268"></a>00268 <span class="preprocessor"># endif</span>
<a name="l00269"></a>00269 <span class="preprocessor"></span>
<a name="l00270"></a>00270 <span class="preprocessor"># ifdef USE_NONOPTION_FLAGS</span>
<a name="l00271"></a>00271 <span class="preprocessor"></span><span class="preprocessor"># define SWAP_FLAGS(ch1, ch2) \</span>
<a name="l00272"></a>00272 <span class="preprocessor"> if (nonoption_flags_len > 0) \</span>
<a name="l00273"></a>00273 <span class="preprocessor"> { \</span>
<a name="l00274"></a>00274 <span class="preprocessor"> char __tmp = __getopt_nonoption_flags[ch1]; \</span>
<a name="l00275"></a>00275 <span class="preprocessor"> __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \</span>
<a name="l00276"></a>00276 <span class="preprocessor"> __getopt_nonoption_flags[ch2] = __tmp; \</span>
<a name="l00277"></a>00277 <span class="preprocessor"> }</span>
<a name="l00278"></a>00278 <span class="preprocessor"></span><span class="preprocessor"># else</span>
<a name="l00279"></a>00279 <span class="preprocessor"></span><span class="preprocessor"># define SWAP_FLAGS(ch1, ch2)</span>
<a name="l00280"></a>00280 <span class="preprocessor"></span><span class="preprocessor"># endif</span>
<a name="l00281"></a>00281 <span class="preprocessor"></span><span class="preprocessor">#else </span><span class="comment">/* !_LIBC */</span>
<a name="l00282"></a>00282 <span class="preprocessor"># define SWAP_FLAGS(ch1, ch2)</span>
<a name="l00283"></a>00283 <span class="preprocessor"></span><span class="preprocessor">#endif </span><span class="comment">/* _LIBC */</span>
<a name="l00284"></a>00284
<a name="l00285"></a>00285 <span class="comment">/* Exchange two adjacent subsequences of ARGV.</span>
<a name="l00286"></a>00286 <span class="comment"> One subsequence is elements [first_nonopt,last_nonopt)</span>
<a name="l00287"></a>00287 <span class="comment"> which contains all the non-options that have been skipped so far.</span>
<a name="l00288"></a>00288 <span class="comment"> The other is elements [last_nonopt,optind), which contains all</span>
<a name="l00289"></a>00289 <span class="comment"> the options processed since those non-options were skipped.</span>
<a name="l00290"></a>00290 <span class="comment"></span>
<a name="l00291"></a>00291 <span class="comment"> `first_nonopt' and `last_nonopt' are relocated so that they describe</span>
<a name="l00292"></a>00292 <span class="comment"> the new indices of the non-options in ARGV after they are moved. */</span>
<a name="l00293"></a>00293
<a name="l00294"></a>00294 <span class="preprocessor">#if defined __STDC__ && __STDC__</span>
<a name="l00295"></a>00295 <span class="preprocessor"></span><span class="keyword">static</span> <span class="keywordtype">void</span> exchange (<span class="keywordtype">char</span> **);
<a name="l00296"></a>00296 <span class="preprocessor">#endif</span>
<a name="l00297"></a>00297 <span class="preprocessor"></span>
<a name="l00298"></a>00298 <span class="keyword">static</span> <span class="keywordtype">void</span>
<a name="l00299"></a>00299 exchange (argv)
<a name="l00300"></a>00300 char **argv;
<a name="l00301"></a>00301 {
<a name="l00302"></a>00302 <span class="keywordtype">int</span> bottom = first_nonopt;
<a name="l00303"></a>00303 <span class="keywordtype">int</span> middle = last_nonopt;
<a name="l00304"></a>00304 <span class="keywordtype">int</span> top = optind;
<a name="l00305"></a>00305 <span class="keywordtype">char</span> *tem;
<a name="l00306"></a>00306
<a name="l00307"></a>00307 <span class="comment">/* Exchange the shorter segment with the far end of the longer segment.</span>
<a name="l00308"></a>00308 <span class="comment"> That puts the shorter segment into the right place.</span>
<a name="l00309"></a>00309 <span class="comment"> It leaves the longer segment in the right place overall,</span>
<a name="l00310"></a>00310 <span class="comment"> but it consists of two parts that need to be swapped next. */</span>
<a name="l00311"></a>00311
<a name="l00312"></a>00312 <span class="preprocessor">#if defined _LIBC && defined USE_NONOPTION_FLAGS</span>
<a name="l00313"></a>00313 <span class="preprocessor"></span> <span class="comment">/* First make sure the handling of the `__getopt_nonoption_flags'</span>
<a name="l00314"></a>00314 <span class="comment"> string can work normally. Our top argument must be in the range</span>
<a name="l00315"></a>00315 <span class="comment"> of the string. */</span>
<a name="l00316"></a>00316 <span class="keywordflow">if</span> (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
<a name="l00317"></a>00317 {
<a name="l00318"></a>00318 <span class="comment">/* We must extend the array. The user plays games with us and</span>
<a name="l00319"></a>00319 <span class="comment"> presents new arguments. */</span>
<a name="l00320"></a>00320 <span class="keywordtype">char</span> *new_str = malloc (top + 1);
<a name="l00321"></a>00321 <span class="keywordflow">if</span> (new_str == NULL)
<a name="l00322"></a>00322 nonoption_flags_len = nonoption_flags_max_len = 0;
<a name="l00323"></a>00323 <span class="keywordflow">else</span>
<a name="l00324"></a>00324 {
<a name="l00325"></a>00325 memset (__mempcpy (new_str, __getopt_nonoption_flags,
<a name="l00326"></a>00326 nonoption_flags_max_len),
<a name="l00327"></a>00327 <span class="charliteral">'\0'</span>, top + 1 - nonoption_flags_max_len);
<a name="l00328"></a>00328 nonoption_flags_max_len = top + 1;
<a name="l00329"></a>00329 __getopt_nonoption_flags = new_str;
<a name="l00330"></a>00330 }
<a name="l00331"></a>00331 }
<a name="l00332"></a>00332 <span class="preprocessor">#endif</span>
<a name="l00333"></a>00333 <span class="preprocessor"></span>
<a name="l00334"></a>00334 <span class="keywordflow">while</span> (top > middle && middle > bottom)
<a name="l00335"></a>00335 {
<a name="l00336"></a>00336 <span class="keywordflow">if</span> (top - middle > middle - bottom)
<a name="l00337"></a>00337 {
<a name="l00338"></a>00338 <span class="comment">/* Bottom segment is the short one. */</span>
<a name="l00339"></a>00339 <span class="keywordtype">int</span> len = middle - bottom;
<a name="l00340"></a>00340 <span class="keyword">register</span> <span class="keywordtype">int</span> i;
<a name="l00341"></a>00341
<a name="l00342"></a>00342 <span class="comment">/* Swap it with the top part of the top segment. */</span>
<a name="l00343"></a>00343 <span class="keywordflow">for</span> (i = 0; i < len; i++)
<a name="l00344"></a>00344 {
<a name="l00345"></a>00345 tem = argv[bottom + i];
<a name="l00346"></a>00346 argv[bottom + i] = argv[top - (middle - bottom) + i];
<a name="l00347"></a>00347 argv[top - (middle - bottom) + i] = tem;
<a name="l00348"></a>00348 SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
<a name="l00349"></a>00349 }
<a name="l00350"></a>00350 <span class="comment">/* Exclude the moved bottom segment from further swapping. */</span>
<a name="l00351"></a>00351 top -= len;
<a name="l00352"></a>00352 }
<a name="l00353"></a>00353 <span class="keywordflow">else</span>
<a name="l00354"></a>00354 {
<a name="l00355"></a>00355 <span class="comment">/* Top segment is the short one. */</span>
<a name="l00356"></a>00356 <span class="keywordtype">int</span> len = top - middle;
<a name="l00357"></a>00357 <span class="keyword">register</span> <span class="keywordtype">int</span> i;
<a name="l00358"></a>00358
<a name="l00359"></a>00359 <span class="comment">/* Swap it with the bottom part of the bottom segment. */</span>
<a name="l00360"></a>00360 <span class="keywordflow">for</span> (i = 0; i < len; i++)
<a name="l00361"></a>00361 {
<a name="l00362"></a>00362 tem = argv[bottom + i];
<a name="l00363"></a>00363 argv[bottom + i] = argv[middle + i];
<a name="l00364"></a>00364 argv[middle + i] = tem;
<a name="l00365"></a>00365 SWAP_FLAGS (bottom + i, middle + i);
<a name="l00366"></a>00366 }
<a name="l00367"></a>00367 <span class="comment">/* Exclude the moved top segment from further swapping. */</span>
<a name="l00368"></a>00368 bottom += len;
<a name="l00369"></a>00369 }
<a name="l00370"></a>00370 }
<a name="l00371"></a>00371
<a name="l00372"></a>00372 <span class="comment">/* Update records for the slots the non-options now occupy. */</span>
<a name="l00373"></a>00373
<a name="l00374"></a>00374 first_nonopt += (optind - last_nonopt);
<a name="l00375"></a>00375 last_nonopt = optind;
<a name="l00376"></a>00376 }
<a name="l00377"></a>00377
<a name="l00378"></a>00378 <span class="comment">/* Initialize the internal data when the first call is made. */</span>
<a name="l00379"></a>00379
<a name="l00380"></a>00380 <span class="preprocessor">#if defined __STDC__ && __STDC__</span>
<a name="l00381"></a>00381 <span class="preprocessor"></span><span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span> *_getopt_initialize (<span class="keywordtype">int</span>, <span class="keywordtype">char</span> *<span class="keyword">const</span> *, <span class="keyword">const</span> <span class="keywordtype">char</span> *);
<a name="l00382"></a>00382 <span class="preprocessor">#endif</span>
<a name="l00383"></a>00383 <span class="preprocessor"></span><span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span> *
<a name="l00384"></a>00384 _getopt_initialize (argc, argv, optstring)
<a name="l00385"></a>00385 int argc;
<a name="l00386"></a>00386 <span class="keywordtype">char</span> *const *argv;
<a name="l00387"></a>00387 const <span class="keywordtype">char</span> *optstring;
<a name="l00388"></a>00388 {
<a name="l00389"></a>00389 <span class="comment">/* Start processing options with ARGV-element 1 (since ARGV-element 0</span>
<a name="l00390"></a>00390 <span class="comment"> is the program name); the sequence of previously skipped</span>
<a name="l00391"></a>00391 <span class="comment"> non-option ARGV-elements is empty. */</span>
<a name="l00392"></a>00392
<a name="l00393"></a>00393 first_nonopt = last_nonopt = optind;
<a name="l00394"></a>00394
<a name="l00395"></a>00395 nextchar = NULL;
<a name="l00396"></a>00396
<a name="l00397"></a>00397 posixly_correct = getenv (<span class="stringliteral">"POSIXLY_CORRECT"</span>);
<a name="l00398"></a>00398
<a name="l00399"></a>00399 <span class="comment">/* Determine how to handle the ordering of options and nonoptions. */</span>
<a name="l00400"></a>00400
<a name="l00401"></a>00401 <span class="keywordflow">if</span> (optstring[0] == <span class="charliteral">'-'</span>)
<a name="l00402"></a>00402 {
<a name="l00403"></a>00403 ordering = RETURN_IN_ORDER;
<a name="l00404"></a>00404 ++optstring;
<a name="l00405"></a>00405 }
<a name="l00406"></a>00406 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (optstring[0] == <span class="charliteral">'+'</span>)
<a name="l00407"></a>00407 {
<a name="l00408"></a>00408 ordering = REQUIRE_ORDER;
<a name="l00409"></a>00409 ++optstring;
<a name="l00410"></a>00410 }
<a name="l00411"></a>00411 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (posixly_correct != NULL)
<a name="l00412"></a>00412 ordering = REQUIRE_ORDER;
<a name="l00413"></a>00413 <span class="keywordflow">else</span>
<a name="l00414"></a>00414 ordering = PERMUTE;
<a name="l00415"></a>00415
<a name="l00416"></a>00416 <span class="preprocessor">#if defined _LIBC && defined USE_NONOPTION_FLAGS</span>
<a name="l00417"></a>00417 <span class="preprocessor"></span> <span class="keywordflow">if</span> (posixly_correct == NULL
<a name="l00418"></a>00418 && argc == __libc_argc && argv == __libc_argv)
<a name="l00419"></a>00419 {
<a name="l00420"></a>00420 <span class="keywordflow">if</span> (nonoption_flags_max_len == 0)
<a name="l00421"></a>00421 {
<a name="l00422"></a>00422 <span class="keywordflow">if</span> (__getopt_nonoption_flags == NULL
<a name="l00423"></a>00423 || __getopt_nonoption_flags[0] == <span class="charliteral">'\0'</span>)
<a name="l00424"></a>00424 nonoption_flags_max_len = -1;
<a name="l00425"></a>00425 <span class="keywordflow">else</span>
<a name="l00426"></a>00426 {
<a name="l00427"></a>00427 <span class="keyword">const</span> <span class="keywordtype">char</span> *orig_str = __getopt_nonoption_flags;
<a name="l00428"></a>00428 <span class="keywordtype">int</span> len = nonoption_flags_max_len = strlen (orig_str);
<a name="l00429"></a>00429 <span class="keywordflow">if</span> (nonoption_flags_max_len < argc)
<a name="l00430"></a>00430 nonoption_flags_max_len = argc;
<a name="l00431"></a>00431 __getopt_nonoption_flags =
<a name="l00432"></a>00432 (<span class="keywordtype">char</span> *) malloc (nonoption_flags_max_len);
<a name="l00433"></a>00433 <span class="keywordflow">if</span> (__getopt_nonoption_flags == NULL)
<a name="l00434"></a>00434 nonoption_flags_max_len = -1;
<a name="l00435"></a>00435 <span class="keywordflow">else</span>
<a name="l00436"></a>00436 memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
<a name="l00437"></a>00437 <span class="charliteral">'\0'</span>, nonoption_flags_max_len - len);
<a name="l00438"></a>00438 }
<a name="l00439"></a>00439 }
<a name="l00440"></a>00440 nonoption_flags_len = nonoption_flags_max_len;
<a name="l00441"></a>00441 }
<a name="l00442"></a>00442 <span class="keywordflow">else</span>
<a name="l00443"></a>00443 nonoption_flags_len = 0;
<a name="l00444"></a>00444 <span class="preprocessor">#endif</span>
<a name="l00445"></a>00445 <span class="preprocessor"></span>
<a name="l00446"></a>00446 <span class="keywordflow">return</span> optstring;
<a name="l00447"></a>00447 }
<a name="l00448"></a>00448
<a name="l00449"></a>00449 <span class="comment">/* Scan elements of ARGV (whose length is ARGC) for option characters</span>
<a name="l00450"></a>00450 <span class="comment"> given in OPTSTRING.</span>
<a name="l00451"></a>00451 <span class="comment"></span>
<a name="l00452"></a>00452 <span class="comment"> If an element of ARGV starts with '-', and is not exactly "-" or "--",</span>
<a name="l00453"></a>00453 <span class="comment"> then it is an option element. The characters of this element</span>
<a name="l00454"></a>00454 <span class="comment"> (aside from the initial '-') are option characters. If `getopt'</span>
<a name="l00455"></a>00455 <span class="comment"> is called repeatedly, it returns successively each of the option characters</span>
<a name="l00456"></a>00456 <span class="comment"> from each of the option elements.</span>
<a name="l00457"></a>00457 <span class="comment"></span>
<a name="l00458"></a>00458 <span class="comment"> If `getopt' finds another option character, it returns that character,</span>
<a name="l00459"></a>00459 <span class="comment"> updating `optind' and `nextchar' so that the next call to `getopt' can</span>
<a name="l00460"></a>00460 <span class="comment"> resume the scan with the following option character or ARGV-element.</span>
<a name="l00461"></a>00461 <span class="comment"></span>
<a name="l00462"></a>00462 <span class="comment"> If there are no more option characters, `getopt' returns -1.</span>
<a name="l00463"></a>00463 <span class="comment"> Then `optind' is the index in ARGV of the first ARGV-element</span>
<a name="l00464"></a>00464 <span class="comment"> that is not an option. (The ARGV-elements have been permuted</span>
<a name="l00465"></a>00465 <span class="comment"> so that those that are not options now come last.)</span>
<a name="l00466"></a>00466 <span class="comment"></span>
<a name="l00467"></a>00467 <span class="comment"> OPTSTRING is a string containing the legitimate option characters.</span>
<a name="l00468"></a>00468 <span class="comment"> If an option character is seen that is not listed in OPTSTRING,</span>
<a name="l00469"></a>00469 <span class="comment"> return '?' after printing an error message. If you set `opterr' to</span>
<a name="l00470"></a>00470 <span class="comment"> zero, the error message is suppressed but we still return '?'.</span>
<a name="l00471"></a>00471 <span class="comment"></span>
<a name="l00472"></a>00472 <span class="comment"> If a char in OPTSTRING is followed by a colon, that means it wants an arg,</span>
<a name="l00473"></a>00473 <span class="comment"> so the following text in the same ARGV-element, or the text of the following</span>
<a name="l00474"></a>00474 <span class="comment"> ARGV-element, is returned in `optarg'. Two colons mean an option that</span>
<a name="l00475"></a>00475 <span class="comment"> wants an optional arg; if there is text in the current ARGV-element,</span>
<a name="l00476"></a>00476 <span class="comment"> it is returned in `optarg', otherwise `optarg' is set to zero.</span>
<a name="l00477"></a>00477 <span class="comment"></span>
<a name="l00478"></a>00478 <span class="comment"> If OPTSTRING starts with `-' or `+', it requests different methods of</span>
<a name="l00479"></a>00479 <span class="comment"> handling the non-option ARGV-elements.</span>
<a name="l00480"></a>00480 <span class="comment"> See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.</span>
<a name="l00481"></a>00481 <span class="comment"></span>
<a name="l00482"></a>00482 <span class="comment"> Long-named options begin with `--' instead of `-'.</span>
<a name="l00483"></a>00483 <span class="comment"> Their names may be abbreviated as long as the abbreviation is unique</span>
<a name="l00484"></a>00484 <span class="comment"> or is an exact match for some defined option. If they have an</span>
<a name="l00485"></a>00485 <span class="comment"> argument, it follows the option name in the same ARGV-element, separated</span>
<a name="l00486"></a>00486 <span class="comment"> from the option name by a `=', or else the in next ARGV-element.</span>
<a name="l00487"></a>00487 <span class="comment"> When `getopt' finds a long-named option, it returns 0 if that option's</span>
<a name="l00488"></a>00488 <span class="comment"> `flag' field is nonzero, the value of the option's `val' field</span>
<a name="l00489"></a>00489 <span class="comment"> if the `flag' field is zero.</span>
<a name="l00490"></a>00490 <span class="comment"></span>
<a name="l00491"></a>00491 <span class="comment"> The elements of ARGV aren't really const, because we permute them.</span>
<a name="l00492"></a>00492 <span class="comment"> But we pretend they're const in the prototype to be compatible</span>
<a name="l00493"></a>00493 <span class="comment"> with other systems.</span>
<a name="l00494"></a>00494 <span class="comment"></span>
<a name="l00495"></a>00495 <span class="comment"> LONGOPTS is a vector of `struct option' terminated by an</span>
<a name="l00496"></a>00496 <span class="comment"> element containing a name which is zero.</span>
<a name="l00497"></a>00497 <span class="comment"></span>
<a name="l00498"></a>00498 <span class="comment"> LONGIND returns the index in LONGOPT of the long-named option found.</span>
<a name="l00499"></a>00499 <span class="comment"> It is only valid when a long-named option has been found by the most</span>
<a name="l00500"></a>00500 <span class="comment"> recent call.</span>
<a name="l00501"></a>00501 <span class="comment"></span>
<a name="l00502"></a>00502 <span class="comment"> If LONG_ONLY is nonzero, '-' as well as '--' can introduce</span>
<a name="l00503"></a>00503 <span class="comment"> long-named options. */</span>
<a name="l00504"></a>00504
<a name="l00505"></a>00505 <span class="keywordtype">int</span>
<a name="l00506"></a>00506 _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
<a name="l00507"></a>00507 int argc;
<a name="l00508"></a>00508 <span class="keywordtype">char</span> *const *argv;
<a name="l00509"></a>00509 const <span class="keywordtype">char</span> *optstring;
<a name="l00510"></a>00510 const struct <a class="code" href="structoption.html">option</a> *longopts;
<a name="l00511"></a>00511 <span class="keywordtype">int</span> *longind;
<a name="l00512"></a>00512 <span class="keywordtype">int</span> long_only;
<a name="l00513"></a>00513 {
<a name="l00514"></a>00514 <span class="keywordtype">int</span> print_errors = opterr;
<a name="l00515"></a>00515 <span class="keywordflow">if</span> (optstring[0] == <span class="charliteral">':'</span>)
<a name="l00516"></a>00516 print_errors = 0;
<a name="l00517"></a>00517
<a name="l00518"></a>00518 <span class="keywordflow">if</span> (argc < 1)
<a name="l00519"></a>00519 <span class="keywordflow">return</span> -1;
<a name="l00520"></a>00520
<a name="l00521"></a>00521 optarg = NULL;
<a name="l00522"></a>00522
<a name="l00523"></a>00523 <span class="keywordflow">if</span> (optind == 0 || !__getopt_initialized)
<a name="l00524"></a>00524 {
<a name="l00525"></a>00525 <span class="keywordflow">if</span> (optind == 0)
<a name="l00526"></a>00526 optind = 1; <span class="comment">/* Don't scan ARGV[0], the program name. */</span>
<a name="l00527"></a>00527 optstring = _getopt_initialize (argc, argv, optstring);
<a name="l00528"></a>00528 __getopt_initialized = 1;
<a name="l00529"></a>00529 }
<a name="l00530"></a>00530
<a name="l00531"></a>00531 <span class="comment">/* Test whether ARGV[optind] points to a non-option argument.</span>
<a name="l00532"></a>00532 <span class="comment"> Either it does not have option syntax, or there is an environment flag</span>
<a name="l00533"></a>00533 <span class="comment"> from the shell indicating it is not an option. The later information</span>
<a name="l00534"></a>00534 <span class="comment"> is only used when the used in the GNU libc. */</span>
<a name="l00535"></a>00535 <span class="preprocessor">#if defined _LIBC && defined USE_NONOPTION_FLAGS</span>
<a name="l00536"></a>00536 <span class="preprocessor"></span><span class="preprocessor"># define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \</span>
<a name="l00537"></a>00537 <span class="preprocessor"> || (optind < nonoption_flags_len \</span>
<a name="l00538"></a>00538 <span class="preprocessor"> && __getopt_nonoption_flags[optind] == '1'))</span>
<a name="l00539"></a>00539 <span class="preprocessor"></span><span class="preprocessor">#else</span>
<a name="l00540"></a>00540 <span class="preprocessor"></span><span class="preprocessor"># define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')</span>
<a name="l00541"></a>00541 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00542"></a>00542 <span class="preprocessor"></span>
<a name="l00543"></a>00543 <span class="keywordflow">if</span> (nextchar == NULL || *nextchar == <span class="charliteral">'\0'</span>)
<a name="l00544"></a>00544 {
<a name="l00545"></a>00545 <span class="comment">/* Advance to the next ARGV-element. */</span>
<a name="l00546"></a>00546
<a name="l00547"></a>00547 <span class="comment">/* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been</span>
<a name="l00548"></a>00548 <span class="comment"> moved back by the user (who may also have changed the arguments). */</span>
<a name="l00549"></a>00549 <span class="keywordflow">if</span> (last_nonopt > optind)
<a name="l00550"></a>00550 last_nonopt = optind;
<a name="l00551"></a>00551 <span class="keywordflow">if</span> (first_nonopt > optind)
<a name="l00552"></a>00552 first_nonopt = optind;
<a name="l00553"></a>00553
<a name="l00554"></a>00554 <span class="keywordflow">if</span> (ordering == PERMUTE)
<a name="l00555"></a>00555 {
<a name="l00556"></a>00556 <span class="comment">/* If we have just processed some options following some non-options,</span>
<a name="l00557"></a>00557 <span class="comment"> exchange them so that the options come first. */</span>
<a name="l00558"></a>00558
<a name="l00559"></a>00559 <span class="keywordflow">if</span> (first_nonopt != last_nonopt && last_nonopt != optind)
<a name="l00560"></a>00560 exchange ((<span class="keywordtype">char</span> **) argv);
<a name="l00561"></a>00561 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (last_nonopt != optind)
<a name="l00562"></a>00562 first_nonopt = optind;
<a name="l00563"></a>00563
<a name="l00564"></a>00564 <span class="comment">/* Skip any additional non-options</span>
<a name="l00565"></a>00565 <span class="comment"> and extend the range of non-options previously skipped. */</span>
<a name="l00566"></a>00566
<a name="l00567"></a>00567 <span class="keywordflow">while</span> (optind < argc && NONOPTION_P)
<a name="l00568"></a>00568 optind++;
<a name="l00569"></a>00569 last_nonopt = optind;
<a name="l00570"></a>00570 }
<a name="l00571"></a>00571
<a name="l00572"></a>00572 <span class="comment">/* The special ARGV-element `--' means premature end of options.</span>
<a name="l00573"></a>00573 <span class="comment"> Skip it like a null option,</span>
<a name="l00574"></a>00574 <span class="comment"> then exchange with previous non-options as if it were an option,</span>
<a name="l00575"></a>00575 <span class="comment"> then skip everything else like a non-option. */</span>
<a name="l00576"></a>00576
<a name="l00577"></a>00577 <span class="keywordflow">if</span> (optind != argc && !strcmp (argv[optind], <span class="stringliteral">"--"</span>))
<a name="l00578"></a>00578 {
<a name="l00579"></a>00579 optind++;
<a name="l00580"></a>00580
<a name="l00581"></a>00581 <span class="keywordflow">if</span> (first_nonopt != last_nonopt && last_nonopt != optind)
<a name="l00582"></a>00582 exchange ((<span class="keywordtype">char</span> **) argv);
<a name="l00583"></a>00583 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (first_nonopt == last_nonopt)
<a name="l00584"></a>00584 first_nonopt = optind;
<a name="l00585"></a>00585 last_nonopt = argc;
<a name="l00586"></a>00586
<a name="l00587"></a>00587 optind = argc;
<a name="l00588"></a>00588 }
<a name="l00589"></a>00589
<a name="l00590"></a>00590 <span class="comment">/* If we have done all the ARGV-elements, stop the scan</span>
<a name="l00591"></a>00591 <span class="comment"> and back over any non-options that we skipped and permuted. */</span>
<a name="l00592"></a>00592
<a name="l00593"></a>00593 <span class="keywordflow">if</span> (optind == argc)
<a name="l00594"></a>00594 {
<a name="l00595"></a>00595 <span class="comment">/* Set the next-arg-index to point at the non-options</span>
<a name="l00596"></a>00596 <span class="comment"> that we previously skipped, so the caller will digest them. */</span>
<a name="l00597"></a>00597 <span class="keywordflow">if</span> (first_nonopt != last_nonopt)
<a name="l00598"></a>00598 optind = first_nonopt;
<a name="l00599"></a>00599 <span class="keywordflow">return</span> -1;
<a name="l00600"></a>00600 }
<a name="l00601"></a>00601
<a name="l00602"></a>00602 <span class="comment">/* If we have come to a non-option and did not permute it,</span>
<a name="l00603"></a>00603 <span class="comment"> either stop the scan or describe it to the caller and pass it by. */</span>
<a name="l00604"></a>00604
<a name="l00605"></a>00605 <span class="keywordflow">if</span> (NONOPTION_P)
<a name="l00606"></a>00606 {
<a name="l00607"></a>00607 <span class="keywordflow">if</span> (ordering == REQUIRE_ORDER)
<a name="l00608"></a>00608 <span class="keywordflow">return</span> -1;
<a name="l00609"></a>00609 optarg = argv[optind++];
<a name="l00610"></a>00610 <span class="keywordflow">return</span> 1;
<a name="l00611"></a>00611 }
<a name="l00612"></a>00612
<a name="l00613"></a>00613 <span class="comment">/* We have found another option-ARGV-element.</span>
<a name="l00614"></a>00614 <span class="comment"> Skip the initial punctuation. */</span>
<a name="l00615"></a>00615
<a name="l00616"></a>00616 nextchar = (argv[optind] + 1
<a name="l00617"></a>00617 + (longopts != NULL && argv[optind][1] == <span class="charliteral">'-'</span>));
<a name="l00618"></a>00618 }
<a name="l00619"></a>00619
<a name="l00620"></a>00620 <span class="comment">/* Decode the current option-ARGV-element. */</span>
<a name="l00621"></a>00621
<a name="l00622"></a>00622 <span class="comment">/* Check whether the ARGV-element is a long option.</span>
<a name="l00623"></a>00623 <span class="comment"></span>
<a name="l00624"></a>00624 <span class="comment"> If long_only and the ARGV-element has the form "-f", where f is</span>
<a name="l00625"></a>00625 <span class="comment"> a valid short option, don't consider it an abbreviated form of</span>
<a name="l00626"></a>00626 <span class="comment"> a long option that starts with f. Otherwise there would be no</span>
<a name="l00627"></a>00627 <span class="comment"> way to give the -f short option.</span>
<a name="l00628"></a>00628 <span class="comment"></span>
<a name="l00629"></a>00629 <span class="comment"> On the other hand, if there's a long option "fubar" and</span>
<a name="l00630"></a>00630 <span class="comment"> the ARGV-element is "-fu", do consider that an abbreviation of</span>
<a name="l00631"></a>00631 <span class="comment"> the long option, just like "--fu", and not "-f" with arg "u".</span>
<a name="l00632"></a>00632 <span class="comment"></span>
<a name="l00633"></a>00633 <span class="comment"> This distinction seems to be the most useful approach. */</span>
<a name="l00634"></a>00634
<a name="l00635"></a>00635 <span class="keywordflow">if</span> (longopts != NULL
<a name="l00636"></a>00636 && (argv[optind][1] == <span class="charliteral">'-'</span>
<a name="l00637"></a>00637 || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
<a name="l00638"></a>00638 {
<a name="l00639"></a>00639 <span class="keywordtype">char</span> *nameend;
<a name="l00640"></a>00640 <span class="keyword">const</span> <span class="keyword">struct </span><a class="code" href="structoption.html">option</a> *p;
<a name="l00641"></a>00641 <span class="keyword">const</span> <span class="keyword">struct </span><a class="code" href="structoption.html">option</a> *pfound = NULL;
<a name="l00642"></a>00642 <span class="keywordtype">int</span> exact = 0;
<a name="l00643"></a>00643 <span class="keywordtype">int</span> ambig = 0;
<a name="l00644"></a>00644 <span class="keywordtype">int</span> indfound = -1;
<a name="l00645"></a>00645 <span class="keywordtype">int</span> option_index;
<a name="l00646"></a>00646
<a name="l00647"></a>00647 <span class="keywordflow">for</span> (nameend = nextchar; *nameend && *nameend != <span class="charliteral">'='</span>; nameend++)
<a name="l00648"></a>00648 <span class="comment">/* Do nothing. */</span> ;
<a name="l00649"></a>00649
<a name="l00650"></a>00650 <span class="comment">/* Test all long options for either exact match</span>
<a name="l00651"></a>00651 <span class="comment"> or abbreviated matches. */</span>
<a name="l00652"></a>00652 <span class="keywordflow">for</span> (p = longopts, option_index = 0; p-><a class="code" href="structoption.html#92c850a23c7828c1dba453bf8d15e1f0">name</a>; p++, option_index++)
<a name="l00653"></a>00653 <span class="keywordflow">if</span> (!strncmp (p-><a class="code" href="structoption.html#92c850a23c7828c1dba453bf8d15e1f0">name</a>, nextchar, nameend - nextchar))
<a name="l00654"></a>00654 {
<a name="l00655"></a>00655 <span class="keywordflow">if</span> ((<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span>) (nameend - nextchar)
<a name="l00656"></a>00656 == (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span>) strlen (p-><a class="code" href="structoption.html#92c850a23c7828c1dba453bf8d15e1f0">name</a>))
<a name="l00657"></a>00657 {
<a name="l00658"></a>00658 <span class="comment">/* Exact match found. */</span>
<a name="l00659"></a>00659 pfound = p;
<a name="l00660"></a>00660 indfound = option_index;
<a name="l00661"></a>00661 exact = 1;
<a name="l00662"></a>00662 <span class="keywordflow">break</span>;
<a name="l00663"></a>00663 }
<a name="l00664"></a>00664 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (pfound == NULL)
<a name="l00665"></a>00665 {
<a name="l00666"></a>00666 <span class="comment">/* First nonexact match found. */</span>
<a name="l00667"></a>00667 pfound = p;
<a name="l00668"></a>00668 indfound = option_index;
<a name="l00669"></a>00669 }
<a name="l00670"></a>00670 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (long_only
<a name="l00671"></a>00671 || pfound-><a class="code" href="structoption.html#90d7ee9a51eea5c002682dbd0af149e4">has_arg</a> != p-><a class="code" href="structoption.html#90d7ee9a51eea5c002682dbd0af149e4">has_arg</a>
<a name="l00672"></a>00672 || pfound-><a class="code" href="structoption.html#b366eea5fe7be25c1928328ba715e353">flag</a> != p-><a class="code" href="structoption.html#b366eea5fe7be25c1928328ba715e353">flag</a>
<a name="l00673"></a>00673 || pfound-><a class="code" href="structoption.html#13bd155ec3b405d29c41ab8d0793be11">val</a> != p-><a class="code" href="structoption.html#13bd155ec3b405d29c41ab8d0793be11">val</a>)
<a name="l00674"></a>00674 <span class="comment">/* Second or later nonexact match found. */</span>
<a name="l00675"></a>00675 ambig = 1;
<a name="l00676"></a>00676 }
<a name="l00677"></a>00677
<a name="l00678"></a>00678 <span class="keywordflow">if</span> (ambig && !exact)
<a name="l00679"></a>00679 {
<a name="l00680"></a>00680 <span class="keywordflow">if</span> (print_errors)
<a name="l00681"></a>00681 fprintf (stderr, _(<span class="stringliteral">"%s: option `%s' is ambiguous\n"</span>),
<a name="l00682"></a>00682 argv[0], argv[optind]);
<a name="l00683"></a>00683 nextchar += strlen (nextchar);
<a name="l00684"></a>00684 optind++;
<a name="l00685"></a>00685 optopt = 0;
<a name="l00686"></a>00686 <span class="keywordflow">return</span> <span class="charliteral">'?'</span>;
<a name="l00687"></a>00687 }
<a name="l00688"></a>00688
<a name="l00689"></a>00689 <span class="keywordflow">if</span> (pfound != NULL)
<a name="l00690"></a>00690 {
<a name="l00691"></a>00691 option_index = indfound;
<a name="l00692"></a>00692 optind++;
<a name="l00693"></a>00693 <span class="keywordflow">if</span> (*nameend)
<a name="l00694"></a>00694 {
<a name="l00695"></a>00695 <span class="comment">/* Don't test has_arg with >, because some C compilers don't</span>
<a name="l00696"></a>00696 <span class="comment"> allow it to be used on enums. */</span>
<a name="l00697"></a>00697 <span class="keywordflow">if</span> (pfound-><a class="code" href="structoption.html#90d7ee9a51eea5c002682dbd0af149e4">has_arg</a>)
<a name="l00698"></a>00698 optarg = nameend + 1;
<a name="l00699"></a>00699 <span class="keywordflow">else</span>
<a name="l00700"></a>00700 {
<a name="l00701"></a>00701 <span class="keywordflow">if</span> (print_errors)
<a name="l00702"></a>00702 {
<a name="l00703"></a>00703 <span class="keywordflow">if</span> (argv[optind - 1][1] == <span class="charliteral">'-'</span>)
<a name="l00704"></a>00704 <span class="comment">/* --option */</span>
<a name="l00705"></a>00705 fprintf (stderr,
<a name="l00706"></a>00706 _(<span class="stringliteral">"%s: option `--%s' doesn't allow an argument\n"</span>),
<a name="l00707"></a>00707 argv[0], pfound-><a class="code" href="structoption.html#92c850a23c7828c1dba453bf8d15e1f0">name</a>);
<a name="l00708"></a>00708 <span class="keywordflow">else</span>
<a name="l00709"></a>00709 <span class="comment">/* +option or -option */</span>
<a name="l00710"></a>00710 fprintf (stderr,
<a name="l00711"></a>00711 _(<span class="stringliteral">"%s: option `%c%s' doesn't allow an argument\n"</span>),
<a name="l00712"></a>00712 argv[0], argv[optind - 1][0], pfound-><a class="code" href="structoption.html#92c850a23c7828c1dba453bf8d15e1f0">name</a>);
<a name="l00713"></a>00713 }
<a name="l00714"></a>00714
<a name="l00715"></a>00715 nextchar += strlen (nextchar);
<a name="l00716"></a>00716
<a name="l00717"></a>00717 optopt = pfound-><a class="code" href="structoption.html#13bd155ec3b405d29c41ab8d0793be11">val</a>;
<a name="l00718"></a>00718 <span class="keywordflow">return</span> <span class="charliteral">'?'</span>;
<a name="l00719"></a>00719 }
<a name="l00720"></a>00720 }
<a name="l00721"></a>00721 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (pfound-><a class="code" href="structoption.html#90d7ee9a51eea5c002682dbd0af149e4">has_arg</a> == 1)
<a name="l00722"></a>00722 {
<a name="l00723"></a>00723 <span class="keywordflow">if</span> (optind < argc)
<a name="l00724"></a>00724 optarg = argv[optind++];
<a name="l00725"></a>00725 <span class="keywordflow">else</span>
<a name="l00726"></a>00726 {
<a name="l00727"></a>00727 <span class="keywordflow">if</span> (print_errors)
<a name="l00728"></a>00728 fprintf (stderr,
<a name="l00729"></a>00729 _(<span class="stringliteral">"%s: option `%s' requires an argument\n"</span>),
<a name="l00730"></a>00730 argv[0], argv[optind - 1]);
<a name="l00731"></a>00731 nextchar += strlen (nextchar);
<a name="l00732"></a>00732 optopt = pfound-><a class="code" href="structoption.html#13bd155ec3b405d29c41ab8d0793be11">val</a>;
<a name="l00733"></a>00733 <span class="keywordflow">return</span> optstring[0] == <span class="charliteral">':'</span> ? <span class="charliteral">':'</span> : <span class="charliteral">'?'</span>;
<a name="l00734"></a>00734 }
<a name="l00735"></a>00735 }
<a name="l00736"></a>00736 nextchar += strlen (nextchar);
<a name="l00737"></a>00737 <span class="keywordflow">if</span> (longind != NULL)
<a name="l00738"></a>00738 *longind = option_index;
<a name="l00739"></a>00739 <span class="keywordflow">if</span> (pfound-><a class="code" href="structoption.html#b366eea5fe7be25c1928328ba715e353">flag</a>)
<a name="l00740"></a>00740 {
<a name="l00741"></a>00741 *(pfound-><a class="code" href="structoption.html#b366eea5fe7be25c1928328ba715e353">flag</a>) = pfound-><a class="code" href="structoption.html#13bd155ec3b405d29c41ab8d0793be11">val</a>;
<a name="l00742"></a>00742 <span class="keywordflow">return</span> 0;
<a name="l00743"></a>00743 }
<a name="l00744"></a>00744 <span class="keywordflow">return</span> pfound-><a class="code" href="structoption.html#13bd155ec3b405d29c41ab8d0793be11">val</a>;
<a name="l00745"></a>00745 }
<a name="l00746"></a>00746
<a name="l00747"></a>00747 <span class="comment">/* Can't find it as a long option. If this is not getopt_long_only,</span>
<a name="l00748"></a>00748 <span class="comment"> or the option starts with '--' or is not a valid short</span>
<a name="l00749"></a>00749 <span class="comment"> option, then it's an error.</span>
<a name="l00750"></a>00750 <span class="comment"> Otherwise interpret it as a short option. */</span>
<a name="l00751"></a>00751 <span class="keywordflow">if</span> (!long_only || argv[optind][1] == <span class="charliteral">'-'</span>
<a name="l00752"></a>00752 || my_index (optstring, *nextchar) == NULL)
<a name="l00753"></a>00753 {
<a name="l00754"></a>00754 <span class="keywordflow">if</span> (print_errors)
<a name="l00755"></a>00755 {
<a name="l00756"></a>00756 <span class="keywordflow">if</span> (argv[optind][1] == <span class="charliteral">'-'</span>)
<a name="l00757"></a>00757 <span class="comment">/* --option */</span>
<a name="l00758"></a>00758 fprintf (stderr, _(<span class="stringliteral">"%s: unrecognized option `--%s'\n"</span>),
<a name="l00759"></a>00759 argv[0], nextchar);
<a name="l00760"></a>00760 <span class="keywordflow">else</span>
<a name="l00761"></a>00761 <span class="comment">/* +option or -option */</span>
<a name="l00762"></a>00762 fprintf (stderr, _(<span class="stringliteral">"%s: unrecognized option `%c%s'\n"</span>),
<a name="l00763"></a>00763 argv[0], argv[optind][0], nextchar);
<a name="l00764"></a>00764 }
<a name="l00765"></a>00765 nextchar = (<span class="keywordtype">char</span> *) <span class="stringliteral">""</span>;
<a name="l00766"></a>00766 optind++;
<a name="l00767"></a>00767 optopt = 0;
<a name="l00768"></a>00768 <span class="keywordflow">return</span> <span class="charliteral">'?'</span>;
<a name="l00769"></a>00769 }
<a name="l00770"></a>00770 }
<a name="l00771"></a>00771
<a name="l00772"></a>00772 <span class="comment">/* Look at and handle the next short option-character. */</span>
<a name="l00773"></a>00773
<a name="l00774"></a>00774 {
<a name="l00775"></a>00775 <span class="keywordtype">char</span> c = *nextchar++;
<a name="l00776"></a>00776 <span class="keywordtype">char</span> *temp = my_index (optstring, c);
<a name="l00777"></a>00777
<a name="l00778"></a>00778 <span class="comment">/* Increment `optind' when we start to process its last character. */</span>
<a name="l00779"></a>00779 <span class="keywordflow">if</span> (*nextchar == <span class="charliteral">'\0'</span>)
<a name="l00780"></a>00780 ++optind;
<a name="l00781"></a>00781
<a name="l00782"></a>00782 <span class="keywordflow">if</span> (temp == NULL || c == <span class="charliteral">':'</span>)
<a name="l00783"></a>00783 {
<a name="l00784"></a>00784 <span class="keywordflow">if</span> (print_errors)
<a name="l00785"></a>00785 {
<a name="l00786"></a>00786 <span class="keywordflow">if</span> (posixly_correct)
<a name="l00787"></a>00787 <span class="comment">/* 1003.2 specifies the format of this message. */</span>
<a name="l00788"></a>00788 fprintf (stderr, _(<span class="stringliteral">"%s: illegal option -- %c\n"</span>),
<a name="l00789"></a>00789 argv[0], c);
<a name="l00790"></a>00790 <span class="keywordflow">else</span>
<a name="l00791"></a>00791 fprintf (stderr, _(<span class="stringliteral">"%s: invalid option -- %c\n"</span>),
<a name="l00792"></a>00792 argv[0], c);
<a name="l00793"></a>00793 }
<a name="l00794"></a>00794 optopt = c;
<a name="l00795"></a>00795 <span class="keywordflow">return</span> <span class="charliteral">'?'</span>;
<a name="l00796"></a>00796 }
<a name="l00797"></a>00797 <span class="comment">/* Convenience. Treat POSIX -W foo same as long option --foo */</span>
<a name="l00798"></a>00798 <span class="keywordflow">if</span> (temp[0] == <span class="charliteral">'W'</span> && temp[1] == <span class="charliteral">';'</span>)
<a name="l00799"></a>00799 {
<a name="l00800"></a>00800 <span class="keywordtype">char</span> *nameend;
<a name="l00801"></a>00801 <span class="keyword">const</span> <span class="keyword">struct </span><a class="code" href="structoption.html">option</a> *p;
<a name="l00802"></a>00802 <span class="keyword">const</span> <span class="keyword">struct </span><a class="code" href="structoption.html">option</a> *pfound = NULL;
<a name="l00803"></a>00803 <span class="keywordtype">int</span> exact = 0;
<a name="l00804"></a>00804 <span class="keywordtype">int</span> ambig = 0;
<a name="l00805"></a>00805 <span class="keywordtype">int</span> indfound = 0;
<a name="l00806"></a>00806 <span class="keywordtype">int</span> option_index;
<a name="l00807"></a>00807
<a name="l00808"></a>00808 <span class="comment">/* This is an option that requires an argument. */</span>
<a name="l00809"></a>00809 <span class="keywordflow">if</span> (*nextchar != <span class="charliteral">'\0'</span>)
<a name="l00810"></a>00810 {
<a name="l00811"></a>00811 optarg = nextchar;
<a name="l00812"></a>00812 <span class="comment">/* If we end this ARGV-element by taking the rest as an arg,</span>
<a name="l00813"></a>00813 <span class="comment"> we must advance to the next element now. */</span>
<a name="l00814"></a>00814 optind++;
<a name="l00815"></a>00815 }
<a name="l00816"></a>00816 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (optind == argc)
<a name="l00817"></a>00817 {
<a name="l00818"></a>00818 <span class="keywordflow">if</span> (print_errors)
<a name="l00819"></a>00819 {
<a name="l00820"></a>00820 <span class="comment">/* 1003.2 specifies the format of this message. */</span>
<a name="l00821"></a>00821 fprintf (stderr, _(<span class="stringliteral">"%s: option requires an argument -- %c\n"</span>),
<a name="l00822"></a>00822 argv[0], c);
<a name="l00823"></a>00823 }
<a name="l00824"></a>00824 optopt = c;
<a name="l00825"></a>00825 <span class="keywordflow">if</span> (optstring[0] == <span class="charliteral">':'</span>)
<a name="l00826"></a>00826 c = <span class="charliteral">':'</span>;
<a name="l00827"></a>00827 <span class="keywordflow">else</span>
<a name="l00828"></a>00828 c = <span class="charliteral">'?'</span>;
<a name="l00829"></a>00829 <span class="keywordflow">return</span> c;
<a name="l00830"></a>00830 }
<a name="l00831"></a>00831 <span class="keywordflow">else</span>
<a name="l00832"></a>00832 <span class="comment">/* We already incremented `optind' once;</span>
<a name="l00833"></a>00833 <span class="comment"> increment it again when taking next ARGV-elt as argument. */</span>
<a name="l00834"></a>00834 optarg = argv[optind++];
<a name="l00835"></a>00835
<a name="l00836"></a>00836 <span class="comment">/* optarg is now the argument, see if it's in the</span>
<a name="l00837"></a>00837 <span class="comment"> table of longopts. */</span>
<a name="l00838"></a>00838
<a name="l00839"></a>00839 <span class="keywordflow">for</span> (nextchar = nameend = optarg; *nameend && *nameend != <span class="charliteral">'='</span>; nameend++)
<a name="l00840"></a>00840 <span class="comment">/* Do nothing. */</span> ;
<a name="l00841"></a>00841
<a name="l00842"></a>00842 <span class="comment">/* Test all long options for either exact match</span>
<a name="l00843"></a>00843 <span class="comment"> or abbreviated matches. */</span>
<a name="l00844"></a>00844 <span class="keywordflow">for</span> (p = longopts, option_index = 0; p-><a class="code" href="structoption.html#92c850a23c7828c1dba453bf8d15e1f0">name</a>; p++, option_index++)
<a name="l00845"></a>00845 <span class="keywordflow">if</span> (!strncmp (p-><a class="code" href="structoption.html#92c850a23c7828c1dba453bf8d15e1f0">name</a>, nextchar, nameend - nextchar))
<a name="l00846"></a>00846 {
<a name="l00847"></a>00847 <span class="keywordflow">if</span> ((<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span>) (nameend - nextchar) == strlen (p-><a class="code" href="structoption.html#92c850a23c7828c1dba453bf8d15e1f0">name</a>))
<a name="l00848"></a>00848 {
<a name="l00849"></a>00849 <span class="comment">/* Exact match found. */</span>
<a name="l00850"></a>00850 pfound = p;
<a name="l00851"></a>00851 indfound = option_index;
<a name="l00852"></a>00852 exact = 1;
<a name="l00853"></a>00853 <span class="keywordflow">break</span>;
<a name="l00854"></a>00854 }
<a name="l00855"></a>00855 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (pfound == NULL)
<a name="l00856"></a>00856 {
<a name="l00857"></a>00857 <span class="comment">/* First nonexact match found. */</span>
<a name="l00858"></a>00858 pfound = p;
<a name="l00859"></a>00859 indfound = option_index;
<a name="l00860"></a>00860 }
<a name="l00861"></a>00861 <span class="keywordflow">else</span>
<a name="l00862"></a>00862 <span class="comment">/* Second or later nonexact match found. */</span>
<a name="l00863"></a>00863 ambig = 1;
<a name="l00864"></a>00864 }
<a name="l00865"></a>00865 <span class="keywordflow">if</span> (ambig && !exact)
<a name="l00866"></a>00866 {
<a name="l00867"></a>00867 <span class="keywordflow">if</span> (print_errors)
<a name="l00868"></a>00868 fprintf (stderr, _(<span class="stringliteral">"%s: option `-W %s' is ambiguous\n"</span>),
<a name="l00869"></a>00869 argv[0], argv[optind]);
<a name="l00870"></a>00870 nextchar += strlen (nextchar);
<a name="l00871"></a>00871 optind++;
<a name="l00872"></a>00872 <span class="keywordflow">return</span> <span class="charliteral">'?'</span>;
<a name="l00873"></a>00873 }
<a name="l00874"></a>00874 <span class="keywordflow">if</span> (pfound != NULL)
<a name="l00875"></a>00875 {
<a name="l00876"></a>00876 option_index = indfound;
<a name="l00877"></a>00877 <span class="keywordflow">if</span> (*nameend)
<a name="l00878"></a>00878 {
<a name="l00879"></a>00879 <span class="comment">/* Don't test has_arg with >, because some C compilers don't</span>
<a name="l00880"></a>00880 <span class="comment"> allow it to be used on enums. */</span>
<a name="l00881"></a>00881 <span class="keywordflow">if</span> (pfound-><a class="code" href="structoption.html#90d7ee9a51eea5c002682dbd0af149e4">has_arg</a>)
<a name="l00882"></a>00882 optarg = nameend + 1;
<a name="l00883"></a>00883 <span class="keywordflow">else</span>
<a name="l00884"></a>00884 {
<a name="l00885"></a>00885 <span class="keywordflow">if</span> (print_errors)
<a name="l00886"></a>00886 fprintf (stderr, _(<span class="stringliteral">"\</span>
<a name="l00887"></a>00887 <span class="stringliteral">%s: option `-W %s' doesn't allow an argument\n"</span>),
<a name="l00888"></a>00888 argv[0], pfound-><a class="code" href="structoption.html#92c850a23c7828c1dba453bf8d15e1f0">name</a>);
<a name="l00889"></a>00889
<a name="l00890"></a>00890 nextchar += strlen (nextchar);
<a name="l00891"></a>00891 <span class="keywordflow">return</span> <span class="charliteral">'?'</span>;
<a name="l00892"></a>00892 }
<a name="l00893"></a>00893 }
<a name="l00894"></a>00894 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (pfound-><a class="code" href="structoption.html#90d7ee9a51eea5c002682dbd0af149e4">has_arg</a> == 1)
<a name="l00895"></a>00895 {
<a name="l00896"></a>00896 <span class="keywordflow">if</span> (optind < argc)
<a name="l00897"></a>00897 optarg = argv[optind++];
<a name="l00898"></a>00898 <span class="keywordflow">else</span>
<a name="l00899"></a>00899 {
<a name="l00900"></a>00900 <span class="keywordflow">if</span> (print_errors)
<a name="l00901"></a>00901 fprintf (stderr,
<a name="l00902"></a>00902 _(<span class="stringliteral">"%s: option `%s' requires an argument\n"</span>),
<a name="l00903"></a>00903 argv[0], argv[optind - 1]);
<a name="l00904"></a>00904 nextchar += strlen (nextchar);
<a name="l00905"></a>00905 <span class="keywordflow">return</span> optstring[0] == <span class="charliteral">':'</span> ? <span class="charliteral">':'</span> : <span class="charliteral">'?'</span>;
<a name="l00906"></a>00906 }
<a name="l00907"></a>00907 }
<a name="l00908"></a>00908 nextchar += strlen (nextchar);
<a name="l00909"></a>00909 <span class="keywordflow">if</span> (longind != NULL)
<a name="l00910"></a>00910 *longind = option_index;
<a name="l00911"></a>00911 <span class="keywordflow">if</span> (pfound-><a class="code" href="structoption.html#b366eea5fe7be25c1928328ba715e353">flag</a>)
<a name="l00912"></a>00912 {
<a name="l00913"></a>00913 *(pfound-><a class="code" href="structoption.html#b366eea5fe7be25c1928328ba715e353">flag</a>) = pfound-><a class="code" href="structoption.html#13bd155ec3b405d29c41ab8d0793be11">val</a>;
<a name="l00914"></a>00914 <span class="keywordflow">return</span> 0;
<a name="l00915"></a>00915 }
<a name="l00916"></a>00916 <span class="keywordflow">return</span> pfound-><a class="code" href="structoption.html#13bd155ec3b405d29c41ab8d0793be11">val</a>;
<a name="l00917"></a>00917 }
<a name="l00918"></a>00918 nextchar = NULL;
<a name="l00919"></a>00919 <span class="keywordflow">return</span> <span class="charliteral">'W'</span>; <span class="comment">/* Let the application handle it. */</span>
<a name="l00920"></a>00920 }
<a name="l00921"></a>00921 <span class="keywordflow">if</span> (temp[1] == <span class="charliteral">':'</span>)
<a name="l00922"></a>00922 {
<a name="l00923"></a>00923 <span class="keywordflow">if</span> (temp[2] == <span class="charliteral">':'</span>)
<a name="l00924"></a>00924 {
<a name="l00925"></a>00925 <span class="comment">/* This is an option that accepts an argument optionally. */</span>
<a name="l00926"></a>00926 <span class="keywordflow">if</span> (*nextchar != <span class="charliteral">'\0'</span>)
<a name="l00927"></a>00927 {
<a name="l00928"></a>00928 optarg = nextchar;
<a name="l00929"></a>00929 optind++;
<a name="l00930"></a>00930 }
<a name="l00931"></a>00931 <span class="keywordflow">else</span>
<a name="l00932"></a>00932 optarg = NULL;
<a name="l00933"></a>00933 nextchar = NULL;
<a name="l00934"></a>00934 }
<a name="l00935"></a>00935 <span class="keywordflow">else</span>
<a name="l00936"></a>00936 {
<a name="l00937"></a>00937 <span class="comment">/* This is an option that requires an argument. */</span>
<a name="l00938"></a>00938 <span class="keywordflow">if</span> (*nextchar != <span class="charliteral">'\0'</span>)
<a name="l00939"></a>00939 {
<a name="l00940"></a>00940 optarg = nextchar;
<a name="l00941"></a>00941 <span class="comment">/* If we end this ARGV-element by taking the rest as an arg,</span>
<a name="l00942"></a>00942 <span class="comment"> we must advance to the next element now. */</span>
<a name="l00943"></a>00943 optind++;
<a name="l00944"></a>00944 }
<a name="l00945"></a>00945 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (optind == argc)
<a name="l00946"></a>00946 {
<a name="l00947"></a>00947 <span class="keywordflow">if</span> (print_errors)
<a name="l00948"></a>00948 {
<a name="l00949"></a>00949 <span class="comment">/* 1003.2 specifies the format of this message. */</span>
<a name="l00950"></a>00950 fprintf (stderr,
<a name="l00951"></a>00951 _(<span class="stringliteral">"%s: option requires an argument -- %c\n"</span>),
<a name="l00952"></a>00952 argv[0], c);
<a name="l00953"></a>00953 }
<a name="l00954"></a>00954 optopt = c;
<a name="l00955"></a>00955 <span class="keywordflow">if</span> (optstring[0] == <span class="charliteral">':'</span>)
<a name="l00956"></a>00956 c = <span class="charliteral">':'</span>;
<a name="l00957"></a>00957 <span class="keywordflow">else</span>
<a name="l00958"></a>00958 c = <span class="charliteral">'?'</span>;
<a name="l00959"></a>00959 }
<a name="l00960"></a>00960 <span class="keywordflow">else</span>
<a name="l00961"></a>00961 <span class="comment">/* We already incremented `optind' once;</span>
<a name="l00962"></a>00962 <span class="comment"> increment it again when taking next ARGV-elt as argument. */</span>
<a name="l00963"></a>00963 optarg = argv[optind++];
<a name="l00964"></a>00964 nextchar = NULL;
<a name="l00965"></a>00965 }
<a name="l00966"></a>00966 }
<a name="l00967"></a>00967 <span class="keywordflow">return</span> c;
<a name="l00968"></a>00968 }
<a name="l00969"></a>00969 }
<a name="l00970"></a>00970
<a name="l00971"></a>00971 <span class="keywordtype">int</span>
<a name="l00972"></a>00972 getopt (argc, argv, optstring)
<a name="l00973"></a>00973 int argc;
<a name="l00974"></a>00974 <span class="keywordtype">char</span> *const *argv;
<a name="l00975"></a>00975 const <span class="keywordtype">char</span> *optstring;
<a name="l00976"></a>00976 {
<a name="l00977"></a>00977 <span class="keywordflow">return</span> _getopt_internal (argc, argv, optstring,
<a name="l00978"></a>00978 (<span class="keyword">const</span> <span class="keyword">struct</span> <a class="code" href="structoption.html">option</a> *) 0,
<a name="l00979"></a>00979 (<span class="keywordtype">int</span> *) 0,
<a name="l00980"></a>00980 0);
<a name="l00981"></a>00981 }
<a name="l00982"></a>00982
<a name="l00983"></a>00983 <span class="preprocessor">#endif </span><span class="comment">/* Not ELIDE_CODE. */</span>
<a name="l00984"></a>00984
<a name="l00985"></a>00985 <span class="preprocessor">#ifdef TEST</span>
<a name="l00986"></a>00986 <span class="preprocessor"></span>
<a name="l00987"></a>00987 <span class="comment">/* Compile with -DTEST to make an executable for use in testing</span>
<a name="l00988"></a>00988 <span class="comment"> the above definition of `getopt'. */</span>
<a name="l00989"></a>00989
<a name="l00990"></a>00990 <span class="keywordtype">int</span>
<a name="l00991"></a>00991 <a class="code" href="ofx2qif_8c.html#0ddf1224851353fc92bfbff6f499fa97">main</a> (argc, argv)
<a name="l00992"></a>00992 int argc;
<a name="l00993"></a>00993 <span class="keywordtype">char</span> **argv;
<a name="l00994"></a>00994 {
<a name="l00995"></a>00995 <span class="keywordtype">int</span> c;
<a name="l00996"></a>00996 <span class="keywordtype">int</span> digit_optind = 0;
<a name="l00997"></a>00997
<a name="l00998"></a>00998 <span class="keywordflow">while</span> (1)
<a name="l00999"></a>00999 {
<a name="l01000"></a>01000 <span class="keywordtype">int</span> this_option_optind = optind ? optind : 1;
<a name="l01001"></a>01001
<a name="l01002"></a>01002 c = getopt (argc, argv, <span class="stringliteral">"abc:d:0123456789"</span>);
<a name="l01003"></a>01003 <span class="keywordflow">if</span> (c == -1)
<a name="l01004"></a>01004 <span class="keywordflow">break</span>;
<a name="l01005"></a>01005
<a name="l01006"></a>01006 <span class="keywordflow">switch</span> (c)
<a name="l01007"></a>01007 {
<a name="l01008"></a>01008 <span class="keywordflow">case</span> <span class="charliteral">'0'</span>:
<a name="l01009"></a>01009 <span class="keywordflow">case</span> <span class="charliteral">'1'</span>:
<a name="l01010"></a>01010 <span class="keywordflow">case</span> <span class="charliteral">'2'</span>:
<a name="l01011"></a>01011 <span class="keywordflow">case</span> <span class="charliteral">'3'</span>:
<a name="l01012"></a>01012 <span class="keywordflow">case</span> <span class="charliteral">'4'</span>:
<a name="l01013"></a>01013 <span class="keywordflow">case</span> <span class="charliteral">'5'</span>:
<a name="l01014"></a>01014 <span class="keywordflow">case</span> <span class="charliteral">'6'</span>:
<a name="l01015"></a>01015 <span class="keywordflow">case</span> <span class="charliteral">'7'</span>:
<a name="l01016"></a>01016 <span class="keywordflow">case</span> <span class="charliteral">'8'</span>:
<a name="l01017"></a>01017 <span class="keywordflow">case</span> <span class="charliteral">'9'</span>:
<a name="l01018"></a>01018 <span class="keywordflow">if</span> (digit_optind != 0 && digit_optind != this_option_optind)
<a name="l01019"></a>01019 printf (<span class="stringliteral">"digits occur in two different argv-elements.\n"</span>);
<a name="l01020"></a>01020 digit_optind = this_option_optind;
<a name="l01021"></a>01021 printf (<span class="stringliteral">"option %c\n"</span>, c);
<a name="l01022"></a>01022 <span class="keywordflow">break</span>;
<a name="l01023"></a>01023
<a name="l01024"></a>01024 <span class="keywordflow">case</span> <span class="charliteral">'a'</span>:
<a name="l01025"></a>01025 printf (<span class="stringliteral">"option a\n"</span>);
<a name="l01026"></a>01026 <span class="keywordflow">break</span>;
<a name="l01027"></a>01027
<a name="l01028"></a>01028 <span class="keywordflow">case</span> <span class="charliteral">'b'</span>:
<a name="l01029"></a>01029 printf (<span class="stringliteral">"option b\n"</span>);
<a name="l01030"></a>01030 <span class="keywordflow">break</span>;
<a name="l01031"></a>01031
<a name="l01032"></a>01032 <span class="keywordflow">case</span> <span class="charliteral">'c'</span>:
<a name="l01033"></a>01033 printf (<span class="stringliteral">"option c with value `%s'\n"</span>, optarg);
<a name="l01034"></a>01034 <span class="keywordflow">break</span>;
<a name="l01035"></a>01035
<a name="l01036"></a>01036 <span class="keywordflow">case</span> <span class="charliteral">'?'</span>:
<a name="l01037"></a>01037 <span class="keywordflow">break</span>;
<a name="l01038"></a>01038
<a name="l01039"></a>01039 <span class="keywordflow">default</span>:
<a name="l01040"></a>01040 printf (<span class="stringliteral">"?? getopt returned character code 0%o ??\n"</span>, c);
<a name="l01041"></a>01041 }
<a name="l01042"></a>01042 }
<a name="l01043"></a>01043
<a name="l01044"></a>01044 <span class="keywordflow">if</span> (optind < argc)
<a name="l01045"></a>01045 {
<a name="l01046"></a>01046 printf (<span class="stringliteral">"non-option ARGV-elements: "</span>);
<a name="l01047"></a>01047 <span class="keywordflow">while</span> (optind < argc)
<a name="l01048"></a>01048 printf (<span class="stringliteral">"%s "</span>, argv[optind++]);
<a name="l01049"></a>01049 printf (<span class="stringliteral">"\n"</span>);
<a name="l01050"></a>01050 }
<a name="l01051"></a>01051
<a name="l01052"></a>01052 exit (0);
<a name="l01053"></a>01053 }
<a name="l01054"></a>01054
<a name="l01055"></a>01055 <span class="preprocessor">#endif </span><span class="comment">/* TEST */</span>
</pre></div><hr size="1"><address style="text-align: right;"><small>Generated on Mon Nov 19 20:27:58 2007 for LibOFX by
<a href="http://www.doxygen.org/index.html">
<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.5.3 </small></address>
</body>
</html>
|
