[unix-history] / usr / src / cmd / mip / cgram.y

%term NAME  2
%term STRING  3
%term ICON  4
%term FCON  5
%term PLUS   6
%term MINUS   8
%term MUL   11
%term AND   14
%term OR   17
%term ER   19
%term QUEST  21
%term COLON  22
%term ANDAND  23
%term OROR  24

/*	special interfaces for yacc alone */
/*	These serve as abbreviations of 2 or more ops:
	ASOP	=, = ops
	RELOP	LE,LT,GE,GT
	EQUOP	EQ,NE
	DIVOP	DIV,MOD
	SHIFTOP	LS,RS
	ICOP	ICR,DECR
	UNOP	NOT,COMPL
	STROP	DOT,STREF

	*/
%term ASOP  25
%term RELOP  26
%term EQUOP  27
%term DIVOP  28
%term SHIFTOP  29
%term INCOP  30
%term UNOP  31
%term STROP  32

/*	reserved words, etc */
%term TYPE  33
%term CLASS  34
%term STRUCT  35
%term RETURN  36
%term GOTO  37
%term IF  38
%term ELSE  39
%term SWITCH  40
%term BREAK  41
%term CONTINUE  42
%term WHILE  43
%term DO  44
%term FOR  45
%term DEFAULT  46
%term CASE  47
%term SIZEOF  48
%term ENUM 49


/*	little symbols, etc. */
/*	namely,

	LP	(
	RP	)

	LC	{
	RC	}

	LB	[
	RB	]

	CM	,
	SM	;

	*/

%term LP  50
%term RP  51
%term LC  52
%term RC  53
%term LB  54
%term RB  55
%term CM  56
%term SM  57
%term ASSIGN  58

/* at last count, there were 7 shift/reduce, 1 reduce/reduce conflicts
/* these involved:
	if/else
	recognizing functions in various contexts, including declarations
	error recovery
	*/

%left CM
%right ASOP ASSIGN
%right QUEST COLON
%left OROR
%left ANDAND
%left OR
%left ER
%left AND
%left EQUOP
%left RELOP
%left SHIFTOP
%left PLUS MINUS
%left MUL DIVOP
%right UNOP
%right INCOP SIZEOF
%left LB LP STROP
%{
# include "mfile1"
%}

	/* define types */
%start ext_def_list

%type <intval> con_e ifelprefix ifprefix whprefix forprefix doprefix switchpart
		enum_head str_head name_lp
%type <nodep> e .e term attributes oattributes type enum_dcl struct_dcl
		cast_type null_decl funct_idn declarator fdeclarator nfdeclarator
		elist

%token <intval> CLASS NAME STRUCT RELOP CM DIVOP PLUS MINUS SHIFTOP MUL AND OR ER ANDAND OROR
		ASSIGN STROP INCOP UNOP ICON
%token <nodep> TYPE

%%

%{
	static int fake = 0;
	static char fakename[NCHNAM+1];
%}

ext_def_list:	   ext_def_list external_def
		|
			=ftnend();
		;
external_def:	   data_def
			={ curclass = SNULL;  blevel = 0; }
		|  error
			={ curclass = SNULL;  blevel = 0; }
		;
data_def:
		   oattributes  SM
			={  $1->op = FREE; }
		|  oattributes init_dcl_list  SM
			={  $1->op = FREE; }
		|  oattributes fdeclarator {
				defid( tymerge($1,$2), curclass==STATIC?STATIC:EXTDEF );
#ifndef LINT
				pfstab(stab[$2->rval].sname);
#endif
				}  function_body
			={  
			    if( blevel ) cerror( "function level error" );
			    if( reached ) retstat |= NRETVAL; 
			    $1->op = FREE;
			    ftnend();
			    }
		;

function_body:	   arg_dcl_list compoundstmt
		;
arg_dcl_list:	   arg_dcl_list declaration
		| 	={  blevel = 1; }
		;

stmt_list:	   stmt_list statement
		|  /* empty */
			={  bccode();
			    locctr(PROG);
			    }
		;

r_dcl_stat_list	:  dcl_stat_list attributes SM
			={  $2->op = FREE; 
#ifndef LINT
			    plcstab(blevel);
#endif
			    }
		|  dcl_stat_list attributes init_dcl_list SM
			={  $2->op = FREE; 
#ifndef LINT
			    plcstab(blevel);
#endif
			    }
		;

dcl_stat_list	:  dcl_stat_list attributes SM
			={  $2->op = FREE; }
		|  dcl_stat_list attributes init_dcl_list SM
			={  $2->op = FREE; }
		|  /* empty */
		;
declaration:	   attributes declarator_list  SM
			={ curclass = SNULL;  $1->op = FREE; }
		|  attributes SM
			={ curclass = SNULL;  $1->op = FREE; }
		|  error  SM
			={  curclass = SNULL; }
		;
oattributes:	  attributes
		|  /* VOID */
			={  $$ = mkty(INT,0,INT);  curclass = SNULL; }
		;
attributes:	   class type
			={  $$ = $2; }
		|  type class
		|  class
			={  $$ = mkty(INT,0,INT); }
		|  type
			={ curclass = SNULL ; }
		;


class:		  CLASS
			={  curclass = $1; }
		;

type:		   TYPE
		|  TYPE TYPE
			={  $1->type = types( $1->type, $2->type, UNDEF );
			    $2->op = FREE;
			    }
		|  TYPE TYPE TYPE
			={  $1->type = types( $1->type, $2->type, $3->type );
			    $2->op = $3->op = FREE;
			    }
		|  struct_dcl
		|  enum_dcl
		;

enum_dcl:	   enum_head LC moe_list optcomma RC
			={ $$ = dclstruct($1); }
		|  ENUM NAME
			={  $$ = rstruct($2,0);  stwart = instruct; }
		;

enum_head:	   ENUM
			={  $$ = bstruct(-1,0); }
		|  ENUM NAME
			={  $$ = bstruct($2,0); }
		;

moe_list:	   moe
		|  moe_list CM moe
		;

moe:		   NAME
			={  moedef( $1 ); }
		|  NAME ASSIGN con_e
			={  strucoff = $3;  moedef( $1 ); }
		;

struct_dcl:	   str_head LC type_dcl_list optsemi RC
			={ $$ = dclstruct($1);  }
		|  STRUCT NAME
			={  $$ = rstruct($2,$1); }
		;

str_head:	   STRUCT
			={  $$ = bstruct(-1,$1);  stwart=0; }
		|  STRUCT NAME
			={  $$ = bstruct($2,$1);  stwart=0;  }
		;

type_dcl_list:	   type_declaration
		|  type_dcl_list SM type_declaration
		;

type_declaration:  type declarator_list
			={ curclass = SNULL;  stwart=0; $1->op = FREE; }
		|  type
			={  if( curclass != MOU ){
				curclass = SNULL;
				}
			    else {
				sprintf( fakename, "$%dFAKE", fake++ );
				defid( tymerge($1, bdty(NAME,NIL,lookup( fakename, SMOS ))), curclass );
				}
			    stwart = 0;
			    $1->op = FREE;
			    }
		;


