
# line 2 "ifyacc.y"
/*************************************************************************

    ifyacc.y	1.9
    yacc parser for #if statements

    Copyright 1997 Willows Software, Inc. 

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Library General Public License for more details.

You should have received a copy of the GNU Library General Public
License along with this library; see the file COPYING.LIB.  If
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA.

The maintainer of the Willows TWIN Libraries may be reached (Email) 
at the address twin@willows.com	

**************************************************************************/


#include <stdio.h>
#include "rc.h"
#include "define.h"
#include "buffer.h"

extern int ifResult;

/* Some systems don't like alloca, so we have to make them work right */
#if defined(_MAC) || defined(macintosh)
#define alloca malloc
#endif

#if defined(TWIN_HAVEALLOCA)
#include <alloca.h>
#endif

# line 47 "ifyacc.y"
typedef union
#ifdef __cplusplus
	ZZSTYPE
#endif

{
  int i;
  char *str;
} ZZSTYPE;
# define ifINT 257
# define ifSTRING 258
# define ifDEFINED 259
# define ifnDEFINED 260
# define ifPREPROCESSORIF 261

#ifdef __STDC__
#include <stdlib.h>
#include <string.h>
#else
#include <malloc.h>
#include <memory.h>
#endif

#include <values.h>

#ifdef __cplusplus

#ifndef zzerror
	void zzerror(const char *);
#endif

#ifndef zzlex
#ifdef __EXTERN_C__
	extern "C" { int zzlex(void); }
#else
	int zzlex(void);
#endif
#endif
	int zzparse(void);

#endif
#define zzclearin zzchar = -1
#define zzerrok zzerrflag = 0
extern int zzchar;
extern int zzerrflag;
ZZSTYPE zzlval;
ZZSTYPE zzval;
typedef int zztabelem;
#ifndef ZZMAXDEPTH
#define ZZMAXDEPTH 150
#endif
#if ZZMAXDEPTH > 0
int zz_zzs[ZZMAXDEPTH], *zzs = zz_zzs;
ZZSTYPE zz_zzv[ZZMAXDEPTH], *zzv = zz_zzv;
#else	/* user does initial allocation */
int *zzs;
ZZSTYPE *zzv;
#endif
static int zzmaxdepth = ZZMAXDEPTH;
# define ZZERRCODE 256

# line 96 "ifyacc.y"


int zzerror(char *str)
{
  CERROR(("%s", str));
  return 0;
}
zztabelem zzexca[] ={
-1, 1,
	0, -1,
	-2, 0,
	};
# define ZZNPROD 25
# define ZZLAST 244
zztabelem zzact[]={

     7,     2,    25,    23,     7,    44,    43,     6,     7,    19,
    41,     6,     7,    35,    40,     6,     7,    20,    52,     6,
     1,    14,    16,     6,     0,    42,    12,    10,    39,    11,
    51,    13,    37,    16,    18,    19,    17,     0,    20,     0,
     0,     0,    14,    16,    18,    19,    17,    12,    10,     0,
    11,     0,    13,    14,    16,    18,    19,    17,    12,     0,
     0,     0,     0,    13,     0,    18,    19,    17,     0,     0,
     0,     0,     0,     3,     0,     0,    18,    19,    17,     0,
    21,    22,     0,     0,    27,    28,    29,    30,    31,    32,
    34,    36,    38,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,    33,     0,     0,     0,    45,    15,    46,
     0,    47,     0,    48,    49,    50,     0,     0,     0,    15,
     0,     0,     0,     0,     0,     0,     0,     0,     0,    15,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    15,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
    26,    24,     0,     0,     4,     5,     8,     9,     4,     5,
     8,     9,     4,     5,     8,     9,     4,     5,     8,     9,
     4,     5,     8,     9 };
