/* web2c.yacc -- parse most of Pascal, and output C. */

/* web2c.yacc -- parse most of Pascal, and output C. */

%token array_tok begin_tok case_tok const_tok do_tok downto_tok else_tok
end_tok file_tok for_tok function_tok goto_tok if_tok label_tok
of_tok procedure_tok program_tok record_tok repeat_tok then_tok
to_tok type_tok until_tok var_tok while_tok integer_tok real_tok
others_tok r_num_tok i_num_tok string_literal_tok single_char_tok
assign_tok two_dots_tok unknown_tok undef_id_tok var_id_tok
proc_id_tok proc_param_tok fun_id_tok fun_param_tok const_id_tok
type_id_tok hhb0_tok hhb1_tok field_id_tok define_tok field_tok
break_tok

%nonassoc '=' not_eq_tok '<' '>' less_eq_tok great_eq_tok
%left '+' '-' or_tok
%right unary_plus_tok unary_minus_tok
%left '*' '/' div_tok mod_tok and_tok
%right not_tok

%{
#include "web2c.h"

#define symbol(x) sym_table[x].id
#define MAX_ARGS 50

static char fn_return_type[50], for_stack[300], control_var[50],
relation[3];
static char arg_type[MAX_ARGS][30];
static int last_type = -1, ids_typed;
char my_routine[100]; /* Name of routine being parsed, if any */
static char array_bounds[80], array_offset[80];
static int uses_mem, uses_eqtb, lower_sym, upper_sym;
static FILE *orig_std;
boolean doing_statements = FALSE;
static boolean var_formals = FALSE;
static int param_id_list[MAX_ARGS], ids_paramed=0;

extern char conditional[], temp[], *std_header;
extern int tex, mf, strict_for;
extern boolean ansi;
extern FILE *coerce;
extern char coerce_name[];
extern boolean debug;

/* Forward refs */
#ifdef ANSI
static long labs(long x);
static void compute_array_bounds(void);
static void fixup_var_list(void);
static void do_proc_args(void);
static void gen_function_head(void);
static boolean doreturn(char *label);
extern int yylex(void);
#else /* not ANSI */
static long labs();
static void compute_array_bounds(), fixup_var_list();
static void do_proc_args(), gen_function_head();
static boolean doreturn();
#endif /* not ANSI */

/* Type hacking for AIX. */
#ifdef AIX
#define UNSIGNED_SHORT_STRING "int"
#else
#define UNSIGNED_SHORT_STRING "unsigned short"
#endif

%}

%start PROGRAM

%%

PROGRAM: DEFS
PROGRAM_HEAD
{block_level++;
printf("#include \"%s\"\n", std_header);}
LABEL_DEC_PART CONST_DEC_PART TYPE_DEC_PART
VAR_DEC_PART
{printf("\n#include \"%s\"\n", coerce_name); }
P_F_DEC_PART
BODY
{YYACCEPT;}
;

DEFS: /* empty */
| DEFS DEF
;

DEF: define_tok field_tok undef_id_tok ';'
{
ii = add_to_table(last_id);
sym_table[ii].typ = field_id_tok;
}
| define_tok function_tok undef_id_tok ';'
{
ii = add_to_table(last_id);
sym_table[ii].typ = fun_id_tok;
}
| define_tok const_tok undef_id_tok ';'
{
ii = add_to_table(last_id);
sym_table[ii].typ = const_id_tok;
}
| define_tok function_tok undef_id_tok '(' ')' ';'
{
ii = add_to_table(last_id);
sym_table[ii].typ = fun_param_tok;
}
| define_tok procedure_tok undef_id_tok ';'
{
ii = add_to_table(last_id);
sym_table[ii].typ = proc_id_tok;
}
| define_tok procedure_tok undef_id_tok '(' ')' ';'
{
ii = add_to_table(last_id);
sym_table[ii].typ = proc_param_tok;
}
| define_tok type_tok undef_id_tok ';'
{
ii = add_to_table(last_id);
sym_table[ii].typ = type_id_tok;
}
| define_tok type_tok undef_id_tok '='
SUBRANGE_TYPE ';'
{
ii = add_to_table(last_id);
sym_table[ii].typ = type_id_tok;
sym_table[ii].val = lower_bound;
sym_table[ii].val_sym = lower_sym;
sym_table[ii].upper = upper_bound;
sym_table[ii].upper_sym = upper_sym;
}
| define_tok var_tok undef_id_tok ';'
{
ii = add_to_table(last_id);
sym_table[ii].typ = var_id_tok;
}
;

PROGRAM_HEAD: program_tok undef_id_tok ';'
;

