1098 lines
20 KiB
Plaintext
1098 lines
20 KiB
Plaintext
%{
|
|
|
|
/*-
|
|
* Copyright (c) 1988, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef lint
|
|
static char sccsid[] = "@(#)mkmake.y 8.1 (Berkeley) 6/6/93";
|
|
#endif /* not lint */
|
|
|
|
typedef struct string {
|
|
int
|
|
hashval,
|
|
length;
|
|
char
|
|
*string;
|
|
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 {
|
|
string_t
|
|
*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 */
|
|
*shell_item; /* If a shell variable, current value */
|
|
} same_t;
|
|
|
|
%}
|
|
|
|
%union {
|
|
string_t *string;
|
|
same_t *same;
|
|
int intval;
|
|
}
|
|
|
|
%start makefile
|
|
%token <string> TOKEN QUOTED_STRING
|
|
%token <intval> FOR IN DO DONE
|
|
%token <intval> MACRO_CHAR NL WHITE_SPACE
|
|
%token <intval> ':' '=' '$' '{' '}' ';' '-' '@' '(' ')' ' ' '\t'
|
|
%type <same> target target1 assignment assign1 actions action
|
|
%type <same> command_list list list_element
|
|
%type <same> for_statement maybe_at_minus tokens token
|
|
%type <same> maybe_white_space
|
|
%type <intval> white_space macro_char
|
|
%%
|
|
|
|
makefile : lines;
|
|
|
|
lines : line
|
|
| lines line
|
|
;
|
|
|
|
line : NL
|
|
| assignment
|
|
| target_action
|
|
;
|
|
|
|
assignment : assign1 tokens NL
|
|
{
|
|
assign($1, $2);
|
|
}
|
|
| assign1 NL
|
|
{
|
|
assign($1, same_copy(null));
|
|
}
|
|
;
|
|
|
|
assign1: token maybe_white_space '=' maybe_white_space
|
|
;
|
|
|
|
target_action: target actions
|
|
{
|
|
add_targets_actions($1, $2);
|
|
}
|
|
| target
|
|
{
|
|
add_targets_actions($1, 0);
|
|
}
|
|
;
|
|
|
|
target : target1 tokens NL
|
|
{
|
|
$$ = add_depends($1, $2);
|
|
}
|
|
| target1 NL
|
|
{
|
|
$$ = add_depends($1, same_copy(null));
|
|
}
|
|
;
|
|
|
|
target1: tokens maybe_white_space ':' maybe_white_space
|
|
{
|
|
$$ = ws_merge($1);
|
|
}
|
|
;
|
|
|
|
actions: action
|
|
| actions action
|
|
{
|
|
$$ = same_cat(same_cat($1, same_copy(newline)), $2);
|
|
}
|
|
;
|
|
|
|
action: white_space command_list NL
|
|
{
|
|
$$ = $2;
|
|
}
|
|
| white_space for_statement do command_list semi_colon done NL
|
|
{
|
|
$$ = do_command($2, $4);
|
|
}
|
|
;
|
|
|
|
for_statement: maybe_at_minus FOR white_space token
|
|
in tokens semi_colon
|
|
{
|
|
$$ = for_statement($1, $4, ws_merge(expand_variables($6, 0)));
|
|
}
|
|
;
|
|
|
|
in: white_space IN white_space
|
|
do: white_space DO white_space
|
|
;
|
|
|
|
done: white_space DONE
|
|
;
|
|
|
|
semi_colon: ';'
|
|
;
|
|
|
|
command_list: list
|
|
| '(' list maybe_white_space ')'
|
|
{
|
|
$$ = same_cat($2, same_copy(cwd_line));
|
|
}
|
|
;
|
|
|
|
list: token
|
|
| list list_element
|
|
{
|
|
$$ = same_cat($1, $2);
|
|
}
|
|
| list white_space list_element
|
|
{
|
|
$$ = same_cat($1, same_cat(same_copy(blank), $3));
|
|
}
|
|
;
|
|
|
|
list_element: token
|
|
| semi_colon
|
|
{
|
|
$$ = same_copy(newline);
|
|
}
|
|
;
|
|
|
|
maybe_at_minus: /* empty */
|
|
{
|
|
$$ = same_copy(null);
|
|
}
|
|
| '@'
|
|
{
|
|
char buffer[2];
|
|
|
|
buffer[0] = $1;
|
|
buffer[1] = 0;
|
|
$$ = same_item(string_lookup(buffer));
|
|
}
|
|
| '-'
|
|
{
|
|
char buffer[2];
|
|
|
|
buffer[0] = $1;
|
|
buffer[1] = 0;
|
|
$$ = same_item(string_lookup(buffer));
|
|
}
|
|
;
|
|
|
|
tokens : token
|
|
| tokens maybe_white_space token
|
|
{
|
|
$$ = same_cat($1, same_cat($2, $3));
|
|
}
|
|
;
|
|
|
|
token: TOKEN
|
|
{
|
|
$$ = 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));
|
|
}
|
|
| '$' '$' TOKEN
|
|
{
|
|
$$ = shell_variable(same_item($3));
|
|
}
|
|
| MACRO_CHAR
|
|
{
|
|
$$ = same_char($1);
|
|
}
|
|
| '$' '{' TOKEN '}'
|
|
{
|
|
$$ = variable(same_item($3));
|
|
}
|
|
| '$' '(' TOKEN ')'
|
|
{
|
|
$$ = variable(same_item($3));
|
|
}
|
|
| '$' TOKEN
|
|
{
|
|
$$ = variable(same_item($2));
|
|
}
|
|
| '-'
|
|
{
|
|
$$ = same_char('-');
|
|
}
|
|
| '@'
|
|
{
|
|
$$ = same_char('@');
|
|
}
|
|
;
|
|
|
|
macro_char: MACRO_CHAR
|
|
| '@'
|
|
;
|
|
|
|
maybe_white_space:
|
|
{
|
|
$$ = same_copy(null);
|
|
}
|
|
| white_space
|
|
{
|
|
$$ = same_char($1);
|
|
}
|
|
;
|
|
|
|
white_space : WHITE_SPACE
|
|
| white_space WHITE_SPACE
|
|
;
|
|
%%
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
|
|
static int last_char, last_saved = 0;
|
|
static int column = 0, lineno = 1;
|
|
|
|
|
|
static string_t
|
|
*strings = 0;
|
|
|
|
static same_t
|
|
*shell_variables = 0,
|
|
*shell_special = 0,
|
|
*variables = 0,
|
|
*targets = 0,
|
|
*actions = 0;
|
|
|
|
static same_t
|
|
*null,
|
|
*blank,
|
|
*cwd_line,
|
|
*newline;
|
|
|
|
extern char *malloc();
|
|
|
|
static unsigned int
|
|
clock = -1;
|
|
|
|
struct {
|
|
same_t *first;
|
|
int next;
|
|
} visit_stack[20]; /* 20 maximum */
|
|
|
|
#define visit(what,via) \
|
|
(visit_stack[++clock].next = 0, visit_stack[clock].first = via = what)
|
|
#define visited(via) (visitcheck(via) || ((via) == 0) \
|
|
|| (visit_stack[clock].next && (via == visit_stack[clock].first)))
|
|
#define visit_next(via) (visit_stack[clock].next = 1, (via) = (via)->nexttoken)
|
|
#define visit_end() (clock--)
|
|
|
|
yyerror(s)
|
|
char *s;
|
|
{
|
|
fprintf(stderr, "line %d, character %d: %s\n", lineno, column, s);
|
|
do_dump();
|
|
}
|
|
|
|
int
|
|
visitcheck(same)
|
|
same_t *same;
|
|
{
|
|
if (same->string == 0) {
|
|
yyerror("BUG - freed 'same' in use...");
|
|
exit(1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
string_hashof(string, length)
|
|
char *string;
|
|
int length;
|
|
{
|
|
register int i = 0;
|
|
|
|
while (length--) {
|
|
i = (i<<3) + *string ^ ((i>>28)&0x7);
|
|
}
|
|
return i;
|
|
}
|
|
|
|
int
|
|
string_same(s1, s2)
|
|
string_t
|
|
*s1, *s2;
|
|
{
|
|
if ((s1->hashval == s2->hashval) && (s1->length == s2->length)
|
|
&& (memcmp(s1->string, s2->string, s1->length) == 0)) {
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
#define same_singleton(s) ((s)->nexttoken == (s))
|
|
|
|
same_t *
|
|
same_search(list, token)
|
|
same_t
|
|
*list,
|
|
*token;
|
|
{
|
|
same_t *ptr;
|
|
|
|
ptr = list;
|
|
for (visit(list, ptr); !visited(ptr); visit_next(ptr)) {
|
|
string_t *string;
|
|
|
|
string = ptr->string;
|
|
if (string_same(string, token->string)) {
|
|
visit_end();
|
|
return ptr;
|
|
}
|
|
}
|
|
visit_end();
|
|
return 0;
|
|
}
|
|
|
|
same_t *
|
|
same_cat(list, tokens)
|
|
same_t
|
|
*list,
|
|
*tokens;
|
|
{
|
|
same_t *last;
|
|
|
|
if (tokens == 0) {
|
|
return list;
|
|
}
|
|
if (list) {
|
|
last = tokens->lasttoken;
|
|
tokens->lasttoken = list->lasttoken;
|
|
list->lasttoken = last;
|
|
tokens->lasttoken->nexttoken = tokens;
|
|
last->nexttoken = list;
|
|
return list;
|
|
} else {
|
|
return tokens;
|
|
}
|
|
}
|
|
|
|
same_t *
|
|
same_item(string)
|
|
string_t *string;
|
|
{
|
|
same_t *ptr;
|
|
|
|
if ((ptr = (same_t *)malloc(sizeof *ptr)) == 0) {
|
|
fprintf(stderr, "No more space for tokens!\n");
|
|
exit(1);
|
|
}
|
|
memset((char *)ptr, 0, sizeof *ptr);
|
|
ptr->nexttoken = ptr->lasttoken = ptr;
|
|
ptr->string = string;
|
|
return ptr;
|
|
}
|
|
|
|
same_t *
|
|
same_copy(same)
|
|
same_t *same;
|
|
{
|
|
same_t *head, *copy;
|
|
|
|
head = 0;
|
|
for (visit(same, copy); !visited(copy); visit_next(copy)) {
|
|
same_t *ptr;
|
|
|
|
ptr = same_item(copy->string);
|
|
head = same_cat(head, ptr);
|
|
}
|
|
visit_end();
|
|
return head;
|
|
}
|
|
|
|
|
|
same_t *
|
|
same_merge(t1, t2)
|
|
same_t
|
|
*t1,
|
|
*t2;
|
|
{
|
|
if (same_singleton(t1) && same_singleton(t2)) {
|
|
int length = strlen(t1->string->string)+strlen(t2->string->string);
|
|
char *buffer = malloc(length+1);
|
|
same_t *value;
|
|
|
|
if (buffer == 0) {
|
|
yyerror("No space to merge strings in same_merge!");
|
|
exit(1);
|
|
}
|
|
strcpy(buffer, t1->string->string);
|
|
strcat(buffer, t2->string->string);
|
|
value = same_item(string_lookup(buffer));
|
|
free(buffer);
|
|
return value;
|
|
} else {
|
|
yyerror("Internal error - same_merge with non-singletons");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
same_free(list)
|
|
same_t *list;
|
|
{
|
|
same_t *token, *ptr;
|
|
|
|
if (list == 0) {
|
|
return;
|
|
}
|
|
|
|
token = list;
|
|
do {
|
|
ptr = token->nexttoken;
|
|
token->string = 0;
|
|
(void) free((char *)token);
|
|
token = ptr;
|
|
} while (token != list);
|
|
}
|
|
|
|
same_t *
|
|
same_unlink(token)
|
|
same_t
|
|
*token;
|
|
{
|
|
same_t *tmp;
|
|
|
|
if (token == 0) {
|
|
return 0;
|
|
}
|
|
if ((tmp = token->nexttoken) == token) {
|
|
tmp = 0;
|
|
}
|
|
token->lasttoken->nexttoken = token->nexttoken;
|
|
token->nexttoken->lasttoken = token->lasttoken;
|
|
token->nexttoken = token->lasttoken = token;
|
|
return tmp;
|
|
}
|
|
|
|
void
|
|
same_replace(old, new)
|
|
same_t
|
|
*old,
|
|
*new;
|
|
{
|
|
new->lasttoken->nexttoken = old->nexttoken;
|
|
old->nexttoken->lasttoken = new->lasttoken;
|
|
new->lasttoken = old->lasttoken;
|
|
/* rather than
|
|
* old->lasttoken->nexttoken = new
|
|
* we update in place (for the case where there isn't anything else)
|
|
*/
|
|
*old = *new;
|
|
}
|
|
|
|
|
|
same_t *
|
|
same_char(ch)
|
|
char ch;
|
|
{
|
|
char buffer[2];
|
|
|
|
buffer[0] = ch;
|
|
buffer[1] = 0;
|
|
|
|
return same_item(string_lookup(buffer));
|
|
}
|
|
|
|
|
|
void
|
|
add_target(target, actions)
|
|
same_t
|
|
*target,
|
|
*actions;
|
|
{
|
|
same_t *ptr;
|
|
|
|
if ((ptr = same_search(targets, target)) == 0) {
|
|
targets = same_cat(targets, target);
|
|
ptr = target;
|
|
} else {
|
|
ptr->depend_list = same_cat(ptr->depend_list, target->depend_list);
|
|
}
|
|
if (actions) {
|
|
if (ptr->action_list) {
|
|
same_free(ptr->action_list);
|
|
}
|
|
ptr->action_list = same_copy(actions);
|
|
}
|
|
}
|
|
|
|
|
|
same_t *
|
|
add_targets_actions(target, actions)
|
|
same_t
|
|
*target,
|
|
*actions;
|
|
{
|
|
same_t *ptr;
|
|
|
|
if (target == 0) {
|
|
return 0;
|
|
}
|
|
do {
|
|
ptr = same_unlink(target);
|
|
add_target(target, actions);
|
|
target = ptr;
|
|
} while (target);
|
|
|
|
same_free(actions);
|
|
return 0;
|
|
}
|
|
|
|
same_t *
|
|
add_depends(target, depends)
|
|
same_t
|
|
*target,
|
|
*depends;
|
|
{
|
|
same_t *original = target;
|
|
|
|
depends = same_cat(depends, same_copy(blank)); /* Separator */
|
|
|
|
for (visit(original, target); !visited(target); visit_next(target)) {
|
|
target->depend_list = same_cat(target->depend_list, same_copy(depends));
|
|
}
|
|
visit_end();
|
|
same_free(depends);
|
|
|
|
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);
|
|
variables = same_unlink(ptr);
|
|
same_free(ptr);
|
|
}
|
|
variable->value_list = value;
|
|
variables = same_cat(variables, variable);
|
|
}
|
|
|
|
same_t *
|
|
value_of(variable)
|
|
same_t *variable;
|
|
{
|
|
same_t *ptr = same_search(variables, variable);
|
|
|
|
if (ptr == 0) {
|
|
return same_copy(null);
|
|
} else {
|
|
return same_copy(ptr->value_list);
|
|
}
|
|
}
|
|
|
|
|
|
same_t *
|
|
expand_variables(token, free)
|
|
same_t *token;
|
|
int free;
|
|
{
|
|
same_t *head = 0;
|
|
|
|
if (!free) {
|
|
token = same_copy(token); /* Get our private copy */
|
|
}
|
|
|
|
while (token) {
|
|
char *string = token->string->string;
|
|
same_t *tmp = same_unlink(token);
|
|
|
|
if ((string[0] == '$') && (string[1] == '{')) { /* Expand time */
|
|
int len = strlen(string);
|
|
|
|
string[len-1] = 0;
|
|
head = same_cat(head, expand_variables(
|
|
value_of(same_item(string_lookup(string+2))), 1));
|
|
string[len-1] = '}';
|
|
} else {
|
|
head = same_cat(head, token);
|
|
}
|
|
token = tmp;
|
|
}
|
|
return head;
|
|
}
|
|
|
|
|
|
same_t *
|
|
ws_merge(list)
|
|
same_t *list;
|
|
{
|
|
same_t *newlist = 0, *item;
|
|
int what = 0;
|
|
|
|
while (list) {
|
|
switch (what) {
|
|
case 0:
|
|
if (isspace(list->string->string[0])) {
|
|
;
|
|
} else {
|
|
item = same_item(list->string);
|
|
what = 1;
|
|
}
|
|
break;
|
|
case 1:
|
|
if (isspace(list->string->string[0])) {
|
|
newlist = same_cat(newlist, item);
|
|
item = 0;
|
|
what = 0;
|
|
} else {
|
|
item = same_merge(item, same_item(list->string));
|
|
what = 1;
|
|
}
|
|
break;
|
|
}
|
|
list = same_unlink(list);
|
|
}
|
|
return same_cat(newlist, item);
|
|
}
|
|
|
|
|
|
same_t *
|
|
variable(var_name)
|
|
same_t *var_name;
|
|
{
|
|
int length = strlen(var_name->string->string);
|
|
same_t *resolved;
|
|
char *newname;
|
|
|
|
if ((newname = malloc(length+1+3)) == 0) {
|
|
fprintf("Out of space for a variable name.\n");
|
|
exit(1);
|
|
}
|
|
newname[0] = '$';
|
|
newname[1] = '{';
|
|
strcpy(newname+2, var_name->string->string);
|
|
strcat(newname, "}");
|
|
resolved = same_item(string_lookup(newname));
|
|
free(newname);
|
|
|
|
return resolved;
|
|
}
|
|
|
|
|
|
same_t *
|
|
shell_variable(var_name)
|
|
same_t *var_name;
|
|
{
|
|
int length = strlen(var_name->string->string);
|
|
same_t *resolved;
|
|
char *newname;
|
|
|
|
if ((newname = malloc(length+1+2)) == 0) {
|
|
fprintf("Out of space for a variable name.\n");
|
|
exit(1);
|
|
}
|
|
newname[0] = '$';
|
|
newname[1] = '$';
|
|
strcpy(newname+2, var_name->string->string);
|
|
resolved = same_item(string_lookup(newname));
|
|
free(newname);
|
|
|
|
return resolved;
|
|
}
|
|
|
|
same_t *
|
|
for_statement(special, variable, list)
|
|
same_t
|
|
*special,
|
|
*variable,
|
|
*list;
|
|
{
|
|
variable->shell_item = special;
|
|
variable->value_list = list;
|
|
return variable;
|
|
}
|
|
|
|
same_t *
|
|
do_command(forlist, commands)
|
|
same_t
|
|
*forlist,
|
|
*commands;
|
|
{
|
|
same_t
|
|
*special,
|
|
*command_list = 0,
|
|
*new_commands,
|
|
*tmp,
|
|
*shell_item,
|
|
*value_list = forlist->value_list;
|
|
char
|
|
*tmpstr,
|
|
*variable_name = forlist->string->string;
|
|
|
|
special = forlist->shell_item;
|
|
if (same_unlink(forlist->shell_item) != 0) {
|
|
yyerror("Unexpected second item in special part of do_command");
|
|
exit(1);
|
|
}
|
|
|
|
while ((shell_item = value_list) != 0) {
|
|
value_list = same_unlink(shell_item);
|
|
/* Visit each item in commands. For each shell variable which
|
|
* matches ours, replace it with ours.
|
|
*/
|
|
new_commands = same_copy(commands);
|
|
for (visit(new_commands, tmp); !visited(tmp); visit_next(tmp)) {
|
|
tmpstr = tmp->string->string;
|
|
if ((tmpstr[0] == '$') && (tmpstr[1] == '$')) {
|
|
if (strcmp(tmpstr+2, variable_name) == 0) {
|
|
same_replace(tmp, same_copy(shell_item));
|
|
}
|
|
}
|
|
}
|
|
visit_end();
|
|
command_list = same_cat(command_list, new_commands);
|
|
}
|
|
return same_cat(command_list, same_copy(newline));
|
|
}
|
|
|
|
|
|
int
|
|
Getchar()
|
|
{
|
|
if (last_saved) {
|
|
last_saved = 0;
|
|
return last_char;
|
|
} else {
|
|
int c;
|
|
c = getchar();
|
|
switch (c) {
|
|
case '\n':
|
|
lineno++;
|
|
column = 0;
|
|
break;
|
|
default:
|
|
column++;
|
|
}
|
|
return c;
|
|
}
|
|
}
|
|
|
|
|
|
int
|
|
token_type(string)
|
|
char *string;
|
|
{
|
|
switch (string[0]) {
|
|
case 'f':
|
|
if (strcmp(string, "for") == 0) {
|
|
return FOR;
|
|
}
|
|
break;
|
|
case 'd':
|
|
if (string[1] == 'o') {
|
|
if (strcmp(string, "do") == 0) {
|
|
return DO;
|
|
} else if (strcmp(string, "done") == 0) {
|
|
return DONE;
|
|
}
|
|
}
|
|
break;
|
|
case 'i':
|
|
if (strcmp(string, "in") == 0) {
|
|
return IN;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return TOKEN;
|
|
}
|
|
|
|
|
|
yylex()
|
|
{
|
|
#define ret_token(c) if (bufptr != buffer) { \
|
|
save(c); \
|
|
*bufptr = 0; \
|
|
bufptr = buffer; \
|
|
yylval.string = string_lookup(buffer); \
|
|
return token_type(buffer); \
|
|
}
|
|
#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[500], *bufptr = buffer;
|
|
static int eof_found = 0;
|
|
int c;
|
|
|
|
if (eof_found != 0) {
|
|
eof_found++;
|
|
if (eof_found > 2) {
|
|
fprintf(stderr, "End of file ignored.\n");
|
|
exit(1);
|
|
}
|
|
Return(EOF,0);
|
|
}
|
|
while ((c = Getchar()) != EOF) {
|
|
switch (c) {
|
|
case '#':
|
|
ret_token(c);
|
|
while (((c = Getchar()) != EOF) && (c != '\n')) {
|
|
;
|
|
}
|
|
save(c);
|
|
break;
|
|
case '<':
|
|
case '?':
|
|
ret_token(c);
|
|
Return(MACRO_CHAR, c);
|
|
case '\t':
|
|
case ' ':
|
|
ret_token(c);
|
|
Return(WHITE_SPACE, c);
|
|
case '-':
|
|
case '@':
|
|
case ':':
|
|
case ';':
|
|
case '=':
|
|
case '$':
|
|
case '{':
|
|
case '}':
|
|
case '(':
|
|
case ')':
|
|
ret_token(c);
|
|
Return(c,c);
|
|
case '\'':
|
|
case '"':
|
|
if (bufptr != buffer) {
|
|
if (bufptr[-1] == '\\') {
|
|
bufptr[-1] = c;
|
|
}
|
|
break;
|
|
} else {
|
|
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--;
|
|
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, 0);
|
|
default:
|
|
*bufptr++ = c;
|
|
break;
|
|
}
|
|
}
|
|
|
|
eof_found = 1;
|
|
|
|
ret_token(' ');
|
|
Return(EOF, 0);
|
|
}
|
|
|
|
main()
|
|
{
|
|
#define YYDEBUG
|
|
extern int yydebug;
|
|
|
|
null = same_item(string_lookup(""));
|
|
newline = same_item(string_lookup("\n"));
|
|
blank = same_item(string_lookup(" "));
|
|
cwd_line = same_cat(same_copy(newline),
|
|
same_cat(same_item(string_lookup("cd ${CWD}")),
|
|
same_copy(newline)));
|
|
|
|
yyparse();
|
|
|
|
do_dump();
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if defined(YYDEBUG)
|
|
dump_same(same)
|
|
same_t *same;
|
|
{
|
|
same_t *same2;
|
|
|
|
for (visit(same, same2); !visited(same2); visit_next(same2)) {
|
|
printf(same2->string->string);
|
|
}
|
|
visit_end();
|
|
}
|
|
#endif /* 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 (visit(variables, same); !visited(same); visit_next(same)) {
|
|
printf("%s =\t", same->string->string);
|
|
for (visit(same->value_list, same2); !visited(same2);
|
|
visit_next(same2)) {
|
|
printf(same2->string->string);
|
|
}
|
|
visit_end();
|
|
printf("\n");
|
|
}
|
|
visit_end();
|
|
|
|
printf("\n\n#targets...\n");
|
|
for (visit(targets, same); !visited(same); visit_next(same)) {
|
|
printf("\n%s:\t", same->string->string);
|
|
for (visit(same->depend_list, same2); !visited(same2);
|
|
visit_next(same2)) {
|
|
printf(same2->string->string);
|
|
}
|
|
visit_end();
|
|
printf("\n\t");
|
|
for (visit(same->action_list, same2); !visited(same2);
|
|
visit_next(same2)) {
|
|
printf(same2->string->string);
|
|
if (same2->string->string[0] == '\n') {
|
|
printf("\t");
|
|
}
|
|
}
|
|
visit_end();
|
|
printf("\n");
|
|
}
|
|
visit_end();
|
|
}
|