![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to comp_parse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / ncurses|
Return to comp_parse.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / ncurses |
1.1 ! root 1: /********************************************************************* ! 2: * COPYRIGHT NOTICE * ! 3: ********************************************************************** ! 4: * This software is copyright (C) 1982 by Pavel Curtis * ! 5: * * ! 6: * Permission is granted to reproduce and distribute * ! 7: * this file by any means so long as no fee is charged * ! 8: * above a nominal handling fee and so long as this * ! 9: * notice is always included in the copies. * ! 10: * * ! 11: * Other rights are reserved except as explicitly granted * ! 12: * by written permission of the author. * ! 13: * Pavel Curtis * ! 14: * Computer Science Dept. * ! 15: * 405 Upson Hall * ! 16: * Cornell University * ! 17: * Ithaca, NY 14853 * ! 18: * * ! 19: * Ph- (607) 256-4934 * ! 20: * * ! 21: * Pavel.Cornell@Udel-Relay (ARPAnet) * ! 22: * decvax!cornell!pavel (UUCPnet) * ! 23: *********************************************************************/ ! 24: ! 25: /* ! 26: * comp_parse.c -- The high-level (ha!) parts of the compiler, ! 27: * that is, the routines which drive the scanner, ! 28: * etc. ! 29: * ! 30: * $Log: comp_parse.c,v $ ! 31: * Revision 1.11 93/04/12 14:13:03 bin ! 32: * Udo: third color update ! 33: * ! 34: * Revision 1.5 92/06/02 12:04:31 bin ! 35: * *** empty log message *** ! 36: * ! 37: * Revision 1.2 92/04/13 14:36:22 bin ! 38: * update by vlad ! 39: * ! 40: * Revision 3.2 91/07/28 13:59:10 munk ! 41: * Made all the large arrays static ! 42: * ! 43: * Revision 3.1 84/12/13 11:19:32 john ! 44: * Revisions by Mark Horton ! 45: * ! 46: * Revision 2.1 82/10/25 14:45:43 pavel ! 47: * Added Copyright Notice ! 48: * ! 49: * Revision 2.0 82/10/24 15:16:39 pavel ! 50: * Beta-one Test Release ! 51: * ! 52: * Revision 1.3 82/08/23 22:29:39 pavel ! 53: * The REAL Alpha-one Release Version ! 54: * ! 55: * Revision 1.2 82/08/19 19:09:53 pavel ! 56: * Alpha Test Release One ! 57: * ! 58: * Revision 1.1 82/08/12 18:37:12 pavel ! 59: * Initial revision ! 60: * ! 61: * ! 62: */ ! 63: ! 64: #ifdef RCSHDR ! 65: static char RCSid[] = ! 66: "$Header: /src386/usr/lib/ncurses/RCS/comp_parse.c,v 1.11 93/04/12 14:13:03 bin Exp Locker: bin $"; ! 67: #endif ! 68: ! 69: #include <sys/types.h> ! 70: #include <sys/stat.h> ! 71: #include <stdio.h> ! 72: #include <ctype.h> ! 73: #include "compiler.h" ! 74: #include "term.h" ! 75: #include "object.h" ! 76: ! 77: char *string_table; ! 78: int next_free; /* next free character in string_table */ ! 79: int table_size = 0; /* current string_table size */ ! 80: short term_names; /* string table offset - current terminal */ ! 81: int part2 = 0; /* set to allow old compiled defns to be used */ ! 82: int complete = 0; /* 1 if entry done with no forward uses */ ! 83: ! 84: struct use_item ! 85: { ! 86: long offset; ! 87: struct use_item *fptr, *bptr; ! 88: }; ! 89: ! 90: struct use_header ! 91: { ! 92: struct use_item *head, *tail; ! 93: }; ! 94: ! 95: struct use_header use_list = {NULL, NULL}; ! 96: int use_count = 0; ! 97: ! 98: /* ! 99: * The use_list is a doubly-linked list with NULLs terminating the lists: ! 100: * ! 101: * use_item use_item use_item ! 102: * --------- --------- --------- ! 103: * | | | | | | offset ! 104: * |-------| |-------| |-------| ! 105: * | ----+-->| ----+-->| NULL | fptr ! 106: * |-------| |-------| |-------| ! 107: * | NULL |<--+---- |<--+---- | bptr ! 108: * --------- --------- --------- ! 109: * ^ ^ ! 110: * | ------------------ | ! 111: * | | | | | ! 112: * +--+---- | ----+---+ ! 113: * | | | ! 114: * ------------------ ! 115: * head tail ! 116: * use_list ! 117: * ! 118: */ ! 119: ! 120: ! 121: /* ! 122: * compile() ! 123: * ! 124: * Main loop of the compiler. ! 125: * ! 126: * get_token() ! 127: * if curr_token != NAMES ! 128: * err_abort() ! 129: * while (not at end of file) ! 130: * do an entry ! 131: * ! 132: */ ! 133: ! 134: compile() ! 135: { ! 136: static char line[1024]; ! 137: int token_type; ! 138: struct use_item *ptr; ! 139: int old_use_count; ! 140: ! 141: token_type = get_token(); ! 142: ! 143: if (token_type != NAMES) ! 144: err_abort("File does not start with terminal names in column one"); ! 145: ! 146: while (token_type != EOF) ! 147: token_type = do_entry((struct use_item *) 0); ! 148: ! 149: DEBUG(2, "Starting handling of forward USE's\n", ""); ! 150: ! 151: for (part2=0; part2<2; part2++) { ! 152: old_use_count = -1; ! 153: DEBUG(2, "\n\nPART %d\n\n", part2); ! 154: while (use_list.head != NULL && old_use_count != use_count) ! 155: { ! 156: old_use_count = use_count; ! 157: for (ptr = use_list.tail; ptr != NULL; ptr = ptr->bptr) ! 158: { ! 159: fseek(stdin, ptr->offset, 0); ! 160: reset_input(); ! 161: if ((token_type = get_token()) != NAMES) ! 162: syserr_abort("Token after a seek not NAMES"); ! 163: (void) do_entry(ptr); ! 164: if (complete) ! 165: dequeue(ptr); ! 166: } ! 167: ! 168: for (ptr = use_list.head; ptr != NULL; ptr = ptr->fptr) ! 169: { ! 170: fseek(stdin, ptr->offset, 0); ! 171: reset_input(); ! 172: if ((token_type = get_token()) != NAMES) ! 173: syserr_abort("Token after a seek not NAMES"); ! 174: (void) do_entry(ptr); ! 175: if (complete) ! 176: dequeue(ptr); ! 177: } ! 178: ! 179: DEBUG(2, "Finished a pass through enqueued forward USE's\n", ""); ! 180: } ! 181: } ! 182: ! 183: if (use_list.head != NULL) ! 184: { ! 185: fprintf(stderr, "\nError in following up use-links. Either there is\n"); ! 186: fprintf(stderr, "a loop in the links or they reference non-existant\n"); ! 187: fprintf(stderr, "terminals. The following is a list of the entries\n"); ! 188: fprintf(stderr, "involved:\n\n"); ! 189: ! 190: for (ptr = use_list.head; ptr != NULL; ptr = ptr->fptr) ! 191: { ! 192: fseek(stdin, ptr->offset, 0); ! 193: fgets(line, 1024, stdin); ! 194: fprintf(stderr, "%s", line); ! 195: } ! 196: ! 197: exit(1); ! 198: } ! 199: } ! 200: ! 201: ! 202: dump_list(str) ! 203: char *str; ! 204: { ! 205: struct use_item *ptr; ! 206: static char line[512]; ! 207: ! 208: fprintf(stderr, "dump_list %s\n", str); ! 209: for (ptr = use_list.head; ptr != NULL; ptr = ptr->fptr) ! 210: { ! 211: fseek(stdin, ptr->offset, 0); ! 212: fgets(line, 1024, stdin); ! 213: fprintf(stderr, "ptr %x off %d bptr %x fptr %x str %s", ! 214: ptr, ptr->offset, ptr->bptr, ptr->fptr, line); ! 215: } ! 216: fprintf(stderr, "\n"); ! 217: } ! 218: ! 219: ! 220: /* ! 221: * int ! 222: * do_entry(item_ptr) ! 223: * ! 224: * Compile one entry. During the first pass, item_ptr is NULL. In pass ! 225: * two, item_ptr points to the current entry in the use_list. ! 226: * ! 227: * found-forward-use = FALSE ! 228: * re-initialise internal arrays ! 229: * save names in string_table ! 230: * get_token() ! 231: * while (not EOF and not NAMES) ! 232: * if found-forward-use ! 233: * do nothing ! 234: * else if 'use' ! 235: * if handle_use() < 0 ! 236: * found-forward-use = TRUE ! 237: * else ! 238: * check for existance and type-correctness ! 239: * enter cap into structure ! 240: * if STRING ! 241: * save string in string_table ! 242: * get_token() ! 243: * if ! found-forward-use ! 244: * clear CANCELS out of the structure ! 245: * dump compiled entry into filesystem ! 246: * ! 247: */ ! 248: ! 249: int ! 250: do_entry(item_ptr) ! 251: struct use_item *item_ptr; ! 252: { ! 253: long entry_offset; ! 254: int i; ! 255: register int token_type; ! 256: register struct name_table_entry *entry_ptr; ! 257: int found_forward_use = FALSE; ! 258: static char Booleans[BOOLCOUNT]; ! 259: static short Numbers[NUMCOUNT], ! 260: Strings[STRCOUNT]; ! 261: ! 262: init_structure(Booleans, Numbers, Strings); ! 263: complete = 0; ! 264: term_names = save_str(curr_token.tk_name); ! 265: DEBUG(2, "Starting '%s'\n", curr_token.tk_name); ! 266: entry_offset = curr_file_pos; ! 267: ! 268: for (token_type = get_token(); ! 269: token_type != EOF && token_type != NAMES; ! 270: token_type = get_token()) ! 271: { ! 272: if (found_forward_use) ! 273: /* do nothing */ ; ! 274: else if (strcmp(curr_token.tk_name, "use") == 0) ! 275: { ! 276: if (handle_use(item_ptr, entry_offset, ! 277: Booleans, Numbers, Strings) < 0) ! 278: found_forward_use = TRUE; ! 279: } ! 280: else ! 281: { ! 282: entry_ptr = find_entry(curr_token.tk_name); ! 283: ! 284: if (entry_ptr == NOTFOUND) { ! 285: warning("Unknown Capability - '%s'", ! 286: curr_token.tk_name); ! 287: continue; ! 288: } ! 289: ! 290: ! 291: if (token_type != CANCEL ! 292: && entry_ptr->nte_type != token_type) ! 293: warning("Wrong type used for capability '%s'", ! 294: curr_token.tk_name); ! 295: switch (token_type) ! 296: { ! 297: case CANCEL: ! 298: switch (entry_ptr->nte_type) ! 299: { ! 300: case BOOLEAN: ! 301: Booleans[entry_ptr->nte_index] = -2; ! 302: break; ! 303: ! 304: case NUMBER: ! 305: Numbers[entry_ptr->nte_index] = -2; ! 306: break; ! 307: ! 308: case STRING: ! 309: Strings[entry_ptr->nte_index] = -2; ! 310: break; ! 311: } ! 312: break; ! 313: ! 314: case BOOLEAN: ! 315: Booleans[entry_ptr->nte_index] = TRUE; ! 316: break; ! 317: ! 318: case NUMBER: ! 319: Numbers[entry_ptr->nte_index] = ! 320: curr_token.tk_valnumber; ! 321: break; ! 322: ! 323: case STRING: ! 324: Strings[entry_ptr->nte_index] = ! 325: save_str(curr_token.tk_valstring); ! 326: break; ! 327: ! 328: default: ! 329: warning("Unknown token type"); ! 330: panic_mode(','); ! 331: continue; ! 332: } ! 333: } /* end else cur_token.name != "use" */ ! 334: ! 335: } /* endwhile (not EOF and not NAMES) */ ! 336: ! 337: if (found_forward_use) ! 338: return(token_type); ! 339: ! 340: for (i=0; i < BOOLCOUNT; i++) ! 341: { ! 342: if (Booleans[i] == -2) ! 343: Booleans[i] = FALSE; ! 344: } ! 345: ! 346: for (i=0; i < NUMCOUNT; i++) ! 347: { ! 348: if (Numbers[i] == -2) ! 349: Numbers[i] = -1; ! 350: } ! 351: ! 352: for (i=0; i < STRCOUNT; i++) ! 353: { ! 354: if (Strings[i] == -2) ! 355: Strings[i] = -1; ! 356: } ! 357: ! 358: dump_structure(term_names, Booleans, Numbers, Strings); ! 359: ! 360: complete = 1; ! 361: return(token_type); ! 362: } ! 363: ! 364: ! 365: /* ! 366: * enqueue(offset) ! 367: * ! 368: * Put a record of the given offset onto the use-list. ! 369: * ! 370: */ ! 371: ! 372: enqueue(offset) ! 373: long offset; ! 374: { ! 375: struct use_item *item; ! 376: char *malloc(); ! 377: ! 378: item = (struct use_item *) malloc(sizeof(struct use_item)); ! 379: ! 380: if (item == NULL) ! 381: syserr_abort("Not enough memory for use_list element"); ! 382: ! 383: item->offset = offset; ! 384: ! 385: if (use_list.head != NULL) ! 386: { ! 387: item->bptr = use_list.tail; ! 388: use_list.tail->fptr = item; ! 389: item->fptr = NULL; ! 390: use_list.tail = item; ! 391: } ! 392: else ! 393: { ! 394: use_list.tail = use_list.head = item; ! 395: item->fptr = item->bptr = NULL; ! 396: } ! 397: ! 398: use_count ++; ! 399: } ! 400: ! 401: ! 402: /* ! 403: * dequeue(ptr) ! 404: * ! 405: * remove the pointed-to item from the use_list ! 406: * ! 407: */ ! 408: ! 409: dequeue(ptr) ! 410: struct use_item *ptr; ! 411: { ! 412: if (ptr->fptr == NULL) ! 413: use_list.tail = ptr->bptr; ! 414: else ! 415: (ptr->fptr)->bptr = ptr->bptr; ! 416: ! 417: if (ptr->bptr == NULL) ! 418: use_list.head = ptr->fptr; ! 419: else ! 420: (ptr->bptr)->fptr = ptr->fptr; ! 421: ! 422: use_count --; ! 423: } ! 424: ! 425: ! 426: /* ! 427: * dump_structure() ! 428: * ! 429: * Save the compiled version of a description in the filesystem. ! 430: * ! 431: * make a copy of the name-list ! 432: * break it up into first-name and all-but-last-name ! 433: * creat(first-name) ! 434: * write object information to first-name ! 435: * close(first-name) ! 436: * for each name in all-but-last-name ! 437: * link to first-name ! 438: * ! 439: */ ! 440: ! 441: dump_structure(term_names, Booleans, Numbers, Strings) ! 442: short term_names; ! 443: char Booleans[]; ! 444: short Numbers[]; ! 445: short Strings[]; ! 446: { ! 447: char *strcpy(); ! 448: struct stat statbuf; ! 449: FILE *fp; ! 450: static char name_list[1024]; ! 451: register char *first_name, *other_names; ! 452: register char *ptr; ! 453: static char filename[50]; ! 454: static char linkname[50]; ! 455: extern char check_only; ! 456: ! 457: strcpy(name_list, term_names + string_table); ! 458: DEBUG(7, "Name list = '%s'\n", name_list); ! 459: ! 460: first_name = name_list; ! 461: ! 462: ptr = &name_list[strlen(name_list) - 1]; ! 463: other_names = ptr + 1; ! 464: ! 465: while (ptr > name_list && *ptr != '|') ! 466: ptr--; ! 467: ! 468: if (ptr != name_list) ! 469: { ! 470: *ptr = '\0'; ! 471: ! 472: for (ptr = name_list; *ptr != '\0' && *ptr != '|'; ptr++) ! 473: ; ! 474: ! 475: if (*ptr == '\0') ! 476: other_names = ptr; ! 477: else ! 478: { ! 479: *ptr = '\0'; ! 480: other_names = ptr + 1; ! 481: } ! 482: } ! 483: ! 484: if (check_only) { ! 485: DEBUG(1, "Checked %s\n", first_name); ! 486: return; ! 487: } ! 488: ! 489: DEBUG(7, "First name = '%s'\n", first_name); ! 490: DEBUG(7, "Other names = '%s'\n", other_names); ! 491: ! 492: if (strlen(first_name) > 100) ! 493: warning("'%s': terminal name too long.", first_name); ! 494: ! 495: check_name(first_name); ! 496: ! 497: sprintf(filename, "%c/%s", first_name[0], first_name); ! 498: ! 499: if (stat(filename, &statbuf) >= 0 && statbuf.st_mtime >= start_time) ! 500: { ! 501: warning("'%s' defined in more than one entry.", first_name); ! 502: fprintf(stderr, "Entry being used is '%s'.\n", ! 503: (unsigned) term_names + string_table); ! 504: } ! 505: ! 506: unlink(filename); ! 507: fp = fopen(filename, "w"); ! 508: if (fp == NULL) ! 509: { ! 510: perror(filename); ! 511: syserr_abort("Can't open %s/%s\n", destination, filename); ! 512: } ! 513: DEBUG(1, "Created %s\n", filename); ! 514: ! 515: if (write_object(fp, term_names, Booleans, Numbers, Strings) < 0) ! 516: { ! 517: syserr_abort("Error in writing %s/%s", destination, filename); ! 518: } ! 519: fclose(fp); ! 520: ! 521: while (*other_names != '\0') ! 522: { ! 523: ptr = other_names++; ! 524: while (*other_names != '|' && *other_names != '\0') ! 525: other_names++; ! 526: ! 527: if (*other_names != '\0') ! 528: *(other_names++) = '\0'; ! 529: ! 530: if (strlen(ptr) > 100) ! 531: { ! 532: warning("'%s': terminal name too long.", ptr); ! 533: continue; ! 534: } ! 535: ! 536: sprintf(linkname, "%c/%s", ptr[0], ptr); ! 537: ! 538: if (strcmp(filename, linkname) == 0) ! 539: { ! 540: warning("Terminal name '%s' synonym for itself", first_name); ! 541: } ! 542: else if (stat(linkname, &statbuf) >= 0 && ! 543: statbuf.st_mtime >= start_time) ! 544: { ! 545: warning("'%s' defined in more than one entry.", ptr); ! 546: fprintf(stderr, "Entry being used is '%s'.\n", ! 547: (unsigned) term_names + string_table); ! 548: } ! 549: else ! 550: { ! 551: unlink(linkname); ! 552: if (link(filename, linkname) < 0) ! 553: syserr_abort("Can't link %s to %s", filename, linkname); ! 554: DEBUG(1, "Linked %s\n", linkname); ! 555: } ! 556: } ! 557: } ! 558: ! 559: ! 560: /* ! 561: * int ! 562: * write_object(fp, term_names, Booleans, Numbers, Strings) ! 563: * ! 564: * Write out the compiled entry to the given file. ! 565: * Return 0 if OK or -1 if not. ! 566: * ! 567: */ ! 568: ! 569: #define swap(x) (((x >> 8) & 0377) + 256 * (x & 0377)) ! 570: ! 571: #define might_swap(x) (must_swap() ? swap(x) : (x)) ! 572: ! 573: ! 574: int ! 575: write_object(fp, term_names, Booleans, Numbers, Strings) ! 576: FILE *fp; ! 577: short term_names; ! 578: char Booleans[]; ! 579: short Numbers[]; ! 580: short Strings[]; ! 581: { ! 582: struct header header; ! 583: char *namelist; ! 584: short namelen; ! 585: char zero = '\0'; ! 586: int i; ! 587: ! 588: namelist = term_names + string_table; ! 589: namelen = strlen(namelist) + 1; ! 590: ! 591: if (must_swap()) ! 592: { ! 593: header.magic = swap(MAGIC); ! 594: header.name_size = swap(namelen); ! 595: header.bool_count = swap(BOOLCOUNT); ! 596: header.num_count = swap(NUMCOUNT); ! 597: header.str_count = swap(STRCOUNT); ! 598: header.str_size = swap(next_free); ! 599: } ! 600: else ! 601: { ! 602: header.magic = MAGIC; ! 603: header.name_size = namelen; ! 604: header.bool_count = BOOLCOUNT; ! 605: header.num_count = NUMCOUNT; ! 606: header.str_count = STRCOUNT; ! 607: header.str_size = next_free; ! 608: } ! 609: ! 610: if (fwrite(&header, sizeof(header), 1, fp) != 1 ! 611: || fwrite(namelist, sizeof(char), namelen, fp) != namelen ! 612: || fwrite(Booleans, sizeof(char), BOOLCOUNT, fp) != BOOLCOUNT) ! 613: return(-1); ! 614: ! 615: if ((namelen+BOOLCOUNT) % 2 != 0 && fwrite(&zero, sizeof(char), 1, fp) != 1) ! 616: return(-1); ! 617: ! 618: if (must_swap()) ! 619: { ! 620: for (i=0; i < NUMCOUNT; i++) ! 621: Numbers[i] = swap(Numbers[i]); ! 622: for (i=0; i < STRCOUNT; i++) ! 623: Strings[i] = swap(Strings[i]); ! 624: } ! 625: ! 626: if (fwrite((char *) Numbers, sizeof(short), NUMCOUNT, fp) != NUMCOUNT ! 627: || fwrite((char *) Strings, sizeof(short), STRCOUNT, fp) != STRCOUNT ! 628: || fwrite((char *) string_table, sizeof(char), next_free, fp) ! 629: != next_free) ! 630: return(-1); ! 631: ! 632: return(0); ! 633: } ! 634: ! 635: ! 636: /* ! 637: * check_name(name) ! 638: * ! 639: * Generate an error message if given name does not begin with a ! 640: * digit or letter (should be lower-case letter, but SV likes capital) ! 641: * Vlad 3-11-92 ! 642: */ ! 643: ! 644: check_name(name) ! 645: char *name; ! 646: { ! 647: if (!isalnum(name[0])) ! 648: { ! 649: fprintf(stderr, "tic: Line %d: Illegal terminal name - '%s'\n", ! 650: curr_line, name); ! 651: fprintf(stderr, ! 652: "Terminal names must start with letter or digit\n"); ! 653: exit(1); ! 654: } ! 655: } ! 656: ! 657: ! 658: /* ! 659: * int ! 660: * save_str(string) ! 661: * ! 662: * copy string into next free part of string_table, doing a realloc() ! 663: * if necessary. return offset of beginning of string from start of ! 664: * string_table. ! 665: * ! 666: */ ! 667: ! 668: int ! 669: save_str(string) ! 670: char *string; ! 671: { ! 672: char *malloc(), *realloc(), *strcpy(); ! 673: int old_next_free = next_free; ! 674: ! 675: if (table_size == 0) ! 676: { ! 677: if ((string_table = malloc(1024)) == NULL) ! 678: syserr_abort("Out of memory"); ! 679: table_size = 1024; ! 680: DEBUG(5, "Made initial string table allocation. Size is %d\n", ! 681: table_size); ! 682: } ! 683: ! 684: while (table_size < next_free + strlen(string)) ! 685: { ! 686: if ((string_table = realloc(string_table, table_size + 1024)) ! 687: == NULL) ! 688: syserr_abort("Out of memory"); ! 689: table_size += 1024; ! 690: DEBUG(5, "Extended string table. Size now %d\n", table_size); ! 691: } ! 692: ! 693: strcpy(&string_table[next_free], string); ! 694: DEBUG(7, "Saved string '%s' ", string); ! 695: DEBUG(7, "at location %d\n", next_free); ! 696: next_free += strlen(string) + 1; ! 697: ! 698: return(old_next_free); ! 699: } ! 700: ! 701: ! 702: /* ! 703: * init_structure(Booleans, Numbers, Strings) ! 704: * ! 705: * Initialise the given arrays ! 706: * Reset the next_free counter to zero. ! 707: * ! 708: */ ! 709: ! 710: init_structure(Booleans, Numbers, Strings) ! 711: char Booleans[]; ! 712: short Numbers[], Strings[]; ! 713: { ! 714: int i; ! 715: ! 716: for (i=0; i < BOOLCOUNT; i++) ! 717: Booleans[i] = FALSE; ! 718: ! 719: for (i=0; i < NUMCOUNT; i++) ! 720: Numbers[i] = -1; ! 721: ! 722: for (i=0; i < STRCOUNT; i++) ! 723: Strings[i] = -1; ! 724: ! 725: next_free = 0; ! 726: } ! 727: ! 728: ! 729: /* ! 730: ** int ! 731: ** handle_use(item_ptr, entry_offset, Booleans, Numbers, Strings) ! 732: ** ! 733: ** Merge the compiled file whose name is in cur_token.valstring ! 734: ** with the current entry. ! 735: ** ! 736: ** if it's a forward use-link ! 737: ** if item_ptr == NULL ! 738: ** queue it up for later handling ! 739: ** else ! 740: ** ignore it (we're already going through the queue) ! 741: ** else it's a backward use-link ! 742: ** read in the object file for that terminal ! 743: ** merge contents with current structure ! 744: ** ! 745: ** Returned value is 0 if it was a backward link and we ! 746: ** successfully read it in, -1 if a forward link. ! 747: */ ! 748: ! 749: int ! 750: handle_use(item_ptr, entry_offset, Booleans, Numbers, Strings) ! 751: long entry_offset; ! 752: struct use_item *item_ptr; ! 753: char Booleans[]; ! 754: short Numbers[]; ! 755: short Strings[]; ! 756: { ! 757: struct term use_term; ! 758: struct stat statbuf; ! 759: static char filename[50]; ! 760: int i; ! 761: ! 762: check_name(curr_token.tk_valstring); ! 763: ! 764: sprintf(filename, "%c/%s", curr_token.tk_valstring[0], ! 765: curr_token.tk_valstring); ! 766: ! 767: if (stat(filename, &statbuf) < 0 || part2==0 && statbuf.st_mtime < start_time) ! 768: { ! 769: DEBUG(2, "Forward USE to %s", curr_token.tk_valstring); ! 770: ! 771: if (item_ptr == NULL) ! 772: { ! 773: DEBUG(2, " (enqueued)\n", ""); ! 774: enqueue(entry_offset); ! 775: } ! 776: else ! 777: DEBUG(2, " (skipped)\n", ""); ! 778: ! 779: return(-1); ! 780: } ! 781: else ! 782: { ! 783: DEBUG(2, "Backward USE to %s\n", curr_token.tk_valstring); ! 784: if (read_entry(filename, &use_term) < 0) ! 785: syserr_abort("Error in re-reading compiled file %s", filename); ! 786: ! 787: for (i=0; i < BOOLCOUNT; i++) ! 788: { ! 789: if (Booleans[i] == FALSE && use_term.Booleans[i] == TRUE) ! 790: Booleans[i] = TRUE; ! 791: } ! 792: ! 793: for (i=0; i < NUMCOUNT; i++) ! 794: { ! 795: if (Numbers[i] == -1 && use_term.Numbers[i] != -1) ! 796: Numbers[i] = use_term.Numbers[i]; ! 797: } ! 798: ! 799: for (i=0; i < STRCOUNT; i++) ! 800: { ! 801: if (Strings[i] == -1 && use_term.Strings[i] != (char *) 0) ! 802: Strings[i] = save_str(use_term.Strings[i]); ! 803: } ! 804: ! 805: } ! 806: return(0); ! 807: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.