BLOCK:
{ if (block_level > 0) my_output("{");
indent++; block_level++;
}
LABEL_DEC_PART
CONST_DEC_PART TYPE_DEC_PART
{if (block_level == 2) {
if (strcmp(fn_return_type, "void")) {
my_output("register");
my_output(fn_return_type);
my_output("Result;");
}
if (tex) {
(void) sprintf(safe_string, "%s_regmem",
my_routine);
my_output(safe_string);
indent_line();
}
}
}
VAR_DEC_PART
{if (block_level == 1)
puts("\n#include \"coerce.h\"");
doing_statements = TRUE;
}
STAT_PART
{if (block_level == 2) {
if (strcmp(fn_return_type,"void")) {
my_output("return(Result)");
semicolon();
}
if (tex) {
if (uses_mem && uses_eqtb)
(void) fprintf(coerce,
"#define %s_regmem register memoryword *mem=zmem, *eqtb=zeqtb;\n",
my_routine);
else if (uses_mem)
(void) fprintf(coerce,
"#define %s_regmem register memoryword *mem=zmem;\n",
my_routine);
else if (uses_eqtb)
(void) fprintf(coerce,
"#define %s_regmem register memoryword *eqtb=zeqtb;\n",
my_routine);
else
(void) fprintf(coerce,
"#define %s_regmem\n",
my_routine);
}
my_routine[0] = '\0';
}
indent--; block_level--;
my_output("}"); new_line();
doing_statements = FALSE;
}
;

LABEL_DEC_PART: /* empty */
| label_tok
{ my_output("/*"); }
LABEL_LIST ';'
{ my_output("*/"); }
;

LABEL_LIST: LABEL
| LABEL_LIST ',' LABEL
;

LABEL: i_num_tok
{ my_output(temp); }
;

CONST_DEC_PART: /* empty */
| const_tok CONST_DEC_LIST
{ indent_line(); }
;

CONST_DEC_LIST: CONST_DEC
| CONST_DEC_LIST CONST_DEC
;

CONST_DEC:
{ new_line(); my_output("#define"); }
undef_id_tok
{ ii=add_to_table(last_id);
sym_table[ii].typ = const_id_tok;
my_output(last_id);
}
'=' CONSTANT ';'
{ sym_table[ii].val=last_i_num;
new_line(); }
;

CONSTANT: i_num_tok
{
(void) sscanf(temp, "%ld", &last_i_num);
if (labs((long) last_i_num) > 32767)
(void) strcat(temp, "L");
my_output(temp);
$$ = ex_32;
}
| r_num_tok
{ my_output(temp);
$$ = ex_real;
}
| STRING
{ $$ = 0; }
| CONSTANT_ID
{ $$ = ex_32; }
;

STRING: string_literal_tok
{ int i, j; char s[132];
j = 1;
s[0] = '"';
for (i=1; yytext[i-1]!=0; i++) {
if (yytext[i] == '\\' || yytext[i] == '"')
s[j++]='\\';
else if (yytext[i] == '\'') i++;
s[j++] = yytext[i];
}
s[j-1] = '"';
s[j] = 0;
my_output(s);
}
| single_char_tok
{ char s[5];
s[0]='\'';
if (yytext[1] == '\\' || yytext[1] == '\'') {
s[2] = yytext[1];
s[1] = '\\';
s[3] = '\'';
s[4] = '\0';
}
else {
s[1] = yytext[1];
s[2]='\'';
s[3]='\0';
}
my_output(s);
}
;

CONSTANT_ID: const_id_tok
{ my_output(last_id); }
;

TYPE_DEC_PART: /* empty */
| type_tok TYPE_DEF_LIST
;

TYPE_DEF_LIST: TYPE_DEF
| TYPE_DEF_LIST TYPE_DEF
;

TYPE_DEF:
{ my_output("typedef"); }
undef_id_tok
{ ii = add_to_table(last_id);
sym_table[ii].typ = type_id_tok;
(void) strcpy(safe_string, last_id);
last_type = ii;
}
'='
{
array_bounds[0] = 0;
array_offset[0] = 0;
}
TYPE ';'
{ if (*array_offset) {
fprintf(stderr, "Cannot typedef arrays with offsets\n");
exit(1);
}
my_output(safe_string);
my_output(array_bounds);
semicolon();
last_type = -1;
}
;

TYPE: SIMPLE_TYPE
| STRUCTURED_TYPE
;