zztabelem zzpact[]={

  -260,-10000000,   -17,     5,-10000000,-10000000,   -17,   -17,   -37,   -38,
   -17,   -17,   -17,   -17,   -17,   -21,   -25,   -29,   -33,   -47,
   -51,   -16,     5,  -252,-10000000,  -253,-10000000,    16,    16,    -5,
    -5,    -5,   -26,   -17,   -26,   -17,   -52,   -17,   -52,   -17,
   -17,   -17,-10000000,   -11,   -23,   -26,   -26,   -52,   -52,   -52,
   -52,-10000000,-10000000 };
zztabelem zzpgo[]={

     0,    73,    20 };
zztabelem zzr1[]={

     0,     2,     1,     1,     1,     1,     1,     1,     1,     1,
     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
     1,     1,     1,     1,     1 };
zztabelem zzr2[]={

     0,     5,     2,     3,     7,     7,     7,     7,     7,     7,
     7,     9,     9,     7,     5,     7,     7,     9,     9,     9,
     9,     9,     5,     9,     5 };
zztabelem zzchk[]={

-10000000,    -2,   261,    -1,   257,   258,    40,    33,   259,   260,
    43,    45,    42,    47,    37,   124,    38,    62,    60,    61,
    33,    -1,    -1,    40,   258,    40,   258,    -1,    -1,    -1,
    -1,    -1,    -1,   124,    -1,    38,    -1,    61,    -1,    61,
    61,    61,    41,   258,   258,    -1,    -1,    -1,    -1,    -1,
    -1,    41,    41 };
zztabelem zzdef[]={

     0,    -2,     0,     1,     2,     3,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,    14,     0,    22,     0,    24,     4,     5,     6,
     7,     8,     9,     0,    10,     0,    15,     0,    16,     0,
     0,     0,    13,     0,     0,    11,    12,    17,    18,    19,
    20,    21,    23 };
typedef struct
#ifdef __cplusplus
	zztoktype
#endif
{ char *t_name; int t_val; } zztoktype;
#ifndef ZZDEBUG
#	define ZZDEBUG	0	/* don't allow debugging */
#endif

#if ZZDEBUG

zztoktype zztoks[] =
{
	"ifINT",	257,
	"ifSTRING",	258,
	"ifDEFINED",	259,
	"ifnDEFINED",	260,
	"ifPREPROCESSORIF",	261,
	"!",	33,
	"+",	43,
	"-",	45,
	"*",	42,
	"/",	47,
	"%",	37,
	"&",	38,
	"|",	124,
	"<",	60,
	">",	62,
	"=",	61,
	"-unknown-",	-1	/* ends search */
};

char * zzreds[] =
{
	"-no such reduction-",
	"preprocessorifclause : ifPREPROCESSORIF expr",
	"expr : ifINT",
	"expr : ifSTRING",
	"expr : expr '+' expr",
	"expr : expr '-' expr",
	"expr : expr '*' expr",
	"expr : expr '/' expr",
	"expr : expr '%' expr",
	"expr : expr '|' expr",
	"expr : expr '&' expr",
	"expr : expr '|' '|' expr",
	"expr : expr '&' '&' expr",
	"expr : '(' expr ')'",
	"expr : '!' expr",
	"expr : expr '>' expr",
	"expr : expr '<' expr",
	"expr : expr '>' '=' expr",
	"expr : expr '<' '=' expr",
	"expr : expr '=' '=' expr",
	"expr : expr '!' '=' expr",
	"expr : ifDEFINED '(' ifSTRING ')'",
	"expr : ifDEFINED ifSTRING",
	"expr : ifnDEFINED '(' ifSTRING ')'",
	"expr : ifnDEFINED ifSTRING",
};
#endif /* ZZDEBUG */
# line	1 "/usr/ccs/bin/yaccpar"
/*
 * Copyright (c) 1993 by Sun Microsystems, Inc.
 */

#pragma ident	"@(#)yaccpar	6.12	93/06/07 SMI"

