1 /***********************************************************************
2 * *
3 * This software is part of the ast package *
4 * Copyright (c) 1990-2012 AT&T Intellectual Property *
5 * and is licensed under the *
6 * Eclipse Public License, Version 1.0 *
7 * by AT&T Intellectual Property *
8 * *
9 * A copy of the License is available at *
10 * http://www.eclipse.org/org/documents/epl-v10.html *
11 * (with md5 checksum b35adb5213ca9657e911e9befb180842) *
12 * *
13 * Information and Software Systems Research *
14 * AT&T Research *
15 * Florham Park NJ *
16 * *
17 * Glenn Fowler <gsf@research.att.com> *
18 * *
19 ***********************************************************************/
20
21 /* : : generated by proto : : */
22
23 #if !defined(__PROTO__)
24 # if defined(__STDC__) || defined(__cplusplus) || defined(_proto) || defined(c_plusplus)
25 # if defined(__cplusplus)
26 # define __LINKAGE__ "C"
27 # else
28 # define __LINKAGE__
29 # endif
30 # define __STDARG__
31 # define __PROTO__(x) x
32 # define __OTORP__(x)
33 # define __PARAM__(n,o) n
34 # if !defined(__STDC__) && !defined(__cplusplus)
35 # if !defined(c_plusplus)
36 # define const
37 # endif
38 # define signed
39 # define void int
40 # define volatile
41 # define __V_ char
42 # else
43 # define __V_ void
44 # endif
45 # else
46 # define __PROTO__(x) ()
47 # define __OTORP__(x) x
48 # define __PARAM__(n,o) o
49 # define __LINKAGE__
50 # define __V_ char
51 # define const
52 # define signed
53 # define void int
54 # define volatile
55 # endif
56 # define __MANGLE__ __LINKAGE__
57 # if defined(__cplusplus) || defined(c_plusplus)
58 # define __VARARG__ ...
59 # else
60 # define __VARARG__
61 # endif
62 # if defined(__STDARG__)
63 # define __VA_START__(p,a) va_start(p,a)
64 # else
65 # define __VA_START__(p,a) va_start(p)
66 # endif
67 # if !defined(__INLINE__)
68 # if defined(__cplusplus)
69 # define __INLINE__ extern __MANGLE__ inline
70 # else
71 # if defined(_WIN32) && !defined(__GNUC__)
72 # define __INLINE__ __inline
73 # endif
74 # endif
75 # endif
76 #endif
77 #if !defined(__LINKAGE__)
78 #define __LINKAGE__ /* 2004-08-11 transition */
79 #endif
80 #line 1 "proto.c"
81
82
83 #line 151
84 # ifndef __STDC__
85 # ifndef creat
86 # define creat _huh_creat
87 # endif
88 # if 1
89 # ifndef access
90 # define access _huh_access
91 # endif
92 # ifndef ctime
93 # define ctime _huh_ctime
94 # endif
95 # ifndef mkdir
96 # define mkdir _huh_mkdir
97 # endif
98 # endif
99 # endif
100
101 # include <sys/types.h>
102 # include <sys/stat.h>
103 # include <fcntl.h>
104 # if 1
105 # include <stdio.h>
106 # else
107 # include <time.h>
108 # endif
109
110 # ifndef __STDC__
111 # undef access
112 # undef ctime
113 # undef creat
114 # undef mkdir
115 # endif
116
117 # ifndef O_RDONLY
118 # define O_RDONLY 0
119 # endif
120
121 # ifndef S_IRUSR
122 # define S_IRUSR 0400
123 # endif
124 # ifndef S_IWUSR
125 # define S_IWUSR 0200
126 # endif
127 # ifndef S_IXUSR
128 # define S_IXUSR 0100
129 # endif
130 # ifndef S_IRGRP
131 # define S_IRGRP 0040
132 # endif
133 # ifndef S_IWGRP
134 # define S_IWGRP 0020
135 # endif
136 # ifndef S_IXGRP
137 # define S_IXGRP 0010
138 # endif
139 # ifndef S_IROTH
140 # define S_IROTH 0004
141 # endif
142 # ifndef S_IWOTH
143 # define S_IWOTH 0002
144 # endif
145 # ifndef S_IXOTH
146 # define S_IXOTH 0001
147 # endif
148
149 # ifndef __STDC__
150 # if !_WIN32 && !_WINIX
151 # define remove(x) unlink(x)
152 # define rename(x,y) ((link(x,y)||remove(x))?-1:0)
153 # endif
154
155 # if 1
156 extern __MANGLE__ int access __PROTO__((const char*, int));
157 extern __MANGLE__ int mkdir __PROTO__((const char*, int));
158 # endif
159
160 # endif
161
162 # if 1
163 extern __MANGLE__ int utime __PROTO__((const char*, time_t*));
164 # endif
165
166
167
168
169
170
171 int
__OTORP__(const char * newfile;const char * oldfile;int preserve;)172 replace __PARAM__((const char* newfile, const char* oldfile, int preserve), (newfile, oldfile, preserve)) __OTORP__(const char* newfile; const char* oldfile; int preserve;){
173 struct stat st;
174 time_t ut[2];
175
176 if (stat(oldfile, &st))
177 {
178 if (preserve)
179 return -1;
180 st.st_mode = 0;
181 }
182 if (remove(oldfile) || rename(newfile, oldfile))
183 return -1;
184 if (st.st_mode &= (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH))
185 chmod(oldfile, st.st_mode);
186 if (preserve)
187 {
188 ut[0] = st.st_atime;
189 ut[1] = st.st_mtime;
190 preserve = utime(oldfile, ut);
191 }
192 return preserve;
193 }
194
195 # undef utime
196 # define utime ______utime
197
198 #line 1 "../../lib/libpp/ppproto.c"
199
200 #line 13
201 static const char id[] = "\n@(#)$Id: proto (AT&T Research) 2012-04-14 $\000\n";
202
203 #line 1 "../../lib/libpp/ppfsm.c"
204
205 #line 1 "../../lib/libpp/pplib.h"
206
207 #line 108
208 struct ppsymbol;
209 struct ppindex;
210
211 typedef char* (*PPBUILTIN) __PROTO__((char*, const char*, const char*));
212 typedef void (*PPCOMMENT) __PROTO__((const char*, const char*, const char*, int));
213 typedef void (*PPINCREF) __PROTO__((const char*, const char*, int, int));
214 typedef void (*PPLINESYNC) __PROTO__((int, const char*));
215 typedef void (*PPMACREF) __PROTO__((struct ppsymbol*, const char*, int, int, unsigned long));
216 typedef int (*PPOPTARG) __PROTO__((int, int, const char*));
217 typedef void (*PPPRAGMA) __PROTO__((const char*, const char*, const char*, const char*, int));
218
219 struct ppinstk
220 {
221 char* nextchr;
222 struct ppinstk* next;
223 struct ppinstk* prev;
224 long* control;
225 char* buffer;
226 char* file;
227 char* prefix;
228 struct ppsymbol* symbol;
229
230 struct ppindex* index;
231 int buflen;
232
233 int line;
234 int vendor;
235 short fd;
236 short hide;
237 short flags;
238 char type;
239 };
240
241
242
243
244
245
246
247
248
249 struct pplist
250 {
251 char* value;
252 struct pplist* next;
253 };
254
255 struct oplist
256 {
257 int op;
258 char* value;
259 struct oplist* next;
260 };
261
262 struct pphide
263 {
264 struct ppmacro* macro;
265 unsigned long flags;
266 int level;
267 };
268
269 struct ppmacstk
270 {
271 struct ppmacstk* next;
272 struct ppmacstk* prev;
273 int line;
274 char* arg[1];
275 };
276
277 struct ppmember
278 {
279 struct ppdirs* archive;
280 unsigned long offset;
281 unsigned long size;
282 };
283
284 struct counter
285 {
286 int candidate;
287 int function;
288 int macro;
289 int pplex;
290 int push;
291 int terminal;
292 int token;
293 };
294
295 struct pptuple
296 {
297 struct pptuple* nomatch;
298 struct pptuple* match;
299 char token[1];
300 };
301
302 struct ppfileid
303 {
304 unsigned long st_dev;
305 unsigned long st_ino;
306 };
307
308 struct pathid
309 {
310 char* path;
311 struct ppfileid id;
312 };
313
314 #line 1 "../../lib/libpp/pp.h"
315
316 #line 206
317
318 #line 217
319
320 #line 329
321 struct ppdirs
322 {
323 char* name;
324 struct ppdirs* next;
325
326
327 unsigned char c; unsigned char index; unsigned char type; union { char* buffer; char* sp; struct ppdirs* subdir; } info; struct ppfileid id;
328
329
330 };
331
332 struct ppkeyword
333 {
334 char* name;
335 int value;
336 };
337
338 struct ppmacro
339 {
340 int arity;
341 char* value;
342
343
344 struct pptuple* tuple; char* formals; int size;
345
346
347 };
348
349 struct ppsymbol
350 {
351 int hash_header;
352 unsigned long flags;
353 struct ppmacro* macro;
354 __V_* value;
355
356
357 struct pphide* hidden;
358
359
360 };
361
362 #line 378
363 struct ppglobals
364 {
365 const char* version;
366 char* lineid;
367 char* outfile;
368 char* pass;
369 char* token;
370 struct ppsymbol* symbol;
371
372
373
374 char* outb;
375 char* outbuf;
376 char* outp;
377 char* oute;
378 unsigned long offset;
379
380
381 struct ppdirs* lcldirs; struct ppdirs* stddirs; int flags; char* symtab;
382
383
384
385 struct ppcontext* context; long state; long mode; long option; long test; struct { char* sp; long flags; } filedeps; struct ppdirs* firstdir; struct ppdirs* lastdir; int hide; int column; int pending; char* firstfile; char* lastfile; char* ignore; char* probe; char* filtab; char* prdtab; char* date; char* time; char* maps; long ro_state; long ro_mode; long ro_option; long ro_op[2]; struct pathid cdir; struct pathid hostdir; char* ppdefault; struct ppindex* firstindex; struct ppindex* lastindex; struct oplist* firstop; struct oplist* lastop; struct oplist* firsttx; struct oplist* lasttx; unsigned char arg_file; unsigned char arg_mode; unsigned char arg_style; unsigned char c; unsigned char hosted; unsigned char ignoresrc; unsigned char initialized; unsigned char standalone; unsigned char spare_1;
386
387
388
389 char* checkpoint; int constack; struct ppinstk* in; char* addp; char* args; char* addbuf; char* catbuf; char* hdrbuf; char* hidebuf; char* path; char* tmpbuf; char* valbuf; char* optflags; int lastout; char* include; char* prefix; struct ppmember* member; int hidden; int hiding; int level; struct { int input; int output; } pool; struct { long ro_state; long ro_mode; long ro_option; long ro_op[2]; int on; char* symtab; } reset; int truncate; struct ppmacstk* macp; char* maxmac; char* mactop; char* toknxt; long* control; long* maxcon; struct oplist* chop; struct ppfile* insert; struct ppfile* original; struct ppdirs* found; int vendor; char* dirtab; char* strtab; PPBUILTIN builtin; PPCOMMENT comment; PPINCREF incref; PPLINESYNC linesync; PPLINESYNC olinesync; PPMACREF macref; PPOPTARG optarg; PPPRAGMA pragma; struct counter counter; char funbuf[256];
390
391
392 };
393
394
395
396
397
398
399
400 extern __MANGLE__ struct ppglobals pp;
401 extern __MANGLE__ char _pp_ctype[];
402
403 extern __MANGLE__ int ppargs __PROTO__((char**, int));
404 extern __MANGLE__ void ppcpp __PROTO__((void));
405 extern __MANGLE__ void ppcomment __PROTO__((char*, char*, char*, int));
406 extern __MANGLE__ __V_* ppcontext __PROTO__((__V_*, int));
407 extern __MANGLE__ void pperror __PROTO__((int, ...));
408 extern __MANGLE__ void ppincref __PROTO__((char*, char*, int, int));
409 extern __MANGLE__ void ppinput __PROTO__((char*, char*, int));
410 extern __MANGLE__ int pplex __PROTO__((void));
411 extern __MANGLE__ void ppline __PROTO__((int, char*));
412 extern __MANGLE__ void ppmacref __PROTO__((struct ppsymbol*, char*, int, int, unsigned long));
413 extern __MANGLE__ void ppop __PROTO__((int, ...));
414 extern __MANGLE__ void pppragma __PROTO__((char*, char*, char*, char*, int));
415 extern __MANGLE__ int ppprintf __PROTO__((char*, ...));
416 extern __MANGLE__ int ppsync __PROTO__((void));
417
418 #line 368 "../../lib/libpp/pplib.h"
419
420 #line 1 "../../lib/libpp/ppdef.h"
421
422 #line 369 "../../lib/libpp/pplib.h"
423
424 #line 1 "../../lib/libpp/ppkey.h"
425
426 #line 16
427
428 #line 125
429 extern __MANGLE__ struct ppkeyword ppkey[];
430
431 #line 370 "../../lib/libpp/pplib.h"
432
433 #line 683
434 struct ppcontext
435 {
436 struct ppdirs* lcldirs; struct ppdirs* stddirs; int flags; char* symtab;
437 struct ppcontext* context; long state; long mode; long option; long test; struct { char* sp; long flags; } filedeps; struct ppdirs* firstdir; struct ppdirs* lastdir; int hide; int column; int pending; char* firstfile; char* lastfile; char* ignore; char* probe; char* filtab; char* prdtab; char* date; char* time; char* maps; long ro_state; long ro_mode; long ro_option; long ro_op[2]; struct pathid cdir; struct pathid hostdir; char* ppdefault; struct ppindex* firstindex; struct ppindex* lastindex; struct oplist* firstop; struct oplist* lastop; struct oplist* firsttx; struct oplist* lasttx; unsigned char arg_file; unsigned char arg_mode; unsigned char arg_style; unsigned char c; unsigned char hosted; unsigned char ignoresrc; unsigned char initialized; unsigned char standalone; unsigned char spare_1;
438 };
439
440 struct ppfile
441 {
442 int hash_header;
443 struct ppsymbol* guard;
444 struct ppfile* bound[4];
445 int flags;
446 };
447
448
449
450 struct ppindex
451 {
452 struct ppindex* next;
453 struct ppfile* file;
454 unsigned long begin;
455 unsigned long end;
456 };
457
458
459
460 struct ppsymkey
461 {
462 struct ppsymbol sym;
463 int lex;
464 };
465
466 #line 729
467 # ifdef __STDC__
468
469 # include <stdlib.h>
470 # include <unistd.h>
471 # include <time.h>
472 # include <string.h>
473
474 # else
475
476 # define size_t int
477
478 extern __MANGLE__ __V_* realloc __PROTO__((__V_*, size_t));
479 extern __MANGLE__ __V_* calloc __PROTO__((size_t, size_t));
480 extern __MANGLE__ char* ctime __PROTO__((time_t*));
481 extern __MANGLE__ void free __PROTO__((__V_*));
482
483 # ifndef O_RDONLY
484
485 extern __MANGLE__ int access __PROTO__((const char*, int));
486 extern __MANGLE__ int close __PROTO__((int));
487 extern __MANGLE__ int creat __PROTO__((const char*, int));
488 extern __MANGLE__ void exit __PROTO__((int));
489 extern __MANGLE__ int link __PROTO__((const char*, const char*));
490 extern __MANGLE__ int open __PROTO__((const char*, int, ...));
491 extern __MANGLE__ int read __PROTO__((int, __V_*, int));
492 extern __MANGLE__ time_t time __PROTO__((time_t*));
493 extern __MANGLE__ int unlink __PROTO__((const char*));
494 extern __MANGLE__ int write __PROTO__((int, const __V_*, int));
495
496 # endif
497
498 # endif
499
500 #line 802
501 extern __MANGLE__ void ppassert __PROTO__((int, char*, char*));
502 extern __MANGLE__ void ppbuiltin __PROTO__((void));
503 extern __MANGLE__ int ppcall __PROTO__((struct ppsymbol*, int));
504 extern __MANGLE__ int ppcontrol __PROTO__((void));
505 extern __MANGLE__ void ppdump __PROTO__((void));
506 extern __MANGLE__ char* ppexpand __PROTO__((char*));
507 extern __MANGLE__ long ppexpr __PROTO__((int*));
508 extern __MANGLE__ void ppfsm __PROTO__((int, char*));
509 extern __MANGLE__ char* ppinstr __PROTO__((struct ppinstk*));
510 extern __MANGLE__ char* ppkeyname __PROTO__((int, int));
511 extern __MANGLE__ char* pplexstr __PROTO__((int));
512 extern __MANGLE__ void ppload __PROTO__((char*));
513 extern __MANGLE__ void ppmapinclude __PROTO__((char*, char*));
514 extern __MANGLE__ char* ppmodestr __PROTO__((long));
515 extern __MANGLE__ int ppmultiple __PROTO__((struct ppfile*, struct ppsymbol*));
516 extern __MANGLE__ void ppnest __PROTO__((void));
517 extern __MANGLE__ int ppoption __PROTO__((char*));
518 extern __MANGLE__ char* ppoptionstr __PROTO__((long));
519 extern __MANGLE__ void pppclose __PROTO__((char*));
520 extern __MANGLE__ int pppdrop __PROTO__((char*));
521 extern __MANGLE__ char* pppopen __PROTO__((char*, int, char*, char*, char*, char*, int));
522 extern __MANGLE__ int pppread __PROTO__((char*));
523 extern __MANGLE__ int pppredargs __PROTO__((void));
524 extern __MANGLE__ void pppush __PROTO__((int, char*, char*, int));
525 extern __MANGLE__ struct ppsymbol* pprefmac __PROTO__((char*, int));
526 extern __MANGLE__ int ppsearch __PROTO__((char*, int, int));
527 extern __MANGLE__ int ppset __PROTO__((long*, long, int));
528 extern __MANGLE__ char* ppstatestr __PROTO__((long));
529 extern __MANGLE__ char* pptokstr __PROTO__((char*, int));
530 extern __MANGLE__ void pptrace __PROTO__((int));
531
532 #line 11 "../../lib/libpp/ppfsm.c"
533
534 #line 1 "../../lib/libpp/ppfsm.h"
535
536 #line 185
537
538 #line 249
539 extern __MANGLE__ short _pp_fsmtab[(0+28)+1][255+1];
540
541
542
543
544
545 extern __MANGLE__ char _pp_trigraph[255+1];
546
547 extern __MANGLE__ void _pp_refill __PROTO__((int));
548
549 #line 12 "../../lib/libpp/ppfsm.c"
550
551
552 #line 67
553 struct fsminit
554 {
555 int state;
556 unsigned char ch[4];
557 int nextstate;
558 };
559
560 static struct fsminit fsminit[] =
561 {
562
563 { 0, { 023 }, ((0+28)+11), },
564 { 0, { 002 }, (0), },
565 { 0, { 001 }, (0+23), },
566 { 0, { '.' }, (0+25), },
567 { 0, { 021 }, (0+19), },
568 { 0, { 'L' }, (0+20), },
569 { 0, { 'd', 'e', 'f', 'i' }, (0+1), },
570 { 0, { 'r', 's', 't', 'v' }, (0+1), },
571 { 0, { 'w', 'N' }, (0+1), },
572 { 0, { '"', '\'' }, ((0+28)+3), },
573 { 0, { '/' }, (0+12), },
574 { 0, { '\n' }, ((0+28)+7), },
575 { 0, { ' ','\t','\f','\013' }, (0+27), },
576
577
578 { (0+1), { 023 }, ((0+28)+6), },
579 { (0+1), { 021, 001 }, (0+19), },
580 { (0+1), { 'a' }, (0+2), },
581 { (0+1), { 'e' }, (0+3), },
582 { (0+1), { 'f' }, (0+4), },
583 { (0+1), { 'h' }, (0+5), },
584 { (0+1), { 'l' }, (0+6), },
585 { (0+1), { 'n' }, (0+7), },
586 { (0+1), { 'o' }, (0+8), },
587 { (0+1), { 't' }, (0+9), },
588 { (0+1), { 'x' }, (0+10), },
589 { (0+1), { 'y' }, (0+11), },
590
591
592 { (0+2), { 023 }, (((0+28)+12)), },
593 { (0+2), { 021, 001 }, (0+19), },
594 { (0+2), { '_','s','t','a' }, (0+2), },
595 { (0+2), { 'r' }, (0+2), },
596
597
598 { (0+3), { 023 }, (((0+28)+12)), },
599 { (0+3), { 021, 001 }, (0+19), },
600 { (0+3), { 't','u','r','n' }, (0+3), },
601
602
603 { (0+4), { 023 }, (((0+28)+12)), },
604 { (0+4), { 021, 001 }, (0+19), },
605
606
607 { (0+5), { 023 }, (((0+28)+12)), },
608 { (0+5), { 021, 001 }, (0+19), },
609 { (0+5), { 'i','l','e' }, (0+5), },
610
611
612 { (0+6), { 023 }, (((0+28)+12)), },
613 { (0+6), { 021, 001 }, (0+19), },
614 { (0+6), { 's','e' }, (0+6), },
615
616
617 { (0+7), { 023 }, (((0+28)+12)), },
618 { (0+7), { 021, 001 }, (0+19), },
619 { (0+7), { 'l','i','n','e' }, (0+7), },
620
621
622 { (0+8), { 023 }, (((0+28)+12)), },
623 { (0+8), { 021, 001 }, (0+19), },
624 { (0+8), { 'r','i','d','N' }, (0+8), },
625
626
627 { (0+9), { 023 }, (((0+28)+12)), },
628 { (0+9), { 021, 001 }, (0+19), },
629 { (0+9), { 'a','t','i','c' }, (0+9), },
630
631
632 { (0+10), { 023 }, (((0+28)+12)), },
633 { (0+10), { 021, 001 }, (0+19), },
634 { (0+10), { 't','e','r','n' }, (0+10), },
635
636
637 { (0+11), { 023 }, (((0+28)+12)), },
638 { (0+11), { 021, 001 }, (0+19), },
639 { (0+11), { 'p','e','d','f' }, (0+11), },
640
641
642 { (0+12), { 023 }, ((0+28)+0), },
643 { (0+12), { '*' }, (0+13), },
644
645 { (0+12), { '/' }, (0+16), },
646
647
648
649 { (0+13), { 023 }, (0+13), },
650 { (0+13), { '\n', 002 }, ((0+28)+1), },
651 { (0+13), { '/' }, (0+15), },
652 { (0+13), { '*' }, (0+14), },
653 { (0+13), { '#', ';', ')' }, ((( (0+13))<<(7+1))|(((0+28)+8))), },
654
655
656 { (0+14), { 023 }, (0+13), },
657 { (0+14), { '\n', 002 }, ((0+28)+1), },
658 { (0+14), { '#', ';', ')' }, ((( (0+13))<<(7+1))|(((0+28)+8))), },
659 { (0+14), { '*' }, (0+14), },
660 { (0+14), { '/' }, ((0+28)+1), },
661
662
663 { (0+15), { 023 }, (0+13), },
664 { (0+15), { '*', '\n', 002 }, ((0+28)+1), },
665 { (0+15), { '/' }, (0+15), },
666
667
668 { (0+16), { 023 }, (0+16), },
669 { (0+16), { '\n', 002 }, ((0+28)+1), },
670 { (0+16), { '/' }, (0+17), },
671 { (0+16), { '*' }, (0+18), },
672
673
674 { (0+17), { 023 }, (0+16), },
675 { (0+17), { '*', '\n', 002 }, ((0+28)+1), },
676 { (0+17), { '/' }, (0+17), },
677
678
679 { (0+18), { 023 }, (0+16), },
680 { (0+18), { '\n', 002 }, ((0+28)+1), },
681 { (0+18), { '*' }, (0+18), },
682 { (0+18), { '/' }, ((0+28)+1), },
683
684
685 { (0+19), { 023 }, ((0+28)+6), },
686 { (0+19), { 021, 001 }, (0+19), },
687
688
689 { (0+25), { 023 }, ((0+28)+0), },
690 { (0+25), { '.' }, (0+26), },
691 { (0+25), { 001 }, (0+23), },
692
693
694 { (0+26), { 023 }, (((( (0401+1))-0401)<<(7+1))|( ((0+28)+14))), },
695 { (0+26), { '.' }, (((( (0401+29))-0401)<<(7+1))|( ((0+28)+13))), },
696
697
698 { (0+20), { 023 }, ((0+28)+6), },
699 { (0+20), { 021, 001 }, (0+19), },
700 { (0+20), { '"', '\'' }, ((( (0+21))<<(7+1))|(((0+28)+8))), },
701
702
703 { (0+21), { 023 }, (0+21), },
704 { (0+21), { '"', '\'' }, ((0+28)+4), },
705 { (0+21), { '\n', 002 }, ((0+28)+4), },
706 { (0+21), { '\\' }, (0+22), },
707
708
709 { (0+22), { 023 }, ((0+28)+5), },
710 { (0+22), { '\n', 002 }, ((0+28)+4), },
711
712
713 { (0+23), { 023 }, (((( (0401+1))-0401)<<(7+1))|( ((0+28)+14))), },
714 { (0+23), { 021, 001, '.' }, (0+23), },
715 { (0+23), { 'e', 'E' }, (0+24), },
716
717
718 { (0+24), { 023 }, (((( (0401+1))-0401)<<(7+1))|( ((0+28)+14))), },
719 { (0+24), { 021, 001, '.' }, (0+23), },
720 { (0+24), { '+', '-' }, (0+23), },
721
722
723 { (0+27), { 023 }, ((0+28)+15), },
724 { (0+27), { ' ', '\t' }, (0+27), },
725 { (0+27), { '\f', '\013' }, ((0+28)+10), },
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 #line 528
917 { (-1), { 0 }, 0, }
918 };
919
920 short _pp_fsmtab[(0+28)+1][255+1];
921
922 char _pp_trigraph[255+1];
923
924
925 static char spl[] = { '\\', '\r', 0 };
926 static char aln[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_$@";
927
928
929
930
931 static char* let = &aln[10];
932 static char hex[] = "fedcbaFEDCBA9876543210";
933 static char* dec = &hex[12];
934 static char* oct = &hex[14];
935
936
937
938
939
940
941 void
__OTORP__(int op;register char * s;)942 ppfsm __PARAM__((int op, register char* s), (op, s)) __OTORP__(int op; register char* s;){
943 register int c;
944 register int n;
945 register int i;
946 register short* rp;
947 register struct fsminit* fp;
948
949
950
951
952
953 switch (op)
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 case 4:
985 for (fp = fsminit;; fp++)
986 {
987 if ((n = fp->nextstate) >= (0+28)) n = ~n;
988 if (fp->state == (-1))
989 {
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003 break;
1004 }
1005 rp = _pp_fsmtab[fp->state];
1006 for (i = 0; i < sizeof(fp->ch) && (c = fp->ch[i]); i++)
1007 {
1008 switch (c)
1009 {
1010 case 023:
1011 for (c = 0; c <= 255; c++)
1012 rp[c] = n;
1013
1014
1015 case 002:
1016 _pp_fsmtab[(0+28)][fp->state+1] = n < 0 ? ~n : n;
1017 continue;
1018
1019 case 021:
1020 s = let;
1021 break;
1022
1023 case 003:
1024 s = hex;
1025 break;
1026
1027 case 001:
1028 s = dec;
1029 break;
1030
1031 case 022:
1032 s = oct;
1033 break;
1034
1035 default:
1036 rp[c] = n;
1037 continue;
1038 }
1039 while (c = *s++)
1040 rp[c] = n;
1041 }
1042 }
1043
1044
1045
1046
1047
1048
1049 for (i = 0; i < (0+28); i++)
1050 {
1051 rp = _pp_fsmtab[i];
1052 s = spl;
1053 while (c = *s++)
1054 if (c != '@' || !(( rp)>=_pp_fsmtab[(0+13)]&&( rp)<=_pp_fsmtab[(0+18)]))
1055 {
1056 if (rp[c] >= 0) rp[c] = ~rp[c];
1057 rp[c] &= ~(1<<7);
1058 }
1059 rp[0] = ~((0+28)+2);
1060 for (c = 0; c <= 255; c++)
1061 if (rp[c] == i)
1062 rp[c] = 0;
1063 }
1064 _pp_fsmtab[(0+28)][0] = ~((0+28)+2);
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083 #line 707
1084 break;
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223 #line 860
1224 }
1225 }
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276 #line 18 "../../lib/libpp/ppproto.c"
1277
1278 #line 1 "../../../include/ast/hashkey.h"
1279
1280 #line 24
1281
1282
1283 #line 68
1284 extern __MANGLE__ long strkey __PROTO__((const char*));
1285
1286 #line 20 "../../lib/libpp/ppproto.c"
1287
1288 #line 41
1289 typedef struct Key_s
1290 {
1291 const char* name;
1292 size_t size;
1293 int hit;
1294 int val;
1295 } Key_t;
1296
1297 typedef struct Proto_s
1298 {
1299 int brace;
1300 int call;
1301 int fd;
1302 char* file;
1303 long flags;
1304 long options;
1305 char* package;
1306 int line;
1307 int test;
1308
1309 char* tp;
1310
1311 int iz;
1312 char* ib;
1313 char* ip;
1314
1315 int oz;
1316 char* ob;
1317 char* op;
1318 char* ox;
1319
1320 char cc[3];
1321 char pushback[4];
1322
1323 char variadic[256];
1324
1325
1326
1327
1328 } Proto_t;
1329
1330
1331 #line 171
1332 static const Key_t pragmas[] =
1333 {
1334 { "prototyped",sizeof( "prototyped")-1, 0x01, 1},
1335 { "noprototyped",sizeof( "noprototyped")-1, 0x01, 0},
1336 { "noticed",sizeof( "noticed")-1, 0x02, 1},
1337 { "nonoticed",sizeof( "nonoticed")-1, 0x02, 0},
1338 };
1339
1340 static const Key_t notices[] =
1341 {
1342 { "Copyright",sizeof( "Copyright")-1, 0x02, 1},
1343 { "COPYRIGHT",sizeof( "COPYRIGHT")-1, 0x02, 1},
1344 { "copyright",sizeof( "copyright")-1, 0x02, 1},
1345 { "Public Domain",sizeof( "Public Domain")-1, 0x02, 0},
1346 { "PUBLIC DOMAIN",sizeof( "PUBLIC DOMAIN")-1, 0x02, 0},
1347 };
1348
1349
1350
1351
1352
1353
1354 static char*
__OTORP__(register char * p;register long n;)1355 number __PARAM__((register char* p, register long n), (p, n)) __OTORP__(register char* p; register long n;){
1356 register long d;
1357
1358 for (d = 1000000; d > 1; d /= 10)
1359 if (n >= d) *p++ = '0' + (n / d) % 10;
1360 *p++ = '0' + n % 10;
1361 return p;
1362 }
1363
1364
1365
1366 static int errors;
1367
1368
1369 #line 224
1370
1371
1372
1373
1374 static int
__OTORP__(register const char * s;)1375 sstrlen __PARAM__((register const char* s), (s)) __OTORP__(register const char* s;){
1376 register const char* b;
1377
1378 for (b = s; *s; s++);
1379 return s - b;
1380 }
1381
1382
1383
1384
1385
1386 static int
__OTORP__(register const char * s;register const char * t;register int n;)1387 sstrncmp __PARAM__((register const char* s, register const char* t, register int n), (s, t, n)) __OTORP__(register const char* s; register const char* t; register int n;){
1388 register const char* e = s + n;
1389
1390 while (s < e)
1391 {
1392 if (*s != *t || !*s)
1393 return *s - *t;
1394 s++;
1395 t++;
1396 }
1397 return 0;
1398 }
1399
1400
1401
1402
1403
1404 static char*
__OTORP__(register char * s;register const char * t;)1405 strcopy __PARAM__((register char* s, register const char* t), (s, t)) __OTORP__(register char* s; register const char* t;){
1406 while (*s++ = *t++);
1407 return s - 1;
1408 }
1409
1410
1411
1412 static void
__OTORP__(char * iob;int level;char * msg;char * arg;)1413 proto_error __PARAM__((char* iob, int level, char* msg, char* arg), (iob, level, msg, arg)) __OTORP__(char* iob; int level; char* msg; char* arg;){
1414 register char* p;
1415 char buf[1024];
1416
1417 p = strcopy(buf, "proto: ");
1418 if (iob)
1419 {
1420 register Proto_t* proto = (Proto_t*)(iob - sizeof(Proto_t));
1421
1422 if (proto->line)
1423 {
1424 if (proto->file)
1425 {
1426 *p++ = '"';
1427 p = strcopy(p, proto->file);
1428 *p++ = '"';
1429 *p++ = ',';
1430 *p++ = ' ';
1431 }
1432 p = strcopy(p, "line ");
1433 p = number(p, proto->line);
1434 }
1435 else if (proto->file)
1436 p = strcopy(p, proto->file);
1437 }
1438 else
1439 {
1440 p = strcopy(p, msg);
1441 msg = arg;
1442 arg = 0;
1443 }
1444 if (*(p - 1) != ' ')
1445 {
1446 *p++ = ':';
1447 *p++ = ' ';
1448 }
1449 if (level == 1)
1450 p = strcopy(p, "warning: ");
1451 p = strcopy(p, msg);
1452 if (arg)
1453 {
1454 *p++ = ' ';
1455 p = strcopy(p, arg);
1456 }
1457 *p++ = '\n';
1458 write(2, buf, p - buf);
1459 if (level >= 3)
1460 exit(level - 2);
1461 if (level >= 2)
1462 errors++;
1463 }
1464
1465
1466
1467
1468
1469 static char*
__OTORP__(register char * s;register char * t;int n;)1470 memcopy __PARAM__((register char* s, register char* t, int n), (s, t, n)) __OTORP__(register char* s; register char* t; int n;){
1471 register char* e = t + n;
1472
1473 while (t < e) *s++ = *t++;
1474 return s;
1475 }
1476
1477 #line 1 "../../lib/libast/port/astlicense.c"
1478
1479
1480
1481 #line 92
1482 typedef struct Buffer_s
1483 {
1484 char* buf;
1485 char* nxt;
1486 char* end;
1487 int siz;
1488 } Buffer_t;
1489
1490 typedef struct Item_s
1491 {
1492 char* data;
1493 int size;
1494 int quote;
1495 } Item_t;
1496
1497 typedef struct Id_s
1498 {
1499 Item_t name;
1500 Item_t value;
1501 } Id_t;
1502
1503
1504
1505
1506
1507
1508
1509 static const Item_t key[] =
1510 {
1511 { "author",sizeof( "author")-1,0},
1512 { "class",sizeof( "class")-1,0},
1513 { "company",sizeof( "company")-1,0},
1514 { "component",sizeof( "component")-1,0},
1515 { "contributor",sizeof( "contributor")-1,0},
1516 { "corporation",sizeof( "corporation")-1,0},
1517 { "domain",sizeof( "domain")-1,0},
1518 { "id",sizeof( "id")-1,0},
1519 { "incorporation",sizeof( "incorporation")-1,0},
1520 { "license",sizeof( "license")-1,0},
1521 { "location",sizeof( "location")-1,0},
1522 { "name",sizeof( "name")-1,0},
1523 { "notice",sizeof( "notice")-1,0},
1524 { "organization",sizeof( "organization")-1,0},
1525 { "package",sizeof( "package")-1,0},
1526 { "parent",sizeof( "parent")-1,0},
1527 { "query",sizeof( "query")-1,0},
1528 { "since",sizeof( "since")-1,0},
1529 { "source",sizeof( "source")-1,0},
1530 { "start",sizeof( "start")-1,0},
1531 { "type",sizeof( "type")-1,0},
1532 { "url",sizeof( "url")-1,0},
1533 { "urlmd5",sizeof( "urlmd5")-1,0},
1534 { "version",sizeof( "version")-1,0},
1535 {0}
1536 };
1537
1538
1539
1540
1541
1542 static const Item_t lic[] =
1543 {
1544 { "none",sizeof( "none")-1, 0},
1545 { "inline",sizeof( "inline")-1, 12},
1546 { "test",sizeof( "test")-1, 2},
1547 { "verbose",sizeof( "verbose")-1, 3},
1548 { "usage",sizeof( "usage")-1, 4},
1549 { "open",sizeof( "open")-1, 5},
1550 { "cpl",sizeof( "cpl")-1, 5},
1551 { "epl",sizeof( "epl")-1, 5},
1552 { "bsd",sizeof( "bsd")-1, 5},
1553 { "zlib",sizeof( "zlib")-1, 5},
1554 { "mit",sizeof( "mit")-1, 5},
1555 { "gpl",sizeof( "gpl")-1, 11},
1556 { "special",sizeof( "special")-1, 12},
1557 { "nonexclusive",sizeof( "nonexclusive")-1, 12},
1558 { "noncommercial",sizeof( "noncommercial")-1, 12},
1559 { "proprietary",sizeof( "proprietary")-1, 15},
1560 {0}
1561 };
1562
1563 typedef struct Notice_s
1564 {
1565 int test;
1566 int type;
1567 int verbose;
1568 int ids;
1569 Item_t item[(sizeof(key)/sizeof(key[0])-1)];
1570 Id_t id[64];
1571 char cc[3];
1572 } Notice_t;
1573
1574
1575
1576
1577
1578 static int
__OTORP__(register const Item_t * item;const char * name;int size;)1579 lookup __PARAM__((register const Item_t* item, const char* name, int size), (item, name, size)) __OTORP__(register const Item_t* item; const char* name; int size;){
1580 register int c;
1581 register int i;
1582
1583 c = name[0];
1584 for (i = 0; item[i].data; i++)
1585 if (c == item[i].data[0] && size == item[i].size && !sstrncmp( name, item[i].data, size))
1586 return i;
1587 return -1;
1588 }
1589
1590
1591
1592
1593
1594
1595 static void
__OTORP__(register Buffer_t * b;register char * s;int n;)1596 copy __PARAM__((register Buffer_t* b, register char* s, int n), (b, s, n)) __OTORP__(register Buffer_t* b; register char* s; int n;){
1597 if (n < 0)
1598 n = sstrlen( s);
1599 while (n--)
1600 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( *s++)):(( *s++),(-1)));
1601 }
1602
1603
1604 #line 225
1605 static void
__OTORP__(Notice_t * notice;register Buffer_t * b;register char * s;register int n;int u;)1606 comment __PARAM__((Notice_t* notice, register Buffer_t* b, register char* s, register int n, int u), (notice, b, s, n, u)) __OTORP__(Notice_t* notice; register Buffer_t* b; register char* s; register int n; int u;){
1607 register int i;
1608 register int m;
1609 register int x;
1610 int cc;
1611
1612 cc = notice->cc[1];
1613 if (!s)
1614 {
1615 if (n)
1616 {
1617 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( notice->cc[n > 0 ? 0 : 1])):(( notice->cc[n > 0 ? 0 : 1]),(-1)));
1618 for (i = 0; i < 70; i++)
1619 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( cc)):(( cc),(-1)));
1620 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( notice->cc[n > 0 ? 1 : 2])):(( notice->cc[n > 0 ? 1 : 2]),(-1)));
1621 }
1622 else
1623 s = "";
1624 }
1625 if (s)
1626 {
1627 if (n > 70)
1628 n = 70;
1629 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( cc)):(( cc),(-1)));
1630 m = (u < 0) ? 1 : (70 - n) / 2;
1631 if ((x = 70 - m - n) < 0)
1632 n--;
1633 while (m-- > 0)
1634 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( ' ')):(( ' '),(-1)));
1635 while (n-- > 0)
1636 {
1637 i = *s++;
1638 if (u > 0 && i >= 'a' && i <= 'z')
1639 i = i - 'a' + 'A';
1640 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( i)):(( i),(-1)));
1641 }
1642 while (x-- > 0)
1643 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( ' ')):(( ' '),(-1)));
1644 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( cc)):(( cc),(-1)));
1645 }
1646 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( '\n')):(( '\n'),(-1)));
1647 }
1648
1649
1650
1651
1652
1653 static void
__OTORP__(Notice_t * notice;register Buffer_t * b;const Item_t * item;)1654 expand __PARAM__((Notice_t* notice, register Buffer_t* b, const Item_t* item), (notice, b, item)) __OTORP__(Notice_t* notice; register Buffer_t* b; const Item_t* item;){
1655 register char* t;
1656 register char* e;
1657 register int q;
1658 register char* x;
1659 register char* z;
1660 register int c;
1661 int m;
1662 int i;
1663 int k;
1664
1665 if (t = item->data)
1666 {
1667 q = item->quote;
1668 e = t + item->size;
1669 i = 0;
1670 while (t < e)
1671 {
1672 if (*t == '$' && t < (e + 2) && *(t + 1) == '{')
1673 {
1674 k = m = 0;
1675 x = t += 2;
1676 while (t < e && (c = *t++) != '}')
1677 if (c == '.')
1678 x = t;
1679 else if (c == '-')
1680 {
1681 k = 1;
1682 break;
1683 }
1684 else if (c == '/')
1685 {
1686 m = 1;
1687 break;
1688 }
1689 if ((c = lookup(key, x, t - x - 1)) >= 0 && (x = notice->item[c].data))
1690 {
1691 z = x + notice->item[c].size;
1692 while (x < z)
1693 {
1694 c = *x++;
1695 if (!m || c >= '0' && c <= '9')
1696 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( c)):(( c),(-1)));
1697 }
1698 }
1699 else if (k)
1700 {
1701 k = 0;
1702 i++;
1703 }
1704 if (k || m)
1705 {
1706 k = 1;
1707 while (t < e)
1708 if ((c = *t++) == '{')
1709 k++;
1710 else if (c == '}' && !--k)
1711 break;
1712 }
1713 }
1714 else if (q > 0 && *t == '\\' && (*(t + 1) == q || *(t + 1) == '\\'))
1715 t++;
1716 else if (*t == '}' && i)
1717 {
1718 t++;
1719 i--;
1720 }
1721 else
1722 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( *t++)):(( *t++),(-1)));
1723 }
1724 }
1725 }
1726
1727
1728
1729
1730
1731 static void
__OTORP__(Notice_t * notice;register Buffer_t * b;)1732 copyright __PARAM__((Notice_t* notice, register Buffer_t* b), (notice, b)) __OTORP__(Notice_t* notice; register Buffer_t* b;){
1733 register char* x;
1734 register char* t;
1735 time_t clock;
1736
1737 copy(b, "Copyright (c) ", -1);
1738 if (notice->test)
1739 {
1740 clock = (time_t)1000212300;
1741 t = ctime(&clock) + 20;
1742 }
1743 else if (!(t = notice->item[18].data))
1744 {
1745 time(&clock);
1746 t = ctime(&clock) + 20;
1747 }
1748 if ((x = notice->item[19].data) && sstrncmp( t, x, 4) < 0)
1749 t = x;
1750 if ((x = notice->item[17].data) && sstrncmp( x, t, 4) < 0)
1751 {
1752 expand(notice, b, ¬ice->item[17]);
1753 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( '-')):(( '-'),(-1)));
1754 }
1755 copy(b, t, 4);
1756 if (notice->item[15].data)
1757 {
1758 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( ' ')):(( ' '),(-1)));
1759 expand(notice, b, ¬ice->item[15]);
1760 }
1761 if (notice->item[5].data)
1762 {
1763 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( ' ')):(( ' '),(-1)));
1764 expand(notice, b, ¬ice->item[5]);
1765 if (notice->item[8].data)
1766 {
1767 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( ' ')):(( ' '),(-1)));
1768 expand(notice, b, ¬ice->item[8]);
1769 }
1770 }
1771 else if (notice->item[2].data)
1772 {
1773 ((( b)->nxt<( b)->end)?(*( b)->nxt++=( ' ')):(( ' '),(-1)));
1774 expand(notice, b, ¬ice->item[2]);
1775 }
1776 }
1777
1778 typedef struct Stack_s
1779 {
1780 char* info;
1781 char* file;
1782 int line;
1783 int size;
1784 } Stack_t;
1785
1786 static int
__OTORP__(Stack_t * sp;char * file;char * parent;char * info;int size;Buffer_t * buf;)1787 push __PARAM__((Stack_t* sp, char* file, char* parent, char* info, int size, Buffer_t* buf), (sp, file, parent, info, size, buf)) __OTORP__(Stack_t* sp; char* file; char* parent; char* info; int size; Buffer_t* buf;){
1788 char* s;
1789 char* t;
1790 int i;
1791 int n;
1792 char path[1024];
1793
1794 if (size <= 8)
1795 {
1796 copy(buf, file, -1);
1797 copy(buf, ": no space", -1);
1798 ((( buf)->nxt<( buf)->end)?(*( buf)->nxt++=( 0)):(( 0),(-1)));
1799 return -1;
1800 }
1801 if (*file != '/' && parent && (s = strrchr(parent, '/')))
1802 {
1803 n = s - parent + 1;
1804 if ((sstrlen( file) + n + 1) <= sizeof(path))
1805 {
1806 memcopy( path, parent, n);
1807 strcopy( path + n, file);
1808 file = path;
1809 }
1810 }
1811 if ((i = open(file, O_RDONLY|0)) < 0)
1812 {
1813
1814 if (file == path)
1815 for (s = path; *s; s++)
1816 if (s[0] == '/' && s[1] == 'a' && s[2] == 'r' && s[3] == 'c' && s[4] == 'h' && s[5] == '/')
1817 {
1818 t = s;
1819 for (s += 6; *s && *s != '/'; s++);
1820 while (*t++ = *s++);
1821 i = open(file, O_RDONLY|0);
1822 }
1823 if (i < 0)
1824 {
1825 copy(buf, file, -1);
1826 copy(buf, ": cannot open", -1);
1827 ((( buf)->nxt<( buf)->end)?(*( buf)->nxt++=( 0)):(( 0),(-1)));
1828 return -1;
1829 }
1830 }
1831 n = read(i, info, size - 1);
1832 close(i);
1833 if (n < 0)
1834 {
1835 copy(buf, file, -1);
1836 copy(buf, ": cannot read", -1);
1837 ((( buf)->nxt<( buf)->end)?(*( buf)->nxt++=( 0)):(( 0),(-1)));
1838 return -1;
1839 }
1840 info[n++] = 0;
1841 sp->file = file;
1842 sp->info = info;
1843 sp->line = 0;
1844 sp->size = n;
1845 return 0;
1846 }
1847
1848
1849
1850
1851
1852
1853
1854 int
__OTORP__(char * p;int size;char * file;char * options;int cc1;int cc2;int cc3;)1855 astlicense __PARAM__((char* p, int size, char* file, char* options, int cc1, int cc2, int cc3), (p, size, file, options, cc1, cc2, cc3)) __OTORP__(char* p; int size; char* file; char* options; int cc1; int cc2; int cc3;){
1856 register char* s;
1857 register char* v;
1858 register char* x;
1859 register int c;
1860 int i;
1861 int h;
1862 int k;
1863 int n;
1864 int q;
1865 int contributor;
1866 int first;
1867 int level;
1868 int quote;
1869 char* data;
1870 char tmpbuf[(70+4)];
1871 char info[8 * 1024];
1872 Stack_t input[4];
1873 Notice_t notice;
1874 Item_t item;
1875 Buffer_t buf;
1876 Buffer_t tmp;
1877
1878 buf.end = (buf.buf = buf.nxt = p) + size;
1879 tmp.end = (tmp.buf = tmp.nxt = tmpbuf) + sizeof(tmpbuf);
1880 level = 0;
1881 data = info;
1882 level = -1;
1883 if (options)
1884 {
1885 level++;
1886 input[level].file = "<options>";
1887 input[level].info = options;
1888 input[level].line = 0;
1889 }
1890 if (file && *file)
1891 {
1892 if (push(&input[++level], file, 0, data, &info[sizeof(info)] - data, &buf))
1893 return -1;
1894 data += input[level].size;
1895 }
1896 if (level < 0)
1897 return 0;
1898 s = input[level].info;
1899 notice.test = 0;
1900 notice.type = 0;
1901 notice.verbose = 0;
1902 notice.ids = 0;
1903 notice.cc[0] = cc1;
1904 notice.cc[1] = cc2;
1905 notice.cc[2] = cc3;
1906 for (i = 0; i < (sizeof(key)/sizeof(key[0])-1); i++)
1907 notice.item[i].data = 0;
1908 notice.item[20] = notice.item[1] = lic[notice.type];
1909 notice.item[20].quote = notice.item[1].quote = 0;
1910 contributor = i = k = 0;
1911 for (;;)
1912 {
1913 first = 1;
1914 while (c = *s)
1915 {
1916 while (c == ' ' || c == '\t' || c == '\n' && ++input[level].line || c == '\r' || c == ',' || c == ';' || c == ')')
1917 c = *++s;
1918 if (!c)
1919 break;
1920 if (c == '#')
1921 {
1922 while (*++s && *s != '\n');
1923 if (*s)
1924 s++;
1925 input[level].line++;
1926 continue;
1927 }
1928 if (c == '.')
1929 {
1930 while ((c = *++s) && (c == ' ' || c == '\t'));
1931 file = s;
1932 while (c && c != ' ' && c != '\t' && c != '\r' && c != '\n')
1933 c = *++s;
1934 *s = 0;
1935 while (c && c != '\n')
1936 c = *++s;
1937 if (*file)
1938 {
1939 input[level].info = s + (c != 0);
1940 if (++level >= (sizeof(input) / sizeof(input[0])) || push(&input[level], file, input[level-1].file, data, &info[sizeof(info)] - data, &buf))
1941 return -1;
1942 data += input[level].size;
1943 s = input[level].info;
1944 }
1945 continue;
1946 }
1947 if (c == '\n')
1948 {
1949 s++;
1950 input[level].line++;
1951 continue;
1952 }
1953 if (c == '[')
1954 c = *++s;
1955 x = s;
1956 n = 0;
1957 while (c && c != '+' && c != '=' && c != ']' && c != ')' && c != ',' && c != ' ' && c != '\t' && c != '\n' && c != '\r')
1958 c = *++s;
1959 n = s - x;
1960 h = lookup(key, x, n);
1961 if (c == '+' || c == ']')
1962 c = *++s;
1963 quote = 0;
1964 if (c == '=' || first)
1965 {
1966 if (c == '=')
1967 {
1968 q = ((c = *++s) == '"' || c == '\'') ? *s++ : 0;
1969 if (c == '(')
1970 {
1971 s++;
1972 if (h == 9)
1973 contributor = 0;
1974 else if (h == 4)
1975 contributor = 1;
1976 else
1977 {
1978 q = 1;
1979 i = 0;
1980 for (;;)
1981 {
1982 switch (*s++)
1983 {
1984 case 0:
1985 s--;
1986 break;
1987 case '(':
1988 if (!i)
1989 q++;
1990 continue;
1991 case ')':
1992 if (!i && !--q)
1993 break;
1994 continue;
1995 case '"':
1996 case '\'':
1997 if (!i)
1998 i = *(s - 1);
1999 else if (i == *(s - 1))
2000 i = 0;
2001 continue;
2002 case '\\':
2003 if (*s == i && i == '"')
2004 i++;
2005 continue;
2006 case '\n':
2007 input[level].line++;
2008 continue;
2009 default:
2010 continue;
2011 }
2012 break;
2013 }
2014 }
2015 continue;
2016 }
2017 v = s;
2018 while ((c = *s) && (q == '"' && (c == '\\' && (*(s + 1) == '"' || *(s + 1) == '\\') && s++ && (quote = q)) || q && c != q || !q && c != ' ' && c != '\t' && c != '\n' && c != '\r' && c != ',' && c != ';'))
2019 {
2020 if (c == '\n')
2021 input[level].line++;
2022 s++;
2023 }
2024 }
2025 else
2026 {
2027 h = 20;
2028 v = x;
2029 }
2030 if (c == '\n')
2031 input[level].line++;
2032 if (contributor)
2033 {
2034 for (i = 0; i < notice.ids; i++)
2035 if (n == notice.id[i].name.size && !sstrncmp( x, notice.id[i].name.data, n))
2036 break;
2037 if (i < 64)
2038 {
2039 notice.id[i].name.data = x;
2040 notice.id[i].name.size = n;
2041 notice.id[i].name.quote = 0;
2042 notice.id[i].value.data = v;
2043 notice.id[i].value.size = s - v;
2044 notice.id[i].value.quote = quote;
2045 if (notice.ids <= i)
2046 notice.ids = i + 1;
2047 }
2048 }
2049 else if (h == 16)
2050 {
2051 if ((s - v) == 3 && v[0] == 'a' && v[1] == 'l' && v[2] == 'l')
2052 {
2053 for (i = 0; i < (sizeof(key)/sizeof(key[0])-1); i++)
2054 if (notice.item[i].size)
2055 {
2056 expand(¬ice, &buf, &key[i]);
2057 ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( '=')):(( '='),(-1)));
2058 for (h = 0;; h++)
2059 if (h >= notice.item[i].size)
2060 {
2061 h = 0;
2062 break;
2063 }
2064 else if (notice.item[i].data[h] == ' ' || notice.item[i].data[h] == '\t')
2065 break;
2066 if (h)
2067 ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( '\'')):(( '\''),(-1)));
2068 expand(¬ice, &buf, ¬ice.item[i]);
2069 if (h)
2070 ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( '\'')):(( '\''),(-1)));
2071 ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( '\n')):(( '\n'),(-1)));
2072 }
2073 }
2074 else
2075 {
2076 if ((h = lookup(key, v, s - v)) < 0)
2077 {
2078 item.data = v;
2079 item.size = s - v;
2080 item.quote = 0;
2081 expand(¬ice, &buf, &item);
2082 }
2083 else
2084 expand(¬ice, &buf, ¬ice.item[h]);
2085 ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( '\n')):(( '\n'),(-1)));
2086 }
2087 return (*(( &buf)->nxt>=( &buf)->end?(( &buf)->nxt=( &buf)->end-1):( &buf)->nxt)=0,( &buf)->nxt-( &buf)->buf);
2088 }
2089 else
2090 {
2091 if (h == 20)
2092 switch (c = lookup(lic, v, s - v))
2093 {
2094 case 0:
2095 return 0;
2096 case 2:
2097 notice.test = 1;
2098 h = -1;
2099 break;
2100 case 3:
2101 notice.verbose = 1;
2102 h = -1;
2103 break;
2104 case 4:
2105 notice.type = c;
2106 h = -1;
2107 break;
2108 case -1:
2109 c = 12;
2110
2111 default:
2112 notice.type = c;
2113 notice.item[1].data = lic[lic[c].quote].data;
2114 notice.item[1].size = lic[lic[c].quote].size;
2115 if (notice.item[20].data != lic[0].data)
2116 h = -1;
2117 break;
2118 }
2119 if (h >= 0)
2120 {
2121 notice.item[h].data = (notice.item[h].size = s - v) ? v : (char*)0;
2122 notice.item[h].quote = quote;
2123 k = 1;
2124 }
2125 }
2126 }
2127 else
2128 {
2129 if (input[level].file)
2130 {
2131 copy(&buf, "\"", -1);
2132 copy(&buf, input[level].file, -1);
2133 copy(&buf, "\", line ", -1);
2134 x = &tmpbuf[sizeof(tmpbuf)];
2135 *--x = 0;
2136 n = ++input[level].line;
2137 do *--x = ("0123456789")[n % 10]; while (n /= 10);
2138 copy(&buf, x, -1);
2139 copy(&buf, ": ", -1);
2140 }
2141 copy(&buf, "option error: assignment expected", -1);
2142 ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( 0)):(( 0),(-1)));
2143 return -1;
2144 }
2145 if (*s)
2146 s++;
2147 first = 0;
2148 }
2149 if (!level--)
2150 break;
2151 s = input[level].info;
2152 }
2153 if (!k)
2154 return 0;
2155 if (notice.type == 1 && (!notice.verbose || !notice.item[12].data))
2156 return 0;
2157 if (notice.type != 4)
2158 {
2159 if (!notice.type)
2160 notice.type = 12;
2161 comment(¬ice, &buf, ((char*)0), 1, 0);
2162 comment(¬ice, &buf, ((char*)0), 0, 0);
2163 if (notice.item[14].data)
2164 {
2165 copy(&tmp, "This software is part of the ", -1);
2166 expand(¬ice, &tmp, ¬ice.item[14]);
2167 copy(&tmp, " package", -1);
2168 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2169 }
2170 if (notice.type >= 5)
2171 {
2172 copyright(¬ice, &tmp);
2173 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2174 if (notice.type >= 12)
2175 comment( ¬ice, &buf, "All Rights Reserved",sizeof( "All Rights Reserved")-1, 0);
2176 }
2177 if (notice.type == 6 || notice.type == 7)
2178 {
2179 copy(&tmp, notice.item[14].data ? "and": "This software", -1);
2180 copy(&tmp, " is licensed under the", -1);
2181 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2182 if (notice.type == 7)
2183 copy(&tmp, "Eclipse Public License", -1);
2184 else
2185 copy(&tmp, "Common Public License", -1);
2186 if (notice.item[23].data)
2187 {
2188 copy(&tmp, ", Version ", -1);
2189 expand(¬ice, &tmp, ¬ice.item[23]);
2190 }
2191 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2192 if (notice.item[5].data || notice.item[2].data)
2193 {
2194 copy(&tmp, "by ", -1);
2195 if (notice.item[15].data)
2196 {
2197 expand(¬ice, &tmp, ¬ice.item[15]);
2198 copy(&tmp, " ", -1);
2199 }
2200 if (notice.item[5].data)
2201 {
2202 expand(¬ice, &tmp, ¬ice.item[5]);
2203 if (notice.item[8].data)
2204 {
2205 copy(&tmp, " ", -1);
2206 expand(¬ice, &tmp, ¬ice.item[8]);
2207 }
2208 }
2209 else if (notice.item[2].data)
2210 expand(¬ice, &tmp, ¬ice.item[2]);
2211 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2212 }
2213 comment(¬ice, &buf, ((char*)0), 0, 0);
2214 comment( ¬ice, &buf, "A copy of the License is available at",sizeof( "A copy of the License is available at")-1, 0);
2215 if (notice.item[21].data)
2216 {
2217 expand(¬ice, &tmp, ¬ice.item[21]);
2218 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2219 if (notice.item[22].data)
2220 {
2221 copy(&tmp, "(with md5 checksum ", -1);
2222 expand(¬ice, &tmp, ¬ice.item[22]);
2223 copy(&tmp, ")", -1);
2224 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2225 }
2226 }
2227 else if (notice.type == 7)
2228 comment( ¬ice, &buf, "http://www.eclipse.org/org/documents/epl-v10.html",sizeof( "http://www.eclipse.org/org/documents/epl-v10.html")-1, 0);
2229 else
2230 comment( ¬ice, &buf, "http://www.opensource.org/licenses/cpl",sizeof( "http://www.opensource.org/licenses/cpl")-1, 0);
2231 comment(¬ice, &buf, ((char*)0), 0, 0);
2232 }
2233 else if (notice.type == 5)
2234 {
2235 copy(&tmp, notice.item[14].data ? "and it": "This software", -1);
2236 copy(&tmp, " may only be used by you under license from", -1);
2237 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2238 if (notice.item[i = 5].data)
2239 {
2240 if (notice.item[15].data)
2241 {
2242 expand(¬ice, &tmp, ¬ice.item[i = 15]);
2243 copy(&tmp, " ", -1);
2244 }
2245 expand(¬ice, &tmp, ¬ice.item[5]);
2246 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2247 }
2248 else if (notice.item[i = 2].data)
2249 {
2250 if (notice.item[15].data)
2251 {
2252 expand(¬ice, &tmp, ¬ice.item[i = 15]);
2253 copy(&tmp, " ", -1);
2254 }
2255 expand(¬ice, &tmp, ¬ice.item[2]);
2256 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2257 }
2258 else
2259 i = -1;
2260 if (notice.item[21].data)
2261 {
2262 comment( ¬ice, &buf, "A copy of the Source Code Agreement is available",sizeof( "A copy of the Source Code Agreement is available")-1, 0);
2263 copy(&tmp, "at the ", -1);
2264 if (i >= 0)
2265 expand(¬ice, &tmp, ¬ice.item[i]);
2266 copy(&tmp, " Internet web site URL", -1);
2267 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2268 comment(¬ice, &buf, ((char*)0), 0, 0);
2269 expand(¬ice, &tmp, ¬ice.item[21]);
2270 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2271 if (notice.item[22].data)
2272 {
2273 copy(&tmp, "(with an md5 checksum of ", -1);
2274 expand(¬ice, &tmp, ¬ice.item[22]);
2275 copy(&tmp, ")", -1);
2276 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2277 }
2278 comment(¬ice, &buf, ((char*)0), 0, 0);
2279 }
2280 comment( ¬ice, &buf, "If you have copied or used this software without agreeing",sizeof( "If you have copied or used this software without agreeing")-1, 0);
2281 comment( ¬ice, &buf, "to the terms of the license you are infringing on",sizeof( "to the terms of the license you are infringing on")-1, 0);
2282 comment( ¬ice, &buf, "the license and copyright and are violating",sizeof( "the license and copyright and are violating")-1, 0);
2283 if (i >= 0)
2284 expand(¬ice, &tmp, ¬ice.item[i]);
2285 copy(&tmp, "'s", -1);
2286 if (n >= (70-32))
2287 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2288 else
2289 ((( &tmp)->nxt<( &tmp)->end)?(*( &tmp)->nxt++=( ' ')):(( ' '),(-1)));
2290 copy(&tmp, "intellectual property rights.", -1);
2291 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2292 comment(¬ice, &buf, ((char*)0), 0, 0);
2293 }
2294 else if (notice.type == 11)
2295 {
2296 comment(¬ice, &buf, ((char*)0), 0, 0);
2297 comment( ¬ice, &buf, "This is free software; you can redistribute it and/or",sizeof( "This is free software; you can redistribute it and/or")-1, 0);
2298 comment( ¬ice, &buf, "modify it under the terms of the GNU General Public License",sizeof( "modify it under the terms of the GNU General Public License")-1, 0);
2299 comment( ¬ice, &buf, "as published by the Free Software Foundation;",sizeof( "as published by the Free Software Foundation;")-1, 0);
2300 comment( ¬ice, &buf, "either version 2, or (at your option) any later version.",sizeof( "either version 2, or (at your option) any later version.")-1, 0);
2301 comment(¬ice, &buf, ((char*)0), 0, 0);
2302 comment( ¬ice, &buf, "This software is distributed in the hope that it",sizeof( "This software is distributed in the hope that it")-1, 0);
2303 comment( ¬ice, &buf, "will be useful, but WITHOUT ANY WARRANTY;",sizeof( "will be useful, but WITHOUT ANY WARRANTY;")-1, 0);
2304 comment( ¬ice, &buf, "without even the implied warranty of MERCHANTABILITY",sizeof( "without even the implied warranty of MERCHANTABILITY")-1, 0);
2305 comment( ¬ice, &buf, "or FITNESS FOR A PARTICULAR PURPOSE.",sizeof( "or FITNESS FOR A PARTICULAR PURPOSE.")-1, 0);
2306 comment( ¬ice, &buf, "See the GNU General Public License for more details.",sizeof( "See the GNU General Public License for more details.")-1, 0);
2307 comment(¬ice, &buf, ((char*)0), 0, 0);
2308 comment( ¬ice, &buf, "You should have received a copy of the",sizeof( "You should have received a copy of the")-1, 0);
2309 comment( ¬ice, &buf, "GNU General Public License",sizeof( "GNU General Public License")-1, 0);
2310 comment( ¬ice, &buf, "along with this software (see the file COPYING.)",sizeof( "along with this software (see the file COPYING.)")-1, 0);
2311 comment( ¬ice, &buf, "If not, a copy is available at",sizeof( "If not, a copy is available at")-1, 0);
2312 comment( ¬ice, &buf, "http://www.gnu.org/copyleft/gpl.html",sizeof( "http://www.gnu.org/copyleft/gpl.html")-1, 0);
2313 comment(¬ice, &buf, ((char*)0), 0, 0);
2314 }
2315 else if (notice.type == 8)
2316 {
2317 comment(¬ice, &buf, ((char*)0), 0, 0);
2318 comment( ¬ice, &buf, "Redistribution and use in source and binary forms, with or",sizeof( "Redistribution and use in source and binary forms, with or")-1, -1);
2319 comment( ¬ice, &buf, "without modification, are permitted provided that the following",sizeof( "without modification, are permitted provided that the following")-1, -1);
2320 comment( ¬ice, &buf, "conditions are met:",sizeof( "conditions are met:")-1, -1);
2321 comment(¬ice, &buf, ((char*)0), 0, 0);
2322 comment( ¬ice, &buf, " 1. Redistributions of source code must retain the above",sizeof( " 1. Redistributions of source code must retain the above")-1, -1);
2323 comment( ¬ice, &buf, " copyright notice, this list of conditions and the",sizeof( " copyright notice, this list of conditions and the")-1, -1);
2324 comment( ¬ice, &buf, " following disclaimer.",sizeof( " following disclaimer.")-1, -1);
2325 comment(¬ice, &buf, ((char*)0), 0, 0);
2326 comment( ¬ice, &buf, " 2. Redistributions in binary form must reproduce the above",sizeof( " 2. Redistributions in binary form must reproduce the above")-1, -1);
2327 comment( ¬ice, &buf, " copyright notice, this list of conditions and the",sizeof( " copyright notice, this list of conditions and the")-1, -1);
2328 comment( ¬ice, &buf, " following disclaimer in the documentation and/or other",sizeof( " following disclaimer in the documentation and/or other")-1, -1);
2329 comment( ¬ice, &buf, " materials provided with the distribution.",sizeof( " materials provided with the distribution.")-1, -1);
2330 comment(¬ice, &buf, ((char*)0), 0, 0);
2331 copy(&tmp, " 3. Neither the name of ", -1);
2332 if (notice.item[i = 15].data || notice.item[i = 5].data || notice.item[i = 2].data)
2333 expand(¬ice, &tmp, ¬ice.item[i]);
2334 else
2335 copy(&tmp, "the copyright holder", -1);
2336 copy(&tmp, " nor the", -1);
2337 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), -1);
2338 comment( ¬ice, &buf, " names of its contributors may be used to endorse or",sizeof( " names of its contributors may be used to endorse or")-1, -1);
2339 comment( ¬ice, &buf, " promote products derived from this software without",sizeof( " promote products derived from this software without")-1, -1);
2340 comment( ¬ice, &buf, " specific prior written permission.",sizeof( " specific prior written permission.")-1, -1);
2341 comment(¬ice, &buf, ((char*)0), 0, 0);
2342 comment( ¬ice, &buf, "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND",sizeof( "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND")-1, -1);
2343 comment( ¬ice, &buf, "CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES,",sizeof( "CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES,")-1, -1);
2344 comment( ¬ice, &buf, "INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF",sizeof( "INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF")-1, -1);
2345 comment( ¬ice, &buf, "MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE",sizeof( "MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE")-1, -1);
2346 comment( ¬ice, &buf, "DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS",sizeof( "DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS")-1, -1);
2347 comment( ¬ice, &buf, "BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,",sizeof( "BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,")-1, -1);
2348 comment( ¬ice, &buf, "EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED",sizeof( "EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED")-1, -1);
2349 comment( ¬ice, &buf, "TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,",sizeof( "TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,")-1, -1);
2350 comment( ¬ice, &buf, "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON",sizeof( "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON")-1, -1);
2351 comment( ¬ice, &buf, "ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,",sizeof( "ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,")-1, -1);
2352 comment( ¬ice, &buf, "OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY",sizeof( "OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY")-1, -1);
2353 comment( ¬ice, &buf, "OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE",sizeof( "OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE")-1, -1);
2354 comment( ¬ice, &buf, "POSSIBILITY OF SUCH DAMAGE.",sizeof( "POSSIBILITY OF SUCH DAMAGE.")-1, -1);
2355 comment(¬ice, &buf, ((char*)0), 0, 0);
2356 }
2357 else if (notice.type == 9)
2358 {
2359 comment(¬ice, &buf, ((char*)0), 0, 0);
2360 comment( ¬ice, &buf, "This software is provided 'as-is', without any express or implied",sizeof( "This software is provided 'as-is', without any express or implied")-1, -1);
2361 comment( ¬ice, &buf, "warranty. In no event will the authors be held liable for any",sizeof( "warranty. In no event will the authors be held liable for any")-1, -1);
2362 comment( ¬ice, &buf, "damages arising from the use of this software.",sizeof( "damages arising from the use of this software.")-1, -1);
2363 comment(¬ice, &buf, ((char*)0), 0, 0);
2364 comment( ¬ice, &buf, "Permission is granted to anyone to use this software for any",sizeof( "Permission is granted to anyone to use this software for any")-1, -1);
2365 comment( ¬ice, &buf, "purpose, including commercial applications, and to alter it and",sizeof( "purpose, including commercial applications, and to alter it and")-1, -1);
2366 comment( ¬ice, &buf, "redistribute it freely, subject to the following restrictions:",sizeof( "redistribute it freely, subject to the following restrictions:")-1, -1);
2367 comment(¬ice, &buf, ((char*)0), 0, 0);
2368 comment( ¬ice, &buf, " 1. The origin of this software must not be misrepresented;",sizeof( " 1. The origin of this software must not be misrepresented;")-1, -1);
2369 comment( ¬ice, &buf, " you must not claim that you wrote the original software. If",sizeof( " you must not claim that you wrote the original software. If")-1, -1);
2370 comment( ¬ice, &buf, " you use this software in a product, an acknowledgment in the",sizeof( " you use this software in a product, an acknowledgment in the")-1, -1);
2371 comment( ¬ice, &buf, " product documentation would be appreciated but is not",sizeof( " product documentation would be appreciated but is not")-1, -1);
2372 comment( ¬ice, &buf, " required.",sizeof( " required.")-1, -1);
2373 comment(¬ice, &buf, ((char*)0), 0, 0);
2374 comment( ¬ice, &buf, " 2. Altered source versions must be plainly marked as such,",sizeof( " 2. Altered source versions must be plainly marked as such,")-1, -1);
2375 comment( ¬ice, &buf, " and must not be misrepresented as being the original",sizeof( " and must not be misrepresented as being the original")-1, -1);
2376 comment( ¬ice, &buf, " software.",sizeof( " software.")-1, -1);
2377 comment(¬ice, &buf, ((char*)0), 0, 0);
2378 comment( ¬ice, &buf, " 3. This notice may not be removed or altered from any source",sizeof( " 3. This notice may not be removed or altered from any source")-1, -1);
2379 comment( ¬ice, &buf, " distribution.",sizeof( " distribution.")-1, -1);
2380 comment(¬ice, &buf, ((char*)0), 0, 0);
2381 }
2382 else if (notice.type == 10)
2383 {
2384 comment(¬ice, &buf, ((char*)0), 0, 0);
2385 comment( ¬ice, &buf, "Permission is hereby granted, free of charge, to any person",sizeof( "Permission is hereby granted, free of charge, to any person")-1, 0);
2386 comment( ¬ice, &buf, "obtaining a copy of this software and associated",sizeof( "obtaining a copy of this software and associated")-1, 0);
2387 comment( ¬ice, &buf, "documentation files (the \"Software\"), to deal in the",sizeof( "documentation files (the \"Software\"), to deal in the")-1, 0);
2388 comment( ¬ice, &buf, "Software without restriction, including without limitation",sizeof( "Software without restriction, including without limitation")-1, 0);
2389 comment( ¬ice, &buf, "the rights to use, copy, modify, merge, publish, distribute,",sizeof( "the rights to use, copy, modify, merge, publish, distribute,")-1, 0);
2390 comment( ¬ice, &buf, "sublicense, and/or sell copies of the Software, and to",sizeof( "sublicense, and/or sell copies of the Software, and to")-1, 0);
2391 comment( ¬ice, &buf, "permit persons to whom the Software is furnished to do so,",sizeof( "permit persons to whom the Software is furnished to do so,")-1, 0);
2392 comment( ¬ice, &buf, "subject to the following conditions:",sizeof( "subject to the following conditions:")-1, 0);
2393 comment(¬ice, &buf, ((char*)0), 0, 0);
2394 comment( ¬ice, &buf, "The above copyright notice and this permission notice shall",sizeof( "The above copyright notice and this permission notice shall")-1, 0);
2395 comment( ¬ice, &buf, "be included in all copies or substantial portions of the",sizeof( "be included in all copies or substantial portions of the")-1, 0);
2396 comment( ¬ice, &buf, "Software.",sizeof( "Software.")-1, 0);
2397 comment(¬ice, &buf, ((char*)0), 0, 0);
2398 comment( ¬ice, &buf, "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY",sizeof( "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY")-1, 0);
2399 comment( ¬ice, &buf, "KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE",sizeof( "KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE")-1, 0);
2400 comment( ¬ice, &buf, "WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR",sizeof( "WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR")-1, 0);
2401 comment( ¬ice, &buf, "PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS",sizeof( "PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS")-1, 0);
2402 comment( ¬ice, &buf, "OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR",sizeof( "OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR")-1, 0);
2403 comment( ¬ice, &buf, "OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR",sizeof( "OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR")-1, 0);
2404 comment( ¬ice, &buf, "OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE",sizeof( "OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE")-1, 0);
2405 comment( ¬ice, &buf, "SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.",sizeof( "SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.")-1, 0);
2406 comment(¬ice, &buf, ((char*)0), 0, 0);
2407 }
2408 else
2409 {
2410 if (notice.type == 15)
2411 {
2412 if (notice.item[i = 15].data || notice.item[i = 5].data || notice.item[i = 2].data)
2413 {
2414 expand(¬ice, &tmp, ¬ice.item[i]);
2415 copy(&tmp, " - ", -1);
2416 }
2417 else
2418 i = -1;
2419 copy(&tmp, "Proprietary", -1);
2420 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 1);
2421 comment(¬ice, &buf, ((char*)0), 0, 0);
2422 if (notice.item[21].data)
2423 {
2424 copy(&tmp, "This is proprietary source code", -1);
2425 if (i >= 0)
2426 copy(&tmp, " licensed by", -1);
2427 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 1);
2428 if (notice.item[15].data)
2429 {
2430 expand(¬ice, &tmp, ¬ice.item[15]);
2431 copy(&tmp, " ", -1);
2432 }
2433 if (notice.item[5].data)
2434 {
2435 expand(¬ice, &tmp, ¬ice.item[5]);
2436 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 1);
2437 }
2438 else if (notice.item[2].data)
2439 {
2440 expand(¬ice, &tmp, ¬ice.item[2]);
2441 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 1);
2442 }
2443 }
2444 else
2445 {
2446 copy(&tmp, "This is unpublished proprietary source code", -1);
2447 if (i >= 0)
2448 copy(&tmp, " of", -1);
2449 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 1);
2450 if (notice.item[i = 15].data || notice.item[i = 5].data)
2451 expand(¬ice, &tmp, ¬ice.item[i]);
2452 if (notice.item[2].data)
2453 {
2454 if ((( &tmp)->nxt-( &tmp)->buf))
2455 ((( &tmp)->nxt<( &tmp)->end)?(*( &tmp)->nxt++=( ' ')):(( ' '),(-1)));
2456 expand(¬ice, &tmp, ¬ice.item[2]);
2457 }
2458 if ((( &tmp)->nxt-( &tmp)->buf))
2459 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 1);
2460 comment( ¬ice, &buf, "and is not to be disclosed or used except in",sizeof( "and is not to be disclosed or used except in")-1, 1);
2461 comment( ¬ice, &buf, "accordance with applicable agreements",sizeof( "accordance with applicable agreements")-1, 1);
2462 }
2463 comment(¬ice, &buf, ((char*)0), 0, 0);
2464 }
2465 else if (notice.type == 13)
2466 {
2467 comment( ¬ice, &buf, "For nonexclusive individual use",sizeof( "For nonexclusive individual use")-1, 1);
2468 comment(¬ice, &buf, ((char*)0), 0, 0);
2469 }
2470 else if (notice.type == 14)
2471 {
2472 comment( ¬ice, &buf, "For noncommercial use",sizeof( "For noncommercial use")-1, 1);
2473 comment(¬ice, &buf, ((char*)0), 0, 0);
2474 }
2475 if (notice.type >= 15 && !notice.item[21].data)
2476 {
2477 comment( ¬ice, &buf, "Unpublished & Not for Publication",sizeof( "Unpublished & Not for Publication")-1, 0);
2478 comment(¬ice, &buf, ((char*)0), 0, 0);
2479 }
2480 if (notice.item[21].data)
2481 {
2482 copy(&tmp, "This software is licensed", -1);
2483 if (notice.item[5].data || notice.item[2].data)
2484 {
2485 copy(&tmp, " by", -1);
2486 if ((notice.item[15].size + (notice.item[5].data ? (notice.item[5].size + notice.item[8].size) : notice.item[2].size)) >= ((70-32) - 6))
2487 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2488 else
2489 ((( &tmp)->nxt<( &tmp)->end)?(*( &tmp)->nxt++=( ' ')):(( ' '),(-1)));
2490 if (notice.item[15].data)
2491 {
2492 expand(¬ice, &tmp, ¬ice.item[15]);
2493 copy(&tmp, " ", -1);
2494 }
2495 if (notice.item[5].data)
2496 {
2497 expand(¬ice, &tmp, ¬ice.item[5]);
2498 if (notice.item[8].data)
2499 {
2500 copy(&tmp, " ", -1);
2501 expand(¬ice, &tmp, ¬ice.item[8]);
2502 }
2503 }
2504 else if (notice.item[2].data)
2505 expand(¬ice, &tmp, ¬ice.item[2]);
2506 }
2507 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2508 comment( ¬ice, &buf, "under the terms and conditions of the license in",sizeof( "under the terms and conditions of the license in")-1, 0);
2509 expand(¬ice, &tmp, ¬ice.item[21]);
2510 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2511 if (notice.item[22].data)
2512 {
2513 copy(&tmp, "(with an md5 checksum of ", -1);
2514 expand(¬ice, &tmp, ¬ice.item[22]);
2515 copy(&tmp, ")", -1);
2516 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2517 }
2518 comment(¬ice, &buf, ((char*)0), 0, 0);
2519 }
2520 else if (notice.type == 15)
2521 {
2522 comment( ¬ice, &buf, "The copyright notice above does not evidence any",sizeof( "The copyright notice above does not evidence any")-1, 0);
2523 comment( ¬ice, &buf, "actual or intended publication of such source code",sizeof( "actual or intended publication of such source code")-1, 0);
2524 comment(¬ice, &buf, ((char*)0), 0, 0);
2525 }
2526 }
2527 if (v = notice.item[12].data)
2528 {
2529 x = v + notice.item[12].size;
2530 if (*v == '\n')
2531 v++;
2532 item.quote = notice.item[12].quote;
2533 do
2534 {
2535 for (item.data = v; v < x && *v != '\n'; v++);
2536 if ((item.size = v - item.data) && *item.data == '\t')
2537 {
2538 item.data++;
2539 item.size--;
2540 h = 0;
2541 }
2542 else
2543 h = -1;
2544 expand(¬ice, &tmp, &item);
2545 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), h);
2546 } while (v++ < x);
2547 if (item.size)
2548 comment(¬ice, &buf, ((char*)0), 0, 0);
2549 }
2550 if (notice.item[13].data)
2551 {
2552 expand(¬ice, &tmp, ¬ice.item[13]);
2553 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2554 if (notice.item[i = 15].data || notice.item[i = 5].data)
2555 expand(¬ice, &tmp, ¬ice.item[i]);
2556 if (notice.item[2].data)
2557 {
2558 if ((( &tmp)->nxt-( &tmp)->buf))
2559 ((( &tmp)->nxt<( &tmp)->end)?(*( &tmp)->nxt++=( ' ')):(( ' '),(-1)));
2560 expand(¬ice, &tmp, ¬ice.item[2]);
2561 }
2562 if ((( &tmp)->nxt-( &tmp)->buf))
2563 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2564 if (notice.item[10].data)
2565 {
2566 expand(¬ice, &tmp, ¬ice.item[10]);
2567 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2568 }
2569 comment(¬ice, &buf, ((char*)0), 0, 0);
2570 }
2571 }
2572 if (v = notice.item[0].data)
2573 {
2574 x = v + notice.item[0].size;
2575 q = (x - v) == 1 && (*v == '*' || *v == '-');
2576 k = q && notice.type != 4 ? -1 : 0;
2577 for (;;)
2578 {
2579 if (!q)
2580 {
2581 while (v < x && (*v == ' ' || *v == '\t' || *v == '\r' || *v == '\n' || *v == ',' || *v == '+'))
2582 v++;
2583 if (v >= x)
2584 break;
2585 item.data = v;
2586 while (v < x && *v != ',' && *v != '+' && *v++ != '>');
2587 item.size = v - item.data;
2588 item.quote = notice.item[0].quote;
2589 }
2590 h = 0;
2591 for (i = 0; i < notice.ids; i++)
2592 if (q || item.size == notice.id[i].name.size && !sstrncmp( item.data, notice.id[i].name.data, item.size))
2593 {
2594 h = 1;
2595 if (notice.type == 4)
2596 {
2597 copy(&buf, "[-author?", -1);
2598 expand(¬ice, &buf, ¬ice.id[i].value);
2599 ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( ']')):(( ']'),(-1)));
2600 }
2601 else
2602 {
2603 if (k < 0)
2604 {
2605 comment( ¬ice, &buf, "CONTRIBUTORS",sizeof( "CONTRIBUTORS")-1, 0);
2606 comment(¬ice, &buf, ((char*)0), 0, 0);
2607 }
2608 k = 1;
2609 expand(¬ice, &tmp, ¬ice.id[i].value);
2610 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2611 }
2612 if (!q)
2613 break;
2614 }
2615 if (q)
2616 break;
2617 if (!h)
2618 {
2619 if (notice.type == 4)
2620 {
2621 copy(&buf, "[-author?", -1);
2622 expand(¬ice, &buf, &item);
2623 ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( ']')):(( ']'),(-1)));
2624 }
2625 else
2626 {
2627 if (k < 0)
2628 {
2629 comment( ¬ice, &buf, "CONTRIBUTORS",sizeof( "CONTRIBUTORS")-1, 0);
2630 comment(¬ice, &buf, ((char*)0), 0, 0);
2631 }
2632 k = 1;
2633 expand(¬ice, &tmp, &item);
2634 comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0);
2635 }
2636 }
2637 }
2638 if (k > 0)
2639 comment(¬ice, &buf, ((char*)0), 0, 0);
2640 }
2641 if (notice.type == 4)
2642 {
2643 copy(&buf, "[-copyright?", -1);
2644 copyright(¬ice, &buf);
2645 ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( ']')):(( ']'),(-1)));
2646 if (notice.item[21].data)
2647 {
2648 copy(&buf, "[-license?", -1);
2649 expand(¬ice, &buf, ¬ice.item[21]);
2650 ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( ']')):(( ']'),(-1)));
2651 }
2652 ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( '\n')):(( '\n'),(-1)));
2653 }
2654 else
2655 comment(¬ice, &buf, ((char*)0), -1, 0);
2656 return (*(( &buf)->nxt>=( &buf)->end?(( &buf)->nxt=( &buf)->end-1):( &buf)->nxt)=0,( &buf)->nxt-( &buf)->buf);
2657 }
2658 #line 336 "../../lib/libpp/ppproto.c"
2659
2660 #line 348
2661 static char*
__OTORP__(register Proto_t * proto;register char * p;register long n;)2662 linesync __PARAM__((register Proto_t* proto, register char* p, register long n), (proto, p, n)) __OTORP__(register Proto_t* proto; register char* p; register long n;){
2663
2664 if (proto->flags & (1L<<13))
2665
2666 {
2667
2668 p = strcopy(p, "\n#line ");
2669
2670
2671
2672 p = number(p, n);
2673 *p++ = '\n';
2674 }
2675 return p;
2676 }
2677
2678
2679
2680
2681
2682
2683 static char*
__OTORP__(Proto_t * proto;char * op;int flags;)2684 init __PARAM__((Proto_t* proto, char* op, int flags), (proto, op, flags)) __OTORP__(Proto_t* proto; char* op; int flags;){
2685 register char* s;
2686
2687 if (flags & (1L<<10))
2688 {
2689 op = strcopy(op, "\
2690 \n\
2691 #if !defined(__PROTO__)\n\
2692 # if defined(__STDC__) || defined(__cplusplus) || defined(_proto) || defined(c_plusplus)\n\
2693 # if defined(__cplusplus)\n\
2694 # define __LINKAGE__ \"C\"\n\
2695 # else\n\
2696 # define __LINKAGE__\n\
2697 # endif\n\
2698 # define __STDARG__\n\
2699 # define __PROTO__(x) x\n\
2700 # define __OTORP__(x)\n\
2701 # define __PARAM__(n,o) n\n\
2702 # if !defined(__STDC__) && !defined(__cplusplus)\n\
2703 # if !defined(c_plusplus)\n\
2704 # define const\n\
2705 # endif\n\
2706 # define signed\n\
2707 # define void int\n\
2708 # define volatile\n\
2709 # define __V_ char\n\
2710 # else\n\
2711 # define __V_ void\n\
2712 # endif\n\
2713 # else\n\
2714 # define __PROTO__(x) ()\n\
2715 # define __OTORP__(x) x\n\
2716 # define __PARAM__(n,o) o\n\
2717 # define __LINKAGE__\n\
2718 # define __V_ char\n\
2719 # define const\n\
2720 # define signed\n\
2721 # define void int\n\
2722 # define volatile\n\
2723 # endif\n\
2724 # define __MANGLE__ __LINKAGE__\n\
2725 # if defined(__cplusplus) || defined(c_plusplus)\n\
2726 # define __VARARG__ ...\n\
2727 # else\n\
2728 # define __VARARG__\n\
2729 # endif\n\
2730 # if defined(__STDARG__)\n\
2731 # define __VA_START__(p,a) va_start(p,a)\n\
2732 # else\n\
2733 # define __VA_START__(p,a) va_start(p)\n\
2734 # endif\n\
2735 # if !defined(__INLINE__)\n\
2736 # if defined(__cplusplus)\n\
2737 # define __INLINE__ extern __MANGLE__ inline\n\
2738 # else\n\
2739 # if defined(_WIN32) && !defined(__GNUC__)\n\
2740 # define __INLINE__ __inline\n\
2741 # endif\n\
2742 # endif\n\
2743 # endif\n\
2744 #endif\n\
2745 #if !defined(__LINKAGE__)\n\
2746 #define __LINKAGE__ /* 2004-08-11 transition */\n\
2747 #endif\n\
2748 ");
2749 }
2750 else
2751 op = strcopy(op, "\
2752 \n\
2753 #if !defined(__PROTO__)\n\
2754 #include <prototyped.h>\n\
2755 #endif\n\
2756 #if !defined(__LINKAGE__)\n\
2757 #define __LINKAGE__ /* 2004-08-11 transition */\n\
2758 #endif\n\
2759 ");
2760 if (proto->package)
2761 {
2762 s = "\
2763 #ifndef __MANGLE_%_DATA__\n\
2764 # ifdef _BLD_%\n\
2765 # ifdef __EXPORT__\n\
2766 # define __MANGLE_%_DATA__ __MANGLE__ __EXPORT__\n\
2767 # else\n\
2768 # define __MANGLE_%_DATA__ __MANGLE__\n\
2769 # endif\n\
2770 # define __MANGLE_%_FUNC__ __MANGLE__\n\
2771 # else\n\
2772 # ifdef __IMPORT__\n\
2773 # define __MANGLE_%_DATA__ __MANGLE__ __IMPORT__\n\
2774 # else\n\
2775 # define __MANGLE_%_DATA__ __MANGLE__\n\
2776 # endif\n\
2777 # define __MANGLE_%_FUNC__ __MANGLE__\n\
2778 # endif\n\
2779 #endif\n\
2780 ";
2781 for (;;)
2782 {
2783 switch (*op++ = *s++)
2784 {
2785 case 0:
2786 op--;
2787 break;
2788 case '%':
2789 op = strcopy(op - 1, proto->package);
2790 continue;
2791 default:
2792 continue;
2793 }
2794 break;
2795 }
2796 }
2797 return op;
2798 }
2799
2800
2801 #line 422
2802 static char*
__OTORP__(register char * s;)2803 nns __PARAM__((register char* s), (s)) __OTORP__(register char* s;){
2804 while (*s == ' ' || *s == '\t' || *s == '\n')
2805 s++;
2806 return s;
2807 }
2808
2809
2810 #line 439
2811 static int
__OTORP__(register char * s;int dir;)2812 directive __PARAM__((register char* s, int dir), (s, dir)) __OTORP__(register char* s; int dir;){
2813 switch (*(s = nns(s)))
2814 {
2815 case 'e':
2816 case 'i':
2817 dir <<= 2;
2818 switch (*++s)
2819 {
2820 case 'f':
2821 dir |= 01;
2822 break;
2823 case 'l':
2824 dir |= 02;
2825 break;
2826 case 'n':
2827 dir |= 03;
2828 break;
2829 }
2830 break;
2831 }
2832 return dir;
2833 }
2834
2835
2836
2837
2838
2839
2840
2841 static int
__OTORP__(register Proto_t * proto;register long flags;)2842 lex __PARAM__((register Proto_t* proto, register long flags), (proto, flags)) __OTORP__(register Proto_t* proto; register long flags;){
2843 register char* ip;
2844 register char* op;
2845 register int c;
2846 register int state;
2847 register short* rp;
2848 char* m;
2849 char* e;
2850 char* t;
2851 char* bp;
2852 char* v;
2853 char* im;
2854 char* ko;
2855 char* aom;
2856 int n;
2857 int line;
2858 int quot;
2859 int brack;
2860 int sub;
2861 int x;
2862 int vc;
2863
2864 char* ie = 0;
2865 char* om = 0;
2866 char* aim = 0;
2867 char* aie = 0;
2868 char* func = 0;
2869 int call = 0;
2870 int dir = 0;
2871 int group = 0;
2872 int last = 0;
2873 int paren = 0;
2874
2875 char* qe = 0;
2876 int qn = 0;
2877 int args = 0;
2878
2879
2880 do{(ip=proto->ip);(op=proto->op);call=proto->call;}while(0);
2881
2882 if (flags & (1L<<5)) (ko=op);
2883
2884 fsm_start:
2885 proto->tp = ip;
2886 state = 0;
2887 bp = ip;
2888 do
2889 {
2890 rp = _pp_fsmtab[state];
2891 fsm_get:
2892 while (!(state = rp[c = (*(unsigned char*)ip++)]));
2893 fsm_next:
2894 ;
2895 } while (state > 0);
2896 if ((n = ip - bp - 1) > 0)
2897 {
2898 ip = bp;
2899 do switch( n) { default : memcopy( op, ip, n); op += n; ip += n; break; case 7 : * op++ = * ip++; case 6 : * op++ = * ip++; case 5 : * op++ = * ip++; case 4 : * op++ = * ip++; case 3 : * op++ = * ip++; case 2 : * op++ = * ip++; case 1 : * op++ = * ip++; case 0 : break; } while (0);
2900 ip++;
2901 }
2902 state = ~state;
2903 fsm_terminal:
2904 switch ((( state)&((1<<(7+1))-1)))
2905 {
2906 case ((0+28)+11):
2907 if (op > proto->ob && *(op - 1) == '=' && (op == proto->ob + 1 || *(op - 2) != '=')) switch (c)
2908 {
2909 case '+':
2910 case '-':
2911 case '*':
2912 case '&':
2913 (*op++=( ' '));
2914 break;
2915 }
2916 (*op++=( c));
2917 break;
2918
2919 case ((0+28)+0):
2920 (ip--);
2921 c = (*(op-1));
2922 break;
2923
2924 case ((0+28)+1):
2925 switch (c)
2926 {
2927 case '\n':
2928 if ((( rp)>=_pp_fsmtab[(0+16)]&&( rp)<=_pp_fsmtab[(0+18)])) goto fsm_newline;
2929 (*op++=( c));
2930 proto->line++;
2931 rp = _pp_fsmtab[(0+13)];
2932 break;
2933 case '/':
2934
2935 if ((flags & ((1L<<5)|(1L<<15))) == (1L<<5)) (op=ko);
2936 else
2937
2938 (*op++=( c));
2939 if ((( rp)>=_pp_fsmtab[(0+16)]&&( rp)<=_pp_fsmtab[(0+18)]))
2940 {
2941 rp = _pp_fsmtab[(0+16)];
2942 break;
2943 }
2944 goto fsm_start;
2945 case (255+1):
2946 break;
2947 default:
2948
2949 if ((flags & ((1L<<5)|(1L<<15))) == (1L<<5)) (op=ko);
2950 else
2951
2952 (*op++=( c));
2953 rp = _pp_fsmtab[(( rp)>=_pp_fsmtab[(0+16)]&&( rp)<=_pp_fsmtab[(0+18)]) ? (0+16) : (0+14)];
2954 break;
2955 }
2956 bp = ip;
2957 goto fsm_get;
2958
2959 case ((0+28)+2):
2960 if (c)
2961 {
2962 if (state = _pp_fsmtab[(0+28)][((( rp)-_pp_fsmtab[0])/(255+1))+1])
2963 goto fsm_terminal;
2964 do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0);
2965 return 0;
2966 }
2967 (ip--);
2968 fsm_eob:
2969 if ((flags & ((1L<<1)|((1L<<16))|(1L<<21))) == ((1L<<16)) && (proto->flags & (1L<<16)))
2970 {
2971
2972 if (!(flags & (1L<<5)))
2973
2974 flags |= (1L<<24);
2975 c = ip - proto->ib;
2976 if (!(flags & (1L<<15)))
2977 im = proto->tp;
2978 if (ip > proto->ib)
2979 {
2980 n = ip - im;
2981 if (ip - n < proto->ib)
2982 proto->flags |= (1L<<4);
2983 memcopy(proto->ib - n, ip - n, n);
2984 ip = proto->ib;
2985 }
2986 proto->tp -= c;
2987 if (flags & (1L<<15))
2988 {
2989 im -= c;
2990 ie -= c;
2991 }
2992 if (aim)
2993 aim -= c;
2994 if (aie)
2995 aie -= c;
2996 if ((n = read(proto->fd, ip, proto->iz)) > 0)
2997 {
2998 if ((proto->options & (1L<<0)) && n < proto->iz)
2999 {
3000 proto->flags &= ~(1L<<16);
3001 close(proto->fd);
3002 }
3003 *(ip + n) = 0;
3004 if (state & (1<<7))
3005 goto fsm_splice;
3006 bp = ip;
3007 goto fsm_get;
3008 }
3009 *ip = 0;
3010 proto->flags &= ~(1L<<16);
3011 close(proto->fd);
3012 }
3013 if (state & (1<<7))
3014 goto fsm_splice;
3015
3016 if (!(flags & (1L<<21)) && (state = rp[c = (255+1)]))
3017 {
3018 bp = ip;
3019 goto fsm_next;
3020 }
3021 do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0);
3022 return 0;
3023
3024 case ((0+28)+3):
3025 quot = c;
3026
3027 if (c == '"' && qe)
3028 {
3029 for (n = 0, t = qe + 1; t < op && (*t == ' ' || *t == '\t' || *t == '\n' && ++n || *t >= 'A' && *t <= 'Z' || *t == '_'); t++);
3030 if (t == op)
3031 {
3032 op = qe;
3033 qe = 0;
3034 qn = n;
3035 }
3036 else (*op++=( c));
3037 }
3038 else
3039
3040 (*op++=( c));
3041 rp = _pp_fsmtab[(0+21)];
3042 bp = ip;
3043 goto fsm_get;
3044
3045 case ((0+28)+4):
3046 if (c == quot)
3047 {
3048
3049 if (!(flags & (1L<<3)))
3050 qe = (c == '"') ? op : (char*)0;
3051
3052 (*op++=( c));
3053
3054 while (qn > 0)
3055 {
3056 qn--;
3057 (*op++=( '\n'));
3058 }
3059
3060 }
3061 else if (c != '\n' && c != (255+1))
3062 {
3063 (*op++=( c));
3064 bp = ip;
3065 goto fsm_get;
3066 }
3067 else
3068 {
3069
3070 while (qn > 0)
3071 {
3072 qn--;
3073 (*op++=( '\n'));
3074 }
3075
3076 (ip--);
3077 }
3078 c = (0401+1);
3079 break;
3080
3081 case ((0+28)+5):
3082
3083 if (flags & (1L<<0)) (*op++=( c));
3084 else
3085
3086 switch (c)
3087 {
3088 case 'a':
3089 n = (('A'==0301)?0057:0007);
3090 goto fsm_oct;
3091 case 'E':
3092 n = (('A'==0301)?0047:0033);
3093 goto fsm_oct;
3094 case 'v':
3095 n = 0013;
3096 goto fsm_oct;
3097 case 'x':
3098 do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0);
3099 lex(proto, (flags & ((1L<<16))) | (1L<<21));
3100 for (n = x = 0; (c = (*(unsigned char*)ip++)), x < 3; x++) switch (c)
3101 {
3102 case '0': case '1': case '2': case '3':
3103 case '4': case '5': case '6': case '7':
3104 case '8': case '9':
3105 n = (n << 4) + c - '0';
3106 break;
3107 case 'a': case 'b': case 'c': case 'd':
3108 case 'e': case 'f':
3109 n = (n << 4) + c - 'a' + 10;
3110 break;
3111 case 'A': case 'B': case 'C': case 'D':
3112 case 'E': case 'F':
3113 n = (n << 4) + c - 'A' + 10;
3114 break;
3115 default:
3116 goto fsm_hex;
3117 }
3118 fsm_hex:
3119 (ip--);
3120 fsm_oct:
3121 (*op++=( ((n >> 6) & 07) + '0'));
3122 (*op++=( ((n >> 3) & 07) + '0'));
3123 (*op++=( (n & 07) + '0'));
3124 break;
3125 default:
3126 (*op++=( c));
3127 break;
3128 }
3129 rp = _pp_fsmtab[(0+21)];
3130 bp = ip;
3131 goto fsm_get;
3132
3133 case ((0+28)+6):
3134 (ip--);
3135
3136 if ((flags & (1L<<5)) && *proto->tp == 's' && !sstrncmp( proto->tp, "static", 6))
3137 {
3138 c = ((0500+4)+9);
3139 break;
3140 }
3141
3142 if (*proto->tp == '_' && !sstrncmp( proto->tp, "__STDPP__directive", 6)) c = '#';
3143 else c = (0401+0);
3144
3145 break;
3146
3147 case ((0+28)+7):
3148 fsm_newline:
3149 proto->line++;
3150
3151 if (flags & (1L<<5))
3152 {
3153 if (op != proto->ob && (*(op-1)) != ' ' && (*(op-1)) != '\n')
3154 (*op++=( ' '));
3155 }
3156 else
3157
3158 (*op++=( c));
3159 if (flags & (1L<<3))
3160 {
3161
3162 if (flags & (1L<<0))
3163 {
3164 if (flags & (1L<<5)) (op=ko);
3165 if (flags & (1L<<12))
3166 {
3167 *(ip - 1) = 0;
3168 op = strcopy(om, "/* ");
3169 op = strcopy(op, im);
3170 op = strcopy(op, " */\n");
3171 }
3172 flags &= ~((1L<<2)|(1L<<3)|(1L<<7)|(1L<<8)|(1L<<12)|(1L<<15)|(1L<<22)|(1L<<26));
3173 }
3174 else
3175
3176 {
3177 if ((flags & ((1L<<2)|(1L<<22))) == ((1L<<2)|(1L<<22)))
3178 {
3179 *(ip - 1) = 0;
3180 op = strcopy(om, "#if defined(__STDC__) || defined(__STDPP__)\n");
3181 op = strcopy(op, im);
3182 op = strcopy(op, "\n#else\n");
3183 bp = ip;
3184 ip = im;
3185 *op++ = *ip++;
3186 while (*op = *ip++)
3187 if (*op++ == '#' && *ip != '(')
3188 {
3189 op--;
3190 while (*--op == ' ' || *op == '\t');
3191 if (*ip == '#')
3192 {
3193 op = strcopy(op + 1, "/**/");
3194 while (*++ip == ' ' || *ip == '\t');
3195 }
3196 else
3197 {
3198 if (*op != '"') *++op = '"';
3199 op++;
3200 while (*ip == ' ' || *ip == '\t') ip++;
3201 while ((c = *ip) >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z' || c >= '0' && c <= '9' || c == '_') *op++ = *ip++;
3202 while (*ip == ' ' || *ip == '\t') ip++;
3203 if (*ip == '"') ip++;
3204 else *op++ = '"';
3205 }
3206 }
3207 ip = bp;
3208 op = strcopy(op, "\n#endif\n");
3209 op = linesync(proto, op, proto->line);
3210 }
3211 flags &= ~((1L<<2)|(1L<<3)|(1L<<7)|(1L<<8)|(1L<<15)|(1L<<17)|(1L<<22)|(1L<<23)|(1L<<25)|(1L<<26));
3212 }
3213 call = 0;
3214 group = 0;
3215 paren = 0;
3216 last = '\n';
3217 }
3218 if (paren == 0 && (flags & ((1L<<15)|(1L<<21)|(1L<<23)|(1L<<24))) == (1L<<24))
3219 {
3220
3221 if (flags & (1L<<5)) (op=ko);
3222
3223 do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0);
3224 return 0;
3225 }
3226 goto fsm_start;
3227
3228 case ((0+28)+8):
3229 (*op++=( c));
3230 rp = _pp_fsmtab[((( state)>>(7+1))&((1<<7)-1))];
3231 bp = ip;
3232 goto fsm_get;
3233
3234 case ((0+28)+13):
3235 (*op++=( c));
3236 c = (((( state)>>(7+1))&((1<<7)-1))+0401);
3237 break;
3238
3239 case ((0+28)+14):
3240 (ip--);
3241 c = (((( state)>>(7+1))&((1<<7)-1))+0401);
3242 break;
3243
3244 case (((0+28)+12)):
3245 (ip--);
3246 c = (0401+0);
3247 if (!(flags & (1L<<1))) switch (((((long)( *proto->tp))<<16)|(((long)( *(ip - 1)))<<8)|((long)( ip - proto->tp))))
3248 {
3249 case ((((long)( 'N'))<<16)|(((long)( 'N'))<<8)|((long)( 3))):
3250 if (proto->tp[1] == 'o')
3251 c = ((0500+4)+6);
3252 break;
3253 case ((((long)( 'd'))<<16)|(((long)( 'o'))<<8)|((long)( 2))):
3254 c = ((0500+4)+6);
3255 break;
3256 case ((((long)( 'e'))<<16)|(((long)( 'e'))<<8)|((long)( 4))):
3257 if (!(flags & (1L<<21)) && (flags & ((1L<<3)|(1L<<25))) != (1L<<3) && !sstrncmp( proto->tp, "else", 4))
3258 {
3259 c = ((0500+4)+8);
3260 goto fsm_id;
3261 }
3262 break;
3263 case ((((long)( 'e'))<<16)|(((long)( 'n'))<<8)|((long)( 6))):
3264 if (!sstrncmp( proto->tp, "extern", 6))
3265 c = ((0500+4)+9);
3266 break;
3267 case ((((long)( 'f'))<<16)|(((long)( 'r'))<<8)|((long)( 3))):
3268 if (!(flags & (1L<<21)) && !sstrncmp( proto->tp, "for", 3))
3269 {
3270 c = ((0500+4)+11);
3271 goto fsm_id;
3272 }
3273 break;
3274 case ((((long)( 'i'))<<16)|(((long)( 'f'))<<8)|((long)( 2))):
3275 c = ((0500+4)+13);
3276 break;
3277 case ((((long)( 'i'))<<16)|(((long)( 'e'))<<8)|((long)( 6))):
3278 if (!sstrncmp( proto->tp, "inline", 6) && !(flags & ((1L<<15)|(1L<<23)|(1L<<25)|(1L<<26))) && proto->brace == 0 && paren == 0 && group == 0 && (last == ';' || last == '}' || last == '\n' || last == 0))
3279 {
3280 flags |= (1L<<23);
3281 do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0);
3282 line = proto->line;
3283 op = strcopy(op - 6, "__INLINE__");
3284 do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0);
3285 }
3286 break;
3287 case ((((long)( 'r'))<<16)|(((long)( 'n'))<<8)|((long)( 6))):
3288 if (!(flags & (1L<<21)) && !sstrncmp( proto->tp, "return", 6))
3289 {
3290 c = ((0500+4)+17);
3291 goto fsm_id;
3292 }
3293 break;
3294 case ((((long)( 's'))<<16)|(((long)( 'c'))<<8)|((long)( 6))):
3295 if ((proto->options & (1L<<6)) && !sstrncmp( proto->tp, "static", 6))
3296 {
3297 proto->ox = op - 6;
3298 flags |= (1L<<6);
3299 }
3300 break;
3301 case ((((long)( 't'))<<16)|(((long)( 'f'))<<8)|((long)( 7))):
3302 if (!(flags & (1L<<21)) && !sstrncmp( proto->tp, "typedef", 7))
3303 {
3304 flags |= (1L<<26);
3305 c = ((0500+4)+9);
3306 }
3307 break;
3308 case ((((long)( 'v'))<<16)|(((long)( 't'))<<8)|((long)( 8))):
3309 if (*ip == '(' && !sstrncmp( proto->tp, "va_start", 8)) c = (0500+1);
3310 break;
3311 case ((((long)( 'v'))<<16)|(((long)( 'd'))<<8)|((long)( 4))):
3312 if (!sstrncmp( proto->tp, "void", 4))
3313 {
3314 if (flags & ((1L<<0)|(1L<<19)|(1L<<10)|(1L<<11))) c = ((0500+4)+30);
3315 else
3316 {
3317 do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0);
3318 line = proto->line;
3319 if (lex(proto, (flags & ((1L<<16))) | (1L<<21)) == '*')
3320 {
3321 memcopy(op - 4, "__V_", 4);
3322 memcopy(ip - 4, "__V_", 4);
3323 }
3324 else c = ((0500+4)+30);
3325 proto->line = line;
3326 do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0);
3327 bp = ip;
3328 }
3329 }
3330 break;
3331 case ((((long)( 'w'))<<16)|(((long)( 'e'))<<8)|((long)( 5))):
3332 if (!(flags & (1L<<21)) && !sstrncmp( proto->tp, "while", 5))
3333 {
3334 c = ((0500+4)+26);
3335 goto fsm_id;
3336 }
3337 break;
3338 }
3339
3340 if ((flags & (1L<<0)) && c != ((0500+4)+9))
3341 c = (0401+0);
3342
3343 break;
3344
3345 case ((0+28)+10):
3346 goto fsm_start;
3347
3348 case ((0+28)+15):
3349 (ip--);
3350
3351 if ((flags & ((1L<<5)|(1L<<15))) == (1L<<5))
3352 {
3353 while (op > proto->ob && (*(op - 1) == ' ' || *(op - 1) == '\t'))
3354 op--;
3355 if (op > proto->ob && *(op - 1) != '\n') *op++ = ' ';
3356 }
3357
3358 goto fsm_start;
3359
3360 default:
3361 if (state & (1<<7))
3362 {
3363 if (c == '\\')
3364 {
3365 if (!(n = (*(unsigned char*)ip++)))
3366 {
3367 goto fsm_eob;
3368 fsm_splice:
3369 c = '\\';
3370 n = (*(unsigned char*)ip++);
3371 }
3372 if (n == '\n')
3373 {
3374 proto->line++;
3375 (*op++=( '\\'));
3376 (*op++=( '\n'));
3377 bp = ip;
3378 goto fsm_get;
3379 }
3380 (ip--);
3381 }
3382 state &= ~(1<<7);
3383 if (state >= (0+28))
3384 goto fsm_terminal;
3385 rp = _pp_fsmtab[state];
3386 }
3387 (*op++=( c));
3388 bp = ip;
3389 goto fsm_get;
3390 }
3391 if (!(flags & ((1L<<10)|(1L<<11)|(1L<<21))))
3392 {
3393 if (!(flags & (1L<<3))) switch (c)
3394 {
3395 case '(':
3396
3397 if (!(flags & (1L<<0)) || proto->brace == 0)
3398
3399 {
3400 if (paren++ == 0)
3401 {
3402
3403 if (!(flags & (1L<<0)) || group <= 1)
3404
3405 {
3406
3407 args = 0;
3408
3409 if (group++ == 0) group++;
3410 else if (flags & (1L<<8)) call++;
3411 flags |= (1L<<15);
3412 im = ip - 1;
3413 om = op - 1;
3414 }
3415 sub = 0;
3416 }
3417 else if (paren == 2 && !aim)
3418 {
3419 sub++;
3420 if (last == '(')
3421 {
3422 flags &= ~(1L<<15);
3423 om = 0;
3424 }
3425 else if (flags & (1L<<8))
3426 {
3427 aim = ip - 1;
3428 aom = op - 1;
3429 }
3430 else if ((flags & ((1L<<15)|(1L<<25))) == (1L<<15))
3431 {
3432 for (m = ip - 2; m > im && (*m == ' ' || *m == '\t'); m--);
3433 if (m != im && sub == 1)
3434 {
3435 m = im + (*nns(ip) == '*');
3436 }
3437 if (m == im)
3438 {
3439 flags &= ~(1L<<15);
3440 om = 0;
3441 }
3442 }
3443 else if ((flags & (1L<<15)) && sub == 1 && *nns(ip) != '*')
3444 {
3445 flags &= ~(1L<<15);
3446 om = 0;
3447 }
3448 }
3449 flags &= ~(1L<<25);
3450 }
3451 break;
3452 case ')':
3453
3454 if (!(flags & (1L<<0)) || proto->brace == 0)
3455
3456 if (--paren == 0)
3457 {
3458
3459 if (flags & (1L<<0))
3460 {
3461 if (group != 2)
3462 {
3463 c = (0401+0);
3464 break;
3465 }
3466 group++;
3467 }
3468
3469 ie = ip;
3470 }
3471 else if (paren == 1 && (flags & (1L<<8)) && !aie)
3472 aie = ip;
3473 break;
3474 case '*':
3475 if (last == '(' && group == 2)
3476 {
3477 group--;
3478 if (paren == 1)
3479 {
3480 flags |= (1L<<8);
3481 aim = aie = 0;
3482 }
3483 }
3484 break;
3485 case '#':
3486 dir = directive(ip, dir);
3487 if (proto->brace == 0 && paren == 0 && last != '=' && (flags & ((1L<<0)|(1L<<1)|(1L<<3)|(1L<<15)|(1L<<19)|(1L<<23)|(1L<<25))) == ((1L<<15)|(1L<<25)) && ((dir & 03) != 03 || ((dir>>2) & 03) != 01))
3488 flags |= (1L<<3);
3489 else if (!(flags & ((1L<<1)|(1L<<3))))
3490 {
3491 flags |= (1L<<3);
3492 if (!(flags & (1L<<19)))
3493 {
3494 bp = ip;
3495 while (*ip == ' ' || *ip == '\t') ip++;
3496 if (*ip == 'l' && *++ip == 'i' && *++ip == 'n' && *++ip == 'e')
3497 {
3498 if (*++ip == ' ' || *ip == '\t')
3499 {
3500 proto->line = 0;
3501 while (*++ip >= '0' && *ip <= '9')
3502 proto->line = proto->line * 10 + *ip - '0';
3503 proto->line--;
3504 }
3505 }
3506
3507 else if ((flags & ((1L<<0)|(1L<<5))) == (1L<<0))
3508 {
3509 n = 0;
3510 t = ip + 6;
3511 while (ip < t && *ip >= 'a' && *ip <= 'z')
3512 n = ((( n)<<5)+(( *ip++)-('a'-1)));
3513 switch (n)
3514 {
3515 case ((( ((( ((( (( 'e')-('a'-1)))<<5)+(( 'l')-('a'-1))))<<5)+(( 's')-('a'-1))))<<5)+(( 'e')-('a'-1))):
3516 case ((( ((( ((( ((( (( 'e')-('a'-1)))<<5)+(( 'n')-('a'-1))))<<5)+(( 'd')-('a'-1))))<<5)+(( 'i')-('a'-1))))<<5)+(( 'f')-('a'-1))):
3517 while (*ip == ' ' || *ip == '\t') ip++;
3518 if (*ip != '\n' && *ip != '/' && *(ip + 1) != '*')
3519 {
3520 flags |= (1L<<12)|(1L<<15);
3521 im = ip;
3522 om = op + (ip - bp);
3523 }
3524 break;
3525 case ((( ((( ((( (( 'e')-('a'-1)))<<5)+(( 'l')-('a'-1))))<<5)+(( 'i')-('a'-1))))<<5)+(( 'f')-('a'-1))):
3526 case ((( ((( ((( ((( (( 'e')-('a'-1)))<<5)+(( 'r')-('a'-1))))<<5)+(( 'r')-('a'-1))))<<5)+(( 'o')-('a'-1))))<<5)+(( 'r')-('a'-1))):
3527 case ((( (( 'i')-('a'-1)))<<5)+(( 'f')-('a'-1))):
3528 case ((( ((( ((( ((( (( 'i')-('a'-1)))<<5)+(( 'f')-('a'-1))))<<5)+(( 'd')-('a'-1))))<<5)+(( 'e')-('a'-1))))<<5)+(( 'f')-('a'-1))):
3529 case ((( ((( ((( ((( ((( (( 'i')-('a'-1)))<<5)+(( 'f')-('a'-1))))<<5)+(( 'n')-('a'-1))))<<5)+(( 'd')-('a'-1))))<<5)+(( 'e')-('a'-1))))<<5)+(( 'f')-('a'-1))):
3530 case ((( ((( ((( ((( (( 'u')-('a'-1)))<<5)+(( 'n')-('a'-1))))<<5)+(( 'd')-('a'-1))))<<5)+(( 'e')-('a'-1))))<<5)+(( 'f')-('a'-1))):
3531 break;
3532 case ((( ((( ((( ((( ((( (( 'i')-('a'-1)))<<5)+(( 'n')-('a'-1))))<<5)+(( 'c')-('a'-1))))<<5)+(( 'l')-('a'-1))))<<5)+(( 'u')-('a'-1))))<<5)+(( 'd')-('a'-1))):
3533 if (*ip == 'e') ip++;
3534
3535 case ((( ((( ((( ((( ((( (( 'd')-('a'-1)))<<5)+(( 'e')-('a'-1))))<<5)+(( 'f')-('a'-1))))<<5)+(( 'i')-('a'-1))))<<5)+(( 'n')-('a'-1))))<<5)+(( 'e')-('a'-1))):
3536 case ((( ((( ((( ((( ((( (( 'p')-('a'-1)))<<5)+(( 'r')-('a'-1))))<<5)+(( 'a')-('a'-1))))<<5)+(( 'g')-('a'-1))))<<5)+(( 'm')-('a'-1))))<<5)+(( 'a')-('a'-1))):
3537 if (*ip < 'a' || *ip > 'z') break;
3538
3539 default:
3540 flags |= (1L<<12)|(1L<<15);
3541 im = bp - 1;
3542 om = op - 1;
3543 break;
3544 }
3545 }
3546 else
3547
3548 {
3549 if (*ip == 'i' && *++ip == 'n' && *++ip == 'c' && *++ip == 'l' && *++ip == 'u' && *++ip == 'd' && *++ip == 'e')
3550 {
3551 while (*++ip == ' ' || *ip == '\t');
3552 if (*ip++ == '<' && *ip++ == 's' && *ip++ == 't' && *ip++ == 'd' && *ip++ == 'a' && *ip++ == 'r' && *ip++ == 'g' && *ip++ == '.' && *ip++ == 'h' && *ip++ == '>')
3553 {
3554 op = strcopy(op, "\
3555 if !defined(va_start)\n\
3556 #if defined(__STDARG__)\n\
3557 #include <stdarg.h>\n\
3558 #else\n\
3559 #include <varargs.h>\n\
3560 #endif\n\
3561 #endif\n\
3562 ");
3563 op = linesync(proto, op, proto->line);
3564 break;
3565 }
3566 }
3567 else if (*ip == 'd' && *++ip == 'e' && *++ ip == 'f' && *++ip == 'i' && *++ip == 'n' && *++ip == 'e' && (*++ip == ' ' || *ip == '\t'))
3568 {
3569 while (*++ip == ' ' || *ip == '\t');
3570 if (*ip == 'e' && *++ip == 'x' && *++ ip == 't' && *++ip == 'e' && *++ip == 'r' && *++ip == 'n' && (*++ip == ' ' || *ip == '\t'))
3571 {
3572 t = ip;
3573 while (*++t == ' ' || *t == '\t');
3574 if (*t == 'e' && *++t == 'x' && *++ t == 't' && *++t == 'e' && *++t == 'r' && *++t == 'n' && (*++t == ' ' || *t == '\t' || *t == '\n' || *t == '\r'))
3575 ip = t;
3576 t = ip;
3577 while (*++t == ' ' || *t == '\t');
3578 if (*t == '_' && *(t + 1) == '_')
3579 {
3580 op = strcopy(op, "undef __MANGLE__\n");
3581 op = linesync(proto, op, proto->line);
3582 op = strcopy(op, "#define __MANGLE__ __LINKAGE__");
3583 break;
3584 }
3585 }
3586 flags |= (1L<<2)|(1L<<15);
3587 im = bp - 1;
3588 om = op - 1;
3589 }
3590 else if (*ip == 'u' && *++ip == 'n' && *++ ip == 'd' && *++ip == 'e' && *++ip == 'f' && (*++ip == ' ' || *ip == '\t'))
3591 {
3592 while (*++ip == ' ' || *ip == '\t');
3593 if (*ip == 'e' && *++ip == 'x' && *++ ip == 't' && *++ip == 'e' && *++ip == 'r' && *++ip == 'n' && (*++ip == ' ' || *ip == '\t' || *ip == '\n' || *ip == '\r'))
3594 {
3595 op = strcopy(op, "undef __MANGLE__\n");
3596 op = linesync(proto, op, proto->line);
3597 op = strcopy(op, "#define __MANGLE__ __LINKAGE__");
3598 break;
3599 }
3600 flags |= (1L<<2)|(1L<<15);
3601 im = bp - 1;
3602 om = op - 1;
3603 }
3604 }
3605 ip = bp;
3606 }
3607 break;
3608 }
3609 else
3610 break;
3611
3612 case '{':
3613 if (proto->brace++ == 0 && paren == 0)
3614 {
3615 if (last == '=') flags |= (1L<<9);
3616
3617 else if (flags & (1L<<0))
3618 {
3619 if ((flags & ((1L<<15)|(1L<<17)|(1L<<23))) == (1L<<15))
3620 {
3621 if (args)
3622 {
3623 v = number(op, args < 0 ? -args : args);
3624 v = strcopy(v, " argument actual/formal mismatch");
3625 *v++ = ' ';
3626 v = memcopy(v, im, ie - im);
3627 *v = 0;
3628 proto_error((char*)proto + sizeof(Proto_t), 2, op, ((char*)0));
3629 }
3630 ip--;
3631
3632 v = ie;
3633 while (ie < ip)
3634 if (*ie++ == '/' && *ie == '*')
3635 {
3636 e = ie - 1;
3637 while (++ie < ip)
3638 {
3639 if (*ie == '*')
3640 {
3641 while (ie < ip && *ie == '*') ie++;
3642 if (ie < ip && *ie == '/')
3643 {
3644 while (++ie < ip && (*ie == ' ' || *ie == '\t'));
3645 while (e > v && (*(e - 1) == ' ' || *(e - 1) == '\t')) e--;
3646 if (e > v && *e != '\n') *e++ = ' ';
3647 t = ie;
3648 while (--e >= v)
3649 *--t = *e;
3650 v = t;
3651 break;
3652 }
3653 }
3654 }
3655 }
3656 ie = v;
3657
3658 op = om++;
3659 if (flags & (1L<<5))
3660 {
3661 v = op;
3662 while (v > ko && *--v != ' ');
3663 if (*v != ' ')
3664 {
3665 om = (v = (op += 4)) + 1;
3666 while (v >= ko + 4)
3667 {
3668 *v = *(v - 4);
3669 v--;
3670 }
3671 memcopy(ko, "int ", 4);
3672 }
3673 if (*v == ' ')
3674 {
3675 while (*(v + 1) == '*')
3676 *v++ = '*';
3677 *v = '\t';
3678 if ((v - ko) <= 8)
3679 {
3680 om = (e = ++op) + 1;
3681 while (e > v)
3682 {
3683 *e = *(e - 1);
3684 e--;
3685 }
3686 }
3687 }
3688 om = (v = (op += 7)) + 1;
3689 while (v >= ko + 7)
3690 {
3691 *v = *(v - 7);
3692 v--;
3693 }
3694 memcopy(ko, "extern ", 7);
3695 }
3696 (*op++=( '('));
3697 t = op;
3698 e = 0;
3699
3700 while (ie < ip)
3701 {
3702 if ((c = *ie) == ' ' || c == '\t' || c == '\n')
3703 {
3704 while ((c = *++ie) == ' ' || c == '\t' || c == '\n');
3705 if (ie >= ip) break;
3706 if (c != '*' && op > om) (*op++=( ' '));
3707 }
3708 if ((n = ((c = *ie) == ',')) || c == ';')
3709 {
3710 if (flags & (1L<<5))
3711 {
3712 m = op;
3713 while (op > om && ((c = *(op - 1)) == '(' || c == ')' || c == '[' || c == ']'))
3714 op--;
3715 v = op;
3716 while (op > om && (c = *(op - 1)) != ' ' && c != '*')
3717 op--;
3718 while (*(op - 1) == ' ')
3719 op--;
3720 if (!e)
3721 {
3722 e = op;
3723 while (e > om && *(e - 1) == '*')
3724 e--;
3725 }
3726
3727
3728
3729
3730 if (op <= om)
3731 op = strcopy(op, "int");
3732 else if (*(op - 1) == ',')
3733 op = strcopy(op, " int");
3734
3735 while (v < m)
3736 (*op++=( *v++));
3737 }
3738 (*op++=( ','));
3739 if (n)
3740 {
3741 if (x = !e) e = op - 1;
3742 (*op++=( ' '));
3743 m = t;
3744 while (m < e)
3745 (*op++=( *m++));
3746 if (x)
3747 {
3748 m = e;
3749 while (*--e != ' ');
3750 while (*(e - 1) == '*') e--;
3751 op -= m - e;
3752 }
3753 }
3754 while ((c = *++ie) == ' ' || c == '\t' || c == '\n');
3755 if (ie >= ip) (op--);
3756 else (*op++=( ' '));
3757 if (!n)
3758 {
3759 t = op;
3760 e = 0;
3761 }
3762 }
3763 else if (*ie == '*')
3764 {
3765 if (op > om && (c = *(op - 1)) == ' ') op--;
3766 while (*ie == '*') (*op++=( *ie++));
3767 while (*ie == ' ' || *ie == '\t' || *ie == '\n') ie++;
3768 if (c != '(') (*op++=( ' '));
3769 }
3770 else if (*ie == '(')
3771 {
3772 if (op > om && *(op - 1) == ' ') op--;
3773 (*op++=( *ie++));
3774 while (*ie == ' ' || *ie == '\t' || *ie == '\n') ie++;
3775 }
3776 else if (*ie == ')')
3777 {
3778 if (op > om && *(op - 1) == '(')
3779 proto_error((char*)proto + sizeof(Proto_t), 1, "function pointer argument prototype omitted", ((char*)0));
3780 (*op++=( *ie++));
3781 while (*ie == ' ' || *ie == '\t' || *ie == '\n') ie++;
3782 }
3783 else if ((flags & (1L<<5)) && (op == om || *(op - 1) == ' ') && *ie == 'r' && !sstrncmp( ie, "register", 8) && (*(ie + 8) == ' ' || *(ie + 8) == '\t' || *(ie + 8) == '\n'))
3784 {
3785 ie += 8;
3786 if (op > om) (op--);
3787 }
3788 else (*op++=( *ie++));
3789 }
3790
3791 if (op <= om) op = strcopy(op, "void");
3792 (*op++=( ')'));
3793 if (flags & (1L<<5))
3794 {
3795 (*op++=( ';'));
3796 (*op++=( '\n'));
3797 (proto->op=op);
3798 (ko=op);
3799 }
3800 else
3801 {
3802 (*op++=( '\n'));
3803 (*op++=( *ip));
3804 }
3805 ip++;
3806 flags &= ~((1L<<15)|(1L<<23));
3807 }
3808 }
3809
3810 else if ((flags & ((1L<<15)|(1L<<19)|(1L<<23)|(1L<<25))) == ((1L<<15)|(1L<<25)))
3811 {
3812 line = proto->line;
3813 op = strcopy(om, " __PARAM__(");
3814 op = memcopy(op, im, ie - im);
3815 (*op++=( ','));
3816 (*op++=( ' '));
3817 (*op++=( '('));
3818 flags &= ~((1L<<15)|(1L<<23));
3819 if (flags & (1L<<27))
3820 {
3821 if ((vc = ie - im + 1) > sizeof(proto->variadic)) vc = sizeof(proto->variadic);
3822 memcopy(proto->variadic, im, vc);
3823 op = strcopy(op, "va_alist)) __OTORP__(va_dcl)\n{");
3824 }
3825 else
3826 {
3827 flags |= (1L<<23);
3828 proto->ip = im;
3829 proto->op = op;
3830 group = 0;
3831 brack = 0;
3832 for (;;)
3833 {
3834 switch (lex(proto, (flags & ((1L<<16))) | (1L<<21)))
3835 {
3836 case '[':
3837 brack++;
3838 continue;
3839 case ']':
3840 brack--;
3841 continue;
3842 case '(':
3843 if (paren++) group++;
3844 continue;
3845 case ')':
3846 if (--paren == 0)
3847 {
3848 group = 0;
3849 if (flags & (1L<<15))
3850 {
3851 flags &= ~((1L<<15)|(1L<<23));
3852 op = memcopy(op, m, e - m);
3853 }
3854 break;
3855 }
3856 continue;
3857 case ',':
3858 if (paren == 1)
3859 {
3860 group = 0;
3861 if (flags & (1L<<15))
3862 {
3863 flags &= ~((1L<<15)|(1L<<23));
3864 op = memcopy(op, m, e - m);
3865 }
3866 (*op++=( ','));
3867 (*op++=( ' '));
3868 proto->op = op;
3869 }
3870 continue;
3871 case (0401+0):
3872 if (group <= 1 && !brack)
3873 {
3874 flags |= (1L<<15);
3875 m = proto->tp;
3876 e = proto->ip;
3877 }
3878 continue;
3879 default:
3880 continue;
3881 }
3882 break;
3883 }
3884 (*op++=( ')'));
3885 (*op++=( ')'));
3886 }
3887 if (!(flags & (1L<<23)))
3888 {
3889 flags |= (1L<<23);
3890 proto->op = strcopy(op, " __OTORP__(");
3891 proto->ip = im + 1;
3892 n = *(ie - 1);
3893 *(ie - 1) = ';';
3894 c = *ie;
3895 *ie = 0;
3896 lex(proto, (flags & ((1L<<16))) | (1L<<1));
3897 *(ie - 1) = n;
3898 *ie = c;
3899 proto->ip = ie;
3900 op = proto->op;
3901 (*op++=( ')'));
3902 }
3903 if (flags & (1L<<6)) memcopy( proto->ox, "extern", 6);
3904 op = linesync(proto, op, proto->line = line);
3905 if (flags & (1L<<3))
3906 {
3907 proto->brace = 0;
3908 (*op++=( '\n'));
3909 (*op++=( '#'));
3910 }
3911 else if (!(flags & (1L<<27))) (*op++=( '{'));
3912 }
3913 }
3914 flags &= ~((1L<<7)|(1L<<8)|(1L<<15)|(1L<<17)|(1L<<23));
3915 call = 0;
3916 group = 0;
3917 break;
3918 case '}':
3919 flags &= ~((1L<<7)|(1L<<8)|(1L<<15)|(1L<<17)|(1L<<23)|(1L<<25));
3920 if (--proto->brace == 0)
3921 {
3922 flags &= ~((1L<<9)|(1L<<27)|(1L<<28));
3923
3924 if (flags & (1L<<5)) (op=ko);
3925
3926 }
3927 call = 0;
3928 group = 0;
3929 paren = 0;
3930 break;
3931 case '=':
3932 if (last == '?') flags |= (1L<<3);
3933 else if (paren == 0 && (flags & ((1L<<9)|(1L<<15)|(1L<<23))) == (1L<<15))
3934 {
3935 if (last == ')' && proto->brace && (group != 2 || call != 2)) flags |= (1L<<23);
3936 else goto fsm_statement;
3937 }
3938 goto fsm_other;
3939 case ',':
3940
3941 if (flags & (1L<<0))
3942 {
3943 if (paren == 1) args++;
3944 else
3945 {
3946 args--;
3947 flags &= ~(1L<<15);
3948 }
3949 break;
3950 }
3951
3952 if (paren == 0 && (flags & (1L<<1))) *(op - 1) = c = ';';
3953
3954 case ';':
3955 fsm_statement:
3956 if (flags & (1L<<9)) ;
3957
3958 else if (flags & (1L<<0))
3959 {
3960 if (paren == 0)
3961 {
3962 if ((flags & (1L<<15)) && last == ')')
3963 flags &= ~(1L<<15);
3964 if (!(flags & (1L<<15)))
3965 {
3966 call = 0;
3967 group = 0;
3968 flags &= ~(1L<<23);
3969 if (flags & (1L<<5)) (op=ko);
3970 if (flags & (1L<<24))
3971 {
3972 do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0);
3973 return 0;
3974 }
3975 }
3976 else
3977 {
3978 args--;
3979 if ((flags & ((1L<<5)|(1L<<23))) == ((1L<<5)|(1L<<23)))
3980 (op=ko);
3981 }
3982 }
3983 }
3984
3985 else if (paren == 0)
3986 {
3987 if ((flags & ((1L<<15)|(1L<<17)|(1L<<23))) == (1L<<15) && call > 1)
3988 {
3989 if ((flags & (1L<<14)) && func)
3990 {
3991 func[0] = 'F';
3992 func[1] = 'U';
3993 func[2] = 'N';
3994 func[3] = 'C';
3995 func = 0;
3996 }
3997 if ((flags & ((1L<<1)|(1L<<8))) == (1L<<8) && aim && aie < im)
3998 {
3999 while (aie < ip && (*aie == ' ' || *aie == '\t' || *aie == '\n')) aie++;
4000 v = aim;
4001 while (v < aie)
4002 if (*v++ == ')') break;
4003 while (v < aie && (*v == ' ' || *v == '\t' || *v == '\n')) v++;
4004 if (v == aie || !(flags & (1L<<20)))
4005 {
4006 if (flags & (1L<<20)) n = 3;
4007 else if (v == aie && *v == '(') n = 10;
4008 else n = 11;
4009 ko = op;
4010 om += n;
4011 v = op += n;
4012 while (v >= ko + n)
4013 {
4014 *v = *(v - n);
4015 v--;
4016 }
4017 if (flags & (1L<<20)) memcopy(aom, "(...))", 6);
4018 else if (n == 10) memcopy(aom, "(__VARARG__))", 13);
4019 else
4020 {
4021 ko = strcopy(aom, " __PROTO__(");
4022 ko = memcopy(ko, aim, aie - aim);
4023 *ko = ')';
4024 if (++ko >= om)
4025 {
4026 *ko++ = ')';
4027 om = ko;
4028 }
4029 }
4030 }
4031 }
4032 else if (flags & (1L<<26))
4033 {
4034 op = om;
4035 while (*--op == ' ' || *op == '\t' || *op == '\n');
4036 if (*op != ')')
4037 {
4038 op = om += 14;
4039 *--op = ')';
4040 while ((x = *(op - 14)) >= 'A' && x <= 'Z' || x >= 'a' && x <= 'z' || x >= '0' && x <= '9' || x == '_')
4041 *--op = x;
4042 memcopy(op - 13, "(__OTORP__(*)", 13);
4043 }
4044 }
4045 if (flags & (1L<<17))
4046 ;
4047 else if (flags & (1L<<20))
4048 {
4049 op = om;
4050 if (!(flags & (1L<<25))) op = strcopy(op, "(...)");
4051 else op = memcopy(op, im, ie - im);
4052 (*op++=( c));
4053 }
4054 else
4055 {
4056 if (flags & (1L<<1)) op = strcopy(om, "()");
4057 else if (!(flags & (1L<<25))) op = strcopy(om, "(__VARARG__)");
4058 else
4059 {
4060 op = strcopy(om, " __PROTO__(");
4061 op = memcopy(op, im, ie - im);
4062 (*op++=( ')'));
4063 }
4064 if (flags & (1L<<6)) memcopy( proto->ox, "extern", 6);
4065 (*op++=( c));
4066 }
4067 flags &= ~((1L<<15)|(1L<<27)|(1L<<28));
4068 if (c == ',' && !(flags & (1L<<8)))
4069 {
4070 call = 1;
4071 group = 0;
4072 break;
4073 }
4074 }
4075 else if (flags & ((1L<<17)|(1L<<23))) call = 0;
4076 if (c == ';')
4077 {
4078 flags &= ~((1L<<6)|(1L<<14)|(1L<<25)|(1L<<26));
4079 call = 0;
4080 if (flags & (1L<<24))
4081 {
4082 do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0);
4083 return 0;
4084 }
4085 }
4086 else call = call > 1 && c == ',';
4087 group = 0;
4088 flags &= ~((1L<<7)|(1L<<8)|(1L<<15)|(1L<<17)|(1L<<23));
4089 }
4090 else if (paren == 1 && group == 1 && !(flags & ((1L<<7)|(1L<<14)))) flags |= (1L<<25)|(1L<<17);
4091 break;
4092 case ((0500+4)+6):
4093 case ((0500+4)+13):
4094 flags |= (1L<<25)|(1L<<23);
4095 break;
4096 case ((0500+4)+9):
4097
4098 if (flags & (1L<<0))
4099 {
4100 if (proto->brace == 0)
4101 flags |= (1L<<23);
4102 }
4103 else
4104
4105 if (paren == 0 && !(flags & (1L<<26)))
4106 {
4107 flags |= (1L<<14);
4108 if (!(flags & (1L<<19)) || proto->package)
4109 {
4110 op = strcopy(op, " __MANGLE__");
4111 if (proto->package)
4112 {
4113 op = strcopy(op - 1, proto->package);
4114 func = op + 1;
4115 op = strcopy(op, "_DATA__");
4116 }
4117 }
4118 else
4119 func = 0;
4120 }
4121 break;
4122 case (0401+29):
4123 if (paren == 0 && (flags & ((1L<<1)|(1L<<27))) == (1L<<1))
4124 {
4125 op -= 3;
4126 do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0);
4127 return c;
4128 }
4129 if (paren == 1 && !(flags & (1L<<23)))
4130 flags |= (1L<<27);
4131 flags |= (1L<<25);
4132 break;
4133 case ((0500+4)+30):
4134 goto fsm_id;
4135 case (0500+1):
4136 if ((flags & ((1L<<19)|(1L<<27))) == (1L<<27))
4137 {
4138 flags &= ~(1L<<15);
4139 line = proto->line;
4140 op = strcopy(op - 8, "__VA_START__");
4141 do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0);
4142 for (;;)
4143 {
4144 switch (lex(proto, (flags & ((1L<<16))) | (1L<<21)))
4145 {
4146 case 0:
4147 case ';':
4148 break;
4149 case (0401+0):
4150 if (!(flags & (1L<<15)))
4151 {
4152 flags |= (1L<<15);
4153 m = proto->tp;
4154 e = proto->ip;
4155 }
4156 continue;
4157 default:
4158 continue;
4159 }
4160 break;
4161 }
4162 do{(ip=proto->ip);(op=proto->op);call=proto->call;}while(0);
4163 if (flags & (1L<<15))
4164 {
4165 v = m;
4166 n = e - m;
4167 }
4168 else
4169 {
4170 v = "ap";
4171 n = 2;
4172 }
4173 op = strcopy(op, " __OTORP__(");
4174 proto->ip = proto->variadic;
4175 proto->op = op;
4176 flags &= ~(1L<<15);
4177 group = 0;
4178 bp = proto->ip + 1;
4179 if (*bp == 'r' && !sstrncmp( bp, "register", 8) && (*(bp + 8) == ' ' || *(bp + 8) == '\t')) bp += 9;
4180 for (;;)
4181 {
4182 switch (lex(proto, (flags & ((1L<<16))) | (1L<<21)))
4183 {
4184 case '(':
4185 if (paren++) group++;
4186 continue;
4187 case ')':
4188 if (--paren == 0)
4189 {
4190 if (flags & (1L<<15))
4191 {
4192 flags &= ~(1L<<15);
4193 if (!(flags & (1L<<28)))
4194 {
4195 op = memcopy(op, m, e - m);
4196 op = strcopy(op, " = ");
4197 }
4198 op = strcopy(op, "va_arg(");
4199 op = memcopy(op, v, n);
4200 (*op++=( ','));
4201 (*op++=( ' '));
4202 if (m > bp) op = memcopy(op, bp, m - bp);
4203 else op = strcopy(op, "int ");
4204 if (group > 1) op = strcopy(op, ")()");
4205 else op = memcopy(op, e, proto->ip - e - 1);
4206 (*op++=( ')'));
4207 (*op++=( ';'));
4208 }
4209 group = 0;
4210 break;
4211 }
4212 continue;
4213 case ',':
4214 if (paren == 1)
4215 {
4216 if (flags & (1L<<15))
4217 {
4218 flags &= ~(1L<<15);
4219 if (!(flags & (1L<<28)))
4220 {
4221 op = memcopy(op, m, e - m);
4222 op = strcopy(op, " = ");
4223 }
4224 op = strcopy(op, "va_arg(");
4225 op = memcopy(op, v, n);
4226 (*op++=( ','));
4227 (*op++=( ' '));
4228 if (m > bp) op = memcopy(op, bp, m - bp);
4229 else op = strcopy(op, "int ");
4230 if (group > 1) op = strcopy(op, ")()");
4231 else op = memcopy(op, e, proto->ip - e - 1);
4232 (*op++=( ')'));
4233 (*op++=( ';'));
4234 bp = proto->ip + 1;
4235 if (*bp == 'r' && !sstrncmp( bp, "register", 8) && (*(bp + 8) == ' ' || *(bp + 8) == '\t')) bp += 9;
4236 }
4237 group = 0;
4238 proto->op = op;
4239 }
4240 continue;
4241 case (0401+0):
4242 if (group <= 1)
4243 {
4244 flags |= (1L<<15);
4245 m = proto->tp;
4246 e = proto->ip;
4247 }
4248 continue;
4249 default:
4250 continue;
4251 }
4252 break;
4253 }
4254 op = strcopy(op, ")");
4255 flags |= (1L<<28);
4256 proto->line = line;
4257 call = 0;
4258 break;
4259 }
4260
4261 case (0401+0):
4262 fsm_id:
4263
4264 if (flags & (1L<<0))
4265 {
4266 if (!args && paren == 1) args++;
4267 break;
4268 }
4269
4270 if (paren == 0)
4271 {
4272 if (last == ')')
4273 {
4274 if (proto->brace == 0 && !(flags & (1L<<1))) flags |= (1L<<23);
4275 call = !call;
4276 }
4277 else if ((flags & (1L<<23)) || c == (0401+0) || c == ((0500+4)+30)) call++;
4278 else flags |= (1L<<23);
4279 if (last == (0401+0)) flags |= (1L<<7);
4280 }
4281 c = (0401+0);
4282 flags |= (1L<<25);
4283 break;
4284 case (0401+1):
4285 if (*proto->tp >= '0' && *proto->tp <= '9')
4286 {
4287 n = 0;
4288 for (;; op--)
4289 {
4290 switch (*(op - 1))
4291 {
4292 case 'f':
4293 case 'F':
4294 t = op;
4295 while ((c = *--t) >= '0' && c <= '9' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z');
4296 if (*t == '.')
4297 op--;
4298 n = 0;
4299 break;
4300 case 'l':
4301 case 'L':
4302 if (!(n & 01))
4303 {
4304 n |= 01;
4305 t = op;
4306 while ((c = *--t) >= '0' && c <= '9' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z');
4307 if (*t == '.')
4308 {
4309 n = 0;
4310 op--;
4311 break;
4312 }
4313 }
4314 continue;
4315 case 'u':
4316 case 'U':
4317 n |= 02;
4318 continue;
4319 }
4320 break;
4321 }
4322 if (n & 01)
4323 *op++ = 'L';
4324 if (n & 02)
4325 {
4326 m = op;
4327 t = op = m + 10;
4328 while ((c = *--m) >= '0' && c <= '9' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z')
4329 *--t = c;
4330 c = *t;
4331 strcopy(m + 1, "(unsigned)");
4332 *t = c;
4333 break;
4334 }
4335 }
4336 goto fsm_other;
4337
4338 case '[':
4339 if ((flags & (1L<<0)) && paren == 0 && group <= 2) flags |= (1L<<23);
4340
4341
4342 default:
4343 fsm_other:
4344
4345 if (flags & (1L<<0)) break;
4346
4347 flags |= (1L<<25);
4348 if (paren == 0) flags |= (1L<<17);
4349 break;
4350 }
4351 else if (c == '#' && *ip != '(') flags |= (1L<<22);
4352 last = c;
4353
4354 if ((flags & ((1L<<5)|(1L<<15))) == ((1L<<5)|(1L<<15)) && ((flags & ((1L<<3)|(1L<<23))) || proto->brace || c != '(' && c != ')' && c != '*' && c != (0401+0)))
4355 (op=proto->op);
4356 else
4357
4358 (proto->op=op);
4359 goto fsm_start;
4360 }
4361 else if (flags & ((1L<<10)|(1L<<11)))
4362 {
4363
4364 if ((flags & (1L<<29)) && c == '%' && *ip == '{')
4365 t = 0;
4366 else
4367
4368 {
4369 if (c == '#')
4370 {
4371 for (t = ip; *t == ' ' || *t == '\t'; t++);
4372 if (*t++ == 'i' && *t++ == 'f' && *t++ == 'n' && *t++ == 'd' && *t++ == 'e' && *t++ == 'f')
4373 {
4374
4375
4376
4377
4378 t = 0;
4379 }
4380 }
4381 else
4382 t = "";
4383 }
4384 if (t)
4385 {
4386
4387 n = ip - proto->tp;
4388 ip -= n;
4389 op -= n;
4390
4391
4392
4393
4394 }
4395 else
4396 while (*ip != '\n')
4397 *op++ = *ip++;
4398 op = init(proto, op, flags);
4399 op = linesync(proto, op, proto->line);
4400 flags &= ~((1L<<10)|(1L<<11));
4401 proto->flags &= ~((1L<<10)|(1L<<11));
4402 goto fsm_start;
4403 }
4404 do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0);
4405 return c;
4406 }
4407
4408
4409
4410
4411
4412 void
__OTORP__(char * iob;)4413 pppclose __PARAM__((char* iob), (iob)) __OTORP__(char* iob;){
4414 register Proto_t* proto = (Proto_t*)(iob - sizeof(Proto_t));
4415
4416 if (proto->flags & (1L<<16)) close(proto->fd);
4417 free((char*)proto);
4418 }
4419
4420
4421 #line 2055
4422 char*
__OTORP__(char * file;int fd;char * notice;char * options;char * package;char * comment;int flags;)4423 pppopen __PARAM__((char* file, int fd, char* notice, char* options, char* package, char* comment, int flags), (file, fd, notice, options, package, comment, flags)) __OTORP__(char* file; int fd; char* notice; char* options; char* package; char* comment; int flags;){
4424 register Proto_t* proto;
4425 register char* iob;
4426 register long n;
4427 register char* s;
4428 char* t;
4429 int pragma;
4430 int clr;
4431 int hit;
4432 int i;
4433 int z;
4434 char* b;
4435
4436 int comlen;
4437 char com[80];
4438
4439 int m = 0;
4440
4441 static int retain;
4442
4443
4444
4445
4446
4447
4448 if (flags & (1<<0)) flags &= ~(1<<5);
4449
4450 if (flags & (1<<11)) flags &= ~retain;
4451 else retain &= (1<<6);
4452 if (file && (fd = open(file, O_RDONLY)) < 0) return 0;
4453
4454
4455
4456
4457
4458
4459
4460
4461
4462
4463
4464
4465
4466
4467
4468
4469
4470
4471
4472
4473
4474
4475 {
4476
4477
4478
4479
4480 n = (16*1024);
4481 if (!(proto = (( 0)?( Proto_t*)realloc((char*)( 0),sizeof( Proto_t)*( 1)+( 5 * n + 2)):( Proto_t*)calloc(1,sizeof( Proto_t)*( 1)+( 5 * n + 2)))))
4482 return 0;
4483 proto->iz = n;
4484 proto->oz = 3 * n;
4485 proto->flags |= (1L<<16);
4486 }
4487 proto->fd = fd;
4488 proto->package = package;
4489 iob = (char*)proto + sizeof(Proto_t);
4490 proto->op = proto->ob = iob;
4491 proto->ip = proto->ib = iob + proto->oz + n;
4492 if (m) proto->options |= (1L<<0);
4493 if (!comment)
4494 comment = "/*";
4495 if (!(proto->cc[0] = comment[0]))
4496 notice = options = 0;
4497 else if (comment[1])
4498 {
4499 proto->cc[1] = comment[1];
4500 proto->cc[2] = comment[2] ? comment[2] : comment[0];
4501 }
4502 else
4503 proto->cc[1] = proto->cc[2] = comment[0];
4504
4505
4506
4507
4508
4509 n = read(fd, proto->ip, proto->iz);
4510 if (!(proto->flags & (1L<<16)))
4511 close(fd);
4512 if (n < 0)
4513 {
4514 pppclose(iob);
4515 return 0;
4516 }
4517 *(proto->ip + n) = 0;
4518
4519
4520 #line 2165
4521 if (!notice && !options || (comlen = astlicense(com, sizeof(com), ((char*)0), "type=check", proto->cc[0], proto->cc[1], proto->cc[2])) <= 0)
4522 *com = 0;
4523
4524 hit = (notice || options) ? 0 : 0x02;
4525 pragma = -1;
4526 s = proto->ip;
4527 m = 80;
4528 while (m-- > 0 && *s && hit != (0x01|0x02))
4529 {
4530 while (*s == ' ' || *s == '\t')
4531 s++;
4532 if (*s == '#')
4533 {
4534 b = s++;
4535 while (*s == ' ' || *s == '\t')
4536 s++;
4537 if (*s == *"pragma"&& !sstrncmp( s, "pragma", sizeof("pragma") - 1) && (*(s += sizeof("pragma") - 1) == ' ' || *s == '\t'))
4538 {
4539 clr = 0;
4540 while (*s && *s != '\r' && *s != '\n')
4541 {
4542 for (; *s == ' ' || *s == '\t'; s++);
4543 for (t = s; *s && *s != ' ' && *s != '\t' && *s != '\r' && *s != '\n'; s++);
4544 z = s - t;
4545 for (i = 0; i < (sizeof( pragmas)/sizeof( pragmas[0])); i++)
4546 if (pragmas[i].size == z && !sstrncmp( t, pragmas[i].name, z))
4547 {
4548 clr = 1;
4549 hit |= pragmas[i].hit;
4550 switch (pragmas[i].hit)
4551 {
4552 case 0x02:
4553 notice = options = 0;
4554 break;
4555 case 0x01:
4556 pragma = pragmas[i].val;
4557 break;
4558 }
4559 }
4560 }
4561 if (clr)
4562 {
4563
4564 if (!(flags & (1<<1)) || (flags & (1<<8)))
4565
4566 for (; b < s; *b++ = ' ');
4567 }
4568 }
4569 }
4570 else if (*s == *"/* : : generated by proto : : */\n"&& !sstrncmp( s, "/* : : generated by proto : : */\n", sizeof("/* : : generated by proto : : */\n") - 1))
4571 {
4572 pragma = 0;
4573 break;
4574 }
4575
4576 else if (*s == '%' && *(s + 1) == '{')
4577 proto->flags |= (1L<<29);
4578 else if (!(hit & 0x02))
4579 {
4580 if (*s == *com && !sstrncmp( s, com, comlen))
4581 {
4582 hit |= 0x02;
4583 notice = options = 0;
4584 }
4585 else
4586 for (; *s && *s != '\n' && !(hit & 0x02); s++)
4587 for (i = 0; i < (sizeof( notices)/sizeof( notices[0])); i++)
4588 if (*s == notices[i].name[0] && !sstrncmp( s, notices[i].name, notices[i].size))
4589 {
4590 s += notices[i].size;
4591 if (notices[i].val)
4592 {
4593 while (*s == ' ' || *s == '\t')
4594 s++;
4595 if (*s == '(' && (*(s + 1) == 'c' || *(s + 1) == 'C') && *(s + 2) == ')' || *s >= '0' && *s <= '9' && *(s + 1) >= '0' && *(s + 1) <= '9')
4596 {
4597 hit |= notices[i].hit;
4598 notice = options = 0;
4599 }
4600 }
4601 else
4602 {
4603 hit |= notices[i].hit;
4604 notice = options = 0;
4605 }
4606 break;
4607 }
4608 }
4609
4610 while (*s && *s++ != '\n');
4611 }
4612 if (flags & (1<<10)) proto->flags |= (1L<<20);
4613 if (flags & (1<<12)) proto->test = 1;
4614 if (flags & (1<<2)) proto->options |= (1L<<6);
4615
4616 if (flags & (1<<0)) pragma = -pragma;
4617 if (flags & (1<<1)) pragma = 0;
4618 if (flags & (1<<7)) proto->flags |= (1L<<13);
4619 if (!(proto->flags & (1L<<29)) && file && (m = sstrlen( file)) > 2 && file[--m] == 'y' && file[--m] == '.')
4620 proto->flags |= (1L<<29);
4621
4622 if (pragma <= 0)
4623 {
4624 if (flags & (1<<10))
4625 {
4626 flags &= ~((1<<4)|(1<<5));
4627 proto->flags |= (1L<<19);
4628 }
4629 else if (!(flags & ((1<<3)|(1<<9))))
4630 {
4631 pppclose(iob);
4632 return 0;
4633 }
4634 else if ((flags & ((1<<3)|(1<<9))) == (1<<9) || !pragma)
4635 {
4636 proto->flags |= (1L<<18);
4637 if (proto->flags & (1L<<16))
4638 proto->oz += proto->iz;
4639 proto->iz = n;
4640 if (notice || options)
4641 {
4642 if (proto->cc[0] == '#' && proto->ip[0] == '#' && proto->ip[1] == '!')
4643 {
4644 s = proto->ip;
4645 while (*s && *s++ != '\n');
4646 m = s - proto->ip;
4647 proto->op = memcopy(proto->op, proto->ip, m);
4648 proto->ip = s;
4649 proto->iz = n -= m;
4650 }
4651
4652 if (proto->cc[0])
4653 {
4654 if ((comlen = astlicense(proto->op, proto->oz, notice, options, proto->cc[0], proto->cc[1], proto->cc[2])) < 0)
4655 proto_error((char*)proto + sizeof(Proto_t), 1, proto->op, ((char*)0));
4656 else
4657 proto->op += comlen;
4658 }
4659 if (!(flags & (1<<0)) && !(proto->flags & (1L<<29)))
4660
4661 proto->op = linesync(proto, proto->op, 1);
4662 proto->iz += proto->op - proto->ob;
4663 }
4664 memcopy(proto->op, proto->ip, n);
4665 return iob;
4666 }
4667 }
4668
4669 if (!(retain & (1<<6)))
4670 {
4671 retain |= (1<<6);
4672 ppfsm(4, ((char*)0));
4673 }
4674
4675 proto->line = 1;
4676
4677 if (notice || options || (flags & ((1<<4)|(1<<5))))
4678 {
4679
4680 if (notice || options)
4681 {
4682 if ((comlen = astlicense(proto->op, proto->oz, notice, options, proto->cc[0], proto->cc[1], proto->cc[2])) < 0)
4683 proto_error((char*)proto + sizeof(Proto_t), 1, proto->op, ((char*)0));
4684 else
4685 proto->op += comlen;
4686 }
4687
4688 if (flags & (1<<5))
4689 {
4690 proto->flags |= (1L<<11);
4691 if (flags & (1<<11))
4692 retain |= (1<<5);
4693 }
4694 else if (flags & (1<<4))
4695 {
4696 if (flags & (1<<11)) retain |= (1<<4);
4697
4698 if (flags & (1<<0))
4699 {
4700 *proto->op++ = '#';
4701 proto->op = strcopy(proto->op, "pragma");
4702 *proto->op++ = ' ';
4703 proto->op = strcopy(proto->op, pragmas[0].name);
4704 *proto->op++ = '\n';
4705 }
4706 else
4707
4708 proto->flags |= (1L<<10);
4709 }
4710
4711 if (!(flags & (1<<0)))
4712 {
4713 if (proto->flags & (1L<<29))
4714 {
4715 proto->op = strcopy(proto->op, "\n%{\n"+ !notice);
4716 proto->op = strcopy(proto->op, "/* : : generated by proto : : */\n");
4717 proto->op = strcopy(proto->op, "%}\n");
4718 }
4719 else
4720 {
4721 if (n || notice || options)
4722 *proto->op++ = '\n';
4723 proto->op = strcopy(proto->op, "/* : : generated by proto : : */\n");
4724 if (n)
4725 proto->op = linesync(proto, proto->op, proto->line);
4726 else if (proto->flags & ((1L<<10)|(1L<<11)))
4727 proto->op = init(proto, proto->op, proto->flags);
4728 }
4729 }
4730
4731 }
4732
4733
4734 proto->file = file;
4735 if (flags & (1<<0))
4736 {
4737 proto->flags |= (1L<<0);
4738 if (!(flags & (1<<4))) proto->flags |= (1L<<5);
4739 }
4740
4741 return iob;
4742 }
4743
4744
4745
4746
4747
4748
4749 int
__OTORP__(char * iob;)4750 pppread __PARAM__((char* iob), (iob)) __OTORP__(char* iob;){
4751 register Proto_t* proto = (Proto_t*)(iob - sizeof(Proto_t));
4752 register int n;
4753
4754 if (proto->flags & (1L<<18))
4755 {
4756 if (proto->iz)
4757 {
4758 n = proto->iz;
4759 proto->iz = 0;
4760 }
4761 else if (!(proto->flags & (1L<<16))) n = 0;
4762 else if ((n = read(proto->fd, proto->ob, proto->oz)) <= 0 || (proto->options & (1L<<0)) && n < proto->oz)
4763 {
4764 proto->flags &= ~(1L<<16);
4765 close(proto->fd);
4766 }
4767 }
4768 else
4769 {
4770 if (proto->op == proto->ob)
4771 {
4772 if (proto->flags & (1L<<4)) return -1;
4773
4774 if (proto->flags & (1L<<29))
4775 {
4776 register char* ip = proto->ip;
4777 register char* op = proto->ob;
4778 register char* ep = proto->ob + proto->oz - 2;
4779
4780 if (!*ip)
4781 {
4782 ip = proto->ip = proto->ib;
4783 if (!(proto->flags & (1L<<16))) n = 0;
4784 else if ((n = read(proto->fd, ip, proto->iz)) <= 0 || (proto->options & (1L<<0)) && n < proto->iz)
4785 {
4786 if (n < 0) n = 0;
4787 proto->flags &= ~(1L<<16);
4788 close(proto->fd);
4789 }
4790 ip[n] = 0;
4791 }
4792 if (proto->flags & (1L<<30))
4793 {
4794 proto->flags &= ~(1L<<30);
4795 if (*ip == '%')
4796 {
4797 *op++ = *ip++;
4798 if (proto->flags & (1L<<31)) proto->flags &= ~(1L<<29);
4799 else proto->flags |= (1L<<31);
4800 }
4801 }
4802 if (proto->flags & (1L<<29))
4803 while (op < ep && (n = *op++ = *ip))
4804 {
4805 ip++;
4806 if (n == '%')
4807 {
4808 if (*ip == '%' && (ip == proto->ip + 1 || *(ip - 2) == '\n'))
4809 {
4810 *op++ = *ip++;
4811 if (proto->flags & (1L<<31)) proto->flags &= ~(1L<<29);
4812 else proto->flags |= (1L<<31);
4813 break;
4814 }
4815 if (!*ip)
4816 {
4817 *op++ = '%';
4818 proto->flags |= (1L<<30);
4819 break;
4820 }
4821 }
4822 else if (n == '\n') proto->line++;
4823 }
4824 proto->op = memcopy(proto->ob, proto->ip, ip - proto->ip);
4825 proto->ip = ip;
4826 }
4827 else
4828
4829 lex(proto, proto->flags);
4830 if ((proto->flags & ((1L<<4)|(1L<<16))) == (1L<<4))
4831 proto->op = strcopy(proto->op, "/* NOTE: some constructs may not have been converted */\n");
4832 }
4833 n = proto->op - proto->ob;
4834 proto->op = proto->ob;
4835 }
4836 return n;
4837 }
4838
4839
4840
4841
4842
4843
4844
4845
4846
4847
4848
4849
4850 #line 269 "proto.c"
4851
4852
4853
4854
4855
4856 static int
__OTORP__(char * file;char * license;char * options;char * package;char * copy;char * comment;int flags;)4857 proto __PARAM__((char* file, char* license, char* options, char* package, char* copy, char* comment, int flags), (file, license, options, package, copy, comment, flags)) __OTORP__(char* file; char* license; char* options; char* package; char* copy; char* comment; int flags;){
4858 char* b;
4859 char* e;
4860 char* p;
4861 int n;
4862 int m;
4863 int x;
4864 int fd;
4865 char buf[1024];
4866
4867 if (file && access(file, 4))
4868 proto_error(((char*)0), 2, file, "not found");
4869 else if (b = pppopen(file, 0, license, options, package, comment, flags))
4870 {
4871 if (!file)
4872 fd = 1;
4873 else if (flags & ((1<<13)<<1))
4874 {
4875 e = file + sstrlen( file) - 1;
4876 x = *e;
4877 *e = '_';
4878 if ((fd = creat(file, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
4879 {
4880 proto_error(b, 2, file, "cannot create temporary file");
4881 pppclose(b);
4882 return flags | ((1<<13)<<0);
4883 }
4884 *e = x;
4885 }
4886 else if (copy)
4887 {
4888 if (((n = sstrlen( copy)) + sstrlen( file) + 2) > sizeof(buf))
4889 {
4890 proto_error(b, 2, copy, "copy path too long");
4891 pppclose(b);
4892 return flags | ((1<<13)<<0);
4893 }
4894 strcopy( buf, copy);
4895 e = buf + n;
4896 if (*file != '/')
4897 *e++ = '/';
4898 strcopy( e, file);
4899 if ((fd = creat(buf, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
4900 {
4901 for (e = buf; *e == '/'; e++);
4902 do
4903 {
4904 if (*e == '/')
4905 {
4906 *e = 0;
4907 if (access(buf, 0) && mkdir(buf, S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH))
4908 {
4909 proto_error(b, 2, buf, "cannot create copy directory");
4910 pppclose(b);
4911 return flags | ((1<<13)<<0);
4912 }
4913 *e = '/';
4914 }
4915 } while (*e++);
4916 if ((fd = creat(buf, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
4917 {
4918 proto_error(b, 2, buf, "cannot create copy file");
4919 pppclose(b);
4920 return flags | ((1<<13)<<0);
4921 }
4922 }
4923 file = buf;
4924 }
4925 else
4926 fd = 1;
4927 if (file && (flags & ((1<<13)<<2)))
4928 proto_error(b, 0, "convert to", file);
4929 while ((n = pppread(b)) > 0)
4930 {
4931 p = b;
4932 for (;;)
4933 {
4934 if ((m = write(fd, p, n)) <= 0)
4935 {
4936 proto_error(b, 2, "write error", ((char*)0));
4937 flags |= ((1<<13)<<0);
4938 break;
4939 }
4940 if ((n -= m) <= 0)
4941 break;
4942 p += m;
4943 }
4944 if (m < 0)
4945 break;
4946 }
4947 if (fd > 1)
4948 close(fd);
4949 if (file && (flags & ((1<<13)<<1)))
4950 {
4951 *e = '_';
4952 strcopy( b, file);
4953 *e = x;
4954 if (replace(b, file, !(flags & (1<<0))))
4955 proto_error(b, 2, "cannot rename to", file);
4956 }
4957 pppclose(b);
4958 }
4959 return flags;
4960 }
4961
4962
4963
4964
4965
4966 typedef struct Sufcom_s
4967 {
4968 char suffix[4];
4969 char comment[4];
4970 } Sufcom_t;
4971
4972 static const Sufcom_t sufcom[] =
4973 {
4974 "c", "/*",
4975 "cpp", "/*",
4976 "cxx", "/*",
4977 "c++", "/*",
4978 "C", "/*",
4979 "CPP", "/*",
4980 "CXX", "/*",
4981 "C++", "/*",
4982 "f", "C",
4983 "F", "C",
4984 "h", "/*",
4985 "hpp", "/*",
4986 "hxx", "/*",
4987 "H", "/*",
4988 "HPP", "/*",
4989 "HXX", "/*",
4990 "ksh", "#",
4991 "KSH", "#",
4992 "l", "/*",
4993 "L", "/*",
4994 "p", "(*)",
4995 "pas", "(*)",
4996 "P", "(*)",
4997 "PAS", "(*)",
4998 "pl", "#",
4999 "PL", "#",
5000 "pl1", "/*",
5001 "pli", "/*",
5002 "PL1", "/*",
5003 "PLI", "/*",
5004 "sh", "#",
5005 "SH", "#",
5006 "sml", "(*)",
5007 "SML", "(*)",
5008 "y", "/*",
5009 "Y", "/*",
5010 };
5011
5012
5013
5014
5015
5016 static char*
__OTORP__(register char * file;char * comment;)5017 type __PARAM__((register char* file, char* comment), (file, comment)) __OTORP__(register char* file; char* comment;){
5018 register char* suffix;
5019 register int i;
5020
5021 if (file && (!comment || !*comment))
5022 {
5023 suffix = 0;
5024 while (*file)
5025 if (*file++ == '.')
5026 suffix = file;
5027 if (suffix && sstrlen( suffix) <= 3)
5028 for (i = 0; i < sizeof(sufcom) / sizeof(sufcom[0]); i++)
5029 if (!strcmp(suffix, sufcom[i].suffix))
5030 return (char*)sufcom[i].comment;
5031 }
5032 return comment;
5033 }
5034
5035 int
__OTORP__(int argc;char ** argv;)5036 main __PARAM__((int argc, char** argv), (argc, argv)) __OTORP__(int argc; char** argv;){
5037 char* b;
5038 char* file;
5039 int fd;
5040 int n;
5041 char* op;
5042 char* oe;
5043 char* comment = 0;
5044 char* copy = 0;
5045 char* list = 0;
5046 char* license = 0;
5047 char* options = 0;
5048 char* package = 0;
5049 int flags = (1<<4);
5050 char buf[1024];
5051 char opt[4 * 1024];
5052
5053 ;
5054
5055 while ((file = *++argv) && *file == '-' && *(file + 1))
5056 {
5057 for (;;)
5058 {
5059 switch (*++file)
5060 {
5061 case 0:
5062 break;
5063 case 'c':
5064 if (!*(comment = ++file))
5065 comment = *++argv;
5066 break;
5067 case 'd':
5068 flags |= (1<<1);
5069 continue;
5070 case 'e':
5071 if (!*(package = ++file) && !(package = *++argv))
5072 {
5073 file = "??";
5074 continue;
5075 }
5076 break;
5077 case 'f':
5078 flags |= (1<<3);
5079 continue;
5080 case 'h':
5081 flags &= ~(1<<4);
5082 continue;
5083 case 'i':
5084 flags |= (1<<0);
5085 continue;
5086 case 'l':
5087 if (!*(license = ++file) && !(license = *++argv))
5088 {
5089 file = "??";
5090 continue;
5091 }
5092 break;
5093 case 'n':
5094 flags |= (1<<7);
5095 continue;
5096 case 'o':
5097 if (!*(b = ++file) && !(b = *++argv))
5098 {
5099 file = "??";
5100 continue;
5101 }
5102 if (!options)
5103 {
5104 options = op = opt;
5105 oe = op + sizeof(opt) - 1;
5106 }
5107 n = sstrlen( b);
5108 if ((n + 1) >= (oe - op))
5109 proto_error(((char*)0), 3, b, "too many options");
5110 else
5111 {
5112 *op++ = '\n';
5113 memcopy( op, b, n + 1);
5114 op += n;
5115 }
5116 break;
5117 case 'p':
5118 flags |= (1<<9);
5119 continue;
5120 case 'r':
5121 flags |= ((1<<13)<<1);
5122 continue;
5123 case 's':
5124 flags |= (1<<5);
5125 continue;
5126 case 't':
5127 flags |= (1<<12);
5128 continue;
5129 case 'v':
5130 flags |= ((1<<13)<<2);
5131 continue;
5132 case 'x':
5133 flags |= (1<<2);
5134 continue;
5135 case 'z':
5136 flags |= (1<<1)|(1<<8);
5137 continue;
5138 case 'C':
5139 if (!*(copy = ++file) && !(copy = *++argv))
5140 {
5141 file = "??";
5142 continue;
5143 }
5144 break;
5145 case 'L':
5146 if (!*(list = ++file) && !(list = *++argv))
5147 {
5148 file = "??";
5149 continue;
5150 }
5151 break;
5152 case 'P':
5153 case '+':
5154 flags |= (1<<10);
5155 continue;
5156 case 'S':
5157 comment = "#";
5158 continue;
5159 default:
5160 proto_error(((char*)0), 2, file, "unknown option");
5161
5162 case '?':
5163 b = "Usage: proto [-dfhinprstvzP+S] [-C directory] [-e package] [-l file]\n [-o \"name='value' ...\"] [-L file] file ...\n";
5164 write(2, b, sstrlen( b));
5165 return 2;
5166 }
5167 break;
5168 }
5169 }
5170
5171
5172
5173
5174
5175
5176
5177
5178
5179
5180
5181
5182
5183
5184
5185
5186
5187
5188
5189
5190
5191
5192
5193
5194
5195
5196
5197
5198
5199
5200
5201
5202
5203
5204
5205
5206
5207
5208
5209
5210
5211
5212
5213
5214
5215
5216
5217
5218
5219
5220
5221
5222
5223
5224
5225
5226
5227
5228
5229
5230
5231
5232
5233
5234
5235
5236
5237
5238
5239
5240
5241
5242
5243
5244
5245
5246
5247
5248
5249
5250
5251
5252
5253
5254
5255
5256
5257
5258
5259
5260
5261
5262
5263 if (list)
5264 {
5265 if (*list == '-' && !*(list + 1))
5266 fd = 0;
5267 else if ((fd = open(list, O_RDONLY)) < 0)
5268 proto_error(((char*)0), 3, list, "not found");
5269 do
5270 {
5271 for (b = buf; (n = read(fd, b, 1)) > 0 && *b != '\n' && b < &buf[sizeof(buf) - 1]; b++);
5272 if (b > buf)
5273 {
5274 *b = 0;
5275 flags = proto(buf, license, options, package, copy, type(buf, comment), flags);
5276 }
5277 } while (n > 0);
5278 if (fd > 0)
5279 close(fd);
5280 }
5281 if (file)
5282 do flags = proto(file, license, options, package, copy, type(file, comment), flags); while (file = *++argv);
5283 else if (!list)
5284 flags = proto(file, license, options, package, copy, type(file, comment), flags);
5285 return errors ? 1 : (flags & ((1<<13)<<0)) ? 2 : 0;
5286 }
5287