llamapar.unx

compiler

ANSI( void yycode( char *fmt, ...))                                        
KnR ( void yycode(       fmt     ))
KnR ( char         *fmt;     )
{
    va_list   	 args;
    va_start( args,  fmt );
    yy_output( 0, fmt, args );
}

ANSI( void yydata( char *fmt, ...))                                        
KnR ( void yydata(       fmt     ))
KnR ( char         	*fmt;     )
{
    va_list   	 args;
    va_start( args,  fmt );
    yy_output( 1, fmt, args );
}

ANSI( void yybss ( char *fmt, ...))                                        
KnR ( void yybss (       fmt     ))
KnR ( char         	*fmt;     )
{
    va_list   	 args;
    va_start( args,  fmt );
    yy_output( 2, fmt, args );
}

                                                                               
                                                                             
                                                                         
                                                                                
                                                                              
                                                                            
                                                
   

#else                                                                  

#    define  yy_push(x,v)  	( ( ( (yyp_Yy_stack) <= Yy_stack )? ((yyt_Yy_stack)(long)(yystk_err(1))) : ( *--yyp_Yy_stack = (x) )),	--Yy_vsp, Yy_vsp->left=Yy_vsp->right=v )

#    define  yy_pop()    	( ++Yy_vsp, ( ( (yyp_Yy_stack) >= (Yy_stack + sizeof(Yy_stack)/sizeof(*Yy_stack)) )? ((yyt_Yy_stack)(long)(yystk_err(0))) : ( *yyp_Yy_stack++ )))
#    define  yy_nextoken()	yylex()
#    define  yy_quit_debug()
#    define  yy_sym()
#    define  yy_say_whats_happening(tos_item,prod)
#    define  yy_redraw_stack()
#    define  yy_pstack(refresh,print_it)
#    define  yy_break(x)

#ifndef va_list
#    include <stdarg.h>
#else
#    ifdef va_dcl
	MUST USE ANSI VARIABLE-ARGUMENT CONVENTIONS IN <stdarg.h>
#    endif
#endif

ANSI( void  yycode( char *fmt, ...))                                        
KnR ( void  yycode(       fmt     ))
KnR ( char         	 *fmt;     )
{
    va_list args;
    va_start( args,      fmt );
    vfprintf( yycodeout, fmt, args );
}

ANSI( void  yydata( char *fmt, ...))                                        
KnR ( void  yydata(       fmt     ))
KnR ( char         	 *fmt;     )
{
    va_list args;
    va_start( args,  fmt );
    vfprintf( yydataout, fmt, args );
}

ANSI( void  yybss ( char *fmt, ...))                                        
KnR ( void  yybss (       fmt     ))
KnR ( char         	 *fmt;     )
{
    va_list args;
    va_start( args,  fmt );
    vfprintf( yybssout, fmt, args );
}

ANSI( void  yycomment( char *fmt, ... )	)
KnR ( void  yycomment( fmt )		)
KnR ( char *fmt;			)
{
    va_list args;
    va_start( args,   fmt );
    vfprintf( stdout, fmt, args );
}

ANSI( void  yyerror( char *fmt, ... )	)
KnR ( void  yyerror( fmt )		)
KnR ( char  *fmt;			)
{
    va_list   args;
    extern char *yytext;
    extern int  yylineno;

    va_start( args, fmt );
    fprintf ( stderr, "ERROR (line %d near %s): ", yylineno, yytext );
    vfprintf( stderr, fmt, args );
    fprintf ( stderr, "\n" );
}
#endif


                                                              
                   
   

ANSI( YYPRIVATE yy_in_synch( int sym )	)
KnR ( YYPRIVATE yy_in_synch( sym )	)
KnR ( int sym;				)
{
                                                                             

    int *p ;

    for( p = Yy_synch; *p  &&  *p > 0 ; p++ )
        if( *p == sym )
             return 1;
    return 0;
}

