/* This is a small prototype for the annotation system, it deliver a 
   set of llnode/bifnode for the annotation system */

%{
#include "macro.h"

#include "compatible.h"
#ifdef SYS5
#include <string.h>
#else
#include <strings.h>
#endif
#include <stdlib> 
#ifdef _NEEDALLOCAH_
#  include <alloca.h>
#endif
 
#define ON 1
#define OFF 0
#define OTHER 2
#define ID_ONLY  1
#define RANGE_APPEAR 2
#define EXCEPTION_ON 4
#define EXPR_LR      8
#define VECTOR_CONST_APPEAR 16
#define ARRAY_OP_NEED 32
#define TRACEON 0

extern POINTER newNode();

%}

%start annotation
%union { 
         int       token ;
         char      charv ;
         char      *charp;
         PTR_BFND   bfnode ;
         PTR_LLND   ll_node ;
         PTR_SYMB   symbol  ;
         PTR_TYPE   data_type ;
         PTR_HASH   hash_entry ;
         PTR_LABEL  label ;        
         PTR_BLOB   blob_ptr ;
       }

/* Begin  Token for annotation system */
/* The IfDef token */
%token IFDEFA
/* the Apply to token */
%token APPLYTO
%token ALABELT
%token SECTIONT
%token SPECIALAF
%token FROMT
%token TOT
%token TOTLABEL
%token TOFUNCTION
%token DefineANN
/* End Token for annotation system */

/* all identifiers   that are not reserved words
   and are not declared typedefs in the current block */
%token IDENTIFIER
/* all identifiers   that are declared typedefs in the current block.
   In some contexts, they are treated just like IDENTIFIER,
   but they can also serve as typespecs in declarations.  */
%token TYPENAME

/* reserved words that specify storage class.
   yylval contains an IDENTIFIER_NODE which indicates which one.  */
%token SCSPEC

/* reserved words that specify type.
   yylval contains an IDENTIFIER_NODE which indicates which one.  */
%token TYPESPEC

/* reserved words that modify type: "const" or "volatile".
   yylval contains an IDENTIFIER_NODE which indicates which one.  */
%token TYPEMOD

/*character or numeric constants.
   yylval is the node for the constant.  */
%token CONSTANT

/* String constants in raw form.
   yylval is a STRING_CST node.  */
%token STRING

/* "...", used for functions with variable arglists.  */
%token ELLIPSIS

/* the reserved words */
%token SIZEOF ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT_TOKEN
%token BREAK CONTINUE RETURN GOTO ASM
%token CLASS PUBLIC FRIEND  ACCESSWORD OVERLOAD
%token OPERATOR COBREAK COLOOP COEXEC LOADEDOPR 

%token MULTIPLEID MULTIPLETYPENAME

/* Define the operator tokens and their precedences.
   The value is an integer because, if used, it is the tree code
   to use in the expression made from the operator.  */

%left  <charv> ','
%right <charv> '='
%right <token> ASSIGN 
%right <charv> '?' ':'
%left <charv> OROR
%left <charv> ANDAND
%left <charv> '|'
%left <charv> '^'
%left <charv> '&'
%left <token> EQCOMPARE
%left <token> ARITHCOMPARE  '>' '<' 
%left <charv> LSHIFT RSHIFT
%left <charv> '+' '-'
%left <token> '*' '/' '%'
%right <token> UNARY PLUSPLUS MINUSMINUS
%left HYPERUNARY
%left <token> DOUBLEMARK 
%left <token> POINTSAT '.'


%type <token> unop
%type <hash_entry> IDENTIFIER TYPENAME  LOADEDOPR
%type <ll_node> CONSTANT STRING  primary 
%type <ll_node> expr_no_commas const_expr_no_commas  
%type <ll_node> expr nonnull_exprlist exprlist const_primary element
%type <ll_node> string
%type <token>   SCSPEC TYPESPEC TYPEMOD 
%type <ll_node> vector_constant triplet  compound_constant vector_list
%type <ll_node> single_v_expr array_expr_a 
%type <ll_node> array_expr_b expr_vector 
%type <ll_node> expr_no_commas_1  
%type <symbol>  identifier    identifiers 
%type <token> ACCESSWORD 
%type <ll_node> IfDefR
%type <ll_node> Alabel
%type <ll_node> ApplyTo
%type <ll_node> LocalDeclare
%type <ll_node> Expression_List
%type <ll_node> declare_local_list
%type <ll_node> onedeclare
%type <ll_node> domain
%type <ll_node> section
%type <ll_node> SECTIONT
%type <hash_entry> SPECIALAF

%{ char      *input_filename;	
   extern    int lastdecl_id;
   PTR_LLND ANNOTATE_NODE = NULL;
   PTR_BFND ANNOTATIONSCOPE = NULL;
   extern PTR_SYMB newSymbol();
   extern PTR_LLND newExpr();
   extern PTR_LLND makeInt();
   static int cur_counter =  0; 
   static int primary_flag=  0;
   PTR_TYPE global_int_annotation = NULL;
   extern PTR_LLND Follow_Llnd();
   static int recursive_yylex = OFF;
   static int exception_flag = 0;
   static PTR_HASH cur_id_entry;
   int line_pos_1 = 0;
   char *line_pos_fname = 0;
   static int old_line = 0;
   static int yylineno=0;
   static int yyerror();
   PTR_CMNT cur_comment = NULL;
   PTR_CMNT new_cur_comment = NULL ;
   PTR_HASH look_up();
   PTR_HASH look_up_type();
   char *STRINGTOPARSE = 0;
   int PTTOSTRINGTOPARSE = 0;
   int LENSTRINGTOPARSE = 0;
   extern PTR_LLND Make_Function_Call();
   static PTR_LLND check_array_id_format();
   static PTR_LLND look_up_section();
   extern PTR_SYMB getSymbolWithName(); /*getSymbolWithName(name, scope)*/
   PTR_SYMB Look_For_Symbol_Ann();
   char AnnExTensionNumber[255]; /* to symbole right for the annotation  */
   static int Recog_My_Token();
   static int look_up_specialfunction();
   static unMYGETC();
   static MYGETC();
   static int map_assgn_op();
%}  

%%

annotation: /* empty */
	| '[' IfDefR   Alabel   ApplyTo   LocalDeclare ';' Expression_List ']'
        { 
	  ANNOTATE_NODE = newExpr(EXPR_LIST,NULL,$2,
	                   newExpr(EXPR_LIST,NULL,$3,
			     newExpr(EXPR_LIST,NULL,$4,
				newExpr(EXPR_LIST,NULL,$5,
				   newExpr(EXPR_LIST,NULL,$7,NULL)))));
	  if (TRACEON)
	    printf("Recognized ANNOTATION\n");
	}
        | '['Expression_List  ']'
        { 
	  ANNOTATE_NODE = newExpr(EXPR_LIST,NULL,NULL,
	                   newExpr(EXPR_LIST,NULL,NULL,
			     newExpr(EXPR_LIST,NULL,NULL,
				newExpr(EXPR_LIST,NULL,NULL,
				   newExpr(EXPR_LIST,NULL,$2,NULL)))));
	   if (TRACEON) printf("Recognized ANNOTATION\n");
	};
        

