![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mkmake.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / tn3270 / tools|
Return to mkmake.y CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / tn3270 / tools |
1.1 ! root 1: %{ ! 2: ! 3: /* ! 4: * Copyright (c) 1988 Regents of the University of California. ! 5: * All rights reserved. ! 6: * ! 7: * Redistribution and use in source and binary forms are permitted ! 8: * provided that the above copyright notice and this paragraph are ! 9: * duplicated in all such forms and that any documentation, ! 10: * advertising materials, and other materials related to such ! 11: * distribution and use acknowledge that the software was developed ! 12: * by the University of California, Berkeley. The name of the ! 13: * University may not be used to endorse or promote products derived ! 14: * from this software without specific prior written permission. ! 15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 17: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 18: * ! 19: * @(#)mkmake.y 4.1 (Berkeley) 12/4/88 ! 20: */ ! 21: ! 22: typedef struct string { ! 23: int ! 24: hashval, ! 25: length; ! 26: char ! 27: *string; ! 28: struct string ! 29: *next; ! 30: } string_t; ! 31: ! 32: /* ! 33: * The deal with these is that they exist on various lists. ! 34: * ! 35: * First off, they are on a temporary list during the time they ! 36: * are in the active focus of the parser. ! 37: * ! 38: * Secondly, they live on one of three queues: ! 39: * 1. Variables ! 40: * 2. Targets ! 41: * 3. Actions ! 42: * (and, we restrict any given one to live on one and only one such list) ! 43: * ! 44: * Also, they may live on the list of values for someone else's variable, ! 45: * or as someone's dependancy. ! 46: */ ! 47: ! 48: typedef struct same { ! 49: string_t ! 50: *string; /* My name */ ! 51: struct same ! 52: *nexttoken, /* Next pointer */ ! 53: *lasttoken, /* Back pointer */ ! 54: *depend_list, /* If target, dependancies */ ! 55: *action_list, /* If target, actions */ ! 56: *value_list, /* If variable, value list */ ! 57: *shell_item; /* If a shell variable, current value */ ! 58: } same_t; ! 59: ! 60: %} ! 61: ! 62: %union { ! 63: string_t *string; ! 64: same_t *same; ! 65: int intval; ! 66: } ! 67: ! 68: %start makefile ! 69: %token <string> TOKEN QUOTED_STRING ! 70: %token <intval> FOR IN DO DONE ! 71: %token <intval> MACRO_CHAR NL WHITE_SPACE ! 72: %token <intval> ':' '=' '$' '{' '}' ';' '-' '@' '(' ')' ' ' '\t' ! 73: %type <same> target target1 assignment assign1 actions action ! 74: %type <same> command_list list list_element ! 75: %type <same> for_statement maybe_at_minus tokens token ! 76: %type <same> maybe_white_space ! 77: %type <intval> white_space macro_char ! 78: %% ! 79: ! 80: makefile : lines; ! 81: ! 82: lines : line ! 83: | lines line ! 84: ; ! 85: ! 86: line : NL ! 87: | assignment ! 88: | target_action ! 89: ; ! 90: ! 91: assignment : assign1 tokens NL ! 92: { ! 93: assign($1, $2); ! 94: } ! 95: | assign1 NL ! 96: { ! 97: assign($1, same_copy(null)); ! 98: } ! 99: ; ! 100: ! 101: assign1: token maybe_white_space '=' maybe_white_space ! 102: ; ! 103: ! 104: target_action: target actions ! 105: { ! 106: add_targets_actions($1, $2); ! 107: } ! 108: | target ! 109: { ! 110: add_targets_actions($1, 0); ! 111: } ! 112: ; ! 113: ! 114: target : target1 tokens NL ! 115: { ! 116: $$ = add_depends($1, $2); ! 117: } ! 118: | target1 NL ! 119: { ! 120: $$ = add_depends($1, same_copy(null)); ! 121: } ! 122: ; ! 123: ! 124: target1: tokens maybe_white_space ':' maybe_white_space ! 125: { ! 126: $$ = ws_merge($1); ! 127: } ! 128: ; ! 129: ! 130: actions: action ! 131: | actions action ! 132: { ! 133: $$ = same_cat(same_cat($1, same_copy(newline)), $2); ! 134: } ! 135: ; ! 136: ! 137: action: white_space command_list NL ! 138: { ! 139: $$ = $2; ! 140: } ! 141: | white_space for_statement do command_list semi_colon done NL ! 142: { ! 143: $$ = do_command($2, $4); ! 144: } ! 145: ; ! 146: ! 147: for_statement: maybe_at_minus FOR white_space token ! 148: in tokens semi_colon ! 149: { ! 150: $$ = for_statement($1, $4, ws_merge(expand_variables($6, 0))); ! 151: } ! 152: ; ! 153: ! 154: in: white_space IN white_space ! 155: do: white_space DO white_space ! 156: ; ! 157: ! 158: done: white_space DONE ! 159: ; ! 160: ! 161: semi_colon: ';' ! 162: ; ! 163: ! 164: command_list: list ! 165: | '(' list maybe_white_space ')' ! 166: { ! 167: $$ = same_cat($2, same_copy(cwd_line)); ! 168: } ! 169: ; ! 170: ! 171: list: token ! 172: | list list_element ! 173: { ! 174: $$ = same_cat($1, $2); ! 175: } ! 176: | list white_space list_element ! 177: { ! 178: $$ = same_cat($1, same_cat(same_copy(blank), $3)); ! 179: } ! 180: ; ! 181: ! 182: list_element: token ! 183: | semi_colon ! 184: { ! 185: $$ = same_copy(newline); ! 186: } ! 187: ; ! 188: ! 189: maybe_at_minus: /* empty */ ! 190: { ! 191: $$ = same_copy(null); ! 192: } ! 193: | '@' ! 194: { ! 195: char buffer[2]; ! 196: ! 197: buffer[0] = $1; ! 198: buffer[1] = 0; ! 199: $$ = same_item(string_lookup(buffer)); ! 200: } ! 201: | '-' ! 202: { ! 203: char buffer[2]; ! 204: ! 205: buffer[0] = $1; ! 206: buffer[1] = 0; ! 207: $$ = same_item(string_lookup(buffer)); ! 208: } ! 209: ; ! 210: ! 211: tokens : token ! 212: | tokens maybe_white_space token ! 213: { ! 214: $$ = same_cat($1, same_cat($2, $3)); ! 215: } ! 216: ; ! 217: ! 218: token: TOKEN ! 219: { ! 220: $$ = same_item($1); ! 221: } ! 222: | QUOTED_STRING ! 223: { ! 224: $$ = same_item($1); ! 225: } ! 226: | '$' macro_char ! 227: { ! 228: char buffer[3]; ! 229: ! 230: buffer[0] = '$'; ! 231: buffer[1] = $2; ! 232: buffer[2] = 0; ! 233: ! 234: $$ = same_item(string_lookup(buffer)); ! 235: } ! 236: | '$' '$' TOKEN ! 237: { ! 238: $$ = shell_variable(same_item($3)); ! 239: } ! 240: | MACRO_CHAR ! 241: { ! 242: $$ = same_char($1); ! 243: } ! 244: | '$' '{' TOKEN '}' ! 245: { ! 246: $$ = variable(same_item($3)); ! 247: } ! 248: | '$' '(' TOKEN ')' ! 249: { ! 250: $$ = variable(same_item($3)); ! 251: } ! 252: | '$' TOKEN ! 253: { ! 254: $$ = variable(same_item($2)); ! 255: } ! 256: | '-' ! 257: { ! 258: $$ = same_char('-'); ! 259: } ! 260: | '@' ! 261: { ! 262: $$ = same_char('@'); ! 263: } ! 264: ; ! 265: ! 266: macro_char: MACRO_CHAR ! 267: | '@' ! 268: ; ! 269: ! 270: maybe_white_space: ! 271: { ! 272: $$ = same_copy(null); ! 273: } ! 274: | white_space ! 275: { ! 276: $$ = same_char($1); ! 277: } ! 278: ; ! 279: ! 280: white_space : WHITE_SPACE ! 281: | white_space WHITE_SPACE ! 282: ; ! 283: %% ! 284: #include <stdio.h> ! 285: #include <ctype.h> ! 286: ! 287: static int last_char, last_saved = 0; ! 288: static int column = 0, lineno = 1; ! 289: ! 290: ! 291: static string_t ! 292: *strings = 0; ! 293: ! 294: static same_t ! 295: *shell_variables = 0, ! 296: *shell_special = 0, ! 297: *variables = 0, ! 298: *targets = 0, ! 299: *actions = 0; ! 300: ! 301: static same_t ! 302: *null, ! 303: *blank, ! 304: *cwd_line, ! 305: *newline; ! 306: ! 307: extern char *malloc(); ! 308: ! 309: static unsigned int ! 310: clock = -1; ! 311: ! 312: struct { ! 313: same_t *first; ! 314: int next; ! 315: } visit_stack[20]; /* 20 maximum */ ! 316: ! 317: #define visit(what,via) \ ! 318: (visit_stack[++clock].next = 0, visit_stack[clock].first = via = what) ! 319: #define visited(via) (visitcheck(via) || ((via) == 0) \ ! 320: || (visit_stack[clock].next && (via == visit_stack[clock].first))) ! 321: #define visit_next(via) (visit_stack[clock].next = 1, (via) = (via)->nexttoken) ! 322: #define visit_end() (clock--) ! 323: ! 324: yyerror(s) ! 325: char *s; ! 326: { ! 327: fprintf(stderr, "line %d, character %d: %s\n", lineno, column, s); ! 328: do_dump(); ! 329: } ! 330: ! 331: int ! 332: visitcheck(same) ! 333: same_t *same; ! 334: { ! 335: if (same->string == 0) { ! 336: yyerror("BUG - freed 'same' in use..."); ! 337: exit(1); ! 338: } ! 339: return 0; ! 340: } ! 341: ! 342: int ! 343: string_hashof(string, length) ! 344: char *string; ! 345: int length; ! 346: { ! 347: register int i = 0; ! 348: ! 349: while (length--) { ! 350: i = (i<<3) + *string ^ ((i>>28)&0x7); ! 351: } ! 352: return i; ! 353: } ! 354: ! 355: int ! 356: string_same(s1, s2) ! 357: string_t ! 358: *s1, *s2; ! 359: { ! 360: if ((s1->hashval == s2->hashval) && (s1->length == s2->length) ! 361: && (memcmp(s1->string, s2->string, s1->length) == 0)) { ! 362: return 1; ! 363: } else { ! 364: return 0; ! 365: } ! 366: } ! 367: ! 368: string_t * ! 369: string_lookup(string) ! 370: char *string; ! 371: { ! 372: string_t ours; ! 373: string_t *ptr; ! 374: ! 375: ours.length = strlen(string); ! 376: ours.hashval = string_hashof(string, ours.length); ! 377: ours.string = string; ! 378: ! 379: for (ptr = strings; ptr; ptr = ptr->next) { ! 380: if (string_same(&ours, ptr)) { ! 381: return ptr; ! 382: } ! 383: } ! 384: if ((ptr = (string_t *)malloc(sizeof *ptr)) == 0) { ! 385: fprintf(stderr, "No space to add string *%s*!\n", string); ! 386: exit(1); ! 387: } ! 388: ptr->hashval = ours.hashval; ! 389: ptr->length = ours.length; ! 390: if ((ptr->string = malloc(ours.length+1)) == 0) { ! 391: fprintf(stderr, "No space to add literal *%s*!\n", string); ! 392: exit(1); ! 393: } ! 394: memcpy(ptr->string, string, ours.length+1); ! 395: ptr->next = strings; ! 396: strings = ptr; ! 397: return ptr; ! 398: } ! 399: ! 400: #define same_singleton(s) ((s)->nexttoken == (s)) ! 401: ! 402: same_t * ! 403: same_search(list, token) ! 404: same_t ! 405: *list, ! 406: *token; ! 407: { ! 408: same_t *ptr; ! 409: ! 410: ptr = list; ! 411: for (visit(list, ptr); !visited(ptr); visit_next(ptr)) { ! 412: string_t *string; ! 413: ! 414: string = ptr->string; ! 415: if (string_same(string, token->string)) { ! 416: visit_end(); ! 417: return ptr; ! 418: } ! 419: } ! 420: visit_end(); ! 421: return 0; ! 422: } ! 423: ! 424: same_t * ! 425: same_cat(list, tokens) ! 426: same_t ! 427: *list, ! 428: *tokens; ! 429: { ! 430: same_t *last; ! 431: ! 432: if (tokens == 0) { ! 433: return list; ! 434: } ! 435: if (list) { ! 436: last = tokens->lasttoken; ! 437: tokens->lasttoken = list->lasttoken; ! 438: list->lasttoken = last; ! 439: tokens->lasttoken->nexttoken = tokens; ! 440: last->nexttoken = list; ! 441: return list; ! 442: } else { ! 443: return tokens; ! 444: } ! 445: } ! 446: ! 447: same_t * ! 448: same_item(string) ! 449: string_t *string; ! 450: { ! 451: same_t *ptr; ! 452: ! 453: if ((ptr = (same_t *)malloc(sizeof *ptr)) == 0) { ! 454: fprintf(stderr, "No more space for tokens!\n"); ! 455: exit(1); ! 456: } ! 457: memset((char *)ptr, 0, sizeof *ptr); ! 458: ptr->nexttoken = ptr->lasttoken = ptr; ! 459: ptr->string = string; ! 460: return ptr; ! 461: } ! 462: ! 463: same_t * ! 464: same_copy(same) ! 465: same_t *same; ! 466: { ! 467: same_t *head, *copy; ! 468: ! 469: head = 0; ! 470: for (visit(same, copy); !visited(copy); visit_next(copy)) { ! 471: same_t *ptr; ! 472: ! 473: ptr = same_item(copy->string); ! 474: head = same_cat(head, ptr); ! 475: } ! 476: visit_end(); ! 477: return head; ! 478: } ! 479: ! 480: ! 481: same_t * ! 482: same_merge(t1, t2) ! 483: same_t ! 484: *t1, ! 485: *t2; ! 486: { ! 487: if (same_singleton(t1) && same_singleton(t2)) { ! 488: int length = strlen(t1->string->string)+strlen(t2->string->string); ! 489: char *buffer = malloc(length+1); ! 490: same_t *value; ! 491: ! 492: if (buffer == 0) { ! 493: yyerror("No space to merge strings in same_merge!"); ! 494: exit(1); ! 495: } ! 496: strcpy(buffer, t1->string->string); ! 497: strcat(buffer, t2->string->string); ! 498: value = same_item(string_lookup(buffer)); ! 499: free(buffer); ! 500: return value; ! 501: } else { ! 502: yyerror("Internal error - same_merge with non-singletons"); ! 503: exit(1); ! 504: } ! 505: } ! 506: ! 507: ! 508: void ! 509: same_free(list) ! 510: same_t *list; ! 511: { ! 512: same_t *token, *ptr; ! 513: ! 514: if (list == 0) { ! 515: return; ! 516: } ! 517: ! 518: token = list; ! 519: do { ! 520: ptr = token->nexttoken; ! 521: token->string = 0; ! 522: (void) free((char *)token); ! 523: token = ptr; ! 524: } while (token != list); ! 525: } ! 526: ! 527: same_t * ! 528: same_unlink(token) ! 529: same_t ! 530: *token; ! 531: { ! 532: same_t *tmp; ! 533: ! 534: if (token == 0) { ! 535: return 0; ! 536: } ! 537: if ((tmp = token->nexttoken) == token) { ! 538: tmp = 0; ! 539: } ! 540: token->lasttoken->nexttoken = token->nexttoken; ! 541: token->nexttoken->lasttoken = token->lasttoken; ! 542: token->nexttoken = token->lasttoken = token; ! 543: return tmp; ! 544: } ! 545: ! 546: void ! 547: same_replace(old, new) ! 548: same_t ! 549: *old, ! 550: *new; ! 551: { ! 552: new->lasttoken->nexttoken = old->nexttoken; ! 553: old->nexttoken->lasttoken = new->lasttoken; ! 554: new->lasttoken = old->lasttoken; ! 555: /* rather than ! 556: * old->lasttoken->nexttoken = new ! 557: * we update in place (for the case where there isn't anything else) ! 558: */ ! 559: *old = *new; ! 560: } ! 561: ! 562: ! 563: same_t * ! 564: same_char(ch) ! 565: char ch; ! 566: { ! 567: char buffer[2]; ! 568: ! 569: buffer[0] = ch; ! 570: buffer[1] = 0; ! 571: ! 572: return same_item(string_lookup(buffer)); ! 573: } ! 574: ! 575: ! 576: void ! 577: add_target(target, actions) ! 578: same_t ! 579: *target, ! 580: *actions; ! 581: { ! 582: same_t *ptr; ! 583: ! 584: if ((ptr = same_search(targets, target)) == 0) { ! 585: targets = same_cat(targets, target); ! 586: ptr = target; ! 587: } else { ! 588: ptr->depend_list = same_cat(ptr->depend_list, target->depend_list); ! 589: } ! 590: if (actions) { ! 591: if (ptr->action_list) { ! 592: same_free(ptr->action_list); ! 593: } ! 594: ptr->action_list = same_copy(actions); ! 595: } ! 596: } ! 597: ! 598: ! 599: same_t * ! 600: add_targets_actions(target, actions) ! 601: same_t ! 602: *target, ! 603: *actions; ! 604: { ! 605: same_t *ptr; ! 606: ! 607: if (target == 0) { ! 608: return 0; ! 609: } ! 610: do { ! 611: ptr = same_unlink(target); ! 612: add_target(target, actions); ! 613: target = ptr; ! 614: } while (target); ! 615: ! 616: same_free(actions); ! 617: return 0; ! 618: } ! 619: ! 620: same_t * ! 621: add_depends(target, depends) ! 622: same_t ! 623: *target, ! 624: *depends; ! 625: { ! 626: same_t *original = target; ! 627: ! 628: depends = same_cat(depends, same_copy(blank)); /* Separator */ ! 629: ! 630: for (visit(original, target); !visited(target); visit_next(target)) { ! 631: target->depend_list = same_cat(target->depend_list, same_copy(depends)); ! 632: } ! 633: visit_end(); ! 634: same_free(depends); ! 635: ! 636: return original; ! 637: } ! 638: ! 639: ! 640: /* ! 641: * We know that variable is a singleton ! 642: */ ! 643: ! 644: void ! 645: assign(variable, value) ! 646: same_t ! 647: *variable, ! 648: *value; ! 649: { ! 650: same_t *ptr; ! 651: ! 652: if ((ptr = same_search(variables, variable)) != 0) { ! 653: same_free(ptr->value_list); ! 654: variables = same_unlink(ptr); ! 655: same_free(ptr); ! 656: } ! 657: variable->value_list = value; ! 658: variables = same_cat(variables, variable); ! 659: } ! 660: ! 661: same_t * ! 662: value_of(variable) ! 663: same_t *variable; ! 664: { ! 665: same_t *ptr = same_search(variables, variable); ! 666: ! 667: if (ptr == 0) { ! 668: return same_copy(null); ! 669: } else { ! 670: return same_copy(ptr->value_list); ! 671: } ! 672: } ! 673: ! 674: ! 675: same_t * ! 676: expand_variables(token, free) ! 677: same_t *token; ! 678: int free; ! 679: { ! 680: same_t *head = 0; ! 681: ! 682: if (!free) { ! 683: token = same_copy(token); /* Get our private copy */ ! 684: } ! 685: ! 686: while (token) { ! 687: char *string = token->string->string; ! 688: same_t *tmp = same_unlink(token); ! 689: ! 690: if ((string[0] == '$') && (string[1] == '{')) { /* Expand time */ ! 691: int len = strlen(string); ! 692: ! 693: string[len-1] = 0; ! 694: head = same_cat(head, expand_variables( ! 695: value_of(same_item(string_lookup(string+2))), 1)); ! 696: string[len-1] = '}'; ! 697: } else { ! 698: head = same_cat(head, token); ! 699: } ! 700: token = tmp; ! 701: } ! 702: return head; ! 703: } ! 704: ! 705: ! 706: same_t * ! 707: ws_merge(list) ! 708: same_t *list; ! 709: { ! 710: same_t *newlist = 0, *item; ! 711: int what = 0; ! 712: ! 713: while (list) { ! 714: switch (what) { ! 715: case 0: ! 716: if (isspace(list->string->string[0])) { ! 717: ; ! 718: } else { ! 719: item = same_item(list->string); ! 720: what = 1; ! 721: } ! 722: break; ! 723: case 1: ! 724: if (isspace(list->string->string[0])) { ! 725: newlist = same_cat(newlist, item); ! 726: item = 0; ! 727: what = 0; ! 728: } else { ! 729: item = same_merge(item, same_item(list->string)); ! 730: what = 1; ! 731: } ! 732: break; ! 733: } ! 734: list = same_unlink(list); ! 735: } ! 736: return same_cat(newlist, item); ! 737: } ! 738: ! 739: ! 740: same_t * ! 741: variable(var_name) ! 742: same_t *var_name; ! 743: { ! 744: int length = strlen(var_name->string->string); ! 745: same_t *resolved; ! 746: char *newname; ! 747: ! 748: if ((newname = malloc(length+1+3)) == 0) { ! 749: fprintf("Out of space for a variable name.\n"); ! 750: exit(1); ! 751: } ! 752: newname[0] = '$'; ! 753: newname[1] = '{'; ! 754: strcpy(newname+2, var_name->string->string); ! 755: strcat(newname, "}"); ! 756: resolved = same_item(string_lookup(newname)); ! 757: free(newname); ! 758: ! 759: return resolved; ! 760: } ! 761: ! 762: ! 763: same_t * ! 764: shell_variable(var_name) ! 765: same_t *var_name; ! 766: { ! 767: int length = strlen(var_name->string->string); ! 768: same_t *resolved; ! 769: char *newname; ! 770: ! 771: if ((newname = malloc(length+1+2)) == 0) { ! 772: fprintf("Out of space for a variable name.\n"); ! 773: exit(1); ! 774: } ! 775: newname[0] = '$'; ! 776: newname[1] = '$'; ! 777: strcpy(newname+2, var_name->string->string); ! 778: resolved = same_item(string_lookup(newname)); ! 779: free(newname); ! 780: ! 781: return resolved; ! 782: } ! 783: ! 784: same_t * ! 785: for_statement(special, variable, list) ! 786: same_t ! 787: *special, ! 788: *variable, ! 789: *list; ! 790: { ! 791: variable->shell_item = special; ! 792: variable->value_list = list; ! 793: return variable; ! 794: } ! 795: ! 796: same_t * ! 797: do_command(forlist, commands) ! 798: same_t ! 799: *forlist, ! 800: *commands; ! 801: { ! 802: same_t ! 803: *special, ! 804: *command_list = 0, ! 805: *new_commands, ! 806: *tmp, ! 807: *shell_item, ! 808: *value_list = forlist->value_list; ! 809: char ! 810: *tmpstr, ! 811: *variable_name = forlist->string->string; ! 812: ! 813: special = forlist->shell_item; ! 814: if (same_unlink(forlist->shell_item) != 0) { ! 815: yyerror("Unexpected second item in special part of do_command"); ! 816: exit(1); ! 817: } ! 818: ! 819: while ((shell_item = value_list) != 0) { ! 820: value_list = same_unlink(shell_item); ! 821: /* Visit each item in commands. For each shell variable which ! 822: * matches ours, replace it with ours. ! 823: */ ! 824: new_commands = same_copy(commands); ! 825: for (visit(new_commands, tmp); !visited(tmp); visit_next(tmp)) { ! 826: tmpstr = tmp->string->string; ! 827: if ((tmpstr[0] == '$') && (tmpstr[1] == '$')) { ! 828: if (strcmp(tmpstr+2, variable_name) == 0) { ! 829: same_replace(tmp, same_copy(shell_item)); ! 830: } ! 831: } ! 832: } ! 833: visit_end(); ! 834: command_list = same_cat(command_list, new_commands); ! 835: } ! 836: return same_cat(command_list, same_copy(newline)); ! 837: } ! 838: ! 839: ! 840: int ! 841: Getchar() ! 842: { ! 843: if (last_saved) { ! 844: last_saved = 0; ! 845: return last_char; ! 846: } else { ! 847: int c; ! 848: c = getchar(); ! 849: switch (c) { ! 850: case '\n': ! 851: lineno++; ! 852: column = 0; ! 853: break; ! 854: default: ! 855: column++; ! 856: } ! 857: return c; ! 858: } ! 859: } ! 860: ! 861: ! 862: int ! 863: token_type(string) ! 864: char *string; ! 865: { ! 866: switch (string[0]) { ! 867: case 'f': ! 868: if (strcmp(string, "for") == 0) { ! 869: return FOR; ! 870: } ! 871: break; ! 872: case 'd': ! 873: if (string[1] == 'o') { ! 874: if (strcmp(string, "do") == 0) { ! 875: return DO; ! 876: } else if (strcmp(string, "done") == 0) { ! 877: return DONE; ! 878: } ! 879: } ! 880: break; ! 881: case 'i': ! 882: if (strcmp(string, "in") == 0) { ! 883: return IN; ! 884: } ! 885: break; ! 886: default: ! 887: break; ! 888: } ! 889: return TOKEN; ! 890: } ! 891: ! 892: ! 893: yylex() ! 894: { ! 895: #define ret_token(c) if (bufptr != buffer) { \ ! 896: save(c); \ ! 897: *bufptr = 0; \ ! 898: bufptr = buffer; \ ! 899: yylval.string = string_lookup(buffer); \ ! 900: return token_type(buffer); \ ! 901: } ! 902: #define save(c) { last_char = c; last_saved = 1; } ! 903: #if defined(YYDEBUG) ! 904: #define Return(c) if (yydebug) { \ ! 905: printf("[%d]", c); \ ! 906: fflush(stdout); \ ! 907: } \ ! 908: yyval.intval = c; \ ! 909: return c; ! 910: #else /* defined(YYDEBUG) */ ! 911: #define Return(y,c) { yylval.intval = c; return y; } ! 912: #endif /* defined(YYDEBUG) */ ! 913: ! 914: ! 915: static char buffer[500], *bufptr = buffer; ! 916: static int eof_found = 0; ! 917: int c; ! 918: ! 919: if (eof_found != 0) { ! 920: eof_found++; ! 921: if (eof_found > 2) { ! 922: fprintf(stderr, "End of file ignored.\n"); ! 923: exit(1); ! 924: } ! 925: Return(EOF,0); ! 926: } ! 927: while ((c = Getchar()) != EOF) { ! 928: switch (c) { ! 929: case '#': ! 930: ret_token(c); ! 931: while (((c = Getchar()) != EOF) && (c != '\n')) { ! 932: ; ! 933: } ! 934: save(c); ! 935: break; ! 936: case '<': ! 937: case '?': ! 938: ret_token(c); ! 939: Return(MACRO_CHAR, c); ! 940: case '\t': ! 941: case ' ': ! 942: ret_token(c); ! 943: Return(WHITE_SPACE, c); ! 944: case '-': ! 945: case '@': ! 946: case ':': ! 947: case ';': ! 948: case '=': ! 949: case '$': ! 950: case '{': ! 951: case '}': ! 952: case '(': ! 953: case ')': ! 954: ret_token(c); ! 955: Return(c,c); ! 956: case '\'': ! 957: case '"': ! 958: if (bufptr != buffer) { ! 959: if (bufptr[-1] == '\\') { ! 960: bufptr[-1] = c; ! 961: } ! 962: break; ! 963: } else { ! 964: int newc; ! 965: ! 966: ret_token(c); ! 967: *bufptr++ = c; ! 968: while (((newc = Getchar()) != EOF) && (newc != c)) { ! 969: *bufptr++ = newc; ! 970: } ! 971: *bufptr++ = c; ! 972: *bufptr = 0; ! 973: bufptr = buffer; ! 974: yylval.string = string_lookup(buffer); ! 975: return QUOTED_STRING; ! 976: } ! 977: case '\n': ! 978: if (bufptr != buffer) { ! 979: if (bufptr[-1] == '\\') { ! 980: bufptr--; ! 981: if ((c = Getchar()) != '\t') { ! 982: yyerror("continuation line doesn't begin with a tab"); ! 983: save(c); ! 984: } ! 985: ret_token(c); ! 986: Return(WHITE_SPACE, c); ! 987: } ! 988: } ! 989: ret_token(c); ! 990: Return(NL, 0); ! 991: default: ! 992: *bufptr++ = c; ! 993: break; ! 994: } ! 995: } ! 996: ! 997: eof_found = 1; ! 998: ! 999: ret_token(' '); ! 1000: Return(EOF, 0); ! 1001: } ! 1002: ! 1003: #ifndef lint ! 1004: static char sccsid[] = "@(#)mkmake.y 4.1 (Berkeley) 12/4/88"; ! 1005: #endif /* not lint */ ! 1006: ! 1007: main() ! 1008: { ! 1009: #define YYDEBUG ! 1010: extern int yydebug; ! 1011: ! 1012: null = same_item(string_lookup("")); ! 1013: newline = same_item(string_lookup("\n")); ! 1014: blank = same_item(string_lookup(" ")); ! 1015: cwd_line = same_cat(same_copy(newline), ! 1016: same_cat(same_item(string_lookup("cd ${CWD}")), ! 1017: same_copy(newline))); ! 1018: ! 1019: yyparse(); ! 1020: ! 1021: do_dump(); ! 1022: ! 1023: return 0; ! 1024: } ! 1025: ! 1026: #if defined(YYDEBUG) ! 1027: dump_same(same) ! 1028: same_t *same; ! 1029: { ! 1030: same_t *same2; ! 1031: ! 1032: for (visit(same, same2); !visited(same2); visit_next(same2)) { ! 1033: printf(same2->string->string); ! 1034: } ! 1035: visit_end(); ! 1036: } ! 1037: #endif /* YYDEBUG */ ! 1038: ! 1039: do_dump() ! 1040: { ! 1041: string_t *string; ! 1042: same_t *same, *same2; ! 1043: ! 1044: if (yydebug > 1) { ! 1045: printf("strings...\n"); ! 1046: for (string = strings; string; string = string->next) { ! 1047: printf("\t%s\n", string->string); ! 1048: } ! 1049: } ! 1050: ! 1051: printf("# variables...\n"); ! 1052: for (visit(variables, same); !visited(same); visit_next(same)) { ! 1053: printf("%s =\t", same->string->string); ! 1054: for (visit(same->value_list, same2); !visited(same2); ! 1055: visit_next(same2)) { ! 1056: printf(same2->string->string); ! 1057: } ! 1058: visit_end(); ! 1059: printf("\n"); ! 1060: } ! 1061: visit_end(); ! 1062: ! 1063: printf("\n\n#targets...\n"); ! 1064: for (visit(targets, same); !visited(same); visit_next(same)) { ! 1065: printf("\n%s:\t", same->string->string); ! 1066: for (visit(same->depend_list, same2); !visited(same2); ! 1067: visit_next(same2)) { ! 1068: printf(same2->string->string); ! 1069: } ! 1070: visit_end(); ! 1071: printf("\n\t"); ! 1072: for (visit(same->action_list, same2); !visited(same2); ! 1073: visit_next(same2)) { ! 1074: printf(same2->string->string); ! 1075: if (same2->string->string[0] == '\n') { ! 1076: printf("\t"); ! 1077: } ! 1078: } ! 1079: visit_end(); ! 1080: printf("\n"); ! 1081: } ! 1082: visit_end(); ! 1083: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.