1 /*********************************************************************** 2 * * 3 * This software is part of the ast package * 4 * Copyright (c) 1986-2009 AT&T Intellectual Property * 5 * and is licensed under the * 6 * Common Public License, Version 1.0 * 7 * by AT&T Intellectual Property * 8 * * 9 * A copy of the License is available at * 10 * http://www.opensource.org/licenses/cpl1.0.txt * 11 * (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) * 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 #pragma prototyped 21 /* 22 * Glenn Fowler 23 * AT&T Research 24 * 25 * preprocessor stacked input stream support 26 */ 27 28 #include "pplib.h" 29 30 31 /* 32 * convert path to native representation 33 */ 34 35 #if 0 36 #include "../../lib/libast/path/pathnative.c" /* drop in 2002 */ 37 #else 38 /* Modified by gisburn 2006-08-18 for OpenSolaris ksh93-integration */ 39 #include "../../libast/common/path/pathnative.c" 40 #endif 41 42 static char* 43 native(register const char* s) 44 { 45 register int c; 46 register struct ppfile* xp; 47 int m; 48 int n; 49 50 static Sfio_t* np; 51 static Sfio_t* qp; 52 53 if (!s) 54 return 0; 55 if (!np && !(np = sfstropen()) || !qp && !(qp = sfstropen())) 56 return (char*)s; 57 n = PATH_MAX; 58 do 59 { 60 m = n; 61 n = pathnative(s, sfstrrsrv(np, m), m); 62 } while (n > m); 63 sfstrseek(np, n, SEEK_CUR); 64 s = (const char*)sfstruse(np); 65 for (;;) 66 { 67 switch (c = *s++) 68 { 69 case 0: 70 break; 71 case '\\': 72 case '"': 73 sfputc(qp, '\\'); 74 /*FALLTHROUGH*/ 75 default: 76 sfputc(qp, c); 77 continue; 78 } 79 break; 80 } 81 if (!(xp = ppsetfile(sfstruse(qp)))) 82 return (char*)s; 83 return xp->name; 84 } 85 86 /* 87 * push stream onto input stack 88 * used by the PUSH_type macros 89 */ 90 91 void 92 pppush(register int t, register char* s, register char* p, int n) 93 { 94 register struct ppinstk* cur; 95 96 PUSH(t, cur); 97 cur->line = error_info.line; 98 cur->file = error_info.file; 99 switch (t) 100 { 101 case IN_FILE: 102 if (pp.option & NATIVE) 103 s = native(s); 104 cur->flags |= IN_newline; 105 cur->fd = n; 106 cur->hide = ++pp.hide; 107 cur->symbol = 0; 108 #if CHECKPOINT 109 if ((pp.mode & (DUMP|INIT)) == DUMP) 110 { 111 cur->index = newof(0, struct ppindex, 1, 0); 112 if (pp.lastindex) pp.lastindex->next = cur->index; 113 else pp.firstindex = cur->index; 114 pp.lastindex = cur->index; 115 cur->index->file = pp.original; 116 cur->index->begin = ppoffset(); 117 } 118 #endif 119 n = 1; 120 #if CHECKPOINT 121 if (!(pp.mode & DUMP)) 122 #endif 123 if (!cur->prev->prev && !(pp.state & COMPILE) && isatty(0)) 124 cur->flags |= IN_flush; 125 #if ARCHIVE 126 if (pp.member) 127 { 128 switch (pp.member->archive->type & (TYPE_BUFFER|TYPE_CHECKPOINT)) 129 { 130 case 0: 131 #if CHECKPOINT 132 cur->buflen = pp.member->size; 133 #endif 134 p = (cur->buffer = oldof(0, char, 0, pp.member->size + PPBAKSIZ + 1)) + PPBAKSIZ; 135 if (sfseek(pp.member->archive->info.sp, pp.member->offset, SEEK_SET) != pp.member->offset) 136 error(3, "%s: archive seek error", pp.member->archive->name); 137 if (sfread(pp.member->archive->info.sp, p, pp.member->size) != pp.member->size) 138 error(3, "%s: archive read error", pp.member->archive->name); 139 pp.member = 0; 140 break; 141 case TYPE_BUFFER: 142 #if CHECKPOINT 143 case TYPE_CHECKPOINT|TYPE_BUFFER: 144 cur->buflen = pp.member->size; 145 #endif 146 p = cur->buffer = pp.member->archive->info.buffer + pp.member->offset; 147 cur->flags |= IN_static; 148 pp.member = 0; 149 break; 150 #if CHECKPOINT 151 case TYPE_CHECKPOINT: 152 p = cur->buffer = ""; 153 cur->flags |= IN_static; 154 break; 155 #endif 156 } 157 cur->flags |= IN_eof|IN_newline; 158 cur->fd = -1; 159 } 160 else 161 #endif 162 { 163 if (lseek(cur->fd, 0L, SEEK_END) > 0 && !lseek(cur->fd, 0L, SEEK_SET)) 164 cur->flags |= IN_regular; 165 errno = 0; 166 #if PROTOTYPE 167 if (!(pp.option & NOPROTO) && !(pp.test & TEST_noproto) && ((pp.state & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY || (pp.option & PLUSPLUS) || (pp.mode & EXTERNALIZE)) && (cur->buffer = pppopen(NiL, cur->fd, NiL, NiL, NiL, NiL, (PROTO_HEADER|PROTO_RETAIN)|(((pp.mode & EXTERNALIZE) || (pp.option & PROTOTYPED)) ? PROTO_FORCE : PROTO_PASS)|((pp.mode & EXTERNALIZE) ? PROTO_EXTERNALIZE : 0)|((pp.mode & MARKC) ? PROTO_PLUSPLUS : 0)))) 168 { 169 *(p = cur->buffer - 1) = 0; 170 cur->buffer -= PPBAKSIZ; 171 cur->flags |= IN_prototype; 172 cur->fd = -1; 173 } 174 else 175 #endif 176 *(p = (cur->buffer = oldof(0, char, 0, PPBUFSIZ + PPBAKSIZ + 1)) + PPBAKSIZ) = 0; 177 } 178 if (pp.incref && !(pp.mode & INIT)) 179 (*pp.incref)(error_info.file, s, error_info.line - 1, PP_SYNC_PUSH); 180 if (pp.macref || (pp.option & IGNORELINE)) 181 cur->flags |= IN_ignoreline; 182 cur->prefix = pp.prefix; 183 /*FALLTHROUGH*/ 184 case IN_BUFFER: 185 case IN_INIT: 186 case IN_RESCAN: 187 pushcontrol(); 188 cur->control = pp.control; 189 *pp.control = 0; 190 cur->vendor = pp.vendor; 191 if (cur->type != IN_RESCAN) 192 { 193 if (cur->type == IN_INIT) 194 pp.mode |= MARKHOSTED; 195 error_info.file = s; 196 error_info.line = n; 197 } 198 if (pp.state & HIDDEN) 199 { 200 pp.state &= ~HIDDEN; 201 pp.hidden = 0; 202 if (!(pp.state & NOTEXT) && pplastout() != '\n') 203 ppputchar('\n'); 204 } 205 pp.state |= NEWLINE; 206 if (pp.mode & HOSTED) cur->flags |= IN_hosted; 207 else cur->flags &= ~IN_hosted; 208 if (pp.mode & (INIT|MARKHOSTED)) 209 { 210 pp.mode |= HOSTED; 211 pp.flags |= PP_hosted; 212 } 213 switch (cur->type) 214 { 215 case IN_FILE: 216 if (!(pp.mode & (INIT|MARKHOSTED))) 217 { 218 pp.mode &= ~HOSTED; 219 pp.flags &= ~PP_hosted; 220 } 221 #if CATSTRINGS 222 if (pp.state & JOINING) pp.state |= HIDDEN|SYNCLINE; 223 else 224 #endif 225 if (pp.linesync) 226 (*pp.linesync)(error_info.line, error_info.file); 227 #if ARCHIVE && CHECKPOINT 228 if (pp.member) 229 ppload(NiL); 230 #endif 231 if (pp.mode & MARKC) 232 { 233 cur->flags |= IN_c; 234 pp.mode &= ~MARKC; 235 if (!(cur->prev->flags & IN_c)) 236 { 237 debug((-7, "PUSH in=%s next=%s [%s]", ppinstr(pp.in), pptokchr(*pp.in->nextchr), pp.in->nextchr)); 238 PUSH_BUFFER("C", "extern \"C\" {\n", 1); 239 return; 240 } 241 } 242 else if (cur->prev->flags & IN_c) 243 { 244 debug((-7, "PUSH in=%s next=%s [%s]", ppinstr(pp.in), pptokchr(*pp.in->nextchr), pp.in->nextchr)); 245 PUSH_BUFFER("C", "extern \"C++\" {\n", 1); 246 return; 247 } 248 break; 249 case IN_BUFFER: 250 cur->buffer = p = strdup(p); 251 break; 252 default: 253 cur->buffer = p; 254 break; 255 } 256 cur->nextchr = p; 257 break; 258 #if DEBUG 259 default: 260 error(PANIC, "use PUSH_<%d>(...) instead of pppush(IN_<%d>, ...)", cur->type, cur->type); 261 break; 262 #endif 263 } 264 debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); 265 } 266 267 /* 268 * external buffer push 269 */ 270 271 void 272 ppinput(char* b, char* f, int n) 273 { 274 PUSH_BUFFER(f, b, n); 275 } 276 277 /* 278 * return expanded value of buffer p 279 */ 280 281 char* 282 ppexpand(register char* p) 283 { 284 register char* m; 285 register int n; 286 register int c; 287 long restore; 288 char* pptoken; 289 char* ppmactop; 290 struct ppmacstk* nextmacp; 291 struct ppinstk* cur; 292 293 debug((-7, "before expand: %s", p)); 294 if (ppmactop = pp.mactop) 295 { 296 nextmacp = pp.macp->next; 297 nextframe(pp.macp, pp.mactop); 298 } 299 restore = pp.state & (COLLECTING|DISABLE|STRIP); 300 pp.state &= ~restore; 301 pp.mode &= ~MARKMACRO; 302 PUSH_STRING(p); 303 cur = pp.in; 304 pp.in->flags |= IN_expand; 305 pptoken = pp.token; 306 n = 2 * MAXTOKEN; 307 pp.token = p = oldof(0, char, 0, n); 308 m = p + MAXTOKEN; 309 for (;;) 310 { 311 if (pplex()) 312 { 313 if ((pp.token = pp.toknxt) > m) 314 { 315 c = pp.token - p; 316 p = newof(p, char, n += MAXTOKEN, 0); 317 m = p + n - MAXTOKEN; 318 pp.token = p + c; 319 } 320 if (pp.mode & MARKMACRO) 321 { 322 pp.mode &= ~MARKMACRO; 323 *pp.token++ = MARK; 324 *pp.token++ = 'X'; 325 } 326 } 327 else if (pp.in == cur) 328 break; 329 } 330 *pp.token = 0; 331 if (ppmactop) 332 pp.macp->next = nextmacp; 333 debug((-7, "after expand: %s", p)); 334 pp.token = pptoken; 335 pp.state |= restore; 336 pp.in = pp.in->prev; 337 return p; 338 } 339 340 #if CHECKPOINT 341 342 #define LOAD_FUNCTION (1<<0) 343 #define LOAD_MULTILINE (1<<1) 344 #define LOAD_NOEXPAND (1<<2) 345 #define LOAD_PREDICATE (1<<3) 346 #define LOAD_READONLY (1<<4) 347 #define LOAD_VARIADIC (1<<5) 348 349 /* 350 * macro definition dump 351 */ 352 353 static int 354 dump(const char* name, char* v, void* handle) 355 { 356 register struct ppmacro* mac; 357 register struct ppsymbol* sym = (struct ppsymbol*)v; 358 register int flags; 359 360 NoP(name); 361 NoP(handle); 362 if ((mac = sym->macro) && !(sym->flags & (SYM_BUILTIN|SYM_PREDEFINED))) 363 { 364 ppprintf("%s", sym->name); 365 ppputchar(0); 366 flags = 0; 367 if (sym->flags & SYM_FUNCTION) flags |= LOAD_FUNCTION; 368 if (sym->flags & SYM_MULTILINE) flags |= LOAD_MULTILINE; 369 if (sym->flags & SYM_NOEXPAND) flags |= LOAD_NOEXPAND; 370 if (sym->flags & SYM_PREDICATE) flags |= LOAD_PREDICATE; 371 if (sym->flags & SYM_READONLY) flags |= LOAD_READONLY; 372 if (sym->flags & SYM_VARIADIC) flags |= LOAD_VARIADIC; 373 ppputchar(flags); 374 if (sym->flags & SYM_FUNCTION) 375 { 376 ppprintf("%d", mac->arity); 377 ppputchar(0); 378 if (mac->arity) 379 { 380 ppprintf("%s", mac->formals); 381 ppputchar(0); 382 } 383 } 384 ppprintf("%s", mac->value); 385 ppputchar(0); 386 } 387 return(0); 388 } 389 390 /* 391 * dump macro definitions for quick loading via ppload() 392 */ 393 394 void 395 ppdump(void) 396 { 397 register struct ppindex* ip; 398 unsigned long macro_offset; 399 unsigned long index_offset; 400 401 /* 402 * NOTE: we assume '\0' does not occur in valid preprocessed output 403 */ 404 405 ppputchar(0); 406 407 /* 408 * output global flags 409 */ 410 411 macro_offset = ppoffset(); 412 ppputchar(0); 413 414 /* 415 * output macro definitions 416 */ 417 418 hashwalk(pp.symtab, 0, dump, NiL); 419 ppputchar(0); 420 421 /* 422 * output include file index 423 */ 424 425 index_offset = ppoffset(); 426 ip = pp.firstindex; 427 while (ip) 428 { 429 ppprintf("%s", ip->file->name); 430 ppputchar(0); 431 if (ip->file->guard != INC_CLEAR && ip->file->guard != INC_IGNORE && ip->file->guard != INC_TEST) 432 ppprintf("%s", ip->file->guard->name); 433 ppputchar(0); 434 ppprintf("%lu", ip->begin); 435 ppputchar(0); 436 ppprintf("%lu", ip->end); 437 ppputchar(0); 438 ip = ip->next; 439 } 440 ppputchar(0); 441 442 /* 443 * output offset directory 444 */ 445 446 ppprintf("%010lu", macro_offset); 447 ppputchar(0); 448 ppprintf("%010lu", index_offset); 449 ppputchar(0); 450 ppflushout(); 451 } 452 453 /* 454 * load text and macro definitions from a previous ppdump() 455 * s is the string argument from the pragma (including quotes) 456 */ 457 458 void 459 ppload(register char* s) 460 { 461 register char* b; 462 register Sfio_t* sp; 463 int m; 464 char* g; 465 char* t; 466 unsigned long n; 467 unsigned long p; 468 unsigned long macro_offset; 469 unsigned long index_offset; 470 unsigned long file_offset; 471 unsigned long file_size; 472 unsigned long keep_begin; 473 unsigned long keep_end; 474 unsigned long skip_end; 475 unsigned long next_begin; 476 unsigned long next_end; 477 struct ppfile* fp; 478 struct ppsymbol* sym; 479 struct ppmacro* mac; 480 481 char* ip = 0; 482 483 pp.mode |= LOADING; 484 if (!(pp.state & STANDALONE)) 485 error(3, "checkpoint load in standalone mode only"); 486 #if ARCHIVE 487 if (pp.member) 488 { 489 sp = pp.member->archive->info.sp; 490 file_offset = pp.member->offset; 491 file_size = pp.member->size; 492 if (sfseek(sp, file_offset + 22, SEEK_SET) != file_offset + 22 || !(s = sfgetr(sp, '\n', 1))) 493 error(3, "checkpoint magic error"); 494 } 495 else 496 #endif 497 { 498 if (pp.in->type != IN_FILE) 499 error(3, "checkpoint load from files only"); 500 if (pp.in->flags & IN_prototype) 501 pp.in->fd = pppdrop(pp.in->buffer + PPBAKSIZ); 502 file_offset = 0; 503 if (pp.in->fd >= 0) 504 { 505 if (!(sp = sfnew(NiL, NiL, SF_UNBOUND, pp.in->fd, SF_READ))) 506 error(3, "checkpoint read error"); 507 file_size = sfseek(sp, 0L, SEEK_END); 508 } 509 else 510 { 511 file_size = pp.in->buflen; 512 if (!(sp = sfnew(NiL, pp.in->buffer + ((pp.in->flags & IN_static) ? 0 : PPBAKSIZ), file_size, -1, SF_READ|SF_STRING))) 513 error(3, "checkpoint read error"); 514 } 515 } 516 if (!streq(s, pp.checkpoint)) 517 error(3, "checkpoint version %s does not match %s", s, pp.checkpoint); 518 519 /* 520 * get the macro and index offsets 521 */ 522 523 p = file_offset + file_size - 22; 524 if ((n = sfseek(sp, p, SEEK_SET)) != p) 525 error(3, "checkpoint directory seek error"); 526 if (!(t = sfreserve(sp, 22, 0))) 527 error(3, "checkpoint directory read error"); 528 macro_offset = file_offset + strtol(t, &t, 10); 529 index_offset = file_offset + strtol(t + 1, NiL, 10); 530 531 /* 532 * read the include index 533 */ 534 535 if (sfseek(sp, index_offset, SEEK_SET) != index_offset) 536 error(3, "checkpoint index seek error"); 537 if (!(s = sfreserve(sp, n - index_offset, 0))) 538 error(3, "checkpoint index read error"); 539 if (sfset(sp, 0, 0) & SF_STRING) 540 b = s; 541 else if (!(b = ip = memdup(s, n - index_offset))) 542 error(3, "checkpoint index alloc error"); 543 544 /* 545 * loop on the index and copy the non-ignored chunks to the output 546 */ 547 548 ppcheckout(); 549 p = PPBUFSIZ - (pp.outp - pp.outbuf); 550 keep_begin = 0; 551 keep_end = 0; 552 skip_end = 0; 553 while (*b) 554 { 555 fp = ppsetfile(b); 556 while (*b++); 557 g = b; 558 while (*b++); 559 next_begin = strtol(b, &t, 10); 560 next_end = strtol(t + 1, &t, 10); 561 if (pp.test & 0x0200) error(2, "%s: %s p=%lu next=<%lu,%lu> keep=<%lu,%lu> skip=<-,%lu> guard=%s", keyname(X_CHECKPOINT), fp->name, p, next_begin, next_end, keep_begin, keep_end, skip_end, fp->guard == INC_CLEAR ? "[CLEAR]" : fp->guard == INC_TEST ? "[TEST]" : fp->guard == INC_IGNORE ? "[IGNORE]" : fp->guard->name); 562 b = t + 1; 563 if (next_begin >= skip_end) 564 { 565 if (!ppmultiple(fp, INC_TEST)) 566 { 567 if (pp.test & 0x0100) error(2, "%s: %s IGNORE", keyname(X_CHECKPOINT), fp->name); 568 if (!keep_begin && skip_end < next_begin) 569 keep_begin = skip_end; 570 if (keep_begin) 571 { 572 flush: 573 if (sfseek(sp, file_offset + keep_begin, SEEK_SET) != file_offset + keep_begin) 574 error(3, "checkpoint data seek error"); 575 n = next_begin - keep_begin; 576 if (pp.test & 0x0100) error(2, "%s: copy <%lu,%lu> n=%lu p=%lu", keyname(X_CHECKPOINT), keep_begin, next_begin - 1, n, p); 577 while (n > p) 578 { 579 if (sfread(sp, pp.outp, p) != p) 580 error(3, "checkpoint data read error"); 581 PPWRITE(PPBUFSIZ); 582 pp.outp = pp.outbuf; 583 n -= p; 584 p = PPBUFSIZ; 585 } 586 if (n) 587 { 588 if (sfread(sp, pp.outp, n) != n) 589 error(3, "checkpoint data read error"); 590 pp.outp += n; 591 p -= n; 592 } 593 keep_begin = 0; 594 if (keep_end <= next_end) 595 keep_end = 0; 596 } 597 skip_end = next_end; 598 } 599 else if (!keep_begin) 600 { 601 if (skip_end) 602 { 603 keep_begin = skip_end; 604 skip_end = 0; 605 } 606 else keep_begin = next_begin; 607 if (keep_end < next_end) 608 keep_end = next_end; 609 } 610 } 611 if (*g && fp->guard != INC_IGNORE) 612 fp->guard = ppsymset(pp.symtab, g); 613 } 614 if (keep_end) 615 { 616 if (!keep_begin) 617 keep_begin = skip_end > next_end ? skip_end : next_end; 618 next_begin = next_end = keep_end; 619 g = b; 620 goto flush; 621 } 622 if (pp.test & 0x0100) error(2, "%s: loop", keyname(X_CHECKPOINT)); 623 624 /* 625 * read the compacted definitions 626 */ 627 628 if (sfseek(sp, macro_offset, SEEK_SET) != macro_offset) 629 error(3, "checkpoint macro seek error"); 630 if (!(s = sfreserve(sp, index_offset - macro_offset, 0))) 631 error(3, "checkpoint macro read error"); 632 633 /* 634 * read the flags 635 */ 636 637 while (*s) 638 { 639 #if _options_dumped_ 640 if (streq(s, "OPTION")) /* ... */; 641 else 642 #endif 643 error(3, "%-.48s: unknown flags in checkpoint file", s); 644 } 645 s++; 646 647 /* 648 * unpack and enter the definitions 649 */ 650 651 while (*s) 652 { 653 b = s; 654 while (*s++); 655 m = *s++; 656 sym = ppsymset(pp.symtab, b); 657 if (sym->macro) 658 { 659 if (m & LOAD_FUNCTION) 660 { 661 if (*s++ != '0') 662 while (*s++); 663 while (*s++); 664 } 665 if (pp.test & 0x1000) error(2, "checkpoint SKIP %s=%s [%s]", sym->name, s, sym->macro->value); 666 while (*s++); 667 } 668 else 669 { 670 ppfsm(FSM_MACRO, b); 671 sym->flags = 0; 672 if (m & LOAD_FUNCTION) sym->flags |= SYM_FUNCTION; 673 if (m & LOAD_MULTILINE) sym->flags |= SYM_MULTILINE; 674 if (m & LOAD_NOEXPAND) sym->flags |= SYM_NOEXPAND; 675 if (m & LOAD_PREDICATE) sym->flags |= SYM_PREDICATE; 676 if (m & LOAD_READONLY) sym->flags |= SYM_READONLY; 677 if (m & LOAD_VARIADIC) sym->flags |= SYM_VARIADIC; 678 mac = sym->macro = newof(0, struct ppmacro, 1, 0); 679 if (sym->flags & SYM_FUNCTION) 680 { 681 for (n = 0; *s >= '0' && *s <= '9'; n = n * 10 + *s++ - '0'); 682 if (*s++) error(3, "%-.48: checkpoint macro arity botched", sym->name); 683 if (mac->arity = n) 684 { 685 b = s; 686 while (*s++); 687 mac->formals = (char*)memcpy(oldof(0, char, 0, s - b), b, s - b); 688 } 689 } 690 b = s; 691 while (*s++); 692 mac->size = s - b - 1; 693 mac->value = (char*)memcpy(oldof(0, char, 0, mac->size + 1), b, mac->size + 1); 694 if (pp.test & 0x1000) error(2, "checkpoint LOAD %s=%s", sym->name, mac->value); 695 } 696 } 697 698 /* 699 * we are now at EOF 700 */ 701 702 if (ip) 703 { 704 pp.in->fd = -1; 705 free(ip); 706 } 707 #if ARCHIVE 708 if (pp.member) pp.member = 0; 709 else 710 #endif 711 { 712 sfclose(sp); 713 pp.in->flags |= IN_eof|IN_newline; 714 pp.in->nextchr = pp.in->buffer + PPBAKSIZ; 715 *pp.in->nextchr++ = 0; 716 *pp.in->nextchr = 0; 717 } 718 pp.mode &= ~LOADING; 719 } 720 721 #endif 722