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

Include dependency graph for main.c:

Functions
char *	mktemp ()

char *	getenv ()

	done (int k)
	Shutdown function. More...

	onintr ()
	Signal handler callback. More...

	set_signals ()
	Sets the appropriate signal handlers up. More...

	usage ()

	getargs (int argc, argv)

char *	allocate (unsigned n)

	create_file_names ()

	open_files ()

int	main (int argc, argv)

Variables
char	dflag

char	lflag

char	rflag

char	tflag

char	vflag

char *	symbol_prefix

char *	file_prefix = "y"

char *	myname = "yacc"

char *	temp_form = "yacc.XXXXXXX"

int	lineno

int	outline

char *	action_file_name

char *	code_file_name

char *	defines_file_name

char *	input_file_name = ""

char *	output_file_name

char *	text_file_name

char *	union_file_name

char *	verbose_file_name

FILE *	action_file

FILE *	code_file

FILE *	defines_file

FILE *	input_file

FILE *	output_file

FILE *	text_file

FILE *	union_file

FILE *	verbose_file

int	nitems

int	nrules
	The number of rules in the grammar. More...

int	nsyms
	The number of symbols (terminals + non-terminals) in the grammar. More...

int	ntokens
	The number of tokens (terminals) in the grammar. More...

int	nvars
	The number of variables (non-terminals) in the grammar. More...

int	start_symbol
	Index of the starting symbol of the grammar. More...

char **	symbol_name
	Array of symbol names. More...

short *	symbol_value

short *	symbol_prec

char *	symbol_assoc

short *	ritem
	Representation of all productions (and items) More...

short *	rlhs
	List of left-hand sides of all rules. More...

short *	rrhs
	List of right-hand sides of all rules. More...

short *	rprec

char *	rassoc

short **	derives
	List of rules that derive each non-terminal. More...

char *	nullable

Function Documentation

char* allocate ( unsigned n )

Definition at line 315 of file main.c.

References CALLOC, and no_space().

 {
     register char *p;
 
     p = NULL;
     if (n)
     {
         p = CALLOC(1, n);
         if (!p) no_space();
     }
     return (p);
 }

Here is the call graph for this function:

create_file_names ( )

Definition at line 330 of file main.c.

References action_file_name, code_file_name, CODE_SUFFIX, defines_file_name, DEFINES_SUFFIX, dflag, file_prefix, getenv(), MALLOC, mktemp(), no_space(), output_file_name, OUTPUT_SUFFIX, rflag, strcpy(), temp_form, text_file_name, union_file_name, verbose_file_name, VERBOSE_SUFFIX, and vflag.