SIMPLE_TYPE: SUBRANGE_TYPE
{ if (last_type >= 0) {
sym_table[ii].val = lower_bound;
sym_table[ii].val_sym = lower_sym;
sym_table[ii].upper = upper_bound;
sym_table[ii].upper_sym = upper_sym;
ii= -1;
}
/* The following code says: if the bounds are known at translation time
* on an integral type, then we select the smallest type of data which
* can represent it in ANSI C. We only use unsigned types when necessary.
*/
if (lower_sym == -1 && upper_sym == -1) {
if (lower_bound>= -127 && upper_bound<=127)
my_output("schar");
else if (lower_bound >= 0
&& upper_bound <= 255)
my_output("unsigned char");
else if (lower_bound >= -32767
&& upper_bound <= 32767)
my_output("short");
else if (lower_bound >= 0
&& upper_bound <= 65535)
my_output(UNSIGNED_SHORT_STRING);
else my_output("integer");
}
else my_output("integer");
}
| TYPE_ID
;

SUBRANGE_TYPE: SUB_CONSTANT two_dots_tok SUB_CONSTANT
;

POSSIBLE_PLUS: /* empty */
| unary_plus_tok
;

SUB_CONSTANT: POSSIBLE_PLUS i_num_tok
{lower_bound = upper_bound;
lower_sym = upper_sym;
(void) sscanf(temp, "%ld", &upper_bound);
upper_sym = -1; /* no sym table entry */
}
| const_id_tok
{ lower_bound = upper_bound;
lower_sym = upper_sym;
upper_bound = sym_table[l_s].val;
upper_sym = l_s;
}
;

TYPE_ID: type_id_tok
{if (last_type >= 0) {
sym_table[last_type].var_not_needed = sym_table[l_s].var_not_needed;
sym_table[last_type].upper = sym_table[l_s].upper;
sym_table[last_type].upper_sym = sym_table[l_s].upper_sym;
sym_table[last_type].val = sym_table[l_s].val;
sym_table[last_type].val_sym = sym_table[l_s].val_sym;
}
my_output(last_id); }
;

STRUCTURED_TYPE: ARRAY_TYPE
{if (last_type >= 0)
sym_table[last_type].var_not_needed = TRUE;}
| RECORD_TYPE
| FILE_TYPE
{if (last_type >= 0)
sym_table[last_type].var_not_needed = TRUE;}
| POINTER_TYPE
{if (last_type >= 0)
sym_table[last_type].var_not_needed = FALSE;}
;

POINTER_TYPE: '^' type_id_tok
{if (last_type >= 0) {
sym_table[last_type].var_not_needed = sym_table[l_s].var_not_needed;
sym_table[last_type].upper = sym_table[l_s].upper;
sym_table[last_type].upper_sym = sym_table[l_s].upper_sym;
sym_table[last_type].val = sym_table[l_s].val;
sym_table[last_type].val_sym = sym_table[l_s].val_sym;
}
my_output(last_id); my_output("*"); }
| '^' undef_id_tok /* HH for Isitex */
{if (last_type >= 0) {
sym_table[last_type].var_not_needed = sym_table[l_s].var_not_needed;
sym_table[last_type].upper = sym_table[l_s].upper;
sym_table[last_type].upper_sym = sym_table[l_s].upper_sym;
sym_table[last_type].val = sym_table[l_s].val;
sym_table[last_type].val_sym = sym_table[l_s].val_sym;
}
my_output(last_id); my_output("*"); }
;

ARRAY_TYPE: array_tok '[' INDEX_TYPE ']' of_tok COMPONENT_TYPE
| array_tok '[' INDEX_TYPE ',' INDEX_TYPE ']' of_tok
COMPONENT_TYPE
;

INDEX_TYPE: SUBRANGE_TYPE
{ compute_array_bounds(); }
| type_id_tok
{ lower_bound = sym_table[l_s].val;
lower_sym = sym_table[l_s].val_sym;
upper_bound = sym_table[l_s].upper;
upper_sym = sym_table[l_s].upper_sym;
compute_array_bounds();
}
;

COMPONENT_TYPE: TYPE
;

RECORD_TYPE: record_tok
{ my_output("struct"); my_output("{"); indent++;}
FIELD_LIST end_tok
{ indent--; my_output("}"); semicolon(); }
;

FIELD_LIST: RECORD_SECTION
| FIELD_LIST ';' RECORD_SECTION
;

RECORD_SECTION:
{ field_list[0] = 0; }
FIELD_ID_LIST ':'
{
/*array_bounds[0] = 0;
array_offset[0] = 0;*/
}
TYPE
{ int i=0, j; char ltemp[80];
while(field_list[i++] == '!') {
j = 0;
while (field_list[i])
ltemp[j++] = field_list[i++];
i++;
if (field_list[i] == '!')
ltemp[j++] = ',';
ltemp[j] = 0;
my_output(ltemp);
}
semicolon();
}
| /* empty */
;

FIELD_ID_LIST: FIELD_ID
| FIELD_ID_LIST ',' FIELD_ID
;