IfDefR: /* empty */
        {
	  $$ = NULL; 
        }
        | IFDEFA '(' string ')'
        {
	  PTR_SYMB ids = NULL;
	  /* need a symb there, will be global later */
          ids = Look_For_Symbol_Ann (FUNCTION_NAME,"IfDef", NULL);
	  $$ = Make_Function_Call (ids,NULL,1,$3);
	  if (TRACEON) printf("Recognized IFDEFA \n");
	};

Alabel: /* empty */
        {	
	  $$ = NULL; 
        }
        | ALABELT '(' string ')'
        {
	  PTR_SYMB ids = NULL;
	  /* need a symb there, will be global later */
          ids = Look_For_Symbol_Ann (FUNCTION_NAME,"Label", NULL);
	  $$ = Make_Function_Call (ids,NULL,1,$3);
	  if (TRACEON) printf("Recognized IFDEFA \n");
	  if (TRACEON) printf("Recognized ALABEL\n");
	};

ApplyTo: /* empty */
        {
	  $$ = NULL; 
        }
        |  APPLYTO '(' section ')'
        {
	  PTR_SYMB ids = NULL;
	  /* need a symb there, will be global later */
          ids = Look_For_Symbol_Ann (FUNCTION_NAME,"ApplyTo", NULL);
	  $$ = Make_Function_Call (ids,NULL,2,$3, NULL);
	   if (TRACEON) printf("Recognized APPLYTO \n");
	}
        |  APPLYTO '(' section ')' IF expr 
        {
	  PTR_SYMB ids = NULL;
	  /* need a symb there, will be global later */
          ids = Look_For_Symbol_Ann (FUNCTION_NAME,"ApplyTo", NULL);
	  $$ = Make_Function_Call (ids,NULL,2,$3,$6);
	   if (TRACEON) printf("Recognized APPLYTO \n");
	}; 

section : SECTIONT
          { /* SECTIONT return a string_val llnd */
            $$ = $1;
          }
          | TOFUNCTION IDENTIFIER
          {
	    
            $$ =  newExpr(VAR_REF,NULL,$2);
          }
          | FROMT string TOT string
          {  
             $$ = newExpr(EXPR_LIST,NULL,$2,
	                   newExpr(EXPR_LIST,NULL,$4,NULL));
          } 
          | TOT string
          {  
             $$ = newExpr(EXPR_LIST,NULL,NULL,
	                   newExpr(EXPR_LIST,NULL,$2,NULL));
          }
          | TOTLABEL string
          {  
             $$ = $2;
          }
          ;


LocalDeclare: /* empty */
        {
	  if (TRACEON) printf("Recognized LocalDeclare\n");
	  $$ = NULL; 
        }
        | declare_local_list
        {
	  $$ = $1;
	  if (TRACEON) printf("Recognized  declare_local_list\n");
	};
/******************* Annotation Expression Stuff ****************************/ 

Expression_List: /* empty */
        {
	  $$ = NULL; 
	  if (TRACEON) printf("Recognized empty expr\n");
        }
        | SPECIALAF '(' exprlist ')'
        { /* for Key word like parallel loop and so on */
	  PTR_SYMB ids = NULL;
	  ids = Look_For_Symbol_Ann (VARIABLE_NAME, $1,global_int_annotation);
	  $$ = Make_Function_Call (ids,NULL,1,$3);
	  if (TRACEON) printf("Recognized Expression_List SPECIALAF  \n");
	}
        | IDENTIFIER '(' exprlist ')'
        { /* for Key word like parallel loop and so on */
	  PTR_SYMB ids = NULL;
	  ids = Look_For_Symbol_Ann (VARIABLE_NAME, $1,global_int_annotation);
	  $$ = Make_Function_Call (ids,NULL,1,$3);
	  if (TRACEON) printf("Recognized Expression_List SPECIALAF  \n");
	}
        | DefineANN '(' string ',' CONSTANT ')'
        { /* for Key word like parallel loop and so on */
	  PTR_SYMB ids = NULL;
	  ids = Look_For_Symbol_Ann (FUNCTION_NAME, "Define" ,global_int_annotation);
	  $$ = Make_Function_Call (ids,NULL,2,$3,$5);
	  if (TRACEON) printf("Recognized Expression_List Define  \n");
	};   


/******************** LOCAL DECLARATION **********************************/
/* for local declaration */
declare_local_list: 
         {
	  $$ = NULL; 
        }
         | onedeclare
         {
           $$ =  newExpr(EXPR_LIST,NODE_TYPE($1),$1,NULL);
	   if (TRACEON) printf("Recognized onedeclare \n");
	 } 
          | declare_local_list  ',' onedeclare
         {
	   PTR_LLND ll_ptr ;
	   ll_ptr = Follow_Llnd($1,2);               
	   NODE_OPERAND1(ll_ptr) = newExpr(EXPR_LIST,NODE_TYPE($3),$3,NULL);
	   if (TRACEON) printf("Recognized declare_local_list _inlist \n");
	   $$=$1;
	 };

onedeclare:
           TYPESPEC IDENTIFIER domain
          {
	    PTR_SYMB ids = NULL;
	    PTR_LLND expr;
            PTR_HASH p;
	    char temp1[256];
	    
	    /* need a symb there, will be global later */
            p = $2;
	    strcpy(temp1,AnnExTensionNumber);
	    strncat(temp1,p->ident,255);
	    ids = newSymbol (VARIABLE_NAME,temp1,global_int_annotation);
	    expr = newExpr(VAR_REF,global_int_annotation, ids);
	    if ($3)
	      $$ = newExpr(ASSGN_OP,global_int_annotation,expr, $3);
            else
              $$ = expr;
          };
domain: 
       {
	  $$ = NULL; 
        }
       | '=' expr_no_commas
        {
	  $$ = $2;
	};


/********************* PARSER EXPRESSION ************************/
/* Must appear precede expr for resolve precedence problem */
/* A nonempty list of identifiers.  */
identifiers:	
	IDENTIFIER
		{ 
		  /* to modify, must be check before created */
		  $$ = (PTR_SYMB) Look_For_Symbol_Ann (VARIABLE_NAME, $1, NULL); 
		  /* $$ = install_parameter($1,VARIABLE_NAME) ; */
                }
	| identifiers ',' IDENTIFIER
		{ 
		  $$ = (PTR_SYMB) Look_For_Symbol_Ann (VARIABLE_NAME, $3, NULL);
		}
	;

identifier:
	IDENTIFIER
         { $$ = (PTR_SYMB) Look_For_Symbol_Ann (VARIABLE_NAME, $1, NULL);}
	| TYPENAME
         { $$ = (PTR_SYMB) Look_For_Symbol_Ann (VARIABLE_NAME, $1, NULL); }
        ;

unop:   '-'
		{ 
                 $$ = MINUS_OP ;
	       }
	| '!'
		{ 
                 $$ = NOT_OP ;
	       }
	;


expr:	nonnull_exprlist
		{ 
                  $$ = $1 ;
                }
	;

exprlist:
	  /* empty */
		{ 
                  $$ = LLNULL ;
                }
	| nonnull_exprlist
		{ 
                  $$ = $1 ; 
                }
	;