Referenced by open_files().

 {
     int i, len;
     char *tmpdir;
 
     tmpdir = getenv("TMPDIR");
     if (tmpdir == 0) tmpdir = "/tmp";
 
     len = strlen(tmpdir);
     i = len + 13;
     if (len && tmpdir[len-1] != '/')
         ++i;
 
     action_file_name = MALLOC(i);
     if (action_file_name == 0) no_space();
     text_file_name = MALLOC(i);
     if (text_file_name == 0) no_space();
     union_file_name = MALLOC(i);
     if (union_file_name == 0) no_space();
 
     strcpy(action_file_name, tmpdir);
     strcpy(text_file_name, tmpdir);
     strcpy(union_file_name, tmpdir);
 
     if (len && tmpdir[len - 1] != '/')
     {
         action_file_name[len] = '/';
         text_file_name[len] = '/';
         union_file_name[len] = '/';
         ++len;
     }
 
     strcpy(action_file_name + len, temp_form);
     strcpy(text_file_name + len, temp_form);
     strcpy(union_file_name + len, temp_form);
 
     action_file_name[len + 5] = 'a';
     text_file_name[len + 5] = 't';
     union_file_name[len + 5] = 'u';
 
     mktemp(action_file_name);
     mktemp(text_file_name);
     mktemp(union_file_name);
 
     len = strlen(file_prefix);
 
     output_file_name = MALLOC(len + 7);
     if (output_file_name == 0)
         no_space();
     strcpy(output_file_name, file_prefix);
     strcpy(output_file_name + len, OUTPUT_SUFFIX);
 
     if (rflag)
     {
         code_file_name = MALLOC(len + 8);
         if (code_file_name == 0)
             no_space();
         strcpy(code_file_name, file_prefix);
         strcpy(code_file_name + len, CODE_SUFFIX);
     }
     else
         code_file_name = output_file_name;
 
     if (dflag)
     {
         defines_file_name = MALLOC(len + 7);
         if (defines_file_name == 0)
             no_space();
         strcpy(defines_file_name, file_prefix);
         strcpy(defines_file_name + len, DEFINES_SUFFIX);
     }
 
     if (vflag)
     {
         verbose_file_name = MALLOC(len + 8);
         if (verbose_file_name == 0)
             no_space();
         strcpy(verbose_file_name, file_prefix);
         strcpy(verbose_file_name + len, VERBOSE_SUFFIX);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

getargs	(	int	argc,
		argv
	)

Definition at line 209 of file main.c.

References dflag, file_prefix, input_file, input_file_name, lflag, myname, rflag, symbol_prefix, tflag, usage(), and vflag.

Referenced by main().

 {
     register int i;
     register char *s;
 
     if (argc > 0) myname = argv[0];
     for (i = 1; i < argc; ++i)
     {
         s = argv[i];
         if (*s != '-') break;
         switch (*++s)
         {
         case '\0':
             input_file = stdin;
             if (i + 1 < argc) usage();
             return;
 
         case '-':
             ++i;
             goto no_more_options;
 
         case 'b':
             if (*++s)
                 file_prefix = s;
             else if (++i < argc)
                 file_prefix = argv[i];
             else
                 usage();
             continue;
 
         case 'd':
             dflag = 1;
             break;
 
         case 'l':
             lflag = 1;
             break;
 
         case 'p':
             if (*++s)
                 symbol_prefix = s;
             else if (++i < argc)
                 symbol_prefix = argv[i];
             else
                 usage();
             continue;
 
         case 'r':
             rflag = 1;
             break;
 
         case 't':
             tflag = 1;
             break;
 
         case 'v':
             vflag = 1;
             break;
 
         default:
             usage();
         }
 
         for (;;)
         {
             switch (*++s)
             {
             case '\0':
                 goto end_of_option;
 
             case 'd':
                 dflag = 1;
                 break;
 
             case 'l':
                 lflag = 1;
                 break;
 
             case 'r':
                 rflag = 1;
                 break;
 
             case 't':
                 tflag = 1;
                 break;
 
             case 'v':
                 vflag = 1;
                 break;
 
             default:
                 usage();
             }
         }
 end_of_option:;
     }
 
 no_more_options:;
     if (i + 1 != argc) usage();
     input_file_name = argv[i];
 }

Here is the call graph for this function:

Here is the caller graph for this function:

char* getenv ( )

Referenced by create_file_names().

Here is the caller graph for this function:

int main	(	int	argc,
		argv
	)

Definition at line 465 of file main.c.

References done(), getargs(), lalr(), lr0(), make_parser(), open_files(), output(), reader(), set_signals(), and verbose().

 {
     set_signals();
     getargs(argc, argv);
     open_files();
     reader();
     lr0();
     lalr();
     make_parser();
     verbose();
     output();
     done(0);
     /*NOTREACHED*/
 }

Here is the call graph for this function:

char* mktemp ( )

Referenced by create_file_names().

Here is the caller graph for this function:

open_files ( )

Definition at line 413 of file main.c.

References action_file, action_file_name, code_file, code_file_name, create_file_names(), defines_file, defines_file_name, dflag, input_file, input_file_name, open_error(), output_file, output_file_name, rflag, text_file, text_file_name, union_file, union_file_name, verbose_file, verbose_file_name, and vflag.

Referenced by main().

 {
     create_file_names();
 
     if (input_file == 0)
     {
         input_file = fopen(input_file_name, "r");
         if (input_file == 0)
             open_error(input_file_name);
     }
 
     action_file = fopen(action_file_name, "w");
     if (action_file == 0)
         open_error(action_file_name);
 
     text_file = fopen(text_file_name, "w");
     if (text_file == 0)
         open_error(text_file_name);
 
     if (vflag)
     {
         verbose_file = fopen(verbose_file_name, "w");
         if (verbose_file == 0)
             open_error(verbose_file_name);
     }
 
     if (dflag)
     {
         defines_file = fopen(defines_file_name, "w");
         if (defines_file == 0)
             open_error(defines_file_name);
         union_file = fopen(union_file_name, "w");
         if (union_file ==  0)
             open_error(union_file_name);
     }
 
     output_file = fopen(output_file_name, "w");
     if (output_file == 0)
         open_error(output_file_name);
 
     if (rflag)
     {
         code_file = fopen(code_file_name, "w");
         if (code_file == 0)
             open_error(code_file_name);
     }
     else
         code_file = output_file;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

usage ( )

Definition at line 202 of file main.c.

References myname.

Referenced by getargs().

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

Here is the caller graph for this function:

Variable Documentation

FILE* action_file

Definition at line 27 of file main.c.

Referenced by copy_action(), done(), open_files(), and output_semantic_actions().

char* action_file_name

Definition at line 18 of file main.c.

Referenced by create_file_names(), done(), open_files(), and output_semantic_actions().

FILE* code_file

Definition at line 29 of file main.c.

Referenced by open_files(), output_debug(), output_defines(), output_prefix(), output_semantic_actions(), output_stored_text(), output_stype(), output_table(), output_trailing_text(), and write_section().

char* code_file_name

Definition at line 19 of file main.c.

Referenced by create_file_names(), open_files(), output_semantic_actions(), output_stored_text(), and output_trailing_text().

FILE* defines_file

Definition at line 30 of file main.c.

Referenced by open_files(), and output_defines().

char* defines_file_name

Definition at line 20 of file main.c.

Referenced by create_file_names(), and open_files().

short** derives

List of rules that derive each non-terminal.

Array of pointers that associates to each symbol the list of productions that have it as the left-hand side. Each item in those lists is the identifying number of a rule. The first ntokens entries (the ones for terminals) are not set and should not be accessed. They are only present to make the indexes consistent with other arrays (i.e. this array can be indexed using the symbol number).

Allocated and filled in set_first_derives().

Definition at line 140 of file main.c.

Referenced by build_relations(), free_derives(), initialize_states(), set_derives(), set_EFF(), and set_first_derives().

char dflag

Definition at line 4 of file main.c.

Referenced by copy_union(), create_file_names(), getargs(), open_files(), and output_defines().

char* file_prefix = "y"

Definition at line 11 of file main.c.

Referenced by create_file_names(), and getargs().

FILE* input_file

Definition at line 31 of file main.c.

Referenced by get_line(), getargs(), open_files(), and output_trailing_text().

char* input_file_name = ""

char lflag

Definition at line 5 of file main.c.

Referenced by copy_action(), copy_text(), copy_union(), getargs(), output_semantic_actions(), output_stored_text(), and output_trailing_text().

int lineno

char* myname = "yacc"

int nitems

Definition at line 40 of file main.c.

Referenced by add_symbol(), allocate_itemsets(), allocate_storage(), copy_action(), end_rule(), generate_states(), get_state(), initialize_grammar(), insert_empty_rule(), pack_grammar(), set_maxrhs(), set_nullable(), and show_ritems().

int nrules

The number of rules in the grammar.

Definition at line 45 of file main.c.

Referenced by allocate_storage(), closure(), copy_action(), end_rule(), finalize_closure(), generate_states(), initialize_grammar(), insert_empty_rule(), log_unused(), mark_symbol(), output_debug(), output_rule_data(), pack_grammar(), print_grammar(), read_grammar(), set_derives(), set_first_derives(), show_rrhs(), start_rule(), unused_rules(), and verbose().

int nsyms

The number of symbols (terminals + non-terminals) in the grammar.

All symbols can be uniquely represented using integers in the range [0, nsyms - 1], which is obtained by joining the range of terminals [0, ntokens - 1] with the range of non-terminals [ntokens, nsyms - 1].

It holds that nsyms = ntokens + nvars.

Definition at line 55 of file main.c.

Referenced by allocate_itemsets(), allocate_storage(), goto_actions(), new_itemsets(), pack_symbols(), set_derives(), set_EFF(), set_first_derives(), set_goto_map(), and set_nullable().

int ntokens

The number of tokens (terminals) in the grammar.

All tokens can be uniquely represented using integers in the range [0, ntokens - 1].

It holds that nsyms = ntokens + nvars.

Definition at line 64 of file main.c.

Referenced by add_reductions(), finalize_closure(), lalr(), output_actions(), output_debug(), output_defines(), pack_symbols(), set_first_derives(), set_goto_map(), token_actions(), and verbose().

char* nullable

Definition at line 141 of file main.c.

Referenced by build_relations(), free_nullable(), initialize_F(), and set_nullable().

int nvars

The number of variables (non-terminals) in the grammar.

All variables can be uniquely represented using integers in the range [ntokens, nsyms - 1], which is equivalent to the range [ntokens, ntokens + nvars - 1].

It holds that nsyms = ntokens + nvars.

Definition at line 74 of file main.c.

Referenced by output_actions(), pack_symbols(), set_derives(), set_EFF(), set_first_derives(), set_goto_map(), and verbose().

int outline

Definition at line 16 of file main.c.

Referenced by copy_ident(), goto_actions(), output_base(), output_check(), output_debug(), output_defines(), output_prefix(), output_rule_data(), output_semantic_actions(), output_stored_text(), output_stype(), output_table(), output_trailing_text(), output_yydefred(), and write_section().

FILE* output_file

Definition at line 32 of file main.c.

Referenced by copy_ident(), goto_actions(), open_files(), output_base(), output_check(), output_debug(), output_rule_data(), output_table(), and output_yydefred().

char* output_file_name

Definition at line 22 of file main.c.

Referenced by create_file_names(), and open_files().

char* rassoc

Definition at line 128 of file main.c.

Referenced by add_reduce(), expand_rules(), initialize_grammar(), insert_empty_rule(), mark_symbol(), pack_grammar(), and start_rule().

char rflag

Definition at line 6 of file main.c.

Referenced by create_file_names(), getargs(), goto_actions(), open_files(), output(), output_base(), output_check(), output_debug(), output_rule_data(), output_table(), and output_yydefred().

short* ritem

Representation of all productions (and items)

Typical shape: [1, 12, 21, -1, 2, 3, -2, 1, 4, -3, ...]

All productions are represented in this array as the list of their right-hand side symbols followed by the negation of their index. So the symbols on the right-hand side of the first rule are followed by -1, then there are the right-hand side symbols of the second rule and then -2, and so on.

Indices (using short integers) inside this array can represent rules (in that case they point to the first element after a negative one) or items, in which case they can point to any position; the element in that position is taken to be the first element after the "point" of the item. If the index points to a negative number, then it represents a reduction item for the rule whose number is the absolute value of the pointed element.

The array called rrhs contains indices inside this list and is used to associate to each rule the beginning of its production (that is, the closure item for that rule).

Definition at line 112 of file main.c.

Referenced by allocate_itemsets(), build_relations(), closure(), find_final_state(), log_unused(), new_itemsets(), output_debug(), pack_grammar(), print_core(), print_grammar(), save_reductions(), set_EFF(), set_maxrhs(), set_nullable(), show_cores(), and show_ritems().