Attachment #898709 for bug #875506

View | Details | Raw Unified | Return to bug 875506
Collapse All | Expand All




static unsigned *EFF;


void set_EFF()
{
    register unsigned *row;
    register int symbol;

}


void set_first_derives()
{
    register unsigned *rrow;
    register unsigned *vrow;

}


void closure(short *nucleus, int n)
short *nucleus;
int n;
{
    register int ruleno;
    register unsigned word;




void finalize_closure()
{
  FREE(itemset);
  FREE(ruleset);


#ifdef	DEBUG

void print_closure(int n)
int n;
{
  register short *isp;


}


void print_EFF()
{
    register int i, j;
    register unsigned *rowp;

}


void print_first_derives()
{
    register int i;
    register int j;




extern short nunused;
extern short final_state;

/* function definitions */

/* closure.c */
void set_EFF();
void set_first_derives();
void closure(short *nucleus, int n);
void finalize_closure();
#ifdef DEBUG
void print_closure(int n);
void print_EFF();
void print_first_derives();
#endif

/* lalr.c */
extern void lalr();
extern void set_state_table();
extern void set_accessing_symbol();
extern void set_shift_table();
extern void set_reduction_table();
extern void set_maxrhs();
extern void initialize_LA();
extern void set_goto_map();
extern int map_goto(int state, int symbol);
extern void initialize_F();
extern void build_relations();
extern void add_lookback_edge(int stateno, int ruleno, int gotono);
extern short **transpose(short **R, int n);
extern void compute_FOLLOWS();
extern void compute_lookaheads();
extern void digraph(short **relation);
extern void traverse(register int i);

/* lr0.c */
extern void allocate_itemsets();
extern void allocate_storage();
extern void append_states();
extern void free_storage();
extern void generate_states();
extern int get_state(int symbol);
extern void initialize_states();
extern void new_itemsets();
extern core *new_state(int symbol);
extern void show_cores();
extern void show_ritems();
extern void show_rrhs();
extern void show_shifts();
extern void save_shifts();
extern void save_reductions();
extern void set_derives();
extern void free_derives();
#ifdef DEBUG
extern void print_derives();
#endif
extern void set_nullable();
extern void free_nullable();
extern void lr0();

/* main.c */
extern void done(int k);
extern void onintr();
extern void set_signals();
extern void usage();
extern void getargs(int argc, char *argv[]);
extern char *allocate(unsigned n);
extern void create_file_names();
extern void open_files();

/* error.c */
extern void fatal(char *msg);
extern void no_space();
extern void open_error(char *filename);
extern void unexpected_EOF();
extern void print_pos(char *st_line, char *st_cptr);
extern void syntax_error(int st_lineno, char *st_line, char *t_cptr);
extern void unterminated_comment(int c_lineno, char *c_line, char *c_cptr);
extern void unterminated_string(int s_lineno, char *s_line, char *s_cptr);
extern void unterminated_text(int t_lineno, char *t_line, char *t_cptr);
extern void unterminated_union(int u_lineno, char *u_line, char *u_cptr);
extern void over_unionized(char *u_cptr);
extern void illegal_tag(int t_lineno, char *t_line, char *t_cptr);
extern void illegal_character(char *c_cptr);
extern void used_reserved(char *s);
extern void tokenized_start(char *s);
extern void retyped_warning(char *s);
extern void reprec_warning(char *s);
extern void revalued_warning(char *s);
extern void terminal_start(char *s);
extern void restarted_warning();
extern void no_grammar();
extern void terminal_lhs(int s_lineno);
extern void prec_redeclared();
extern void unterminated_action(int a_lineno, char *a_line, char *a_cptr);
extern void dollar_warning(int a_lineno, int i);
extern void dollar_error(int a_lineno, char *a_line, char *a_cptr);
extern void untyped_lhs();
extern void untyped_rhs(int i, char *s);
extern void unknown_rhs(int i);
extern void default_action_warning();
extern void undefined_goal(char *s);
extern void undefined_symbol_warning(char *s);

/* mkpar.c */
extern void make_parser();
extern action *parse_actions(register int stateno);
extern action *get_shifts(int stateno);
extern action *add_reductions(int stateno, register action *actions);
extern action *add_reduce(register action *actions, register int ruleno, register int symbol);
extern void find_final_state();
extern void unused_rules();
extern void remove_conflicts();
extern void total_conflicts();
extern int sole_reduction(int stateno);
extern void defreds();
extern void free_action_row(register action *p);
extern void free_parser();


/* output.c */
extern void output();
extern void output_prefix();
extern void output_rule_data();
extern void output_yydefred();
extern void output_actions();
extern void token_actions();
extern void goto_actions();
extern int default_goto(int symbol);
extern void save_column(int symbol, int default_state);
extern void sort_actions();
extern void pack_table();
extern int matching_vector(int vector);
extern int pack_vector(int vector);
extern void output_base();
extern void output_table();
extern void output_check();
extern int is_C_identifier(char *name);
extern void output_defines();
extern void output_stored_text();
extern void output_debug();
extern void output_stype();
extern void output_trailing_text();
extern void output_semantic_actions();
extern void free_itemsets();
extern void free_shifts();
extern void free_reductions();


/* reader.c */
extern void cachec(int c);
extern void get_line();
extern char *dup_line();
extern void skip_comment();
extern int nextc();
extern int keyword();
extern void copy_ident();
extern void copy_text();
extern void copy_union();
extern int hexval(int c);
extern bucket *get_literal();
extern int is_reserved(char *name);
extern bucket *get_name();
extern int get_number();
extern char *get_tag();
extern void declare_tokens(int assoc);
extern void declare_types();
extern void declare_start();
extern void read_declarations();
extern void initialize_grammar();
extern void expand_items();
extern void expand_rules();
extern void advance_to_start();
extern void start_rule(register bucket *bp, int s_lineno);
extern void end_rule();
extern void insert_empty_rule();
extern void add_symbol();
extern void copy_action();
extern int mark_symbol();
extern void read_grammar();
extern void free_tags();
extern void pack_names();
extern void check_symbols();
extern void pack_symbols();
extern void pack_grammar();
extern void print_grammar();
extern void reader();

/* skeleton.c */
extern void write_section(char *section[]);

/* symtab.c */
extern int hash(char *name);
extern bucket *make_bucket(char *name);
extern bucket *lookup(char *name);
extern void create_symbol_table();
extern void free_symbol_table();
extern void free_symbols();

/* verbose.c */
extern void verbose();
extern void log_unused();
extern void log_conflicts();
extern void print_state(int state);
extern void print_conflicts(int state);
extern void print_core(int state);
extern void print_nulls(int state);
extern void print_actions(int stateno);
extern void print_shifts(register action *p);
extern void print_reductions(register action *p, register int defred);
extern void print_gotos(int stateno);

/* warshall.c */
extern void transitive_closure(unsigned *R, int n);
extern void reflexive_transitive_closure(unsigned *R, int n);

/* system variables */





#include "defs.h"


void fatal(char *msg)
char *msg;
{
    fprintf(stderr, "%s: f - %s\n", myname, msg);
    done(2);
}


void no_space()
{
    fprintf(stderr, "%s: f - out of space\n", myname);
    done(2);
}


void open_error(char *filename)
char *filename;
{
    fprintf(stderr, "%s: f - cannot open \"%s\"\n", myname, filename);
    done(2);
}


void unexpected_EOF()
{
    fprintf(stderr, "%s: e - line %d of \"%s\", unexpected end-of-file\n",
	    myname, lineno, input_file_name);

}


void print_pos(char *st_line, char *st_cptr)
char *st_line;
char *st_cptr;
{
    register char *s;


}


void syntax_error(int st_lineno, char *st_line, char *st_cptr)
int st_lineno;
char *st_line;
char *st_cptr;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", syntax error\n",
	    myname, st_lineno, input_file_name);

}


void unterminated_comment(int c_lineno, char *c_line, char *c_cptr)
int c_lineno;
char *c_line;
char *c_cptr;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", unmatched /*\n",
	    myname, c_lineno, input_file_name);

    done(1);
}

void unterminated_string(int s_lineno, char *s_line, char *s_cptr)
unterminated_string(s_lineno, s_line, s_cptr)
int s_lineno;
char *s_line;
char *s_cptr;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", unterminated string\n",
	    myname, s_lineno, input_file_name);

}


void unterminated_text(int t_lineno, char *t_line, char *t_cptr)
int t_lineno;
char *t_line;
char *t_cptr;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", unmatched %%{\n",
	    myname, t_lineno, input_file_name);

}


void unterminated_union(int u_lineno, char *u_line, char *u_cptr)
int u_lineno;
char *u_line;
char *u_cptr;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", unterminated %%union \
declaration\n", myname, u_lineno, input_file_name);

}


void over_unionized(char *u_cptr)
char *u_cptr;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", too many %%union \
declarations\n", myname, lineno, input_file_name);

}


void illegal_tag(int t_lineno, char *t_line, char *t_cptr)
int t_lineno;
char *t_line;
char *t_cptr;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", illegal tag\n",
	    myname, t_lineno, input_file_name);

}


void illegal_character(char *c_cptr)
char *c_cptr;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", illegal character\n",
	    myname, lineno, input_file_name);

}


void used_reserved(char *s)
char *s;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", illegal use of reserved symbol \
%s\n", myname, lineno, input_file_name, s);

}


void tokenized_start(char *s)
char *s;
{
     fprintf(stderr, "%s: e - line %d of \"%s\", the start symbol %s cannot be \
declared to be a token\n", myname, lineno, input_file_name, s);

}


void retyped_warning(char *s)
char *s;
{
    fprintf(stderr, "%s: w - line %d of \"%s\", the type of %s has been \
redeclared\n", myname, lineno, input_file_name, s);
}


void reprec_warning(char *s)
char *s;
{
    fprintf(stderr, "%s: w - line %d of \"%s\", the precedence of %s has been \
redeclared\n", myname, lineno, input_file_name, s);
}


void revalued_warning(char *s)
char *s;
{
    fprintf(stderr, "%s: w - line %d of \"%s\", the value of %s has been \
redeclared\n", myname, lineno, input_file_name, s);
}


void terminal_start(char *s)
char *s;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", the start symbol %s is a \
token\n", myname, lineno, input_file_name, s);

}


void restarted_warning()
{
    fprintf(stderr, "%s: w - line %d of \"%s\", the start symbol has been \
redeclared\n", myname, lineno, input_file_name);
}


void no_grammar()
{
    fprintf(stderr, "%s: e - line %d of \"%s\", no grammar has been \
specified\n", myname, lineno, input_file_name);

}


void terminal_lhs(int s_lineno)
int s_lineno;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", a token appears on the lhs \
of a production\n", myname, s_lineno, input_file_name);

}


void prec_redeclared()
{
    fprintf(stderr, "%s: w - line %d of  \"%s\", conflicting %%prec \
specifiers\n", myname, lineno, input_file_name);
}