FIELD_ID: undef_id_tok
{ int i=0, j=0;
while (field_list[i] == '!')
while(field_list[i++]);
ii = add_to_table(last_id);
sym_table[ii].typ = field_id_tok;
field_list[i++] = '!';
while (last_id[j])
field_list[i++] = last_id[j++];
field_list[i++] = 0;
field_list[i++] = 0;
}
| field_id_tok
{ int i=0, j=0;
while (field_list[i] == '!')
while(field_list[i++]);
field_list[i++] = '!';
while (last_id[j])
field_list[i++] = last_id[j++];
field_list[i++] = 0;
field_list[i++] = 0;
}
;

FILE_TYPE: file_tok of_tok
{ my_output("file_ptr /* of "); }
TYPE
{ my_output("*/"); }
;

VAR_DEC_PART: /* empty */
| var_tok VAR_DEC_LIST
;

VAR_DEC_LIST: VAR_DEC
| VAR_DEC_LIST VAR_DEC
;

VAR_DEC:
{ var_list[0] = 0;
array_bounds[0] = 0;
array_offset[0] = 0;
var_formals = FALSE;
ids_paramed = 0;
}
VAR_ID_DEC_LIST ':'
{
array_bounds[0] = 0;
array_offset[0] = 0;
}
TYPE ';'
{ fixup_var_list(); }
;

VAR_ID_DEC_LIST: VAR_ID
| VAR_ID_DEC_LIST ',' VAR_ID
;

VAR_ID: undef_id_tok
{ int i=0, j=0;
ii = add_to_table(last_id);
sym_table[ii].typ = var_id_tok;
sym_table[ii].var_formal = var_formals;
param_id_list[ids_paramed++] = ii;
while (var_list[i] == '!')
while(var_list[i++]);
var_list[i++] = '!';
while (last_id[j])
var_list[i++] = last_id[j++];
var_list[i++] = 0;
var_list[i++] = 0;
}
| var_id_tok
{ int i=0, j=0;
ii = add_to_table(last_id);
sym_table[ii].typ = var_id_tok;
sym_table[ii].var_formal = var_formals;
param_id_list[ids_paramed++] = ii;
while (var_list[i] == '!')
while (var_list[i++]);
var_list[i++] = '!';
while (last_id[j])
var_list[i++] = last_id[j++];
var_list[i++] = 0;
var_list[i++] = 0;
}
| field_id_tok
{ int i=0, j=0;
ii = add_to_table(last_id);
sym_table[ii].typ = var_id_tok;
sym_table[ii].var_formal = var_formals;
param_id_list[ids_paramed++] = ii;
while (var_list[i] == '!')
while(var_list[i++]);
var_list[i++] = '!';
while (last_id[j])
var_list[i++] = last_id[j++];
var_list[i++] = 0;
var_list[i++] = 0;
}
;

BODY: /* empty */
| begin_tok
{ my_output("void main_body() {");
indent++;
new_line();
}
STAT_LIST end_tok '.'
{ indent--; my_output("}"); new_line(); }
;

P_F_DEC_PART: /* empty */
| P_F_DEC
| P_F_DEC_PART P_F_DEC
;

P_F_DEC: PROCEDURE_DEC ';'
{ indent_line(); remove_locals(); }
| FUNCTION_DEC ';'
{ indent_line(); remove_locals(); }
;

PROCEDURE_DEC: PROCEDURE_HEAD BLOCK
;

PROCEDURE_HEAD: procedure_tok undef_id_tok
{ ii = add_to_table(last_id);
if (debug)
(void) fprintf(stderr, "%3d Procedure %s\n",
pf_count++, last_id);
sym_table[ii].typ = proc_id_tok;
(void) strcpy(my_routine, last_id);
uses_eqtb = uses_mem = FALSE;
my_output("void");
orig_std = std;
std = 0;
}
PARAM ';'
{(void) strcpy(fn_return_type, "void");
do_proc_args();
gen_function_head();}
| procedure_tok DECLARED_PROC
{ ii = l_s;
if (debug)
(void) fprintf(stderr, "%3d Procedure %s\n",
pf_count++, last_id);
(void) strcpy(my_routine, last_id);
my_output("void");
}
PARAM ';'
{(void) strcpy(fn_return_type, "void");
do_proc_args();
gen_function_head();}
;

PARAM: /* empty */
{ (void) strcpy(z_id, last_id);
mark();
ids_paramed = 0;
}
| '('
{ if (ansi) (void) strcpy(z_id, last_id);
else (void) sprintf(z_id, "z%s", last_id);
ids_paramed = 0;
if (sym_table[ii].typ == proc_id_tok)
sym_table[ii].typ = proc_param_tok;
else if (sym_table[ii].typ == fun_id_tok)
sym_table[ii].typ = fun_param_tok;
mark();
}
FORM_PAR_SEC_L ')'
;