/* modified */
nonnull_exprlist:
          expr_no_commas
		{ 
                  $$ = newExpr(EXPR_LIST,NODE_TYPE($1),$1,NULL);
                }
	| nonnull_exprlist ',' expr_no_commas
		{ PTR_LLND ll_ptr ;
                  ll_ptr = Follow_Llnd($1,2);               
                  NODE_OPERAND1(ll_ptr) = newExpr(EXPR_LIST,NODE_TYPE($3),$3,NULL);

                  $$=$1;
                }
	;

/* modified */
vector_constant : '['  ']'   %prec ','
            {     
                  $$ = newExpr(VECTOR_CONST,NULL,NULL,NULL);
                  primary_flag = VECTOR_CONST_APPEAR ;
		  /* Temporarily setting */
                  NODE_TYPE($$) = global_int_annotation ;
		}
        | '['  vector_list  ']'  %prec ','
             {   
                 $$ = newExpr(VECTOR_CONST,NULL,$2,NULL);
                  primary_flag = VECTOR_CONST_APPEAR ;
		  /* Temporarily setting */
                  NODE_TYPE($$) = global_int_annotation ;
	       }
        ;

vector_list :
        {
           $$ = NULL;
        }
        |  single_v_expr
             { 
               $$ = newExpr(EXPR_LIST,NULL,$1,NULL);
             }
        | vector_list ',' single_v_expr
             {
               PTR_LLND ll_node1 ;
               ll_node1 = Follow_Llnd($1,2);
               NODE_OPERAND1(ll_node1)= newExpr(EXPR_LIST,NULL,$3,NULL);
	       $$=$1;
	     }

        ;

/* modified */
single_v_expr :
          const_expr_no_commas
             { 
               $$ = $1;
             }
        | triplet
             { 
               $$ = $1;
             }
        | compound_constant
             { 
               $$ = $1;
             }
        |   vector_constant
                { 
                  $$ = $1 ;
                }
        ;


 element:
         CONSTANT
            { 
                  $$ = $1 ;
	    }
	| IDENTIFIER
		{ 
		  $$ = newExpr(VAR_REF, NULL,Look_For_Symbol_Ann (VARIABLE_NAME, $1, NULL));
		  exception_flag = ON ;
		}
       ;

 triplet :
          element ':' element ':' element     %prec '.'

            { PTR_LLND p1,p2 ;
              p1 =  newExpr(DDOT,NULL,$1,$3);
              p2 = newExpr(DDOT,NULL,p1,$5);
              $$ = p2 ;
	    }
         | element ':' element               %prec '.'
            { 
              $$= newExpr(DDOT,NULL,$1,$3);
	    }
        ;


compound_constant :
          CONSTANT '#' CONSTANT
           { 
             $$=  newExpr(COPY_NODE,NULL,$1,$3);
	   }

        ;
/* modified */
array_expr_a :        /* empty */
            {
	      $$ = NULL;
	    }
        | expr_no_commas_1 ':' expr_no_commas_1 ':' expr_no_commas_1  %prec ','
            { PTR_LLND p1,p2 ;
	      p1 =  newExpr(DDOT,NULL,$1,$3);
              p2 = newExpr(DDOT,NULL,p1,$5);
              $$ = p2 ;
	    }
        | expr_no_commas_1 ':' expr_no_commas_1                     %prec ','
            {
              $$= newExpr(DDOT,NULL,$1,$3);
	    }
        ;


expr_no_commas_1 :
             {
                $$ = LLNULL ;
             } 
       | expr_no_commas
           { 
                 $$ = $1 ;
           }
       ;
/* modified */
array_expr_b :  expr_no_commas '#' expr_no_commas  
        ;


/* modified */
expr_vector : expr_no_commas   /* original is expr  */
        |  array_expr_a
        ;
 
expr_no_commas:
	primary
           { 
            /* Need Another way to check this one */
            /*  if (primary_flag & EXCEPTION_ON) Message("syntax error 6"); */
             if (exception_flag == ON)  { /* Message("undefined symbol",0); */
                                          exception_flag =OFF;
                                        }
             $$=$1 ;
	   }
	| unop primary %prec UNARY
		{	
		  $$=newExpr($1,NULL,$2);
		}
	| SIZEOF expr_no_commas  %prec UNARY
		{ 
		  $$= newExpr(SIZE_OP,global_int_annotation,$2,LLNULL);
                }
	| expr_no_commas '+' expr_no_commas
		{ 
		  $$=newExpr(ADD_OP,NULL,$1,$3);
                }
	| expr_no_commas '-' expr_no_commas
		{ 
		  $$=newExpr(SUBT_OP,NULL,$1,$3);
                }
	| expr_no_commas '*' expr_no_commas
		{ 
		  $$=newExpr(MULT_OP,NULL,$1,$3);
                }
	| expr_no_commas '/' expr_no_commas
		{ 
		  $$=newExpr(DIV_OP,NULL,$1,$3);
                }
	| expr_no_commas '%' expr_no_commas
		{ 
		  $$=newExpr(MOD_OP,NULL,$1,$3);
                }
	| expr_no_commas ARITHCOMPARE expr_no_commas
		{ int op1 ;
                  op1 = ($2 == ((int) LE_EXPR)) ? LE_OP : GE_OP ;
		  $$=newExpr(op1,NULL,$1,$3);
                }
	| expr_no_commas '<'  expr_no_commas  
                { 
		  $$=newExpr(LT_OP,global_int_annotation,$1,$3);
                }
	| expr_no_commas '>'  expr_no_commas   
                { 
		  $$=newExpr(GT_OP,global_int_annotation,$1,$3);
                }
	| expr_no_commas EQCOMPARE expr_no_commas
		{ int op1 ;
                  op1 = ($2 == ((int) NE_EXPR)) ? NE_OP : EQ_OP  ;
     		  $$=newExpr(op1,global_int_annotation,$1,$3);
                }
	| expr_no_commas '&' expr_no_commas
		{ 
		  $$=newExpr(BITAND_OP,global_int_annotation,$1,$3);
                }
	| expr_no_commas '|' expr_no_commas
		{ 
		  $$=newExpr(BITOR_OP,global_int_annotation,$1,$3);
                }
	| expr_no_commas '^' expr_no_commas
		{ 
		  $$=newExpr(XOR_OP,NULL,$1,$3);
                }
	| expr_no_commas ANDAND expr_no_commas
		{ 
		  $$=newExpr(AND_OP,global_int_annotation,$1,$3);
                }
	| expr_no_commas OROR expr_no_commas
		{ 
		  $$=newExpr(OR_OP,global_int_annotation,$1,$3);
                }
	| expr_no_commas '?' expr_no_commas ':' expr_no_commas  /* expr */
		{ PTR_LLND ll_node1;
		  ll_node1=newExpr(EXPR_IF_BODY,$3,$5);
		  $$=newExpr(EXPR_IF,NULL,$1,ll_node1);
		}
	| expr_no_commas '=' expr_no_commas
		{ 
		  $$=newExpr(ASSGN_OP,NULL,$1,$3);
                }
	| expr_no_commas ASSIGN expr_no_commas
		{ int op1 ;
                  op1 = map_assgn_op($2);
		  $$=newExpr(op1,NULL,$1,$3);
                }

	;
 