declarator_list:   declarator
			={ defid( tymerge($<nodep>0,$1), curclass);  stwart = instruct; }
		|  declarator_list  CM {$<nodep>$=$<nodep>0;}  declarator
			={ defid( tymerge($<nodep>0,$4), curclass);  stwart = instruct; }
		;
declarator:	   fdeclarator
		|  nfdeclarator
		|  nfdeclarator COLON con_e
			%prec CM
			={  if( !(instruct&INSTRUCT) ) uerror( "field outside of structure" );
			    if( $3<0 || $3 >= FIELD ){
				uerror( "illegal field size" );
				$3 = 1;
				}
			    defid( tymerge($<nodep>0,$1), FIELD|$3 );
			    $$ = NIL;
			    }
		|  COLON con_e
			%prec CM
			={  if( !(instruct&INSTRUCT) ) uerror( "field outside of structure" );
			    falloc( stab, $2, -1, $<nodep>0 );  /* alignment or hole */
			    $$ = NIL;
			    }
		|  error
			={  $$ = NIL; }
		;

		/* int (a)();   is not a function --- sorry! */
nfdeclarator:	   MUL nfdeclarator		
			={  umul:
				$$ = bdty( UNARY MUL, $2, 0 ); }
		|  nfdeclarator  LP   RP		
			={  uftn:
				$$ = bdty( UNARY CALL, $1, 0 );  }
		|  nfdeclarator LB RB		
			={  uary:
				$$ = bdty( LB, $1, 0 );  }
		|  nfdeclarator LB con_e RB	
			={  bary:
				if( (int)$3 <= 0 ) werror( "zero or negative subscript" );
				$$ = bdty( LB, $1, $3 );  }
		|  NAME  		
			={  $$ = bdty( NAME, NIL, $1 );  }
		|   LP  nfdeclarator  RP 		
			={ $$=$2; }
		;
fdeclarator:	   MUL fdeclarator
			={  goto umul; }
		|  fdeclarator  LP   RP
			={  goto uftn; }
		|  fdeclarator LB RB
			={  goto uary; }
		|  fdeclarator LB con_e RB
			={  goto bary; }
		|   LP  fdeclarator  RP
			={ $$ = $2; }
		|  name_lp  name_list  RP
			={
				if( blevel!=0 ) uerror("function declaration in bad context");
				$$ = bdty( UNARY CALL, bdty(NAME,NIL,$1), 0 );
				stwart = 0;
				}
		|  name_lp RP
			={
				$$ = bdty( UNARY CALL, bdty(NAME,NIL,$1), 0 );
				stwart = 0;
				}
		;

name_lp:	  NAME LP
			={
				/* turn off typedefs for argument names */
				stwart = SEENAME;
				}
		;

name_list:	   NAME			
			={ ftnarg( $1 );  stwart = SEENAME; }
		|  name_list  CM  NAME 
			={ ftnarg( $3 );  stwart = SEENAME; }
		;
		/* always preceeded by attributes: thus the $<nodep>0's */
init_dcl_list:	   init_declarator
			%prec CM
		|  init_dcl_list  CM {$<nodep>$=$<nodep>0;}  init_declarator
		;
		/* always preceeded by attributes */
xnfdeclarator:	   nfdeclarator
			={  defid( $1 = tymerge($<nodep>0,$1), curclass);
			    beginit($1->rval);
			    }
		|  error
		;
		/* always preceeded by attributes */
init_declarator:   nfdeclarator
			={  nidcl( tymerge($<nodep>0,$1) ); }
		|  fdeclarator
			={  defid( tymerge($<nodep>0,$1), uclass(curclass) );
			}
		|  xnfdeclarator optasgn e
			%prec CM
			={  doinit( $3 );
			    endinit(); }
		|  xnfdeclarator optasgn LC init_list optcomma RC
			={  endinit(); }
		;

init_list:	   initializer
			%prec CM
		|  init_list  CM  initializer
		;
initializer:	   e
			%prec CM
			={  doinit( $1 ); }
		|  ibrace init_list optcomma RC
			={  irbrace(); }
		;

optcomma	:	/* VOID */
		|  CM
		;

optsemi		:	/* VOID */
		|  SM
		;

optasgn		:	/* VOID */
			={  werror( "old-fashioned initialization: use =" ); }
		|  ASSIGN
		;

ibrace		: LC
			={  ilbrace(); }
		;

/*	STATEMENTS	*/

compoundstmt:	   dcmpstmt
		|  cmpstmt
		;

dcmpstmt:	   begin r_dcl_stat_list stmt_list RC
			={  
#ifndef LINT
			    prcstab(blevel);
#endif
			    --blevel;
			    if( blevel == 1 ) blevel = 0;
			    clearst( blevel );
			    checkst( blevel );
			    autooff = *--psavbc;
			    regvar = *--psavbc;
			    }
		;

cmpstmt:	   begin stmt_list RC
			={  --blevel;
			    if( blevel == 1 ) blevel = 0;
			    clearst( blevel );
			    checkst( blevel );
			    autooff = *--psavbc;
			    regvar = *--psavbc;
			    }
		;

begin:		  LC
			={  if( blevel == 1 ) dclargs();
			    ++blevel;
			    if( psavbc > &asavbc[BCSZ-2] ) cerror( "nesting too deep" );
			    *psavbc++ = regvar;
			    *psavbc++ = autooff;
			    }
		;

statement:	   e   SM
			={ ecomp( $1 ); }
		|  compoundstmt
		|  ifprefix statement
			={ deflab($1);
			   reached = 1;
			   }
		|  ifelprefix statement
			={  if( $1 != NOLAB ){
				deflab( $1 );
				reached = 1;
				}
			    }
		|  whprefix statement
			={  branch(  contlab );
			    deflab( brklab );
			    if( (flostat&FBRK) || !(flostat&FLOOP)) reached = 1;
			    else reached = 0;
			    resetbc(0);
			    }
		|  doprefix statement WHILE  LP  e  RP   SM
			={  deflab( contlab );
			    if( flostat & FCONT ) reached = 1;
			    ecomp( buildtree( CBRANCH, buildtree( NOT, $5, NIL ), bcon( $1 ) ) );
			    deflab( brklab );
			    reached = 1;
			    resetbc(0);
			    }
		|  forprefix .e RP statement
			={  deflab( contlab );
			    if( flostat&FCONT ) reached = 1;
			    if( $2 ) ecomp( $2 );
			    branch( $1 );
			    deflab( brklab );
			    if( (flostat&FBRK) || !(flostat&FLOOP) ) reached = 1;
			    else reached = 0;
			    resetbc(0);
			    }
		| switchpart statement
			={  if( reached ) branch( brklab );
			    deflab( $1 );
			   swend();
			    deflab(brklab);
			    if( (flostat&FBRK) || !(flostat&FDEF) ) reached = 1;
			    resetbc(FCONT);
			    }
		|  BREAK  SM
			={  if( brklab == NOLAB ) uerror( "illegal break");
			    else if(reached) branch( brklab );
			    flostat |= FBRK;
			    if( brkflag ) goto rch;
			    reached = 0;
			    }
		|  CONTINUE  SM
			={  if( contlab == NOLAB ) uerror( "illegal continue");
			    else branch( contlab );
			    flostat |= FCONT;
			    goto rch;
			    }
		|  RETURN  SM
			={  retstat |= NRETVAL;
			    branch( retlab );
			rch:
			    if( !reached ) werror( "statement not reached");
			    reached = 0;
			    }
		|  RETURN e  SM
			={  register NODE *temp;
			    idname = curftn;
			    temp = buildtree( NAME, NIL, NIL );
			    temp->type = DECREF( temp->type );
			    temp = buildtree( RETURN, temp, $2 );
			    /* now, we have the type of the RHS correct */
			    temp->left->op = FREE;
			    temp->op = FREE;
			    ecomp( buildtree( FORCE, temp->right, NIL ) );
			    retstat |= RETVAL;
			    branch( retlab );
			    reached = 0;
			    }
		|  GOTO NAME SM
			={  register NODE *q;
			    q = block( FREE, NIL, NIL, INT|ARY, 0, INT );
			    q->rval = idname = $2;
			    defid( q, ULABEL );
			    stab[idname].suse = -lineno;
			    branch( stab[idname].offset );
			    goto rch;
			    }
		|   SM
		|  error  SM
		|  error RC
		|  label statement
		;