FORM_PAR_SEC_L: FORM_PAR_SEC
| FORM_PAR_SEC_L ';' FORM_PAR_SEC
;

FORM_PAR_SEC1: { ids_typed = ids_paramed;}
VAR_ID_DEC_LIST ':' type_id_tok
{int i, need_var;
i = search_table(last_id);
need_var = !sym_table[i].var_not_needed;
for (i=ids_typed; i<ids_paramed; i++) {
(void) strcpy(arg_type[i], last_id);
if (need_var && sym_table[param_id_list[i]].var_formal)
(void) strcat(arg_type[i], " *");
else sym_table[param_id_list[i]].var_formal = FALSE;
}
}
;

FORM_PAR_SEC: {var_formals = 0;} FORM_PAR_SEC1
| var_tok {var_formals = 1;} FORM_PAR_SEC1
;

DECLARED_PROC : proc_id_tok
| proc_param_tok
;

FUNCTION_DEC: FUNCTION_HEAD BLOCK
;

FUNCTION_HEAD: function_tok undef_id_tok
{ orig_std = std;
std = 0;
ii = add_to_table(last_id);
if (debug)
(void) fprintf(stderr, "%3d Function %s\n",
pf_count++, last_id);
sym_table[ii].typ = fun_id_tok;
(void) strcpy(my_routine, last_id);
uses_eqtb = uses_mem = FALSE;
}
PARAM ':'
{ normal();
array_bounds[0] = 0;
array_offset[0] = 0;
}
RESULT_TYPE
{(void) strcpy(fn_return_type, yytext);
do_proc_args();
gen_function_head();
}
';'
|
function_tok DECLARED_FUN
{ orig_std = std;
std = 0;
ii = l_s;
if (debug)
(void) fprintf(stderr, "%3d Function %s\n",
pf_count++, last_id);
(void) strcpy(my_routine, last_id);
uses_eqtb = uses_mem = FALSE;
}
PARAM ':'
{ normal();
array_bounds[0] = 0;
array_offset[0] = 0;
}
RESULT_TYPE
{(void) strcpy(fn_return_type, yytext);
do_proc_args();
gen_function_head();
}
';'
;

DECLARED_FUN : fun_id_tok
| fun_param_tok
;

RESULT_TYPE: TYPE
;

STAT_PART: begin_tok STAT_LIST end_tok
;

COMPOUND_STAT: begin_tok
{my_output("{"); indent++; new_line();}
STAT_LIST end_tok
{ indent--; my_output("}"); new_line(); }
;

STAT_LIST: STATEMENT
| STAT_LIST ';' STATEMENT
;

STATEMENT: UNLAB_STAT
| S_LABEL ':'
UNLAB_STAT
;

S_LABEL: i_num_tok
{if (!doreturn(temp)) {
(void) sprintf(safe_string, "lab%s:",
temp);
my_output(safe_string);
}
}
;

UNLAB_STAT: SIMPLE_STAT
{ semicolon(); }
| STRUCT_STAT
{ semicolon(); }
;

SIMPLE_STAT: ASSIGN_STAT
| PROC_STAT
| GO_TO_STAT
| EMPTY_STAT
| break_tok
{my_output("break");}
;

ASSIGN_STAT: VARIABLE assign_tok
{ my_output("="); }
EXPRESS
| FUNC_ID_AS assign_tok
{ my_output("Result ="); }
EXPRESS
;

VARIABLE: var_id_tok
{ if (strcmp(last_id, "mem") == 0)
uses_mem = 1;
else if (strcmp(last_id, "eqtb") == 0)
uses_eqtb = 1;
if (sym_table[l_s].var_formal) {
(void) putchar('(');
(void) putchar('*');
my_output(last_id);
(void) putchar(')');
}
else
my_output(last_id);
$$ = ex_32;
}
VAR_DESIG_LIST
| var_id_tok '^' '.' /* HH for Isitex */
{ if (sym_table[l_s].var_formal) {
(void) putchar('(');
(void) putchar('*');
my_output(last_id);
(void) putchar(')');
}
else
my_output(last_id);
(void) putchar('-');
(void) putchar('>');
$$ = ex_32;
}
FIELD_VARIABLE
| var_id_tok '^'
{ (void) putchar('(');
(void) putchar('*');
if (sym_table[l_s].var_formal) {
(void) putchar('(');
(void) putchar('*');
my_output(last_id);
(void) putchar(')');
}
else
my_output(last_id);
(void) putchar(')');
$$ = ex_32;
}
| var_id_tok
{ if (sym_table[l_s].var_formal) {
(void) putchar('(');
(void) putchar('*');
my_output(last_id);
(void) putchar(')');
}
else
my_output(last_id);
$$ = ex_32; }
;