/*
** Skeleton parser driver for yacc output
*/

/*
** yacc user known macros and defines
*/
#define ZZERROR		goto zzerrlab
#define ZZACCEPT	return(0)
#define ZZABORT		return(1)
#define ZZBACKUP( newtoken, newvalue )\
{\
	if ( zzchar >= 0 || ( zzr2[ zztmp ] >> 1 ) != 1 )\
	{\
		zzerror( "syntax error - cannot backup" );\
		goto zzerrlab;\
	}\
	zzchar = newtoken;\
	zzstate = *zzps;\
	zzlval = newvalue;\
	goto zznewstate;\
}
#define ZZRECOVERING()	(!!zzerrflag)
#define ZZNEW(type)	malloc(sizeof(type) * zznewmax)
#define ZZCOPY(to, from, type) \
	(type *) memcpy(to, (char *) from, zznewmax * sizeof(type))
#define ZZENLARGE( from, type) \
	(type *) realloc((char *) from, zznewmax * sizeof(type))
#ifndef ZZDEBUG
#	define ZZDEBUG	1	/* make debugging available */
#endif

/*
** user known globals
*/
int zzdebug;			/* set to 1 to get debugging */

/*
** driver internal defines
*/
#define ZZFLAG		(-10000000)

/*
** global variables used by the parser
*/
ZZSTYPE *zzpv;			/* top of value stack */
int *zzps;			/* top of state stack */

int zzstate;			/* current state */
int zztmp;			/* extra var (lasts between blocks) */

int zznerrs;			/* number of errors */
int zzerrflag;			/* error recovery flag */
int zzchar;			/* current input token number */



#ifdef ZZNMBCHARS
#define ZZLEX()		zzcvtok(zzlex())
/*
** zzcvtok - return a token if i is a wchar_t value that exceeds 255.
**	If i<255, i itself is the token.  If i>255 but the neither 
**	of the 30th or 31st bit is on, i is already a token.
*/
#if defined(__STDC__) || defined(__cplusplus)
int zzcvtok(int i)
#else
int zzcvtok(i) int i;
#endif
{
	int first = 0;
	int last = ZZNMBCHARS - 1;
	int mid;
	wchar_t j;

	if(i&0x60000000){/*Must convert to a token. */
		if( zzmbchars[last].character < i ){
			return i;/*Giving up*/
		}
		while ((last>=first)&&(first>=0)) {/*Binary search loop*/
			mid = (first+last)/2;
			j = zzmbchars[mid].character;
			if( j==i ){/*Found*/ 
				return zzmbchars[mid].tvalue;
			}else if( j<i ){
				first = mid + 1;
			}else{
				last = mid -1;
			}
		}
		/*No entry in the table.*/
		return i;/* Giving up.*/
	}else{/* i is already a token. */
		return i;
	}
}
#else/*!ZZNMBCHARS*/
#define ZZLEX()		zzlex()
#endif/*!ZZNMBCHARS*/

