From 9b9748d9d16e9dcb9deb4655be4a1d1a386f75c6 Mon Sep 17 00:00:00 2001 From: Gregory Minshall Date: Sun, 21 Jun 1987 16:34:49 -0800 Subject: [PATCH] Before messing around a bit. SCCS-vsn: usr.bin/tn3270/tools/mkmake.y 1.2 --- usr/src/usr.bin/tn3270/tools/mkmake.y | 562 ++++++++++++++++++++------ 1 file changed, 441 insertions(+), 121 deletions(-) diff --git a/usr/src/usr.bin/tn3270/tools/mkmake.y b/usr/src/usr.bin/tn3270/tools/mkmake.y index eb8a765622..b1af178458 100644 --- a/usr/src/usr.bin/tn3270/tools/mkmake.y +++ b/usr/src/usr.bin/tn3270/tools/mkmake.y @@ -9,66 +9,99 @@ typedef struct string { *next; } string_t; +/* + * The deal with these is that they exist on various lists. + * + * First off, they are on a temporary list during the time they + * are in the active focus of the parser. + * + * Secondly, they live on one of three queues: + * 1. Variables + * 2. Targets + * 3. Actions + * (and, we restrict any given one to live on one and only one such list) + * + * Also, they may live on the list of values for someone else's variable, + * or as someone's dependancy. + */ + typedef struct same { - int - myname, - values, /* If a variable, the values */ - action; /* If a target, the action number */ - struct same - *moretokens, - *depends; string_t - *string; + *string; /* My name */ + struct same + *nexttoken, /* Next pointer */ + *lasttoken, /* Back pointer */ + *depend_list, /* If target, dependancies */ + *action_list, /* If target, actions */ + *value_list; /* If variable, value list */ } same_t; -same_t - *add_depends(), - *assign(), - *token_cat(), - *token_item(); %} %union { string_t *string; same_t *same; + int intval; } -%token TOKEN -%token END_OF_FILE NL +%token TOKEN QUOTED_STRING +%token MACRO_CHAR BREAK_CHAR WHITE_SPACE NL END_OF_FILE +%token ':' '=' '$' '{' '}' %type target assignment actions action tokens token +%type special_chars white_space macro_char %% + makefile : lines END_OF_FILE; lines : line | lines line ; -line : NL - | target NL - | assignment NL - | actions NL +line : maybe_white_space NL + | assignment + | target_action ; -target : tokens ':' tokens +assignment : + token maybe_white_space '=' maybe_white_space tokens maybe_white_space NL { - $$ = add_depends($1, $3); + assign($1, $5); + } + | token maybe_white_space '=' maybe_white_space NL + { + assign($1, same_copy(&null)); } ; -assignment : token '=' tokens +target_action: target actions + { + add_targets_actions($1, $2); + } + | target { - $$ = assign($1, $3); + add_targets_actions($1, same_copy(&null)); + } + ; + +target : + tokens maybe_white_space ':' maybe_white_space tokens maybe_white_space NL + { + $$ = add_depends($1, $5); + } + | tokens maybe_white_space ':' maybe_white_space NL + { + $$ = add_depends($1, same_copy(&null)); } ; actions: action | actions action { - $$ = token_cat($1, $2); + $$ = same_cat($1, $2); } ; -action: '\t' tokens +action: white_space tokens NL { $$ = $2; } @@ -77,14 +110,59 @@ action: '\t' tokens tokens : token | tokens token { - $$ = token_cat($1, $2); + $$ = same_cat($1, $2); } ; + token: TOKEN { - $$ = token_item($1); + $$ = same_item($1); + } + | QUOTED_STRING + { + $$ = same_item($1); + } + | '$' macro_char + { + char buffer[3]; + + buffer[0] = '$'; + buffer[1] = $2; + buffer[2] = 0; + + $$ = same_item(string_lookup(buffer)); + } + | special_chars + { + char buffer[2]; + + buffer[0] = $1; + buffer[1] = 0; + + $$ = same_item(string_lookup(buffer)); + } + | '$' '{' token '}' + { + $$ = same_copy(value_of($3)); } ; + +macro_char: MACRO_CHAR + | '$' + ; + +special_chars : BREAK_CHAR + | MACRO_CHAR + | white_space + ; + +maybe_white_space: + | white_space; + +white_space : WHITE_SPACE + | white_space WHITE_SPACE + ; + %% #include @@ -92,66 +170,128 @@ static int last_char, last_saved = 0; static int column = 0, lineno = 1; -static string_t *strings = 0; +static string_t + *strings = 0; +static same_t + variables = { 0 }, + targets = { 0 }, + actions = { 0 }; + static same_t - *variables = 0, - *targets = 0, - *actions = 0; + null = { 0 }, + blank = { 0 }, + newline = { 0 }; extern char *malloc(); -main() +yyerror(s) +char *s; { -#define YYDEBUG - extern int yydebug; + fprintf(stderr, "line %d, character %d: %s\n", lineno, column, s); + do_dump(); +} - return yyparse(); +int +string_hashof(string, length) +char *string; +int length; +{ + register int i = 0; + + while (length--) { + i = (i<<3) + *string ^ ((i>>28)&0x7); + } + return i; } -yyerror(s) -char *s; +int +string_same(s1, s2) +string_t + *s1, *s2; { - fprintf(stderr, "line %d, column %d: %s\n", lineno, column, s); + if ((s1->hashval == s2->hashval) && (s1->length == s2->length) + && (memcmp(s1->string, s2->string, s1->length) == 0)) { + return 1; + } else { + return 0; + } } -same_t * -add_depends(list1, list2) -same_t - *list1, - *list2; +string_t * +string_lookup(string) +char *string; { + string_t ours; + string_t *ptr; + + ours.length = strlen(string); + ours.hashval = string_hashof(string, ours.length); + ours.string = string; + + for (ptr = strings; ptr; ptr = ptr->next) { + if (string_same(&ours, ptr)) { + return ptr; + } + } + if ((ptr = (string_t *)malloc(sizeof *ptr)) == 0) { + fprintf(stderr, "No space to add string *%s*!\n", string); + exit(1); + } + ptr->hashval = ours.hashval; + ptr->length = ours.length; + if ((ptr->string = malloc(ours.length+1)) == 0) { + fprintf(stderr, "No space to add literal *%s*!\n", string); + exit(1); + } + memcpy(ptr->string, string, ours.length+1); + ptr->next = strings; + strings = ptr; + return ptr; } same_t * -assign(variable, value) +same_search(list, token) same_t - *variable, - *value; + *list, + *token; { -} + same_t *ptr; + + for (ptr = list; ptr; ptr = ptr->nexttoken) { + string_t *string; + string = ptr->string; + if (string_same(string, token->string)) { + return ptr; + } + } + return 0; +} same_t * -token_cat(tokens, token) +same_cat(list, tokens) same_t - *tokens, - *token; + *list, + *tokens; { - same_t *ptr; + same_t *last; - if (tokens->moretokens == 0) { - tokens->moretokens = token; + last = tokens->lasttoken; + tokens->lasttoken = list->lasttoken; + list->lasttoken = last; } else { - for (ptr = tokens; ptr->moretokens; ptr = ptr->moretokens) { - ; - } - ptr->moretokens = token; + list->lasttoken = tokens; } - return tokens; + if (list->nexttoken == 0) { + list->nexttoken = tokens; + } else { + tokens->lasttoken->nexttoken = tokens; + } + return list; } same_t * -token_item(string) +same_item(string) string_t *string; { same_t *ptr; @@ -160,12 +300,147 @@ string_t *string; fprintf(stderr, "No more space for tokens!\n"); exit(1); } - + memset((char *)ptr, 0, sizeof *ptr); ptr->string = string; - ptr->moretokens = 0; return ptr; } +same_t * +same_copy(same) +same_t *same; +{ + same_t *head; + + head = same_item(same->string); + for (same = same->nexttoken; same; same = same->nexttoken) { + same_t *ptr; + + ptr = same_item(same->string); + same_cat(head, ptr); + } + return head; +} + +void +same_free(token) +same_t *token; +{ + same_t *ptr; + + while (token) { + ptr = token->nexttoken; + (void) free((char *)token); + token = ptr; + } +} + +void +same_unlink(token, base) +same_t + *token, + *base; +{ + if (token->lasttoken) { + token->lasttoken->nexttoken = token->nexttoken; + } + if (token->nexttoken) { + token->nexttoken->lasttoken = token->lasttoken; + } + if (base->nexttoken == token) { + base->nexttoken = token->nexttoken; + } + if (base->lasttoken == token) { + base->lasttoken = token->lasttoken; + } + (void) free((char *) token); +} + +same_t * +add_target(target) +same_t + *target; +{ + same_t *ptr; + + if ((ptr = same_search(&targets, target)) == 0) { + same_cat(&targets, target); + } else { + same_cat(ptr->action_list, target->action_list); + same_cat(ptr->depend_list, target->depend_list); + } + return 0; +} + +same_t * +add_targets_actions(target, actions) +same_t + *target, + *actions; +{ + same_t *next; + + while (target) { + next = target->lasttoken; + target->lasttoken = target->lasttoken = 0; + target->action_list = actions; + add_target(target); + target= next; + } + return 0; +} + +same_t * +add_depends(target, depends) +same_t + *target, + *depends; +{ + same_t *original = target; + + same_cat(depends, blank); /* Separator */ + + while (target) { + target->depend_list = depends; + target = target->nexttoken; + } + return original; +} + + +/* + * We know that variable is a singleton + */ + +void +assign(variable, value) +same_t + *variable, + *value; +{ + same_t *ptr; + + if ((ptr = same_search(&variables, variable)) != 0) { + same_free(ptr->value_list); + same_unlink(ptr, &variables); + } + variable->value_list = value; + same_cat(&variables, variable); +} + +same_t * +value_of(variable) +same_t *variable; +{ + same_t *ptr = same_search(&variables, variable); + + if (ptr == 0) { + return &null; + } else { + return ptr->value_list; + } +} + + int Getchar() { @@ -187,52 +462,6 @@ Getchar() } } -int -hashof(string, length) -char *string; -int length; -{ - register int i = 0; - - while (length--) { - i = (i<<3) + *string ^ ((i>>28)&0x7); - } - return i; -} - -string_t * -lookup(string) -char *string; -{ - int hashval; - int length = strlen(string); - string_t *ptr; - - hashval = hashof(string, length); - - for (ptr = strings; ptr; ptr = ptr->next) { - if ((ptr->hashval == hashval) && (ptr->length == length)) { - if (memcmp(string, ptr->string, length) == 0) { - return ptr; - } - } - } - if ((ptr = (string_t *)malloc(sizeof *ptr)) == 0) { - fprintf(stderr, "No space to add string *%s*!\n", string); - exit(1); - } - ptr->hashval = hashval; - ptr->length = length; - if ((ptr->string = malloc(length+1)) == 0) { - fprintf(stderr, "No space to add literal *%s*!\n", string); - exit(1); - } - memcpy(ptr->string, string, length+1); - ptr->next = strings; - strings = ptr; - return ptr; -} - yylex() { @@ -240,17 +469,23 @@ yylex() save(c); \ *bufptr = 0; \ bufptr = buffer; \ - yylval.string = lookup(buffer); \ + yylval.string = string_lookup(buffer); \ return TOKEN; \ } #define save(c) { last_char = c; last_saved = 1; } +#if defined(YYDEBUG) #define Return(c) if (yydebug) { \ printf("[%d]", c); \ fflush(stdout); \ } \ + yyval.intval = c; \ return c; +#else /* defined(YYDEBUG) */ +#define Return(y,c) { yylval.intval = c; return y; } +#endif /* defined(YYDEBUG) */ - static char buffer[100], *bufptr = buffer; + + static char buffer[500], *bufptr = buffer; static int eof_found = 0; int c; @@ -260,7 +495,7 @@ yylex() fprintf(stderr, "End of file ignored.\n"); exit(1); } - Return(END_OF_FILE); + Return(END_OF_FILE,0); } while ((c = Getchar()) != EOF) { switch (c) { @@ -271,28 +506,58 @@ yylex() } save(c); break; - case ' ': - ret_token(' '); - break; + case '@': + case '<': + case '?': + ret_token(c); + Return(MACRO_CHAR, c); + case '-': + case '(': + case ')': + case ';': + ret_token(c); + Return(BREAK_CHAR, c); case '\t': + case ' ': ret_token(c); - if (column == 1) { - Return(c); - } - break; + Return(WHITE_SPACE, c); case ':': case '=': + case '$': + case '{': + case '}': ret_token(c); - Return(c); + Return(c,c); + case '\'': + case '"': + { + int newc; + + ret_token(c); + *bufptr++ = c; + while (((newc = Getchar()) != EOF) && (newc != c)) { + *bufptr++ = newc; + } + *bufptr++ = c; + *bufptr = 0; + bufptr = buffer; + yylval.string = string_lookup(buffer); + return QUOTED_STRING; + } case '\n': if (bufptr != buffer) { if (bufptr[-1] == '\\') { bufptr--; - break; + if ((c = Getchar()) != '\t') { + yyerror("continuation line doesn't begin with a tab"); + save(c); + } + ret_token(c); + Return(WHITE_SPACE, c); } } ret_token(c); - Return(NL); + Return(NL, 0); default: *bufptr++ = c; break; @@ -302,5 +567,60 @@ yylex() eof_found = 1; ret_token(' '); - Return(END_OF_FILE); + Return(END_OF_FILE, 0); +} + +main() +{ +#define YYDEBUG + extern int yydebug; + + + null.string = string_lookup(""); + newline.string = string_lookup("\n"); + blank.string = string_lookup(" "); + + return yyparse(); +} + +#if defined(YYDEBUG) +do_dump() +{ + string_t *string; + same_t *same, *same2; + + if (yydebug > 1) { + printf("strings...\n"); + for (string = strings; string; string = string->next) { + printf("\t%s\n", string->string); + } + } + + printf("variables...\n"); + for (same = variables.nexttoken; same; same = same->nexttoken) { + printf("\t%s =\t", same->string->string); + for (same2 = same->value_list; same2; same2 = same2->nexttoken) { + printf(same2->string->string); + } + printf("\n"); + } + + printf("targets...\n"); + for (same = targets.nexttoken; same; same = same->nexttoken) { + printf("\t%s :\t", same->string->string); + for (same2 = same->depend_list; same2; same2 = same2->nexttoken) { + printf(same2->string->string); + } + if (same->action_list) { + printf("\n\t\t"); + for (same2 = same->action_list; same2; same2 = same2->nexttoken) { + printf(same2->string->string); + if (same2->string->string[0] == '\n') { + printf("\t\t"); + } + } + printf("\n"); + } + } } +#endif /* YYDEBUG */ -- 2.20.1