const_expr_no_commas:
	const_primary
           { 
             if (exception_flag == ON)  { Message("undefined symbol",0);
                                          exception_flag =OFF;
                                        }
             $$=$1 ;
	   }
	| unop const_expr_no_commas  %prec UNARY
		{ 
		  $$=newExpr($1,NULL,$2);
                }
	| SIZEOF const_expr_no_commas  %prec UNARY
		{ 
		  $$=newExpr(SIZE_OP,NULL,$2);
                }
	| const_expr_no_commas '+' const_expr_no_commas
		{ 
		  $$=newExpr(ADD_OP,NULL,$1,$3);
                }
	| const_expr_no_commas '-' const_expr_no_commas
		{ 
		  $$=newExpr(SUBT_OP,NULL,$1,$3);
                }
	| const_expr_no_commas '*' const_expr_no_commas
		{ 
		  $$=newExpr(MULT_OP,NULL,$1,$3);
                }
	| const_expr_no_commas '/' const_expr_no_commas
		{ 
		  $$=newExpr(DIV_OP,NULL,$1,$3);
                }
	| const_expr_no_commas '%' const_expr_no_commas
		{ 
		  $$=newExpr(MOD_OP,NULL,$1,$3);
                }
	| const_expr_no_commas LSHIFT const_expr_no_commas
		{ 
		  $$=newExpr(LSHIFT_OP,NULL,$1,$3);
                }
	| const_expr_no_commas RSHIFT const_expr_no_commas
		{ 
		  $$=newExpr(RSHIFT_OP,NULL,$1,$3);
                }
	| const_expr_no_commas ARITHCOMPARE const_expr_no_commas
		{ int op1 ;
                  op1 = ($2 == ((int) LE_EXPR)) ? LE_OP : GE_OP ;
		  $$=newExpr(op1,NULL,$1,$3);
                }
	| const_expr_no_commas '<'  const_expr_no_commas  
                { 
		  $$=newExpr(LT_OP,NULL,$1,$3);
                }
	| const_expr_no_commas '>'  const_expr_no_commas   
                { 
		  $$=newExpr(GT_OP,NULL,$1,$3);
                }

	| const_expr_no_commas EQCOMPARE const_expr_no_commas
		{ int op1 ;

                  op1 = ($2 == ((int) NE_EXPR)) ? NE_OP : EQ_OP  ;
		  $$=newExpr(op1,NULL,$1,$3);
                }
	| const_expr_no_commas '&' const_expr_no_commas
		{ 
		  $$=newExpr(BITAND_OP,NULL,$1,$3);
                }
	| const_expr_no_commas '|' const_expr_no_commas
		{ 
		  $$=newExpr(BITOR_OP,NULL,$1,$3);
                }
	| const_expr_no_commas '^' const_expr_no_commas
		{ 
		  $$=newExpr(XOR_OP,NULL,$1,$3);
                }
	| const_expr_no_commas ANDAND const_expr_no_commas
		{ 
		  $$=newExpr(AND_OP,NULL,$1,$3);
                }
	| const_expr_no_commas OROR const_expr_no_commas
		{ 
		  $$=newExpr(OR_OP,NULL,$1,$3);
                }
	| const_expr_no_commas '?' expr ':' const_expr_no_commas
		{ PTR_LLND ll_node1;
		  ll_node1=newExpr(EXPR_IF_BODY,$2,$3);
		  $$=newExpr(EXPR_IF,NULL,$1,ll_node1);
		}
	| const_expr_no_commas '=' const_expr_no_commas
		{ 
		  $$=newExpr(ASSGN_OP,NULL,$1,$3);
                }
	| const_expr_no_commas ASSIGN const_expr_no_commas
		{ int op1 ;
                  op1 = map_assgn_op($2);
		  $$=newExpr(op1,NULL,$1,$3);
                }

	;


/* modified */
primary:
	IDENTIFIER
		{ PTR_SYMB symbptr;
		  symbptr = (PTR_SYMB) Look_For_Symbol_Ann (VARIABLE_NAME, $1,NULL);
		  $$ = newExpr(VAR_REF,global_int_annotation,symbptr);
		  exception_flag = ON ;
		}
	| CONSTANT
                { 
                  $$ = $1 ;
                }
	| string
		{ 
                  $$ = $1 ;    
                }
	| '(' expr ')'
		{ 
                  primary_flag = EXPR_LR ;
                  $$ = $2 ;
                }

	| '(' error ')'
           {
	     $$ = NULL;
	   }
        |   vector_constant       %prec '.'
           {
	     $$ = $1;
	   }
	| primary '('  
                {  PTR_SYMB symb;

                   if (exception_flag == ON)
		    {
                      /* strange behavior for default function */
		      symb = NODE_SYMB($1);
		      SYMB_CODE(symb) = FUNCTION_NAME;
                      exception_flag = OFF ;
                      $<ll_node>$ =  Make_Function_Call (symb,NULL,0,NULL);
                     }
                   else
                      $<ll_node>$ = $1 ;
		 }

          exprlist ')'   %prec '.'
		{ PTR_LLND lnode_ptr ,llp ;
                  int      status;

                  llp = $<ll_node>3 ;
                  status = OFF ;
                  if ((llp->variant == FUNC_CALL) && (!llp->entry.Template.ll_ptr1))
                      { 
                         lnode_ptr = llp;
                         status = FUNC_CALL ;
		       }
                  if ((!status) &&((llp->variant == RECORD_REF)||
				   (llp->variant == POINTST_OP)))
		    {
                       lnode_ptr = llp->entry.Template.ll_ptr2;
		       if ((lnode_ptr)&&(lnode_ptr->variant== FUNCTION_REF))
			 {
                           lnode_ptr->variant = FUNC_CALL;
			 }
                       status = FUNC_CALL ;
		     }
                  if ((!status) &&(llp->variant== FUNCTION_REF))
		    {  llp->variant = FUNC_CALL ;
                       status = FUNC_CALL ;
		       lnode_ptr = llp;
		     }
		  if (!status) {
                       status = FUNCTION_OP;
		       lnode_ptr = llp;
		     }
                  switch (status) {
                  case FUNCTION_OP : $$ =newExpr(FUNCTION_OP,$<ll_node>3,$4);
                                     $$->type = $<ll_node>3->type ;
                                     break;
                  case FUNC_CALL :   lnode_ptr->entry.Template.ll_ptr1=$4;
                                     $$ = $<ll_node>3 ;
                                     break;
	          default :        Message("system error 10",0);
		  }
		}

	| primary '[' expr_vector ']'   %prec '.'
	   { int status ;
             PTR_LLND ll_ptr,lp1;

             ll_ptr = check_array_id_format($1,&status);
             switch (status) {
             case NO : Message("syntax error ",0);
                       break ;
	     case ARRAY_OP_NEED:
                       lp1 = newExpr(EXPR_LIST,NULL,$3,LLNULL);/*mod*/
                       $$ = newExpr(ARRAY_OP,NULL,$1,lp1);
                       break;
             case ID_ONLY :
                       ll_ptr->variant = ARRAY_REF ;
                       ll_ptr->entry.Template.ll_ptr1 = newExpr(EXPR_LIST,NULL,$3,LLNULL);
                       $$ = $1 ;
                       break;
             case RANGE_APPEAR :
	               ll_ptr->entry.Template.ll_ptr2 = newExpr(EXPR_LIST,NULL,$3,LLNULL);
 	               $$ = $1 ; 
                       break;
             }
/*             $$->type = adjust_deref_type($1->type,DEREF_OP);*/
           }
	| primary PLUSPLUS
		{ 
                  $$ = newExpr(PLUSPLUS_OP,NULL,LLNULL,$1);
		  $$->type = $1->type ;
                }
	| primary MINUSMINUS
		{ 
                  $$ = newExpr(MINUSMINUS_OP,NULL,LLNULL,$1);
		  $$->type = $1->type ;
		}
	;