FIELD_VARIABLE: field_id_tok
{ my_output(last_id); }
VAR_DESIG_LIST
| field_id_tok '^' '.'
{ my_output(last_id);
(void) putchar('-');
(void) putchar('>');
}
FIELD_VARIABLE
| field_id_tok
{ my_output(last_id); }
;

FUNC_ID_AS: fun_id_tok
{ $$ = ex_32; }
| fun_param_tok
{ $$ = ex_32; }
;

VAR_DESIG_LIST: VAR_DESIG
| VAR_DESIG_LIST VAR_DESIG
;

VAR_DESIG: '['
{ my_output("["); }
EXPRESS VAR_DESIG1
{ my_output("]"); }
| '.' field_id_tok
{if (tex || mf) {
if (strcmp(last_id, "int")==0)
my_output(".cint");
else if (strcmp(last_id, "lh")==0)
my_output(".v.LH");
else if (strcmp(last_id, "rh")==0)
my_output(".v.RH");
else {
(void)sprintf(safe_string, ".%s", last_id);
my_output(safe_string);
}
}
else {
(void) sprintf(safe_string, ".%s", last_id);
my_output(safe_string);
}
}
| '.' hhb0_tok
{ my_output(".hh.b0");}
| '.' hhb1_tok
{ my_output(".hh.b1");}
;

VAR_DESIG1: ']'
| ','
{ my_output("][");}
EXPRESS ']'
;

EXPRESS: UNARY_OP EXPRESS %prec '*'
{ $$ = $2; }
| EXPRESS '+' {my_output("+");} EXPRESS
{$$ = max($1, $4);}
| EXPRESS '-' {my_output("-");} EXPRESS
{$$ = max($1, $4);}
| EXPRESS '*' {my_output("*");} EXPRESS
{$$ = max($1, $4);}
| EXPRESS div_tok {my_output("/");} EXPRESS
{$$ = max($1, $4);}
| EXPRESS '=' {my_output("==");} EXPRESS
{$$ = max($1, $4);}
| EXPRESS not_eq_tok {my_output("!=");} EXPRESS
{$$ = max($1, $4);}
| EXPRESS mod_tok {my_output("%");} EXPRESS
{$$ = max($1, $4);}
| EXPRESS '<' {my_output("<");} EXPRESS
{$$ = max($1, $4);}
| EXPRESS '>' {my_output(">");} EXPRESS
{$$ = max($1, $4);}
| EXPRESS less_eq_tok {my_output("<=");} EXPRESS
{$$ = max($1, $4);}
| EXPRESS great_eq_tok {my_output(">=");} EXPRESS
{$$ = max($1, $4);}
| EXPRESS and_tok {my_output("&&");} EXPRESS
{$$ = max($1, $4);}
| EXPRESS or_tok {my_output("||");} EXPRESS
{$$ = max($1, $4);}
| EXPRESS '/'
{ my_output("/ ((double)"); }
EXPRESS
{$$ = max($1, $4); my_output(")"); }
| FACTOR
{ $$ = $1; }
;

UNARY_OP: unary_plus_tok
| unary_minus_tok
{ my_output("- (integer)"); }
| not_tok
{ my_output("!"); }
;

FACTOR: '('
{ my_output("("); }
EXPRESS ')'
{ my_output(")"); $$ = $1; }
| VARIABLE
| CONSTANT
| fun_id_tok
{ my_output(last_id); my_output("()"); }
| fun_param_tok
{ my_output(last_id); }
PARAM_LIST
;

PARAM_LIST: '('
{ my_output("("); }
ACTUAL_PARAM_L ')'
{ my_output(")"); }
;

ACTUAL_PARAM_L: ACTUAL_PARAM
| ACTUAL_PARAM_L ','
{ my_output(","); }
ACTUAL_PARAM
;

ACTUAL_PARAM:
EXPRESS WIDTH_FIELD
;

WIDTH_FIELD: ':' i_num_tok
| /* empty */
;

PROC_STAT: proc_id_tok
{ my_output(last_id); my_output("()"); }
| undef_id_tok
{ my_output(last_id);
ii = add_to_table(last_id);
sym_table[ii].typ = proc_id_tok;
my_output("()");
}
| proc_param_tok
{ my_output(last_id); }
PARAM_LIST
;