label:		   NAME COLON
			={  register NODE *q;
			    q = block( FREE, NIL, NIL, INT|ARY, 0, LABEL );
			    q->rval = $1;
			    defid( q, LABEL );
			    reached = 1;
			    }
		|  CASE e COLON
			={  addcase($2);
			    reached = 1;
			    }
		|  DEFAULT COLON
			={  reached = 1;
			    adddef();
			    flostat |= FDEF;
			    }
		;
doprefix:	DO
			={  savebc();
			    if( !reached ) werror( "loop not entered at top");
			    brklab = getlab();
			    contlab = getlab();
			    deflab( $$ = getlab() );
			    reached = 1;
			    }
		;
ifprefix:	IF LP e RP
			={  ecomp( buildtree( CBRANCH, $3, bcon( $$=getlab()) ) ) ;
			    reached = 1;
			    }
		;
ifelprefix:	  ifprefix statement ELSE
			={  if( reached ) branch( $$ = getlab() );
			    else $$ = NOLAB;
			    deflab( $1 );
			    reached = 1;
			    }
		;

whprefix:	  WHILE  LP  e  RP
			={  savebc();
			    if( !reached ) werror( "loop not entered at top");
			    if( $3->op == ICON && $3->lval != 0 ) flostat = FLOOP;
			    deflab( contlab = getlab() );
			    reached = 1;
			    brklab = getlab();
			    if( flostat == FLOOP ) tfree( $3 );
			    else ecomp( buildtree( CBRANCH, $3, bcon( brklab) ) );
			    }
		;
forprefix:	  FOR  LP  .e  SM .e  SM 
			={  if( $3 ) ecomp( $3 );
			    else if( !reached ) werror( "loop not entered at top");
			    savebc();
			    contlab = getlab();
			    brklab = getlab();
			    deflab( $$ = getlab() );
			    reached = 1;
			    if( $5 ) ecomp( buildtree( CBRANCH, $5, bcon( brklab) ) );
			    else flostat |= FLOOP;
			    }
		;
switchpart:	   SWITCH  LP  e  RP
			={  savebc();
			    brklab = getlab();
			    ecomp( buildtree( FORCE, $3, NIL ) );
			    branch( $$ = getlab() );
			    swstart();
			    reached = 0;
			    }
		;
/*	EXPRESSIONS	*/
con_e:		   { $<intval>$=instruct; stwart=instruct=0; } e
			%prec CM
			={  $$ = icons( $2 );  instruct=$<intval>1; }
		;
.e:		   e
		|
			={ $$=0; }
		;
elist:		   e
			%prec CM
		|  elist  CM  e
			={  goto bop; }
		;

e:		   e RELOP e
			={
			preconf:
			    if( yychar==RELOP||yychar==EQUOP||yychar==AND||yychar==OR||yychar==ER ){
			    precplaint:
				if( hflag ) werror( "precedence confusion possible: parenthesize!" );
				}
			bop:
			    $$ = buildtree( $2, $1, $3 );
			    }
		|  e CM e
			={  $2 = COMOP;
			    goto bop;
			    }
		|  e DIVOP e
			={  goto bop; }
		|  e PLUS e
			={  if(yychar==SHIFTOP) goto precplaint; else goto bop; }
		|  e MINUS e
			={  if(yychar==SHIFTOP ) goto precplaint; else goto bop; }
		|  e SHIFTOP e
			={  if(yychar==PLUS||yychar==MINUS) goto precplaint; else goto bop; }
		|  e MUL e
			={  goto bop; }
		|  e EQUOP  e
			={  goto preconf; }
		|  e AND e
			={  if( yychar==RELOP||yychar==EQUOP ) goto preconf;  else goto bop; }
		|  e OR e
			={  if(yychar==RELOP||yychar==EQUOP) goto preconf; else goto bop; }
		|  e ER e
			={  if(yychar==RELOP||yychar==EQUOP) goto preconf; else goto bop; }
		|  e ANDAND e
			={  goto bop; }
		|  e OROR e
			={  goto bop; }
		|  e MUL ASSIGN e
			={  abop:
				$$ = buildtree( ASG $2, $1, $4 );
				}
		|  e DIVOP ASSIGN e
			={  goto abop; }
		|  e PLUS ASSIGN e
			={  goto abop; }
		|  e MINUS ASSIGN e
			={  goto abop; }
		|  e SHIFTOP ASSIGN e
			={  goto abop; }
		|  e AND ASSIGN e
			={  goto abop; }
		|  e OR ASSIGN e
			={  goto abop; }
		|  e ER ASSIGN e
			={  goto abop; }
		|  e QUEST e COLON e
			={  $$=buildtree(QUEST, $1, buildtree( COLON, $3, $5 ) );
			    }
		|  e ASOP e
			={  werror( "old-fashioned assignment operator" );  goto bop; }
		|  e ASSIGN e
			={  goto bop; }
		|  term
		;