/* modified */
const_primary:

          CONSTANT
                { 
                  $$ = $1 ;    
                }
	| '(' const_expr_no_commas ')'
		{ 
                  primary_flag =EXPR_LR ;
                  $$ = $2 ;
                }

	| '(' error ')'
           {
	     $$ = NULL;
	   }          
	| const_primary PLUSPLUS
		{ 
                  $$ = newExpr(PLUSPLUS_OP,NULL,LLNULL,$1);
                }
	| const_primary MINUSMINUS
		{ 
                  $$ = newExpr(MINUSMINUS_OP,NULL,LLNULL,$1);
		}
	;

/* Produces a STRING_CST with perhaps more STRING_CSTs chained onto it.  */
string:
	  STRING
            { 
              $$ = $1 ;
            }
	| string STRING
	;

%%
int lineno;			/* current line number in file being read */

/* comments structure */
#define MAX_COMMENT_SIZE  1024 
char    comment_buf[MAX_COMMENT_SIZE + 2];  /* OFFSET '2' to avoid boundary */
int     comment_cursor = 0;
int     global_comment_type;


/*************************************************************************
 *                                                                       *
 *                      lexical analyzer                                 * 
 *                                                                       *
 *************************************************************************/

static int maxtoken;		/* Current length of token buffer */
static char *token_buffer;	/* Pointer to token buffer */
static int previous_value ;     /* last token to be remembered */

/* frw[i] is index in rw of the first word whose length is i. */

#define MAXRESERVED 9

/*static char frw[10] =
  { 0, 0, 0, 2, 6, 14, 22, 34, 39, 44 };*/
static char frw[10] =
{ 0, 0, 0, 2, 5, 13, 21, 32, 37, 41 };

static char *rw[] =
  { "if", "do", 
    "int", "for", "asm",
    "case", "char", "auto", "goto", "else", "long", "void", "enum",
    "float", "short", "union", "break", "while", "const",  "IfDef","Label",
    "double", "static", "extern", "struct", "return", "sizeof", "switch", "signed","coexec","coloop","friend",
    "typedef", "default","private","cobreak", "ApplyTo",
    "unsigned", "continue", "register", "volatile","operator"};

static short rtoken[] =
  { IF, DO, 
    TYPESPEC, FOR, ASM,
    CASE, TYPESPEC, SCSPEC, GOTO, ELSE, TYPEMOD, TYPESPEC, ENUM,
    TYPESPEC, TYPEMOD, UNION, BREAK, WHILE, TYPEMOD,  IFDEFA, ALABELT,
    TYPESPEC, SCSPEC, SCSPEC, STRUCT, RETURN, SIZEOF, SWITCH, TYPEMOD,COEXEC,COLOOP,FRIEND,
    SCSPEC, DEFAULT_TOKEN,ACCESSWORD,COBREAK, APPLYTO,
    TYPEMOD, CONTINUE, SCSPEC, TYPEMOD,OPERATOR};

/* This table corresponds to rw and rtoken.
   Its element is an index in ridpointers  */

#define NORID RID_UNUSED

static enum rid rid[] =
  { NORID, NORID, 
    RID_INT, NORID, NORID,
    NORID, RID_CHAR, RID_AUTO, NORID, NORID, RID_LONG, RID_VOID, NORID,
    RID_FLOAT, RID_SHORT, NORID, NORID, NORID, RID_CONST, NORID, NORID,
    RID_DOUBLE, RID_STATIC, RID_EXTERN, NORID, NORID, NORID, NORID, RID_SIGNED,NORID,NORID,NORID,
    RID_TYPEDEF, NORID,RID_PRIVATE,NORID, NORID,
    RID_UNSIGNED, NORID, RID_REGISTER, RID_VOLATILE,NORID};

/* The elements of `ridpointers' are identifier nodes
   for the reserved type names and storage classes.  
tree ridpointers[(int) RID_MAX];
static tree line_identifier;    The identifier node named "line" */


void
init_lex ()
{
  //extern char *malloc();

  /* Start it at 0, because check_newline is called at the very beginning
     and will increment it to 1.  */
  lineno = 0;
  maxtoken = 40;
  lastdecl_id = 0;
  token_buffer = (char *) xmalloc((unsigned)(maxtoken+1));
}

static void
reinit_parse_for_function ()
{
}

/* Put char into comment buffer. When the buffer is full, we make a comment */
/* structure and reset the comment_cursor. */
static int
put_char_buffer(c,sw)
char c ;
int sw;
{
/* no comment here */
return 0;
}

static int
skip_white_space(type)
  int type ;
{
  register int c;


  c = MYGETC();

  for (;;)
    {
      switch (c)
	{
	case '/':
	   return '/';	

	case '\n':
	case ' ':
	case '\t':
	case '\f':
	case '\r':
	case '\b':
	  c = MYGETC();
	  break;

	case '\\':
	  c = MYGETC();
	  if (c == '\n')
	    lineno++;
	  else
	    yyerror("stray '\\' in program");
	  c = MYGETC();
	  break;

	default:
	  return (c);
	}
    }
}

/* Take care of the comments in the tail of the source code */
static int
skip_white_space_2()
{
  register int c;

  c = MYGETC();
  for (;;)
    {
      switch (c)
	{
	case '/':
	  return '/';
	case '\n':
           return(c);

	case ' ':
	case '\t':
	case '\f':
	case '\r':
	case '\b':
	  c = MYGETC();
	  break;

	case '\\':
	  c = MYGETC();
	  if (c == '\n')
	    lineno++;
	  else
	    yyerror("stray '\\' in program");
	  c = MYGETC();
	  break;

	default:
	  return (c);
	}
    }
}



/* make the token buffer longer, preserving the data in it.
p should point to just beyond the last valid character in the old buffer
and the value points to the corresponding place in the new one.  */

static char *
extend_token_buffer(p)
char *p;
{
  register char *newbuf;
  register char *value;
  int newlength = maxtoken * 2 + 10;
  register char *p2, *p1;
  extern char *malloc();

  newbuf = malloc((unsigned)(newlength+1));

  p2 = newbuf;
  p1 = newbuf + newlength + 1;
  while (p1 != p2) *p2++ = 0;

  value = newbuf;
  p2 = token_buffer;
  while (p2 != p)
   *value++ = *p2++;

  token_buffer = newbuf;

  maxtoken = newlength;

  return (value);
}