ANSI( YYPRIVATE yy_synch( int lookahead )	)
KnR ( YYPRIVATE yy_synch( lookahead 	)	)
KnR ( int sym;					)
{
                                                                             
                                                                                
                                                                             
                                  
     
                                                                              
     	       
                                                                               
                              
                                                                             
                                                                              
      

    int    tok;

    if( ++yynerrs > YYMAXERR )
        return 0;

    while( !yy_in_synch( tok = ( *(yyp_Yy_stack + (0)) ))	&& !( (yyp_Yy_stack) >= (Yy_stack + sizeof(Yy_stack)/sizeof(*Yy_stack)) ))	       
	yy_pop();

    if( ( (yyp_Yy_stack) >= (Yy_stack + sizeof(Yy_stack)/sizeof(*Yy_stack)) ))						       
        return 0;

    while( lookahead && lookahead != tok )				       
        lookahead = yy_nextoken();

    return lookahead;
}

                                                                       
                                                                             
                                                                           
   

ANSI( int yyparse (void)	)
KnR ( int yyparse (    )	)
{
    int      *p;		                                  	    
    YY_TTYPE prod;		                                  	    
    int      lookahead;		                                 	    
    int	     errcode = 0;	                                  	    
    int	     tchar;		                                      	    
    int	     actual_lineno;	                            		    
    char     *actual_text;	                          		    
    int	     actual_leng;	                            		    
    YYSTYPE  val;		                                       	    

#   ifdef YYDEBUG
	if( !yy_init_debug( Yy_stack,  &yyp_Yy_stack,
			    Yy_dstack, &yyp_Yy_dstack,
			    Yy_vstack, sizeof(yyvstype), YYMAXDEPTH) )
	    YYABORT;

	( (yyp_Yy_dstack) = (Yy_dstack + sizeof(Yy_dstack)/sizeof(*Yy_dstack)) );
#   endif

    ( (yyp_Yy_stack) = (Yy_stack + sizeof(Yy_stack)/sizeof(*Yy_stack)) );
    Yy_vsp = Yy_vstack + YYMAXDEPTH;

    yy_push( YY_START_STATE, (Yy_vsp-1)->left );                              
						                              
						                              
    yy_init_llama( Yy_vsp );			                              
    lookahead = yy_nextoken();

    while( !( (yyp_Yy_stack) >= (Yy_stack + sizeof(Yy_stack)/sizeof(*Yy_stack)) ))
    {
        if( YY_ISACT( ( *(yyp_Yy_stack + (0)) )) )	                                
	{					                                
	    if( yytext = (char *) ii_ptext() )
	    {
		yylineno       = ii_plineno() ;
		tchar          = yytext[ yyleng = ii_plength() ];
		yytext[yyleng] = '\0' ;
	    }
	    else				                       
	    {
		yytext = "";
		yyleng = yylineno = 0;
	    }

	    if( errcode = yy_act( ( *(yyp_Yy_stack + (0)) )))
		return errcode;

	    yy_pop();
	    yy_redraw_stack();
	    if( yylineno )
		ii_ptext()[ ii_plength() ] = tchar;
	}
        else if( YY_ISTERM( ( *(yyp_Yy_stack + (0)) )))	                                
        {
            if( ( *(yyp_Yy_stack + (0)) )!= lookahead ) 	                                
            {
                yyerror( "%s expected\n", Yy_stok[ ( *(yyp_Yy_stack + (0)) )]);
                if( !(lookahead = yy_synch(lookahead)) )
		    YYABORT;
            }
            else
            {
                                                                            
		                                                           
		                                              
                   

                yy_pop();
		ii_mark_prev();

                lookahead     = yy_nextoken();
		actual_lineno = yylineno;
		actual_text   = yytext  ;
		actual_leng   = yyleng  ;
            }
        }
        else
        {
	                                                                      
	                                                                
	                                                                    
	                                                                     
	                                                                     
	                                                  
	       

            prod = yy_next( ( *(yyp_Yy_stack + (0)) )-YY_MINNONTERM, lookahead );

            if( prod == YYF )
            {
                yyerror( "Unexpected %s\n", Yy_stok[ lookahead ] );
                if( !(lookahead = yy_synch(lookahead)) )
		    YYABORT;
            }
            else
            {
		yy_say_whats_happening( ( *(yyp_Yy_stack + (0)) ), prod );
		yy_break( prod );

		val = Yy_vsp->right ;
                yy_pop();

                for( p = Yy_pushtab[ prod ] ; *p ; ++p )
                    yy_push( *p, val );
            }
        }
    }

    yylineno = actual_lineno ;	                                                
    yytext   = actual_text   ;                                                  
    yyleng   = actual_leng   ;                        			        

    yy_quit_debug();
    YYACCEPT;
}