term:		   term INCOP
			={  $$ = buildtree( $2, $1, bcon(1) ); }
		|  MUL term
			={ ubop:
			    $$ = buildtree( UNARY $1, $2, NIL );
			    }
		|  AND term
			={  if( ISFTN($2->type) || ISARY($2->type) ){
				werror( "& before array or function: ignored" );
				$$ = $2;
				}
			    else goto ubop;
			    }
		|  MINUS term
			={  goto ubop; }
		|  UNOP term
			={
			    $$ = buildtree( $1, $2, NIL );
			    }
		|  INCOP term
			={  $$ = buildtree( $1==INCR ? ASG PLUS : ASG MINUS,
						$2,
						bcon(1)  );
			    }
		|  SIZEOF term
			={  $$ = doszof( $2 ); }
		|  LP cast_type RP term  %prec INCOP
			={  $$ = buildtree( CAST, $2, $4 );
			    $$->left->op = FREE;
			    $$->op = FREE;
			    $$ = $$->right;
			    }
		|  SIZEOF LP cast_type RP  %prec SIZEOF
			={  $$ = doszof( $3 ); }
		|  term LB e RB
			={  $$ = buildtree( UNARY MUL, buildtree( PLUS, $1, $3 ), NIL ); }
		|  funct_idn  RP
			={  $$=buildtree(UNARY CALL,$1,NIL); }
		|  funct_idn elist  RP
			={  $$=buildtree(CALL,$1,$2); }
		|  term STROP NAME
			={  if( $2 == DOT ){
				$1 = buildtree( UNARY AND, $1, NIL );
				}
			    idname = $3;
			    $$ = buildtree( STREF, $1, buildtree( NAME, NIL, NIL ) );
			    }
		|  NAME
			={  idname = $1;
			    /* recognize identifiers in initializations */
			    if( blevel==0 && stab[idname].stype == UNDEF ) {
				register NODE *q;
				werror( "undeclared initializer name %.8s", stab[idname].sname );
				q = block( FREE, NIL, NIL, INT, 0, INT );
				q->rval = idname;
				defid( q, EXTERN );
				}
			    $$=buildtree(NAME,NIL,NIL);
			    stab[$1].suse = -lineno;
			}
		|  ICON
			={  $$=bcon(0);
			    $$->lval = lastcon;
			    $$->rval = NONAME;
			    if( $1 ) $$->csiz = $$->type = ctype(LONG);
			    }
		|  FCON
			={  $$=buildtree(FCON,NIL,NIL);
			    $$->dval = dcon;
			    }
		|  STRING
			={  $$ = getstr(); /* get string contents */ }
		|   LP  e  RP
			={ $$=$2; }
		;

cast_type:	  type null_decl
			={
			$$ = tymerge( $1, $2 );
			$$->op = NAME;
			$1->op = FREE;
			}
		;

null_decl:	   /* empty */
			={ $$ = bdty( NAME, NIL, -1 ); }
		|  LP RP
			={ $$ = bdty( UNARY CALL, bdty(NAME,NIL,-1),0); }
		|  LP null_decl RP LP RP
			={  $$ = bdty( UNARY CALL, $2, 0 ); }
		|  MUL null_decl
			={  goto umul; }
		|  null_decl LB RB
			={  goto uary; }
		|  null_decl LB con_e RB
			={  goto bary;  }
		|  LP null_decl RP
			={ $$ = $2; }
		;

funct_idn:	   NAME  LP 
			={  if( stab[$1].stype == UNDEF ){
				register NODE *q;
				q = block( FREE, NIL, NIL, FTN|INT, 0, INT );
				q->rval = $1;
				defid( q, EXTERN );
				}
			    idname = $1;
			    $$=buildtree(NAME,NIL,NIL);
			    stab[idname].suse = -lineno;
			}
		|  term  LP 
		;
%%

NODE *
mkty( t, d, s ) unsigned t; {
	return( block( TYPE, NIL, NIL, t, d, s ) );
	}

NODE *
bdty( op, p, v ) NODE *p; {
	register NODE *q;

	q = block( op, p, NIL, INT, 0, INT );

	switch( op ){

	case UNARY MUL:
	case UNARY CALL:
		break;

	case LB:
		q->right = bcon(v);
		break;

	case NAME:
		q->rval = v;
		break;

	default:
		cerror( "bad bdty" );
		}

	return( q );
	}

dstash( n ){ /* put n into the dimension table */
	if( curdim >= DIMTABSZ-1 ){
		cerror( "dimension table overflow");
		}
	dimtab[ curdim++ ] = n;
	}

savebc() {
	if( psavbc > & asavbc[BCSZ-4 ] ){
		cerror( "whiles, fors, etc. too deeply nested");
		}
	*psavbc++ = brklab;
	*psavbc++ = contlab;
	*psavbc++ = flostat;
	*psavbc++ = swx;
	flostat = 0;
	}

resetbc(mask){

	swx = *--psavbc;
	flostat = *--psavbc | (flostat&mask);
	contlab = *--psavbc;
	brklab = *--psavbc;

	}

addcase(p) NODE *p; { /* add case to switch */

	p = optim( p );  /* change enum to ints */
	if( p->op != ICON ){
		uerror( "non-constant case expression");
		return;
		}
	if( swp == swtab ){
		uerror( "case not in switch");
		return;
		}
	if( swp >= &swtab[SWITSZ] ){
		cerror( "switch table overflow");
		}
	swp->sval = p->lval;
	deflab( swp->slab = getlab() );
	++swp;
	tfree(p);
	}

adddef(){ /* add default case to switch */
	if( swtab[swx].slab >= 0 ){
		uerror( "duplicate default in switch");
		return;
		}
	if( swp == swtab ){
		uerror( "default not inside switch");
		return;
		}
	deflab( swtab[swx].slab = getlab() );
	}

swstart(){
	/* begin a switch block */
	if( swp >= &swtab[SWITSZ] ){
		cerror( "switch table overflow");
		}
	swx = swp - swtab;
	swp->slab = -1;
	++swp;
	}

swend(){ /* end a switch block */

	register struct sw *swbeg, *p, *q, *r, *r1;
	CONSZ temp;
	int tempi;

	swbeg = &swtab[swx+1];

	/* sort */

	r1 = swbeg;
	r = swp-1;

	while( swbeg < r ){
		/* bubble largest to end */
		for( q=swbeg; q<r; ++q ){
			if( q->sval > (q+1)->sval ){
				/* swap */
				r1 = q+1;
				temp = q->sval;
				q->sval = r1->sval;
				r1->sval = temp;
				tempi = q->slab;
				q->slab = r1->slab;
				r1->slab = tempi;
				}
			}
		r = r1;
		r1 = swbeg;
		}

	/* it is now sorted */

	for( p = swbeg+1; p<swp; ++p ){
		if( p->sval == (p-1)->sval ){
			uerror( "duplicate case in switch, %d", tempi=p->sval );
			return;
			}
		}

	genswitch( swbeg-1, swp-swbeg );
	swp = swbeg-1;
	}
