#include #include /* compile with -DNOFIRST to disable firstset optimization -DFOLLOW_OPT to enable followset optimization NOTE: Followset optimization is not supported when using -s option of LLgen -DDEBUG to print debug information */ extern int LLsymb; extern int LLstartsymb; #if LL_ANSI_C void LLmessage(int); #endif struct stacks { /* Acces to the stacks is through a 'dynamic array' of pointers * to the heads. We implemented it this way to save on the number * of Malloc() calls. nr_heads is the number of heads; heads_buf_size * is the current size of heads_buf. */ int nr_heads; struct stack_elt **heads_buf; int heads_buf_size; /* r_rec contains nonterminals already tried to build a new * stack with, to prevent right-recursive rules making the * process loop forever */ char r_rec[(LLNNONTERMINALS + 7)/8]; /* join_array contains pointers to already substituted stack * elements, so that if the same nonterminal turns up again * we can make a link */ struct stack_elt *join_array[LLNNONTERMINALS]; /* cleanup_buf contains pointerts to elements that can possibly * be deleted. Again this is implemented as a `growing array'. * Although it's not so clean to do it this way, it DOES save * a lot of time, mainly because much less pointer manipulation * is required, and because it's not necessary to deallocate * the buffer after each turn. Just set nr_cleanups to 0... */ int nr_cleanups; int cleanup_buf_size; struct stack_elt **cleanup_buf; /* visited_buf contains pointers to elements whose flags * need to be cleared */ int nr_visited; int visited_buf_size; struct stack_elt **visited_buf; /* start_seen indicates if the last prediction phase * has matched the start symbol */ int start_seen; /* exp_terminals will contain the terminals that are `on top' * of the prediction graph after a prediction phase */ char exp_terminals[LLSETSIZE]; /* check_run_ok indicates whether a stack element can be deleted * or not */ int check_run_ok; }; #ifdef DEBUG static int allocates = 0; static int deallocates = 0; static int max_in_use = 0; static int edge_allocates = 0; static int edge_deallocates = 0; static int edge_max_in_use = 0; #endif static int grammar_index = 0; /* The grammar should only be build the first time we enter the * recovery routine. grammar_read == 0 indicates this has not * been done yet */ static int grammar_read = 0; /* 'terminals' is an array indexed by the number of a terminal and links * all rules containing this terminal in the RHS */ static struct terminal *terminals; /* 'nonterminals' is an array indexed by the number of a nonterminal * and contains all rules with this nonterminal in the LHS and links all * rules containing this nonterminal in the RHS */ static struct nonterminal *nonterminals; /* These functions must be called instead of the original functions in * 'malloc.h'. They offer a checking allocation mechanism. */ #if LL_ANSI_C static char *Malloc(unsigned); static char *Realloc(char*, unsigned); #else static char *Malloc(); static char *Realloc(); #endif /* These functions build the grammar */ #if LL_ANSI_C static void init_grammar(void); static void build_grammar(void); static struct lhs *build_rule(void); static struct symbol *build_rhs(struct lhs*); static struct symbol *make_link(struct symbol*); #else static init_grammar(); static build_grammar(); static struct lhs *build_rule(); static struct symbol *build_rhs(); static struct symbol *make_link(); #endif /* These functions operate on the stacks */ #if LL_ANSI_C static int optimize(struct stacks*, struct symbol*, int); static void read_token(void); static void start_stack(struct stacks*, int, int); static void continuation(struct stacks*, int, int); static struct stack_elt *push_rule(struct stack_elt*, struct symbol*); static void new_head(struct stacks*, struct stack_elt*); static void to_delete(struct stacks*, struct stack_elt*); static void substitute(struct stacks*, struct stack_elt*, int); static int join(struct stacks*, struct stack_elt*, int); static int path(struct stack_elt*, struct stack_elt*); static int part_of_loop(struct stack_elt*); static void generate_heads(struct stacks*, struct stack_elt*, int); static void delete(struct stacks*, struct stack_elt*); static void hyp_run(struct stack_elt*); static void check_run(struct stacks*, struct stack_elt*); static struct stack_elt *split(struct stack_elt*); #ifdef DEBUG static void test(struct stacks*); static void dump_stack(struct stack_elt*, int); #endif static void clear_flags(struct stack_elt*, char); static void clear_gen_flags(struct stacks*); static void match_heads(struct stacks*, int); static void cleanup(struct stacks*); static void initialize(struct stacks*); static void calculate(struct stacks*, int); static void kill_stack(struct stacks *stack); void LLnc_recover(void); #else static int optimize(); static read_token(); static start_stack(); static continuation(); static struct stack_elt *push_rule(); static new_head(); static to_delete(); static substitute(); static int join(); static int path(); static int part_of_loop(); static generate_heads(); static delete(); static hyp_run(); static check_run(); static struct stack_elt *split(); static test(); static dump_stack(); static clear_flags(); static clear_gen_flags(); static match_heads(); static cleanup(); static initialize(); static calculate(); static kill_stack(); LLnc_recover(); #endif #if LL_ANSI_C static char *Malloc(unsigned size) #else static char *Malloc(size) unsigned size; #endif { char *p; if ((p = malloc(size)) == (char *)0) { fprintf(stderr, "fatal error: out of memory\n"); exit(1); } return p; } #if LL_ANSI_C static char *Realloc(char *ptr, unsigned size) #else static char *Realloc(ptr, size) char *ptr; unsigned size; #endif { char *p; if ((p = realloc(ptr, size)) == (char *)0) { fprintf(stderr, "fatal error: out of memory\n"); exit(1); } return p; } #if LL_ANSI_C static void init_grammar(void) #else static init_grammar() #endif { /* Allocate and initialize an array for terminals and nonterminals */ int i; terminals = (struct terminal *) Malloc((unsigned) LLFIRST_NT * sizeof(struct terminal)); for (i = 0; i < LLFIRST_NT; i++) { (terminals + i)->link = (struct symbol *)0; } nonterminals = (struct nonterminal *) Malloc((unsigned)LLNNONTERMINALS * sizeof(struct nonterminal)); for (i = 0; i < LLNNONTERMINALS; i++) { (nonterminals + i)->rule = (struct lhs *)0; (nonterminals + i)->link = (struct symbol *)0; } } #if LL_ANSI_C static void build_grammar(void) #else static build_grammar() #endif { /* Build a rule for every nonterminal. The LHS must be saved first because * of the fact that the right side of an assignment statement (in C) will * be evaluated before the left side */ int nt, j; init_grammar(); for (j = 0; j < LLNNONTERMINALS; j++) { nt = LLgrammar[grammar_index]; (nonterminals + nt - LLFIRST_NT)->rule = build_rule(); } } #if LL_ANSI_C static struct lhs *build_rule(void) #else static struct lhs *build_rule() #endif { /* Build LHS and call a funcion to create RHS */ struct lhs *l; int j; l = (struct lhs *)Malloc(sizeof(struct lhs)); l->nr = LLgrammar[grammar_index++]; /* Build first set */ for (j = 0; j < LLSETSIZE; j++) { l->first[j] = LLgrammar[grammar_index++]; } /* Build follow set */ for (j = 0; j < LLSETSIZE; j++) { l->follow[j] = LLgrammar[grammar_index++]; } l->empty = LLgrammar[grammar_index++]; /* Can NT produce empty? */ l->rhs = build_rhs(l); return l; } #if LL_ANSI_C static struct symbol *build_rhs(struct lhs *l) #else static struct symbol *build_rhs(l) struct lhs *l; #endif { /* Build RHS by creating structs for all symbols including ALT and * EORULE. Also call a function for linking same terminals and * nonterminals. */ struct symbol *r; r = (struct symbol *)Malloc(sizeof(struct symbol)); if (LLgrammar[grammar_index] == LLALT) { grammar_index++; r->x = LLALT; r->nr = -1; /* Not applicable */ r->link = (struct symbol *)0; /* Not applicable */ r->next = build_rhs(l); r->lhs = l; } else if (LLgrammar[grammar_index] == LLEORULE) { grammar_index++; r->x = LLEORULE; r->nr = -1; /* Not applicable */ r->link = (struct symbol *)0; /* Not applicable */ r->next = (struct symbol *)0; /* Not applicable */ r->lhs = l; } else if (LLgrammar[grammar_index] < LLFIRST_NT) { r->x = LLTERMINAL; r->nr = LLgrammar[grammar_index++]; r->link = make_link(r); r->next = build_rhs(l); r->lhs = l; } else { r->x = LLNONTERMINAL; r->nr = LLgrammar[grammar_index++]; r->link = make_link(r); r->next = build_rhs(l); r->lhs = l; } return r; } #if LL_ANSI_C static struct symbol *make_link(struct symbol *r) #else static struct symbol *make_link(r) struct symbol *r; #endif { /* Link same terminals and nonterminals. Every new symbol is appended * in front of the corresponding list for efficiency. */ struct symbol *tmp; if (r->nr < LLFIRST_NT) { /* Terminal array */ tmp = (terminals + r->nr)->link; (terminals + r->nr)->link = r; } else { /* Nonterminal array */ tmp = (nonterminals + (r->nr - LLFIRST_NT))->link; (nonterminals + (r->nr - LLFIRST_NT))->link = r; } return tmp; } /*****************************************************************************/ #if LL_ANSI_C static int optimize(struct stacks* stack, struct symbol *symb_ptr, int l_ahead) #else static int optimize(stack, symb_ptr, l_ahead) struct stacks *stack; struct symbol *symb_ptr; int l_ahead; #endif /* Return 1 if rule symb_ptr can start with terminal l_ahead, else return 0. * The array with expected terminals will also be filled in. */ { struct lhs *l; int i; #ifdef NOFIRST return(1); #else if ((l_ahead <= 0) || (l_ahead == EOFILE)) return 1; switch(symb_ptr->x) { case LLTERMINAL: LLPUTIN(stack->exp_terminals, LLindex[symb_ptr->nr]); if (symb_ptr->nr != l_ahead) return 0; else return 1;/*???*/ case LLNONTERMINAL: l = (nonterminals + symb_ptr->nr - LLFIRST_NT)->rule; if (LLIN(l->first, LLindex[l_ahead])) return 1; else if (l->empty) { /* Try next symbol */ return optimize(stack, symb_ptr->next, l_ahead); } else { for (i = 0; i < LLSETSIZE; i++) { stack->exp_terminals[i] |= (l->first)[i]; } return 0; } default: #ifndef FOLLOW_OPT return(1); #else l = (nonterminals + symb_ptr->lhs->nr - LLFIRST_NT)->rule; if (LLIN(l->follow, LLindex[l_ahead])) return 1; else { for (i = 0; i < LLSETSIZE; i++) { stack->exp_terminals[i] |= (l->follow)[i]; } return 0; } #endif /*FOLLOW_OPT */ } #endif /* NOFIRST */ } #if LL_ANSI_C static void read_token(void) #else static read_token() #endif /* Read token and put it in global variable LLsymb, skipping * invalid tokens */ { LLsymb = LL_LEXI(); while (LLindex[LLsymb] < 0) { /* Skip garbage tokens */ LLmessage(0); LLsymb = LL_LEXI(); } } #if LL_ANSI_C static void start_stack(struct stacks *stack, int base, int l_ahead) #else static start_stack(stack, base, l_ahead) struct stacks *stack; int base, l_ahead; #endif /* Start stack on base symbol base with lookahead l_ahead */ { struct stack_elt *bottom, *top; struct symbol *symb_ptr; int i; /* Find first applicable rule */ symb_ptr = (terminals + base)->link; /* Now try all applicable rules */ while (symb_ptr != (struct symbol *)0) { /* If the current rule cannot start with l_ahead, * try the next one */ if (!optimize(stack, symb_ptr->next, l_ahead)) { symb_ptr = symb_ptr->link; continue; } if ( (symb_ptr->next->x == LLTERMINAL) || (symb_ptr->next->x == LLNONTERMINAL) ) { /* Allocate an end-of-stack */ #ifdef DEBUG allocates++; if (allocates - deallocates > max_in_use) { max_in_use = allocates - deallocates; } #endif bottom = (struct stack_elt *) Malloc(sizeof(struct stack_elt)); bottom->edges = (struct edge *)0; bottom->nr = LLEOSTACK; bottom->flags = 0; bottom->nr_nexts = 0; bottom->ref_count = 0; bottom->hyp_ref_count = -1; /* And use the rule to build a stack on it */ top = push_rule(bottom, symb_ptr->next); /* Remember that we're now trying to match the LHS * of the used rule */ bottom->matched = symb_ptr->lhs->nr; if (top->nr >= LLFIRST_NT) { substitute(stack, top, l_ahead); } else { new_head(stack, top); } /* Perhaps this only has produced an empty stack, in * that case bottom can be deallocated. */ if (bottom->ref_count == 0) { to_delete(stack, bottom); } } else { /* base was the last element of the rule, so we * figure we have matched the LHS of this rule. */ if (symb_ptr->lhs->nr == LLstartsymb) { stack->start_seen = 1; } continuation(stack, symb_ptr->lhs->nr, l_ahead); } symb_ptr = symb_ptr->link; } /* Reinitialize some arrays */ for (i = 0; i < (LLNNONTERMINALS + 7)/8; i++) { stack->r_rec[i] = (char) 0; } for (i = 0; i < LLNNONTERMINALS; i++) { stack->join_array[i] = (struct stack_elt *)0; } /* Delete all HEAD flags */ for (i = 0; i < stack->nr_heads; i++) { (*(stack->heads_buf + i))->flags &= ~LLHEAD; } /* Delete flags turned on by 'generate_heads()' */ clear_gen_flags(stack); /* Try to delete elements on cleanup_buf */ cleanup(stack); } #if LL_ANSI_C static void continuation(struct stacks *stack, int nt, int l_ahead) #else static continuation(stack, nt, l_ahead) struct stacks *stack; int nt, l_ahead; #endif /* We have 'eaten' a whole stack, and think we recognized nt. Now look for rules that we can proceed with, ie containing nt in the RHS. Each rule found will be developed untill a terminal is at the top of the stack.*/ { struct symbol *symb_ptr; struct stack_elt *bottom, *top; /* If we've already tried this nt, don't do it again. * Otherwise we may loop forever on right-recursive rules */ if (LLIN(stack->r_rec, nt - LLFIRST_NT)) return; /* Mark that we have looked for a continuation for nt */ LLPUTIN(stack->r_rec, nt - LLFIRST_NT); /* Find first applicable rule */ symb_ptr = (nonterminals + nt - LLFIRST_NT)->link; /* Try all applicable rules */ while (symb_ptr != (struct symbol *)0) { /* If the current rule cannot start with l_ahead, * try the next one */ if (!optimize(stack, symb_ptr->next, l_ahead)) { symb_ptr = symb_ptr->link; continue; } if ( (symb_ptr->next->x == LLTERMINAL) || (symb_ptr->next->x == LLNONTERMINAL) ) { #ifdef DEBUG allocates++; if (allocates - deallocates > max_in_use) { max_in_use = allocates - deallocates; } #endif bottom = (struct stack_elt *) Malloc(sizeof(struct stack_elt)); bottom->edges = (struct edge *)0; bottom->nr = LLEOSTACK; bottom->flags = 0; bottom->nr_nexts = 0; bottom->ref_count = 0; bottom->hyp_ref_count = -1; /* Use the rule to build a stack on bottom */ top = push_rule(bottom, symb_ptr->next); /* Remember that we're now trying to match the LHS * of the used rule */ bottom->matched = symb_ptr->lhs->nr; if (top->nr >= LLFIRST_NT) { substitute(stack, top, l_ahead); } else { new_head(stack, top); } /* Perhaps this only has produced an empty stack, in * that case bottom can be deallocated. */ if (bottom->ref_count == 0) { delete(stack, bottom); } } else { /* Stack is still empty */ if (symb_ptr->lhs->nr == LLstartsymb) { stack->start_seen = 1; } continuation(stack, symb_ptr->lhs->nr, l_ahead); } symb_ptr = symb_ptr->link; } } #if LL_ANSI_C static struct stack_elt *push_rule(struct stack_elt *element, struct symbol *symb_ptr) #else static struct stack_elt *push_rule(element, symb_ptr) struct stack_elt *element; struct symbol *symb_ptr; #endif /* Append the rule symb_ptr to stack element 'element'. Return a * pointer to the new top of the stack */ { struct stack_elt *se, *top; if ( (symb_ptr->next->x == LLTERMINAL) || (symb_ptr->next->x == LLNONTERMINAL) ) { top = push_rule(element, symb_ptr->next); } else { top = element; } #ifdef DEBUG allocates++; if (allocates - deallocates > max_in_use) { max_in_use = allocates - deallocates; } #endif se = (struct stack_elt *)Malloc(sizeof(struct stack_elt)); se->flags = 0; se->nr = symb_ptr->nr; se->ref_count = 0; se->hyp_ref_count = -1; se->matched = -1; se->nr_nexts = 1; #ifdef DEBUG edge_allocates++; if (edge_allocates - edge_deallocates > edge_max_in_use) { edge_max_in_use = edge_allocates - edge_deallocates; } #endif se->edges = (struct edge *)Malloc(sizeof(struct edge)); se->edges->ptr = top; se->edges->flags = 0; top->ref_count++; return se; } #if LL_ANSI_C static void new_head(struct stacks *stack, struct stack_elt *ptr) #else static new_head(stack, ptr) struct stacks *stack; struct stack_elt *ptr; #endif /* Make ptr a head of stack */ { /* Is this already a head?*/ if (ptr->flags & LLHEAD) return; if (stack->heads_buf_size == 0) { stack->heads_buf_size = LLHEADS_BUF_INCR; stack->heads_buf = (struct stack_elt **) Malloc(LLHEADS_BUF_INCR * sizeof(struct stack_elt *)); } else if (stack->nr_heads == stack->heads_buf_size) { /* buffer full? */ stack->heads_buf_size += LLHEADS_BUF_INCR; stack->heads_buf = (struct stack_elt **) Realloc((char *) stack->heads_buf, (unsigned) stack->heads_buf_size * sizeof(struct stack_elt *) ); } *(stack->heads_buf + stack->nr_heads) = ptr; /* Add at the tail */ stack->nr_heads++; /* Increase number of heads */ ptr->flags |= LLHEAD; /* Mark it as a head */ ptr->ref_count++; /* Increase reference count */ LLPUTIN(stack->exp_terminals, LLindex[ptr->nr]); } #if LL_ANSI_C static void to_delete(struct stacks *stack, struct stack_elt *ptr) #else static to_delete(stack, ptr) struct stacks *stack; struct stack_elt *ptr; #endif /* Remember that ptr has to be deleted */ { int i; #ifdef NOCLEAN return; #endif for (i = 0; i < stack->nr_cleanups; i++) { /* Check if already in buffer */ if (*(stack->cleanup_buf + i) == ptr) return; } if (stack->cleanup_buf_size == 0) { stack->cleanup_buf_size = LLCLEANUP_BUF_INCR; stack->cleanup_buf = (struct stack_elt **) Malloc(LLCLEANUP_BUF_INCR * sizeof(struct stack_elt *)); } else if (stack->nr_cleanups == stack->cleanup_buf_size) { stack->cleanup_buf_size += LLCLEANUP_BUF_INCR; stack->cleanup_buf = (struct stack_elt **) Realloc((char *) stack->cleanup_buf, (unsigned) stack->cleanup_buf_size * sizeof(struct stack_elt *)); } *(stack->cleanup_buf + stack->nr_cleanups) = ptr; stack->nr_cleanups++; } #if LL_ANSI_C static void substitute(struct stacks *stack, struct stack_elt *top, int l_ahead) #else static substitute(stack, top, l_ahead) struct stacks *stack; struct stack_elt *top; int l_ahead; #endif /* This function substitutes the NT pointed to by 'top'. 'top' should be a top * of a stack */ { struct symbol *symb_ptr; struct stack_elt *new_top; /* Try to join top NT */ if (join(stack, top, l_ahead)) return; /* Find RHS of the rule of nonterminal 'top->nr' */ symb_ptr = (nonterminals + top->nr - LLFIRST_NT)->rule->rhs; /* Mark top as dummy */ top->flags |= LLDUMMY; while (1) { /* If this an empty production, search down the stack for * terminals */ if ((symb_ptr->x == LLALT) || (symb_ptr->x == LLEORULE)) { generate_heads(stack, top, l_ahead); } /* Skip other empty productions, they have no effect. */ while (symb_ptr->x == LLALT) { symb_ptr = symb_ptr->next; } if (symb_ptr->x == LLEORULE) { /* If there are only empty productions, the NT on top * can be deleted */ if (top->ref_count == 0) { to_delete(stack, top); } return; } /* If this rule can produce 'l_ahead' on the top of the stack * substitute the nonterminal */ if (optimize(stack, symb_ptr, l_ahead)) { new_top = push_rule(top, symb_ptr); /* If the new element on top is a nonterminal * substitute it, else make it a head */ if (new_top->nr >= LLFIRST_NT) { substitute(stack, new_top, l_ahead); } else { new_head(stack, new_top); } } /* Search to next alternative */ while ( (symb_ptr->x == LLTERMINAL) || (symb_ptr->x == LLNONTERMINAL) ) { symb_ptr = symb_ptr->next; } if (symb_ptr->x == LLEORULE) { if (top->ref_count == 0) { to_delete(stack, top); } return; } else { symb_ptr = symb_ptr->next; } } } #if LL_ANSI_C static int join(struct stacks *stack, struct stack_elt *top, int l_ahead) #else static int join(stack, top, l_ahead) struct stacks *stack; struct stack_elt *top; int l_ahead; #endif /* This function tries to connect a NT on top of a stack with another stack, * which has already substituted this NT */ { struct stack_elt *se; int size; if ( (se = stack->join_array[top->nr - LLFIRST_NT]) == (struct stack_elt *)0 ) { stack->join_array[top->nr - LLFIRST_NT] = top; return 0; /* Join not possible */ } else { se->nr_nexts++; /* Increase number of descendants */ #ifdef DEBUG edge_allocates++; if (edge_allocates - edge_deallocates > edge_max_in_use) { edge_max_in_use = edge_allocates - edge_deallocates; } #endif /* Allocate one more pointer to descendants */ size = se->nr_nexts * sizeof(struct edge); se->edges = (struct edge *)Realloc((char *) se->edges, (unsigned) size); /* Link it */ (se->edges + se->nr_nexts - 1)->ptr = top->edges->ptr; (se->edges + se->nr_nexts - 1)->flags = 0; /* The successor of 'top' gets an extra predecessor. * 'top' has always only one successor because the stacks are * constructed in 'depth first' order */ top->edges->ptr->ref_count++; #ifndef NOLOOPS /* If we have made a new loop find all stack elements of this * loop and mark them */ if (path(top->edges->ptr, se)) { (se->edges + se->nr_nexts - 1)->flags |= LLLOOP; (se->edges + se->nr_nexts - 1)->flags |= LLYES; } clear_flags(top->edges->ptr, (LLNO | LLYES)); #endif /* Check if joined NT produces empty */ if ((nonterminals + se->nr - LLFIRST_NT)->rule->empty) { generate_heads(stack, top, l_ahead); } /* Deallocate top symbol */ if (top->ref_count == 0) { to_delete(stack, top); } return 1; } } #ifndef NOLOOPS #if LL_ANSI_C static int path(struct stack_elt *se1, struct stack_elt *se2) #else static int path(se1, se2) struct stack_elt *se1, *se2; #endif /* LL_ANSI_C */ /* If there is a path from se1 to se2 it returns 1 and marks all the paths * betweeen these two points, otherwise it returns 0. The flags LLYES and * LLNO are used for optimization. */ { int i, result = 0; if (se1 == se2) return 1; for (i = 0; i < se1->nr_nexts; i++) { if ( (!((se1->edges + i)->flags & LLNO)) && (!((se1->edges + i)->flags & LLLOOP_SEARCH)) ) { (se1->edges + i)->flags |= LLLOOP_SEARCH; if (path((se1->edges + i)->ptr, se2)) { (se1->edges + i)->flags |= LLLOOP; result = 1; } else { (se1->edges + i)->flags |= LLNO; } (se1->edges + i)->flags &= ~LLLOOP_SEARCH; } (se1->edges + i)->flags |= LLYES; } return result; } #if LL_ANSI_C static int part_of_loop(struct stack_elt *se) #else static int part_of_loop(se) struct stack_elt *se; #endif /* LL_ANSI_C */ /* Checks if 'se' belongs to a loop */ { int i; for (i = 0; i < se->nr_nexts; i++) { if ((se->edges + i)->flags & LLLOOP) return 1; } return 0; } #endif /* NOLOOPS */ #if LL_ANSI_C static void generate_heads(struct stacks *stack, struct stack_elt *se, int l_ahead) #else static generate_heads(stack, se, l_ahead) struct stacks *stack; struct stack_elt *se; int l_ahead; #endif /* This funcion finds all heads starting at 'se'. */ { int i; struct stack_elt *next_se; for (i = 0; i < se->nr_nexts; i++) { if (!((se->edges + i)->ptr->flags & LLGEN_SEARCH)) { (se->edges + i)->ptr->flags |= LLGEN_SEARCH; next_se = (se->edges + i)->ptr; /* Remember a flag has to be cleared later */ if (stack->visited_buf_size == 0) { stack->visited_buf_size = LL_VIS_INCR; stack->visited_buf = (struct stack_elt **) Malloc(LL_VIS_INCR * sizeof(struct stack_elt *)); } else if (stack->nr_visited == stack->visited_buf_size) { stack->visited_buf_size += LL_VIS_INCR; stack->visited_buf = (struct stack_elt **) Realloc((char *) stack->visited_buf, (unsigned) stack->visited_buf_size * sizeof(struct stack_elt *)); } *(stack->visited_buf + stack->nr_visited) = next_se; stack->nr_visited++; if (next_se->flags & LLDUMMY) { generate_heads(stack, next_se, l_ahead); } else if (next_se->nr == LLEOSTACK) { /* We have matched a nt */ if (next_se->matched == LLstartsymb) { stack->start_seen = 1; } continuation(stack, next_se->matched, l_ahead); if (next_se->ref_count == 0) { to_delete(stack, next_se); } } else if (next_se->nr < LLFIRST_NT) { /* terminal */ new_head(stack, next_se); } else { if (next_se->ref_count > 0) { next_se = split(next_se); } substitute(stack, next_se, l_ahead); } } } } #if LL_ANSI_C static void delete(struct stacks *stack, struct stack_elt *se) #else static delete(stack, se) struct stacks *stack; struct stack_elt *se; #endif /* This function runs down the stack(s) deleting every element which cannot be * reached anymore. */ { int i; #ifdef NOCLEAN return; #endif if (se->ref_count == 0) { /* Decrease reference counts of all successors */ for (i = 0; i < se->nr_nexts; i++) { if ((se->edges + i)->ptr->ref_count != 0) { (se->edges + i)->ptr->ref_count--; /* Try to delete next element */ delete(stack, (se->edges + i)->ptr); } } /* If this element is saved in the join_array clear it */ if (se->nr >= LLFIRST_NT) { if (stack->join_array[se->nr - LLFIRST_NT] == se) { stack->join_array[se->nr - LLFIRST_NT] = (struct stack_elt *)0; } } #ifdef DEBUG deallocates++; edge_deallocates += se->nr_nexts; #endif free((char *) se->edges); free((char *) se); } #ifndef NOLOOPS /* If this element belongs to a loop try to delete it */ else if (part_of_loop(se)) { /* Do a temporary delete */ hyp_run(se); /* Check it */ stack->check_run_ok = 1; check_run(stack, se); /* If it can be deleted delete it */ if (stack->check_run_ok) { se->ref_count = 0; delete(stack, se); } } #endif } #ifndef NOLOOPS #if LL_ANSI_C static void hyp_run(struct stack_elt *se) #else static hyp_run(se) struct stack_elt *se; #endif /* LL_ANSI_C */ /* This function sets the 'hyp_ref_counts' of all elements of the loop that * 'se' belongs to to the value that 'ref_count' will get when 'se' is * deleted */ { int i; struct stack_elt *next_se; for (i = 0; i < se->nr_nexts; i++) { next_se = (se->edges + i)->ptr; if ( (!((se->edges + i)->flags & LLHYP_SEARCH)) && ((se->edges + i)->flags & LLLOOP) ) { (se->edges + i)->flags |= LLHYP_SEARCH; /* If this element is not yet visited initialize * 'hyp_ref_count' else decrease it by one */ if (next_se->hyp_ref_count == -1) { next_se->hyp_ref_count = next_se->ref_count - 1; } else { next_se->hyp_ref_count--; } /* Continue searching */ hyp_run(next_se); } } } #if LL_ANSI_C static void check_run(struct stacks *stack, struct stack_elt *se) #else static check_run(stack, se) struct stacks *stack; struct stack_elt *se; #endif /* LL_ANSI_C */ /* This function checks all 'hyp_ref_counts' that 'hyp_run()' has set. * If one of them is not 0, 'check_run_ok' will be set to 0 indicating * that 'se' cannot be deleted. 'check_run()' also resets all 'hyp_ref_counts' */ { int i; if (se->hyp_ref_count > 0) { stack->check_run_ok = 0; } /* Reset 'hyp_ref_count' */ se->hyp_ref_count = -1; for (i = 0; i < se->nr_nexts; i++) { if ((se->edges + i)->flags & LLHYP_SEARCH) { (se->edges + i)->flags &= ~LLHYP_SEARCH; check_run(stack, (se->edges + i)->ptr); } } } #endif /* NOLOOPS */ #if LL_ANSI_C static struct stack_elt *split(struct stack_elt *se) #else static struct stack_elt *split(se) struct stack_elt *se; #endif /* This function splits of a NT in de stack, and returns a pointer to it */ { struct stack_elt *new_stack; int i; #ifdef DEBUG allocates++; if (allocates - deallocates > max_in_use) { max_in_use = allocates - deallocates; } #endif new_stack = (struct stack_elt *)Malloc(sizeof(struct stack_elt)); new_stack->flags = 0; /* Used by 'clear_gen_flags()' */ new_stack->nr = se->nr; new_stack->ref_count = 0; /* Copy is new top */ new_stack->hyp_ref_count = -1; new_stack->matched = -1; new_stack->nr_nexts = se->nr_nexts; #ifdef DEBUG edge_allocates++; if (edge_allocates - edge_deallocates > edge_max_in_use) { edge_max_in_use = edge_allocates - edge_deallocates; } #endif new_stack->edges = (struct edge *) Malloc((unsigned)se->nr_nexts * sizeof(struct edge)); /* Copy gets the same successors as the original */ memcpy((char *) new_stack->edges, (char *) se->edges, se->nr_nexts * sizeof(struct edge)); /* Each successor gets a new predecessor */ for (i = 0; i < new_stack->nr_nexts; i++) { (new_stack->edges + i)->ptr->ref_count++; (new_stack->edges + i)->flags = 0; } return new_stack; } #ifdef DEBUG #if LL_ANSI_C static void test(struct stacks *stack) #else static test(stack) struct stacks *stack; #endif { struct stack_elt *se; int i; printf("STACKS:\n"); for (i = 0; i < stack->nr_heads; i++) { printf("%2d: ", i + 1); if (*(stack->heads_buf + i) == (struct stack_elt *)0) { printf("NIL\n"); continue; } se = *(stack->heads_buf + i); dump_stack(se, 1); clear_flags(se, PRINT_SEARCH); } } #if LL_ANSI_C static void dump_stack(struct stack_elt *se, int level) #else static dump_stack(se, level) struct stack_elt *se; int level; #endif { int i, j; while (se->nr != LLEOSTACK) { if ((se->flags & LLDUMMY) && (se->nr_nexts > 1)) { printf("[%d] <%d,%d,%d>\n", se->nr, se->ref_count, se->hyp_ref_count, se->flags ); for (j = 0; j < se->nr_nexts; j++) { for (i = 1; i <= level; i++) { printf(" "); } printf("%d: ", j + 1); if (!((se->edges + j)->flags & PRINT_SEARCH)) { printf(" (%d) ", (se->edges + j)->flags); (se->edges + j)->flags |= PRINT_SEARCH; dump_stack((se->edges+j)->ptr,level+1); /*clear_flags((se->edges+j)->ptr,PRINT_SEARCH);*/ } else { printf("LOOP\n"); } } return; } else { if (se->flags & LLDUMMY) { printf("[%d] <%d,%d,%d> ", se->nr,se->ref_count, se->hyp_ref_count, se->flags ); } else { printf("%d <%d,%d,%d> ", se->nr, se->ref_count, se->hyp_ref_count, se->flags ); } if (!(se->edges->flags & PRINT_SEARCH)) { printf(" (%d) ", se->edges->flags); se->edges->flags |= PRINT_SEARCH; se = se->edges->ptr; } else { printf("LOOP\n"); return; } } } printf("\n"); } #endif #if LL_ANSI_C static void clear_flags(struct stack_elt *se, char flag) #else static clear_flags(se, flag) struct stack_elt *se; char flag; #endif /* Clears edge flag 'flag' */ { int i; for (i = 0; i < se->nr_nexts; i++) { if ((se->edges + i)->flags & flag) { (se->edges + i)->flags &= ~flag; /* clear flag */ clear_flags((se->edges + i)->ptr, flag); } } } #if LL_ANSI_C static void clear_gen_flags(struct stacks *stack) #else static clear_gen_flags(stack) struct stacks *stack; #endif { int i; for (i = 0; i < stack->nr_visited; i++) { (*(stack->visited_buf + i))->flags &= ~(LLGEN_SEARCH); } stack->nr_visited = 0; } #if LL_ANSI_C static void match_heads(struct stacks *stack, int symb) #else static match_heads(stack, symb) struct stacks *stack; int symb; #endif /* Match heads_buf against symb, leaving only matching heads, * whilst deallocating the non-matching stacks */ { int i; int old_nr_heads; struct stack_elt **old_heads_buf; /* Copy the 'old' heads */ old_nr_heads = stack->nr_heads; old_heads_buf = stack->heads_buf; /* Set heads in stack to 0 */ stack->nr_heads = 0; stack->heads_buf_size = 0; stack->heads_buf = (struct stack_elt **) 0; for (i = 0; i < old_nr_heads; i++) { if ((*(old_heads_buf + i))->nr != symb) { /* Does not match? */ (*(old_heads_buf + i))->ref_count--; (*(old_heads_buf + i))->flags &= ~LLHEAD; delete(stack, *(old_heads_buf + i)); } else { /* Matches */ if (stack->heads_buf_size == 0) { stack->heads_buf_size = LLHEADS_BUF_INCR; stack->heads_buf = (struct stack_elt **) Malloc((unsigned)stack->heads_buf_size * sizeof(struct stack_elt *)); } else if (stack->nr_heads == stack->heads_buf_size) { stack->heads_buf_size += LLHEADS_BUF_INCR; stack->heads_buf = (struct stack_elt **) Realloc((char *) stack->heads_buf, (unsigned) stack->heads_buf_size * sizeof(struct stack_elt *)); } *(stack->heads_buf + stack->nr_heads) = *(old_heads_buf + i); stack->nr_heads++; } } free((char *) old_heads_buf); } #if LL_ANSI_C static void cleanup(struct stacks *stack) #else static cleanup(stack) struct stacks *stack; #endif /* Deletes all elements in 'cleanup_buf()' */ { int i; for (i = 0; i < stack->nr_cleanups; i++) { delete(stack, *(stack->cleanup_buf + i)); } stack->nr_cleanups = 0; } #if LL_ANSI_C static void initialize(struct stacks *stack) #else static initialize(stack) struct stacks *stack; #endif /* Initializes some variables and arrays */ { int j; stack->nr_heads = 0; stack->heads_buf_size = 0; stack->heads_buf = (struct stack_elt **)0; stack->nr_cleanups = 0; stack->cleanup_buf_size = 0; stack->cleanup_buf = (struct stack_elt **)0; stack->nr_visited = 0; stack->visited_buf_size = 0; stack->visited_buf = (struct stack_elt **)0; for (j = 0; j < (LLNNONTERMINALS + 7)/8; j++) { stack->r_rec[j] = (char) 0; } for (j = 0; j < LLNNONTERMINALS; j++) { stack->join_array[j] = (struct stack_elt *)0; } for (j = 0; j < LLSETSIZE; j++) { stack->exp_terminals[j] = 0; } stack->start_seen = 0; } #if LL_ANSI_C static void calculate(struct stacks *stack, int l_ahead) #else static calculate(stack, l_ahead) struct stacks *stack; int l_ahead; #endif /* This function finds all new heads and deletes the old heads */ { int i; int old_nr_heads; struct stack_elt **old_heads_buf; /* Make a copy of the heads */ old_nr_heads = stack->nr_heads; old_heads_buf = stack->heads_buf; stack->nr_heads = 0; stack->heads_buf = (struct stack_elt **) 0; stack->heads_buf_size = 0; for (i = 0; i < old_nr_heads; i++) { /* Find all new heads */ generate_heads(stack, *(old_heads_buf + i), l_ahead); clear_gen_flags(stack); /* Old head can be deleted now */ (*(old_heads_buf + i))->ref_count--; delete(stack, *(old_heads_buf + i)); } cleanup(stack); free((char *) old_heads_buf); /* Reinitialize some things */ for (i = 0; i < (LLNNONTERMINALS + 7)/8; i++) { stack->r_rec[i] = (char) 0; } for (i = 0; i < LLNNONTERMINALS; i++) { stack->join_array[i] = (struct stack_elt *)0; } /* Delete all HEAD flags */ for (i = 0; i < stack->nr_heads; i++) { (*(stack->heads_buf + i))->flags &= ~LLHEAD; } } #if LL_ANSI_C static void kill_stack(struct stacks *stack) #else static kill_stack(stack) struct stacks *stack; #endif { int i; for (i = 0; i < stack->nr_heads; i++) { (*(stack->heads_buf + i))->ref_count--; delete(stack, *(stack->heads_buf + i)); } } #if LL_ANSI_C void LLnc_recover(void) #else LLnc_recover() #endif /* This function contains the main loop for non correcting syntax error * recovery */ { int j; int base_symb; struct stacks stack; int max_nr_heads; int max_nr_good_heads; initialize(&stack); max_nr_heads = 0; max_nr_good_heads = 0; /* Grammar has to be read only once */ if (!grammar_read) { build_grammar(); grammar_read = 1; } /* Read first token */ read_token(); base_symb = LLsymb; /* Check on end of file */ if ((base_symb <= 0) || (base_symb == EOFILE)) { if ((nonterminals + LLstartsymb - LLFIRST_NT)->rule->empty != 1 ) { LLsymb = EOFILE; LLmessage(0); } kill_stack(&stack); return; } /* Read look ahead token */ read_token(); /* Now search applicable rules and starts the ball rolling */ start_stack(&stack, base_symb, LLsymb); if (stack.nr_heads > max_nr_heads) { max_nr_heads = stack.nr_heads; } /* Only matching heads are needed */ match_heads(&stack, LLsymb); if (stack.nr_heads > max_nr_good_heads) { max_nr_good_heads = stack.nr_heads; } #ifdef DEBUG test(&stack); #endif /* Loop untill end of inputfile */ while ((LLsymb > 0) && (LLsymb != EOFILE)) { /* When entering the loop LLsymb always contains the * symbol that was used as look_ahead to construct the stacks, * or, if optimization is OFF, it contains the symbol with * which the current heads have been matched */ if (stack.nr_heads == 0) { /* No more heads left */ LLmessage(0); /* Restart the whole thing */ initialize(&stack); /* The look-ahead caused the empty stack, don't * use it to start a new one ! */ read_token(); base_symb = LLsymb; /* Check on end of file */ if ((base_symb <= 0) || (base_symb == EOFILE)) { if ((nonterminals + LLstartsymb - LLFIRST_NT)->rule->empty != 1) { LLsymb = EOFILE; LLmessage(0); } kill_stack(&stack); return; } read_token(); start_stack(&stack, base_symb, LLsymb); if (stack.nr_heads > max_nr_heads) { max_nr_heads = stack.nr_heads; } match_heads(&stack, LLsymb); if (stack.nr_heads > max_nr_good_heads) { max_nr_good_heads = stack.nr_heads; } continue; } /* Normal case starts here */ stack.start_seen = 0; for (j = 0; j < LLSETSIZE; j++) { stack.exp_terminals[j] = 0; } /* Read next symbol */ read_token(); /* Generate all new heads and delete old ones */ calculate(&stack, LLsymb); /* Leave out not wanted heads */ if (stack.nr_heads > max_nr_heads) { max_nr_heads = stack.nr_heads; } match_heads(&stack, LLsymb); if (stack.nr_heads > max_nr_good_heads) { max_nr_good_heads = stack.nr_heads; } #ifdef DEBUG test(&stack); #endif } /* End of file reached, check if we have seen a start symbol */ if (stack.start_seen == 1) return; else { LLsymb = EOFILE; LLmessage(0); } kill_stack(&stack); #ifdef DEBUG printf("Maximum number of heads: %d\n", max_nr_heads); printf("Maximum number of good heads: %d\n", max_nr_good_heads); printf("Number of node allocates: %d\n", allocates); printf("Number of node deallocates: %d\n", deallocates); printf("Maximum number of nodes in use: %8d\n", max_in_use); printf("Sizeof(struct stack_elt) = %8d\n", sizeof(struct stack_elt)); printf(" --------x\n"); printf(" %8d\n", max_in_use * sizeof( struct stack_elt)); printf("Number of edge allocates: %d\n", edge_allocates); printf("Number of edge deallocates: %d\n", edge_deallocates); printf("Maximum number of edges in use: %8d\n", edge_max_in_use); printf("Sizeof(struct edge) = %8d\n", sizeof(struct edge)); printf(" --------x\n"); printf(" %8d\n", edge_max_in_use * sizeof(struct edge)); #endif }