#define isalnum(char) ((char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9'))
#define isdigit(char) (char >= '0' && char <= '9')
#define ENDFILE -1  /* token that represents end-of-file */
#define isanop(d) ((d == '+') || (d == '-') || (d == '&') || (d == '|') || (d == '<') || (d == '>') || (d == '*') || (d == '/') || (d == '%') || (d == '^') || (d == '!') || (d == '=') )


int
readescape ()
{
  register int c = MYGETC ();
  register int count, code;

  switch (c)
    {
    case 'x':
      code = 0;
      count = 0;
      while (1)
	{
	  c = MYGETC ();
	  if (!(c >= 'a' && c <= 'f')
	      && !(c >= 'A' && c <= 'F')
	      && !(c >= '0' && c <= '9'))
	    {
	      unMYGETC (c);
	      break;
	    }
	  if (c >= 'a' && c <= 'z')
	    c -= 'a' - 'A';
	  code *= 16;
	  if (c >= 'a' && c <= 'f')
	    code += c - 'a' + 10;
	  if (c >= 'A' && c <= 'F')
	    code += c - 'A' + 10;
	  if (c >= '0' && c <= '9')
	    code += c - '0';
	  count++;
	  if (count == 3)
	    break;
	}
      if (count == 0)
	yyerror ("\\x used with no following hex digits");
      return code;

    case '0':  case '1':  case '2':  case '3':  case '4':
    case '5':  case '6':  case '7':
      code = 0;
      count = 0;
      while ((c <= '7') && (c >= '0') && (count++ < 3))
	{
	  code = (code * 8) + (c - '0');
	  c = MYGETC ();
	}
      unMYGETC (c);
      return code;

    case '\\': case '\'': case '"':
      return c;

    case '\n':
      lineno++;
      return -1;

    case 'n':
      return c ;  /*     return TARGET_NEWLINE; */

    case 't':
      return c;  /*      return TARGET_TAB; */

    case 'r':
      return c;/*      return TARGET_CR; */

    case 'f':
      return c;/*       return TARGET_FF;*/

    case 'b':
      return c;/*       return TARGET_BS;*/

    case 'a':
      return c; /*      return TARGET_BELL;*/

    case 'v':
      return c; /*      return TARGET_VT;*/
    }
  return c;
}

 
int
yylex()
{
  register int c;
  register char *p;
  register int value;
  int low /*,high */ ;
  char *str1 ;
/*  double  ddval ; */
/*  int type; */
  int c3;



  if (recursive_yylex == OFF) new_cur_comment = (PTR_CMNT) NULL ;

  /* line_pos_1 = lineno +1 ; */
  c = skip_white_space(FULL);
  /*  yylloc.first_line = lineno;*/

  switch (c)
    {
    case EOF:
      value = ENDFILE; break;

    case 'A':  case 'B':  case 'C':  case 'D':  case 'E':
    case 'F':  case 'G':  case 'H':  case 'I':  case 'J':
    case 'K':  case 'L':  case 'M':  case 'N':  case 'O':
    case 'P':  case 'Q':  case 'R':  case 'S':  case 'T':
    case 'U':  case 'V':  case 'W':  case 'X':  case 'Y':
    case 'Z':
    case 'a':  case 'b':  case 'c':  case 'd':  case 'e':
    case 'f':  case 'g':  case 'h':  case 'i':  case 'j':
    case 'k':  case 'l':  case 'm':  case 'n':  case 'o':
    case 'p':  case 'q':  case 'r':  case 's':  case 't':
    case 'u':  case 'v':  case 'w':  case 'x':  case 'y':
    case 'z':
    case '_':

      p = token_buffer;
      while (isalnum(c) || (c == '_') || (c == '~'))
	{
	  if (p >= token_buffer + maxtoken)
	    p = extend_token_buffer(p);
	  *p++ = c;
	  c = MYGETC();
	}

      *p = 0;
      unMYGETC(c);

      value = IDENTIFIER;


      if (p - token_buffer <= MAXRESERVED)
	{
	  register int lim = frw [p - token_buffer + 1];
	  register int i;

	  for (i = frw[p - token_buffer]; i < lim; i++)
	    if (rw[i][0] == token_buffer[0] && !strcmp(rw[i], token_buffer))
	      {
		if (rid[i])
		  yylval.token = (int) rid[i] ;
                  value = (int) rtoken[i];
		break;
	      }
	}

      { int temp;
	if ((temp = Recog_My_Token(token_buffer)) != -1)
	  {
	    yylval.token = temp;
	    value = temp;
	  }
      }

      if (value == IDENTIFIER)
	{ int t_status ;
	  PTR_LLND temp;
	/* temp move it out */

          yylval.hash_entry = look_up_type(token_buffer,&t_status);
          /* if ((t_status)&&(lastdecl_id ==0))   value = TYPENAME;    
	     Wait to fix that */
	  /* temporary fix */
           temp = look_up_section(token_buffer);
          if (temp)
	    {
	      yylval.ll_node = temp;
	      value = SECTIONT;
	    }

	  if (look_up_specialfunction(token_buffer))
	    {
	      value =  SPECIALAF;
	    }
	      
	  
        }

      break;

    case '0':  case '1':  case '2':  case '3':  case '4':
    case '5':  case '6':  case '7':  case '8':  case '9':
    case '.':
      {
	int base = 10;
	int count = 0;
	int largest_digit = 0;
	/* for multi-precision arithmetic,
	   we store only 8 live bits in each short,
	   giving us 64 bits of reliable precision */
	short shorts[8];
	int floatflag = 0;  /* Set 1 if we learn this is a floating constant */

	for (count = 0; count < 8; count++)
	  shorts[count] = 0;

	p = token_buffer;
	*p++ = c;

	if (c == '0')
	  {
	    *p++ = (c = MYGETC());
	    if ((c == 'x') || (c == 'X'))
	      {
		base = 16;
		*p++ = (c = MYGETC());
	      }
	    else
	      {
		base = 8;
	      }
	  }

	while (c == '.'
	       || (isalnum (c) && (c != 'l') && (c != 'L')
		   && (c != 'u') && (c != 'U')
		   && (!floatflag || ((c != 'f') && (c != 'F')))))
	  {
	    if (c == '.')
	      {
		if (base == 16)
		  yyerror ("floating constant may not be in radix 16");
		floatflag = 1;
		base = 10;
		*p++ = c = MYGETC ();
		/* Accept '.' as the start of a floating-point number
		   only when it is followed by a digit.
		   Otherwise, unread the following non-digit
		   and use the '.' as a structural token.  */
		if (p == token_buffer + 2 && !isdigit (c))
		  {
		    if (c == '.')
		      {
			c = MYGETC ();
			if (c == '.')
			  { 
                            value = ELLIPSIS ;
			    goto done ;
                          }
			yyerror ("syntax error");
		      }
		    unMYGETC (c);
		    value = '.';
                    goto done;
		  }
	      }
	    else
	      {
		if (isdigit(c))
		  {
		    c = c - '0';
		  }
		else if (base <= 10)
		  {
		    if ((c&~040) == 'E')
		      {
			if (base == 8)
			  yyerror ("floating constant may not be in radix 8");
			base = 10;
			floatflag = 1;
			break;   /* start of exponent */
		      }
		    yyerror ("nondigits in number and not hexadecimal");
		    c = 0;
		  }
		else if (c >= 'a')
		  {
		    c = c - 'a' + 10;
		  }
		else
		  {
		    c = c - 'A' + 10;
		  }
		if (c >= largest_digit)
		  largest_digit = c;
	    
		for (count = 0; count < 8; count++)
		  {
		    (shorts[count] *= base);
		    if (count)
		      {
			shorts[count] += (shorts[count-1] >> 8);
			shorts[count-1] &= (1<<8)-1;
		      }
		    else shorts[0] += c;
		  }
    
		*p++ = (c = MYGETC());
	      }
	  }

	if (largest_digit >= base)
	  yyerror ("numeric constant contains digits beyond the radix");

	/* Remove terminating char from the token buffer and delimit the string */
	*--p = 0;

	if (floatflag)
	  {
	   /*  enum rid type = DOUBLE_TYPE_CONST ; */

	    /* Read explicit exponent if any, and put it in tokenbuf.  */

	    if ((c == 'e') || (c == 'E'))
	      {
		*p++ = c;
		c = MYGETC();
		if ((c == '+') || (c == '-'))
		  {
		    *p++ = c;
		    c = MYGETC();
		  }
	        while (isdigit(c))
		  {
		    *p++ = c;
		    c = MYGETC();
		  }
	      }

	    *p = 0;

	    while (1)
	      {
/*		if (c == 'f' || c == 'F')
		  type = FLOAT_TYPE_CONST ;
		else if (c == 'l' || c == 'L')
		  type = LONG_DOUBLE_TYPE_CONST ;
		else */

                if((c != 'f') && (c != 'F') && (c != 'l') && (c !='L'))
		  {
		    if (isalnum (c))
		      {
			yyerror ("garbage at end of number");
			while (isalnum (c))
			  c = MYGETC ();
		      }
		    break;
		  }
		c = MYGETC ();
	      }

	    unMYGETC(c);

/*	    ddval = build_real_from_string (token_buffer, 0);  */
            str1= (char *) copys(token_buffer);
            yylval.ll_node = newExpr(FLOAT_VAL,NULL,LLNULL,LLNULL,str1);

	  }
	else
	  {
	    /* enum rid  type; */

	    /* int spec_unsigned = 0; */
	    /* int spec_long = 0;  */

	    while (1)
	      {
/*		if (c == 'u' || c == 'U')
		  {
		    spec_unsigned = 1;
		  }
		else if (c == 'l' || c == 'L')
		  {
		    spec_long = 1;
		  }
		else */

               if((c != 'u') && (c != 'U') && (c != 'l') && (c != 'L'))
		  {
		    if (isalnum (c))
		      {
			yyerror ("garbage at end of number");
			while (isalnum (c))
			  c = MYGETC ();
		      }
		    break;
		  }
		c = MYGETC ();
	      }

	    unMYGETC (c);

	    /* This is simplified by the fact that our constant
	       is always positive.  */

	    low= (shorts[3]<<24) + (shorts[2]<<16) + (shorts[1]<<8) + shorts[0] ;
	  /*  high = (shorts[7]<<24) + (shorts[6]<<16) + (shorts[5]<<8) + shorts[4] ; */
	    

	    /* type = LONG_UNSIGNED_TYPE_CONST ; */
	    yylval.ll_node = makeInt(low);	
	 }

	value = CONSTANT; break;
      }

    case '\'':
      c = MYGETC();
      {

      tryagain:

	if (c == '\\')
	  {
	    c = readescape ();
	    if (c < 0)
	      goto tryagain;
	  }
	else if (c == '\n')
	  {
	      Message ("ANSI C forbids newline in character constant",0);
	    lineno++;
	  }

	c3= c;

	c = MYGETC ();
	if (c != '\'')
	  yyerror("malformatted character constant");
        yylval.ll_node = newExpr(CHAR_VAL,LLNULL,LLNULL,low);
	yylval.ll_node->entry.cval = c3;  
	value = CONSTANT; break;
      }

    case '"':
      {
	c = MYGETC();
	p = token_buffer;

	while (c != '"')
	  {
	    if (c == '\\')
	      {
                /* New Added Three lines */
                if (p == token_buffer + maxtoken)
	          p = extend_token_buffer(p);
  	        *p++ = c;

		c = readescape ();
		if (c < 0)
		  goto skipnewline;
	      }
	    else if (c == '\n')
	      {
		  Message ("ANSI C forbids newline in string constant",0);
		lineno++;
	      }

	    if (p == token_buffer + maxtoken)
	      p = extend_token_buffer(p);
	    *p++ = c;

	  skipnewline:
	    c = MYGETC ();
	  }

	*p++ = 0;

	str1= (char *) copys(token_buffer);
        yylval.ll_node = (PTR_LLND) newNode(STRING_VAL);
	NODE_STRING_POINTER(yylval.ll_node) = str1;
	value = STRING; break;
      }
      
    case '+':
    case '-':
    case '&':
    case '|':
    case '<':
    case '>':
    case '*':
    case '/':
    case '%':
    case '^':
    case '!':
    case '=':
      {
	register int c1;
        if ( previous_value == OPERATOR )
           {
             p = token_buffer;
             while (isanop(c) )
              {
                  if (p >= token_buffer + maxtoken)
	          p = extend_token_buffer(p);
	          *p++ = c;
	          c = MYGETC();
               }
             *p = 0;
             unMYGETC(c);
             value =  LOADEDOPR ;
             yylval.hash_entry = look_up(token_buffer);
             break;
            }
      combine:

	switch (c)
	  {
	  case '+':
	    yylval.token = (int) PLUS_EXPR; break;
	  case '-':
	    yylval.token = (int) MINUS_EXPR; break;
	  case '&':
	    yylval.token = (int) BIT_AND_EXPR; break;
	  case '|':
	    yylval.token = (int) BIT_IOR_EXPR; break;
	  case '*':
	    yylval.token = (int) MULT_EXPR; break;
	  case '/':
	    yylval.token = (int) TRUNC_DIV_EXPR; break;
	  case '%':
	    yylval.token = (int) TRUNC_MOD_EXPR; break;
	  case '^':
	    yylval.token = (int) BIT_XOR_EXPR; break;
	  case LSHIFT:
	    yylval.token = (int) LSHIFT_EXPR; break;
	  case RSHIFT:
	    yylval.token = (int) RSHIFT_EXPR; break;
	  case '<':
	    yylval.token = (int) LT_EXPR; break;
	  case '>':
	    yylval.token = (int) GT_EXPR; break;
	  }	

	c1 = MYGETC();

	if (c1 == '=')
	  {
	    switch (c)
	      {
	      case '<':
		value = ARITHCOMPARE; yylval.token = (int) LE_EXPR; goto done;
	      case '>':
		value = ARITHCOMPARE; yylval.token = (int) GE_EXPR; goto done;
	      case '!':
		value = EQCOMPARE; yylval.token = (int) NE_EXPR; goto done;
	      case '=':
		value = EQCOMPARE; yylval.token = (int) EQ_EXPR; goto done;
	      }	
	    value = ASSIGN; goto done;
	  }
	else if (c == c1)
	  switch (c)
	    {
	    case '+':
	      value = PLUSPLUS; goto done;
	    case '-':
	      value = MINUSMINUS; goto done;
	    case '&':
	      value = ANDAND; goto done;
	    case '|':
	      value = OROR; goto done;
/* testing  */
/*            case ':':
              value = DOUBLEMARK; goto done;  */

	    case '<':
	      c = LSHIFT;
	      goto combine;
	    case '>':
	      c = RSHIFT;
	      goto combine;
	    }
	else if ((c == '-') && (c1 == '>'))
	  { value = POINTSAT; goto done; }
	unMYGETC (c1);


        value = c;
	goto done;
      }

    default:
      value = c;
    }

done:

  if (recursive_yylex == OFF) {
    previous_value = value ;
    line_pos_1 = lineno ;
    c = skip_white_space_2();
    if (c != '\n');
       unMYGETC(c);
    if (value != '}') 
      { c = skip_white_space(NEXT_FULL);
	if (c == '\n') lineno++ ;
	else           unMYGETC(c);
      }
    set_up_momentum(value,yylval.token);
    automata_driver(value);
    cur_counter++;
    old_line = yylineno  ;
    yylineno = line_pos_1;
  }

  if (TRACEON) printf("yylex returned %d\n", value);
  return (value);
}
 