GO_TO_STAT: goto_tok i_num_tok
{if (doreturn(temp)) {
if (strcmp(fn_return_type,"void"))
my_output("return(Result)");
else
my_output("return");
} else {
(void) sprintf(safe_string, "goto lab%s",
temp);
my_output(safe_string);
}
}
;

EMPTY_STAT: /* empty */
;

STRUCT_STAT: COMPOUND_STAT
| CONDIT_STAT
| REPETIT_STAT
;

CONDIT_STAT: IF_STATEMENT
| CASE_STATEMENT
;

IF_STATEMENT: BEGIN_IF_STAT
| BEGIN_IF_STAT ELSE_STAT
;

BEGIN_IF_STAT: if_tok
{ my_output("if"); my_output("("); }
EXPRESS
{ my_output(")"); new_line();}
then_tok STATEMENT
;

ELSE_STAT: else_tok
{ my_output("else"); }
STATEMENT
;

CASE_STATEMENT: case_tok
{ my_output("switch"); my_output("("); }
EXPRESS of_tok
{ my_output(")"); indent_line();
my_output("{"); indent++;
}
CASE_EL_LIST END_CASE
{ indent--; my_output("}"); new_line(); }
;

CASE_EL_LIST: CASE_ELEMENT
| CASE_EL_LIST ';' CASE_ELEMENT
;

CASE_ELEMENT: CASE_LAB_LIST ':' UNLAB_STAT
{ my_output("break"); semicolon(); }
;

CASE_LAB_LIST: CASE_LAB
| CASE_LAB_LIST ',' CASE_LAB
;

CASE_LAB: i_num_tok
{ my_output("case");
my_output(temp);
my_output(":"); indent_line();
}
| others_tok
{ my_output("default:"); indent_line(); }
;

END_CASE: end_tok
| ';' end_tok
;

REPETIT_STAT: WHILE_STATEMENT
| REP_STATEMENT
| FOR_STATEMENT
;

WHILE_STATEMENT: while_tok
{ my_output("while");
my_output("(");
}
EXPRESS
{ my_output(")"); }
do_tok STATEMENT
;

REP_STATEMENT: repeat_tok
{ my_output("do"); my_output("{"); indent++; }
STAT_LIST until_tok
{ indent--; my_output("}");
my_output("while"); my_output("( ! (");
}
EXPRESS
{ my_output(") )"); }
;

FOR_STATEMENT: for_tok
{
my_output("{");
my_output("register");
my_output("integer");
if (strict_for)
my_output("for_begin,");
my_output("for_end;");
}
CONTROL_VAR assign_tok
{ if (strict_for)
my_output("for_begin");
else
my_output(control_var);
my_output("="); }
FOR_LIST do_tok
{ my_output("; if (");
if (strict_for) my_output("for_begin");
else my_output(control_var);
my_output(relation);
my_output("for_end)");
if (strict_for) {
my_output("{");
my_output(control_var);
my_output("=");
my_output("for_begin");
semicolon();
}
my_output("do");
indent++;
new_line();}
STATEMENT
{
char *top = rindex(for_stack, '#');
indent--; new_line();
my_output("while");
my_output("(");
my_output(top+1);
my_output(")");
my_output(";");
my_output("}");
if (strict_for)
my_output("}");
*top=0;
new_line();
}
;

CONTROL_VAR: var_id_tok
{(void) strcpy(control_var, last_id); }
;

FOR_LIST: EXPRESS
{ my_output(";"); }
to_tok
{
(void) strcpy(relation, "<=");
my_output("for_end");
my_output("="); }
EXPRESS
{
(void) sprintf(for_stack + strlen(for_stack),
"#%s++ < for_end", control_var);
}
| EXPRESS
{ my_output(";"); }
downto_tok
{
(void) strcpy(relation, ">=");
my_output("for_end");
my_output("="); }
EXPRESS
{
(void) sprintf(for_stack + strlen(for_stack),
"#%s-- > for_end", control_var);
}
;
%%

static void compute_array_bounds()
{
long lb;
char tmp[200];

if (lower_sym == -1) { /* lower is a constant */
lb = lower_bound - 1;
if (lb==0) lb = -1; /* Treat lower_bound==1 as if lower_bound==0 */
if (upper_sym == -1) /* both constants */
(void) sprintf(tmp, "[%ld]", upper_bound - lb);
else { /* upper a symbol, lower constant */
if (lb < 0)
(void) sprintf(tmp, "[%s + %ld]",
symbol(upper_sym), (-lb));
else
(void) sprintf(tmp, "[%s - %ld]",
symbol(upper_sym), lb);
}
if (lower_bound < 0 || lower_bound > 1) {
if (*array_bounds) {
fprintf(stderr, "Cannot handle offset in second dimension\n");
exit(1);
}
if (lower_bound < 0) {
(void) sprintf(array_offset, "+%ld", -lower_bound);
} else {
(void) sprintf(array_offset, "-%ld", lower_bound);
}
}
(void) strcat(array_bounds, tmp);
}
else { /* lower is a symbol */
if (upper_sym != -1) /* both are symbols */
(void) sprintf(tmp, "[%s - %s + 1]", symbol(upper_sym),
symbol(lower_sym));
else { /* upper constant, lower symbol */
(void) sprintf(tmp, "[%ld - %s]", upper_bound + 1,
symbol(lower_sym));
}
if (*array_bounds) {
fprintf(stderr, "Cannot handle symbolic offset in second dimension\n");
exit(1);
}
(void) sprintf(array_offset, "- (int)(%s)", symbol(lower_sym));
(void) strcat(array_bounds, tmp);
}
}