void unterminated_action(int a_lineno, char *a_line, char *a_cptr)
int a_lineno;
char *a_line;
char *a_cptr;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", unterminated action\n",
	    myname, a_lineno, input_file_name);

}


void dollar_warning(int a_lineno, int i)
int a_lineno;
int i;
{
    fprintf(stderr, "%s: w - line %d of \"%s\", $%d references beyond the \
end of the current rule\n", myname, a_lineno, input_file_name, i);
}


void dollar_error(int a_lineno, char *a_line, char *a_cptr)
int a_lineno;
char *a_line;
char *a_cptr;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", illegal $-name\n",
	    myname, a_lineno, input_file_name);

}


void untyped_lhs()
{
    fprintf(stderr, "%s: e - line %d of \"%s\", $$ is untyped\n",
	    myname, lineno, input_file_name);

}


void untyped_rhs(int i, char *s)
int i;
char *s;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", $%d (%s) is untyped\n",
	    myname, lineno, input_file_name, i, s);

}


void unknown_rhs(int i)
int i;
{
    fprintf(stderr, "%s: e - line %d of \"%s\", $%d is untyped\n",
	    myname, lineno, input_file_name, i);

}


void default_action_warning()
{
    fprintf(stderr, "%s: w - line %d of \"%s\", the default action assigns an \
undefined value to $$\n", myname, lineno, input_file_name);
}


void undefined_goal(char *s)
char *s;
{
    fprintf(stderr, "%s: e - the start symbol %s is undefined\n", myname, s);
    done(1);
}


void undefined_symbol_warning(char *s)
char *s;
{
    fprintf(stderr, "%s: w - the symbol %s is undefined\n", myname, s);
}




static int top;


