README.SCCS: Could find no reason to read-only default for string literals. -Xnostrwrite
README.SCCS: -Xnostrwrite to put string literals in "text" to save space in runtime images.
README.SCCS: fifth byte was lost.  Bitfields are now aligned on 32-bit boundries.
README.SCCS: which was aligned in such a manner as to cross a 32-bit boundry the data
README.SCCS: x ? i++ : i--;
README.SCCS: As par usual AT&T used typically non-portable code to stringize arguements.
README.SCCS: This did not conform to the standard ANSI ordering of pre-processor processing.
README.SCCS: In bldspecs only $$=-1; has been added.
README.SCCS: define for NameV now is ifdef'ed for both ANSI and non-ANSI compiles.
README.SCCS: see bug#5016-1
README.SCCS: A bug which dis-allowed qualifying of typedef'ed types has been fixed. Thus
README.SCCS: typedef int junk;   <--- 'illegal combination of type and
README.SCCS: if ( a.pb->i == 13 )
README.SCCS: if ( a.pb->i == 13 )
README.SCCS: nothing (NCVT == no-conversion).
README.SCCS: -----------------------------------------------------------------------
README.SCCS: {(-1),-1}
README.SCCS: (-1),-1
README.SCCS: -----------------------------------------------------------------------
README.SCCS: -----------------------------------------------------------------------
README.SCCS: such as "} missing" or "inconsistently-bracketed initialization".
README.SCCS: 'incompletely-bracketed initialization' and second the bracket
README.SCCS: ( ( (W_OBJ)(bar->tile) = (*(((WA_tile)->type)[ 1 ])) (WA_tile))->ref) += 2;
README.SCCS: ( (        (bar->tile) = (*(((WA_tile)->type)[ 1 ])) (WA_tile))->ref) += 2;
README.SCCS: nothing (NCVT == no-conversion).
README.SCCS: if(o==CAST && p->in.right->in.type == p->in.left->in.type ) return(NCVT);
README.SCCS: nothing (NCVT == no-conversion).
README.SCCS: incomplete declaration we take a look to the current TOKEN -held
README.SCCS: in yychar-. If yychar==62 (that is, a semi-colon) then it is
README.SCCS: if(o==CAST && p->in.right->in.type == p->in.left->in.type )
README.SCCS: if(o==CAST && p->in.right->in.type == p->in.left->in.type
README.SCCS: && p->in.right->fn.csiz==p->in.left->fn.csiz)
allo.c:	n = q->needs;
allo.c:				markbusy( j, p->tn.type );
allo.c:				markbusy( j+1, p->tn.type );
allo.c:				n -= 2*NREG;
allo.c:				markbusy( j, p->tn.type );
allo.c:				n -= NREG;
allo.c:			presc->in.op = REG;
allo.c:			presc->tn.rval = j;
allo.c:			presc->tn.type = p->tn.type;
allo.c:			presc->tn.lval = 0;
allo.c:			presc->in.name = (char *) 0;
allo.c:		printf( "allo( %d, %d ), %o", p-node, q->stinline, q->needs );
allo.c:	return( -tmpoff - maxboff ); 
allo.c:  	return( -tmpoff );
allo.c:	if( callop(p->in.op) )
allo.c:	cerror( "allocation fails, op %s", opst[p->tn.op] );
allo.c:	register int t = optype( p->tn.op );
allo.c:	if( callop(p->in.op) )
allo.c:		for( j=NRGS-1; j>=0; --j ) if( usable(p,n,j) ) return( j );
allo.c:	cerror( "allocation fails, op %s", opst[p->tn.op] );
allo.c:	if( (o=p->tn.op) == REG ) 
allo.c:		r = p->tn.rval;
allo.c:		if( r >= NRGS ) return( -1 );
allo.c:	/* we look for shared regs under unary-like ops */
allo.c:		return( shared( p->in.left ) );
allo.c:	return( -1 );
allo.c:	if( p->tn.type & TPOINT )
allo.c:	else if( FP_TYPE(p->tn.type) && is_m68881)
allo.c:	register int t = optype(p->tn.op);
allo.c:	if( (n&LSHARE) && ushare( getlt( p, t ), r, p->in.type ) ) return(1);
allo.c:	if( (n&RSHARE) && ushare( getrt( p, t ), r, p->in.type ) ) return(1);
allo.c:	if( p->in.op == REG && sameregtype( t, p->in.type ) )
allo.c:		if( szty( p->tn.type ) == 2 && r==(p->tn.rval+1) ) return( 1 );
allo.c:		return( r == p->tn.rval );
allo.c:	switch( optype( p->tn.op ) )
allo.c:		if( ushare( p->in.right, r, t ) ) return( 1 );
allo.c:		if( ushare( p->in.left, r, t ) ) return( 1 );
allo.c:	r = p->tn.rval;
allo.c:	if( p->in.op == REG ) rfree( r, p->in.type );
allo.c:	switch( optype( p->tn.op ) )
allo.c:		regrcl( p->in.right );
allo.c:		if( asgop(p->tn.op) && p->in.left->tn.op == REG ) break;
allo.c:		regrcl( p->in.left );
allo.c:		if( --*reg < 0 ) cerror( "register overfreed");
allo.c:			if( --*reg < 0 ) cerror( "register overfreed" );
allo.c:		printf( "reclaim( %d, ", p-node );
allo.c:	if( (o=p->tn.op) == COMOP )
allo.c:		regrcl( p->in.right );
allo.c:		p->in.op = CCODES;
allo.c:		p->tn.lval = 0;
allo.c:		p->tn.rval = 0;
allo.c:		cerror( "illegal reclaim, op %s", opst[p->tn.op]);
allo.c:	if( o == STARG ) p = p->in.left;  /* STARGs are still STARGS */
allo.c:	q->in.op = FREE;
allo.c:	r = p->tn.rval;
allo.c:	if( p->in.op == REG ) rbusy( r, p->in.type );
allo.c:	switch( optype(q->in.op) )
allo.c:		q->in.right = tcopy(p->in.right);
allo.c:		q->in.left = tcopy(p->in.left);
allo.c:	if( p->tn.op == CM )
allo.c:		t = argsize( p->in.left );
allo.c:		p = p->in.right;
allo.c:	if( p->tn.type & (TDOUBLE|TFLOAT) )
allo.c:	else if( p->tn.type & (TLONG|TULONG) )
allo.c:	else if( p->tn.type & TPOINT )
allo.c:	else if( p->tn.type & TSTRUCT )
allo.c:		SETOFF( t, p->stn.stalign );  /* alignment */
allo.c:		t += p->stn.stsize;  /* size */
cgen.c:# define istnode(p) (p->in.op==REG && istreg(p->tn.rval))
cgen.c:	o = p->tn.op;
cgen.c:	p->tn.goal = goal;
cgen.c:		cerror( "rewcom(%d) is FREE", p-node );
cgen.c:		rewcom( r = p->in.right, g2 );
cgen.c:		rewcom( l = p->in.left, g1 );
cgen.c:    if( l->tn.op == COMOP && l->in.left->tn.op != GENBR )
cgen.c:		ql = l->in.left;
cgen.c:		qr = l->in.right;
cgen.c:		l->in.left = qr;
cgen.c:		p->in.right = l;
cgen.c:		p->in.left = ql;
cgen.c:		p->tn.op = COMOP;
cgen.c:		rewcom( p, p->tn.goal );
cgen.c:    if( r->tn.op == COMOP && r->in.right->tn.op != GENBR )
cgen.c:		ql = r->in.left;
cgen.c:		qr = r->in.right;
cgen.c:		p->tn.op = COMOP;
cgen.c:		p->in.left = ql;
cgen.c:		r->in.right = qr;
cgen.c:		rewcom( p, p->tn.goal );
cgen.c:	t = tcopy( p->in.left );
cgen.c:	p->in.left = q;
cgen.c:	p->in.right = t;
cgen.c:	p->tn.op = COMOP;
cgen.c:	while( (o=p->tn.op) == COMOP ) p = p->in.right;
cgen.c:		*t = *p->in.left;  /* copy contents, mainly for type, etc. */
cgen.c:		t->tn.op = TEMP;
cgen.c:		t->tn.lval = freetemp(argsize(p)/SZINT );
cgen.c:		t->tn.lval = BITOOR(t->tn.lval);
cgen.c:		/* t->tn.rval == 0 indicates stack temporary (not register) */
cgen.c:		t->tn.rval = 0;
cgen.c:		t->tn.name = (char *) 0;
cgen.c:		t->tn.type = TSTRUCT;
cgen.c:		q->tn.op = UNARY AND;
cgen.c:		q->in.left = t;
cgen.c:		t->in.left = q;
cgen.c:		t->in.right = p->in.left;
cgen.c:		t->tn.op = STASG;
cgen.c:		p->in.left = talloc();
cgen.c:		p->in.left->tn.op = COMOP;
cgen.c:		p->in.left->in.left = t;
cgen.c:		p->in.left->in.right = t = talloc(); /* copy q here */
cgen.c:		t->in.left = talloc();
cgen.c:		*t->in.left = *q->in.left;
cgen.c:	if( asgop(o) && o!=INCR && o!=DECR && lhsok( p->in.left ) ) {
cgen.c:		if( p->in.left->tn.op == TEMP ) 
cgen.c:			p->tn.op = ao;
cgen.c:	t->tn.op = TEMP;
cgen.c:	t->tn.rval = tempreg(&t->tn.lval, argsize(p)/SZINT, t->tn.type);
cgen.c:	if (t->tn.rval == 0)
cgen.c:	/* if not, get one from the stack as usual (rval == 0) - jgh */
cgen.c:	t->tn.lval = freetemp(argsize(p)/SZINT );
cgen.c:	t->tn.lval = BITOOR(t->tn.lval);
cgen.c:	t->tn.name = (char *) 0;
cgen.c:	q->tn.op = ASSIGN;
cgen.c:	q->in.left = t;
cgen.c:	q->in.right = talloc();
cgen.c:	*(q->in.right) = *p;
cgen.c:	p->in.right = talloc();
cgen.c:	*(p->in.right) = *t;
cgen.c:	p->tn.op = COMOP;
cgen.c:	p->in.left = q;
cgen.c:	o = p->tn.op;
cgen.c:		if( iseff( p->in.right ) ) return( 1 );
cgen.c:		return( iseff( p->in.left ) );
cgen.c:	o = p->tn.op;
cgen.c:		if( volatile_chk( p->in.right ) ) return( 1 );
cgen.c:		return( volatile_chk( p->in.left ) );
cgen.c:	if ( is_volatile( p->tn.typeq ) )
cgen.c:	for( q = p->in.left; (o=q->tn.op)!=STAR; q=q->in.left )
cgen.c:	q = q->in.left;
cgen.c:	o = q->tn.op;
cgen.c:	t = p->tn.type;
cgen.c:	tl = p->in.left->tn.type;
cgen.c:	t = p->tn.type;
cgen.c:	if (   ( h->tn.type == TFLOAT || h->tn.type == TDOUBLE )
cgen.c:	if( p->tn.op == CONV && c2bigger(p) ) 
cgen.c:		p->tn.type = t;
cgen.c:	q->tn.op = CONV;
cgen.c:	q->in.left = p;
cgen.c:	q->in.right = 0;
cgen.c:	q->tn.name = (char *) 0;
cgen.c:	q->tn.type = t;
cgen.c:	q->tn.goal = NRGS;
cgen.c:	r = p->in.right;
cgen.c:	s = tcopy( p->in.left );
cgen.c:	q->in.left = s; /* q->in.right = r, side effect of copy. */
cgen.c:	if( p->in.left->tn.op == CONV ) 
cgen.c:		t = p->in.left;
cgen.c:		ty = t->in.left->tn.type;
cgen.c:		p->in.left = t->in.left;
cgen.c:		p->in.right = t;
cgen.c:		t->in.left = q;
cgen.c:		t->tn.type = ty;
cgen.c:		p->in.right = q;
cgen.c:	p->tn.op = ASSIGN;
cgen.c:	q->tn.op = NOASG q->tn.op;
cgen.c:	p->tn.type = p->in.left->tn.type;
cgen.c:	q->tn.type = q->in.right->tn.type;
cgen.c:	o = p->tn.op;
cgen.c:		if( p->in.left->tn.op == RNODE ) 
cgen.c:			q = p->in.left;
cgen.c:			q->tn.op = ICON;
cgen.c:			q->tn.op = FREE;
cgen.c:		rewsto( p->in.left );
cgen.c:			o = p->in.left->tn.op;
cgen.c:				p->in.left->tn.op = REG;
cgen.c:				p->in.left->tn.rval = o==QNODE ? 1 : callreg( p->in.right );
cgen.c:				p->in.left->tn.lval = 0;	/* bk: broke M4.1 USE_AREG */
cgen.c:			TWORD t = p->in.left->tn.type;
cgen.c:  			TWORD t2= p->in.right->tn.type;
cgen.c:			  {	p->in.left->tn.type = TUNSIGNED;
cgen.c:				p->in.right->tn.type = TUNSIGNED;
cgen.c:			p->in.left = ind2type( p, p->in.left );
cgen.c:			p->in.right = ind2type( p, p->in.right );
cgen.c:  			if( ( t  != p->in.left->tn.type ) ||
cgen.c:  			    ( t2 != p->in.right->tn.type) )
cgen.c:		/* very crude: a++ becomes (a+=1)-1 */
cgen.c:		regrcl( p->in.left );
cgen.c:		tfree( p->in.left );
cgen.c:		p->in.left = q;
cgen.c:		q->tn.op = ((o==INCR)?ASG PLUS:ASG MINUS);
cgen.c:		p->tn.op = ((o==INCR)?MINUS:PLUS);
cgen.c:		if (q->in.left->tn.op == FLD)
cgen.c:			p->in.left = z;		/* make AND node at top */
cgen.c:			p->tn.op = AND;
cgen.c:			p->in.right = talloc();	/* ICON node for mask */
cgen.c:			*p->in.right = *q->in.right;	/* copy ICON node */
cgen.c:			p->in.right->tn.lval = (1<<UPKFSZ(q->in.left->tn.rval)) -1;
cgen.c:		rewcom( p, p->tn.goal );  /* move COMOP to the top */
cgen.c:		if( p->tn.op != COMOP ) cerror( "rewass1" );
cgen.c:		if( !asgop( p->in.right->tn.op ) ) cerror( "rewass2" );
cgen.c:		reweop( p->in.right );
cgen.c:	o = p->tn.op;
cgen.c:	if( t==BITYPE && subcall(p->in.right) ) return( 1 );
cgen.c:	if( t!=LTYPE ) return( subcall( p->in.left ) );
cgen.c:	o = p->tn.op;
cgen.c:		stocm( p->in.right );
cgen.c:		nonest( p->in.left );
cgen.c:	if( t == BITYPE ) nonest( p->in.right );
cgen.c:	if( t != LTYPE ) nonest( p->in.left );
cgen.c:	while( (o=p->tn.op) == CM )
cgen.c:		stocm( p->in.right );
cgen.c:		p = p->in.left;
cgen.c:	q = p->in.left;
cgen.c:		printf( " (%d)\n", p->sc );
cgen.c:		printf("Dump of table[%d] (stinline %d)\n", p-table, p->stinline );
cgen.c:		printf("\top = %s\n", opst[p->op]);
cgen.c:		printf("\tnextop = %d\n", p->nextop?p->nextop-table:-1 );
cgen.c:		printf("\tlshape = %d\n", p->lshape-pshape);
cgen.c:		printf("\tltype = 0%o\n", p->ltype);
cgen.c:		printf("\trshape = %d\n", p->rshape-pshape);
cgen.c:		printf("\trtype = 0%o\n", p->rtype);
cgen.c:		printf("\tneeds = %d\n", p->needs);
cgen.c:		printf("\trewrite = %d\n", p->rewrite);
cgen.c:		printf("\tcstring = %s", p->cstring);
cgen.c:		printf("\tcost = %d\n", p->cost);
cgen.c:		outshp(p->lshape);
cgen.c:		outshp(p->rshape);
cgen.c:		p = pi->p;
cgen.c:		q = pi->q;
cgen.c:		c = pi->goal;
cgen.c:		if( c == CCC && (q->rewrite&RESCC) ) goal = FORCC;
cgen.c:	        if (p->in.op == INCALL || p->in.op == UNARY INCALL)
cgen.c:		    n = sizeof(INST) * (ninsav-i);
cgen.c:		    if (p->in.op == UNARY CALL || p->in.op == CALL)
cgen.c:		{ /* non-asm template expansion */
cgen.c:				protect(1);			/* issue no-optimize pragma */
cgen.c:			expand( p, goal, q->cstring, q );
cgen.c:				protect(0);			/* re-enable optimization */
cgen.c:		} /* end non-asm template expansion */
cgen.c:		reclaim( p, q->rewrite, goal );
cgen.c:		if( c == CCC && p->tn.op != CCODES ) 
cgen.c:			if( p->tn.op != CCODES ) cerror( "ctest fails" );
cgen.c: 		else if( c>=0 && c<=NRGS && p->tn.op != REG ) 
cgen.c:		p->tn.goal = CCC;
cgen.c:		if( q->rewrite & r ) 
cgen.c:			expand( p, goal, q->cstring, q );
cgen.c:			reclaim( p, q->rewrite, goal );
cgram.c:static int optid = -1;
cgram.c:						/* This doubles as an inside-proto flag. */
cgram.c:int incit;				/* related to "null_decl-> NAME LP opt_plist RP" */
cgram.c:#define yyclearin yychar = -1
cgram.c:		q->in.right = bcon(v);
cgram.c:		q->tn.rval = v;
cgram.c:	if( curdim >= DIMTABSZ-1 ){
cgram.c:	if( psavbc > & asavbc[BCSZ-4 ] ){
cgram.c:	swx = *--psavbc;
cgram.c:	flostat = *--psavbc | (flostat&mask);
cgram.c:	contlab = *--psavbc;
cgram.c:	brklab = *--psavbc;
cgram.c:	if( p->in.op != ICON ){
cgram.c:		uerror( "non-integer constant case expression");
cgram.c:	swp->sval = p->tn.lval;
cgram.c:	deflab( swp->slab = getlab() );
cgram.c:	swx = swp - swtab;
cgram.c:	swp->slab = -1;
cgram.c:	r = swp-1;
cgram.c:			if( q->sval > (q+1)->sval ){
cgram.c:				temp = q->sval;
cgram.c:				q->sval = r1->sval;
cgram.c:				r1->sval = temp;
cgram.c:				tempi = q->slab;
cgram.c:				q->slab = r1->slab;
cgram.c:				r1->slab = tempi;
cgram.c:		if( p->sval == (p-1)->sval ){
cgram.c:			uerror( "duplicate case in switch, %d", tempi=p->sval );
cgram.c:	genswitch( swbeg-1, (int)(swp-swbeg) );
cgram.c:	swp = swbeg-1;
cgram.c:  ty=n->in.type;
cgram.c:   case USHORT: if ( chktype[UNSIGNED -1 ] || chktype[ ty -UNSIGNED + INT -1] )
cgram.c:			chktype[UNSIGNED -1 ]  = 1; 
cgram.c:			chktype[ ty - UNSIGNED + INT -1] = 1; 
cgram.c:   case SHORT: if ( chktype[ ty -1 ] )
cgram.c:			chktype[ ty -1 ]  = 1; 
cgram.c:   default: return(-1);
cgram.c:-1, 1,
cgram.c:	0, -1,
cgram.c:	-2, 0,
cgram.c:-1, 14,
cgram.c:	-2, 114,
cgram.c:-1, 15,
cgram.c:	-2, 15,
cgram.c:-1, 17,
cgram.c:	-2, 0,
cgram.c:-1, 20,
cgram.c:	-2, 113,
cgram.c:-1, 22,
cgram.c:	-2, 118,
cgram.c:-1, 24,
cgram.c:	-2, 39,
cgram.c:-1, 27,
cgram.c:	-2, 114,
cgram.c:-1, 28,
cgram.c:	-2, 14,
cgram.c:-1, 76,
cgram.c:	-2, 21,
cgram.c:-1, 83,
cgram.c:	-2, 61,
cgram.c:-1, 85,
cgram.c:	-2, 53,
cgram.c:-1, 102,
cgram.c:	-2, 104,
cgram.c:-1, 142,
cgram.c:	-2, 0,
cgram.c:-1, 243,
cgram.c:	-2, 28,
cgram.c:-1, 262,
cgram.c:	-2, 104,
cgram.c: -1000,   -50, -1000, -1000, -1000,    36,    29,    25, -1000,   154,
cgram.c:    94, -1000, -1000,    -4,   109,    92, -1000,    14,   235,   235,
cgram.c:   110,    -7, -1000,   199, -1000, -1000,    -8,   109,    92, -1000,
cgram.c:   154, -1000, -1000, -1000, -1000,    94,    94,    94, -1000, -1000,
cgram.c: -1000, -1000, -1000,   221,   124,   295,   123,   291,  1274, -1000,
cgram.c: -1000, -1000,    96,   184,    89,   183,    68, -1000, -1000, -1000,
cgram.c: -1000,   110,   109,    92,    98,    85,    80,   180,    77,  1164,
cgram.c: -1000, -1000,   221, -1000, -1000,    17, -1000, -1000, -1000, -1000,
cgram.c: -1000, -1000, -1000, -1000,   258, -1000,  1219,    59,  1219,  1219,
cgram.c:  1219,  1219,  1219,  1219,  1233,  1178,   198, -1000, -1000, -1000,
cgram.c:    31,   174, -1000, -1000,    67,  1219,   172, -1000, -1000,    65,
cgram.c: -1000, -1000,   288,    52, -1000, -1000, -1000, -1000, -1000, -1000,
cgram.c:   170, -1000,    63,  1061,  1109,    59,  1219, -1000, -1000,   -10,
cgram.c: -1000, -1000,    87, -1000, -1000,   210, -1000,   210,    20,   342,
cgram.c:    34, -1000,    11,    24,    48, -1000,   -20,   169,   977, -1000,
cgram.c:  1219,   284, -1000,    59,    59,    59,    59,    59,    59,    59,
cgram.c:  1219, -1000,    54,  1061, -1000, -1000,   109,    92, -1000, -1000,
cgram.c: -1000,  1061, -1000, -1000, -1000, -1000,   -24,   164, -1000, -1000,
cgram.c:  1219,  1219,  1219,  1219,    -6, -1000,  1061,  1109, -1000,   168,
cgram.c: -1000, -1000, -1000, -1000, -1000,   -13, -1000, -1000,   920,    32,
cgram.c: -1000,   405,   405,   405,   405,  1219,   405,    27,    23,  1095,
cgram.c:   282, -1000,   -12,   405,   197,   195, -1000,   194,   192,   196,
cgram.c:  1219,   236,   118, -1000,    38, -1000,    24,    24,   115,   258,
cgram.c: -1000,   319, -1000,   458, -1000,   166,  1219, -1000, -1000, -1000,
cgram.c:   100, -1000,   164,   164,   190,   329,  1061, -1000,   276,   276,
cgram.c:   321, -1000,   665,   413,   602,   612,   545,   485,  1061,  1061,
cgram.c:  1109,    -6,  1219,    11, -1000, -1000, -1000, -1000,   213, -1000,
cgram.c: -1000,   208,   165,  1034, -1000, -1000, -1000, -1000,   836,    15,
cgram.c: -1000, -1000, -1000,  1219,  1219,  1219,  1219, -1000,   809, -1000,
cgram.c: -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,    59, -1000,
cgram.c:  1219,  1155,  1061,    61,   162,   160,    99,   100, -1000,  1219,
cgram.c: -1000, -1000,   112, -1000, -1000,   188,   405, -1000, -1000,   752,
cgram.c:   695,    12,   638, -1000,   575, -1000,    57, -1000, -1000,   186,
cgram.c: -1000,   406, -1000,  1219, -1000, -1000, -1000,  1219, -1000, -1000,
cgram.c: -1000, -1000,   159,   515,     7, -1000, -1000,     6, -1000,   156,
cgram.c: -1000, -1000 };
cgram.c: -1000,    -1,   -42,   -43,   256,    64,   -23,   -24,   -38,   -39,
cgram.c:   -52,    61,    61,   -44,   -40,   -32,   -66,   -11,   -56,    54,
cgram.c:   -33,   -68,   256,     2,    12,    61,   -44,   -40,   -32,   -45,
cgram.c:   -47,   -46,   -72,    56,   -14,   -53,   -15,   -17,    38,    36,
cgram.c:   -27,   -26,   -41,    37,   -10,    39,    -9,    53,    65,    61,
cgram.c:    60,    54,    58,    54,    58,   -35,   -64,    55,   -65,     2,
cgram.c:   256,   -33,   -40,   -32,   -33,   -40,   -32,    54,    58,    62,
cgram.c:    54,   -54,   -55,    61,   -46,   -23,   -51,   -16,   -14,   -16,
cgram.c:   -16,   -17,    56,     2,    56,     2,    54,   -22,    12,    15,
cgram.c:     9,     6,    34,    33,    52,   -30,     2,     4,     5,     3,
cgram.c:   -67,   -36,   -76,    59,    -2,   -74,   -35,    55,    59,    -2,
cgram.c:    55,    55,    60,   -37,   -28,   -75,    55,    55,    55,    55,
cgram.c:   -35,    59,    -2,   -20,    56,   -22,    54,   -56,   -17,   -48,
cgram.c:    61,   -31,   -33,    23,   256,   -56,     2,    54,   -23,   -49,
cgram.c:   -60,   -62,   -25,   -52,   -57,   -59,     2,   -28,   -20,    33,
cgram.c:    58,    35,    54,   -22,   -22,   -22,   -22,   -22,   -22,   -22,
cgram.c:    54,    55,   -34,   -20,    54,   -66,   -40,   -32,    55,   -35,
cgram.c:    59,   -20,    55,    59,     2,   -12,    60,   -23,    55,    59,
cgram.c:    21,    22,    26,    62,   -69,   -70,   -20,   -71,    56,   -28,
cgram.c:    61,    60,    23,    -2,    61,   -44,   -50,    57,   -20,    64,
cgram.c:   -46,    -4,    -3,    -5,    -7,    -6,    -8,    45,    46,    40,
cgram.c:    41,    61,   256,   -73,    42,    47,    48,    49,    44,     2,
cgram.c:    51,    50,   -61,    61,   -48,   -18,   -15,   -17,   -58,    60,
cgram.c:    62,    55,    55,   -20,     2,   -28,    60,    55,    63,   -28,
cgram.c:   -29,   -13,    54,   -56,     2,   -20,   -20,   -20,   -20,   -20,
cgram.c:   -20,   -20,   -20,   -20,   -20,   -20,   -20,   -20,   -20,   -20,
cgram.c:   -20,   -20,   -20,   -20,   -20,   -20,   -20,   -20,   -20,   -58,
cgram.c:    60,   -69,    55,   -63,    -2,    61,    61,    61,   -50,   -50,
cgram.c:   -50,   -50,   -21,   -20,   -50,    61,    61,    61,   -20,     2,
cgram.c:    61,    57,   -50,    54,    54,    54,    54,    23,   -20,    23,
cgram.c:    57,   -62,   -19,   -18,   -19,    57,   -59,    -2,   -22,    59,
cgram.c:    23,    55,   -20,    58,   -35,   -13,   -29,   -29,    54,    23,
cgram.c:    57,   -70,   -58,   -31,    43,    47,    55,    61,    61,   -20,
cgram.c:   -20,   -21,   -20,    23,   -20,    59,    -2,    55,    55,    55,
cgram.c:   -78,   -20,    57,    54,   -50,    55,    55,    61,    55,    59,
cgram.c:    59,    54,   -36,   -20,   -21,   -77,    55,    55,    61,   -36,
cgram.c:     2,    -2,     1,     3,     4,     0,     0,     0,    19,     0,
cgram.c:     0,     5,     6,     0,    -2,    -2,   108,    -2,     0,     0,
cgram.c:    -2,     0,    -2,    82,    -2,     7,     0,    -2,    -2,    10,
cgram.c:   100,    50,     0,     9,    16,     0,    -2,    29,    33,    30,
cgram.c:    31,    43,    28,    -2,     0,    -2,   207,    49,     0,     0,
cgram.c:     0,     0,    -2,    88,     0,     0,     0,    92,    93,     0,
cgram.c:    62,    66,    -2,     0,   123,    56,    58,     0,     0,   186,
cgram.c:     0,     0,     0,    -2,    68,    27,    36,    36,     0,   124,
cgram.c:   206,   210,    -2,   222,   221,   161,   162,   163,   164,   165,
cgram.c:	"-unknown-",	-1	/* ends search */
cgram.c:	"-no such reduction-",
cgram.c:		yyerror( "syntax error - cannot backup" );\
cgram.c:#define YYFLAG		(-1000)
cgram.c:** yyparse - return 0 if worked, 1 if syntax error not recovered from
cgram.c:	** Initialize externals - yyparse may be called more than once
cgram.c:	yypv = &yyv[-1];
cgram.c:	yyps = &yys[-1];
cgram.c:	yychar = -1;
cgram.c:		** name pairs.  0 and negative (-1) are special values.
cgram.c:				printf( "end-of-file\n" );
cgram.c:				printf( "-none-\n" );
cgram.c:		** we have a new state - find out what to do
cgram.c:				printf( "end-of-file\n" );
cgram.c:				printf( "-none-\n" );
cgram.c:			yychar = -1;
cgram.c:				yyerrflag--;
cgram.c:		if ( ( yy_n = yydef[ yy_state ] ) == -2 )
cgram.c:					printf( "end-of-file\n" );
cgram.c:					printf( "-none-\n" );
cgram.c:				while ( ( *yyxi != -1 ) ||
cgram.c:							yy_ps[-1] );
cgram.c:					yy_ps--;
cgram.c:					yy_pv--;
cgram.c:						printf( "token end-of-file\n" );
cgram.c:						printf( "token -none-\n" );
cgram.c:				yychar = -1;
cgram.c:				yyval = ( yy_pv -= yy_len )[1];	/* $$ = $1 */
cgram.c:					*( yy_ps -= yy_len ) + 1;
cgram.c:					yyact[ yy_state ] ] != -yy_n )
cgram.c:			yyval = ( yy_pv -= yy_len )[1];	/* $$ = $1 */
cgram.c:				*( yy_ps -= yy_len ) + 1;
cgram.c:				yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
cgram.c:				yypvt[-1].nodep->in.op = FREE; DECL_RESET; 
cgram.c:				yypvt[-1].nodep->in.op = FREE; DECL_RESET; 
cgram.c:				if ( indcl != -1 )
cgram.c:				yypvt[-2].nodep->in.op = FREE; DECL_RESET; 
cgram.c:				yypvt[-2].nodep->in.op = FREE; DECL_RESET; 
cgram.c:				if ( indcl != -1 )
cgram.c:					"non-function external must have specifiers" );
cgram.c:			    yypvt[-1].nodep->in.op = FREE;
cgram.c:			    yypvt[-1].nodep->in.op = FREE;
cgram.c:				defid(tymerge(yypvt[-1].nodep, yypvt[-0].nodep), INLINE);
cgram.c:				squirrelmacro(stab[yypvt[-0].nodep->tn.rval].sname);
cgram.c:					ProtoDefine(yypvt[-0].nodep);		/* got identifiers for all types? */
cgram.c:					defid( tymerge(yypvt[-1].nodep,yypvt[-0].nodep),
cgram.c:case 17:{ yypvt[-2].nodep->in.op = FREE; DECL_RESET; } break;
cgram.c:case 18:{ yypvt[-1].nodep->in.op = FREE; DECL_RESET; } break;
cgram.c:				int t = BTYPE(yypvt[-1].nodep->in.type); 
cgram.c:				yypvt[-1].nodep->in.op = FREE;  DECL_RESET;
cgram.c:case 23:{  yypvt[-2].nodep->in.op = FREE;  DECL_RESET; } break;
cgram.c:				if ( yypvt[-0].intval != -1 ) {		/* -1 means struct_dcl or type_def */
cgram.c:							str_type->in.op = FREE;
cgram.c:				if ( yypvt[-0].intval != -1 ) {		/* -1 means struct_dcl or type_def */
cgram.c:							str_type->in.op = FREE;
cgram.c:case 28:{ indcl = -1; } break;
cgram.c:case 29:{ yyval.intval = ( yypvt[-0].intval == -1 ) ? -1 : 0 ; } break;
cgram.c:				if ( yypvt[-0].intval == -1 ) {		/* e.g. short struct foo { ... }; */
cgram.c:case 31:{ yyval.intval = ( yypvt[-0].intval == -1 ) ? -1 : 0 ; } break;
cgram.c:case 35:{ yyval.intval = ( yypvt[-0].intval == -1 ) ? -1 : 0 ; } break;
cgram.c:				curclass = yypvt[-0].intval;
cgram.c:case 42:{ typequal = type_quals( typequal, yypvt[-0].intval, tqshift ); } break;
cgram.c:case 43:{	typequal = type_quals( typequal, yypvt[-1].intval, tqshift ); } break;
cgram.c:						if (chktype[ yypvt[-0].nodep->in.type - 1 ] )
cgram.c:						chktype[ yypvt[-0].nodep->in.type - 1 ] = 1;
cgram.c:						yypvt[-0].nodep->in.op = FREE;
cgram.c:					 if ( yypvt[-0].nodep != type_def ) /* e.g.:  "TYPEDEF_NAME int x;" */
cgram.c:					 if ( decomp_type(yypvt[-0].nodep) )
cgram.c:					   yyval.intval = -1;
cgram.c:					   yypvt[-0].nodep->in.op = FREE;
cgram.c:				yyval.intval = -1;
cgram.c:				str_type = yypvt[-0].nodep;
cgram.c:				arg_type = yypvt[-0].nodep;
cgram.c:				yyval.intval = -1; 
cgram.c:					optid = -1; 
cgram.c:				yyval.nodep = do_argty( yypvt[-1].nodep );
cgram.c:case 49:{  yyval.nodep = do_argty( yypvt[-0].nodep ); } break;
cgram.c:case 52:{ yyval.nodep = dclstruct(yypvt[-4].intval); } break;
cgram.c:case 53:{  yyval.nodep = rstruct(yypvt[-0].intval,0);  stwart = instruct; } break;
cgram.c:case 54:{  yyval.intval = bstruct(-1,0); stwart = SEENAME; } break;
cgram.c:case 55:{  yyval.intval = bstruct(yypvt[-0].intval,0); stwart = SEENAME; } break;
cgram.c:case 58:{  moedef( yypvt[-0].intval ); } break;
cgram.c:case 59:{	strucoff = yypvt[-0].intval;  enum_chk = 0; moedef( yypvt[-2].intval ); } break;
cgram.c:case 60:{ yyval.nodep = dclstruct(yypvt[-4].intval);  
cgram.c:			  if (is_struc[sulvl]) strucdef--; /*finished struc def
cgram.c:			  sulvl--;
cgram.c:case 61:{  yyval.nodep = rstruct(yypvt[-0].intval,yypvt[-1].intval); } break;
cgram.c:case 62:{ werror( W_STRICT, "missing semi-colon in structure member list" ); } break;
cgram.c:			   is_struc[sulvl] = (yypvt[-0].intval == INSTRUCT);
cgram.c:			   yyval.intval = bstruct(-1,yypvt[-0].intval);  stwart=0; } break;
cgram.c:			   is_struc[sulvl] = (yypvt[-1].intval == INSTRUCT);
cgram.c:			   yyval.intval = bstruct(yypvt[-0].intval,yypvt[-1].intval);  stwart=0;  } break;
cgram.c:				stwart=0; yypvt[-1].nodep->in.op = FREE; 
cgram.c:					defid( tymerge(yypvt[-0].nodep, bdty(NAME,NIL,
cgram.c:			    yypvt[-0].nodep->in.op = FREE;
cgram.c:case 70:{ defid( tymerge(yypvt[-1].nodep,yypvt[-0].nodep), curclass);
cgram.c:case 71:{yyval.nodep=yypvt[-2].nodep;} break;
cgram.c:case 72:{ defid( tymerge(yypvt[-4].nodep,yypvt[-0].nodep), curclass);
cgram.c:			    if( yypvt[-0].intval<0 || yypvt[-0].intval >= FIELD ){
cgram.c:				yypvt[-0].intval = 1;
cgram.c:			    defid( tymerge(yypvt[-3].nodep,yypvt[-2].nodep), FIELD|yypvt[-0].intval );
cgram.c:			    falloc( stab, yypvt[-0].intval, -1, yypvt[-2].nodep );
cgram.c:				yyval.nodep = bdty( UNARY MUL, yypvt[-0].nodep, 0 ); } break;
cgram.c:				yyval.nodep = bdty( UNARY CALL, yypvt[-2].nodep, 0 ); } break;
cgram.c:				yyval.nodep = bdty( UNARY CALL, yypvt[-3].nodep, 0 );
cgram.c:				ProtoLink( yypvt[-3].nodep, 0 );		 /* tie protolist to ftn-ptr id */
cgram.c:				ProtoDeclare(yypvt[-3].nodep);		/* just an id, not a function def'n */
cgram.c:				yyval.nodep = bdty( LB, yypvt[-2].nodep, 0 ); } break;
cgram.c:				if( (int)yypvt[-1].intval <= 0 )
cgram.c:				yyval.nodep = bdty( LB, yypvt[-3].nodep, yypvt[-1].intval ); 
cgram.c:case 82:{  seen_typespec = 0; yyval.nodep = bdty( NAME, NIL, yypvt[-0].intval ); } break;
cgram.c:case 83:{ yyval.nodep=yypvt[-1].nodep; seen_typespec = 0; } break;
cgram.c:				yyval.nodep = bdty( UNARY CALL, yypvt[-3].nodep, 0 );
cgram.c:				ProtoPush();	/* we don't know name of pointed-to ftn */
cgram.c:				ProtoLink(yypvt[-3].nodep,1);
cgram.c:				yyval.nodep = bdty( UNARY CALL, bdty(NAME,NIL,yypvt[-2].intval), 0 );
cgram.c:				ProtoLink(idn=bdty(NAME,NIL,yypvt[-2].intval),0); /*link ptypes to ftn id*/
cgram.c:				idn->in.op = FREE;
cgram.c:				yyval.nodep = bdty( UNARY CALL, yypvt[-3].nodep, 0 );
cgram.c:				if ( yypvt[-1].nodep ) {
cgram.c:					ProtoLink(yypvt[-3].nodep,1);
cgram.c:case 90:{ yyval.nodep = yypvt[-1].nodep; } break;
cgram.c:case 95:{ yyval.nodep = yypvt[-1].nodep; } break;
cgram.c:				yyval.nodep = bdty( UNARY CALL, bdty(NAME,NIL,yypvt[-2].intval), 0 );
cgram.c:				yyval.nodep = bdty( UNARY CALL, bdty(NAME,NIL,yypvt[-1].intval), 0 );
cgram.c:				if( stab[yypvt[-1].intval].sclass == SNULL )
cgram.c:				    stab[yypvt[-1].intval].stype = FTN;
cgram.c:				ProtoEnd(yypvt[-0].intval);			/* mark end of prototype list */
cgram.c:				tfree(yypvt[-1].nodep);				/* done with proto list */
cgram.c:				--blevel;				/* back down from protolist scope */
cgram.c:				yyval.nodep = yypvt[-1].nodep;
cgram.c:				ProtoType(yypvt[-0].nodep,optid);
cgram.c:				optid = -1;
cgram.c:				ProtoType(yypvt[-0].nodep,optid);
cgram.c:				optid = -1;
cgram.c:case 105:{ ftnarg( yypvt[-0].intval );  stwart = SEENAME; } break;
cgram.c:case 106:{ ftnarg( yypvt[-0].intval );  stwart = SEENAME; } break;
cgram.c:case 109:{yyval.nodep=yypvt[-2].nodep;} break;
cgram.c:				yypvt[-0].nodep = tymerge(yypvt[-1].nodep,yypvt[-0].nodep);
cgram.c:				defid( yypvt[-0].nodep, curclass );
cgram.c:			    beginit(yypvt[-0].nodep->tn.rval);
cgram.c:				yypvt[-0].nodep = tymerge( yypvt[-1].nodep,yypvt[-0].nodep ); 
cgram.c:				nidcl( yypvt[-0].nodep );
cgram.c:				p = &stab[yypvt[-0].nodep->tn.rval];
cgram.c:				if ( ( CONST_QUALIFIED( yypvt[-0].nodep->tn.type, p->stypeq ) ) &&
cgram.c:						p->sclass != TYPEDEF )
cgram.c:					werror( W_DFLT, "unitialized const-qualified object" );
cgram.c:				ProtoDeclare(tymerge(yypvt[-1].nodep,yypvt[-0].nodep)), 
cgram.c:case 115:{ ProtoMix(yypvt[-0].nodep); defid( tymerge(yypvt[-1].nodep,yypvt[-0].nodep), uclass(curclass) ); } break;
cgram.c:				if ( yypvt[-0].nodep && yypvt[-0].nodep->in.type == STRTY ) 
cgram.c:					doinit( yypvt[-0].nodep );
cgram.c:case 121:{  doinit( yypvt[-0].nodep ); } break;
cgram.c:			    if (--blevel == 1)
cgram.c:			    autooff = *--psavbc;
cgram.c:			    regvar = *--psavbc;
cgram.c:			    if( psavbc > &asavbc[BCSZ-2] )
cgram.c:case 128:{ ecomp( yypvt[-1].nodep ); } break;
cgram.c:				deflab(yypvt[-1].intval);
cgram.c:				if( yypvt[-1].intval != NOLAB ){
cgram.c:				deflab( yypvt[-1].intval );
cgram.c:			    buildtree( NOT, yypvt[-2].nodep, NIL ), bcon( yypvt[-6].intval ) ) );
cgram.c:			    if( yypvt[-2].nodep ) ecomp( yypvt[-2].nodep );
cgram.c:			    branch( yypvt[-3].intval );
cgram.c:			    deflab( yypvt[-1].intval );
cgram.c:			    if(temp->in.type == (FTN|VOID))
cgram.c:			    temp->in.type = DECREF( temp->in.type );
cgram.c:			    temp->in.type = indtype( temp->in.type );
cgram.c:			    temp->tn.op = RNODE;  /* node for return */
cgram.c:			    temp = buildtree( ASSIGN, temp, yypvt[-1].nodep );
cgram.c:			    q->tn.rval = idname = yypvt[-1].intval;
cgram.c:			    stab[idname].suse = -lineno;
cgram.c:			    q->tn.rval = yypvt[-1].intval;
cgram.c:case 147:{  addcase(yypvt[-1].nodep);
cgram.c:			 ecomp( buildtree( CBRANCH, yypvt[-1].nodep, bcon( yyval.intval=getlab()) ) ) ;
cgram.c:			    deflab( yypvt[-2].intval );
cgram.c:			    if( yypvt[-1].nodep->in.op == ICON && yypvt[-1].nodep->tn.lval != 0 ) flostat = FLOOP;
cgram.c:			    if( flostat == FLOOP ) tfree( yypvt[-1].nodep );
cgram.c:			    else ecomp( buildtree( CBRANCH, yypvt[-1].nodep, bcon( brklab) ) );
cgram.c:			 	if( yypvt[-3].nodep ) ecomp( yypvt[-3].nodep );
cgram.c:			    if( yypvt[-1].nodep )
cgram.c:				ecomp( buildtree( CBRANCH, yypvt[-1].nodep, bcon( brklab) ));
cgram.c:			    temp = buildtree( ASSIGN, temp, yypvt[-1].nodep );
cgram.c:				icon_overflow( yypvt[-0].nodep, 1 );		/* bk */
cgram.c:				yyval.intval = icons( yypvt[-0].nodep );  
cgram.c:				instruct=yypvt[-1].intval; 
cgram.c:			    yyval.nodep = buildtree( yypvt[-1].intval, yypvt[-2].nodep, yypvt[-0].nodep );
cgram.c:case 162:{  yypvt[-1].intval = COMOP;
cgram.c:				yyval.nodep = buildtree( yypvt[-1].intval, yypvt[-2].nodep, yypvt[-0].nodep );
cgram.c:case 175:{   yyval.nodep = buildtree( ASG yypvt[-1].intval, yypvt[-2].nodep, yypvt[-0].nodep ); } break;
cgram.c:case 178:{  yyval.nodep = buildtree( ASG yypvt[-1].intval, yypvt[-2].nodep, yypvt[-0].nodep ); } break;
cgram.c:case 182:{  yyval.nodep=buildtree(QUEST, yypvt[-4].nodep, buildtree( COLON, yypvt[-2].nodep, yypvt[-0].nodep ) );
cgram.c:case 183:{  werror( W_LINT, "old-fashioned assignment operator" );
cgram.c:case 186:{  yyval.nodep = buildtree( yypvt[-0].intval, yypvt[-1].nodep, bcon(1) ); } break;
cgram.c:			    	yyval.nodep = buildtree( UNARY yypvt[-1].intval, yypvt[-0].nodep, NIL );
cgram.c:			    	yyval.nodep = buildtree( UNARY yypvt[-1].intval, yypvt[-0].nodep, NIL );
cgram.c:					if ( str_expr( yypvt[-0].nodep ) ) {
cgram.c:						yyval.nodep = yypvt[-0].nodep;
cgram.c:					if ( ISFTN(yypvt[-0].nodep->in.type) || 
cgram.c:					   ISARY(yypvt[-0].nodep->in.type) ) {
cgram.c:						yyval.nodep = yypvt[-0].nodep;
cgram.c:						if ( str_expr ( yypvt[-0].nodep ) ) {
cgram.c:							yyval.nodep = yypvt[-0].nodep;
cgram.c:			    yyval.nodep = buildtree( yypvt[-1].intval, yypvt[-0].nodep, NIL );
cgram.c:case 192:{  yyval.nodep = buildtree( yypvt[-1].intval==INCR ? ASG PLUS : ASG MINUS,
cgram.c:						yypvt[-0].nodep,
cgram.c:case 193:{  yyval.nodep = doszof( yypvt[-0].nodep ); } break;
cgram.c:					optid = -1; 
cgram.c:				yyval.nodep = buildtree( CAST, yypvt[-2].nodep, yypvt[-0].nodep );
cgram.c:			    yyval.nodep->in.left->in.op = FREE;
cgram.c:			    yyval.nodep->in.op = FREE;
cgram.c:			    yyval.nodep = yyval.nodep->in.right;
cgram.c:					optid = -1; 
cgram.c:				yyval.nodep = doszof( yypvt[-1].nodep );
cgram.c:case 196:{  yyval.nodep = buildtree( LB, yypvt[-3].nodep, yypvt[-1].nodep ); } break;
cgram.c:case 197:{  yyval.nodep = xicolon( yypvt[-5].nodep, yypvt[-3].nodep, yypvt[-1].nodep ); } break;
cgram.c:case 198:{  ftn_call = 0; yyval.nodep=buildtree(UNARY CALL,yypvt[-1].nodep,NIL);  } break;
cgram.c:case 199:{ ftn_call = 0;  yyval.nodep=buildtree(CALL,yypvt[-2].nodep,yypvt[-1].nodep);} break;
cgram.c:case 200:{  if( yypvt[-1].intval == DOT ){
cgram.c:				yypvt[-2].nodep = buildtree( UNARY AND, yypvt[-2].nodep, NIL );
cgram.c:			    idname = yypvt[-0].intval;
cgram.c:			    yyval.nodep = buildtree( STREF, yypvt[-2].nodep,
cgram.c:case 201:{  idname = yypvt[-0].intval;
cgram.c:				q->tn.rval = idname;
cgram.c:			    if ( constid && yypvt[-1].intval != MUL)  leftcons = 0;
cgram.c:			    stab[yypvt[-0].intval].suse = -lineno;
cgram.c:			    yyval.nodep->tn.lval = lastcon;
cgram.c:			    yyval.nodep->tn.rval = NONAME;
cgram.c:			    if( yypvt[-0].intval ) yyval.nodep->fn.csiz = yyval.nodep->in.type = ctype( ULONG );	/*bk */
cgram.c:			    yyval.nodep->fpn.dval = dcon;
cgram.c:				if ( yypvt[-0].intval ) yyval.nodep->fn.csiz = yyval.nodep->fpn.type = ctype(FLOAT);	/*bk*/
cgram.c:case 205:{ yyval.nodep=yypvt[-1].nodep; } break;
cgram.c:				yyval.nodep = tymerge( yypvt[-1].nodep, yypvt[-0].nodep );
cgram.c:				yyval.nodep->in.op = NAME;
cgram.c:				yypvt[-1].nodep->in.op = FREE;
cgram.c:					yyval.nodep->in.type = INCREF(yyval.nodep->in.type);
cgram.c:case 209:{ yyval.nodep = yypvt[-0].nodep; } break;
cgram.c:case 210:{ yyval.nodep = bdty( NAME, NIL, yypvt[-0].intval ); } break;
cgram.c:case 211:{ yyval.nodep = buildtree( UNARY CALL, bdty(NAME,NIL,-1),0); } break;
cgram.c:case 212:{ yyval.nodep = bdty( UNARY CALL, bdty(NAME,NIL,yypvt[-1].intval),0); } break;
cgram.c:				yypvt[-5].nodep->in.type = FTN|INT;
cgram.c:				yyval.nodep = bdty( UNARY CALL, yypvt[-5].nodep, 0 ); 
cgram.c:				if ( yypvt[-1].nodep )					/* any prototype? */
cgram.c:					ProtoLink(yypvt[-5].nodep,0);		/* link prototypes to funct id */
cgram.c:case 218:{ ftnsave = yypvt[-1].intval; } break;
cgram.c:				wrk = bdty( NAME, NIL, yypvt[-4].intval );
cgram.c:				wrk->in.type = FTN|INT;
cgram.c:				if ( yypvt[-1].nodep )					/* any prototype? */
cgram.c:case 220:{ yyval.nodep = yypvt[-1].nodep; } break;
cgram.c:case 221:{ optid = yypvt[-0].intval; seen_typespec = 0; } break;
cgram.c:case 222:{ optid = -1; yyval.intval = -1; seen_typespec = 0; } break;
cgram.c:case 224:{  if( stab[yypvt[-1].intval].stype == UNDEF ){
cgram.c:				q->tn.rval = yypvt[-1].intval;
cgram.c:			    idname = yypvt[-1].intval;
cgram.c:			    stab[idname].suse = -lineno;
cgram.c:				if ( (yypvt[-1].nodep->in.type & ( FTN<<TSHIFT | PTR )) == 0 )	
cgram.c:					if ( ( yypvt[-1].nodep->in.type & FTN ) == 0 )
cgram.y:static int optid = -1;
cgram.y:						/* This doubles as an inside-proto flag. */
cgram.y:int incit;				/* related to "null_decl-> NAME LP opt_plist RP" */
cgram.y:				$1->in.op = FREE; DECL_RESET; 
cgram.y:				$1->in.op = FREE; DECL_RESET; 
cgram.y:				if ( indcl != -1 )
cgram.y:				$1->in.op = FREE; DECL_RESET; 
cgram.y:				$1->in.op = FREE; DECL_RESET; 
cgram.y:				if ( indcl != -1 )
cgram.y:					"non-function external must have specifiers" );
cgram.y:			    $1->in.op = FREE;
cgram.y:			    $1->in.op = FREE;
cgram.y:				squirrelmacro(stab[$2->tn.rval].sname);
cgram.y:			{ $2->in.op = FREE; DECL_RESET; };
cgram.y:			{ $2->in.op = FREE; DECL_RESET; };
cgram.y:				int t = BTYPE($2->in.type); 
cgram.y:				$2->in.op = FREE;  DECL_RESET;
cgram.y:			{  $2->in.op = FREE;  DECL_RESET; }
cgram.y:				if ( $2 != -1 ) {		/* -1 means struct_dcl or type_def */
cgram.y:							str_type->in.op = FREE;
cgram.y:				if ( $2 != -1 ) {		/* -1 means struct_dcl or type_def */
cgram.y:							str_type->in.op = FREE;
cgram.y:		{ indcl = -1; }
cgram.y:			{ $$ = ( $2 == -1 ) ? -1 : 0 ; }
cgram.y:				if ( $2 == -1 ) {		/* e.g. short struct foo { ... }; */
cgram.y:			{ $$ = ( $2 == -1 ) ? -1 : 0 ; }
cgram.y:			{ $$ = ( $2 == -1 ) ? -1 : 0 ; }
cgram.y:						if (chktype[ $1->in.type - 1 ] )
cgram.y:						chktype[ $1->in.type - 1 ] = 1;
cgram.y:						$1->in.op = FREE;
cgram.y:					   $$ = -1;
cgram.y:					   $1->in.op = FREE;
cgram.y:				$$ = -1;
cgram.y:				$$ = -1; 
cgram.y:					optid = -1; 
cgram.y:			{  $$ = bstruct(-1,0); stwart = SEENAME; }
cgram.y:			  if (is_struc[sulvl]) strucdef--; /*finished struc def
cgram.y:			  sulvl--;
cgram.y:		{ werror( W_STRICT, "missing semi-colon in structure member list" ); }
cgram.y:			   $$ = bstruct(-1,$1);  stwart=0; }
cgram.y:				stwart=0; $1->in.op = FREE; 
cgram.y:			    $1->in.op = FREE;
cgram.y:			    falloc( stab, $2, -1, $<nodep>0 );
cgram.y:		/* int (a)();   is not a function --- sorry! */
cgram.y:				ProtoLink( $1, 0 );		 /* tie protolist to ftn-ptr id */
cgram.y:				ProtoPush();	/* we don't know name of pointed-to ftn */
cgram.y:				idn->in.op = FREE;
cgram.y:				--blevel;				/* back down from protolist scope */
cgram.y:				optid = -1;
cgram.y:				optid = -1;
cgram.y:			    beginit($1->tn.rval);
cgram.y:				p = &stab[$1->tn.rval];
cgram.y:				if ( ( CONST_QUALIFIED( $1->tn.type, p->stypeq ) ) &&
cgram.y:						p->sclass != TYPEDEF )
cgram.y:					werror( W_DFLT, "unitialized const-qualified object" );
cgram.y:				if ( $3 && $3->in.type == STRTY ) 
cgram.y:			    if (--blevel == 1)
cgram.y:			    autooff = *--psavbc;
cgram.y:			    regvar = *--psavbc;
cgram.y:			    if( psavbc > &asavbc[BCSZ-2] )
cgram.y:			    if(temp->in.type == (FTN|VOID))
cgram.y:			    temp->in.type = DECREF( temp->in.type );
cgram.y:			    temp->in.type = indtype( temp->in.type );
cgram.y:			    temp->tn.op = RNODE;  /* node for return */
cgram.y:			    q->tn.rval = idname = $2;
cgram.y:			    stab[idname].suse = -lineno;
cgram.y:			    q->tn.rval = $1;
cgram.y:			    if( $3->in.op == ICON && $3->tn.lval != 0 ) flostat = FLOOP;
cgram.y:			{  werror( W_LINT, "old-fashioned assignment operator" );
cgram.y:					if ( ISFTN($2->in.type) || 
cgram.y:					   ISARY($2->in.type) ) {
cgram.y:					optid = -1; 
cgram.y:			    $$->in.left->in.op = FREE;
cgram.y:			    $$->in.op = FREE;
cgram.y:			    $$ = $$->in.right;
cgram.y:					optid = -1; 
cgram.y:				q->tn.rval = idname;
cgram.y:			    stab[$1].suse = -lineno;
cgram.y:			    $$->tn.lval = lastcon;
cgram.y:			    $$->tn.rval = NONAME;
cgram.y:			    if( $1 ) $$->fn.csiz = $$->in.type = ctype( ULONG );	/*bk */
cgram.y:			    $$->fpn.dval = dcon;
cgram.y:				if ( $1 ) $$->fn.csiz = $$->fpn.type = ctype(FLOAT);	/*bk*/
cgram.y:				$$->in.op = NAME;
cgram.y:				$2->in.op = FREE;
cgram.y:					$$->in.type = INCREF($$->in.type);
cgram.y:			{ $$ = buildtree( UNARY CALL, bdty(NAME,NIL,-1),0); } 
cgram.y:				$2->in.type = FTN|INT;
cgram.y:				wrk->in.type = FTN|INT;
cgram.y:			{ optid = -1; $$ = -1; seen_typespec = 0; }
cgram.y:				q->tn.rval = $1;
cgram.y:			    stab[idname].suse = -lineno;
cgram.y:				if ( ($1->in.type & ( FTN<<TSHIFT | PTR )) == 0 )	
cgram.y:					if ( ( $1->in.type & FTN ) == 0 )
cgram.y:		q->in.right = bcon(v);
cgram.y:		q->tn.rval = v;
cgram.y:	if( curdim >= DIMTABSZ-1 ){
cgram.y:	if( psavbc > & asavbc[BCSZ-4 ] ){
cgram.y:	swx = *--psavbc;
cgram.y:	flostat = *--psavbc | (flostat&mask);
cgram.y:	contlab = *--psavbc;
cgram.y:	brklab = *--psavbc;
cgram.y:	if( p->in.op != ICON ){
cgram.y:		uerror( "non-integer constant case expression");
cgram.y:	swp->sval = p->tn.lval;
cgram.y:	deflab( swp->slab = getlab() );
cgram.y:	swx = swp - swtab;
cgram.y:	swp->slab = -1;
cgram.y:	r = swp-1;
cgram.y:			if( q->sval > (q+1)->sval ){
cgram.y:				temp = q->sval;
cgram.y:				q->sval = r1->sval;
cgram.y:				r1->sval = temp;
cgram.y:				tempi = q->slab;
cgram.y:				q->slab = r1->slab;
cgram.y:				r1->slab = tempi;
cgram.y:		if( p->sval == (p-1)->sval ){
cgram.y:			uerror( "duplicate case in switch, %d", tempi=p->sval );
cgram.y:	genswitch( swbeg-1, (int)(swp-swbeg) );
cgram.y:	swp = swbeg-1;
cgram.y:  ty=n->in.type;
cgram.y:   case USHORT: if ( chktype[UNSIGNED -1 ] || chktype[ ty -UNSIGNED + INT -1] )
cgram.y:			chktype[UNSIGNED -1 ]  = 1; 
cgram.y:			chktype[ ty - UNSIGNED + INT -1] = 1; 
cgram.y:   case SHORT: if ( chktype[ ty -1 ] )
cgram.y:			chktype[ ty -1 ]  = 1; 
cgram.y:   default: return(-1);
common:        lastfree = &node[TREESZ-1];
common:	highnode = node - 1;
common:# define TNEXT(p) (p== &node[TREESZ-1]?node:p+1)
common:				p->in.op = FREE;
common:				p->tn.typeq = 0;		/* bk */
common:			if( p->in.op ==FREE )  
common:				p->tn.typeq = 0;		/* bk */
common:               if( p->in.op != FREE )
common:                          cerror( "wasted space: %d", p-node );
common:        switch( optype( p->tn.op ) )
common:                tfree( p->in.right );
common:                tfree( p->in.left );
common:        p->in.op = FREE;
common:        UNARY MINUS, "U-", UTYPE,
common:        MINUS, "-", BITYPE|FLOFLG|SIMPFLG,
common:        ASG MINUS, "-=", BITYPE|FLOFLG|SIMPFLG|ASGFLG|ASGOPFLG,
common:        DECR, "--", BITYPE|ASGFLG,
common:        STREF, "->", BITYPE,
common:        -1,     0
common:        for( q = indope; q->dopeop >= 0; ++q )
common:                dope[q->dopeop] = q->dopeval;
common:                opst[q->dopeop] = q->opst;
common:        switch( optype(q->in.op) )
common:                q->in.right = cptree(p->in.right);
common:                q->in.left = cptree(p->in.left);
cost.c:SHAPE * lshbc[NCOSTS];  /* left-hand shape */
cost.c:SHAPE * rshbc[NCOSTS];  /* right-hand shape */
cost.c:	if(odebug) printf("commute: .=%u l=%u r=%u\n",p,p->in.left,p->in.right);
cost.c:	q = p->in.left;
cost.c:	p->in.left = p->in.right;
cost.c:	p->in.right = q;
cost.c:	o = p->tn.op;
cost.c:	n = (q->needs&NCOUNT);
cost.c:	if( (q->needs&NPAIR) && n<HREG ) n = HREG;
cost.c:	if( q->rshape && !q->lshape)
cost.c:	res = q->rewrite;
cost.c:			p-node, opst[o], q->stinline, opst[q->op], sha[0] );
cost.c:			(q->needs&LSHARE)?", LSHARE":"",
cost.c:			(q->needs&RSHARE)?", RSHARE":"" );
cost.c:			sha[0][0]-shapes, sha[0][1]-shapes, sha[0][2]-shapes,
cost.c:			sha[1][0]-shapes, sha[1][1]-shapes, sha[1][2]-shapes
cost.c:		c = q->cost;
cost.c:			if( l->tn.op==REG && sl->op==REG && asgop(q->op)
cost.c:				setregtype( l->tn.type );
cost.c:			c += q->lcount * sl->sc;
cost.c:			if( (!(q->needs&LSHARE)))
cost.c:				sl-shapes, sl?opst[sl->op]:"?", c );
cost.c:					subtree[j]-node, subgoal[j].goal );
cost.c:				ttc += q->rcount * sr->sc;
cost.c:					sr-shapes, sr?opst[sr->op]:"?", ttc );
cost.c:					nsubtree-lsubtree );
cost.c:						subtree[j]-node, subgoal[j].goal );
cost.c:				if( q->needs & RSHARE )
cost.c:					wnn[i] -= rregs[i];
cost.c:			for( j=NRGS; j>=nn; --j ) {
cost.c:							subregs(j1,pp->in.type);
cost.c:							pp->tn.cst[subgoal[ix].goal];
cost.c:					for( ix=nsubtree-1; ix>=0; --ix ) {
cost.c:							subregs(j1,pp->in.type);
cost.c:							pp->tn.cst[subgoal[ix].goal];
cost.c:				if( cc < p->tn.cst[CEFF] ) {
cost.c:					p->tn.cst[CEFF] = cc;
cost.c:				if( p->tn.goal == CEFF ) break;
cost.c:				if( (p->tn.goal==CCC) && (res&RESCC) ) {
cost.c:					if( cc < p->tn.cst[CCC] ) {
cost.c:						p->tn.cst[CCC] = cc;
cost.c:				if( (res&RLEFT) && sl->op != REG ){
cost.c:				else if( (res&RRIGHT) && sr->op != REG ){
cost.c:				if( cc < p->tn.cst[j] ) {
cost.c:					p->tn.cst[j] = cc;
cost.c:				if( p->tn.goal == CCC ) break;
cost.c:				if( tempok(p) && tc < p->tn.cst[CTEMP] ) {
cost.c:					p->tn.cst[CTEMP] = tc;
cost.c:	if( p->tn.goal == CEFF ) return;  /* done */
cost.c:	if( p->tn.goal == CCC ) {
cost.c:		tc = p->tn.cst[NRGS]+CCTEST(q);
cost.c:		if( tc < p->tn.cst[CCC] ) {
cost.c:			p->tn.cst[CCC] = tc;
cost.c:			p->tn.type == l->tn.type ) {
cost.c:		cc = p->tn.cst[CEFF];
cost.c:		if( cc < p->tn.cst[CTEMP] ) {
cost.c:			p->tn.cst[CTEMP] = cc;
cost.c:	tc = p->tn.cst[NRGS] + CSTORE(q);
cost.c:	if( tc < p->tn.cst[CTEMP] ) {
cost.c:		p->tn.cst[CTEMP] = tc;
cost.c:	tc = p->tn.cst[CTEMP] + CLOAD(q);
cost.c:		if( tc < p->tn.cst[j] ) {
cost.c:			p->tn.cst[j] = tc;
cost.c:	switch( p->tn.op ) {
cost.c:	if( sp->op < 0 || sp->op > DSIZE ) cerror( "shape op %d\n", sp->op );
cost.c:	printf(" %s", opst[sp->op]);
cost.c:	shpr(sp->sl);
cost.c:	shpr(sp->sr);
cost.c:	c = p->in.cst[i];
cost.c:	o = p->tn.op;
cost.c:	if( odebug>1 ) printf( "insout(%d,%d), cost %d\n", p-node,i,c );
cost.c:		cerror( "missing table entry, op %s", opst[p->tn.op] );
cost.c:	for( j=0; j<NCOSTS; ++j ) ++p->in.cst[j];
cost.c:			if( q->rewrite & RLEFT ) restrip( sha[0] );
cost.c:			if( q->rewrite & RRIGHT ) restrip( sha[1] );
cost.c:		if( p->tn.cst[i] == c ) {  /* we have found it */
cost.c:			if( q->rewrite & RLEFT ) restrip( sha[0] );
cost.c:			if( q->rewrite & RRIGHT ) restrip( sha[1] );
cost.c:		if( p->tn.cst[i] == c ) { /* we found it */
cost.c:	if (q->rshape && !q->lshape)
cost.c:	o = p->tn.op;
cost.c:		printf("bprt(%d,  %d,  %d)\n", p-node, q-table, i);
cost.c:			q->stinline, ls-shapes, ls?opst[ls->op]:"SHNL",
cost.c:			rs-shapes, rs?opst[rs->op]:"SHNL" );
cost.c:		if( l->tn.op==REG && ls->op==REG && asgop(q->op) &&
cost.c:		for( k=0, rk=nn-1; k<nn; ++k, --rk )
cost.c:			printf( "\t\tnode %d, goal %d\n",mysubs[k]-node,
cost.c:			printf( "\t\tbprt: calling insout(%d,%d)\n", mysubs[k]-node,
cost.c:			subregs( j1, mysubs[k]->tn.type );
cost.c:	if( asgop(o) && p->in.left->tn.op == REG && o != INCR && o != DECR
cost.c:			&& i!=CEFF && i!=CCC && !istreg(p->in.left->tn.rval)){
cost.c:		printf( "\t\tfindsub( %d, %d )\n", p-node, s-shapes );
cost.c:	switch( s->op ) {
cost.c:		if( p->tn.op == TEMP ) return;
cost.c:		if( p->tn.op == REG ) return;  /* exact match */
cost.c:		setregtype( p->tn.type );
cost.c:	if( s->op == p->tn.op ) 
cost.c:		if( s->sl ) findsub( getl(p), s->sl );
cost.c:		if( s->sr ) findsub( getr(p), s->sr );
cost.c:	t = pp->tn.type;
cost.c:		return( pp->tn.cst[MIN(ureg)] );
cost.c:		ureg[0] -= szty( t );
cost.c:		ureg[2] -= szty( t );
cost.c:		ureg[1] -= ( t == TDOUBLE? 2: szty( t ) );
cost.c:		regs[0] += szty(subtree[i]->tn.type);
cost.c:		regs[1]+= szty(subtree[i]->tn.type);
cost.c:		regs[2] += szty(subtree[i]->tn.type);
cost.c:	pc = p->in.cst;
cost.c:	ty = optype( o = p->tn.op );
cost.c:		printf( "costs( %d, %d ), op = %s\n", p-node,
cost.c:			p->tn.goal, opst[o] );
cost.c:	if( ty != LTYPE ) if( costs( p->in.left ) ) return(1);
cost.c:	if( ty == BITYPE ) if( costs( p->in.right ) ) return(1);
cost.c:	pc = p->in.cst;
cost.c:		int cc = p->in.left->in.cst[CEFF];
cost.c:			pc[i] = cc + p->in.right->in.cst[i];
cost.c:		if( p->tn.goal != CEFF ) {
cost.c:			if( q->rewrite & RLEFT ) restrip( sha[0] );
cost.c:			if( q->rewrite & RRIGHT ) restrip( sha[1] );
cost.c:			printf( "bcost( %d, %d )\n", p-node, q->stinline);
cost.c:			printf( "COMMUTE %d *******\n", p-node );
cost.c:		if( p->tn.goal != CEFF ) {
cost.c:			if( q->rewrite & RLEFT ) restrip( sha[0] );
cost.c:			if( q->rewrite & RRIGHT ) restrip( sha[1] );
cost.c:				printf( "bcost( %d, %d )\n", p-node, q->stinline);
cost.c:			printf( "END OF COMMUTE %d *******\n", p-node );
cost.c:	if( pc[p->tn.goal]>=INFINITY ){
cost.c:		if( p->fn.type == TSTRUCT ) return(0);
dope.h:	dopedef(UNARY MINUS, "U-", UTYPE ),
dope.h:	dopedef(MINUS, "-", BITYPE|FLOFLG|SIMPFLG ),
dope.h:	dopedef(ASG MINUS, "-=", BITYPE|FLOFLG|SIMPFLG|ASGFLG|ASGOPFLG ),
dope.h:	dopedef(DECR, "--", BITYPE|ASGFLG ),
dope.h:	dopedef(STREF, "->", BITYPE ),
dope.h:	-1,	0,	0
dope.h:	for( q = indope; q->dopeop >= 0; ++q )
dope.h:		if (q->dopeop >= DSIZE)
dope.h:		    	("bad dope[] OP %s\n", q->opst);
dope.h:		dope[q->dopeop] = q->dopeval;
dope.h:		opst[q->dopeop] = q->opst;
grey.c:/* for the definition of non-grey expressions. */
grey.c:#define MAX_SIDEFF	50			/* reflects worst-case assumptions regarding */
grey.c:	if ( optype(p->in.op) != LTYPE )
grey.c:		switch ( p->in.op ) {
grey.c:				if ( p->tn.type == VOID && p->tn.lval == 0 )
grey.c:/* Conduct (modified) post-order traversal of expression tree, */
grey.c:/* side-effected lvalues within each "boxed" expression.  For a */
grey.c:#define LEG1(p)		(RTOL(p->in.op) ? p->in.right : p->in.left )
grey.c:#define LEG2(p)		(RTOL(p->in.op) ? p->in.left : p->in.right )
grey.c:	ty = optype( p->in.op );
grey.c:		traverse( LEG1(p), side_eff(p->in.op) );
grey.c:			 *  i ? i++ : i--
grey.c:			if ( p->in.op == COLON || sequence_point(p->in.op) ) {
grey.c:		if ( side_eff(p->in.op) ) {
grey.c:			push_sideff( p->in.left );
grey.c:			if ( callop(p->in.op) )
grey.c:	switch ( p->in.op ) {
grey.c:/* Return non-zero if given lvalue found. */
grey.c:		for ( i = lval_idx-1; i >= 0; --i ) {
grey.c:	for ( i = stk_idx-1; i >= 0; --i ) {
grey.c:/* Save information about the node on the stack of side-effected lvalues. */
grey.c:/* middle of the expression tree.  It removes from the side-effect stack */
grey.c:		--stk_idx;
grey.c:		--lval_idx;
grey.c:/* Compare two nodes and return non-zero if they refer to the same lvalue. */
grey.c:	if ( one->in.op != two->in.op )
grey.c:	switch ( one->in.op ) {
grey.c:			same = ( one->tn.lval == two->tn.lval );
grey.c:			if ( one->tn.rval != NONAME )
grey.c:				same = ( one->tn.rval == two->tn.rval && 
grey.c:						one->tn.lval == two->tn.lval );
grey.c:				test = (ISPTR(one->tn.type) << 3 	| 
grey.c:						ISPTR(two->tn.type) << 2 	| 
grey.c:						FP_TYPE(one->tn.type) << 1	| 
grey.c:						FP_TYPE(two->tn.type) );
grey.c:						same = ( one->tn.rval == two->tn.rval );
grey.c:/* Return non-zero if op produces a sequence point */
grey.c:	range = high - low;
grey.c:	for ( i=low; range>0 ; --range,i++ )
iconmul.c: *  iconmult - test constant multiplier to decide if multiply should be replaced
iconmul.c: *      value     - integer constant
iconmul.c: *	0	- hardware multiply is better
iconmul.c: *	1	- replacement shift/add/... is better
iconmul.c: *	iconmulg() - generate replacement instructions for constant multiply
iconmul.c: *      value   - integer constant
iconmul.c: *		size	- 'l', 'w', or 's' representing size of the multiply
iconmul.c: *		snode	- source value register node
iconmul.c: *		tnode	- temporary work value register node
iconmul.c: *	icongen() - function to generate/count instructions for multiply
iconmul.c:         num = -num;
iconmul.c: *   shiftl - function to produce assembly code for any left shift < 31 bits 
iconmul.c: *          siz     - the shift size.
iconmul.c:		     siz -= 16;
iconmul.c:		  siz -= 8;
iconmul.c: * exceptn - returns a 1 for exceptions to the rule:
iconmul.c: *       temp2 - input multiplier constant shifted right so that its 
iconmul.c: *       mask  - contains a '1' in the same bit position as the input
iconmul.c: *  sub0s - function to subtract out the powers of two not present in the 
iconmul.c:/* output() - print out the given instruction string after proper substitutions
iconmul.c:**		S	- source register
iconmul.c:**		T	- temporary work register
iconmul.c:**		Z	- size modifier for multiply width
inline.c:/* 'asm' pseudo-function definitions, whose bodies contain code 
inline.c:/* When asm function calls are expanded in-line,
inline.c:/* arguments are evaluated left-to-right if they're
inline.c:/* symbol defined in order to turn on the asm psuedo-function expansion
inline.c:static int expanding = 0;		/* non-zero if currently expanding */
inline.c:	if (p->in.op == INCALL && genfargs(p->in.right)) return(1);
inline.c:	if (p->in.left->in.op != ICON)
inline.c:		cerror("asm pseudo-function must be called directly");
inline.c:    if (p->in.op == CM)
inline.c:	return( genfargs(p->in.left) || genfargs(p->in.right) );
inline.c:    p = p->in.left;
inline.c:    if (optype(p->in.op) != LTYPE)	/* don't bother if it's a leaf */
inline.c:		cerror("In-line runs out of registers\n");
inline.c:	    l->tn.op = TEMP;
inline.c:	    l->tn.lval = freetemp( argsize(p)/SZINT );
inline.c:	    l->tn.lval = BITOOR( l->tn.lval );
inline.c:	    l->tn.name = (char *) 0;
inline.c:	    l->tn.type = p->tn.type;
inline.c:	    aop->in.op = ASSIGN;
inline.c:	    aop->in.left = l;
inline.c:	    aop->in.right = r;
inline.c:	    aop->in.type = p->tn.type;
inline.c:		cerror("In-line fails to assign to TEMP\n");
inline.c:#define IT_undet	(-1)
inline.c:	inlname = p->in.left->tn.name;
inline.c:		*(t+strlen(t)-1) = '\0'; /* overwrite \n with NUL */
inline.c:	/* now we're ready for the works--first, try to find the %
inline.c:						if ( p->in.op == INCALL )
inline.c:						    p->in.op = CALL;
inline.c:						    p->in.op = UNARY CALL;
inline.c:							*(t+strlen(t)-1) = '\0'; /* overwrite \n with NUL */
inline.c:						expmac(); /* got it -- expand */
inline.c:							uerror("%%error specification reached in asm expansion -- check arguments");
inline.c:	/* nice to have coroutines here--one to prewalk the arg tree, */
inline.c:	if ( ninlargs && p->in.op == INCALL)
inline.c:		return (pcllist(&s, p->in.right, &curarg));
inline.c:	p->tn.op = ICON;
inline.c:	p->tn.name = "";
inline.c:	p->tn.lval = ++labno;
inline.c:	for ( howdeep = nargs-n; howdeep > 0; --howdeep )
inline.c:	    p = p->in.left;
inline.c:	if ( p->in.op == CM )  return( p->in.right->in.left );
inline.c:	else  return( p->in.left );
inline.c:		if (!p->name || !strcmp(p->name, name)) {
inline.c:			if (p->tn.op != REG || istreg(p->tn.rval))
inline.c:			if (p->tn.op != REG || ! istreg(p->tn.rval))
inline.c:			if (p->tn.op != REG)
inline.c:			if (p->tn.op != ICON)
inline.c:	if (psym->name)
inline.c:	if ((psym->name = malloc(strlen(name) + 1)) == NULL)
inline.c:	strcpy(psym->name, name);
inline.c:	psym->class = class;
inline.c:	psym->pnode = p;
inline.c:	while (n-- && p->name)
inline.c:		if (p->class == ISCL_lab)
inline.c:			tfree(p->pnode);
inline.c:		p->class = ISCL_undef;
inline.c:		p->pnode = (NODE *) 0;
inline.c:		p->name = (char *) 0;
inline.c:				/* put out non-significant gunk */
inline.c:				if ((ngunk = (s-sbuf) - (m-mybuf)) != 0)
inline.c:					if ((q = mac_lookup(s))->name)
inline.c:						if (q->class == ISCL_lab)
inline.c:							if (q->pnode->in.op != ICON)
inline.c:								printf(".ASM%d", q->pnode->tn.lval);
inline.c:							adrput(q->pnode);
inline.c:	**	$ <external-name> # <# of args> # <list of formals> \n
inline.c:	    td_enlarge(&td_inlargs, SZINLARGS-needsize);
inline.c:			cerror("EOF in asm pseudo-function definition");
inline.c:    /* The string searched through starts with '#' number-of-argumemts '#',
inline1.c:/* inline1.c -- produce in-line code for ASM psuedo functions */
inline1.c:/* 'asm' pseudo-function definitions, whose bodies contain code 
inline1.c:/* symbol defined in order to turn on the asm psuedo-function expansion
inline1.c:		cerror("Missing temporary file for in-line processing\n");
inline1.c:			cerror("EOF in asm pseudo-function definition");
inline2.c:/* inline2.c -- produce in-line code for ASM psuedo functions */
inline2.c:/* 'asm' pseudo-function definitions, whose bodies contain code 
inline2.c:/* When asm function calls are expanded in-line,
inline2.c:/* arguments are evaluated left-to-right if they're
inline2.c:/* symbol defined in order to turn on the asm psuedo-function expansion
inline2.c:static int expanding = 0;		/* non-zero if currently expanding */
inline2.c:	    uerror("Missing temporary file for in-line capability\n");
inline2.c:	if (p->in.op == INCALL && genfargs(p->in.right)) return(1);
inline2.c:	if (p->in.left->in.op != ICON)
inline2.c:		cerror("asm pseudo-function must be called directly");
inline2.c:    if (p->in.op == CM)
inline2.c:	return( genfargs(p->in.left) || genfargs(p->in.right) );
inline2.c:    p = p->in.left;
inline2.c:    if (optype(p->in.op) != LTYPE)	/* don't bother if it's a leaf */
inline2.c:		cerror("In-line runs out of registers\n");
inline2.c:	    l->tn.op = TEMP;
inline2.c:	    l->tn.lval = freetemp( argsize(p)/SZINT );
inline2.c:	    l->tn.lval = BITOOR( l->tn.lval );
inline2.c:	    l->tn.name = (char *) 0;
inline2.c:	    l->tn.type = p->tn.type;
inline2.c:		l->tn.rval = 0;		/* not a register temp */
inline2.c:	    aop->in.op = ASSIGN;
inline2.c:	    aop->in.left = l;
inline2.c:	    aop->in.right = r;
inline2.c:	    aop->in.type = p->tn.type;
inline2.c:		cerror("In-line fails to assign to TEMP\n");
inline2.c:#define IT_undet	(-1)
inline2.c:	inlname = p->in.left->tn.name;
inline2.c:		*(t+strlen(t)-1) = '\0'; /* overwrite \n with NUL */
inline2.c:	/* now we're ready for the works--first, try to find the %
inline2.c:						if ( p->in.op == INCALL )
inline2.c:						    p->in.op = CALL;
inline2.c:						    p->in.op = UNARY CALL;
inline2.c:							*(t+strlen(t)-1) = '\0'; /* overwrite \n with NUL */
inline2.c:						expmac(); /* got it -- expand */
inline2.c:							uerror("%%error specification reached in asm expansion -- check arguments");
inline2.c:	/* nice to have coroutines here--one to prewalk the arg tree, */
inline2.c:	if ( ninlargs && p->in.op == INCALL)
inline2.c:		return (pcllist(&s, p->in.right, &curarg));
inline2.c:	p->tn.op = ICON;
inline2.c:	p->tn.name = "";
inline2.c:	p->tn.lval = ++labno;
inline2.c:	for ( howdeep = nargs-n; howdeep > 0; --howdeep )
inline2.c:	    p = p->in.left;
inline2.c:	if ( p->in.op == CM )  return( p->in.right->in.left );
inline2.c:	else  return( p->in.left );
inline2.c:	while (n--)
inline2.c:		if (!p->name || !strcmp(p->name, name))
inline2.c:			if (p->tn.op != REG || istreg(p->tn.rval))
inline2.c:			if (p->tn.op != REG || ! istreg(p->tn.rval))
inline2.c:			if (p->tn.op != REG)
inline2.c:			if (p->tn.op != ICON)
inline2.c:	if (psym->name)
inline2.c:	if ((psym->name = malloc(strlen(name) + 1)) == NULL)
inline2.c:	strcpy(psym->name, name);
inline2.c:	psym->class = class;
inline2.c:	psym->pnode = p;
inline2.c:	while (n--)
inline2.c:		if (p->class == ISCL_lab)
inline2.c:			tfree(p->pnode);
inline2.c:		p->class = ISCL_undef;
inline2.c:		p->name = (char *) (p->pnode = (NODE *) NULL);
inline2.c:				/* put out non-significant gunk */
inline2.c:				if ((ngunk = (s-sbuf) - (m-mybuf)) != 0)
inline2.c:					if ((q = mac_lookup(s))->name)
inline2.c:						if (q->class == ISCL_lab)
inline2.c:							if (q->pnode->in.op != ICON)
inline2.c:								printf("_ASM%d", q->pnode->tn.lval);
inline2.c:							adrput(q->pnode);
inline2.c:    /* The string searched through starts with '#' number-of-argumemts '#',
manifest.h:# define INTCALL1 144           /* MC68881 in-line */
manifest.h:# define INTCALL2 145           /* MC68881 in-line matherr support */
manifest.h:# define INTCALL3 146           /* MC68881 in-line matherr sin/cos/tan */
manifest.h:# define ASMNO  156   /* in-line asm stmt */
manifest.h:						/**	coptim to c1 -- treat same as ASMNO **/
manifest.h:# define NOASG (-1)+
manifest.h:# define NOUNARY (-2)+
manifest.h:# define NOLAB (-1)
manifest.h:# define BITMASK(n) (((n)==SZLONG)?-1L:((1L<<(n))-1))
manifest.h:# define ENUNSIGN(x) ((x)+(UNSIGNED-INT))
manifest.h:# define DEUNSIGN(x) ((x)+(INT-UNSIGNED))
manifest.h:# define DIMTABSZ 9000 /* size of the dimension/size table -- ken#6 && ken#7 */
manifest.h:# define TREESZ 2000 /* space for building parse tree: bk, 700->2000 */
manifest.h:extern int Arix[];	/* Arix-specific flags */
manifest.h:   char flags;		/* attributes of basic block - header of 
manifest.h:   int id;		/* identification number - order in which created
manifest.h:			** this label.   NOTE - if NIL then 
manifest.h:	/* in one-pass operation, define the tree nodes */
manifest.h:		char pad[NCHNAM-sizeof(char *)];	/* padding hack! */
manifest.h:		char pad[NCHNAM-sizeof(char *)];	/* padding hack! */
manifest.h:		char pad[NCHNAM-sizeof(char *)];	/* padding hack! */
manifest.h:		int *udduptr;	/* pointer to UD/DU information - not used */
match.c:int zflag = 0;			/* non-zero to output stin line and cost for
match.c:		q = ophead[pop=p->tn.op];
match.c:		tl = l->in.type;
match.c:		tr = r->in.type;
match.c:		if( p->tn.goal == CCC ) goal = (VALUE|RESCC);
match.c:		else if( p->tn.goal == NRGS ) goal = VALUE;
match.c:		tyop = p->in.type;
match.c:		else q = q->nextop;
match.c:		printf( "match tree %d, op %s\n", p-node, opst[pop] );
match.c:	for( ; q ; q = q->nextop ){
match.c:		if( !( tl & q->ltype ) ) continue;
match.c:		if( !( tr & q->rtype ) ) continue;
match.c:		if( !( goal & q->rewrite ) ) continue;
match.c: *    The op will be one of the following ( =, +=, -=, +, -, ++, -- )
match.c:		if( (  p->in.op == ASSIGN
match.c:		    || p->in.op == ASG PLUS
match.c:		    || p->in.op == ASG MINUS
match.c:		    || p->in.op == INCR
match.c:		    || p->in.op == DECR
match.c:		    && ( p->in.left->tn.op == REG )
match.c:		    && ( p->in.left->tn.lval & USE_AREG )
match.c:		    && ( q->rewrite & RESCC )
match.c:		    && !((q->needs >> NEEDNUM) & CC_AREG )
match.c: *                         op  ( +=, -=, ++, -- )
match.c:		else if( (  p->in.op == ASG PLUS
match.c:		         || p->in.op == ASG MINUS
match.c:		    	 || p->in.op == INCR
match.c:		    	 || p->in.op == DECR
match.c:		    	&& ( p->in.right )
match.c:		    	&& ( p->in.right->tn.op == REG )
match.c:		    	&& ( p->in.right->tn.lval & USE_AREG )
match.c:		    	&& !( p->in.left && ( p->in.left->tn.op == REG ))
match.c:			&& !((q->needs >> NEEDNUM) & CC_AREG )
match.c:		else if( ( q->needs & USERNEEDS ) &&
match.c:				q->stinline, opst[q->op] );
match.c:		if( !( tyop & q->tyop ) ) {
match.c:				q->stinline, tyop, q->tyop );
match.c:		if( q->rshape ){
match.c:			if( rr=mspine( q->rshape, (q->lshape)?r:p, 0, sha[1] )){
match.c:				if( !q->lshape ) ustrip(pop);
match.c:		if( q->lshape ){
match.c:			if( !lflg && asgop(q->op) ){
match.c:				/* q->op is an assignment op, pop isn't */
match.c:				rr = rtspine( q->lshape, p );
match.c:			else rr = mspine( q->lshape, l, lflg, sha[0] );
match.c:				q->stinline, p-node );
match.c:		if( sha[1][j]->op == o ) sha[1][i++] = sha[1][j];
match.c:		switch( s->op ) {
match.c:			if( s->sh ) if( !spshape( s->sh, p ) ) continue;
match.c:			if( rr >= NSHP-1 ) cerror( "too many shapes" );
match.c:		if( noresult( *p ) ) --p;  /* overwrite if result is illegal */
match.c:	if( s->op == INCR || s->op == DECR ) return( 1 );
match.c:	return( (s->sr && noresult(s->sr)) ||
match.c:	    (s->sl && noresult( s->sl )) );
match.c:	sop = s->op;
match.c:	pop = p->tn.op;
match.c:		s-shapes, opst[sop], p-node, opst[pop] );
match.c:	if( ( s->sh ) && !spshape( s->sh,p) ) return( 0 );
match.c:		if( !smspine( s->sr, p->in.right, 0 ) ) return(0);
match.c:		s = s->sl;
match.c:		p = p->in.left;
match.c:		printf( "\tmspine( %d, %d, %d )\n", ps-pshape, p-node, flag );
match.c:	pop = p->tn.op;
match.c:	/* copy the wild-cards, and those where the op matches */
match.c:		switch( s->op ) 
match.c:			if( s->sh ) if( !spshape(s->sh,p) ) continue;
match.c:			if( rr >= NSHP-1 ) cerror( "too many shapes" );
match.c:				s-shapes, opst[s->op], p-node,
match.c:	for( ; (s= *ps) && s->op != pop; ++ps ) 
match.c:	for( ; (s = *ps) && s->op == pop; ++ps ) 
match.c:			if( !smspine( s->sl, p->in.left, 0 ) ) continue;
match.c:		else if( s->sl ) 
match.c:			if( s->sr ) 
match.c:				if( !smspine( s->sr, p->in.right, 0 ) )
match.c:				if( !smspine( s->sl, p->in.left, asgop(s->op)) )
match.c:				if( !smspine( s->sl, p->in.left, flag ))
match.c:		else if( s->sr && !smspine( s->sr, p->in.right, 0 ) )
match.c:		if( s->sh ) if( !spshape( s->sh, p ) ) continue;
match.c:		if( rr >= NSHP-1 ) cerror( "too many shapes" );
match.c:			s-shapes, opst[s->op], p-node,
match.c:	if( (o = p->tn.op) == TEMP ) return( 1 );
match.c:		return( p->in.left->tn.op == TEMP );
match.c:	o = p->tn.op;
match.c:		if( p->in.right->tn.op == ICON ) p->in.right->tn.op = FREE;
match.c:			regrcl( p->in.right );
match.c:			tfree( p->in.right );
match.c:		q = p->in.left;
match.c:		q->tn.op = FREE;
match.c:		rmside( p->in.right );
match.c:		rmside( p->in.left );
match.c:/*	if( (c = p->tn.op) == CALL || c == UNARY CALL )
match.c:/*		pstab( S_NARGS, p->stn.argsize/SZINT);
match.c:				COMMENTSTR, q->stinline, p->in.cst[CEFF] );
match.c:			if( q1->tn.op != REG ) cerror( "bad D" );
match.c:			if( ushare( q2, q1->tn.rval, p->in.type ) == c ) continue;
match.c:			if( q1->tn.op != REG )
match.c:			if( q2->tn.op != REG )
match.c:			if( q1->tn.rval != q2->tn.rval )
match.c:			    || ((q1->tn.type&TPOINT) ^ (q2->tn.type&TPOINT))
match.c:			         (FP_TYPE(q1->tn.type) ^ FP_TYPE(q2->tn.type))
match.c:			    || ((q1->tn.lval&USE_AREG) ^ (q2->tn.lval&USE_AREG))
match.c:			    || ((q1->tn.type&TPOINT) ^ (q2->tn.type&TPOINT))
match.c:			    || ((q1->tn.lval&USE_AREG) ^ (q2->tn.lval&USE_AREG))
match.c:			if( q1->tn.op != FLD ) cerror( "bad FLD for %c", c );
match.c:			fldsz = UPKFSZ(q1->tn.rval);
match.c:			fldshf = UPKFOFF(q1->tn.rval);
match.c:			t = q1->tn.type;
match.c:				fldshf = SZLONG - fldsz - UPKFOFF(q1->tn.rval);
match.c:				fldshf = SZSHORT - fldsz - UPKFOFF(q1->tn.rval);
match.c:				fldshf = SZCHAR - fldsz - UPKFOFF(q1->tn.rval);
match.c:			else fldshf = SZINT - fldsz - UPKFOFF(q1->tn.rval);
match.c:			--val;
match.c:			if ( p->bn.label < 0 )
match.c:			   printf( "_%d", -p->bn.label );
match.c:			printf( "%d", p->bn.label );
match.c:		return( &resc[c-'1'] );
match.c:		return( optype( p->in.op ) == LTYPE ? p : p->in.left );
match.c:		return( optype( p->in.op ) != BITYPE ? p : p->in.right );
match.c:	if( c == '-' )
match.c:			printf( "SPTYPE(%d, %o), ttype=%o\n", p-node,
match.c:				sh, p->tn.type );
match.c:		if( sh & p->tn.type ) return( 1 );
match.c:		if( p->tn.op != ICON || p->tn.name != (char *) 0 ) return( 0 );
match.c:		val = p->tn.lval;
match.c:		else if( t==SNVAL && val == -i ) return( 1 );
match.c:		else if( t==SSRANGE && val>= -pow2[i] && val<pow2[i] )return(1);
match.c:	need = q->needs >> NEEDNUM;
match.c:			l = p->in.left;
match.c:			r = p->in.right;
match.c:			if( l && ( l->in.op == TEMP && l->in.right ) )
match.c:			if( r && ( r->in.op == TEMP && r->in.right ) )
match.c:			if( is_m68881 && FP_TYPE( p->in.type ) )
mfile1.h:			** pre-existing file header blocks and object files;
mfile1.h:# define NOOFFSET (-10201)
mfile2.h:# define SRANGE0 	 030000 /* positive range [0, 2**mm - 1] */
mfile2.h:# define SSRANGE 	 040000	/* signed range [-2**mm, 2**mm] */
mfile2.h:	SHAPE	*sl;	/* pointers to left- and right-hand shape */
mfile2.h:			** pre-existing file header blocks and object files;
mfile2.h:# define getlt(p,t) ((t)==LTYPE?p:p->in.left)
mfile2.h:# define getl(p) (getlo(p,p->tn.op))
mfile2.h:# define getrt(p,t) ((t)==BITYPE?p->in.right:p)
mfile2.h:# define getr(p) (getro(p,p->tn.op))
mfile2.h:	/* the assumption is that registers 0 through NRGS-1 are scratch */
mfile2.h:# define NINS 1200	/* ken#6-to 400; bk-to 1200 */
mfile2.h:#define IS_BYTE(i)	( ( i > -129 ) && ( i < 128 ) )
mfile2.h:#define IS_WORD(i)	( ( i > -32769 ) && ( i < 32768 ) )
mfile2.h:#define NONE -1		/* indicates no register specified */
optim.c:# define ISCON(p) (p->in.op==ICON)
optim.c:	switch( p->tn.op )
optim.c:		p->tn.lval += adj;
optim.c:		return( block( PLUS, p, bcon(adj), p->fn.type,
optim.c:		p->fn.cdim, p->fn.csiz, 0 ) );
optim.c:		q = p->in.right;
optim.c:		if( q->tn.op != ICON ) goto mkplus;
optim.c:		q->tn.lval += adj;
optim.c:		q = p->in.right;
optim.c:		if( q->tn.op != ICON ) goto mkplus;
optim.c:		q->tn.lval -= adj;
optim.c:	switch( p->tn.op )
optim.c:		p->tn.lval += BITOOR(adj);
optim.c:		p->in.left = aadjust( p->in.left, adj );
optim.c:	/* Special structure alignment for m68k - see comments in pftn.c */
optim.c:		printf( "tydown(%d) called with:\n", p-node );
optim.c:	t = p->tn.type;
optim.c:	switch( p->tn.op ) 
optim.c:		r = p->in.right;
optim.c:		if( bigsize(r->tn.type) > bigsize(p->tn.type ) ) 
optim.c:			p->in.right = doptim( r );
optim.c:				p-node );
optim.c:		if( p->tn.op == COMOP ) return( flag );
optim.c:		l = p->in.left;
optim.c:		if( bigsize(l->tn.type) > bigsize(p->tn.type ) ) 
optim.c:			p->in.left = doptim( l );
optim.c:				p-node );
optim.c:	/* the unsigned-ness is mostly ignored */
optim.c:		printf( "sconvert(%d) called:\n", p-node );
optim.c:	if( p->tn.op != CONV ) cerror( "sconvert" );
optim.c:	l = p->in.left;
optim.c:	t = p->tn.type;
optim.c:	lt = l->tn.type;
optim.c:	o = l->tn.op;
optim.c:		l->tn.op = ICON;
optim.c:		l->tn.lval = l->fpn.dval;  /* MACHINE-DEPENDENT CONVERSION */
optim.c:		l->tn.rval = NONAME;
optim.c:		p->in.left = l->in.left;
optim.c:		l->tn.op = FREE;
optim.c:		p->tn.op = FREE;
optim.c:		l->tn.lval = ccast( l->tn.lval, p->tn.type );
optim.c:		l->tn.type = p->tn.type;
optim.c:		l->fn.csiz = p->fn.csiz;
optim.c:		l->fn.cdim = p->fn.cdim;
optim.c:		p->tn.op = FREE;
optim.c:	if ( l->tn.typeq & VOLATILE )		/* bk */
optim.c:		if( t == LONG ) adj -= SZLONG;				/* bk */
optim.c:		else if( t == INT ) adj -= SZINT;
optim.c:		else if( t == SHORT ) adj -= SZSHORT;
optim.c:		else if( t == CHAR ) adj -= SZCHAR;
optim.c:	/* bk: catch case of CONV(int->long) when o==REG */
optim.c:	l = p->in.left;
optim.c:	if( ISPTR( l->tn.type ) ) {		
optim.c:		p->in.op = FREE;				/* bk */
optim.c:		if ( BTYPE(p->tn.type) == STRTY || BTYPE(p->tn.type)==UNIONTY)
optim.c:			l->fn.csiz = p->fn.csiz;
optim.c:	o = l->tn.op;
optim.c:		if( l->tn.op == CONV ) l = sconvert( l );
optim.c:		l->tn.type = p->tn.type;
optim.c:		l->fn.cdim = p->fn.cdim;
optim.c:		l->fn.csiz = p->fn.csiz;
optim.c:		p->tn.op = FREE;
optim.c:	if( p->in.op == CM )
optim.c:		p->in.left = fortarg( p->in.left );
optim.c:		p->in.right = fortarg( p->in.right );
optim.c:	while( ISPTR(p->in.type) )
optim.c:# define REPORT(x) if(opdebug)printf( "optim turns %d into %d\n",p-node,x-node);
optim.c:	if( (t=BTYPE(p->in.type))==ENUMTY || t==MOETY ) econvert(p);
optim.c:	switch( optype( o = p->tn.op ) ) 
optim.c:		r = p->in.right;
optim.c:		l = p->in.left;
optim.c:		return( ISPTR(p->tn.type)?pvconvert(p):sconvert(p) );
optim.c:		t = l->in.type;
optim.c:		if( l->tn.op == CONV && t!=FLOAT && t!=DOUBLE
optim.c:			p->in.left = l->in.left;
optim.c:			l->tn.op = FREE;
optim.c:			l = p->in.left;
optim.c:			r = makety( r, p->in.type, p->fn.cdim, p->fn.csiz );
optim.c:			p->in.right = doptim( r );
optim.c:		if( !r->tn.lval && (o==ASG PLUS || o==ASG MINUS || o==ASG OR ||
optim.c:		if( r->tn.lval == 1 && (o==ASG MUL || o==ASG DIV) ) 
optim.c:		if( (i = ispow2( r->tn.lval ))>=0 && o==ASG MUL ) 
optim.c:			o = p->in.op = ASG LS;
optim.c:			r->tn.lval = i;
optim.c:		if( !nncon(r) || r->tn.lval )
optim.c:		p->in.right = fortarg( r );
optim.c:		if ( intrflg && is_m68881 && t==DOUBLE && r->in.op==FUNARG
optim.c:		    && (FP_TYPE(r->in.type)) && l->tn.op==ICON
optim.c:		    && l->tn.rval!=NONAME && l->tn.rval>=0)
optim.c:		    intr_nm = exname(stab[l->tn.rval].sname);
optim.c:				p->in.right = r->in.left;
optim.c:				r->in.op = FREE;
optim.c:				p->in.op = INTCALL1;
optim.c:						p->in.op = INTCALL3;
optim.c:					   else p->in.op = INTCALL2;
optim.c:						     p-node, r-node);
optim.c:		switch( l->tn.op ) 
optim.c:			l->tn.op = FREE;
optim.c:			l=l->in.left;
optim.c:			if( simpstr( p->fn.cdim, p->fn.csiz ) == STRTY ) 
optim.c:				l->tn.op = VPARAM;
optim.c:				l->tn.lval = BITOOR(ARGINIT);
optim.c:				l->tn.rval = NONAME;
optim.c:			if( simpstr( p->fn.cdim, p->fn.csiz ) != STRTY ) break;
optim.c:			l->tn.rval = -strftn;
optim.c:			l->tn.op = ICON;
optim.c:			l->in.type = p->in.type;
optim.c:			l->fn.cdim = p->fn.cdim;
optim.c:			l->fn.csiz = p->fn.csiz;
optim.c:			p->in.op = FREE;
optim.c:		t = simpstr( l->fn.cdim, l->fn.csiz );
optim.c:			p->tn.type = DECREF( p->tn.type );
optim.c:			if( o == STCALL ) l->tn.op = CALL;
optim.c:			else l->tn.op = UNARY CALL;
optim.c:			l->fn.type = l->fn.csiz = t;
optim.c:			l->fn.cdim = 0;
optim.c:		if( p->tn.type == STRTY || p->tn.type == UNIONTY ) 
optim.c:			p->tn.op = FREE;
optim.c:		if( l->tn.op == UNARY AND && !callop(l->in.left->tn.op) ) 
optim.c:			if ( l->in.left->in.type == p->in.type ) {	/* bk */
optim.c:				l->tn.op = FREE;
optim.c:				l = l->in.left;
optim.c:		if( l->tn.op != ICON ) break;
optim.c:		l->tn.op = NAME;
optim.c:		r->tn.lval = - r->tn.lval;
optim.c:		o = p->in.op = PLUS;
optim.c:		if( o==r->tn.op || nncon(l) || ( ISCON(l) && !ISCON(r) ) ) 
optim.c:			l = p->in.left = r;
optim.c:			r = p->in.right = sp;
optim.c:		if( o==PLUS && l->tn.op==PLUS && ISCON(r) &&
optim.c:		    nncon(l->in.right) )
optim.c:			p->in.left = l->in.left;
optim.c:			l->tn.op = FREE;
optim.c:			l = l->in.right;
optim.c:			r->tn.lval += l->tn.lval;
optim.c:			l->tn.op = FREE;
optim.c:		if( o==PLUS && l->tn.op==PLUS && nncon(r) &&
optim.c:		    ISCON(l->in.right) )
optim.c:			l->in.right->tn.lval += r->tn.lval;
optim.c:		/* (A - C1) + C2, where C2 can be a ptr, C1 not */
optim.c:		if( o==PLUS && l->tn.op==MINUS && ISCON(r) &&
optim.c:		    nncon(l->in.right) )
optim.c:			p->in.left = l->in.left;
optim.c:			l->tn.op = FREE;
optim.c:			l = l->in.right;
optim.c:			r->tn.lval -= l->tn.lval;
optim.c:			l->tn.op = FREE;
optim.c:		if( o==PLUS && l->tn.op == UNARY AND && ISCON(r) ) 
optim.c:			switch( l->in.left->tn.op ) 
optim.c:				l->in.left->tn.lval += r->tn.lval;
optim.c:		if( o==MUL && nncon(r) && (i=ispow2(r->tn.lval))>=0)
optim.c:				l = makety( l, p->tn.type, p->fn.cdim,
optim.c:				p->fn.csiz );
optim.c:				r->tn.op = FREE;
optim.c:				p->tn.op = FREE;
optim.c:					p-node );
optim.c:			o = p->in.op = LS;
optim.c:			r->tn.lval = i;
optim.c:		/* change +'s of negative consts back to - */
optim.c:		if( o==PLUS && nncon(r) && r->tn.lval<0 )
optim.c:			r->tn.lval = -r->tn.lval;
optim.c:			o = p->in.op = MINUS;
optim.c:		if( nncon(r) && !r->tn.lval && (o==PLUS||o==MINUS) )
optim.c:		if( o==PLUS && ISPTR(p->tn.type) && ISPTR(r->tn.type)
optim.c:		    && r->tn.op != ICON
optim.c:			p->in.left = r; 
optim.c:			p->in.right = sp; 
optim.c:		if( o==PLUS && ISPTR(p->tn.type) && ISPTR(l->tn.type)
optim.c:		    && r->tn.op != ICON
optim.c:			p->in.left = r; 
optim.c:			p->in.right = sp; 
optim.c:		if( nncon( r ) && r->tn.lval == 1 ) goto bless;
optim.c:			p->in.op = revrel[p->in.op - EQ ];
optim.c:			l = p->in.left = r;
optim.c:			r = p->in.right = sp;
optim.c:		if( (t=simpstr( p->fn.cdim, p->fn.csiz ) ) != STRTY ) 
optim.c:			if( ISPTR(r->tn.type) ) 
optim.c:				r->fn.type = r->fn.csiz = t;
optim.c:				r->fn.cdim = 0;
optim.c:				p->in.right = r = doptim( r );
optim.c:			l->fn.type = l->fn.csiz = t;
optim.c:			l->fn.cdim = 0;
optim.c:			p->in.left = l = doptim( l );
optim.c:			p->fn.type = p->fn.csiz = t;
optim.c:			p->fn.cdim = 0;
optim.c:			p->fn.op = ASSIGN;
optim.c:		if( (t=simpstr( p->fn.cdim, p->fn.csiz ) ) != STRTY ) 
optim.c:			if( ISPTR(l->fn.type) ) 
optim.c:				l->fn.type = l->fn.csiz = t;
optim.c:				l->fn.cdim = 0;
optim.c:				p->in.left = l = doptim( l );
optim.c:			p->fn.type = p->fn.csiz = (t==LONG ? LONG : INT);
optim.c:			p->fn.cdim = 0;
optim.c:			p->fn.op = FUNARG;
optim.c:		p->in.left = aadjust( l, p->stn.stsize );
optim.c:		p->tn.op = FREE;
optim.c:	switch( optype( p->tn.op ) )
optim.c:		p->in.right = optim( p->in.right );
optim.c:		p->in.left = optim( p->in.left );
optim.c:	if( c <= 0 || (c&(c-1)) ) return(-1);
optim.c:	return( p->tn.op == ICON && p->tn.rval == NONAME && !ISPTR(p->tn.type));
optim.c:	p->tn.lval = BITOOR(off);
optim.c:	p->fn.type = p->fn.csiz = PTRTYPE;
optim.c:	if ( BTYPE( p->fn.type ) == LONG ) {
optim.c:		p->fn.type = (p->fn.type & ~BTMASK) | INT;
optim.c:		p->fn.csiz = INT;
optim.c:		if ( BTYPE( p->fn.type ) == ULONG ) {
optim.c:			p->fn.type = (p->fn.type & ~BTMASK) | UNSIGNED;
optim.c:			p->fn.csiz = UNSIGNED;
optim.c:/*		pstab( S_LBRAC, blevel-1 );
pftn.c:	block-nested extern declarations & goto label namespace
pftn.c:	idp = q->tn.rval;
pftn.c:		printf( "defid( %s (%d), ", p->sname, idp );
pftn.c:		qprint( q->in.typeq );
pftn.c:		tprint(stdout, q->in.type );
pftn.c:		q->fn.cdim, q->fn.csiz, blevel );
pftn.c:	/* Label symbols are separated from their non-label namesakes: */
pftn.c:	if ((p->sclass != ULABEL) && (p->sclass != LABEL)) {
pftn.c:			j = lookup( p->sname, SLAB );
pftn.c:			    if ( p->sclass != SNULL && 
pftn.c:					q->tn.rval = idp = mkspace( p );
pftn.c:	type = q->in.type;
pftn.c:	stp = p->stype;
pftn.c:	slev = p->slevel;
pftn.c:		printf( ", %s, (%d,%d) ), level %d\n", scnames(p->sclass),
pftn.c:		p->dimoff, p->sizoff, slev );
pftn.c:	if( stp == FTN && p->sclass == SNULL )goto enter;
pftn.c:			"declared argument %s is missing", p->sname );
pftn.c:				werror( W_STRICT, "non-portable redeclaration of return type" );
pftn.c:	dsym = p->dimoff;
pftn.c:	ddef = q->fn.cdim;
pftn.c:	if( (temp==STRTY||temp==UNIONTY||temp==ENUMTY) && p->sizoff != q->fn.csiz
pftn.c:	scl = ( p->sclass );
pftn.c:			p->sclass = STATIC;
pftn.c:			p->sclass = LABEL;
pftn.c:			deflab( p->offset );
pftn.c:				werror( W_STRICT, "benign re-typedef" );
pftn.c:			p->sclass = FORTRAN;
pftn.c:/*			if( p->offset!= strucoff++ ) break;		*/ 	/* bk */
pftn.c:			if( p->offset!= strucoff ) break;
pftn.c:			p->sclass = EXTDEF;
pftn.c:		if( dimtab[p->sizoff] == 0 ) {
pftn.c:		p->sflags |= SNONUNIQ;  /* old entry is nonunique */
pftn.c:		for( memp = &paramstk[paramno-1];
pftn.c:			/* iterate */ --memp)
pftn.c:				if ( p->sname != stab[*memp].sname )
pftn.c:						p->sname);
pftn.c:					p->sname);
pftn.c:		q->tn.rval = idp = hide( p );
pftn.c:		chk_struct = p->sizoff;
pftn.c:	uerror( "redeclaration of %s", p->sname );
pftn.c:	if( type == UNDEF ) uerror("void type for %s",p->sname);
pftn.c:	p->stype = type;
pftn.c:	p->sclass = class;
pftn.c:	p->slevel = blevel;
pftn.c:	p->offset = NOOFFSET;
pftn.c:	p->suse = lineno;
pftn.c:		p->sflags |= SREG;	/* can't allocate real reg, but do usage checks */
pftn.c:		p->stypeq = 0;
pftn.c:		p->stypeq = typequal;
pftn.c:		p->sizoff = curdim;
pftn.c:		dstash( -1 ); /* index to members of str or union */
pftn.c:			p->sizoff = q->fn.csiz;
pftn.c:			p->stypeq |= struc_qual[sulvl];			/* bk */
pftn.c:				qprint( p->stypeq );
pftn.c:			p->sizoff = BTYPE(type);
pftn.c:	p->dimoff = q->fn.cdim;
pftn.c:		/* if high-level optimizer follows c0 we spread out addresses */
pftn.c:		p->offset = getlab();
pftn.c:		p->sflags |= SLAB;	 /*bk#8*/
pftn.c:		p->offset = getlab();
pftn.c:		p->slevel = 2;
pftn.c:			deflab( p->offset );
pftn.c:		p->offset = getlab();
pftn.c:		p->slevel = 0;
pftn.c:		p->offset = bump_enum();
pftn.c:		p->offset = nextrvar;
pftn.c:/*		if( blevel == 1 ) p->sflags |= SSET;		*/	/* bk: not used! */
pftn.c:	/* user-supplied routine to fix up new definitions */
pftn.c:		if ( p->sclass != EXTERN )		/* well then: is it tentative? */
pftn.c:		/* don't link block-nested extern into scopestack at external level */
pftn.c:	if ((p->sclass == EXTERN) && (blevel >= 2) && mode_chk( MODE_XBLOCK )) {
pftn.c:	    p->scopelink = scopestack[slev = blevel];
pftn.c:	    p->scopelink = scopestack[slev = p->slevel];
pftn.c:			p->dimoff, p->sizoff, p->offset );
pftn.c:		bracketinc--;
pftn.c:		fprintf(stderr," %s\n", p->sname);
pftn.c:			p->sname, 
pftn.c:			tsize(q->in.type, q->fn.cdim, q->fn.csiz)/SZCHAR);
pftn.c:	    /* not quite right --- puts extra indent in */
pftn.c:		fprintf(stderr," %s:\t%#x", p->sname, p->offset/SZCHAR);
pftn.c:		    if ((p->offset/SZCHAR) % 4)
pftn.c:			fprintf(stderr,"<----- %% 4");
pftn.c:			    if ((p->offset/SZCHAR) % 2)
pftn.c:				fprintf(stderr,"<----- %% 2");
pftn.c:			    if ((p->offset/SZCHAR) % 4)
pftn.c:				fprintf(stderr,"<----- %% 4");
pftn.c:			    if ((p->offset/SZCHAR) % 8)
pftn.c:				fprintf(stderr,"<----- %% 8");
pftn.c:			    if ((p->offset/SZCHAR) %4)
pftn.c:				fprintf(stderr,"<------- default %% 4");
pftn.c:				t = p->stype;
pftn.c:				p->stype = argty[i];
pftn.c:				if( p->sclass == REGISTER )
pftn.c:					p->sclass = PARAM;
pftn.c:					p->offset = argsoff[i];
pftn.c:				p->stype = t;
pftn.c:	int	newstyle,		/* new-style ftn def */
pftn.c:		oldwproto; 		/* old-style ftn def, but comes with a prototype */
pftn.c:						/* ask if old-style def but has a prototype */
pftn.c:		if ( (plist = &proto_lists[i])->lflag & PDECLARE ) {
pftn.c:			if ( (plist->lcnt != argno) && !(plist->lflag & PVARARGS) )
pftn.c:			protoargs = plist->lcnt;
pftn.c:			newstyle = 1;			/* new-style ftn-def needs symbol fixing */
pftn.c:		pt = plist->lhead;
pftn.c:			printf("\t%s (%d) ",p->sname, j);
pftn.c:			tprint(stdout,p->stype);
pftn.c:				if( p->stype == FARG ) 
pftn.c:					q = block(FREE,NIL,NIL,INT,0,INT, protoargs ? pt->pqual: 0);
pftn.c:					q->tn.rval = j;
pftn.c:/* ANSI: "old-style fn parms are taken as widened before type-matching" */
pftn.c:/* followed by function call with no float->double widening, followed by  */
pftn.c:/* an old-style ftn-def declaring "float", which is widened to double by */
pftn.c:/* cases involving narrow types, so we make it a STRICT-level warning. */
pftn.c:				} else if ( indtype(p->stype) != pt->ptype ) { /* way off! */
pftn.c:					if ( indtype(p->stype) == indtype(pt->ptype) ) {
pftn.c:						p->sname );
pftn.c:						p->sname );
pftn.c:				p->slevel--; /* was set 1 level higher for "prototype scope" */
pftn.c:				q = block(FREE,NIL,NIL,pt->ptype,pt->pdim,pt->psiz, pt->pqual );
pftn.c:				q->tn.rval = j;
pftn.c:				typequal = pt->pqual;
pftn.c:				defid( q, pt->pclass );
pftn.c:				if ( --protoargs > 0 )
pftn.c:					pt = pt->pnext;
pftn.c:				pt = pt->pnext;
pftn.c:		} else if( p->stype == FARG ) 
pftn.c:			q->tn.rval = j;
pftn.c:		if( p->sclass == REGISTER )
pftn.c:			int tmp = p->offset;
pftn.c:			p->offset = NOOFFSET;
pftn.c:			p->sclass = PARAM;
pftn.c:			argsoff[i] = p->offset;
pftn.c:			argty[i] = p->stype;
pftn.c:			p->sclass = REGISTER;
pftn.c:			p->offset = tmp;
pftn.c:			argsoff[i] = p->offset;
pftn.c:			argty[i] = p->stype;
pftn.c:	if( p->slevel>1 && p->sclass == STATIC ) deflab( p->offset );
pftn.c:	temp = p->stype;
pftn.c:	if( strftn && simpstr( p->dimoff, p->sizoff ) != STRTY )
pftn.c:		i = tsize( temp, p->dimoff, p->sizoff);
pftn.c:		defalign( talign( temp, p->sizoff ) );
pftn.c:		zecode( (i+SZINT-1)/SZINT );  /* set aside integer zeros */
pftn.c:		if( s->sclass == REGISTER )
pftn.c:			temp = s->offset;
pftn.c:			s->offset = argsoff[i];
pftn.c:			s->sclass = PARAM;
pftn.c:			s->offset = temp;
pftn.c:			s->sclass = REGISTER;
pftn.c:	if ( yychar==61 && p->slevel != blevel ) goto def;
pftn.c:	switch( p->stype )
pftn.c:		q->tn.rval = idn;
pftn.c:		q->in.type = (soru&INSTRUCT) ? STRTY : ( (soru&INUNION) ? UNIONTY : ENUMTY );
pftn.c:	return( mkty( p->stype, 0, p->sizoff, typequal ) );
pftn.c:	q->tn.rval = idn;
pftn.c:	q->tn.rval = idn;
pftn.c:		q->in.type = STRTY;
pftn.c:		q->in.type = UNIONTY;
pftn.c:		q->in.type = ENUMTY;
pftn.c:	psave( idn = q->tn.rval );
pftn.c:	return( paramno-4 );
pftn.c:		dstash( -1 );  /* index to member names */
pftn.c:		dstash( -lineno );  /* name of structure */
pftn.c:	else hanval = -1;		/* ken#4 */
pftn.c:				chk_struct = -1;
pftn.c:			if( p->offset < low ) low = p->offset;
pftn.c:			if( p->offset > high ) high = p->offset;
pftn.c:			p->sizoff = szindex;
pftn.c:			sa = salign( p->stype, p->sizoff );
pftn.c:			sa = talign( p->stype, p->sizoff );
pftn.c:		if( p->sclass & FIELD )
pftn.c:			sz = p->sclass&FLDSIZ;
pftn.c:			sz = tsize( p->stype, p->dimoff, p->sizoff );
pftn.c:			werror( W_DFLT, "structure member has size 0: %s", p->sname );
pftn.c:		if ( chk_struct != -1 )	/* if benign, warn anyway (ANSI constraint) */
pftn.c:	dstash( -1 );  /* endmarker */
pftn.c:		bracketinc--;
pftn.c:	switch( p->stype )
pftn.c:		uerror("redeclaration of formal parameter, %s",p->sname);
pftn.c:	p->stype = FARG;
pftn.c:	p->sclass = PARAM;
pftn.c:	    if ( strlen(inlargs) + strlen(p->sname) > BUFSIZ -2 )
pftn.c:	    strcat( inlargs, p->sname);
pftn.c:	for( i=0; i<=(SZINT-BTSHIFT-1); i+=TSHIFT )
pftn.c:	for( i=0; i<=(SZINT-BTSHIFT-1); i+=TSHIFT )
pftn.c:	for( i=0; i<=(SZINT-BTSHIFT-1); i+=TSHIFT )
pftn.c:		rest = n - inoff;
pftn.c:	rest = wb - inoff;
pftn.c:	rest = (n-inoff)/SZINT;
pftn.c:	rest = n-inoff;
pftn.c:	struct_init = (BTYPE(p->stype)==STRTY); /* structure initialization */
pftn.c:	iclass = p->sclass;
pftn.c:		( ISARY(p->stype) ) && 
pftn.c:		( dimtab[p->dimoff] == 0 ) ) {		/* i.e. is size yet unknown? */
pftn.c:		iclass = p->sclass = EXTDEF;
pftn.c: 		if ( is_const(p->stypeq ) 	/* put const data in text section; */
pftn.c: 			ilocctr = ISARY(p->stype)?ADATA:DATA;
pftn.c:		if (ISARY(p->stype))
pftn.c:		 else defalign( talign( p->stype, p->sizoff ) );
pftn.c:		else if( p->slevel>1 && p->sclass == STATIC ) deflab( p->offset );
pftn.c:	instk( curid, p->stype, p->stypeq, p->dimoff, p->sizoff, inoff );
pftn.c:         if ( ISARY(p->stype) || p->stype == STRTY || p->stype == ENUMTY )
pftn.c:			if ( ++pstk > &instack[STR_NEST-1] )			/* bk */
pftn.c:		pstk->in_fl = 0;	/* { flag */
pftn.c:		pstk->in_id =  id ;
pftn.c:		pstk->in_t =  t ;
pftn.c:		pstk->in_tq =  tq ;
pftn.c:		pstk->in_d =  d ;
pftn.c:		pstk->in_s =  s ;
pftn.c:		pstk->in_n = 0;  /* number seen */
pftn.c:			pstk->in_x = dimtab[s+1];
pftn.c:			pstk->in_x = 0;
pftn.c:		pstk->in_off = off;  /* offset at beginning of this element */
pftn.c:		/* INS_sz has size of array elements, and -size for fields */
pftn.c:			pstk->in_sz = tsize( DECREF(t), d+1, s );
pftn.c:			if ( pstk->in_sz <= 0 ) {
pftn.c:				pstk->in_sz = SZINT;
pftn.c:			pstk->in_sz = - ( stab[id].sclass & FLDSIZ );
pftn.c:			pstk->in_sz = 0;
pftn.c:		/* should fail in -SYSV */
pftn.c:			id = dimtab[pstk->in_x];
pftn.c:			if( p->sclass != MOS && !(p->sclass&FIELD) )
pftn.c:			t = p->stype;
pftn.c:			d = p->dimoff;
pftn.c:			s = p->sizoff;
pftn.c:			off += p->offset;
pftn.c:			id = dimtab[pstk->in_x];
pftn.c:			if( p->sclass != MOU )
pftn.c:			t = p->stype;
pftn.c:			d = p->dimoff;
pftn.c:			s = p->sizoff;
pftn.c:			if ( p->offset )
pftn.c:				cerror( "Non-zero union member offset" );
pftn.c:			off += p->offset;
pftn.c:	    (pstk->in_t == CHAR || pstk->in_t == UCHAR) &&
pftn.c:	    pstk!=instack && ISARY( pstk[-1].in_t ) )
pftn.c:		inforce( pstk->in_off );
pftn.c:			lxstr((pstk-1)!=instack?dimtab[(pstk-1)->in_d]:0);
pftn.c:			lxstr(dimtab[(pstk-1)->in_d]);
pftn.c:			(pstk->in_t == CHAR || pstk->in_t == UCHAR) &&
pftn.c:			pstk!=instack && ISARY( pstk[-1].in_t ) ) {
pftn.c:		p->tn.rval = -l;
pftn.c:		t = temp->in_t;
pftn.c:			d = temp->in_d;
pftn.c:			n = temp->in_n;  /* real number of initializers */
pftn.c:			d1 = dimtab[d];	/* should-be number of initializers */
pftn.c:					while( temp->in_n < d1 ) {
pftn.c:				doinit( bcon(0) );	/* zero-pad */
pftn.c:	t = pstk->in_t;
pftn.c:	d = pstk->in_d;
pftn.c:	s = pstk->in_s;
pftn.c:	n = pstk->in_n;
pftn.c:		vfdalign( pstk->in_sz );
pftn.c:		n = inoff/pstk->in_sz;  /* real number of initializers */
pftn.c:		prdef( &stab[pstk->in_id], 0 );
pftn.c:	autosym->offset = NOOFFSET;			/* so oalloc will work */
pftn.c:	src = bdty( NAME, NIL, -label );
pftn.c:	src->fn.type = dest->fn.type;
pftn.c:	src->fn.cdim = dest->fn.cdim;
pftn.c:	src->fn.csiz = dest->fn.csiz;
pftn.c:		iclass = -1;
pftn.c:			((pstk->in_t == STRTY) || 
pftn.c:			(pstk->in_t == UNIONTY) ||
pftn.c:			(ISARY(pstk->in_t))) ) {
pftn.c:                (ISARY(t = pstk[-1].in_t) || t==STRTY || t==UNIONTY) ) {
pftn.c:                if ( pstk[-1].in_fl == 0  && !icomplain) {
pftn.c:                                 if ( temp->in_fl != 0 ) {
pftn.c:                   werror( W_DFLT, "Inconsistently-bracketed initialization" );
pftn.c:		idname = pstk->in_id;
pftn.c:		if ( ((sym = &stab[idname])->sclass == MOS ) ||
pftn.c:				(sym->sclass == MOU) || (sym->sclass & FIELD) )
pftn.c:			if ( ISARY(pstk[-1].in_t) )
pftn.c:				 * of the automatic variable.  Since pstk->in_off contains
pftn.c:				 * the (positive) 0-relative offset of the current initializer,
pftn.c:				 *	lval = [stack offset of instack[0] aggregate] + pstk->in_off
pftn.c:				lval = BITOOR(pstk->in_off);
pftn.c:				idname = (pstk-1)->in_id;
pftn.c:				base->tn.type = (pstk-1)->in_t;	/* for multidimensional arrays*/
pftn.c:				base->tn.op = VAUTO;
pftn.c:				base->tn.rval = NONAME;
pftn.c:				base->tn.lval = BITOOR(stab[instack[0].in_id].offset);
pftn.c:				base->fn.csiz = 2;
pftn.c:				 * in the initialization offset (pstk->in_off) instead.
pftn.c:				 *	lval = [stack offset of instack[0] aggregate] + pstk->in_off
pftn.c:				curmem = pstk->in_id;
pftn.c:				stab[curmem].offset = pstk->in_off;
pftn.c:				idname = (pstk-1)->in_id;
pftn.c:				base->in.type = (pstk-1)->in_t;
pftn.c:				base->tn.op = VAUTO;
pftn.c:				base->tn.rval = NONAME;
pftn.c:				base->tn.lval = BITOOR(stab[instack[0].in_id].offset);
pftn.c:/*				base->fn.csiz = 2;*/
pftn.c:				if ( !ISPTR(base->in.type ) )
pftn.c:				base = buildtree( STREF, base, off );		/* p->n... *(p+n) */
pftn.c:		} else if ( ISARY(pstk[-1].in_t) )
pftn.c:/*			lval = BITOOR(pstk->in_off) / pstk->in_s ;	/ offset */
pftn.c:/*			lval = pstk[-1].in_off + ( pstk[-1].in_n ); */
pftn.c:			lval = BITOOR(pstk->in_off);
pftn.c:			lval = lval / (BITOOR(dimtab[pstk->in_s]));
pftn.c:			if ( ISPTR( DECREF(pstk[-1].in_t) ) )
pftn.c:			idname = (pstk-1)->in_id;
pftn.c:			base->tn.type = (pstk-1)->in_t;	/* for multidimensional arrays*/
pftn.c:		idname = pstk->in_id;
pftn.c:		t = pstk->in_t;
pftn.c:		d = pstk->in_d;
pftn.c:		s = pstk->in_s;
pftn.c:	t = pstk->in_t;  /* type required */
pftn.c:	tq = pstk->in_tq;
pftn.c:	d = pstk->in_d;
pftn.c:	s = pstk->in_s;
pftn.c:	p->in.left->in.op = FREE;
pftn.c:	p->in.left = p->in.right;
pftn.c:	p->in.right = NIL;
pftn.c:	p->in.left = optim( p->in.left );
pftn.c:	if( p->in.left->in.op == UNARY AND )
pftn.c:		p->in.left->in.op = FREE;
pftn.c:		p->in.left = p->in.left->in.left;
pftn.c:	if( p->in.left->in.op == CONV)
pftn.c:			q = p->in.left;
pftn.c:			l = q->in.left;
pftn.c:			if( ISPTR( l->tn.type ) )
pftn.c:					l->tn.type = q->tn.type;
pftn.c:					l->fn.csiz = q->fn.csiz;
pftn.c:					l->fn.cdim = q->fn.cdim;
pftn.c:					q->tn.op = FREE;
pftn.c:					p->in.left = l;
pftn.c:	p->in.op = INIT;
pftn.c:	if( pstk->in_sz < 0 )
pftn.c:		sz = -pstk->in_sz;
pftn.c: 	inforce( pstk->in_off );
pftn.c:	if( p->in.left->in.op == FCON )
pftn.c:		fincode( p->in.left->fpn.dval, sz );
pftn.c:		if( p->in.left->in.op != ICON )
pftn.c:			incode( p->in.left, sz );
pftn.c:		if( pstk->in_fl ) ++ibseen;
pftn.c:		--pstk;
pftn.c:		--cur_level;       /* roger: keep track of nesting brackets */
pftn.c:		t = pstk->in_t;
pftn.c:			ix = ++pstk->in_x;
pftn.c:			instk( id, p->stype, p->stypeq? p->stypeq: pstk->in_tq, 
pftn.c:					p->dimoff, p->sizoff, p->offset+pstk->in_off );
pftn.c:			n = ++pstk->in_n;
pftn.c:			if( n >= dimtab[pstk->in_d] &&  pstk > instack ) continue;
pftn.c:			temp = pstk->in_sz;
pftn.c:			temp2 = (TWORD)DECQUAL(pstk->in_tq)?(TWORD)DECQUAL(pstk->in_tq):pstk->in_tq;
pftn.c:			instk( pstk->in_id, (TWORD)DECREF(pstk->in_t), 
pftn.c:							    temp2,pstk->in_d+1, pstk->in_s,
pftn.c:								pstk->in_off+n*temp );
pftn.c:               incr = -1;
pftn.c:		t = pstk->in_t;
pftn.c:		if( pstk->in_fl )
pftn.c:				if( pstk->in_n ) uerror( "illegal {" );
pftn.c:                 pstk->in_fl = 1;
pftn.c:		if ( pstk->in_off == (pstk+1)->in_off)
pftn.c:		 pstk->in_fl = 1;
pftn.c:		--ibseen;
pftn.c:	for( ; pstk >= instack; --pstk, --cur_level )	/*bk: changed from pstk > instack */
pftn.c:		if( !pstk->in_fl ) continue;
pftn.c:		pstk->in_fl = 0;  /* cancel { */
pftn.c:	if( (maxoffset-off) < size )
pftn.c:		/* Special m68k structure alignment - function arguments
pftn.c:		al = salign( p->stype, p->sizoff );
pftn.c:	al = talign( p->stype, p->sizoff );
pftn.c:	tsz = tsize( p->stype, p->dimoff, p->sizoff );
pftn.c:	if( p->sclass == AUTO )
pftn.c:		if( (maxoffset-off) < tsz ) cerror("too many local variables");
pftn.c:		off = -noff;
pftn.c:		if( p->sclass == PARAM )
pftn.c:			if( (maxoffset-off) < tsz ) cerror("too many local variables");
pftn.c:				off = -noff;
pftn.c:				off = -noff;
pftn.c:			if( p->sclass == PARAM && ( tsz < SZINT ) )
pftn.c:				off = noff - tsz;
pftn.c:	if( p->sclass != REGISTER )
pftn.c:		if( p->offset == NOOFFSET ) p->offset = off;
pftn.c:			else if( off != p->offset ) return(1);
pftn.c:	/* new is 0 if new entry, 1 if redefinition, -1 if alignment */
pftn.c:	type = (new<0)? pty->in.type : p->stype;
pftn.c:	switch( new<0?pty->in.type:p->stype )
pftn.c:			s = new<0 ? pty->fn.csiz : p->sizoff;
pftn.c:			al = fldal( p->stype );
pftn.c:		if( (maxoffset-strucoff) < w )
pftn.c:		if( p->offset != strucoff || p->sclass != (FIELD|w) ) return(1);
pftn.c:	p->offset = strucoff;
pftn.c:	if( (maxoffset-strucoff) < w ) cerror("structure too large");
pftn.c:	p->stype = type;
pftn.c:	ftn_arg = 1;						/* take care of float->double */
pftn.c:				if ( (prevclass = stab[p->tn.rval].sclass) != EXTDEF &&
pftn.c:		beginit( p->tn.rval );
pftn.c:		if ( ! ISFTN( stab[p->tn.rval].stype ) )		/*bk*/
pftn.c:			commdec( p->tn.rval );
pftn.c:	if( unsg == UNSIGNED ) return( noun + (UNSIGNED-INT) );
pftn.c:		qval = newtq <<  ( BTSHIFT + ((tqshift-1) * TSHIFT) );
pftn.c:	if (( type_def ) && ( ISDT(tdtype = type_def->in.type) ))
pftn.c:	if( typ->in.op != TYPE && 
pftn.c:		typ->in.op != ARGTYPE) 		/* bk */
pftn.c:	idp->in.type = typ->in.type;
pftn.c:	idp->in.proto = typ->in.proto;		/*bk*/
pftn.c:	idp->in.typeq = typ->in.typeq;		/*roger*/
pftn.c:	idp->fn.cdim = curdim;
pftn.c:	idp->fn.csiz = typ->fn.csiz;
pftn.c:	for( t=typ->in.type, i=typ->fn.cdim; t&TMASK; t = DECREF(t) )
pftn.c:/*	idp->in.type = ctype( idp->in.type ); */
pftn.c:	if( (t = BTYPE(idp->in.type)) != STRTY && t != UNIONTY && t != ENUMTY )
pftn.c:		idp->fn.csiz = t;  /* in case ctype has rewritten things */
pftn.c:	o = p->in.op;
pftn.c:	p->in.op = FREE;
pftn.c:	t = INCREF( p->in.type );
pftn.c:	if( o == UNARY CALL ) t += (FTN-PTR);
pftn.c:		t += (ARY-PTR);
pftn.c:		temp = p->in.right->tn.lval;
pftn.c:		p->in.right->in.op = FREE;
pftn.c:	p->in.left->in.type = t;
pftn.c:	tyreduce( p->in.left );
pftn.c:	p->tn.rval = p->in.left->tn.rval;
pftn.c:	p->in.type = p->in.left->in.type;
pftn.c:	if( (type = p->in.type) == UNDEF ) return;
pftn.c:			++p->fn.cdim;
pftn.c:			type += (PTR-ARY);
pftn.c:	p->in.type = type;
pftn.c:				case -1:			/* type incompatible for reg */
pftn.c:	while( sp->stype != TNULL )
pftn.c:	sp->sflags = SNONUNIQ | SMOS;
pftn.c:	sp->sname = stab[*idindex].sname; /* old entry name */
pftn.c:		sp->sname, *idindex, i );
pftn.c:	labels = sp->labels;
pftn.c:		if( sp->stype == TNULL )
pftn.c:			sp->sflags = s;
pftn.c:			sp->sname = name;
pftn.c:			sp->stype = UNDEF;
pftn.c:			sp->sclass = SNULL;
pftn.c:		if( ( sp->sflags & ( SLAB | STAG | SMOS | SHIDDEN ) ) != s )
pftn.c:		if ( sp->sname == name )
pftn.c:		if (	( sp->sflags & SLAB )
pftn.c:			( ii == ((unsigned long) sp->sname) % SYMTSZ )
pftn.c:			if ( ( --labels == 0 ) && empty )
pftn.c:		if( p->stype == TNULL ) continue;
pftn.c:		j = lookup( p->sname, p->sflags&(SMOS|STAG|SLAB) );
pftn.c:			if( q->stype == UNDEF ||
pftn.c:			    q->slevel <= p->slevel )
pftn.c:				cerror( "check error: %s", q->sname );
pftn.c:		else if( p->slevel > lev ) cerror( "%s check at level %d", p->sname, lev );
pftn.c:	q = &stab[lookup( p->sname, p->sflags&(SLAB|STAG|SMOS|SHIDDEN) )];
pftn.c:	if( q->stype == UNDEF )
pftn.c:		q->stype = TNULL;
pftn.c:		if( q->stype == TNULL ) break;
pftn.c:		p = p->scopelink;
pftn.c:			    p->sname,p-stab,p->sflags,p->slevel);
pftn.c:                if( p->sclass == ULABEL && lev <= 2 )
pftn.c:                        uerror("%s undefined label",p->sname); /*bk#8*/
pftn.c:		if ( p->sclass == LABEL )
pftn.c:					((unsigned long) p->sname) % SYMTSZ;
pftn.c:					p->sname
pftn.c:			stab[ ((unsigned long) p->sname) % SYMTSZ ].labels--;
pftn.c:		if( p->sflags & SHIDES )
pftn.c:		p->stype = TNULL;
pftn.c:		p->stypeq = 0;	/*bk: temporary, someone's setting this by mistake */
pftn.c:		p = p->scopelink;
pftn.c:	p->stype = q->stype;
pftn.c:	p->sclass = q->sclass;
pftn.c:	p->slevel = q->slevel;
pftn.c:	p->offset = q->offset;
pftn.c:	p->sflags = q->sflags;
pftn.c:	p->dimoff = q->dimoff;
pftn.c:	p->sizoff = q->sizoff;
pftn.c:	p->sproto = q->sproto;
pftn.c:	p->suse = q->suse;
pftn.c:	p->sname = q->sname;
pftn.c:	p->stypeq = q->stypeq;
pftn.c:		if( q->stype == TNULL ) break;
pftn.c:	p->sflags |= SHIDDEN;
pftn.c:	q->sflags = (p->sflags&(SMOS|STAG|SLAB)) | SHIDES;
pftn.c:	werror( W_LINT, "%s hides earlier namesake", p->sname );
pftn.c:	if( ddebug ) printf( "	%d hidden by %d\n", p-stab, q-stab );
pftn.c:	return( idname = q-stab );
pftn.c:		if( q->stype == TNULL ) break;
pftn.c:	werror( W_LINT, "%s hides earlier namesake", p->sname );
pftn.c:	if( ddebug ) printf( "	%d hidden (mkspace) in %d\n", p-stab, q-stab );
pftn.c:	return( idname = q-stab );
pftn.c:	s = p->sflags & (SMOS|STAG);
pftn.c:		if( q == stab ) q = &stab[SYMTSZ-1];
pftn.c:		else --q;
pftn.c:		if( (q->sflags&(SMOS|STAG)) == s )
pftn.c:			if ( p->sname == q->sname )
pftn.c:				q->sflags &= ~SHIDDEN;
pftn.c:				if( ddebug ) printf( "unhide uncovered %d from %d\n", q-stab,p-stab);
pftn.c:		p = p->scopelink;
pftn.c: * organization corresponding to the type's type-category (this can
pftn.c:	for ( i=(MAXDT-1)*2; i>=0; i-=2 ) {
proto.c:#define NUM_PTYPES (PLIST_SZ * 2)	/* pre-allocated prototype entries */
proto.c:#define PROTO_NOID	-1				/* prototype with no (comment) id */
proto.c:			/* special conversion note: for now, we convert float->double */
proto.c:			/* unpromoted by un-defining ARGCONV. */
proto.c:int ftn_arg;						/* for float->double farg promotion */
proto.c:			ptype->pprev = ptype; 	/* remember head of list */
proto.c:		pctrl.ctail->pnext = ptype;
proto.c:		ptype->pprev = pctrl.ctail;
proto.c:			/* ftn-type argument, but before it knows if that ftn arg */
proto.c:			/* has an (optional) parameter-type list.  This creates   */
proto.c:	pctrl = proto_stack[--pstk_indx];
proto.c:									/* distinguish non-prototyped functions */
proto.c:	plist->lhead = pctrl.chead;			/* head of list */
proto.c:	plist->lflag = pctrl.cflag;
proto.c:	for ( plist->lcnt = 0, ptype = plist->lhead; ptype; ptype = ptype->pnext )
proto.c:		++plist->lcnt;
proto.c:				/* ProtoEnd:	Conclude a parm-type-list         */
proto.c:				/* ProtoLink:	Link parm-type-list to function id*/
proto.c: * type; if so, the node's "proto" field will be non-zero (thanks
proto.c:int optid;			/* equals -1 (PROTO_NOID) if no ftn arg identifier */
proto.c:	if (is_ftn(DECREF(pn->in.type))) { /* "int foo(int (*x)(args))" */
proto.c:		switch ( pn->in.proto ) {
proto.c:			case -1:		/* yylex flag for typedef'd ftn w/out prototype */
proto.c:				if ( pn->in.proto > 0 )			/* paranoia safety check */
proto.c:					oldplist = pn->in.proto;
proto.c:		if ( pn->fn.type == VOID ) {
proto.c:			/* roger: Ansi 3.5.4.3. lines 19-22: and the type of each prototype parameter shall be compatible with the type that results from the application of the default argument promotions to the type of the corresponding identifier */
proto.c:			if ( pn->fn.type == FLOAT )
proto.c:			ptype->ptype = pn->fn.type;
proto.c:			ptype->pdim = pn->fn.cdim;
proto.c:			ptype->psiz = pn->fn.csiz;
proto.c:			ptype->psym = optid;
proto.c:			ptype->pqual = typequal;	/* needed by dclargs, not prototyping */
proto.c:				ptype->pclass = REGISTER;
proto.c:				ptype->pclass = PARAM;
proto.c:			ptype->pnest = oldplist;
proto.c:	if (pctrl.ctail) {				/* non-empty parameter type list? */
proto.c:	optname = wrk->tn.rval;		/* get NAME node's rval */
proto.c:	if ( ptrflag && HASPROTO(sptr->sproto) )	/* int (*foo(int))(int) */
proto.c:		lindx = sptr->sproto;
proto.c:		if ( HASPROTO(sptr->sproto) ) {		/* already prototyped */
proto.c:			sptr->sproto = ProtoCmp( sptr->sproto, lindx,0); /*"merge"*/
proto.c:			plist = &proto_lists[sptr->sproto];
proto.c:			/* plist->lhead = PNULL;			/ free extra list */
proto.c:			sptr->sproto = lindx;		/* link ftn symbol with proto list */
proto.c:		plist->lsymidx = optname;		/* link proto list to ftn symbol */
proto.c:									/* -> empty list, just points to plist */
proto.c:									/* of pointed-to function */
proto.c:		sptr->sproto = lindx;
proto.c:		plist->lsymidx = optname;
proto.c:		save = plist->lptr2ftn;
proto.c:		plist->lptr2ftn = ProtoHeadInit();
proto.c:			plist->lptr2ftn = ProtoCmp( save, plist->lptr2ftn,0); /*"merge"*/
proto.c:	scope_proto_index = sptr->sproto;
proto.c:				(plist->lsymidx > 0) ? stab[plist->lsymidx].sname : "??" );
proto.c:	for (  ptype = plist->lhead; ptype != PNULL; ptype = ptype->pnext ) {
proto.c:		tprint(stderr,ptype->ptype);
proto.c:		fprintf(stderr," (%d,%d),",ptype->pdim,ptype->psiz);
proto.c:		if (ptype->pnest) {						/* nested ftn prototype */
proto.c:			fprintf( stderr," ->[" );
proto.c:			ProtoDump( &proto_lists[ptype->pnest], 1 );
proto.c:			fprintf( stderr,"]<- " );
proto.c:	if ( plist->lflag & PVOID )
proto.c:	if ( plist->lflag & PVARARGS )
proto.c:	if ( plist->lptr2ftn ) {				/* ftn points to another */
proto.c:		fprintf( stderr," ->*" );
proto.c:		ProtoDump( &proto_lists[plist->lptr2ftn], 1 );	/* show latter's plist*/
proto.c:		fprintf( stderr,"*<- " );
proto.c:	checkst(blevel);						/* id's inside prototype-scope */
proto.c:	ftnidx = stab[fn->tn.rval].sproto;		/* get indx into proto_lists */
proto.c:		for (  ;	ptype != PNULL;  ptype = ptype->pnext ) {
proto.c:			if ( ptype->psym != PROTO_NOID ) {	/* got optional identifier? */
proto.c:				sptr = &stab[ptype->psym];		/* got the symbol entry */
proto.c:				if( sptr->sflags & SHIDES )		/* did it hide another sym? */
proto.c:				sptr->stype = TNULL;			/* free up slot */
proto.c:											ptype->psym));
proto.c:	ftnidx = stab[fn->in.left->tn.rval].sproto;	/* get indx into proto_lists */
proto.c:	if ( plist->lflag & PDECLARE )	/* old-style ftn definition preceded */
proto.c:	if (plist->lflag & PVOID) 		/* function takes 0 parameters */
proto.c:	ptype = plist->lhead;			/* point at start of ftn's prototypes */
proto.c:	for (  ; ptype && ptype->ptype; ptype = ptype->pnext ) {
proto.c:		if (ptype->psym == PROTO_NOID)	{
proto.c:	wrk = ProtoId(fn->in.left);
proto.c:	ftnidx = wrk->in.proto;
proto.c:	arglist = fn->in.right;				/* arglist is right child of ftn node */
proto.c:						optype(wrk->tn.op) == LTYPE &&
proto.c:							wrk->tn.rval!=NONAME && wrk->tn.op!=REG ? 
proto.c:							stab[wrk->tn.rval].sname : "" );
proto.c:			if ( wrk->tn.op == NAME )
proto.c:				stab[wrk->tn.rval].sproto = WARNED;	/*prevent more warnings*/
proto.c:		if (plist->lflag & PVOID) {		/* function takes 0 parameters */
proto.c:		protocnt = plist->lcnt;			/* count of prototyped parameters */
proto.c:		unknowns -= protocnt;			/* varargs */
proto.c:			if ( (argcnt > protocnt) && !(plist->lflag & PVARARGS) ) {
proto.c:									/* any un-prototyped parms. */
proto.c:									/* ftn_arg takes care of float->double, */
proto.c:	for (  ;  unknowns;  --unknowns, arglist = arglist->in.left ) {
proto.c:/*		if ( optype(arglist->in.op) == BITYPE ) { *  augh!!! **/
proto.c:		if ( arglist->in.op == CM ) {
proto.c:			arglist->in.right = pconvert( arglist->in.right, 0 );
proto.c:			if ( arglist == fn->in.right ) {		/* just one arg, period */
proto.c:				fn->in.right = pconvert( arglist, 0 );
proto.c:				prev->in.left = pconvert( arglist, 0 );
proto.c:	ftn_arg = 0;					/* back to float->float */
proto.c:		for ( ptype = plist->lhead, i = 0; i < protocnt-1; i++ )
proto.c:			ptype = ptype->pnext;		/* scan to end: arglist is RTOL */
proto.c:			--protocnt, ptype=ptype->pprev, arglist=arglist->in.left ) {
proto.c:		if ( arglist->in.op == CM ) {				/* arglist navigation */
proto.c:			parent = &arglist->in.right;
proto.c:			arg = arglist->in.right;
proto.c:			if ( arglist == fn->in.right ) {		/* just one arg, period */
proto.c:				parent = &fn->in.right;
proto.c:				parent = &prev->in.left;
proto.c:		if ( ISFTN(arg->tn.type) ) {
proto.c:			if ( ptype->pnest )
proto.c:				nestarg = arg->tn.rval;
proto.c:							/* Run through the full type-checking mechanism. */
proto.c:		proto_argno = protocnt;	/* help make buildtree errors user-friendly */
proto.c:					ARGCONV(ptype->ptype),ptype->pdim,ptype->psiz, 0);
proto.c:		*parent = chknode->in.right; 		/* in case CONV node inserted*/
proto.c:			chknode->tn.op = FREE;
proto.c:		} while ( chknode = chknode->in.left );
proto.c:				ProtoCmp( nestarg, ptype->pnest, PCALL );
proto.c:	for ( argcnt = 0;  arglist->in.op == CM; arglist = arglist->in.left )
proto.c:				/* Either: old guy has parm-list, new doesn't: make composite */
proto.c:	ptype1 = plist1->lhead;
proto.c:	ptype2 = plist2->lhead;
proto.c:	if (( plist1->lcnt != plist2->lcnt ) ||
proto.c:		( (plist1->lflag & PVARARGS) != (plist2->lflag & PVARARGS) )) {
proto.c:				plist1->lsymidx ? stab[plist1->lsymidx].sname : "??" );
proto.c:		pcnt = MIN( plist1->lcnt,plist2->lcnt );
proto.c:		pcnt = plist1->lcnt;
proto.c:									/* now check parameter-by-parameter */
proto.c:	for (  ;  pcnt;  --pcnt, ptype1=ptype1->pnext, ptype2=ptype2->pnext ) {
proto.c:		if (( ptype1->ptype != ptype2->ptype ) ||
proto.c:			( dimtab[ptype1->psiz] != dimtab[ptype2->psiz] ) ||
proto.c:		if (ptype1->pnest)  			/* nested ftn parm prototype */
proto.c:				ptype2->pnest = ProtoCmp( ptype1->pnest, ptype2->pnest, 1 );
proto.c:					/* We thus use 2nd parm-list if 1st lacks any; this may */
proto.c:	if ( plist1->lptr2ftn && plist2->lptr2ftn == 0 )
proto.c:		plist2->lptr2ftn = plist1->lptr2ftn;	/* int (*foo(int))(char) */
proto.c:	ty = ptype1->ptype;			/* by now, we know that both have same type */
proto.c:	for( i=0; i<=(SZINT-BTSHIFT-1); i+=TSHIFT )
proto.c:	dim1 = ptype1->pdim;
proto.c:	dim2 = ptype2->pdim;
proto.c:				ptype1->pdim = ptype2->pdim; /* make composite array type */
proto.c:				ptype2->pdim = ptype1->pdim; /* make composite array type */
proto.c:	if ( ftndef->sclass == STATIC )		/* alert user if static function */
proto.c:											ftndef->sname );
proto.c:	fprintf( out, "%s ", lscnames(ftndef->sclass) );
proto.c:	fprintf( out, " %s _PARMS((", ftndef->sname );
proto.c:	if ( (HASPROTO(ftndef->sproto) && 		/* new-style with ellipsis? */
proto.c:			(proto_lists[ ftndef->sproto ].lflag & PVARARGS))
proto.c:			if ( i < argno-1 ) {
proto.c:	ty = sym->stype;
proto.c:	tq = sym->stypeq;
proto.c:		ftn_arg--;
proto.c:	dim = sym->dimoff;
proto.c:	for ( i = 0; i <= (SZINT-BTSHIFT-1); i+=TSHIFT ) {
proto.c:					--dim;
proto.c:	if ( sym->stypeq & CONST )		
proto.c:	if ( sym->stypeq & VOLATILE )
proto.c:		int tag = dimtab[ sym->sizoff+3 ];		/* symidx of structure tag */
proto.c:		if ( tag == -1 ) {						/* unnamed template */
proto.c:	while ( --sx >= 0 ) {					/* then derived types */
proto.c:				if ( --sx >= 0 ) {
proto.c:		if ( p->sizoff == sym->sizoff && p!=sym ) {
proto.c:			if ( p->sclass == TYPEDEF ) {
proto.c:				if (BTYPE(p->stype) != STRTY && 		/* sanity checks */
proto.c:					BTYPE(p->stype) != UNIONTY &&
proto.c:					BTYPE(p->stype) != ENUMTY)
proto.c:				return p->sname;						/* FOUND IT!! */
proto.c:	ptx = stab[ fdcl->tn.rval ].sproto;
proto.c:	bad = plist->lflag & PVARARGS;
proto.c:		ptype = plist->lhead;  
proto.c:		pcnt = plist->lcnt; 
proto.c:		for (  ; pcnt;  --pcnt, ptype = ptype->pnext )
proto.c:			if ( indtype( ptype->ptype ) != ptype->ptype ) {
proto.c:	while ( optype(dtree->in.op) != LTYPE ) {
proto.c:		if ( !indcl  && callop(dtree->in.op) )
proto.c:		dtree = dtree->in.left;
proto.c:	switch ( dtree->in.op ) {	/* validity check */
proto.c:/* We have just recognized a cast-expression:             *
proto.c: * cast-expression vs. parameter-declaration              */
proto.c:		if (temp->psym > 0)
proto.c:			optional_name = &stab[temp->psym];
proto.c:			optional_name->scopelink = scopestack[blevel+1];
proto.c:		temp = temp->pnext;
reader.c:/* earlier attempts to keep these on a per-block basis were silly */
reader.c:	q->tn.op = ASSIGN;
reader.c:	q->in.right = p;
reader.c:	q->in.left = r;
reader.c:	r->tn.op = QNODE;
reader.c:	r->tn.rval = callreg(p); /* the reg where the value will be forced */
reader.c:		++asmdebug;   /* debug in-line expansion */
reader.c:		if( *(cp=argv[c]) == '-' )
reader.c:					--cp;
reader.c:				case 'A':	/* Arix-specific boolean flags */
reader.c:				case 'u':  /* Sethi-Ullman testing
reader.c:	q->tn.type = p->tn.type;
reader.c:	q->in.left = p;
reader.c:	q->tn.op = GENLAB;
reader.c:	q->bn.label = l;
reader.c:	q->bn.lop = o;
reader.c:	q->tn.op = o?GENBR:GENUBR;
reader.c:	q->in.left = p;
reader.c:	q->bn.label = l;
reader.c:	if( o && logop(pop=p->tn.op)
reader.c:		p->in.op = CMP;
reader.c:		p->in.type = p->in.left->in.type;
reader.c:	q->tn.type = p->tn.type;
reader.c:	if (tcond(p->in.left))  {
reader.c:		tfree(p->in.right);
reader.c:		p->in.op = FREE;
reader.c:		p = condit( p->in.left, CEFF, -1, -1);
reader.c:	} else if (fcond(p->in.left))  {
reader.c:		p->in.op = COMOP;
reader.c:		p = condit( p, CEFF, -1, -1);
reader.c:		p->in.op = FREE;
reader.c:		r = condit( p->in.right, CEFF, -1, -1);
reader.c:		    l = condit( p->in.left, CCC, lab, -1);
reader.c:		    l = condit( p->in.left, CEFF, -1, -1);
reader.c:	if (fcond(p->in.left))  {
reader.c:		tfree(p->in.right);
reader.c:		p->in.op = FREE;
reader.c:		p = condit( p->in.left, CEFF, -1, -1);
reader.c:	} else if (tcond(p->in.left))  {
reader.c:		p->in.op = COMOP;
reader.c:		p = condit( p, CEFF, -1, -1);
reader.c:		p->in.op = FREE;
reader.c:		r = condit( p->in.right, CEFF, -1, -1);
reader.c:		    l = condit( p->in.left, CCC, -1, lab);
reader.c:		    l = condit( p->in.left, CEFF, -1, -1);
reader.c:	register o = p->tn.op;
reader.c:		return( p->tn.lval || p->tn.name != (char *) 0 );
reader.c:		return( tcond( p->in.right ) );
reader.c:		return( tcond( p->in.left ) || tcond( p->in.right ) );
reader.c:		return( tcond( p->in.left ) && tcond( p->in.right ) );
reader.c:		return( fcond( p->in.left ) );
reader.c:		q = p->in.right;
reader.c:		if( tcond( p->in.left ) ) return( tcond( q->in.left ) );
reader.c:		if( fcond( p->in.left ) ) return( tcond( q->in.right ) );
reader.c:		return( tcond( q->in.left ) && tcond( q->in.right ) );
reader.c:		if( p->in.right->in.op == ICON &&
reader.c:		    p->in.right->tn.lval == 0  &&
reader.c:		    p->in.right->in.name == (char *) 0 ) return( 1 );
reader.c:	register o = p->tn.op;
reader.c:		return( !p->tn.lval && p->tn.name == (char *) 0 );
reader.c:		return( fcond( p->in.right ) );
reader.c:		return( fcond( p->in.left ) || fcond( p->in.right ) );
reader.c:		return( fcond( p->in.left ) && fcond( p->in.right ) );
reader.c:		return( tcond( p->in.left ) );
reader.c:		q = p->in.right;
reader.c:		if( tcond( p->in.left ) ) return( fcond( q->in.left ) );
reader.c:		if( fcond( p->in.left ) ) return( fcond( q->in.right ) );
reader.c:		return( fcond( q->in.left ) && fcond( q->in.right ) );
reader.c:		if( p->in.right->in.op == ICON &&
reader.c:		    p->in.right->tn.lval == 0  &&
reader.c:		    p->in.right->in.name == (char *) 0 ) return( 1 );
reader.c:	if( p->tn.op != COMOP ) cerror( "rcomma" );
reader.c:	if( p->in.left && p->in.right ) return( p );
reader.c:	p->tn.op = FREE;
reader.c:	if( !p->in.left ) return( p->in.right );
reader.c:	return( p->in.left );
reader.c:	q->in.op = COMOP;
reader.c:	q->in.type = p2->in.right->in.type;
reader.c:	q->in.left = p1;
reader.c:	q->in.right = p2;
reader.c:	/* if l is -1, return NULL */
reader.c:	q = condit( p, CEFF, -1, -1 );
reader.c:	/* -1 only value indicating no label */
reader.c:	if( l==-1 ) return( q );
reader.c:		q->tn.op = ICON;
reader.c:		q->tn.lval = 0;
reader.c:		q->tn.name = (char *) 0;
reader.c:		q->tn.type = TINT;
reader.c:	o = p->tn.op;
reader.c:		printf( "condit( %d (%s), %s, %d, %d )\n", (int)(p-node),
reader.c:		p->in.right->tn.op = p->tn.op = FREE;
reader.c:		l = p->in.right->tn.lval;
reader.c:		p = p->in.left;
reader.c:		if( tcond( p ) ) return( gtb(p,-1) );
reader.c:		return( condit( p, CCC, -1, l ) );
reader.c:		if( p->in.left->tn.op == ICON && p->in.left->tn.lval == 1)
reader.c:		    printf("L%%%d:\n", p->tn.rval);
reader.c:		if( p->in.left->tn.op == ICON && p->in.left->tn.lval == 1)
reader.c:		    printf("\tbra\tL%%%d\n", p->tn.rval);
reader.c:		if( optype(o) == UTYPE ) p->stn.argsize = 0;
reader.c:		else p->stn.argsize = argsize(p->in.right);
reader.c:			q1->tn.op = ICON;
reader.c:			q1->tn.name = (char *) 0;
reader.c:			q1->tn.lval = 1;
reader.c:			q1->tn.type = p->tn.type;
reader.c:			q2->tn.lval = 0;
reader.c:			q->tn.op = COLON;
reader.c:			q->tn.type = p->tn.type;
reader.c:			q->in.left = q1;
reader.c:			q->in.right = q2;
reader.c:			q1->tn.op = o = QUEST;
reader.c:			q1->tn.type = p->tn.type;
reader.c:			q1->in.left = p;
reader.c:			q1->in.right = q;
reader.c:			p->tn.op = COMOP;
reader.c:			q = p->in.right;
reader.c:			q1 = condit( q->in.left, goal, -1, -1 );
reader.c:			q->in.right = condit( q->in.right, goal, -1, -1 );
reader.c:			if( tcond( p->in.left ) ) 
reader.c:				q->tn.op = FREE;
reader.c:				tfree( q->in.right );
reader.c:				p->in.right = q1;
reader.c:				p->in.left=condit( p->in.left, CEFF, -1, -1 );
reader.c:			if( fcond( p->in.left ) ) 
reader.c:				q->tn.op = FREE;
reader.c:				p->in.right = q->in.right;
reader.c:				p->in.left=condit( p->in.left, CEFF, -1, -1 );
reader.c:				if( !q->in.right ) 
reader.c: 					q1 = condit(p->in.left, goal,
reader.c:						-1, -1);
reader.c: 						tfree( p->in.left );
reader.c:					p->tn.op = q->tn.op = FREE;
reader.c:				p->in.left = condit( p->in.left, CCC, l, -1 );
reader.c:				p->in.right = dlabel( q->in.right, l );
reader.c:				q->tn.op = FREE;
reader.c:			else if( !q->in.right ) 
reader.c:				p->in.left=condit( p->in.left, CCC, -1, lf );
reader.c:				p->in.right = dlabel( q1, lf );
reader.c:				q->tn.op = FREE;
reader.c:			p->in.left = condit( p->in.left, CCC, -1, lf );
reader.c:			    q->in.right = force(q->in.right);
reader.c:			q->in.left = dlabel( q1, lf );
reader.c:			q->tn.op = COMOP;
reader.c:				p->tn.op = FREE;
reader.c:			p->in.right = condit( p->in.right, goal, -1, -1 );
reader.c:			p->in.left = condit( p->in.left, o==COMOP?CEFF:goal,
reader.c:			-1, -1 );
reader.c:				p->tn.op = COMOP;
reader.c:				p->tn.op = FREE;
reader.c:				return( p->in.left );
reader.c:				p->tn.op = FREE;
reader.c:		if(t == -1)
reader.c:			o = p->tn.op = negrel[o-EQ];
reader.c:			f = -1;
reader.c:		if( p->in.right->in.op == ICON &&
reader.c:		    p->in.right->tn.lval == 0 &&
reader.c:		    p->in.right->in.name == (char *) 0 ) 
reader.c:			    ( p->in.left->tn.type == TCHAR ||
reader.c:			      ( p->in.left->in.op == CONV && 
reader.c:			        p->in.left->in.left->tn.type == TCHAR ) )
reader.c:				o += UGT - GT;
reader.c:				o = p->in.op = (o==UGT)?NE:EQ;
reader.c:				o = p->in.op = (o==GE)?PL:MI;
reader.c:				if (       p->in.left->tn.op == AND
reader.c:					&& p->in.left->in.right->tn.op == ICON
reader.c:					&& p->in.left->in.right->tn.name == 0
reader.c:					&& (con=p->in.left->in.right->tn.lval)
reader.c:					&& (con & (con-1)) == 0
reader.c:						o = p->in.op = EQ;	
reader.c:dorel:          if(    logop( p->in.left->tn.op )
reader.c:					|| p->in.left->in.op == QUEST )
reader.c:			p->tn.op = p->in.right->tn.op = FREE;
reader.c:			p = condit( p->in.left, NRGS, -1, -1 );
reader.c:			if( f == -1 ) return( p );
reader.c:		p->in.left = condit( p->in.left, NRGS, -1, -1 );
reader.c:		p->in.right = condit( p->in.right, NRGS, -1, -1 );
reader.c:		if( f != -1 )
reader.c:		p->in.left = condit( p->in.left, CEFF, -1, -1 );
reader.c:		p->in.right = condit( p->in.right, CCC, t, f );
reader.c:		p->tn.op = FREE;
reader.c:		return( condit( p->in.left, CCC, f, t ) );
reader.c:		lf = f == -1 ? getlab() : f;
reader.c:		p->tn.op = COMOP;
reader.c:		if( tcond( p->in.left ) )
reader.c:			p->in.left = condit( p->in.left, CEFF, -1, -1 );
reader.c:			p->in.right = condit( p->in.right, CCC, t, f );
reader.c:			if( tcond( p->in.right ) )
reader.c:				p->in.right =
reader.c:				   condit( p->in.right, CEFF, -1, -1 );
reader.c:				if (p->in.right)  {
reader.c:				    p->in.left = 
reader.c:					condit( p->in.left, CCC, -1,lf);
reader.c:				    p->in.right = condit( p->in.right,
reader.c:				    p->in.left =
reader.c:				     condit( p->in.left, CCC, t, f );
reader.c:				p->in.left =
reader.c:				     condit( p->in.left, CCC, -1, lf );
reader.c:				p->in.right =
reader.c:				   condit( p->in.right, CCC, t, f );
reader.c:		    if( f== -1 ) q = dlabel( q, lf );
reader.c:		lt = t== -1 ? getlab() : t;
reader.c:		p->tn.op = COMOP;
reader.c:		if( fcond( p->in.left ) )
reader.c:			p->in.left = condit( p->in.left, CEFF, -1, -1 );
reader.c:			p->in.right = condit( p->in.right, CCC, t, f );
reader.c:			if( fcond( p->in.right ) )
reader.c:				p->in.right =
reader.c:				   condit( p->in.right, CEFF, -1, -1 );
reader.c:				if (p->in.right) { /* right side has side effect */
reader.c:				    p->in.left = 
reader.c:					condit( p->in.left, CCC, lt,-1);
reader.c:				    if (f != -1)         /* if fall-thru, no branch */
reader.c:					p->in.right = genbr( 0, f, p->in.right );
reader.c:				    p->in.left =
reader.c:				        condit( p->in.left, CCC, t, f );
reader.c:				p->in.left =
reader.c:				     condit( p->in.left, CCC, lt, -1 );
reader.c:				p->in.right =
reader.c:				   condit( p->in.right, CCC, t, f );
reader.c:		    if( t==-1 ) p = dlabel( p, lt );
reader.c:		lf = f == -1 ? getlab() : f;
reader.c:		lt = t == -1 ? getlab() : t;
reader.c:		p->in.left = condit( p->in.left, CCC, -1, l=getlab() );
reader.c:		q = p->in.right;
reader.c:		q1 = condit( q->in.left, goal, lt, lf );
reader.c:		q->in.left = dlabel( q1, l );
reader.c:		q->in.right = condit( q->in.right, goal, t, f );
reader.c:		p->tn.op = COMOP;
reader.c:		q->tn.op = COMOP;
reader.c:		if( t == -1 ) p = dlabel( p, lt );
reader.c:		if( f == -1 ) p = dlabel( p, lf );
reader.c:			p->in.right = condit( p->in.right, NRGS, -1, -1 );
reader.c:			p->in.left = condit( p->in.left, NRGS, -1, -1 );
reader.c:		if( t != -1 ) p = genbr( NE, t, p );
reader.c:		if( f != -1 ) p = genbr( (t!=-1)?0:EQ, f, p );
reader.c:			if( *(argv[files]) != '-' ) switch( ++fdef )
reader.c:				for ( ; isalpha(c) && i < sizeof(cstring)-1; c = getchar())
reader.c:		p = condit( p, CEFF, -1, -1 );
reader.c:	p = condit( p, CEFF, -1, -1 );
reader.c:	static int myftn = -1;
reader.c:	p->in.op = i;
reader.c: 	if( p->in.op == GENBR )
reader.c: 		p->bn.label = rdin( 10 );
reader.c: 		p->bn.lop = rdin( 10 );
reader.c: 		if( i == LTYPE ) p->tn.lval = rdin( 10 );
reader.c:		if( i != BITYPE ) p->tn.rval = rdin( 10 );
reader.c:	if (p->in.op == SWCASE)
reader.c:		p->in.type = rdin(8); /* KLUGE type is not really a type */
reader.c:	p->in.type = rdin(8);
reader.c:	p->in.type = ttype( rdin(8 ) );
reader.c:	switch( p->in.op)
reader.c:		p->in.typeq = rdin(8);
reader.c:		p->stn.stsize = rdin( 10 );
reader.c:		p->stn.stalign = rdin(10);
reader.c:		((FLTDBL *)&p->fp.dval)->lg.l = rdin(10);
reader.c:		if( p->fp.type == DOUBLE )
reader.c:		if( p->fp.type == TDOUBLE )
reader.c:			((FLTDBL *)&p->fp.dval)->lg.l2 = rdin(10);
reader.c:		rbusy( p->tn.rval, p->in.type );  /* not usually, but sometimes justified */
reader.c:				if( j < sizeof(buff) - 1 ) 
reader.c:		strncpy(p->in.name, buff, NCHNAM);
reader.c:		if ( j==0 ) p->in.name = (char *)0;	/* no name */
reader.c:		      p->in.name = (char *)malloc( j+1 );
reader.c:		      strcpy( p->in.name, buff );
reader.c:	if( i != LTYPE ) p->in.left = eread();
reader.c:	if( i == BITYPE ) p->in.right = eread();
reader.c:		if( c == '-' ){
reader.c:			if( val != 0 ) cerror( "illegal -");
reader.c:			sign = -sign;
reader.c:				val += c-'0';
reader.c:				val -= c-'0';
reader.c:	/* print a nice-looking description of goal */
reader.c:		for( d=down; d>1; d -= 2 ) printf( "\t" );
reader.c:	ty = optype( p->tn.op );
reader.c:		e22print( p->in.right ,"R");
reader.c:		--down;
reader.c:		e22print( p->in.left, "L" );
reader.c:		--down;
reader.c:	for( d=down; d>1; d -= 2 ) printf( "\t" );
reader.c:	printf( "%s.%d) op= '%s'",s, (int)(p-node), opst[p->in.op] );
reader.c:	switch( p->in.op ) 
reader.c:		printf( " %s", rnames[p->tn.rval] );
reader.c:		printf( " args=%d", p->stn.argsize );
reader.c:		printf( " size=%d", p->stn.stsize );
reader.c:		printf( " align=%d", p->stn.stalign );
reader.c:		printf( " %d (%s)", p->bn.label, opst[p->bn.lop] );
reader.c:		printf( " args=%d", p->stn.argsize );
reader.c:		printf( " %d", p->bn.label );
reader.c:		printf( " offset=%d", p->tn.rval );
reader.c:	t2print( p->in.type );
reader.c:	for( i=0; i<NRGS; ++i ) cprt( p->in.cst[i], "," );
reader.c:	cprt( p->in.cst[NRGS], "; " );
reader.c:	cprt( p->in.cst[CEFF], "; " );
reader.c:	cprt( p->in.cst[CTEMP], "; " );
reader.c:	cprt( p->in.cst[CCC], "]" );
reader.c:	if( p->tn.goal == CEFF ) printf( " (EFF)\n" );
reader.c:	else if( p->tn.goal == CCC ) printf( " (CC)\n" );
reader.c:	else if (p->tn.goal == 0) printf(" NOGOAL\n");
reader.c:	else if( p->tn.goal != NRGS ) printf( "(BAD GOAL: %d)\n", p->tn.goal );
scan.c:	fixed scan.c to recognize 8-bit characters.
scan.c:/* character-set translation */
scan.c:int protoflg;	/* if -XG, generate prototypes for old-style ftn definitions */
scan.c:static int wideflg;	/*bk: flags presence of wide-character prefix */
scan.c:# define A_MI 10		/* - */
scan.c:/* If FLEXNAMES defined, let -T determine whether symbols are truncated.
scan.c:0;		/* truncate based on -T (non-zero to truncate */
scan.c:	int proflg;	/* global - referenced again in local.c - bfcode() */
scan.c:	maxoffset = 1 << (i-1);
scan.c:		++asmdebug;   /* debug in-line expansion */
scan.c:				** all else is long-aligned. */
scan.c:	/* check specifically for -g  or -O as first argument */
scan.c:	if( argc>1 && *(cp=argv[1])=='-')
scan.c:			--argc;
scan.c:			--argc;
scan.c:		if( *(cp=argv[i]) == '-' )	/* beg hoss#1 */
scan.c:					case 'A':	/* Arix-specific boolean flags */
scan.c:				cerror("bad option: -%c", *cp);
scan.c:#define	ungetc(c, ioptr)	*--linecp=(c)
scan.c:		printf( "%s -- line %d %s\n", COMMENTSTR, lineno, ftitle );
scan.c:		if( cp < &yytext[LXTSZ-1] )
scan.c:	'-',	A_MI,	MINUS,	MINUS,
scan.c:	-1,	A_1C,	0,	0,
scan.c:		lxcp[p->lxch+1] = p;
scan.c:		if( p->lxch < 0 ) break;
scan.c:								val += *cp-'0';
scan.c:								val += *cp - 'A'+ 10;
scan.c:								val += *cp - 'a'+ 10;
scan.c:					val = c-'0';
scan.c:						val = (val<<3) | (c-'0');
scan.c:							val = (val<<3) | (c-'0');
scan.c:			bycode( -1, i );
scan.c:				i = yytext[7]?yytext[7]-'0':0;
scan.c:		switch( (p = lxcp[(lxchar = getchar())+1])->lxact )
scan.c:			if ((!indcl) && (p->lxtok == ASSIGN)) constid = 1;
scan.c:			yylval.intval = p->lxval;
scan.c:			return( p->lxtok );
scan.c:				switch ( lxcp[ (lxchar = getchar())+1]->lxact ) {
scan.c:					case A_STR:			/* wide-char string literal */
scan.c:					case A_CC:			/* wide-char character constant */
scan.c:			if(  sp->sclass == TYPEDEF && !seen_typespec)
scan.c:				yylval.nodep = mkty( sp->stype, sp->dimoff, 
scan.c:									sp->sizoff, sp->stypeq );
scan.c:						/* If typedef is for non-prototyped function, */
scan.c:						/* flag it - otherwise ProtoType() will get confused. */
scan.c:				yylval.nodep->in.proto = sp->sproto;
scan.c:				if ( ISFTN( sp->stype ) ) {
scan.c:												sp->sname, sp->sproto );
scan.c:					if (sp->sproto == 0)
scan.c:						yylval.nodep->in.proto = -1;
scan.c:						/* bk: also inherit typedef's type-qualifier info */
scan.c:				testqual = sp->stypeq;
scan.c:/*				if ( ISPTR(sp->stype) ) {		/ Plum Hall errtests/m35041 /
scan.c:					typequal |= sp->stypeq;
scan.c:								lastcon += *cp-'0';
scan.c:								lastcon += *cp - 'A'+ 10;
scan.c:								lastcon += *cp - 'a'+ 10;
scan.c:					    lxchar == '-' )
scan.c:				if ( *(yytext + strlen(yytext)-1) == '+' ) {
scan.c:						lastcon += *cp - '0';
scan.c:						lastcon = lastcon*10 + *cp - '0';
scan.c:					yyleng = cp - yytext;
scan.c:				if ( lastcon & ONEBIT(SZLONG-1) )
scan.c:				lastcon >>= 6*(6-i);
scan.c:					yylval.intval = UOP0 + yytext[1]-'0';
scan.c:			/* - */
scan.c:			if( (lxchar = getchar()) == '-' )
scan.c: *                                  ** haven't seen a type-specifier.   *
scan.c:		switch( (p = lxcp[(lxchar = getchar())+1])->lxact ) 
scan.c:				/* Fall-through */
scan.c:	/* otherwise, return -1 */
scan.c:	if( !islower(ch) && ch!='_' ) return( -1 );
scan.c:		return( -1 );
scan.c:	for( p= lxrdope+c; p->lxrch[0] == ch; ++p )
scan.c:		if( !strcmp( yytext, p->lxrch ) )
scan.c:			switch( p->lxract )
scan.c:					return( -1 );
scan.c:				yylval.intval = p->lxrval;
scan.c:				if ( p->lxrval == SIGNED && !mode_chk(MODE_ANSIKEYW) )
scan.c:					return( -1 );
scan.c:				if ( p->lxrval <= DOUBLE ) seen_typespec = 1;
scan.c:				yylval.nodep = mkty( (TWORD)p->lxrval, 0, p->lxrval, 0 );
scan.c:				if( p->lxrval==FLOAT || p->lxrval==DOUBLE )
scan.c:					yylval.nodep->tn.type = LONG;
scan.c:				return( yylval.intval = p->lxrval );
scan.c:				if ( p->lxrval == FORTRAN )
scan.c:						return( -1 );
scan.c:				yylval.intval = p->lxrval;
scan.c:					return( -1 );
scan.c:					if( asmp >= &asmbuf[ASMBUF-1] )
scan.c:	return( -1 );
scan.c:		/* "S-lists" feature:  Recognition of #ident <string> line.
scan.c:			val = val*10+ c - '0';
scan.c:			bg_file();	/* having seen filename, do start-of-file
scan.c:	saveleft -= len;
scan.c:	while ( *cp && ( ( cp - s ) < LNCHNAM ) )
scan.c:		if ( htp->ht_low == 0 )
scan.c:			htp->ht_low = hp;
scan.c:			htp->ht_high = hp + HASHINC;
scan.c:		h = htp->ht_low + sh;
scan.c:		* Use quadratic re-hash
scan.c:				if ( htp->ht_used > ( HASHINC * 3 ) / 4 )
scan.c:				htp->ht_used++;
scan.c:			else	/* insufficient warning level - use entire name length */
scan.c:			if ( h >= htp->ht_high )
scan.c:				h -= HASHINC;
scan.c:    static int done = 0;		/* non-zero if we've been here before */
scan.c:/* Pragmas beginning with capital letter are non-documented. */
scan.c:	"topdown",		1,		/* multi-dim array initialization parsed top-down */
scan.c:			/* non-documented pragmas must be last before show/reset */
scan.c:	"show",			-1,		/* show current state of pragma settings */
scan.c:	"reset",		-2,		/* reset to original settings */
scan.c:	"SYS",			-3,		/* for system headers */
scan.c:		for ( i = 0; isalpha(c) && i < sizeof(cstring)-1; c = getchar() )
scan.c:		for ( p = modes; p->lxmch; p++ ) {
scan.c:			if ( strcmp( p->lxmch, keyp ) == 0 ) {
scan.c:				switch ( p->lxmval ) {
scan.c:					case -1:				/* "show" current settings */
scan.c:						for ( s = modes; !isupper(s->lxmch[0]); ) {
scan.c:										s->lxmval > 0 ? "" : "no", s->lxmch );
scan.c:							if ( !isupper((++s)->lxmch[0]) ) {
scan.c:					case -2:						/* "reset" */
scan.c:					case -3:				/* "SYS": inside System Header */
scan.c:						if ( p->lxmval == newval )	/* check vs existing value*/
scan.c:							p->lxmval = newval;
scan.c:		if ( p->lxmch == 0 ) { 				/* lookup returns 0 */
sty.y:	NCONVAL n	the constant -n
sty.y:	POSRANGE n	constants in the range [0,2**n -1]
sty.y:	SGRANGE n	constants in the range [-2**n, 2**n - 1]
sty.y:	Thus, when side-effects only are desired, the first template matching
sty.y:static int	nmshp = NSTYSHPS - 1;
sty.y:	OP	the ops <, <<, >, >>, <=, >=, +, -, *, /, %, &, ^, ~, !
sty.y:	DIG	a digit, 0-9
sty.y:			shp[$2].sright = -1;
sty.y:			shp[nshp].sleft = -1;
sty.y:			shp[nshp].sright = -1;
sty.y:			checkit( nshp-1 );
sty.y:			shp[$2].sleft = nshp-1;
sty.y:			shp[$2].sright = -1;
sty.y:			rshty.sha = -1;
sty.y:			rshty.sha = -1;
sty.y:			lshty.sha = -1;
sty.y:		optl[i] = ophd[i] = -1;
sty.y:	if( p->sop < 0 || p->sop > MANY ) {
sty.y:		yyerror( "out of range op: %d", p->sop );
sty.y:	switch( optype(p->sop) ) {
sty.y:		if( p->sright < 0 && p->sop != MANY ) {
sty.y:		checkit( p->sright );
sty.y:		if( p->sleft < 0 ) {
sty.y:		checkit( p->sleft );
sty.y:	for( i = notb-1;  i >= 0;  --i )
sty.y:	lshty.sha = -1;
sty.y:		for( i= NSTYSHPS; i>nmshp; --i ) {
sty.y:		i = bop( MANY, s, -1, 0 );
sty.y:	return( !(x&(x-1)) );
sty.y:		yyerror( "multiple results -- illegal (%o)", rewrite );
sty.y:	q->line = lineno;
sty.y:	q->op = op;
sty.y:	q->tyop = tyop;
sty.y:	q->nxop = -1;
sty.y:	q->l = lshty;
sty.y:	q->r = rshty;
sty.y:	q->oneeds = needs;
sty.y:	q->orew = rewrite;
sty.y:	q->ocost = cost;
sty.y:	q->string = asstring;
sty.y:	q->olcount = lcount;
sty.y:	q->orcount = rcount;
sty.y:		if( (s=q->r.sha) >= 0 && trivial(s) ) {
sty.y:			q->r.sha = -1;  /* clobber any right shape */
sty.y:		if( q->r.sha >=0 ) {
sty.y:	/* flagl and flagr are 1 if L and R legal, 0 if not, -1 if
sty.y:			if( *s == '-' )
sty.y:				/* look for side-effects here */
sty.y:				/* look for side-effects here */
sty.y:				if( (*s - '0') > (needs&NCOUNT) )
sty.y:				if( (needs&LSHARE) && flagl ) flagl = -1;
sty.y:				if( (needs&RSHARE) && flagr ) flagr = -1;
sty.y:	return( bop( o, a, -1, 0 ) );
sty.y:	checkit( nshp-1 );
sty.y:	return( nshp-1 );
sty.y:		p = &shp[ ret = nmshp-- ];
sty.y:	p->sop = o;
sty.y:	p->sleft = a;
sty.y:	p->sright =b;
sty.y:	p->scost = cst;
sty.y:	p->ssh = 0;
sty.y:	p->shname[0] = '\0';
sty.y:int olist[] = { PLUS, MINUS, MUL, DIV, MOD, LS, RS, OR, ER, AND, -1 };
sty.y:#define NameV(x)	#x,	x	/* name-value pairs */
sty.y:#define NameV(x)	"x",	x	/* name-value pairs */
sty.y:		exit( -1 );
sty.y:		exit( -1 );
sty.y:		exit( -1 );
sty.y:		q->l.sha = mkshp(q->l.sha);
sty.y:		q->r.sha = mkshp(q->r.sha);
sty.y:		q->struse = 1;
sty.y:		q->strdef = -1;
sty.y:			if(!q1->struse)
sty.y:			if(strcmp(q->string,q1->string)==0)
sty.y:				q->strdef = j;
sty.y:				q1->struse++;
sty.y:				q->struse = 0;
sty.y:		if(q->struse>1)
sty.y:				i, q->string);
sty.y:			q->struse = 0;
sty.y:			q->strdef = i;
sty.y:	for( j=0,i=NSTYSHPS-1; i>nmshp; --i ) {
sty.y:		if( p->sop<0 )
sty.y:			yyerror( "undefined shape: %.8s", p->shname );
sty.y:		fprintf( tbl_a, "%4d,\t",p->sop );
sty.y:		saaddr(p->sleft);
sty.y:		saaddr(p->sright);
sty.y:		fprintf( tbl_a, "%#o,\t%d,", p->ssh, p->scost );
sty.y:		if( p->shname[0] )
sty.y:			fprintf( tbl_a, "\t/* %.8s */\n", p->shname );
sty.y:		if(p->shname[0])
sty.y:	for( j = 0, i = NSTYSHPS-1;  i > nmshp; --i ) {
sty.y:		fprintf( tbl_b, "/* # %d, line %d */\n", i, q->line );
sty.y:		prop( q->op );
sty.y:		prnam( q->tyop, Tnam );
sty.y:		if( q->nxop >= 0 )
sty.y:			fprintf( tbl_b, "\t&table[%d],\n", q->nxop );
sty.y:		shpprint(q->l.sha, q->l.ty);
sty.y:		shpprint(q->r.sha, q->r.ty);
sty.y:		prnam(q->oneeds, Ndnam);
sty.y:		prnam(q->orew, Rwnam);
sty.y:		if(q->strdef>=0)
sty.y:			fprintf(tbl_b, "\t\tStr%d,\n", q->strdef);
sty.y:			fprintf(tbl_b, "\t\t\"%s\",\n", q->string);
sty.y:			q->ocost, q->olcount, q->orcount, q->line );
sty.y:	if((p->sleft >= 0) && (p->sop==MANY)) chkdup1(p->sleft);
sty.y:	if((p->sright >= 0) && (p->sop==MANY)) chkdup1(p->sright);
sty.y:	p->scnt++;
sty.y:	treecnt += p->scnt;
sty.y:	if(p->sleft >= 0) clrcnt(p->sleft);
sty.y:	if(p->sright >= 0) clrcnt(p->sright);
sty.y:	p->scnt = 0;
sty.y:	fprintf(stderr,"%s.%d	=	%d",str,ii,p->scnt);
sty.y:	if(p->shname[0]) fprintf(stderr,"	/* %s */",p->shname);
sty.y:	if(p->sright>=0) prtree("R",p->sright);
sty.y:	if(p->sleft>=0) prtree("L",p->sleft);
sty.y:	for(tn = src; tn->tntn; tn++)
sty.y:		if( tn->tnty == ty )
sty.y:			fprintf( tbl_b, "%s,\n", tn->tntn );
sty.y:		for(tn = src; tn->tntn; tn++)
sty.y:			if(tn->tnty==jj)
sty.y:		if(tn->tntn)
sty.y:			fprintf( tbl_b, "%s",tn->tntn);
sty.y:		if( c<0 ) return( -1 );
sty.y:		case '-':
sty.y:			while( pstring < &strng[NSTRING-2] )
sty.y:			for( i = 0;  i < sizeof name - 1;  ++i )
sty.y:			for( i = 0;  i < sizeof name - 1;  ++i )
sty.y:				yylval.ival = c-'0';
sty.y:						yylval.ival =c-'0';
sty.y:				yylval.ival = c-'0';
sty.y:	"--",	DECR,
sty.y:	"-",	MINUS,
sty.y:	"-=",	ASG MINUS,
sty.y:	"",	-1 };
sty.y:			yyerror( "illegal type: %c", p[-1] );
sty.y:	"",	-1,
sty.y:	for( i=NSTYSHPS-1, p= &shp[NSTYSHPS-1]; i>nmshp; --i,--p )
sty.y:		if( !strncmp( name, p->shname, 8 ) )
sty.y:	strncpy( p->shname, name, 8 );
sty.y:	p->ssh = p->scost = 0;
sty.y:	p->sleft = p->sright = -1;
sty.y:	p->sop = -1;
sty.y:	yylval.ival = nmshp--;
sty.y:	if ( sn == nshp - 1 )
sty.y:	checkit( nshp-1 );
sty.y:	return( nshp-1 );
sty.y:		return(-a);
sty.y:	case MINUS:	return(a-b);
sty.y:	for( np = Opnam;  np->tnty;  np++ )
sty.y:		if( op == np->tnty )
sty.y:			fprintf( tbl_b, "%s,", np->tntn );
sty.y:#define	EqOptb(a)	(q->a == q1->a)
sty.y:				shapeshr(q->l.sha, q1->l.sha)  &&
sty.y:				shapeshr(q->r.sha, q1->r.sha)
sty.y:					q->line, q1->line );
tags:ISCON	optim.c	?^# define ISCON(p) (p->in.op==ICON)$?
tags:LEG1	grey.c	?^#define LEG1(p)		(RTOL(p->in.op) ? p->in.right : p?
tags:LEG2	grey.c	?^#define LEG2(p)		(RTOL(p->in.op) ? p->in.left : p-?
tags:istnode	cgen.c	?^# define istnode(p) (p->in.op==REG && istreg(p->tn?
tags:ungetc	scan.c	?^#define	ungetc(c, ioptr)	*--linecp=(c)$?
trees.c:	(bk#5) catch non-scalar conditional expressions
trees.c:** rval<0 is -inlabel number
trees.c:** rval has the STAB index, or - label number,
trees.c:	extern int ftn_arg;		/*bk: for default (unprototype'd) float->double */
trees.c:                printf( "buildtree( %s, %d, %d )\n", opst[o], l-node, r-node );
trees.c:        if( o == LB && l->tn.type == LONG )
trees.c:				uerror( "non-integral array subscript" );
trees.c:        if( o == NOT && l->in.op == ICON )
trees.c:        else if( o==UNARY MINUS && l->in.op==FCON )
trees.c:                l->fpn.dval = -l->fpn.dval;
trees.c:        else if( o==UNARY PLUS && l->in.op==FCON )		/*bk*/
trees.c:        else if( o==QUEST && l->in.op==ICON && l->tn.rval==NONAME )
trees.c:                l->in.op = FREE;
trees.c:                r->in.op = FREE;
trees.c:                if( l->tn.lval )
trees.c:                        tfree( r->in.right );
trees.c:						r->in.left->in.typeq |= r->in.right->in.typeq;
trees.c:                        return( r->in.left );
trees.c:                        tfree( r->in.left );
trees.c:						r->in.right->in.typeq |= r->in.left->in.typeq;
trees.c:                        return( r->in.right );
trees.c:        else if( (o==ANDAND || o==OROR) && (l->in.op==ICON||r->in.op==ICON) )
trees.c:			if (   l->in.op == ICON 	/* left side is ICON */
trees.c:				&& l->tn.rval == NONAME /* not a symbol */
trees.c:				&& (   (o==ANDAND && l->tn.lval==0)
trees.c:					|| (o==OROR && l->tn.lval!=0)
trees.c:				p->in.op = FREE;
trees.c:				l->tn.lval = (o==ANDAND) ? 0 : 1;	/* force to correct value */
trees.c:        else if( opty == BITYPE && l->in.op == ICON && r->in.op == ICON )
trees.c:                        uerror( "illegal use of const-qualified object" );
trees.c:                p->in.left = pconvert( p->in.left, 0 );
trees.c:	                        p->in.right = pconvert( p->in.right, 
trees.c:                                p->in.left = pconvert( p->in.left,
trees.c:				if (ISFTN( p->in.right->tn.type ))	/* actual arg type is 010x*/
trees.c:					p->in.right = pconvert( p->in.right, 0 );
trees.c:				else if ( ISARY( p->in.right->tn.type ) )
trees.c:					p->in.right = pconvert( p->in.right, 0 );
trees.c:				if ( ISARY( p->in.left->tn.type ) )
trees.c:					p->in.left = pconvert( p->in.left, 0 );
trees.c:                q = (actions&TYPL) ? p->in.left : p->in.right;
trees.c:                p->in.type = q->in.type;
trees.c:                p->in.typeq = q->in.typeq;		/* bk */
trees.c:                p->fn.cdim = q->fn.cdim;
trees.c:                p->fn.csiz = q->fn.csiz;
trees.c:                l = p->in.left;
trees.c:                r = p->in.right;
trees.c:					if ( r->in.op == ICON ) {
trees.c:						switch ( r->in.type ) {
trees.c:						if ( max && r->tn.lval > 32 )
trees.c:                        if( sp->stype == UNDEF )
trees.c:                                uerror( "%s undefined", sp->sname );
trees.c:                                p->in.type = p->fn.cdim = p->fn.csiz = INT;
trees.c:                                p->tn.rval = idname;
trees.c:                                p->tn.lval = 0;
trees.c:                        p->in.type = sp->stype;
trees.c:						p->in.typeq = sp->stypeq;
trees.c:						p->in.proto = sp->sproto;		/*bk*/
trees.c:                        p->fn.cdim = sp->dimoff;
trees.c:                        p->fn.csiz = sp->sizoff;
trees.c:                        if( p->in.type == MOETY )
trees.c:                                p->tn.rval = NONAME;
trees.c:                                p->tn.lval = sp->offset;
trees.c:                                p->fn.cdim = 0;
trees.c:                                p->in.type = INT;
trees.c:                                p->in.op = ICON;
trees.c:                                switch( sp->sclass )
trees.c:                                        p->in.op = VAUTO;
trees.c:                                        p->tn.rval = NONAME;
trees.c:                                        p->tn.lval = BITOOR(sp->offset);
trees.c:										p->tn.goal = sp->sflags;
trees.c:                                        p->in.op = VPARAM;
trees.c:                                        p->tn.rval = NONAME;
trees.c:                                        p->tn.lval = BITOOR(sp->offset);
trees.c:										p->tn.goal = sp->sflags;
trees.c:                                        p->in.op = REG;
trees.c:                                        p->tn.lval = 0;
trees.c:                                        p->tn.rval = sp->offset;
trees.c:                                        if( sp->slevel != 0 )
trees.c:                                                p->tn.lval = 0;
trees.c:                                                p->tn.rval = -sp->offset;
trees.c:                                        p->tn.lval = 0;
trees.c:                                        p->tn.rval = idname;
trees.c:                        p->in.type = INT;
trees.c:                        p->fn.cdim = 0;
trees.c:                        p->fn.csiz = INT;
trees.c:                        p->in.op = NAME;
trees.c:                        p->in.type = CHAR+ARY;
trees.c:/*                      	p->in.typeq = CONSTSTR;	/ bk: string "constant" */
trees.c:                        p->tn.lval = 0;
trees.c:                        p->tn.rval = NOLAB;
trees.c:                        p->fn.cdim = curdim;
trees.c:                        p->fn.csiz = CHAR;
trees.c:                        p->tn.lval = 0;
trees.c:                        p->tn.rval = 0;
trees.c:                        p->in.type = DOUBLE;
trees.c:                        p->fn.cdim = 0;
trees.c:                        p->fn.csiz = DOUBLE;
trees.c:                        /* p->x turned into *(p+offset) */
trees.c:                        i = r->tn.rval;
trees.c:                        if(i<0 || i>=SYMTSZ || ((sp= &stab[i])->sclass != MOS &&
trees.c:                            sp->sclass != MOU && !(sp->sclass&FIELD)) )
trees.c:                                /* if this name is non-unique, find right one */
trees.c:                                if( stab[i].sflags&SNONUNIQ && (l->in.type==PTR+STRTY ||
trees.c:                                    l->in.type == PTR+UNIONTY) &&
trees.c:                                    (l->fn.csiz+1) >= 0 && dimtab[l->fn.csiz+1] >= 0)
trees.c:                                j=dimtab[l->fn.csiz+1];
trees.c:                                                r->tn.rval = i = memi;
trees.c:                                if( l->in.type != PTR+STRTY &&
trees.c:                                    l->in.type != PTR+UNIONTY )
trees.c:                                else if( (j=l->fn.csiz+1)<0 )
trees.c:                                        DECREF(l->in.type) ) )
trees.c:                        if( l->in.op == UNARY AND )
trees.c:                                p->in.op = l->in.op = FREE;
trees.c:                                p = l->in.left;
trees.c:                        if ( !ISPTR(l->in.type) )
trees.c:/*						if ( leftcons && (l->in.typeq & CONSTVAR) ) */
trees.c:						p->in.typeq = l->in.typeq;	/*bk: inherit const */
trees.c:                        p->in.type = DECREF(l->in.type);
trees.c:                        p->fn.cdim = l->fn.cdim;
trees.c:                        p->fn.csiz = l->fn.csiz;
trees.c:                        switch( l->in.op )
trees.c:                                p->in.op = l->in.op = FREE;
trees.c:                                p = l->in.left;
trees.c:								if ( p->in.op == CONV && 
trees.c:									ISPTR(p->in.type) &&
trees.c:									ISPTR(p->in.left->in.type) ) {
trees.c:									t = p->in.left->in.type;
trees.c:									d = p->in.left->fn.cdim;
trees.c:									s = p->in.left->fn.csiz;
trees.c:									p->in.op = FREE;
trees.c:									p = p->in.left;
trees.c:									p->in.type = t;	/* see makety */
trees.c:									p->fn.cdim = d;
trees.c:									p->fn.csiz = s;
trees.c:								if ( l->tn.goal & SREG ) {	/* bk */
trees.c:                                p->in.type = INCREF( l->in.type );
trees.c:								p->in.typeq = l->in.typeq;		/* bk */
trees.c:                                p->fn.cdim = l->fn.cdim;
trees.c:                                p->fn.csiz = l->fn.csiz;
trees.c:                                lr = buildtree( UNARY AND, l->in.right, NIL );
trees.c:                                p->in.op = l->in.op = FREE;
trees.c:                                p = buildtree( COMOP, l->in.left, lr );
trees.c:                                l->in.right->in.right, NIL );
trees.c:                                l->in.right->in.left, NIL );
trees.c:                                p->in.op = l->in.op = l->in.right->in.op = FREE;
trees.c:                                p = buildtree( QUEST, l->in.left,
trees.c:                                if( l->fn.csiz != r->fn.csiz )
trees.c:                                t = r->in.type;
trees.c:                                d = r->fn.cdim;
trees.c:                                s = r->fn.csiz;
trees.c:									l->in.op = HIDASG;
trees.c:                                        p->in.op = FREE;
trees.c:                                p->in.op = STAR;
trees.c:                                p->in.left = clocal(l);
trees.c:                                p->in.right = NIL;
trees.c:                        if( l->fn.csiz != r->fn.csiz )
trees.c:                        p->in.right = r = strargs( p->in.right, &i );
trees.c:                        if( !ISPTR(l->in.type)) uerror("illegal function");
trees.c:                        p->in.type = DECREF(l->in.type);
trees.c:                        if( !ISFTN(p->in.type)) uerror("illegal function");
trees.c:                        p->in.type = DECREF( p->in.type );
trees.c:                        p->fn.cdim = l->fn.cdim;
trees.c:                        p->fn.csiz = l->fn.csiz;
trees.c:                        if( l->in.op == UNARY AND &&
trees.c:                            l->in.left->in.op == NAME &&
trees.c:                            l->in.left->tn.rval >= 0 &&
trees.c:                            l->in.left->tn.rval != NONAME &&
trees.c:                            ((i=stab[l->in.left->tn.rval].sclass)==FORTRAN
trees.c:                                p->in.op += (FORTCALL-CALL);
trees.c:                        if( l->in.op == UNARY AND &&
trees.c:                            l->in.left->in.op == NAME &&
trees.c:                            l->in.left->tn.rval >= 0 &&
trees.c:                            l->in.left->tn.rval != NONAME &&
trees.c:                            stab[l->in.left->tn.rval].sclass == INLINE )
trees.c:                                p->in.op += (INCALL-CALL);
trees.c:                        if( p->in.type == STRTY || p->in.type == UNIONTY )
trees.c:                                i = tsize( p->in.type, p->fn.cdim, p->fn.csiz );
trees.c:                                p->in.op += STCALL-CALL;
trees.c:                                p->in.type = INCREF( p->in.type );
trees.c:                                t = indtype( p->tn.type );
trees.c:                                if( t != p->tn.type )
trees.c:                                        p->fn.csiz = p->tn.type = t;
trees.c:                        i = tsize( p->in.type, p->fn.cdim, p->fn.csiz );
trees.c:        t = p->fn.type;
trees.c:        if( p->in.op == CM )
trees.c:                p->in.left = strargs( p->in.left, off );
trees.c:                p->in.right = strargs( p->in.right, off );
trees.c:        p = block( STARG, p, NIL, t, p->fn.cdim, p->fn.csiz, 0 );
trees.c:                p->in.left = buildtree( UNARY AND, p->in.left, NIL );
trees.c:                p->in.op = FUNARG;
trees.c:        SETOFF( *off, talign( t, p->fn.csiz ) );
trees.c:        p->tn.rval = *off;
trees.c:        *off += tsize( t, p->fn.cdim, p->fn.csiz );
trees.c:#define NNCON(p) (p->tn.op == ICON && p->tn.rval == NONAME && \
trees.c:					!ISPTR(p->tn.type))
trees.c:        switch( optype(o = p->tn.op) )
trees.c:                l = p->in.left;
trees.c:                r = p->in.right;
trees.c:                r = l = p->in.left;
trees.c:        f = (p->tn.type==FLOAT || p->tn.type == DOUBLE);
trees.c:        u = ISUNSIGNED(p->tn.type);
trees.c:							/* operation is not floating-point */
trees.c:			&& (   (l->tn.op == FCON && r->tn.op == FCON)
trees.c:				|| (l->tn.op == FCON && NNCON(r))
trees.c:				|| (NNCON(l) && r->tn.op == FCON)
trees.c:			** (other than && or ||) with (a) two floating-point constant
trees.c:				newleft = (l->tn.op == FCON) ? l->fpn.dval : l->tn.lval;
trees.c:				newright = (r->tn.op == FCON) ? r->fpn.dval : r->tn.lval;
trees.c:				if (l->fpn.dval > r->fpn.dval)
trees.c:				if (l->fpn.dval < r->fpn.dval)
trees.c:			l->tn.lval = newleft;	/* set left ICON value */
trees.c:			r->tn.lval = newright;	/* set right ICON value */
trees.c:			l->in.op = ICON;		/* force any FCONs into ICONs */
trees.c:			r->in.op = ICON;
trees.c:			l->tn.type = p->tn.type;	/* insure same type as parent op */
trees.c:			r->tn.type = p->tn.type;
trees.c:			l->tn.rval = NONAME;	/* ICONs without a name */
trees.c:			r->tn.rval = NONAME;
trees.c:        if( l->tn.op != ( f ? FCON : ICON ) ) return( p );
trees.c:        if( r->tn.op != ( f ? FCON : ICON ) ) return( p );
trees.c:                val = r->tn.lval;
trees.c:				/*    the rval's must be NONAME (n'est-ce pas?) 	*/
trees.c:                if( l->tn.rval != NONAME && r->tn.rval != NONAME )
trees.c:						&& l->tn.rval==r->tn.rval
trees.c:						&& l->tn.lval==r->tn.lval
trees.c:						r->tn.op = FREE;	/* free right side */
trees.c:						l->tn.lval = 0;	/* set left ICON value */
trees.c:						l->tn.type = p->tn.type; /* insure same type */
trees.c:						l->tn.rval = NONAME; /* ICON with no name */
trees.c:						p->tn.op = FREE;	/* free minus node */
trees.c:                if( l->tn.rval != NONAME && r->tn.rval != NONAME ) return(p);
trees.c:                if( r->tn.rval != NONAME && o!=PLUS ) return(p);
trees.c:                if( l->tn.rval != NONAME && o!=PLUS && o!=MINUS ) return(p);
trees.c:			sl =  ( f ? l->fpn.dval < 0.0 : l->tn.lval < 0 );
trees.c:			sr =  ( f ? r->fpn.dval < 0.0 : r->tn.lval < 0 );
trees.c:                l->tn.lval = (l->tn.lval && r->tn.lval) ? 1 : 0;
trees.c:                l->tn.lval = (l->tn.lval || r->tn.lval) ? 1 : 0;
trees.c:                        l->fpn.dval += r->fpn.dval;
trees.c:                l->tn.lval += val;
trees.c:                if( l->tn.rval == NONAME )
trees.c:                        l->tn.rval = r->tn.rval;
trees.c:                        l->in.type = r->in.type;
trees.c:                if( f ) l->fpn.dval -= r->fpn.dval;
trees.c:                else l->tn.lval -= val;
trees.c:                if( f ) l->fpn.dval *= r->fpn.dval;
trees.c:                else l->tn.lval *= val;
trees.c:	                if( r->fpn.dval == 0.0 ) {
trees.c:					} else l->fpn.dval /= r->fpn.dval;
trees.c:                                l->tn.lval = (unsigned long)l->tn.lval / val;
trees.c:                        else l->tn.lval /= val;
trees.c:                else if( u ) l->tn.lval = (unsigned long)l->tn.lval % val;
trees.c:                else l->tn.lval %= val;
trees.c:                l->tn.lval &= val;
trees.c:                l->tn.lval |= val;
trees.c:                l->tn.lval ^=  val;
trees.c:                l->tn.lval = l->tn.lval << i;
trees.c:                if( u ) l->tn.lval = (unsigned long)l->tn.lval >> i;
trees.c:                else l->tn.lval = l->tn.lval >> i;
trees.c:                if( f ) l->fpn.dval = -l->fpn.dval;
trees.c:					l->tn.lval = - l->tn.lval;
trees.c:					if ( ISUNSIGNED(l->tn.type) ) {		/* bk */
trees.c:                		p->in.type = l->tn.type = DEUNSIGN(l->tn.type);
trees.c:                l->tn.lval = ~l->tn.lval;
trees.c:                if( l->tn.type == FLOAT || l->tn.type == DOUBLE )
trees.c:                        l->tn.op = ICON;
trees.c:                        l->tn.lval = !l->fpn.dval;
trees.c:                else l->tn.lval = !l->tn.lval;
trees.c:                l->tn.lval = l->tn.lval < val;
trees.c:                l->tn.lval = l->tn.lval <= val;
trees.c:                l->tn.lval = l->tn.lval > val;
trees.c:                l->tn.lval = l->tn.lval >= val;
trees.c:/*                l->tn.lval = (l->tn.lval-val)<0; */
trees.c:                l->tn.lval = (unsigned long) l->tn.lval < (unsigned long) val ;
trees.c:                l->tn.lval = (unsigned long) l->tn.lval <= (unsigned long) val;
trees.c:/*                l->tn.lval = (l->tn.lval-val)>=0; */		
trees.c:                l->tn.lval = (unsigned long) l->tn.lval >= (unsigned long) val;
trees.c:/*                l->tn.lval = (l->tn.lval-val)>0; */
trees.c:                l->tn.lval = (unsigned long) l->tn.lval > (unsigned long) val;
trees.c:                l->tn.lval = l->tn.lval == val;
trees.c:                l->tn.lval = l->tn.lval != val;
trees.c:			sres =  ( f ? l->fpn.dval < 0.0 : l->tn.lval < 0 );
trees.c:						f ? "floating" : "integer", opst[p->tn.op] );
trees.c:        if( l != r ) r->tn.op = FREE; /* don't clobber unary answer */
trees.c:        l = makety( l, p->tn.type, p->fn.cdim, p->fn.csiz );
trees.c:        p->tn.op = FREE;
trees.c:				"non-portable type combination");
trees.c:        q1 = p->in.left;
trees.c:        q2 = p->in.right;
trees.c:        t1 = q1->in.type;
trees.c:        t2 = q2->in.type;
trees.c:			if( t1==ENUMTY && t2==ENUMTY && q1->fn.csiz==q2->fn.csiz )
trees.c:				if ( t1==INT && asgop( p->in.op ) )
trees.c:					if ( (t1==INT || t2==INT) && q1->fn.csiz==q2->fn.csiz )
trees.c:			if ( p->in.op == PROTOCHK ) {
trees.c:					"enumeration type clash, operator %s", opst[p->in.op]);
trees.c:        {       /* switch roles: q1 should be non-pointer */
trees.c:                q2 = p->in.left;
trees.c:        if( !ISPTR(q1->in.type) && !ISARY(q1->in.type) )
trees.c:                if( q1->in.op == ICON && q1->tn.lval == 0 && q1->tn.rval == NONAME )
trees.c:                        q1->fn.type = q2->fn.type;
trees.c:                        q1->fn.cdim = q2->fn.cdim;
trees.c:                        q1->fn.csiz = q2->fn.type;
trees.c:                d1 = q1->fn.cdim;
trees.c:                d2 = q2->fn.cdim;
trees.c:								if(q1->fn.csiz!=q2->fn.csiz)
trees.c:		if ( p->tn.op == PROTOCHK ) {
trees.c:			switch ( p->in.left->in.op )		/* special cases */
trees.c:		        	strcpy( buf, "non-scalar switch condition" );
trees.c:											opst[p->tn.op] );
trees.c:/* conversion down-sizeing. If rhs is a constant, we can eliminate */
trees.c:		l = p->in.left;			
trees.c:		r = p->in.right;			
trees.c:		sizel = bigsize(l->tn.type);
trees.c:		sizer = bigsize(r->tn.type);
trees.c:		if ( r->tn.op == FLD ||
trees.c:			((sizer == sizel) && !ISUNSIGNED(r->tn.type)) )
trees.c:		if ( r->tn.op == ICON ) {
trees.c:			switch ( l->in.type ) {
trees.c:			if ( (unsigned) r->tn.lval <= max )	/* within bounds? */
trees.c:			if ( r->tn.op == FCON )
trees.c:		if ( p->tn.op == PROTOCHK ) {
trees.c:	        sprintf( buf, "possible loss of value, op %s", opst[p->tn.op] );
trees.c:	ret = p->tn.op == ICON && 
trees.c:		  ISUNSIGNED(p->tn.type) &&
trees.c:		  (unsigned) p->tn.lval > INT_MAX ;
trees.c:        /* make p->x */
trees.c:        q = &stab[p->in.right->tn.rval];
trees.c:        p->in.right->in.op = FREE;
trees.c:        p->in.op = FREE;
trees.c:        p = pconvert( p->in.left, 0 );
trees.c:		tqual = p->in.typeq;					/* bk */
trees.c:        if( !ISPTR(p->in.type))
trees.c:                p->in.type = PTR+UNIONTY;
trees.c:        t = INCREF( q->stype );
trees.c:        d = q->dimoff;
trees.c:        s = q->sizoff;
trees.c:        off = q->offset;
trees.c:        dsc = q->sclass;
trees.c:                switch(q->stype)
trees.c:				tqual = ( tqual << type_category(q->stype) );
trees.c:		p->in.typeq = tqual | q->stypeq;
trees.c:                p = block( FLD, p, NIL, q->stype, 0, q->sizoff, 0 );
trees.c:                p->tn.rval = PKFIELD( dsc&FLDSIZ, q->offset%align );
trees.c:        /* return 0 if p an lvalue, 2 if const-qualified,
trees.c:	l = p->in.left;
trees.c:        switch( l->in.op )
trees.c:                l = l->in.left;
trees.c:/*                if( l->in.left->in.op == STASG ) return( 1 );	**bk **/
trees.c:			if( ISARY(l->in.type) || 
trees.c:				ISFTN(l->in.type) ) return(1);
trees.c:				if ( CONST_QUALIFIED( l->in.type, l->in.typeq ) )
trees.c:						/* 2: test if pointed-to type is const */
trees.c:			if ( ISPTR( l->tn.type ) && (p->in.op != CAST) )
trees.c:					r = p->in.right;
trees.c:					tqleft = l->in.typeq;
trees.c:					tqright = r->in.typeq;
trees.c:	bad = ISARY( p->in.type );
trees.c:		switch (BTYPE(p->in.type) )
trees.c:/* bk: ANSI 3.3.2.3: catch non-lvalue structure expressions */
trees.c:	for ( l = p; optype( l->in.op ) != LTYPE && !ret; ) {
trees.c:		switch ( op = l->in.left->in.op ) {
trees.c:				r = l->in.left->in.right;
trees.c:				if ( BTYPE( r->in.type ) == STRTY ) {/* stref: dot bad, -> ok */
trees.c:					if ( callop(r->in.op) ) {
trees.c:						ret = ( r->tn.op == STCALL ||
trees.c:								r->tn.op == UNARY STCALL );
trees.c:							r = r->in.right;
trees.c:						ret = ( r->tn.op == UNARY AND );
trees.c:						uerror( "non-lvalue structure expression" );
trees.c:				uerror( "non-lvalue structure expression" );
trees.c:		l = l->in.left;
trees.c:        p->tn.lval = i;
trees.c:        p->tn.rval = NONAME;
trees.c:        return( offcon( psize(p), p->in.type, p->fn.cdim, p->fn.csiz ) );
trees.c:        if( !ISPTR(p->in.type) )
trees.c:        } else if( IS_FTNPTR(p->in.type) )			/* bk */
trees.c:        return( tsize( DECREF(p->in.type), p->fn.cdim, p->fn.csiz ) );
trees.c:                q = p->in.left;
trees.c:                r = bpsize( p->in.right );
trees.c:                q = p->in.right;
trees.c:                r = bpsize( p->in.left );
trees.c:                p->in.left = r;
trees.c:                p->in.right = r;
trees.c:        if( (ty=BTYPE(p->in.type)) == ENUMTY || ty == MOETY )
trees.c:                if( dimtab[ p->fn.csiz ] == SZCHAR ) ty = CHAR;
trees.c:                else if( dimtab[ p->fn.csiz ] == SZINT ) ty = INT;
trees.c:                else if( dimtab[ p->fn.csiz ] == SZSHORT ) ty = SHORT;
trees.c:                p->fn.csiz = ty;
trees.c:                MODTYPE(p->in.type,ty);
trees.c:                if( p->in.op == ICON && ty != LONG )
trees.c:                        p->in.type = p->fn.csiz = INT;
trees.c:        if( ISARY( p->in.type) )
trees.c:                p->in.type = DECREF( p->in.type );
trees.c:                ++p->fn.cdim;
trees.c:        if( ISFTN( p->in.type) )
trees.c:        t = indtype( p->tn.type );
trees.c:        if( t == p->tn.type ) return( p );
trees.c:        if( p->tn.op == CONV && cbigger( p ) )
trees.c:                p->tn.type = p->fn.csiz = t;
trees.c:        if( p->tn.op != CONV ) cerror( "cbigger" );
trees.c:        return( bigsize( p->tn.type ) > bigsize( p->in.left->tn.type ) );
trees.c:        switch(p->in.op)
trees.c:                t = p->in.left->in.type;
trees.c:                        p->in.op += (ULE-LE);
trees.c:                        t = p->in.right->in.type;
trees.c:                                p->in.op += (ULE-LE);
trees.c:                return( unconvert( p, p->in.left ) );
trees.c:        cerror( "illegal oconvert: %d", p->in.op );
trees.c:        o = p->in.op;
trees.c:        t = t1 = p->in.left->in.type;
trees.c:        t2 = p->in.right->in.type;
trees.c:        d = p->in.left->fn.cdim;
trees.c:        d2 = p->in.right->fn.cdim;
trees.c:        s = p->in.left->fn.csiz;
trees.c:        s2 = p->in.right->fn.csiz;
trees.c:                if( psize(p->in.left) != psize(p->in.right) )
trees.c:                p->tn.type = p->fn.csiz = PTRTYPE;
trees.c:                p->fn.cdim = 0;
trees.c:        p->in.left = makety( p->in.left, t, d, s );
trees.c:        p->in.right = makety( p->in.right, t, d, s );
trees.c:				p->in.right->in.typeq = p->in.typeq;
trees.c:				p->in.typeq |= (p->in.right->in.typeq | p->in.left->in.typeq );
trees.c:			p->in.type = t;
trees.c:			p->fn.cdim = d;
trees.c:			p->fn.csiz = s;
trees.c:        o = p->in.op;
trees.c:        t1 = (l=p->in.left)->in.type;
trees.c:        t2 = (r=p->in.right)->in.type;
trees.c:	/* bk: no more "unsigned-preserving" conversions, unless MODE_UNSIGNED */
trees.c:        if( r->tn.op == ICON && r->tn.rval == NONAME &&
trees.c:                if( r->tn.lval == ccast( r->tn.lval, t1 ) )
trees.c:                        r->in.type = t2 = t1;
trees.c:                        r->fn.cdim = l->fn.cdim;
trees.c:                        r->fn.csiz = l->fn.csiz;
trees.c:        if( l->tn.op == ICON && l->tn.rval == NONAME &&
trees.c:                if( l->tn.lval == ccast( l->tn.lval, t2 ) )
trees.c:                        l->in.type = t1 = t2;
trees.c:                        l->fn.cdim = r->fn.cdim;
trees.c:                        l->fn.csiz = r->fn.csiz;
trees.c:			/*bk: float->double promotion only if user explicitly asks for it */
trees.c:				if( ISUNSIGNED(l->tn.type) ) u=1;
trees.c:						loseval_chk( p );	/* warn of unsigned->signed conv */
trees.c:                t2 = r->tn.type;  /* back to reality... */
trees.c:				(ISUNSIGNED(l->tn.type) ^ ISUNSIGNED(r->tn.type)) ) {
trees.c:				if ( ISUNSIGNED(l->tn.type) ) {	
trees.c:					if ( bigsize(l->tn.type) < bigsize(r->tn.type) )
trees.c:						tu = r->tn.type;
trees.c:						tu = l->tn.type;
trees.c:					if ( bigsize(r->tn.type) < bigsize(l->tn.type) )
trees.c:						tu = l->tn.type;
trees.c:						tu = r->tn.type;
trees.c:        if( tu != t1 ) p->in.left = makety( l, tu, 0, (int)tu );
trees.c:        if( tu != t2 ) p->in.right = makety( r, tu, 0, (int)tu );
trees.c:                p->in.type = tu;
trees.c:                p->fn.cdim = 0;
trees.c:                p->fn.csiz = t;
trees.c:        if( asgop(o) && p->in.left->tn.op == CONV  )
trees.c:                l = p->in.left->in.left;
trees.c:                tu = l->in.type;
trees.c:				p->in.type=tu;	/* LHS represents result! ken#3 */
trees.c:                /* p->in.type = l->in.type = tu;  / ken#3 - old code */
trees.c:                /*l->in.type = tu;  		/ ken#3 - new code */
trees.c:                p->fn.cdim = l->fn.cdim;
trees.c:                p->fn.csiz = l->fn.csiz;
trees.c:        pt = p->in.type;
trees.c:        if( pt == ENUMTY && p->in.op == ICON )
trees.c:                pt = p->in.type;
trees.c:		/* non-simple type */
trees.c:				p->fn.csiz == s && p->fn.cdim == d ) {
trees.c:                p->fn.type = t;
trees.c:                p->fn.cdim = d;
trees.c:                p->fn.csiz = s;
trees.c:                opst[o], l-node, r-node, t, d, s, p-node, p->fn.typeq );
trees.c:        if( p->in.op == ICON && p->tn.rval==NONAME )
trees.c:                        p->in.op = FCON;
trees.c:                                p->fpn.dval = (unsigned long) p->tn.lval;
trees.c:                                p->fpn.dval = p->tn.lval;
trees.c:                p->tn.lval = ccast( p->tn.lval, t );
trees.c:        p->in.op = o;
trees.c:        p->tn.goal = 0;
trees.c:        p->in.left = l;
trees.c:        p->in.right = r;
trees.c:        p->in.type = t;
trees.c:        p->fn.cdim = d;
trees.c:        p->fn.csiz = s;
trees.c:		p->fn.typeq = tq;
trees.c:		p->in.proto = 0;
trees.c:        if( p->in.op != ICON )
trees.c:                val = p->tn.lval;
trees.c:                if( val != p->tn.lval )
trees.c:                        uerror( "constant too big for cross-compiler" );
trees.c:** FCVT   don't do default conversions, but do ftn-to-ftnptr conversion(bk)
trees.c:        switch( optype(o=p->in.op) )
trees.c:                mt12=mt2 = moditype( p->in.right->in.type );
trees.c:                mt12 &= (mt1 = moditype( p->in.left->in.type ));
trees.c:					mt1 & SCALAR_TYPES && p->in.right->in.type == VOID )
trees.c:					&& p->in.right->in.type  == p->in.left->in.type 
trees.c:					&& p->in.right->fn.csiz  == p->in.left->fn.csiz
trees.c:					&& p->in.right->in.typeq == p->in.left->in.typeq)
trees.c:		if ( p->in.left->tn.op == RNODE ) {	/* special case */
trees.c:					uerror("non-scalar conditional expression");
trees.c:                if( v&ONEBIT(SZCHAR-1) )
trees.c:                if( v&ONEBIT(SZSHORT-1) )
trees.c:                if( v&ONEBIT(SZINT-1) )
trees.c:		if ( p->in.op == FLD ) {		/* bk: ANSI 3.3.3.4 */
trees.c:		} else if ( ISFTN( p->in.type ) ) {		/* bk: ANSI 3.3.3.4 */
trees.c:			i = tsize( p->in.type, p->fn.cdim, p->fn.csiz )/SZCHAR;
trees.c:        p->tn.type = UNSIGNED;  /* damn dmr anyhow! */
trees.c:	ftn_arg = 1;						/* take care of float->double */
trees.c:	ityp = indtype( p->in.type );	
trees.c:	if ( ityp != p->in.type )
trees.c:		p->fn.csiz = BTYPE(ityp);
trees.c:	p->in.type = ityp;
trees.c:	p->in.op = ARGTYPE;
trees.c:        printf("---------\n");
trees.c:        ty = optype( p->tn.op );
trees.c:                e1print( p->in.right ,"R");
trees.c:                --down;
trees.c:        for( d=down; d>1; d -= 2 ) printf( "\t" );
trees.c:        printf("%s=%d) %s, ", s, (int) (p-node), opst[p->in.op] );
trees.c:                printf( "lval=%ld", p->tn.lval );
trees.c:                printf( ", rval=%d, ", p->tn.rval );
trees.c:		if ( p->in.typeq ) {
trees.c:			qprint( p->in.typeq );
trees.c:		if ( HASPROTO(p->in.proto) )
trees.c:			printf( " %s", stab[ proto_lists[p->in.proto].lsymidx ].sname );
trees.c:        tprint(stdout, p->in.type );	/* ken#4 : designate stdout */
trees.c:        printf( ", dim=%d, siz=%d\n", p->fn.cdim, p->fn.csiz );
trees.c:                e1print( p->in.left ,"L");
trees.c:                --down;
trees.c:        if( p->in.op == FCON )
trees.c:                t = p->tn.type;
trees.c:                fincode( p->fpn.dval, t==DOUBLE?SZDOUBLE:SZFLOAT );
trees.c:                p->tn.lval = 0;
trees.c:                p->tn.rval = -i;
trees.c:                p->in.op = NAME;
trees.c:        if( (i = optype(p->in.op)) == BITYPE ) prtdcon( p->in.right );
trees.c:        if( i != LTYPE ) prtdcon( p->in.left );
trees.c:        ty = optype(p->in.op);
trees.c:		if ( p->in.op == HIDASG ) {			/* bk: almost same as STASG */
trees.c:			p->in.op = STASG;
trees.c:			l = p->in.left;
trees.c:			p->stn.stsize = tsize(DECREF(l->fn.type),l->fn.cdim,l->fn.csiz);
trees.c:			p->stn.stalign = talign(DECREF(l->fn.type),l->fn.csiz);
trees.c:        printf( "%d\t", p->in.op );
trees.c:                printf( CONFMT, p->tn.lval );
trees.c:                if( p->in.op == NAME || p->in.op == ICON || p->in.op == FCON)
trees.c:                else printf( "%d\t", p->tn.rval );
trees.c:        printf( "%o\t", p->in.type );
trees.c:        switch( p->in.op ){
trees.c:       		printf( "%o\t\n", p->in.typeq );
trees.c:                if( p->tn.rval == NONAME ) printf( "\n" );
trees.c:                else if( p->tn.rval >= 0 ){
trees.c:                        q = &stab[p->tn.rval];
trees.c:                        printf(  "%.8s\n", exname(q->sname) );
trees.c:                        printf(  "%s\n", exname(q->sname) );
trees.c:                else if( p->tn.rval == - strftn )
trees.c:                        printf( RNODNAME, -p->tn.rval );
trees.c:                        printf( LABFMT, -p->tn.rval );
trees.c:                /* note: p->in.left not a field... */
trees.c:					printf( CONFMT, p->stn.stsize );
trees.c:					printf( "\t%d\t\n", p->stn.stalign );
trees.c:						STRTY, p->in.left->fn.cdim, p->in.left->fn.csiz ) );
trees.c:						STRTY, p->in.left->fn.csiz ) );
trees.c:                x.d = p->fpn.dval;
trees.c:                dbltolong( &x, (p->fpn.type == DOUBLE? SZDOUBLE: SZFLOAT) );
trees.c:                if(p->fpn.type == DOUBLE )
trees.c:                if(p->fpn.type == DOUBLE )
trees.c:                        x.d = p->fpn.dval;
trees.c:                        x.f = p->fpn.dval;
trees.c:        if( ty != LTYPE ) prtree( p->in.left );
trees.c:        if( ty == BITYPE ) prtree( p->in.right );
trees.c:        ty = optype(o=p->in.op);
trees.c:        p->tn.goal = 0;  /* an illegal goal, just to clear it out */
trees.c:        if (p->in.op != SWCASE)
trees.c:        p->tn.type = ttype( p->tn.type );  /* type gets second-pass (bits) */
trees.c:                if( p->tn.rval == NONAME )
trees.c:                        p->in.name = (char *) 0;
trees.c:                else if( p->tn.rval >= 0 )
trees.c:                        cp = exname( stab[p->tn.rval].sname );
trees.c:                        p->in.name = tstr( cp );
trees.c:                else if( p->tn.rval == - strftn )
trees.c:                        sprintf( temp, RNODNAME, -p->tn.rval );
trees.c:                        p->in.name = tstr( temp );
trees.c:                        sprintf( temp, LABFMT, -p->tn.rval );
trees.c:                        p->in.name = tstr( temp );
trees.c:                l = p->in.left;
trees.c:                p->stn.stsize = tsize(STRTY,l->fn.cdim,l->fn.csiz);
trees.c:                p->stn.stalign = talign(STRTY,l->fn.csiz);
trees.c:                /* built into the tree by machine-dependent actions */
trees.c:                rbusy( p->tn.rval, p->in.type );
trees.c:                p->in.name = (char *) 0;
trees.c:        if( ty != LTYPE ) p2tree( p->in.left );
trees.c:        if( ty == BITYPE ) p2tree( p->in.right );
xdefs.c:int Arix[2];		/* Arix-specific flags */