static int yyerror(s)
        char   *s;
{
  /* Message(s,0); empty at the moment, generate false error report?
     to be modified later */
  return 1;  /* PHB needed a return val, 1 seems ok */
}


/*  primary :- primary [ expr_vector ]
 *  <1> check the LHS format
 *  <2> return : NO if incorrect format at LHS
 *               ID_ONLY if LHS only have id format (including multiple id)
 *               RANGE_APPEAR if LHS format owns both id and range_list
 */

static
PTR_LLND check_array_id_format(ll_ptr,state)
int *state;
PTR_LLND ll_ptr ;

{   PTR_LLND temp,temp1;

      temp = ll_ptr;
      switch (NODE_CODE(ll_ptr)) {
      case VAR_REF :
                     *state = ID_ONLY ;
                     return(ll_ptr);
      case ARRAY_REF :
                     temp1 = Follow_Llnd(NODE_OPERAND0(ll_ptr),2);
                     *state = RANGE_APPEAR;
                     return(temp1);
      case  ARRAY_OP:temp1 = Follow_Llnd(NODE_OPERAND1(ll_ptr),2);
                     *state =RANGE_APPEAR ;
                     return(temp1);
        default :    *state = ARRAY_OP_NEED ;
                     return(temp);
      }
  }

static
int
map_assgn_op(value)
int value;
{
  switch (value) {
  case ((int) PLUS_EXPR) :
      return(PLUS_ASSGN_OP);
  case ((int) MINUS_EXPR):
      return(MINUS_ASSGN_OP);
  case ((int) BIT_AND_EXPR):
      return(AND_ASSGN_OP);
  case ((int) BIT_IOR_EXPR):
      return(IOR_ASSGN_OP);
  case ((int) MULT_EXPR):
      return(MULT_ASSGN_OP);
  case ((int) TRUNC_DIV_EXPR):
      return(DIV_ASSGN_OP);
  case ((int) TRUNC_MOD_EXPR):
      return(MOD_ASSGN_OP);
  case ((int) BIT_XOR_EXPR):
      return(XOR_ASSGN_OP);
  case ((int) LSHIFT_EXPR):
      return(LSHIFT_ASSGN_OP);
  case ((int) RSHIFT_EXPR):
      return(RSHIFT_ASSGN_OP);
  }
return 0;
}