Commit	Line	Data
3d1c2c08 TL	1	%term NAME 2
	2	%term STRING 3
	3	%term ICON 4
	4	%term FCON 5
	5	%term PLUS 6
	6	%term MINUS 8
	7	%term MUL 11
	8	%term AND 14
	9	%term OR 17
	10	%term ER 19
	11	%term QUEST 21
	12	%term COLON 22
	13	%term ANDAND 23
	14	%term OROR 24
	15
	16	/* special interfaces for yacc alone */
	17	/* These serve as abbreviations of 2 or more ops:
	18	ASOP =, = ops
	19	RELOP LE,LT,GE,GT
	20	EQUOP EQ,NE
	21	DIVOP DIV,MOD
	22	SHIFTOP LS,RS
	23	ICOP ICR,DECR
	24	UNOP NOT,COMPL
	25	STROP DOT,STREF
	26
	27	*/
	28	%term ASOP 25
	29	%term RELOP 26
	30	%term EQUOP 27
	31	%term DIVOP 28
	32	%term SHIFTOP 29
	33	%term INCOP 30
	34	%term UNOP 31
	35	%term STROP 32
	36
	37	/* reserved words, etc */
	38	%term TYPE 33
	39	%term CLASS 34
	40	%term STRUCT 35
	41	%term RETURN 36
	42	%term GOTO 37
	43	%term IF 38
	44	%term ELSE 39
	45	%term SWITCH 40
	46	%term BREAK 41
	47	%term CONTINUE 42
	48	%term WHILE 43
	49	%term DO 44
	50	%term FOR 45
	51	%term DEFAULT 46
	52	%term CASE 47
	53	%term SIZEOF 48
	54	%term ENUM 49
	55
	56
	57	/* little symbols, etc. */
	58	/* namely,
	59
	60	LP (
	61	RP )
	62
	63	LC {
	64	RC }
65
66	LB [
67	RB ]
68
69	CM ,
70	SM ;
71
72	*/
73
74	%term LP 50
75	%term RP 51
76	%term LC 52
77	%term RC 53
78	%term LB 54
79	%term RB 55
80	%term CM 56
81	%term SM 57
82	%term ASSIGN 58
83
84	/* at last count, there were 7 shift/reduce, 1 reduce/reduce conflicts
85	/* these involved:
86	if/else
87	recognizing functions in various contexts, including declarations
88	error recovery
89	*/
90
91	%left CM
92	%right ASOP ASSIGN
93	%right QUEST COLON
94	%left OROR
95	%left ANDAND
96	%left OR
97	%left ER
98	%left AND
99	%left EQUOP
100	%left RELOP
101	%left SHIFTOP
102	%left PLUS MINUS
103	%left MUL DIVOP
104	%right UNOP
105	%right INCOP SIZEOF
106	%left LB LP STROP
107	%{
108	# include "mfile1"
109	%}
110
111	/* define types */
112	%start ext_def_list
113
114	%type <intval> con_e ifelprefix ifprefix whprefix forprefix doprefix switchpart
115	enum_head str_head name_lp
116	%type <nodep> e .e term attributes oattributes type enum_dcl struct_dcl
117	cast_type null_decl funct_idn declarator fdeclarator nfdeclarator
118	elist
119
120	%token <intval> CLASS NAME STRUCT RELOP CM DIVOP PLUS MINUS SHIFTOP MUL AND OR ER ANDAND OROR
121	ASSIGN STROP INCOP UNOP ICON
122	%token <nodep> TYPE
123
124	%%
125
126	%{
127	static int fake = 0;
128	static char fakename[NCHNAM+1];
129	%}
130
131	ext_def_list: ext_def_list external_def
132	\|
133	=ftnend();
134	;
135	external_def: data_def
136	={ curclass = SNULL; blevel = 0; }
137	\| error
138	={ curclass = SNULL; blevel = 0; }
139	;
140	data_def:
141	oattributes SM
142	={ $1->op = FREE; }
143	\| oattributes init_dcl_list SM
144	={ $1->op = FREE; }
145	\| oattributes fdeclarator {
146	defid( tymerge($1,$2), curclass==STATIC?STATIC:EXTDEF );
147	#ifndef LINT
148	pfstab(stab[$2->rval].sname);
149	#endif
150	} function_body
151	={
152	if( blevel ) cerror( "function level error" );
153	if( reached ) retstat \|= NRETVAL;
154	$1->op = FREE;
155	ftnend();
156	}
157	;
158
159	function_body: arg_dcl_list compoundstmt
160	;
161	arg_dcl_list: arg_dcl_list declaration
162	\| ={ blevel = 1; }
163	;
164
165	stmt_list: stmt_list statement
166	\| /* empty */
167	={ bccode();
168	locctr(PROG);
169	}
170	;
171
172	r_dcl_stat_list : dcl_stat_list attributes SM
173	={ $2->op = FREE;
174	#ifndef LINT
175	plcstab(blevel);
176	#endif
177	}
178	\| dcl_stat_list attributes init_dcl_list SM
179	={ $2->op = FREE;
180	#ifndef LINT
181	plcstab(blevel);
182	#endif
183	}
184	;
185
186	dcl_stat_list : dcl_stat_list attributes SM
187	={ $2->op = FREE; }
188	\| dcl_stat_list attributes init_dcl_list SM
189	={ $2->op = FREE; }
190	\| /* empty */
191	;
192	declaration: attributes declarator_list SM
193	={ curclass = SNULL; $1->op = FREE; }
194	\| attributes SM
195	={ curclass = SNULL; $1->op = FREE; }
196	\| error SM
197	={ curclass = SNULL; }
198	;
199	oattributes: attributes
200	\| /* VOID */
201	={ $$ = mkty(INT,0,INT); curclass = SNULL; }
202	;
203	attributes: class type
204	={ $$ = $2; }
205	\| type class
206	\| class
207	={ $$ = mkty(INT,0,INT); }
208	\| type
209	={ curclass = SNULL ; }
210	;
211
212
213	class: CLASS
214	={ curclass = $1; }
215	;
216
217	type: TYPE
218	\| TYPE TYPE
219	={ $1->type = types( $1->type, $2->type, UNDEF );
220	$2->op = FREE;
221	}
222	\| TYPE TYPE TYPE
223	={ $1->type = types( $1->type, $2->type, $3->type );
224	$2->op = $3->op = FREE;
225	}
226	\| struct_dcl
227	\| enum_dcl
228	;
229
230	enum_dcl: enum_head LC moe_list optcomma RC
231	={ $$ = dclstruct($1); }
232	\| ENUM NAME
233	={ $$ = rstruct($2,0); stwart = instruct; }
234	;
235
236	enum_head: ENUM
237	={ $$ = bstruct(-1,0); }
238	\| ENUM NAME
239	={ $$ = bstruct($2,0); }
240	;
241
242	moe_list: moe
243	\| moe_list CM moe
244	;
245
246	moe: NAME
247	={ moedef( $1 ); }
248	\| NAME ASSIGN con_e
249	={ strucoff = $3; moedef( $1 ); }
250	;
251
252	struct_dcl: str_head LC type_dcl_list optsemi RC
253	={ $$ = dclstruct($1); }
254	\| STRUCT NAME
255	={ $$ = rstruct($2,$1); }
256	;
257
258	str_head: STRUCT
259	={ $$ = bstruct(-1,$1); stwart=0; }
260	\| STRUCT NAME
261	={ $$ = bstruct($2,$1); stwart=0; }
262	;
263
264	type_dcl_list: type_declaration
265	\| type_dcl_list SM type_declaration
266	;
267
268	type_declaration: type declarator_list
269	={ curclass = SNULL; stwart=0; $1->op = FREE; }
270	\| type
271	={ if( curclass != MOU ){
272	curclass = SNULL;
273	}
274	else {
275	sprintf( fakename, "$%dFAKE", fake++ );
276	defid( tymerge($1, bdty(NAME,NIL,lookup( fakename, SMOS ))), curclass );
277	}
278	stwart = 0;
279	$1->op = FREE;
280	}
281	;
282
283
284	declarator_list: declarator
285	={ defid( tymerge($<nodep>0,$1), curclass); stwart = instruct; }
286	\| declarator_list CM {$<nodep>$=$<nodep>0;} declarator
287	={ defid( tymerge($<nodep>0,$4), curclass); stwart = instruct; }
288	;
289	declarator: fdeclarator
290	\| nfdeclarator
291	\| nfdeclarator COLON con_e
292	%prec CM
293	={ if( !(instruct&INSTRUCT) ) uerror( "field outside of structure" );
294	if( $3<0 \|\| $3 >= FIELD ){
295	uerror( "illegal field size" );
296	$3 = 1;
297	}
298	defid( tymerge($<nodep>0,$1), FIELD\|$3 );
299	$$ = NIL;
300	}
301	\| COLON con_e
302	%prec CM
303	={ if( !(instruct&INSTRUCT) ) uerror( "field outside of structure" );
304	falloc( stab, $2, -1, $<nodep>0 ); /* alignment or hole */
305	$$ = NIL;
306	}
307	\| error
308	={ $$ = NIL; }
309	;
310
311	/* int (a)(); is not a function --- sorry! */
312	nfdeclarator: MUL nfdeclarator
313	={ umul:
314	$$ = bdty( UNARY MUL, $2, 0 ); }
315	\| nfdeclarator LP RP
316	={ uftn:
317	$$ = bdty( UNARY CALL, $1, 0 ); }
318	\| nfdeclarator LB RB
319	={ uary:
320	$$ = bdty( LB, $1, 0 ); }
321	\| nfdeclarator LB con_e RB
322	={ bary:
323	if( (int)$3 <= 0 ) werror( "zero or negative subscript" );
324	$$ = bdty( LB, $1, $3 ); }
325	\| NAME
326	={ $$ = bdty( NAME, NIL, $1 ); }
327	\| LP nfdeclarator RP
328	={ $$=$2; }
329	;
330	fdeclarator: MUL fdeclarator
331	={ goto umul; }
332	\| fdeclarator LP RP
333	={ goto uftn; }
334	\| fdeclarator LB RB
335	={ goto uary; }
336	\| fdeclarator LB con_e RB
337	={ goto bary; }
338	\| LP fdeclarator RP
339	={ $$ = $2; }
340	\| name_lp name_list RP
341	={
342	if( blevel!=0 ) uerror("function declaration in bad context");
343	$$ = bdty( UNARY CALL, bdty(NAME,NIL,$1), 0 );
344	stwart = 0;
345	}
346	\| name_lp RP
347	={
348	$$ = bdty( UNARY CALL, bdty(NAME,NIL,$1), 0 );
349	stwart = 0;
350	}
351	;
352
353	name_lp: NAME LP
354	={
355	/* turn off typedefs for argument names */
356	stwart = SEENAME;
357	}
358	;
359
360	name_list: NAME
361	={ ftnarg( $1 ); stwart = SEENAME; }
362	\| name_list CM NAME
363	={ ftnarg( $3 ); stwart = SEENAME; }
364	;
365	/* always preceeded by attributes: thus the $<nodep>0's */
366	init_dcl_list: init_declarator
367	%prec CM
368	\| init_dcl_list CM {$<nodep>$=$<nodep>0;} init_declarator
369	;
370	/* always preceeded by attributes */
371	xnfdeclarator: nfdeclarator
372	={ defid( $1 = tymerge($<nodep>0,$1), curclass);
373	beginit($1->rval);
374	}
375	\| error
376	;
377	/* always preceeded by attributes */
378	init_declarator: nfdeclarator
379	={ nidcl( tymerge($<nodep>0,$1) ); }
380	\| fdeclarator
381	={ defid( tymerge($<nodep>0,$1), uclass(curclass) );
382	}
383	\| xnfdeclarator optasgn e
384	%prec CM
385	={ doinit( $3 );
386	endinit(); }
387	\| xnfdeclarator optasgn LC init_list optcomma RC
388	={ endinit(); }
389	;
390
391	init_list: initializer
392	%prec CM
393	\| init_list CM initializer
394	;
395	initializer: e
396	%prec CM
397	={ doinit( $1 ); }
398	\| ibrace init_list optcomma RC
399	={ irbrace(); }
400	;
401
402	optcomma : /* VOID */
403	\| CM
404	;
405
406	optsemi : /* VOID */
407	\| SM
408	;
409
410	optasgn : /* VOID */
411	={ werror( "old-fashioned initialization: use =" ); }
412	\| ASSIGN
413	;
414
415	ibrace : LC
416	={ ilbrace(); }
417	;
418
419	/* STATEMENTS */
420
421	compoundstmt: dcmpstmt
422	\| cmpstmt
423	;
424
425	dcmpstmt: begin r_dcl_stat_list stmt_list RC
426	={
427	#ifndef LINT
428	prcstab(blevel);
429	#endif
430	--blevel;
431	if( blevel == 1 ) blevel = 0;
432	clearst( blevel );
433	checkst( blevel );
434	autooff = *--psavbc;
435	regvar = *--psavbc;
436	}
437	;
438
439	cmpstmt: begin stmt_list RC
440	={ --blevel;
441	if( blevel == 1 ) blevel = 0;
442	clearst( blevel );
443	checkst( blevel );
444	autooff = *--psavbc;
445	regvar = *--psavbc;
446	}
447	;
448
449	begin: LC
450	={ if( blevel == 1 ) dclargs();
451	++blevel;
452	if( psavbc > &asavbc[BCSZ-2] ) cerror( "nesting too deep" );
453	*psavbc++ = regvar;
454	*psavbc++ = autooff;
455	}
456	;
457
458	statement: e SM
459	={ ecomp( $1 ); }
460	\| compoundstmt
461	\| ifprefix statement
462	={ deflab($1);
463	reached = 1;
464	}
465	\| ifelprefix statement
466	={ if( $1 != NOLAB ){
467	deflab( $1 );
468	reached = 1;
469	}
470	}
471	\| whprefix statement
472	={ branch( contlab );
473	deflab( brklab );
474	if( (flostat&FBRK) \|\| !(flostat&FLOOP)) reached = 1;
475	else reached = 0;
476	resetbc(0);
477	}
478	\| doprefix statement WHILE LP e RP SM
479	={ deflab( contlab );
480	if( flostat & FCONT ) reached = 1;
481	ecomp( buildtree( CBRANCH, buildtree( NOT, $5, NIL ), bcon( $1 ) ) );
482	deflab( brklab );
483	reached = 1;
484	resetbc(0);
485	}
486	\| forprefix .e RP statement
487	={ deflab( contlab );
488	if( flostat&FCONT ) reached = 1;
489	if( $2 ) ecomp( $2 );
490	branch( $1 );
491	deflab( brklab );
492	if( (flostat&FBRK) \|\| !(flostat&FLOOP) ) reached = 1;
493	else reached = 0;
494	resetbc(0);
495	}
496	\| switchpart statement
497	={ if( reached ) branch( brklab );
498	deflab( $1 );
499	swend();
500	deflab(brklab);
501	if( (flostat&FBRK) \|\| !(flostat&FDEF) ) reached = 1;
502	resetbc(FCONT);
503	}
504	\| BREAK SM
505	={ if( brklab == NOLAB ) uerror( "illegal break");
506	else if(reached) branch( brklab );
507	flostat \|= FBRK;
508	if( brkflag ) goto rch;
509	reached = 0;
510	}
511	\| CONTINUE SM
512	={ if( contlab == NOLAB ) uerror( "illegal continue");
513	else branch( contlab );
514	flostat \|= FCONT;
515	goto rch;
516	}
517	\| RETURN SM
518	={ retstat \|= NRETVAL;
519	branch( retlab );
520	rch:
521	if( !reached ) werror( "statement not reached");
522	reached = 0;
523	}
524	\| RETURN e SM
525	={ register NODE *temp;
526	idname = curftn;
527	temp = buildtree( NAME, NIL, NIL );
528	temp->type = DECREF( temp->type );
529	temp = buildtree( RETURN, temp, $2 );
530	/* now, we have the type of the RHS correct */
531	temp->left->op = FREE;
532	temp->op = FREE;
533	ecomp( buildtree( FORCE, temp->right, NIL ) );
534	retstat \|= RETVAL;
535	branch( retlab );
536	reached = 0;
537	}
538	\| GOTO NAME SM
539	={ register NODE *q;
540	q = block( FREE, NIL, NIL, INT\|ARY, 0, INT );
541	q->rval = idname = $2;
542	defid( q, ULABEL );
543	stab[idname].suse = -lineno;
544	branch( stab[idname].offset );
545	goto rch;
546	}
547	\| SM
548	\| error SM
549	\| error RC
550	\| label statement
551	;
552	label: NAME COLON
553	={ register NODE *q;
554	q = block( FREE, NIL, NIL, INT\|ARY, 0, LABEL );
555	q->rval = $1;
556	defid( q, LABEL );
557	reached = 1;
558	}
559	\| CASE e COLON
560	={ addcase($2);
561	reached = 1;
562	}
563	\| DEFAULT COLON
564	={ reached = 1;
565	adddef();
566	flostat \|= FDEF;
567	}
568	;
569	doprefix: DO
570	={ savebc();
571	if( !reached ) werror( "loop not entered at top");
572	brklab = getlab();
573	contlab = getlab();
574	deflab( $$ = getlab() );
575	reached = 1;
576	}
577	;
578	ifprefix: IF LP e RP
579	={ ecomp( buildtree( CBRANCH, $3, bcon( $$=getlab()) ) ) ;
580	reached = 1;
581	}
582	;
583	ifelprefix: ifprefix statement ELSE
584	={ if( reached ) branch( $$ = getlab() );
585	else $$ = NOLAB;
586	deflab( $1 );
587	reached = 1;
588	}
589	;
590
591	whprefix: WHILE LP e RP
592	={ savebc();
593	if( !reached ) werror( "loop not entered at top");
594	if( $3->op == ICON && $3->lval != 0 ) flostat = FLOOP;
595	deflab( contlab = getlab() );
596	reached = 1;
597	brklab = getlab();
598	if( flostat == FLOOP ) tfree( $3 );
599	else ecomp( buildtree( CBRANCH, $3, bcon( brklab) ) );
600	}
601	;
602	forprefix: FOR LP .e SM .e SM
603	={ if( $3 ) ecomp( $3 );
604	else if( !reached ) werror( "loop not entered at top");
605	savebc();
606	contlab = getlab();
607	brklab = getlab();
608	deflab( $$ = getlab() );
609	reached = 1;
610	if( $5 ) ecomp( buildtree( CBRANCH, $5, bcon( brklab) ) );
611	else flostat \|= FLOOP;
612	}
613	;
614	switchpart: SWITCH LP e RP
615	={ savebc();
616	brklab = getlab();
617	ecomp( buildtree( FORCE, $3, NIL ) );
618	branch( $$ = getlab() );
619	swstart();
620	reached = 0;
621	}
622	;
623	/* EXPRESSIONS */
624	con_e: { $<intval>$=instruct; stwart=instruct=0; } e
625	%prec CM
626	={ $$ = icons( $2 ); instruct=$<intval>1; }
627	;
628	.e: e
629	\|
630	={ $$=0; }
631	;
632	elist: e
633	%prec CM
634	\| elist CM e
635	={ goto bop; }
636	;
637
638	e: e RELOP e
639	={
640	preconf:
641	if( yychar==RELOP\|\|yychar==EQUOP\|\|yychar==AND\|\|yychar==OR\|\|yychar==ER ){
642	precplaint:
643	if( hflag ) werror( "precedence confusion possible: parenthesize!" );
644	}
645	bop:
646	$$ = buildtree( $2, $1, $3 );
647	}
648	\| e CM e
649	={ $2 = COMOP;
650	goto bop;
651	}
652	\| e DIVOP e
653	={ goto bop; }
654	\| e PLUS e
655	={ if(yychar==SHIFTOP) goto precplaint; else goto bop; }
656	\| e MINUS e
657	={ if(yychar==SHIFTOP ) goto precplaint; else goto bop; }
658	\| e SHIFTOP e
659	={ if(yychar==PLUS\|\|yychar==MINUS) goto precplaint; else goto bop; }
660	\| e MUL e
661	={ goto bop; }
662	\| e EQUOP e
663	={ goto preconf; }
664	\| e AND e
665	={ if( yychar==RELOP\|\|yychar==EQUOP ) goto preconf; else goto bop; }
666	\| e OR e
667	={ if(yychar==RELOP\|\|yychar==EQUOP) goto preconf; else goto bop; }
668	\| e ER e
669	={ if(yychar==RELOP\|\|yychar==EQUOP) goto preconf; else goto bop; }
670	\| e ANDAND e
671	={ goto bop; }
672	\| e OROR e
673	={ goto bop; }
674	\| e MUL ASSIGN e
675	={ abop:
676	$$ = buildtree( ASG $2, $1, $4 );
677	}
678	\| e DIVOP ASSIGN e
679	={ goto abop; }
680	\| e PLUS ASSIGN e
681	={ goto abop; }
682	\| e MINUS ASSIGN e
683	={ goto abop; }
684	\| e SHIFTOP ASSIGN e
685	={ goto abop; }
686	\| e AND ASSIGN e
687	={ goto abop; }
688	\| e OR ASSIGN e
689	={ goto abop; }
690	\| e ER ASSIGN e
691	={ goto abop; }
692	\| e QUEST e COLON e
693	={ $$=buildtree(QUEST, $1, buildtree( COLON, $3, $5 ) );
694	}
695	\| e ASOP e
696	={ werror( "old-fashioned assignment operator" ); goto bop; }
697	\| e ASSIGN e
698	={ goto bop; }
699	\| term
700	;
701	term: term INCOP
702	={ $$ = buildtree( $2, $1, bcon(1) ); }
703	\| MUL term
704	={ ubop:
705	$$ = buildtree( UNARY $1, $2, NIL );
706	}
707	\| AND term
708	={ if( ISFTN($2->type) \|\| ISARY($2->type) ){
709	werror( "& before array or function: ignored" );
710	$$ = $2;
711	}
712	else goto ubop;
713	}
714	\| MINUS term
715	={ goto ubop; }
716	\| UNOP term
717	={
718	$$ = buildtree( $1, $2, NIL );
719	}
720	\| INCOP term
721	={ $$ = buildtree( $1==INCR ? ASG PLUS : ASG MINUS,
722	$2,
723	bcon(1) );
724	}
725	\| SIZEOF term
726	={ $$ = doszof( $2 ); }
727	\| LP cast_type RP term %prec INCOP
728	={ $$ = buildtree( CAST, $2, $4 );
729	$$->left->op = FREE;
730	$$->op = FREE;
731	$$ = $$->right;
732	}
733	\| SIZEOF LP cast_type RP %prec SIZEOF
734	={ $$ = doszof( $3 ); }
735	\| term LB e RB
736	={ $$ = buildtree( UNARY MUL, buildtree( PLUS, $1, $3 ), NIL ); }
737	\| funct_idn RP
738	={ $$=buildtree(UNARY CALL,$1,NIL); }
739	\| funct_idn elist RP
740	={ $$=buildtree(CALL,$1,$2); }
741	\| term STROP NAME
742	={ if( $2 == DOT ){
743	$1 = buildtree( UNARY AND, $1, NIL );
744	}
745	idname = $3;
746	$$ = buildtree( STREF, $1, buildtree( NAME, NIL, NIL ) );
747	}
748	\| NAME
749	={ idname = $1;
750	/* recognize identifiers in initializations */
751	if( blevel==0 && stab[idname].stype == UNDEF ) {
752	register NODE *q;
753	werror( "undeclared initializer name %.8s", stab[idname].sname );
754	q = block( FREE, NIL, NIL, INT, 0, INT );
755	q->rval = idname;
756	defid( q, EXTERN );
757	}
758	$$=buildtree(NAME,NIL,NIL);
759	stab[$1].suse = -lineno;
760	}
761	\| ICON
762	={ $$=bcon(0);
763	$$->lval = lastcon;
764	$$->rval = NONAME;
765	if( $1 ) $$->csiz = $$->type = ctype(LONG);
766	}
767	\| FCON
768	={ $$=buildtree(FCON,NIL,NIL);
769	$$->dval = dcon;
770	}
771	\| STRING
772	={ $$ = getstr(); /* get string contents */ }
773	\| LP e RP
774	={ $$=$2; }
775	;
776
777	cast_type: type null_decl
778	={
779	$$ = tymerge( $1, $2 );
780	$$->op = NAME;
781	$1->op = FREE;
782	}
783	;
784
785	null_decl: /* empty */
786	={ $$ = bdty( NAME, NIL, -1 ); }
787	\| LP RP
788	={ $$ = bdty( UNARY CALL, bdty(NAME,NIL,-1),0); }
789	\| LP null_decl RP LP RP
790	={ $$ = bdty( UNARY CALL, $2, 0 ); }
791	\| MUL null_decl
792	={ goto umul; }
793	\| null_decl LB RB
794	={ goto uary; }
795	\| null_decl LB con_e RB
796	={ goto bary; }
797	\| LP null_decl RP
798	={ $$ = $2; }
799	;
800
801	funct_idn: NAME LP
802	={ if( stab[$1].stype == UNDEF ){
803	register NODE *q;
804	q = block( FREE, NIL, NIL, FTN\|INT, 0, INT );
805	q->rval = $1;
806	defid( q, EXTERN );
807	}
808	idname = $1;
809	$$=buildtree(NAME,NIL,NIL);
810	stab[idname].suse = -lineno;
811	}
812	\| term LP
813	;
814	%%
815
816	NODE *
817	mkty( t, d, s ) unsigned t; {
818	return( block( TYPE, NIL, NIL, t, d, s ) );
819	}
820
821	NODE *
822	bdty( op, p, v ) NODE *p; {
823	register NODE *q;
824
825	q = block( op, p, NIL, INT, 0, INT );
826
827	switch( op ){
828
829	case UNARY MUL:
830	case UNARY CALL:
831	break;
832
833	case LB:
834	q->right = bcon(v);
835	break;
836
837	case NAME:
838	q->rval = v;
839	break;
840
841	default:
842	cerror( "bad bdty" );
843	}
844
845	return( q );
846	}
847
848	dstash( n ){ /* put n into the dimension table */
849	if( curdim >= DIMTABSZ-1 ){
850	cerror( "dimension table overflow");
851	}
852	dimtab[ curdim++ ] = n;
853	}
854
855	savebc() {
856	if( psavbc > & asavbc[BCSZ-4 ] ){
857	cerror( "whiles, fors, etc. too deeply nested");
858	}
859	*psavbc++ = brklab;
860	*psavbc++ = contlab;
861	*psavbc++ = flostat;
862	*psavbc++ = swx;
863	flostat = 0;
864	}
865
866	resetbc(mask){
867
868	swx = *--psavbc;
869	flostat = *--psavbc \| (flostat&mask);
870	contlab = *--psavbc;
871	brklab = *--psavbc;
872
873	}
874
875	addcase(p) NODE p; { / add case to switch */
876
877	p = optim( p ); /* change enum to ints */
878	if( p->op != ICON ){
879	uerror( "non-constant case expression");
880	return;
881	}
882	if( swp == swtab ){
883	uerror( "case not in switch");
884	return;
885	}
886	if( swp >= &swtab[SWITSZ] ){
887	cerror( "switch table overflow");
888	}
889	swp->sval = p->lval;
890	deflab( swp->slab = getlab() );
891	++swp;
892	tfree(p);
893	}
894
895	adddef(){ /* add default case to switch */
896	if( swtab[swx].slab >= 0 ){
897	uerror( "duplicate default in switch");
898	return;
899	}
900	if( swp == swtab ){
901	uerror( "default not inside switch");
902	return;
903	}
904	deflab( swtab[swx].slab = getlab() );
905	}
906
907	swstart(){
908	/* begin a switch block */
909	if( swp >= &swtab[SWITSZ] ){
910	cerror( "switch table overflow");
911	}
912	swx = swp - swtab;
913	swp->slab = -1;
914	++swp;
915	}
916
917	swend(){ /* end a switch block */
918
919	register struct sw swbeg, p, q, r, *r1;
920	CONSZ temp;
921	int tempi;
922
923	swbeg = &swtab[swx+1];
924
925	/* sort */
926
927	r1 = swbeg;
928	r = swp-1;
929
930	while( swbeg < r ){
931	/* bubble largest to end */
932	for( q=swbeg; q<r; ++q ){
933	if( q->sval > (q+1)->sval ){
934	/* swap */
935	r1 = q+1;
936	temp = q->sval;
937	q->sval = r1->sval;
938	r1->sval = temp;
939	tempi = q->slab;
940	q->slab = r1->slab;
941	r1->slab = tempi;
942	}
943	}
944	r = r1;
945	r1 = swbeg;
946	}
947
948	/* it is now sorted */
949
950	for( p = swbeg+1; p<swp; ++p ){
951	if( p->sval == (p-1)->sval ){
952	uerror( "duplicate case in switch, %d", tempi=p->sval );
953	return;
954	}
955	}
956
957	genswitch( swbeg-1, swp-swbeg );
958	swp = swbeg-1;
959	}