void lalr()
{
    tokensetsize = WORDSIZE(ntokens);





void set_state_table()
{
    register core *sp;





void set_accessing_symbol()
{
    register core *sp;





void set_shift_table()
{
    register shifts *sp;





void set_reduction_table()
{
    register reductions *rp;





void set_maxrhs()
{
  register short *itemp;
  register short *item_end;




void initialize_LA()
{
  register int i, j, k;
  register reductions *rp;

}


void set_goto_map()
{
  register shifts *sp;
  register int i;


/*  Map_goto maps a state/symbol pair into its numeric representation.	*/

int map_goto(int state, int symbol)
map_goto(state, symbol)
int state;
int symbol;
{
    register int high;
    register int low;




void initialize_F()
{
  register int i;
  register int j;




void build_relations()
{
  register int i;
  register int j;

}


void add_lookback_edge(int stateno, int ruleno, int gotono)
int stateno, ruleno, gotono;
{
    register int i, k;
    register int found;




short **transpose(short **R, int n)
transpose(R, n)
short **R;
int n;
{
  register short **new_R;
  register short **temp_R;




void compute_FOLLOWS()
{
  digraph(includes);
}


void compute_lookaheads()
{
  register int i, n;
  register unsigned *fp1, *fp2, *fp3;

}


void digraph(short **relation)
short **relation;
{
  register int i;





void traverse(register int i)
register int i;
{
  register unsigned *fp1;
  register unsigned *fp2;




static short *kernel_items;


void allocate_itemsets()
{
    register short *itemp;
    register short *item_end;

}


void allocate_storage()
{
    allocate_itemsets();
    shiftset = NEW2(nsyms, short);

}


void append_states()
{
    register int i;
    register int j;

}


void free_storage()
{
    FREE(shift_symbol);
    FREE(redset);




void generate_states()
{
    allocate_storage();
    itemset = NEW2(nitems, short);




int get_state(int symbol)
get_state(symbol)
int symbol;
{
    register int key;
    register short *isp1;




void initialize_states()
{
    register int i;
    register short *start_derives;

}


void new_itemsets()
{
    register int i;
    register int shiftcount;




core *new_state(int symbol)
new_state(symbol)
int symbol;
{
    register int n;
    register core *p;


/* show_cores is used for debugging */

void show_cores()
{
    core *p;
    int i, j, k, n;


/* show_ritems is used for debugging */

void show_ritems()
{
    int i;




/* show_rrhs is used for debugging */
void show_rrhs()
{
    int i;



/* show_shifts is used for debugging */

void show_shifts()
{
    shifts *p;
    int i, j, k;

}


void save_shifts()
{
    register shifts *p;
    register short *sp1;




void save_reductions()
{
    register short *isp;
    register short *rp1;

}


void set_derives()
{
    register int i, k;
    register int lhs;

#endif
}

void free_derives()
{
    FREE(derives[start_symbol]);
    FREE(derives);
}

#ifdef	DEBUG
void print_derives()
{
    register int i;
    register short *sp;

#endif


void set_nullable()
{
    register int i, j;
    register int empty;

}


void free_nullable()
{
    FREE(nullable);
}


void lr0()
{
    set_derives();
    set_nullable();




#endif /* not lint */

#include <signal.h>
#include <unistd.h>
#include "defs.h"

char dflag;

extern char *getenv();


void done(int k)
int k;
{
    if (action_file) { fclose(action_file); unlink(action_file_name); }
    if (text_file) { fclose(text_file); unlink(text_file_name); }

}


void onintr()
onintr()
{
    done(1);
}


void set_signals()
{
#ifdef SIGINT
    if (signal(SIGINT, SIG_IGN) != SIG_IGN)

}


void usage()
{
    fprintf(stderr, "usage: %s [-dlrtv] [-b file_prefix] [-p symbol_prefix] filename\n", myname);
    exit(1);
}


void getargs(int argc, char *argv[])
int argc;
char *argv[];
{
    register int i;
    register char *s;

}


char *allocate(unsigned n)
allocate(n)
unsigned n;
{
    register char *p;


}


void create_file_names()
{
    int i, len;
    char *tmpdir;

}


void open_files()
{
    create_file_names();


}


int main(int argc, char *argv[])
main(argc, argv)
int argc;
char *argv[];
{
    set_signals();
    getargs(argc, argv);




extern action *add_reduce();


void make_parser()
{
    register int i;


}


action *parse_actions(register int stateno)
parse_actions(stateno)
register int stateno;
{
    register action *actions;


}


action *get_shifts(int stateno)
get_shifts(stateno)
int stateno;
{
    register action *actions, *temp;
    register shifts *sp;

    return (actions);
}

action *add_reductions(int stateno, register action *actions)
add_reductions(stateno, actions)
int stateno;
register action *actions;
{
    register int i, j, m, n;
    register int ruleno, tokensetsize;

}


action *add_reduce(register action *actions, register int ruleno, register int symbol)
add_reduce(actions, ruleno, symbol)
register action *actions;
register int ruleno, symbol;
{
    register action *temp, *prev, *next;


}


void find_final_state()
{
    register int goal, i;
    register short *to_state;

}


void unused_rules()
{
    register int i;
    register action *p;

}


void remove_conflicts()
{
    register int i;
    register int symbol;

}


void total_conflicts()
{
    fprintf(stderr, "%s: ", myname);
    if (SRtotal == 1)

}


int sole_reduction(int stateno)
sole_reduction(stateno)
int stateno;
{
    register int count, ruleno;
    register action *p;

}


void defreds()
{
    register int i;


    for (i = 0; i < nstates; i++)
	defred[i] = sole_reduction(i);
}

void free_action_row(register action *p)
register action *p;
{
  register action *q;


    }
}

void free_parser()
{
  register int i;





static int high;


void output()
{
    free_itemsets();
    free_shifts();

}


void output_prefix()
{
    if (symbol_prefix == NULL)
	symbol_prefix = "yy";

}


void output_rule_data()
{
    register int i;
    register int j;

}


void output_yydefred()
{
    register int i, j;


}


void output_actions()
{
    nvectors = 2*nstates + nvars;


}


void token_actions()
{
    register int i, j;
    register int shiftcount, reducecount;

    FREE(actionrow);
}

void goto_actions()
{
    register int i, j, k;


    FREE(state_count);
}

int default_goto(int symbol)
default_goto(symbol)
int symbol;
{
    register int i;
    register int m;




void save_column(int symbol, int default_state)
int symbol;
int default_state;
{
    register int i;
    register int m;

    width[symno] = sp1[-1] - sp[0] + 1;
}

void sort_actions()
{
  register int i;
  register int j;

}


void pack_table()
{
    register int i;
    register int place;

/*  faster.  Also, it depends on the vectors being in a specific	*/
/*  order.								*/

int matching_vector(int vector)
matching_vector(vector)
int vector;
{
    register int i;
    register int j;




int pack_vector(int vector)
pack_vector(vector)
int vector;
{
    register int i, j, k, l;
    register int t;




void output_base()
{
    register int i, j;





void output_table()
{
    register int i;
    register int j;




void output_check()
{
    register int i;
    register int j;

}


int is_C_identifier(char *name)
is_C_identifier(name)
char *name;
{
    register char *s;
    register int c;

}


void output_defines()
{
    register int c, i;
    register char *s;

}


void output_stored_text()
{
    register int c;
    register FILE *in, *out;

}


void output_debug()
{
    register int i, j, k, max;
    char **symnam, *s;

}


void output_stype()
{
    if (!unionized && ntags == 0)
    {

}


void output_trailing_text()
{
    register int c, last;
    register FILE *in, *out;

}


void output_semantic_actions()
{
    register int c, last;
    register FILE *out;

}


void free_itemsets()
{
    register core *cp, *next;


}


void free_shifts()
{
    register shifts *sp, *next;





void free_reductions()
{
    register reductions *rp, *next;





char line_format[] = "#line %d \"%s\"\n";


void cachec(int c)
int c;
{
    assert(cinc >= 0);
    if (cinc >= cache_size)

}


void get_line()
{
    register FILE *f = input_file;
    register int c;

}


char *dup_line()
dup_line()
{
    register char *p, *s, *t;


}


void skip_comment()
{
    register char *s;


}


int nextc()
nextc()
{
    register char *s;


}


int keyword()
keyword()
{
    register int c;
    char *t_cptr = cptr;

}


void copy_ident()
{
    register int c;
    register FILE *f = output_file;

}


void copy_text()
{
    register int c;
    int quote;

}


void copy_union()
{
    register int c;
    int quote;

}


int hexval(int c)
hexval(c)
int c;
{
    if (c >= '0' && c <= '9')
	return (c - '0');

}


bucket *get_literal()
get_literal()
{
    register int c, quote;
    register int i;

}


int is_reserved(char *name)
is_reserved(name)
char *name;
{
    char *s;


}


bucket *get_name()
get_name()
{
    register int c;


}


int get_number()
get_number()
{
    register int c;
    register int n;

}


char *get_tag()
get_tag()
{
    register int c;
    register int i;

}


void declare_tokens(int assoc)
int assoc;
{
    register int c;
    register bucket *bp;

}


void declare_types()
{
    register int c;
    register bucket *bp;

}


void declare_start()
{
    register int c;
    register bucket *bp;

}


void read_declarations()
{
    register int c, k;


}


void initialize_grammar()
{
    nitems = 4;
    maxitems = 300;

}


void expand_items()
{
    maxitems += 300;
    pitem = (bucket **) REALLOC(pitem, maxitems*sizeof(bucket *));

}


void expand_rules()
{
    maxrules += 100;
    plhs = (bucket **) REALLOC(plhs, maxrules*sizeof(bucket *));

}


void advance_to_start()
{
    register int c;
    register bucket *bp;

}


void start_rule(register bucket *bp, int s_lineno)
register bucket *bp;
int s_lineno;
{
    if (bp->class == TERM)
	terminal_lhs(s_lineno);

}


void end_rule()
{
    register int i;


}


void insert_empty_rule()
{
    register bucket *bp, **bpp;


}


void add_symbol()
{
    register int c;
    register bucket *bp;

}


void copy_action()
{
    register int c;
    register int i, n;

}


int mark_symbol()
mark_symbol()
{
    register int c;
    register bucket *bp;

}


void read_grammar()
{
    register int c;


}


void free_tags()
{
    register int i;


}


void pack_names()
{
    register bucket *bp;
    register char *p, *s, *t;

}


void check_symbols()
{
    register bucket *bp;


}


void pack_symbols()
{
    register bucket *bp;
    register bucket **v;

}


void pack_grammar()
{
    register int i, j;
    int assoc, prec;

}


void print_grammar()
{
    register int i, j, k;
    int spacing;

}


void reader()
{
    write_section(banner);
    create_symbol_table();

Lines 299-306 Link Here

(-)yacc-1.9.1-orig/skeleton.c (-2 / +1 lines)
299	};	299	};
300		300
301		301
302	write_section(section)	302	void write_section(char *section[])
303	char *section[];
304	{	303	{
305	register int c;	304	register int c;
306	register int i;	305	register int i;




bucket *last_symbol;


int hash(char *name)
hash(name)
char *name;
{
    register char *s;
    register int c, k;

}


bucket *make_bucket(char *name)
make_bucket(name)
char *name;
{
    register bucket *bp;


}


bucket *lookup(char *name)
lookup(name)
char *name;
{
    register bucket *bp, **bpp;


}


void create_symbol_table()
{
    register int i;
    register bucket *bp;

}


void free_symbol_table()
{
    FREE(symbol_table);
    symbol_table = 0;
}


void free_symbols()
{
    register bucket *p, *q;






static short *null_rules;

void verbose()
{
    register int i;


}


void log_unused()
{
    register int i;
    register short *p;

}


void log_conflicts()
{
    register int i;


}


void print_state(int state)
int state;
{
    if (state)
	fprintf(verbose_file, "\n\n");

}


void print_conflicts(int state)
int state;
{
    register int symbol, act, number;
    register action *p;

}


void print_core(int state)
int state;
{
    register int i;
    register int k;

}


void print_nulls(int state)
int state;
{
    register action *p;
    register int i, j, k, nnulls;

}


void print_actions(int stateno)
int stateno;
{
    register action *p;
    register shifts *sp;

}


void print_shifts(register action *p)
register action *p;
{
    register int count;
    register action *q;

}


void print_reductions(register action *p, register int defred)
register action *p;
register int defred;
{
    register int k, anyreds;
    register action *q;

}


void print_gotos(int stateno)
int stateno;
{
    register int i, k;
    register int as;





#include "defs.h"

void transitive_closure(unsigned *R, int n)
unsigned *R;
int n;
{
    register int rowsize;
    register unsigned i;

    }
}

void reflexive_transitive_closure(unsigned *R, int n)
unsigned *R;
int n;
{
    register int rowsize;
    register unsigned i;

Return to bug 875506

Lines 12-18 Link Here

(-)yacc-1.9.1-orig/closure.c (-10 / +7 lines)
12	static unsigned *EFF;	12	static unsigned *EFF;
13		13
14		14
15	set_EFF()	15	void set_EFF()
16	{	16	{
17	register unsigned *row;	17	register unsigned *row;
18	register int symbol;	18	register int symbol;
Lines 48-54 Link Here
48	}	48	}
49		49
50		50
51	set_first_derives()	51	void set_first_derives()
52	{	52	{
53	register unsigned *rrow;	53	register unsigned *rrow;
54	register unsigned *vrow;	54	register unsigned *vrow;
Lines 103-111 Link Here
103	}	103	}
104		104
105		105
106	closure(nucleus, n)	106	void closure(short *nucleus, int n)
107	short *nucleus;
108	int n;
109	{	107	{
110	register int ruleno;	108	register int ruleno;
111	register unsigned word;	109	register unsigned word;
Lines 173-179 Link Here
173		171
174		172
175		173
176	finalize_closure()	174	void finalize_closure()
177	{	175	{
178	FREE(itemset);	176	FREE(itemset);
179	FREE(ruleset);	177	FREE(ruleset);
Lines 183-190 Link Here
183		181
184	#ifdef DEBUG	182	#ifdef DEBUG
185		183
186	print_closure(n)	184	void print_closure(int n)
187	int n;
188	{	185	{
189	register short *isp;	186	register short *isp;
190		187
Lines 194-200 Link Here
194	}	191	}
195		192
196		193
197	print_EFF()	194	void print_EFF()
198	{	195	{
199	register int i, j;	196	register int i, j;
200	register unsigned *rowp;	197	register unsigned *rowp;
Lines 225-231 Link Here
225	}	222	}
226		223
227		224
228	print_first_derives()	225	void print_first_derives()
229	{	226	{
230	register int i;	227	register int i;
231	register int j;	228	register int j;

Lines 38-44 Link Here

(-)yacc-1.9.1-orig/lalr.c (-26 / +17 lines)
38	static int top;	38	static int top;
39		39
40		40
41	lalr()	41	void lalr()
42	{	42	{
43	tokensetsize = WORDSIZE(ntokens);	43	tokensetsize = WORDSIZE(ntokens);
44		44
Lines 57-63 Link Here
57		57
58		58
59		59
60	set_state_table()	60	void set_state_table()
61	{	61	{
62	register core *sp;	62	register core *sp;
63		63
Lines 68-74 Link Here
68		68
69		69
70		70
71	set_accessing_symbol()	71	void set_accessing_symbol()
72	{	72	{
73	register core *sp;	73	register core *sp;
74		74
Lines 79-85 Link Here
79		79
80		80
81		81
82	set_shift_table()	82	void set_shift_table()
83	{	83	{
84	register shifts *sp;	84	register shifts *sp;
85		85
Lines 90-96 Link Here
90		90
91		91
92		92
93	set_reduction_table()	93	void set_reduction_table()
94	{	94	{
95	register reductions *rp;	95	register reductions *rp;
96		96
Lines 101-107 Link Here
101		101
102		102
103		103
104	set_maxrhs()	104	void set_maxrhs()
105	{	105	{
106	register short *itemp;	106	register short *itemp;
107	register short *item_end;	107	register short *item_end;
Lines 129-135 Link Here
129		129
130		130
131		131
132	initialize_LA()	132	void initialize_LA()
133	{	133	{
134	register int i, j, k;	134	register int i, j, k;
135	register reductions *rp;	135	register reductions *rp;
Lines 166-172 Link Here
166	}	166	}
167		167
168		168
169	set_goto_map()	169	void set_goto_map()
170	{	170	{
171	register shifts *sp;	171	register shifts *sp;
172	register int i;	172	register int i;
Lines 235-244 Link Here
235		235
236	/* Map_goto maps a state/symbol pair into its numeric representation. */	236	/* Map_goto maps a state/symbol pair into its numeric representation. */
237		237
238	int	238	int map_goto(int state, int symbol)
239	map_goto(state, symbol)
240	int state;
241	int symbol;
242	{	239	{
243	register int high;	240	register int high;
244	register int low;	241	register int low;
Lines 264-270 Link Here
264		261
265		262
266		263
267	initialize_F()	264	void initialize_F()
268	{	265	{
269	register int i;	266	register int i;
270	register int j;	267	register int j;
Lines 341-347 Link Here
341		338
342		339
343		340
344	build_relations()	341	void build_relations()
345	{	342	{
346	register int i;	343	register int i;
347	register int j;	344	register int j;
Lines 433-440 Link Here
433	}	430	}
434		431
435		432
436	add_lookback_edge(stateno, ruleno, gotono)	433	void add_lookback_edge(int stateno, int ruleno, int gotono)
437	int stateno, ruleno, gotono;
438	{	434	{
439	register int i, k;	435	register int i, k;
440	register int found;	436	register int found;
Lines 460-469 Link Here
460		456
461		457
462		458
463	short **	459	short transpose(short R, int n)
464	transpose(R, n)
465	short **R;
466	int n;
467	{	460	{
468	register short **new_R;	461	register short **new_R;
469	register short **temp_R;	462	register short **temp_R;
Lines 518-530 Link Here
518		511
519		512
520		513
521	compute_FOLLOWS()	514	void compute_FOLLOWS()
522	{	515	{
523	digraph(includes);	516	digraph(includes);
524	}	517	}
525		518
526		519
527	compute_lookaheads()	520	void compute_lookaheads()
528	{	521	{
529	register int i, n;	522	register int i, n;
530	register unsigned fp1, fp2, *fp3;	523	register unsigned fp1, fp2, *fp3;
Lines 558-565 Link Here
558	}	551	}
559		552
560		553
561	digraph(relation)	554	void digraph(short **relation)
562	short **relation;
563	{	555	{
564	register int i;	556	register int i;
565		557
Lines 585-592 Link Here
585		577
586		578
587		579
588	traverse(i)	580	void traverse(register int i)
589	register int i;
590	{	581	{
591	register unsigned *fp1;	582	register unsigned *fp1;
592	register unsigned *fp2;	583	register unsigned *fp2;

Lines 33-39 Link Here

(-)yacc-1.9.1-orig/lr0.c (-25 / +21 lines)
33	static short *kernel_items;	33	static short *kernel_items;
34		34
35		35
36	allocate_itemsets()	36	void allocate_itemsets()
37	{	37	{
38	register short *itemp;	38	register short *itemp;
39	register short *item_end;	39	register short *item_end;
Lines 75-81 Link Here
75	}	75	}
76		76
77		77
78	allocate_storage()	78	void allocate_storage()
79	{	79	{
80	allocate_itemsets();	80	allocate_itemsets();
81	shiftset = NEW2(nsyms, short);	81	shiftset = NEW2(nsyms, short);
Lines 84-90 Link Here
84	}	84	}
85		85
86		86
87	append_states()	87	void append_states()
88	{	88	{
89	register int i;	89	register int i;
90	register int j;	90	register int j;
Lines 113-119 Link Here
113	}	113	}
114		114
115		115
116	free_storage()	116	void free_storage()
117	{	117	{
118	FREE(shift_symbol);	118	FREE(shift_symbol);
119	FREE(redset);	119	FREE(redset);
Lines 126-132 Link Here
126		126
127		127
128		128
129	generate_states()	129	void generate_states()
130	{	130	{
131	allocate_storage();	131	allocate_storage();
132	itemset = NEW2(nitems, short);	132	itemset = NEW2(nitems, short);
Lines 153-161 Link Here
153		153
154		154
155		155
156	int	156	int get_state(int symbol)
157	get_state(symbol)
158	int symbol;
159	{	157	{
160	register int key;	158	register int key;
161	register short *isp1;	159	register short *isp1;
Lines 218-224 Link Here
218		216
219		217
220		218
221	initialize_states()	219	void initialize_states()
222	{	220	{
223	register int i;	221	register int i;
224	register short *start_derives;	222	register short *start_derives;
Lines 245-251 Link Here
245	}	243	}
246		244
247		245
248	new_itemsets()	246	void new_itemsets()
249	{	247	{
250	register int i;	248	register int i;
251	register int shiftcount;	249	register int shiftcount;
Lines 281-289 Link Here
281		279
282		280
283		281
284	core *	282	core *new_state(int symbol)
285	new_state(symbol)
286	int symbol;
287	{	283	{
288	register int n;	284	register int n;
289	register core *p;	285	register core *p;
Lines 322-328 Link Here
322		318
323	/* show_cores is used for debugging */	319	/* show_cores is used for debugging */
324		320
325	show_cores()	321	void show_cores()
326	{	322	{
327	core *p;	323	core *p;
328	int i, j, k, n;	324	int i, j, k, n;
Lines 357-363 Link Here
357		353
358	/* show_ritems is used for debugging */	354	/* show_ritems is used for debugging */
359		355
360	show_ritems()	356	void show_ritems()
361	{	357	{
362	int i;	358	int i;
363		359
Lines 367-373 Link Here
367		363
368		364
369	/* show_rrhs is used for debugging */	365	/* show_rrhs is used for debugging */
370	show_rrhs()	366	void show_rrhs()
371	{	367	{
372	int i;	368	int i;
373		369
Lines 378-384 Link Here
378		374
379	/* show_shifts is used for debugging */	375	/* show_shifts is used for debugging */
380		376
381	show_shifts()	377	void show_shifts()
382	{	378	{
383	shifts *p;	379	shifts *p;
384	int i, j, k;	380	int i, j, k;
Lines 396-402 Link Here
396	}	392	}
397		393
398		394
399	save_shifts()	395	void save_shifts()
400	{	396	{
401	register shifts *p;	397	register shifts *p;
402	register short *sp1;	398	register short *sp1;
Lines 430-436 Link Here
430		426
431		427
432		428
433	save_reductions()	429	void save_reductions()
434	{	430	{
435	register short *isp;	431	register short *isp;
436	register short *rp1;	432	register short *rp1;
Lines 479-485 Link Here
479	}	475	}
480		476
481		477
482	set_derives()	478	void set_derives()
483	{	479	{
484	register int i, k;	480	register int i, k;
485	register int lhs;	481	register int lhs;
Lines 509-522 Link Here
509	#endif	505	#endif
510	}	506	}
511		507
512	free_derives()	508	void free_derives()
513	{	509	{
514	FREE(derives[start_symbol]);	510	FREE(derives[start_symbol]);
515	FREE(derives);	511	FREE(derives);
516	}	512	}
517		513
518	#ifdef DEBUG	514	#ifdef DEBUG
519	print_derives()	515	void print_derives()
520	{	516	{
521	register int i;	517	register int i;
522	register short *sp;	518	register short *sp;
Lines 538-544 Link Here
538	#endif	534	#endif
539		535
540		536
541	set_nullable()	537	void set_nullable()
542	{	538	{
543	register int i, j;	539	register int i, j;
544	register int empty;	540	register int empty;
Lines 587-599 Link Here
587	}	583	}
588		584
589		585
590	free_nullable()	586	void free_nullable()
591	{	587	{
592	FREE(nullable);	588	FREE(nullable);
593	}	589	}
594		590
595		591
596	lr0()	592	void lr0()
597	{	593	{
598	set_derives();	594	set_derives();
599	set_nullable();	595	set_nullable();

Lines 3-8 Link Here

(-)yacc-1.9.1-orig/main.c (-18 / +10 lines)
3	#endif /* not lint */	3	#endif /* not lint */
4		4
5	#include <signal.h>	5	#include <signal.h>
		6	#include <unistd.h>
6	#include "defs.h"	7	#include "defs.h"
7		8
8	char dflag;	9	char dflag;
Lines 65-72 Link Here
65	extern char *getenv();	66	extern char *getenv();
66		67
67		68
68	done(k)	69	void done(int k)
69	int k;
70	{	70	{
71	if (action_file) { fclose(action_file); unlink(action_file_name); }	71	if (action_file) { fclose(action_file); unlink(action_file_name); }
72	if (text_file) { fclose(text_file); unlink(text_file_name); }	72	if (text_file) { fclose(text_file); unlink(text_file_name); }
Lines 75-88 Link Here
75	}	75	}
76		76
77		77
78	void	78	void onintr()
79	onintr()
80	{	79	{
81	done(1);	80	done(1);
82	}	81	}
83		82
84		83
85	set_signals()	84	void set_signals()
86	{	85	{
87	#ifdef SIGINT	86	#ifdef SIGINT
88	if (signal(SIGINT, SIG_IGN) != SIG_IGN)	87	if (signal(SIGINT, SIG_IGN) != SIG_IGN)
Lines 99-114 Link Here
99	}	98	}
100		99
101		100
102	usage()	101	void usage()
103	{	102	{
104	fprintf(stderr, "usage: %s [-dlrtv] [-b file_prefix] [-p symbol_prefix] filename\n", myname);	103	fprintf(stderr, "usage: %s [-dlrtv] [-b file_prefix] [-p symbol_prefix] filename\n", myname);
105	exit(1);	104	exit(1);
106	}	105	}
107		106
108		107
109	getargs(argc, argv)	108	void getargs(int argc, char *argv[])
110	int argc;
111	char *argv[];
112	{	109	{
113	register int i;	110	register int i;
114	register char *s;	111	register char *s;
Lines 211-219 Link Here
211	}	208	}
212		209
213		210
214	char *	211	char *allocate(unsigned n)
215	allocate(n)
216	unsigned n;
217	{	212	{
218	register char *p;	213	register char *p;
219		214
Lines 227-233 Link Here
227	}	222	}
228		223
229		224
230	create_file_names()	225	void create_file_names()
231	{	226	{
232	int i, len;	227	int i, len;
233	char *tmpdir;	228	char *tmpdir;
Lines 310-316 Link Here
310	}	305	}
311		306
312		307
313	open_files()	308	void open_files()
314	{	309	{
315	create_file_names();	310	create_file_names();
316		311
Lines 361-370 Link Here
361	}	356	}
362		357
363		358
364	int	359	int main(int argc, char *argv[])
365	main(argc, argv)
366	int argc;
367	char *argv[];
368	{	360	{
369	set_signals();	361	set_signals();
370	getargs(argc, argv);	362	getargs(argc, argv);

Lines 23-29 Link Here

(-)yacc-1.9.1-orig/mkpar.c (-27 / +14 lines)
23	extern action *add_reduce();	23	extern action *add_reduce();
24		24
25		25
26	make_parser()	26	void make_parser()
27	{	27	{
28	register int i;	28	register int i;
29		29
Lines 39-47 Link Here
39	}	39	}
40		40
41		41
42	action *	42	action *parse_actions(register int stateno)
43	parse_actions(stateno)
44	register int stateno;
45	{	43	{
46	register action *actions;	44	register action *actions;
47		45
Lines 51-59 Link Here
51	}	49	}
52		50
53		51
54	action *	52	action *get_shifts(int stateno)
55	get_shifts(stateno)
56	int stateno;
57	{	53	{
58	register action actions, temp;	54	register action actions, temp;
59	register shifts *sp;	55	register shifts *sp;
Lines 86-95 Link Here
86	return (actions);	82	return (actions);
87	}	83	}
88		84
89	action *	85	action add_reductions(int stateno, register action actions)
90	add_reductions(stateno, actions)
91	int stateno;
92	register action *actions;
93	{	86	{
94	register int i, j, m, n;	87	register int i, j, m, n;
95	register int ruleno, tokensetsize;	88	register int ruleno, tokensetsize;
Lines 112-121 Link Here
112	}	105	}
113		106
114		107
115	action *	108	action add_reduce(register action actions, register int ruleno, register int symbol)
116	add_reduce(actions, ruleno, symbol)
117	register action *actions;
118	register int ruleno, symbol;
119	{	109	{
120	register action temp, prev, *next;	110	register action temp, prev, *next;
121		111
Lines 153-159 Link Here
153	}	143	}
154		144
155		145
156	find_final_state()	146	void find_final_state()
157	{	147	{
158	register int goal, i;	148	register int goal, i;
159	register short *to_state;	149	register short *to_state;
Lines 170-176 Link Here
170	}	160	}
171		161
172		162
173	unused_rules()	163	void unused_rules()
174	{	164	{
175	register int i;	165	register int i;
176	register action *p;	166	register action *p;
Lines 202-208 Link Here
202	}	192	}
203		193
204		194
205	remove_conflicts()	195	void remove_conflicts()
206	{	196	{
207	register int i;	197	register int i;
208	register int symbol;	198	register int symbol;
Lines 277-283 Link Here
277	}	267	}
278		268
279		269
280	total_conflicts()	270	void total_conflicts()
281	{	271	{
282	fprintf(stderr, "%s: ", myname);	272	fprintf(stderr, "%s: ", myname);
283	if (SRtotal == 1)	273	if (SRtotal == 1)
Lines 297-305 Link Here
297	}	287	}
298		288
299		289
300	int	290	int sole_reduction(int stateno)
301	sole_reduction(stateno)
302	int stateno;
303	{	291	{
304	register int count, ruleno;	292	register int count, ruleno;
305	register action *p;	293	register action *p;
Lines 326-332 Link Here
326	}	314	}
327		315
328		316
329	defreds()	317	void defreds()
330	{	318	{
331	register int i;	319	register int i;
332		320
Lines 334-342 Link Here
334	for (i = 0; i < nstates; i++)	322	for (i = 0; i < nstates; i++)
335	defred[i] = sole_reduction(i);	323	defred[i] = sole_reduction(i);
336	}	324	}
337		325
338	free_action_row(p)	326	void free_action_row(register action *p)
339	register action *p;
340	{	327	{
341	register action *q;	328	register action *q;
342		329
Lines 348-354 Link Here
348	}	335	}
349	}	336	}
350		337
351	free_parser()	338	void free_parser()
352	{	339	{
353	register int i;	340	register int i;
354		341

Lines 271-282 Link Here

(-)yacc-1.9.1-orig/defs.h (-4 / +210 lines)
271	extern short nunused;	271	extern short nunused;
272	extern short final_state;	272	extern short final_state;
273		273
274	/* global functions */	274	/* function definitions */
275		275
276	extern char *allocate();	276	/* closure.c */
277	extern bucket *lookup();	277	void set_EFF();
278	extern bucket *make_bucket();	278	void set_first_derives();
		279	void closure(short *nucleus, int n);
		280	void finalize_closure();
		281	#ifdef DEBUG
		282	void print_closure(int n);
		283	void print_EFF();
		284	void print_first_derives();
		285	#endif
279		286
		287	/* lalr.c */
		288	extern void lalr();
		289	extern void set_state_table();
		290	extern void set_accessing_symbol();
		291	extern void set_shift_table();
		292	extern void set_reduction_table();
		293	extern void set_maxrhs();
		294	extern void initialize_LA();
		295	extern void set_goto_map();
		296	extern int map_goto(int state, int symbol);
		297	extern void initialize_F();
		298	extern void build_relations();
		299	extern void add_lookback_edge(int stateno, int ruleno, int gotono);
		300	extern short transpose(short R, int n);
		301	extern void compute_FOLLOWS();
		302	extern void compute_lookaheads();
		303	extern void digraph(short **relation);
		304	extern void traverse(register int i);
		305
		306	/* lr0.c */
		307	extern void allocate_itemsets();
		308	extern void allocate_storage();
		309	extern void append_states();
		310	extern void free_storage();
		311	extern void generate_states();
		312	extern int get_state(int symbol);
		313	extern void initialize_states();
		314	extern void new_itemsets();
		315	extern core *new_state(int symbol);
		316	extern void show_cores();
		317	extern void show_ritems();
		318	extern void show_rrhs();
		319	extern void show_shifts();
		320	extern void save_shifts();
		321	extern void save_reductions();
		322	extern void set_derives();
		323	extern void free_derives();
		324	#ifdef DEBUG
		325	extern void print_derives();
		326	#endif
		327	extern void set_nullable();
		328	extern void free_nullable();
		329	extern void lr0();
		330
		331	/* main.c */
		332	extern void done(int k);
		333	extern void onintr();
		334	extern void set_signals();
		335	extern void usage();
		336	extern void getargs(int argc, char *argv[]);
		337	extern char *allocate(unsigned n);
		338	extern void create_file_names();
		339	extern void open_files();
		340
		341	/* error.c */
		342	extern void fatal(char *msg);
		343	extern void no_space();
		344	extern void open_error(char *filename);
		345	extern void unexpected_EOF();
		346	extern void print_pos(char st_line, char st_cptr);
		347	extern void syntax_error(int st_lineno, char st_line, char t_cptr);
		348	extern void unterminated_comment(int c_lineno, char c_line, char c_cptr);
		349	extern void unterminated_string(int s_lineno, char s_line, char s_cptr);
		350	extern void unterminated_text(int t_lineno, char t_line, char t_cptr);
351	extern void unterminated_union(int u_lineno, char u_line, char u_cptr);
352	extern void over_unionized(char *u_cptr);
353	extern void illegal_tag(int t_lineno, char t_line, char t_cptr);
354	extern void illegal_character(char *c_cptr);
355	extern void used_reserved(char *s);
356	extern void tokenized_start(char *s);
357	extern void retyped_warning(char *s);
358	extern void reprec_warning(char *s);
359	extern void revalued_warning(char *s);
360	extern void terminal_start(char *s);
361	extern void restarted_warning();
362	extern void no_grammar();
363	extern void terminal_lhs(int s_lineno);
364	extern void prec_redeclared();
365	extern void unterminated_action(int a_lineno, char a_line, char a_cptr);
366	extern void dollar_warning(int a_lineno, int i);
367	extern void dollar_error(int a_lineno, char a_line, char a_cptr);
368	extern void untyped_lhs();
369	extern void untyped_rhs(int i, char *s);
370	extern void unknown_rhs(int i);
371	extern void default_action_warning();
372	extern void undefined_goal(char *s);
373	extern void undefined_symbol_warning(char *s);
374
375	/* mkpar.c */
376	extern void make_parser();
377	extern action *parse_actions(register int stateno);
378	extern action *get_shifts(int stateno);
379	extern action add_reductions(int stateno, register action actions);
380	extern action add_reduce(register action actions, register int ruleno, register int symbol);
381	extern void find_final_state();
382	extern void unused_rules();
383	extern void remove_conflicts();
384	extern void total_conflicts();
385	extern int sole_reduction(int stateno);
386	extern void defreds();
387	extern void free_action_row(register action *p);
388	extern void free_parser();
389
390
391	/* output.c */
392	extern void output();
393	extern void output_prefix();
394	extern void output_rule_data();
395	extern void output_yydefred();
396	extern void output_actions();
397	extern void token_actions();
398	extern void goto_actions();
399	extern int default_goto(int symbol);
400	extern void save_column(int symbol, int default_state);
401	extern void sort_actions();
402	extern void pack_table();
403	extern int matching_vector(int vector);
404	extern int pack_vector(int vector);
405	extern void output_base();
406	extern void output_table();
407	extern void output_check();
408	extern int is_C_identifier(char *name);
409	extern void output_defines();
410	extern void output_stored_text();
411	extern void output_debug();
412	extern void output_stype();
413	extern void output_trailing_text();
414	extern void output_semantic_actions();
415	extern void free_itemsets();
416	extern void free_shifts();
417	extern void free_reductions();
418
419
420	/* reader.c */
421	extern void cachec(int c);
422	extern void get_line();
423	extern char *dup_line();
424	extern void skip_comment();
425	extern int nextc();
426	extern int keyword();
427	extern void copy_ident();
428	extern void copy_text();
429	extern void copy_union();
430	extern int hexval(int c);
431	extern bucket *get_literal();
432	extern int is_reserved(char *name);
433	extern bucket *get_name();
434	extern int get_number();
435	extern char *get_tag();
436	extern void declare_tokens(int assoc);
437	extern void declare_types();
438	extern void declare_start();
439	extern void read_declarations();
440	extern void initialize_grammar();
441	extern void expand_items();
442	extern void expand_rules();
443	extern void advance_to_start();
444	extern void start_rule(register bucket *bp, int s_lineno);
445	extern void end_rule();
446	extern void insert_empty_rule();
447	extern void add_symbol();
448	extern void copy_action();
449	extern int mark_symbol();
450	extern void read_grammar();
451	extern void free_tags();
452	extern void pack_names();
453	extern void check_symbols();
454	extern void pack_symbols();
455	extern void pack_grammar();
456	extern void print_grammar();
457	extern void reader();
458
459	/* skeleton.c */
460	extern void write_section(char *section[]);
461
462	/* symtab.c */
463	extern int hash(char *name);
464	extern bucket make_bucket(char name);
465	extern bucket lookup(char name);
466	extern void create_symbol_table();
467	extern void free_symbol_table();
468	extern void free_symbols();
469
470	/* verbose.c */
471	extern void verbose();
472	extern void log_unused();
473	extern void log_conflicts();
474	extern void print_state(int state);
475	extern void print_conflicts(int state);
476	extern void print_core(int state);
477	extern void print_nulls(int state);
478	extern void print_actions(int stateno);
479	extern void print_shifts(register action *p);
480	extern void print_reductions(register action *p, register int defred);
481	extern void print_gotos(int stateno);
482
483	/* warshall.c */
484	extern void transitive_closure(unsigned *R, int n);
485	extern void reflexive_transitive_closure(unsigned *R, int n);
280		486
281	/* system variables */	487	/* system variables */
282		488

Lines 7-36 Link Here

(-)yacc-1.9.1-orig/error.c (-77 / +32 lines)
7	#include "defs.h"	7	#include "defs.h"
8		8
9		9
10	fatal(msg)	10	void fatal(char *msg)
11	char *msg;
12	{	11	{
13	fprintf(stderr, "%s: f - %s\n", myname, msg);	12	fprintf(stderr, "%s: f - %s\n", myname, msg);
14	done(2);	13	done(2);
15	}	14	}
16		15
17		16
18	no_space()	17	void no_space()
19	{	18	{
20	fprintf(stderr, "%s: f - out of space\n", myname);	19	fprintf(stderr, "%s: f - out of space\n", myname);
21	done(2);	20	done(2);
22	}	21	}
23		22
24		23
25	open_error(filename)	24	void open_error(char *filename)
26	char *filename;
27	{	25	{
28	fprintf(stderr, "%s: f - cannot open \"%s\"\n", myname, filename);	26	fprintf(stderr, "%s: f - cannot open \"%s\"\n", myname, filename);
29	done(2);	27	done(2);
30	}	28	}
31		29
32		30
33	unexpected_EOF()	31	void unexpected_EOF()
34	{	32	{
35	fprintf(stderr, "%s: e - line %d of \"%s\", unexpected end-of-file\n",	33	fprintf(stderr, "%s: e - line %d of \"%s\", unexpected end-of-file\n",
36	myname, lineno, input_file_name);	34	myname, lineno, input_file_name);
Lines 38-46 Link Here
38	}	36	}
39		37
40		38
41	print_pos(st_line, st_cptr)	39	void print_pos(char st_line, char st_cptr)
42	char *st_line;
43	char *st_cptr;
44	{	40	{
45	register char *s;	41	register char *s;
46		42
Lines 65-74 Link Here
65	}	61	}
66		62
67		63
68	syntax_error(st_lineno, st_line, st_cptr)	64	void syntax_error(int st_lineno, char st_line, char st_cptr)
69	int st_lineno;
70	char *st_line;
71	char *st_cptr;
72	{	65	{
73	fprintf(stderr, "%s: e - line %d of \"%s\", syntax error\n",	66	fprintf(stderr, "%s: e - line %d of \"%s\", syntax error\n",
74	myname, st_lineno, input_file_name);	67	myname, st_lineno, input_file_name);
Lines 77-86 Link Here
77	}	70	}
78		71
79		72
80	unterminated_comment(c_lineno, c_line, c_cptr)	73	void unterminated_comment(int c_lineno, char c_line, char c_cptr)
81	int c_lineno;
82	char *c_line;
83	char *c_cptr;
84	{	74	{
85	fprintf(stderr, "%s: e - line %d of \"%s\", unmatched /*\n",	75	fprintf(stderr, "%s: e - line %d of \"%s\", unmatched /*\n",
86	myname, c_lineno, input_file_name);	76	myname, c_lineno, input_file_name);
Lines 88-98 Link Here
88	done(1);	78	done(1);
89	}	79	}
90		80
91		81	void unterminated_string(int s_lineno, char s_line, char s_cptr)
92	unterminated_string(s_lineno, s_line, s_cptr)
93	int s_lineno;
94	char *s_line;
95	char *s_cptr;
96	{	82	{
97	fprintf(stderr, "%s: e - line %d of \"%s\", unterminated string\n",	83	fprintf(stderr, "%s: e - line %d of \"%s\", unterminated string\n",
98	myname, s_lineno, input_file_name);	84	myname, s_lineno, input_file_name);
Lines 101-110 Link Here
101	}	87	}
102		88
103		89
104	unterminated_text(t_lineno, t_line, t_cptr)	90	void unterminated_text(int t_lineno, char t_line, char t_cptr)
105	int t_lineno;
106	char *t_line;
107	char *t_cptr;
108	{	91	{
109	fprintf(stderr, "%s: e - line %d of \"%s\", unmatched %%{\n",	92	fprintf(stderr, "%s: e - line %d of \"%s\", unmatched %%{\n",
110	myname, t_lineno, input_file_name);	93	myname, t_lineno, input_file_name);
Lines 113-122 Link Here
113	}	96	}
114		97
115		98
116	unterminated_union(u_lineno, u_line, u_cptr)	99	void unterminated_union(int u_lineno, char u_line, char u_cptr)
117	int u_lineno;
118	char *u_line;
119	char *u_cptr;
120	{	100	{
121	fprintf(stderr, "%s: e - line %d of \"%s\", unterminated %%union \	101	fprintf(stderr, "%s: e - line %d of \"%s\", unterminated %%union \
122	declaration\n", myname, u_lineno, input_file_name);	102	declaration\n", myname, u_lineno, input_file_name);
Lines 125-132 Link Here
125	}	105	}
126		106
127		107
128	over_unionized(u_cptr)	108	void over_unionized(char *u_cptr)
129	char *u_cptr;
130	{	109	{
131	fprintf(stderr, "%s: e - line %d of \"%s\", too many %%union \	110	fprintf(stderr, "%s: e - line %d of \"%s\", too many %%union \
132	declarations\n", myname, lineno, input_file_name);	111	declarations\n", myname, lineno, input_file_name);
Lines 135-144 Link Here
135	}	114	}
136		115
137		116
138	illegal_tag(t_lineno, t_line, t_cptr)	117	void illegal_tag(int t_lineno, char t_line, char t_cptr)
139	int t_lineno;
140	char *t_line;
141	char *t_cptr;
142	{	118	{
143	fprintf(stderr, "%s: e - line %d of \"%s\", illegal tag\n",	119	fprintf(stderr, "%s: e - line %d of \"%s\", illegal tag\n",
144	myname, t_lineno, input_file_name);	120	myname, t_lineno, input_file_name);
Lines 147-154 Link Here
147	}	123	}
148		124
149		125
150	illegal_character(c_cptr)	126	void illegal_character(char *c_cptr)
151	char *c_cptr;
152	{	127	{
153	fprintf(stderr, "%s: e - line %d of \"%s\", illegal character\n",	128	fprintf(stderr, "%s: e - line %d of \"%s\", illegal character\n",
154	myname, lineno, input_file_name);	129	myname, lineno, input_file_name);
Lines 157-164 Link Here
157	}	132	}
158		133
159		134
160	used_reserved(s)	135	void used_reserved(char *s)
161	char *s;
162	{	136	{
163	fprintf(stderr, "%s: e - line %d of \"%s\", illegal use of reserved symbol \	137	fprintf(stderr, "%s: e - line %d of \"%s\", illegal use of reserved symbol \
164	%s\n", myname, lineno, input_file_name, s);	138	%s\n", myname, lineno, input_file_name, s);
Lines 166-173 Link Here
166	}	140	}
167		141
168		142
169	tokenized_start(s)	143	void tokenized_start(char *s)
170	char *s;
171	{	144	{
172	fprintf(stderr, "%s: e - line %d of \"%s\", the start symbol %s cannot be \	145	fprintf(stderr, "%s: e - line %d of \"%s\", the start symbol %s cannot be \
173	declared to be a token\n", myname, lineno, input_file_name, s);	146	declared to be a token\n", myname, lineno, input_file_name, s);
Lines 175-206 Link Here
175	}	148	}
176		149
177		150
178	retyped_warning(s)	151	void retyped_warning(char *s)
179	char *s;
180	{	152	{
181	fprintf(stderr, "%s: w - line %d of \"%s\", the type of %s has been \	153	fprintf(stderr, "%s: w - line %d of \"%s\", the type of %s has been \
182	redeclared\n", myname, lineno, input_file_name, s);	154	redeclared\n", myname, lineno, input_file_name, s);
183	}	155	}
184		156
185		157
186	reprec_warning(s)	158	void reprec_warning(char *s)
187	char *s;
188	{	159	{
189	fprintf(stderr, "%s: w - line %d of \"%s\", the precedence of %s has been \	160	fprintf(stderr, "%s: w - line %d of \"%s\", the precedence of %s has been \
190	redeclared\n", myname, lineno, input_file_name, s);	161	redeclared\n", myname, lineno, input_file_name, s);
191	}	162	}
192		163
193		164
194	revalued_warning(s)	165	void revalued_warning(char *s)
195	char *s;
196	{	166	{
197	fprintf(stderr, "%s: w - line %d of \"%s\", the value of %s has been \	167	fprintf(stderr, "%s: w - line %d of \"%s\", the value of %s has been \
198	redeclared\n", myname, lineno, input_file_name, s);	168	redeclared\n", myname, lineno, input_file_name, s);
199	}	169	}
200		170
201		171
202	terminal_start(s)	172	void terminal_start(char *s)
203	char *s;
204	{	173	{
205	fprintf(stderr, "%s: e - line %d of \"%s\", the start symbol %s is a \	174	fprintf(stderr, "%s: e - line %d of \"%s\", the start symbol %s is a \
206	token\n", myname, lineno, input_file_name, s);	175	token\n", myname, lineno, input_file_name, s);
Lines 208-221 Link Here
208	}	177	}
209		178
210		179
211	restarted_warning()	180	void restarted_warning()
212	{	181	{
213	fprintf(stderr, "%s: w - line %d of \"%s\", the start symbol has been \	182	fprintf(stderr, "%s: w - line %d of \"%s\", the start symbol has been \
214	redeclared\n", myname, lineno, input_file_name);	183	redeclared\n", myname, lineno, input_file_name);
215	}	184	}
216		185
217		186
218	no_grammar()	187	void no_grammar()
219	{	188	{
220	fprintf(stderr, "%s: e - line %d of \"%s\", no grammar has been \	189	fprintf(stderr, "%s: e - line %d of \"%s\", no grammar has been \
221	specified\n", myname, lineno, input_file_name);	190	specified\n", myname, lineno, input_file_name);
Lines 223-230 Link Here
223	}	192	}
224		193
225		194
226	terminal_lhs(s_lineno)	195	void terminal_lhs(int s_lineno)
227	int s_lineno;
228	{	196	{
229	fprintf(stderr, "%s: e - line %d of \"%s\", a token appears on the lhs \	197	fprintf(stderr, "%s: e - line %d of \"%s\", a token appears on the lhs \
230	of a production\n", myname, s_lineno, input_file_name);	198	of a production\n", myname, s_lineno, input_file_name);
Lines 232-248 Link Here
232	}	200	}
233		201
234		202
235	prec_redeclared()	203	void prec_redeclared()
236	{	204	{
237	fprintf(stderr, "%s: w - line %d of \"%s\", conflicting %%prec \	205	fprintf(stderr, "%s: w - line %d of \"%s\", conflicting %%prec \
238	specifiers\n", myname, lineno, input_file_name);	206	specifiers\n", myname, lineno, input_file_name);
239	}	207	}
240		208
241		209
242	unterminated_action(a_lineno, a_line, a_cptr)	210	void unterminated_action(int a_lineno, char a_line, char a_cptr)
243	int a_lineno;
244	char *a_line;
245	char *a_cptr;
246	{	211	{
247	fprintf(stderr, "%s: e - line %d of \"%s\", unterminated action\n",	212	fprintf(stderr, "%s: e - line %d of \"%s\", unterminated action\n",
248	myname, a_lineno, input_file_name);	213	myname, a_lineno, input_file_name);
Lines 251-269 Link Here
251	}	216	}
252		217
253		218
254	dollar_warning(a_lineno, i)	219	void dollar_warning(int a_lineno, int i)
255	int a_lineno;
256	int i;
257	{	220	{
258	fprintf(stderr, "%s: w - line %d of \"%s\", $%d references beyond the \	221	fprintf(stderr, "%s: w - line %d of \"%s\", $%d references beyond the \
259	end of the current rule\n", myname, a_lineno, input_file_name, i);	222	end of the current rule\n", myname, a_lineno, input_file_name, i);
260	}	223	}
261		224
262		225
263	dollar_error(a_lineno, a_line, a_cptr)	226	void dollar_error(int a_lineno, char a_line, char a_cptr)
264	int a_lineno;
265	char *a_line;
266	char *a_cptr;
267	{	227	{
268	fprintf(stderr, "%s: e - line %d of \"%s\", illegal $-name\n",	228	fprintf(stderr, "%s: e - line %d of \"%s\", illegal $-name\n",
269	myname, a_lineno, input_file_name);	229	myname, a_lineno, input_file_name);
Lines 272-278 Link Here
272	}	232	}
273		233
274		234
275	untyped_lhs()	235	void untyped_lhs()
276	{	236	{
277	fprintf(stderr, "%s: e - line %d of \"%s\", $$ is untyped\n",	237	fprintf(stderr, "%s: e - line %d of \"%s\", $$ is untyped\n",
278	myname, lineno, input_file_name);	238	myname, lineno, input_file_name);
Lines 280-288 Link Here
280	}	240	}
281		241
282		242
283	untyped_rhs(i, s)	243	void untyped_rhs(int i, char *s)
284	int i;
285	char *s;
286	{	244	{
287	fprintf(stderr, "%s: e - line %d of \"%s\", $%d (%s) is untyped\n",	245	fprintf(stderr, "%s: e - line %d of \"%s\", $%d (%s) is untyped\n",
288	myname, lineno, input_file_name, i, s);	246	myname, lineno, input_file_name, i, s);
Lines 290-297 Link Here
290	}	248	}
291		249
292		250
293	unknown_rhs(i)	251	void unknown_rhs(int i)
294	int i;
295	{	252	{
296	fprintf(stderr, "%s: e - line %d of \"%s\", $%d is untyped\n",	253	fprintf(stderr, "%s: e - line %d of \"%s\", $%d is untyped\n",
297	myname, lineno, input_file_name, i);	254	myname, lineno, input_file_name, i);
Lines 299-321 Link Here
299	}	256	}
300		257
301		258
302	default_action_warning()	259	void default_action_warning()
303	{	260	{
304	fprintf(stderr, "%s: w - line %d of \"%s\", the default action assigns an \	261	fprintf(stderr, "%s: w - line %d of \"%s\", the default action assigns an \
305	undefined value to $$\n", myname, lineno, input_file_name);	262	undefined value to $$\n", myname, lineno, input_file_name);
306	}	263	}
307		264
308		265
309	undefined_goal(s)	266	void undefined_goal(char *s)
310	char *s;
311	{	267	{
312	fprintf(stderr, "%s: e - the start symbol %s is undefined\n", myname, s);	268	fprintf(stderr, "%s: e - the start symbol %s is undefined\n", myname, s);
313	done(1);	269	done(1);
314	}	270	}
315		271
316		272
317	undefined_symbol_warning(s)	273	void undefined_symbol_warning(char *s)
318	char *s;
319	{	274	{
320	fprintf(stderr, "%s: w - the symbol %s is undefined\n", myname, s);	275	fprintf(stderr, "%s: w - the symbol %s is undefined\n", myname, s);
321	}	276	}

Lines 21-27 Link Here

(-)yacc-1.9.1-orig/output.c (-36 / +26 lines)
21	static int high;	21	static int high;
22		22
23		23
24	output()	24	void output()
25	{	25	{
26	free_itemsets();	26	free_itemsets();
27	free_shifts();	27	free_shifts();
Lines 44-50 Link Here
44	}	44	}
45		45
46		46
47	output_prefix()	47	void output_prefix()
48	{	48	{
49	if (symbol_prefix == NULL)	49	if (symbol_prefix == NULL)
50	symbol_prefix = "yy";	50	symbol_prefix = "yy";
Lines 104-110 Link Here
104	}	104	}
105		105
106		106
107	output_rule_data()	107	void output_rule_data()
108	{	108	{
109	register int i;	109	register int i;
110	register int j;	110	register int j;
Lines 151-157 Link Here
151	}	151	}
152		152
153		153
154	output_yydefred()	154	void output_yydefred()
155	{	155	{
156	register int i, j;	156	register int i, j;
157		157
Lines 178-184 Link Here
178	}	178	}
179		179
180		180
181	output_actions()	181	void output_actions()
182	{	182	{
183	nvectors = 2*nstates + nvars;	183	nvectors = 2*nstates + nvars;
184		184
Lines 206-212 Link Here
206	}	206	}
207		207
208		208
209	token_actions()	209	void token_actions()
210	{	210	{
211	register int i, j;	211	register int i, j;
212	register int shiftcount, reducecount;	212	register int shiftcount, reducecount;
Lines 290-296 Link Here
290	FREE(actionrow);	290	FREE(actionrow);
291	}	291	}
292		292
293	goto_actions()	293	void goto_actions()
294	{	294	{
295	register int i, j, k;	295	register int i, j, k;
296		296
Lines 322-330 Link Here
322	FREE(state_count);	322	FREE(state_count);
323	}	323	}
324		324
325	int	325	int default_goto(int symbol)
326	default_goto(symbol)
327	int symbol;
328	{	326	{
329	register int i;	327	register int i;
330	register int m;	328	register int m;
Lines 359-367 Link Here
359		357
360		358
361		359
362	save_column(symbol, default_state)	360	void save_column(int symbol, int default_state)
363	int symbol;
364	int default_state;
365	{	361	{
366	register int i;	362	register int i;
367	register int m;	363	register int m;
Lines 401-407 Link Here
401	width[symno] = sp1[-1] - sp[0] + 1;	397	width[symno] = sp1[-1] - sp[0] + 1;
402	}	398	}
403		399
404	sort_actions()	400	void sort_actions()
405	{	401	{
406	register int i;	402	register int i;
407	register int j;	403	register int j;
Lines 436-442 Link Here
436	}	432	}
437		433
438		434
439	pack_table()	435	void pack_table()
440	{	436	{
441	register int i;	437	register int i;
442	register int place;	438	register int place;
Lines 498-506 Link Here
498	/* faster. Also, it depends on the vectors being in a specific */	494	/* faster. Also, it depends on the vectors being in a specific */
499	/* order. */	495	/* order. */
500		496
501	int	497	int matching_vector(int vector)
502	matching_vector(vector)
503	int vector;
504	{	498	{
505	register int i;	499	register int i;
506	register int j;	500	register int j;
Lines 539-547 Link Here
539		533
540		534
541		535
542	int	536	int pack_vector(int vector)
543	pack_vector(vector)
544	int vector;
545	{	537	{
546	register int i, j, k, l;	538	register int i, j, k, l;
547	register int t;	539	register int t;
Lines 617-623 Link Here
617		609
618		610
619		611
620	output_base()	612	void output_base()
621	{	613	{
622	register int i, j;	614	register int i, j;
623		615
Lines 683-689 Link Here
683		675
684		676
685		677
686	output_table()	678	void output_table()
687	{	679	{
688	register int i;	680	register int i;
689	register int j;	681	register int j;
Lines 715-721 Link Here
715		707
716		708
717		709
718	output_check()	710	void output_check()
719	{	711	{
720	register int i;	712	register int i;
721	register int j;	713	register int j;
Lines 744-752 Link Here
744	}	736	}
745		737
746		738
747	int	739	int is_C_identifier(char *name)
748	is_C_identifier(name)
749	char *name;
750	{	740	{
751	register char *s;	741	register char *s;
752	register int c;	742	register int c;
Lines 777-783 Link Here
777	}	767	}
778		768
779		769
780	output_defines()	770	void output_defines()
781	{	771	{
782	register int c, i;	772	register int c, i;
783	register char *s;	773	register char *s;
Lines 829-835 Link Here
829	}	819	}
830		820
831		821
832	output_stored_text()	822	void output_stored_text()
833	{	823	{
834	register int c;	824	register int c;
835	register FILE in, out;	825	register FILE in, out;
Lines 856-862 Link Here
856	}	846	}
857		847
858		848
859	output_debug()	849	void output_debug()
860	{	850	{
861	register int i, j, k, max;	851	register int i, j, k, max;
862	char *symnam, s;	852	char *symnam, s;
Lines 1070-1076 Link Here
1070	}	1060	}
1071		1061
1072		1062
1073	output_stype()	1063	void output_stype()
1074	{	1064	{
1075	if (!unionized && ntags == 0)	1065	if (!unionized && ntags == 0)
1076	{	1066	{
Lines 1080-1086 Link Here
1080	}	1070	}
1081		1071
1082		1072
1083	output_trailing_text()	1073	void output_trailing_text()
1084	{	1074	{
1085	register int c, last;	1075	register int c, last;
1086	register FILE in, out;	1076	register FILE in, out;
Lines 1137-1143 Link Here
1137	}	1127	}
1138		1128
1139		1129
1140	output_semantic_actions()	1130	void output_semantic_actions()
1141	{	1131	{
1142	register int c, last;	1132	register int c, last;
1143	register FILE *out;	1133	register FILE *out;
Lines 1174-1180 Link Here
1174	}	1164	}
1175		1165
1176		1166
1177	free_itemsets()	1167	void free_itemsets()
1178	{	1168	{
1179	register core cp, next;	1169	register core cp, next;
1180		1170
Lines 1187-1193 Link Here
1187	}	1177	}
1188		1178
1189		1179
1190	free_shifts()	1180	void free_shifts()
1191	{	1181	{
1192	register shifts sp, next;	1182	register shifts sp, next;
1193		1183
Lines 1201-1207 Link Here
1201		1191
1202		1192
1203		1193
1204	free_reductions()	1194	void free_reductions()
1205	{	1195	{
1206	register reductions rp, next;	1196	register reductions rp, next;
1207		1197

Lines 38-45 Link Here

(-)yacc-1.9.1-orig/reader.c (-53 / +37 lines)
38	char line_format[] = "#line %d \"%s\"\n";	38	char line_format[] = "#line %d \"%s\"\n";
39		39
40		40
41	cachec(c)	41	void cachec(int c)
42	int c;
43	{	42	{
44	assert(cinc >= 0);	43	assert(cinc >= 0);
45	if (cinc >= cache_size)	44	if (cinc >= cache_size)
Lines 53-59 Link Here
53	}	52	}
54		53
55		54
56	get_line()	55	void get_line()
57	{	56	{
58	register FILE *f = input_file;	57	register FILE *f = input_file;
59	register int c;	58	register int c;
Lines 99-106 Link Here
99	}	98	}
100		99
101		100
102	char *	101	char *dup_line()
103	dup_line()
104	{	102	{
105	register char p, s, *t;	103	register char p, s, *t;
106		104
Lines 117-123 Link Here
117	}	115	}
118		116
119		117
120	skip_comment()	118	void skip_comment()
121	{	119	{
122	register char *s;	120	register char *s;
123		121
Lines 147-154 Link Here
147	}	145	}
148		146
149		147
150	int	148	int nextc()
151	nextc()
152	{	149	{
153	register char *s;	150	register char *s;
154		151
Lines 209-216 Link Here
209	}	206	}
210		207
211		208
212	int	209	int keyword()
213	keyword()
214	{	210	{
215	register int c;	211	register int c;
216	char *t_cptr = cptr;	212	char *t_cptr = cptr;
Lines 272-278 Link Here
272	}	268	}
273		269
274		270
275	copy_ident()	271	void copy_ident()
276	{	272	{
277	register int c;	273	register int c;
278	register FILE *f = output_file;	274	register FILE *f = output_file;
Lines 301-307 Link Here
301	}	297	}
302		298
303		299
304	copy_text()	300	void copy_text()
305	{	301	{
306	register int c;	302	register int c;
307	int quote;	303	int quote;
Lines 432-438 Link Here
432	}	428	}
433		429
434		430
435	copy_union()	431	void copy_union()
436	{	432	{
437	register int c;	433	register int c;
438	int quote;	434	int quote;
Lines 572-580 Link Here
572	}	568	}
573		569
574		570
575	int	571	int hexval(int c)
576	hexval(c)
577	int c;
578	{	572	{
579	if (c >= '0' && c <= '9')	573	if (c >= '0' && c <= '9')
580	return (c - '0');	574	return (c - '0');
Lines 586-593 Link Here
586	}	580	}
587		581
588		582
589	bucket *	583	bucket *get_literal()
590	get_literal()
591	{	584	{
592	register int c, quote;	585	register int c, quote;
593	register int i;	586	register int i;
Lines 725-733 Link Here
725	}	718	}
726		719
727		720
728	int	721	int is_reserved(char *name)
729	is_reserved(name)
730	char *name;
731	{	722	{
732	char *s;	723	char *s;
733		724
Lines 747-754 Link Here
747	}	738	}
748		739
749		740
750	bucket *	741	bucket *get_name()
751	get_name()
752	{	742	{
753	register int c;	743	register int c;
754		744
Lines 763-770 Link Here
763	}	753	}
764		754
765		755
766	int	756	int get_number()
767	get_number()
768	{	757	{
769	register int c;	758	register int c;
770	register int n;	759	register int n;
Lines 777-784 Link Here
777	}	766	}
778		767
779		768
780	char *	769	char *get_tag()
781	get_tag()
782	{	770	{
783	register int c;	771	register int c;
784	register int i;	772	register int i;
Lines 828-835 Link Here
828	}	816	}
829		817
830		818
831	declare_tokens(assoc)	819	void declare_tokens(int assoc)
832	int assoc;
833	{	820	{
834	register int c;	821	register int c;
835	register bucket *bp;	822	register bucket *bp;
Lines 890-896 Link Here
890	}	877	}
891		878
892		879
893	declare_types()	880	void declare_types()
894	{	881	{
895	register int c;	882	register int c;
896	register bucket *bp;	883	register bucket *bp;
Lines 918-924 Link Here
918	}	905	}
919		906
920		907
921	declare_start()	908	void declare_start()
922	{	909	{
923	register int c;	910	register int c;
924	register bucket *bp;	911	register bucket *bp;
Lines 936-942 Link Here
936	}	923	}
937		924
938		925
939	read_declarations()	926	void read_declarations()
940	{	927	{
941	register int c, k;	928	register int c, k;
942		929
Lines 985-991 Link Here
985	}	972	}
986		973
987		974
988	initialize_grammar()	975	void initialize_grammar()
989	{	976	{
990	nitems = 4;	977	nitems = 4;
991	maxitems = 300;	978	maxitems = 300;
Lines 1016-1022 Link Here
1016	}	1003	}
1017		1004
1018		1005
1019	expand_items()	1006	void expand_items()
1020	{	1007	{
1021	maxitems += 300;	1008	maxitems += 300;
1022	pitem = (bucket *) REALLOC(pitem, maxitemssizeof(bucket *));	1009	pitem = (bucket *) REALLOC(pitem, maxitemssizeof(bucket *));
Lines 1024-1030 Link Here
1024	}	1011	}
1025		1012
1026		1013
1027	expand_rules()	1014	void expand_rules()
1028	{	1015	{
1029	maxrules += 100;	1016	maxrules += 100;
1030	plhs = (bucket *) REALLOC(plhs, maxrulessizeof(bucket *));	1017	plhs = (bucket *) REALLOC(plhs, maxrulessizeof(bucket *));
Lines 1036-1042 Link Here
1036	}	1023	}
1037		1024
1038		1025
1039	advance_to_start()	1026	void advance_to_start()
1040	{	1027	{
1041	register int c;	1028	register int c;
1042	register bucket *bp;	1029	register bucket *bp;
Lines 1086-1094 Link Here
1086	}	1073	}
1087		1074
1088		1075
1089	start_rule(bp, s_lineno)	1076	void start_rule(register bucket *bp, int s_lineno)
1090	register bucket *bp;
1091	int s_lineno;
1092	{	1077	{
1093	if (bp->class == TERM)	1078	if (bp->class == TERM)
1094	terminal_lhs(s_lineno);	1079	terminal_lhs(s_lineno);
Lines 1101-1107 Link Here
1101	}	1086	}
1102		1087
1103		1088
1104	end_rule()	1089	void end_rule()
1105	{	1090	{
1106	register int i;	1091	register int i;
1107		1092
Lines 1120-1126 Link Here
1120	}	1105	}
1121		1106
1122		1107
1123	insert_empty_rule()	1108	void insert_empty_rule()
1124	{	1109	{
1125	register bucket bp, *bpp;	1110	register bucket bp, *bpp;
1126		1111
Lines 1149-1155 Link Here
1149	}	1134	}
1150		1135
1151		1136
1152	add_symbol()	1137	void add_symbol()
1153	{	1138	{
1154	register int c;	1139	register int c;
1155	register bucket *bp;	1140	register bucket *bp;
Lines 1180-1186 Link Here
1180	}	1165	}
1181		1166
1182		1167
1183	copy_action()	1168	void copy_action()
1184	{	1169	{
1185	register int c;	1170	register int c;
1186	register int i, n;	1171	register int i, n;
Lines 1403-1410 Link Here
1403	}	1388	}
1404		1389
1405		1390
1406	int	1391	int mark_symbol()
1407	mark_symbol()
1408	{	1392	{
1409	register int c;	1393	register int c;
1410	register bucket *bp;	1394	register bucket *bp;
Lines 1447-1453 Link Here
1447	}	1431	}
1448		1432
1449		1433
1450	read_grammar()	1434	void read_grammar()
1451	{	1435	{
1452	register int c;	1436	register int c;
1453		1437
Lines 1480-1486 Link Here
1480	}	1464	}
1481		1465
1482		1466
1483	free_tags()	1467	void free_tags()
1484	{	1468	{
1485	register int i;	1469	register int i;
1486		1470
Lines 1495-1501 Link Here
1495	}	1479	}
1496		1480
1497		1481
1498	pack_names()	1482	void pack_names()
1499	{	1483	{
1500	register bucket *bp;	1484	register bucket *bp;
1501	register char p, s, *t;	1485	register char p, s, *t;
Lines 1520-1526 Link Here
1520	}	1504	}
1521		1505
1522		1506
1523	check_symbols()	1507	void check_symbols()
1524	{	1508	{
1525	register bucket *bp;	1509	register bucket *bp;
1526		1510
Lines 1538-1544 Link Here
1538	}	1522	}
1539		1523
1540		1524
1541	pack_symbols()	1525	void pack_symbols()
1542	{	1526	{
1543	register bucket *bp;	1527	register bucket *bp;
1544	register bucket **v;	1528	register bucket **v;
Lines 1662-1668 Link Here
1662	}	1646	}
1663		1647
1664		1648
1665	pack_grammar()	1649	void pack_grammar()
1666	{	1650	{
1667	register int i, j;	1651	register int i, j;
1668	int assoc, prec;	1652	int assoc, prec;
Lines 1721-1727 Link Here
1721	}	1705	}
1722		1706
1723		1707
1724	print_grammar()	1708	void print_grammar()
1725	{	1709	{
1726	register int i, j, k;	1710	register int i, j, k;
1727	int spacing;	1711	int spacing;
Lines 1757-1763 Link Here
1757	}	1741	}
1758		1742
1759		1743
1760	reader()	1744	void reader()
1761	{	1745	{
1762	write_section(banner);	1746	write_section(banner);
1763	create_symbol_table();	1747	create_symbol_table();

Lines 15-23 Link Here

(-)yacc-1.9.1-orig/symtab.c (-12 / +6 lines)
15	bucket *last_symbol;	15	bucket *last_symbol;
16		16
17		17
18	int	18	int hash(char *name)
19	hash(name)
20	char *name;
21	{	19	{
22	register char *s;	20	register char *s;
23	register int c, k;	21	register int c, k;
Lines 32-40 Link Here
32	}	30	}
33		31
34		32
35	bucket *	33	bucket make_bucket(char name)
36	make_bucket(name)
37	char *name;
38	{	34	{
39	register bucket *bp;	35	register bucket *bp;
40		36
Lines 59-67 Link Here
59	}	55	}
60		56
61		57
62	bucket *	58	bucket lookup(char name)
63	lookup(name)
64	char *name;
65	{	59	{
66	register bucket bp, *bpp;	60	register bucket bp, *bpp;
67		61
Lines 83-89 Link Here
83	}	77	}
84		78
85		79
86	create_symbol_table()	80	void create_symbol_table()
87	{	81	{
88	register int i;	82	register int i;
89	register bucket *bp;	83	register bucket *bp;
Lines 103-116 Link Here
103	}	97	}
104		98
105		99
106	free_symbol_table()	100	void free_symbol_table()
107	{	101	{
108	FREE(symbol_table);	102	FREE(symbol_table);
109	symbol_table = 0;	103	symbol_table = 0;
110	}	104	}
111		105
112		106
113	free_symbols()	107	void free_symbols()
114	{	108	{
115	register bucket p, q;	109	register bucket p, q;
116		110

Lines 7-13 Link Here

(-)yacc-1.9.1-orig/verbose.c (-20 / +11 lines)
7		7
8	static short *null_rules;	8	static short *null_rules;
9		9
10	verbose()	10	void verbose()
11	{	11	{
12	register int i;	12	register int i;
13		13
Lines 31-37 Link Here
31	}	31	}
32		32
33		33
34	log_unused()	34	void log_unused()
35	{	35	{
36	register int i;	36	register int i;
37	register short *p;	37	register short *p;
Lines 50-56 Link Here
50	}	50	}
51		51
52		52
53	log_conflicts()	53	void log_conflicts()
54	{	54	{
55	register int i;	55	register int i;
56		56
Lines 78-85 Link Here
78	}	78	}
79		79
80		80
81	print_state(state)	81	void print_state(int state)
82	int state;
83	{	82	{
84	if (state)	83	if (state)
85	fprintf(verbose_file, "\n\n");	84	fprintf(verbose_file, "\n\n");
Lines 92-99 Link Here
92	}	91	}
93		92
94		93
95	print_conflicts(state)	94	void print_conflicts(int state)
96	int state;
97	{	95	{
98	register int symbol, act, number;	96	register int symbol, act, number;
99	register action *p;	97	register action *p;
Lines 140-147 Link Here
140	}	138	}
141		139
142		140
143	print_core(state)	141	void print_core(int state)
144	int state;
145	{	142	{
146	register int i;	143	register int i;
147	register int k;	144	register int k;
Lines 176-183 Link Here
176	}	173	}
177		174
178		175
179	print_nulls(state)	176	void print_nulls(int state)
180	int state;
181	{	177	{
182	register action *p;	178	register action *p;
183	register int i, j, k, nnulls;	179	register int i, j, k, nnulls;
Lines 220-227 Link Here
220	}	216	}
221		217
222		218
223	print_actions(stateno)	219	void print_actions(int stateno)
224	int stateno;
225	{	220	{
226	register action *p;	221	register action *p;
227	register shifts *sp;	222	register shifts *sp;
Lines 247-254 Link Here
247	}	242	}
248		243
249		244
250	print_shifts(p)	245	void print_shifts(register action *p)
251	register action *p;
252	{	246	{
253	register int count;	247	register int count;
254	register action *q;	248	register action *q;
Lines 272-280 Link Here
272	}	266	}
273		267
274		268
275	print_reductions(p, defred)	269	void print_reductions(register action *p, register int defred)
276	register action *p;
277	register int defred;
278	{	270	{
279	register int k, anyreds;	271	register int k, anyreds;
280	register action *q;	272	register action *q;
Lines 310-317 Link Here
310	}	302	}
311		303
312		304
313	print_gotos(stateno)	305	void print_gotos(int stateno)
314	int stateno;
315	{	306	{
316	register int i, k;	307	register int i, k;
317	register int as;	308	register int as;

Lines 4-12 Link Here

(-)yacc-1.9.1-orig/warshall.c (-6 / +2 lines)
4		4
5	#include "defs.h"	5	#include "defs.h"
6		6
7	transitive_closure(R, n)	7	void transitive_closure(unsigned *R, int n)
8	unsigned *R;
9	int n;
10	{	8	{
11	register int rowsize;	9	register int rowsize;
12	register unsigned i;	10	register unsigned i;
Lines 56-64 Link Here
56	}	54	}
57	}	55	}
58		56
59	reflexive_transitive_closure(R, n)	57	void reflexive_transitive_closure(unsigned *R, int n)
60	unsigned *R;
61	int n;
62	{	58	{
63	register int rowsize;	59	register int rowsize;
64	register unsigned i;	60	register unsigned i;