PTR_HASH 
look_up_type(st, ip)
     char *st;
     int *ip;
{
  char *pt;
  
  pt =  (char *) xmalloc(strlen(st) +1);
  strcpy(pt,st);
 /* dummy, to be cleaned */
  return (PTR_HASH) pt;
}


PTR_HASH 
look_up(st)
     char *st;
{
  char *pt;
  
  pt =  (char *)  xmalloc(strlen(st) +1);
  strcpy(pt,st);
 /* dummy, to be cleaned */
  return (PTR_HASH)  pt;
}

static
MYGETC()
{
  
  if (LENSTRINGTOPARSE <= PTTOSTRINGTOPARSE)
	return EOF;

  if (STRINGTOPARSE[ PTTOSTRINGTOPARSE] == '\0')
    {
      PTTOSTRINGTOPARSE++;
      return EOF;
    }
  
  PTTOSTRINGTOPARSE++;
  return STRINGTOPARSE[ PTTOSTRINGTOPARSE-1];
}

static
unMYGETC(c)
char c;
{
  if (LENSTRINGTOPARSE <= PTTOSTRINGTOPARSE)
    return EOF;

  if (PTTOSTRINGTOPARSE >0)
    PTTOSTRINGTOPARSE --;
  STRINGTOPARSE[ PTTOSTRINGTOPARSE] = c;
  return c;
}


/* CurrentScope should be the last in the list */
static char *sectionkeyword[] =
  { "NextStmt",
    "NextAnnotation",      
    "EveryWhere",
    "Follow",
/* keep it last*/  "CurrentScope"};


static PTR_LLND
look_up_section(str)
 char *str;
{ int i;
  PTR_LLND pt = NULL;

  for (i = 0; i < RID_MAX; i++)
    {
      if (strcmp(sectionkeyword[i], str) == 0)
	{
	  pt  = (PTR_LLND) newNode(STRING_VAL);
	  NODE_STRING_POINTER(pt) = (char *) xmalloc(strlen(str) +1);
	  strcpy(NODE_STRING_POINTER(pt),str);
	  return pt;
	}
      if (strcmp(sectionkeyword[i],"CurrentScope") == 0)
	return NULL;
    }
  
  return NULL;
}


/* Dummy should be the last in the list */
static char *specialfunction[] =
  { "ListOfAn",
    "Align",
    "Induction",
    "Used",
    "Modified",
    "Alias",
    "Permutation",
    "Assert",
/* keep it last*/  "Dummy"};

static int
look_up_specialfunction(str)
 char *str;
{ int i;

  for (i = 0; i < RID_MAX; i++)
    {
      if (strcmp(specialfunction[i], str) == 0)
	{
	  return TRUE;
	}
      if (strcmp(specialfunction[i],"Dummy") == 0)
	return NULL;
    }
  
  return NULL;
}


static int 
Recog_My_Token(str)
char *str;
{

  if (strcmp("FromAnn",str) == 0)
    return FROMT;

  if (strcmp("ToAnn",str) == 0)
    return TOT;

   if (strcmp("ToLabel",str) == 0)
    return TOTLABEL;

  if (strcmp("ToFunction",str) == 0)
    return TOFUNCTION;

  if (strcmp("Define",str) == 0)
    return DefineANN;

  return -1;
}


PTR_SYMB
Look_For_Symbol_Ann(code,name,type)
     int code;
     char *name;
     PTR_TYPE type;
{
  PTR_SYMB symb;
  char temp1[256];

  strcpy(temp1, AnnExTensionNumber);
  strncat(temp1,name,255);

  if ((symb = getSymbolWithName(temp1, ANNOTATIONSCOPE)))
    return symb;

  if ((symb = getSymbolWithName(name, ANNOTATIONSCOPE)))
    return symb;

  return  newSymbol (code,name,type);
}