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 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 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* 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 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 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* 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 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* 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 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 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 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 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 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 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 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* 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* 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* 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 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 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 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* 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 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 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* 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 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