static void fixup_var_list()
{
int i, j;
char output_string[100], real_symbol[100];

for (i=0; var_list[i++] == '!'; ) {
for (j=0; real_symbol[j++] = var_list[i++];);
if (*array_offset) {
(void) fprintf(std, "\n#define %s (%s %s)\n ",
real_symbol, next_temp, array_offset);
(void) strcpy(real_symbol, next_temp);
find_next_temp();
}
(void) sprintf(output_string, "%s%s%c",
real_symbol, array_bounds, (var_list[i]=='!' ? ',' : ' '));
my_output(output_string);
}
semicolon();
}

/*
* If we're not processing TeX, we return 0 (false). Otherwise,
* return 1 if the label is "10" and we're not in one of four TeX
* routines where the line labeled "10" isn't the end of the routine.
* Otherwise, return 0.
*/
static boolean doreturn(label)
char *label;
{
if (!tex) return(FALSE);
if (strcmp(label, "10")) return(FALSE);
if (strcmp(my_routine, "macrocall") == 0) return(FALSE);
if (strcmp(my_routine, "hpack") == 0) return(FALSE);
if (strcmp(my_routine, "vpackage") == 0) return(FALSE);
if (strcmp(my_routine, "trybreak") == 0) return(FALSE);
return(TRUE);
}

/* Return the absolute value of a long */
static long labs(x)
long x;
{
if (x < 0L) return(-x);
return(x);
}

static void do_proc_args()
{
int i, var;

/*
* If we want ANSI code and one of the parameters is a var parameter,
* then use the #define to add the &. We do this by adding a 'z' at
* the front of the name. gen_function_head will do the real work.
*/
if (ansi) {
var = 0;
for (i=0; i<ids_paramed; ++i)
var += sym_table[param_id_list[i]].var_formal;
if (var) {
for (i=strlen(z_id); i>=0; --i)
z_id[i+1] = z_id[i];
z_id[0] = 'z';
}
}

if (ansi) {
fprintf(coerce, "%s %s(", fn_return_type, z_id);
if (ids_paramed == 0) fprintf(coerce, "void");
for (i=0; i<ids_paramed; i++) {
if (i > 0) putc(',', coerce);
fprintf(coerce, "%s %s",
arg_type[i],
symbol(param_id_list[i]));
}
fprintf(coerce, ");\n");
} else
fprintf(coerce, "%s %s();\n", fn_return_type, z_id);
}

static void gen_function_head()
{
int i;

if (strcmp(my_routine, z_id)) {
fprintf(coerce, "#define %s(", my_routine);
for (i=0; i<ids_paramed; i++) {
if (i > 0)
fprintf(coerce, ", %s", symbol(param_id_list[i]));
else
fprintf(coerce, "%s", symbol(param_id_list[i]));
}
fprintf(coerce, ") %s(", z_id);
for (i=0; i<ids_paramed; i++) {
if (i > 0)
fputs(", ", coerce);
if (!ansi) /* ansi doesn't need the cast */
fprintf(coerce, "(%s) ", arg_type[i]);
fprintf(coerce, "%s(%s)",
sym_table[param_id_list[i]].var_formal?"&":"",
symbol(param_id_list[i]));
}
fprintf(coerce, ")\n");
}
std = orig_std;
my_output(z_id);
my_output("(");
if (ansi) {
for (i=0; i<ids_paramed; i++) {
if (i > 0) my_output(",");
my_output(arg_type[i]);
my_output(symbol(param_id_list[i]));
}
my_output(")");
indent_line();
} else { /* Not ansi */
for (i=0; i<ids_paramed; i++) {
if (i > 0) my_output(",");
my_output(symbol(param_id_list[i]));
}
my_output(")");
indent_line();
for (i=0; i<ids_paramed; i++) {
my_output(arg_type[i]);
my_output(symbol(param_id_list[i]));
semicolon();
}
}
}