/*
** zzparse - return 0 if worked, 1 if syntax error not recovered from
*/
#if defined(__STDC__) || defined(__cplusplus)
int zzparse(void)
#else
int zzparse()
#endif
{
	register ZZSTYPE *zzpvt;	/* top of value stack for $vars */

#if defined(__cplusplus) || defined(lint)
/*
	hacks to please C++ and lint - goto's inside switch should never be
	executed; zzpvt is set to 0 to avoid "used before set" warning.
*/
	static int __yaccpar_lint_hack__ = 0;
	switch (__yaccpar_lint_hack__)
	{
		case 1: goto zzerrlab;
		case 2: goto zznewstate;
	}
	zzpvt = 0;
#endif

	/*
	** Initialize externals - zzparse may be called more than once
	*/
	zzpv = &zzv[-1];
	zzps = &zzs[-1];
	zzstate = 0;
	zztmp = 0;
	zznerrs = 0;
	zzerrflag = 0;
	zzchar = -1;

#if ZZMAXDEPTH <= 0
	if (zzmaxdepth <= 0)
	{
		if ((zzmaxdepth = ZZEXPAND(0)) <= 0)
		{
			zzerror("yacc initialization error");
			ZZABORT;
		}
	}
#endif

	{
		register ZZSTYPE *zz_pv;	/* top of value stack */
		register int *zz_ps;		/* top of state stack */
		register int zz_state;		/* current state */
		register int  zz_n;		/* internal state number info */
	goto zzstack;	/* moved from 6 lines above to here to please C++ */

		/*
		** get globals into registers.
		** branch to here only if ZZBACKUP was called.
		*/
	zznewstate:
		zz_pv = zzpv;
		zz_ps = zzps;
		zz_state = zzstate;
		goto zz_newstate;

		/*
		** get globals into registers.
		** either we just started, or we just finished a reduction
		*/
	zzstack:
		zz_pv = zzpv;
		zz_ps = zzps;
		zz_state = zzstate;

		/*
		** top of for (;;) loop while no reductions done
		*/
	zz_stack:
		/*
		** put a state and value onto the stacks
		*/
#if ZZDEBUG
		/*
		** if debugging, look up token value in list of value vs.
		** name pairs.  0 and negative (-1) are special values.
		** Note: linear search is used since time is not a real
		** consideration while debugging.
		*/
		if ( zzdebug )
		{
			register int zz_i;

			printf( "State %d, token ", zz_state );
			if ( zzchar == 0 )
				printf( "end-of-file\n" );
			else if ( zzchar < 0 )
				printf( "-none-\n" );
			else
			{
				for ( zz_i = 0; zztoks[zz_i].t_val >= 0;
					zz_i++ )
				{
					if ( zztoks[zz_i].t_val == zzchar )
						break;
				}
				printf( "%s\n", zztoks[zz_i].t_name );
			}
		}
#endif /* ZZDEBUG */
		if ( ++zz_ps >= &zzs[ zzmaxdepth ] )	/* room on stack? */
		{
			/*
			** reallocate and recover.  Note that pointers
			** have to be reset, or bad things will happen
			*/
			int zzps_index = (zz_ps - zzs);
			int zzpv_index = (zz_pv - zzv);
			int zzpvt_index = (zzpvt - zzv);
			int zznewmax;
#ifdef ZZEXPAND
			zznewmax = ZZEXPAND(zzmaxdepth);
#else
			zznewmax = 2 * zzmaxdepth;	/* double table size */
			if (zzmaxdepth == ZZMAXDEPTH)	/* first time growth */
			{
				char *newzzs = (char *)ZZNEW(int);
				char *newzzv = (char *)ZZNEW(ZZSTYPE);
				if (newzzs != 0 && newzzv != 0)
				{
					zzs = ZZCOPY(newzzs, zzs, int);
					zzv = ZZCOPY(newzzv, zzv, ZZSTYPE);
				}
				else
					zznewmax = 0;	/* failed */
			}
			else				/* not first time */
			{
				zzs = ZZENLARGE(zzs, int);
				zzv = ZZENLARGE(zzv, ZZSTYPE);
				if (zzs == 0 || zzv == 0)
					zznewmax = 0;	/* failed */
			}
#endif
			if (zznewmax <= zzmaxdepth)	/* tables not expanded */
			{
				zzerror( "yacc stack overflow" );
				ZZABORT;
			}
			zzmaxdepth = zznewmax;

			zz_ps = zzs + zzps_index;
			zz_pv = zzv + zzpv_index;
			zzpvt = zzv + zzpvt_index;
		}
		*zz_ps = zz_state;
		*++zz_pv = zzval;

		/*
		** we have a new state - find out what to do
		*/
	zz_newstate:
		if ( ( zz_n = zzpact[ zz_state ] ) <= ZZFLAG )
			goto zzdefault;		/* simple state */
#if ZZDEBUG
		/*
		** if debugging, need to mark whether new token grabbed
		*/
		zztmp = zzchar < 0;
#endif
		if ( ( zzchar < 0 ) && ( ( zzchar = ZZLEX() ) < 0 ) )
			zzchar = 0;		/* reached EOF */
#if ZZDEBUG
		if ( zzdebug && zztmp )
		{
			register int zz_i;

			printf( "Received token " );
			if ( zzchar == 0 )
				printf( "end-of-file\n" );
			else if ( zzchar < 0 )
				printf( "-none-\n" );
			else
			{
				for ( zz_i = 0; zztoks[zz_i].t_val >= 0;
					zz_i++ )
				{
					if ( zztoks[zz_i].t_val == zzchar )
						break;
				}
				printf( "%s\n", zztoks[zz_i].t_name );
			}
		}
#endif /* ZZDEBUG */
		if ( ( ( zz_n += zzchar ) < 0 ) || ( zz_n >= ZZLAST ) )
			goto zzdefault;
		if ( zzchk[ zz_n = zzact[ zz_n ] ] == zzchar )	/*valid shift*/
		{
			zzchar = -1;
			zzval = zzlval;
			zz_state = zz_n;
			if ( zzerrflag > 0 )
				zzerrflag--;
			goto zz_stack;
		}

	zzdefault:
		if ( ( zz_n = zzdef[ zz_state ] ) == -2 )
		{
#if ZZDEBUG
			zztmp = zzchar < 0;
#endif
			if ( ( zzchar < 0 ) && ( ( zzchar = ZZLEX() ) < 0 ) )
				zzchar = 0;		/* reached EOF */
#if ZZDEBUG
			if ( zzdebug && zztmp )
			{
				register int zz_i;

				printf( "Received token " );
				if ( zzchar == 0 )
					printf( "end-of-file\n" );
				else if ( zzchar < 0 )
					printf( "-none-\n" );
				else
				{
					for ( zz_i = 0;
						zztoks[zz_i].t_val >= 0;
						zz_i++ )
					{
						if ( zztoks[zz_i].t_val
							== zzchar )
						{
							break;
						}
					}
					printf( "%s\n", zztoks[zz_i].t_name );
				}
			}
#endif /* ZZDEBUG */
			/*
			** look through exception table
			*/
			{
				register int *zzxi = zzexca;

				while ( ( *zzxi != -1 ) ||
					( zzxi[1] != zz_state ) )
				{
					zzxi += 2;
				}
				while ( ( *(zzxi += 2) >= 0 ) &&
					( *zzxi != zzchar ) )
					;
				if ( ( zz_n = zzxi[1] ) < 0 )
					ZZACCEPT;
			}
		}

		/*
		** check for syntax error
		*/
		if ( zz_n == 0 )	/* have an error */
		{
			/* no worry about speed here! */
			switch ( zzerrflag )
			{
			case 0:		/* new error */
				zzerror( "syntax error" );
				goto skip_init;
			zzerrlab:
				/*
				** get globals into registers.
				** we have a user generated syntax type error
				*/
				zz_pv = zzpv;
				zz_ps = zzps;
				zz_state = zzstate;
			skip_init:
				zznerrs++;
				/* FALLTHRU */
			case 1:
			case 2:		/* incompletely recovered error */
					/* try again... */
				zzerrflag = 3;
				/*
				** find state where "error" is a legal
				** shift action
				*/
				while ( zz_ps >= zzs )
				{
					zz_n = zzpact[ *zz_ps ] + ZZERRCODE;
					if ( zz_n >= 0 && zz_n < ZZLAST &&
						zzchk[zzact[zz_n]] == ZZERRCODE)					{
						/*
						** simulate shift of "error"
						*/
						zz_state = zzact[ zz_n ];
						goto zz_stack;
					}
					/*
					** current state has no shift on
					** "error", pop stack
					*/
#if ZZDEBUG
#	define _POP_ "Error recovery pops state %d, uncovers state %d\n"
					if ( zzdebug )
						printf( _POP_, *zz_ps,
							zz_ps[-1] );
#	undef _POP_
#endif
					zz_ps--;
					zz_pv--;
				}
				/*
				** there is no state on stack with "error" as
				** a valid shift.  give up.
				*/
				ZZABORT;
			case 3:		/* no shift yet; eat a token */
#if ZZDEBUG
				/*
				** if debugging, look up token in list of
				** pairs.  0 and negative shouldn't occur,
				** but since timing doesn't matter when
				** debugging, it doesn't hurt to leave the
				** tests here.
				*/
				if ( zzdebug )
				{
					register int zz_i;

					printf( "Error recovery discards " );
					if ( zzchar == 0 )
						printf( "token end-of-file\n" );
					else if ( zzchar < 0 )
						printf( "token -none-\n" );
					else
					{
						for ( zz_i = 0;
							zztoks[zz_i].t_val >= 0;
							zz_i++ )
						{
							if ( zztoks[zz_i].t_val
								== zzchar )
							{
								break;
							}
						}
						printf( "token %s\n",
							zztoks[zz_i].t_name );
					}
				}
#endif /* ZZDEBUG */
				if ( zzchar == 0 )	/* reached EOF. quit */
					ZZABORT;
				zzchar = -1;
				goto zz_newstate;
			}
		}/* end if ( zz_n == 0 ) */
		/*
		** reduction by production zz_n
		** put stack tops, etc. so things right after switch
		*/
#if ZZDEBUG
		/*
		** if debugging, print the string that is the user's
		** specification of the reduction which is just about
		** to be done.
		*/
		if ( zzdebug )
			printf( "Reduce by (%d) \"%s\"\n",
				zz_n, zzreds[ zz_n ] );
#endif
		zztmp = zz_n;			/* value to switch over */
		zzpvt = zz_pv;			/* $vars top of value stack */
		/*
		** Look in goto table for next state
		** Sorry about using zz_state here as temporary
		** register variable, but why not, if it works...
		** If zzr2[ zz_n ] doesn't have the low order bit
		** set, then there is no action to be done for
		** this reduction.  So, no saving & unsaving of
		** registers done.  The only difference between the
		** code just after the if and the body of the if is
		** the goto zz_stack in the body.  This way the test
		** can be made before the choice of what to do is needed.
		*/
		{
			/* length of production doubled with extra bit */
			register int zz_len = zzr2[ zz_n ];

			if ( !( zz_len & 01 ) )
			{
				zz_len >>= 1;
				zzval = ( zz_pv -= zz_len )[1];	/* $$ = $1 */
				zz_state = zzpgo[ zz_n = zzr1[ zz_n ] ] +
					*( zz_ps -= zz_len ) + 1;
				if ( zz_state >= ZZLAST ||
					zzchk[ zz_state =
					zzact[ zz_state ] ] != -zz_n )
				{
					zz_state = zzact[ zzpgo[ zz_n ] ];
				}
				goto zz_stack;
			}
			zz_len >>= 1;
			zzval = ( zz_pv -= zz_len )[1];	/* $$ = $1 */
			zz_state = zzpgo[ zz_n = zzr1[ zz_n ] ] +
				*( zz_ps -= zz_len ) + 1;
			if ( zz_state >= ZZLAST ||
				zzchk[ zz_state = zzact[ zz_state ] ] != -zz_n )
			{
				zz_state = zzact[ zzpgo[ zz_n ] ];
			}
		}
					/* save until reenter driver code */
		zzstate = zz_state;
		zzps = zz_ps;
		zzpv = zz_pv;
	}
	/*
	** code supplied by user is placed in this switch
	*/
	switch( zztmp )
	{
		
case 1:
# line 70 "ifyacc.y"
{ifResult = zzpvt[-0].i; } break;
case 3:
# line 73 "ifyacc.y"
{ LOG(("Undefined constant %s", zzpvt[-0].str)); zzval.i = 0; } break;
case 4:
# line 74 "ifyacc.y"
{ zzval.i = zzpvt[-2].i + zzpvt[-0].i; } break;
case 5:
# line 75 "ifyacc.y"
{ zzval.i = zzpvt[-2].i - zzpvt[-0].i; } break;
case 6:
# line 76 "ifyacc.y"
{ zzval.i = zzpvt[-2].i * zzpvt[-0].i; } break;
case 7:
# line 77 "ifyacc.y"
{ zzval.i = zzpvt[-2].i / zzpvt[-0].i; } break;
case 8:
# line 78 "ifyacc.y"
{ zzval.i = zzpvt[-2].i % zzpvt[-0].i; } break;
case 9:
# line 79 "ifyacc.y"
{ zzval.i = zzpvt[-2].i | zzpvt[-0].i; } break;
case 10:
# line 80 "ifyacc.y"
{ zzval.i = zzpvt[-2].i & zzpvt[-0].i; } break;
case 11:
# line 81 "ifyacc.y"
{ zzval.i = zzpvt[-3].i || zzpvt[-0].i; } break;
case 12:
# line 82 "ifyacc.y"
{zzval.i = zzpvt[-3].i && zzpvt[-0].i; } break;
case 13:
# line 83 "ifyacc.y"
{ zzval.i = zzpvt[-1].i; } break;
case 14:
# line 84 "ifyacc.y"
{zzval.i = !zzpvt[-0].i; } break;
case 15:
# line 85 "ifyacc.y"
{ zzval.i = zzpvt[-2].i > zzpvt[-0].i; } break;
case 16:
# line 86 "ifyacc.y"
{ zzval.i = zzpvt[-2].i < zzpvt[-0].i; } break;
case 17:
# line 87 "ifyacc.y"
{ zzval.i = (zzpvt[-3].i >= zzpvt[-0].i); } break;
case 18:
# line 88 "ifyacc.y"
{ zzval.i = (zzpvt[-3].i <= zzpvt[-0].i); } break;
case 19:
# line 89 "ifyacc.y"
{ zzval.i = (zzpvt[-3].i == zzpvt[-0].i); } break;
case 20:
# line 90 "ifyacc.y"
{ zzval.i = (zzpvt[-3].i != zzpvt[-0].i); } break;
case 21:
# line 91 "ifyacc.y"
{ LOG(("%s is%s defined", zzpvt[-1].str, match_define(zzpvt[-1].str) ? "" : " not")); zzval.i = match_define(zzpvt[-1].str) ? 1 : 0; str_free(zzpvt[-1].str); } break;
case 22:
# line 92 "ifyacc.y"
{ LOG(("%s is%s defined", zzpvt[-0].str, match_define(zzpvt[-0].str) ? "" : " not")); zzval.i = match_define(zzpvt[-0].str) ? 1 : 0; str_free(zzpvt[-0].str); } break;
case 23:
# line 93 "ifyacc.y"
{ LOG(("%s is%s defined", zzpvt[-1].str, match_define(zzpvt[-1].str) ? "" : " not")); zzval.i = !match_define(zzpvt[-1].str) ? 1 : 0; str_free(zzpvt[-1].str); } break;
case 24:
# line 94 "ifyacc.y"
{ LOG(("%s is%s defined", zzpvt[-0].str, match_define(zzpvt[-0].str) ? "" : " not")); zzval.i = !match_define(zzpvt[-0].str) ? 1 : 0; str_free(zzpvt[-0].str); } break;
# line	532 "/usr/ccs/bin/yaccpar"
	}
	goto zzstack;		/* reset registers in driver code */
}

