%{
#include <stdio.h>
#include <malloc.h>
#undef YY_INPUT

#ifndef YYWRAP
#	define YYWRAP
int yywrap()	{return 1;}
#endif


extern int PortType;
extern int InitVal;
extern int EdgeSymbol;
extern int CSSymbol;
extern int useUpperCase;

#define YY_INPUT(buf,result,max_size) \
	{ \
	int c = getChar(); \
	result = (c == 0) ? YY_NULL : (buf[0] = c, 1); \
	}

#include "BeIf.h"
#include "vsyn.h"
#include "veriext.h"

typedef struct StateData	{
	int State;
	struct StateData *Prev,*Next;
	}StateData;

static StateData *StateList=NULL,*LastState=NULL;
void PushState(int State);
int PopState();
static int MultiLineComment=0;
static int CurrentState=INITIAL;
void ChangeToState(int NewState);
int GetCurrentState();
void BeginState(char *NewState);



void LexFreeBuffer()
{
  if (yy_current_buffer) {
    yy_delete_buffer(yy_current_buffer);
  }
  yy_current_buffer = 0;
}

%}

%s MCOMMENT
%s SCOMMENT
%s IN_STRING
%s SPECIFY_BLOCK
%s CS_TABLE
%s CONSTANT_ONLY
%s INITIALU
%s SPECIFY_BLOCKU
%s IN_HIER


NL			\n
WS			[ \t\r\b\f]
Digit			[0-9]
DigitU			[0-9_]
Letter			[a-zA-Z]
LetterU			[a-zA-Z_]
WordNum			[0-9a-zA-Z]
WordNumU		[0-9a-zA-Z_]
DWordNumU		[$0-9a-zA-Z_]
WSs			{WS}+
Number			{Digit}{DigitU}*
Word			{LetterU}{WordNumU}*
DWord			{LetterU}{DWordNumU}*
Binary			({Number})?[ \t]*'[bB][ \t]*[01xXzZ?][01xXzZ?_]*
Octal			({Number})?[ \t]*'[oO][ \t]*[0-7xXzZ?][0-7xXzZ?_]*
Decimal			({Number})?[ \t]*'[dD][ \t]*{Number}
Hexdecimal		({Number})?[ \t]*'[hH][ \t]*[0-9a-fA-FxXzZ?][0-9a-fA-FxXzZ?_]*
Simpreal		{Number}[.]({Number})?
Real0			{Number}[eE][+-]?{Number}
Real1			{Simpreal}[eE][+-]?{Simpreal}
Real2			{Number}[eE][+-]?{Simpreal}
Real3			{Simpreal}[eE][+-]?{Number}
QoutedString		\"[^"\n]*["{NL}]
Comment			"//"[^\n]*{NL}



%%

<INITIALU,INITIAL,CS_TABLE,SPECIFY_BLOCK>{NL}           {  }
<INITIALU,INITIAL,CS_TABLE,SPECIFY_BLOCK>{WSs}		{  }
<INITIALU,INITIAL,CS_TABLE>"//"      { 
					PushState(GetCurrentState());
					ChangeToState(SCOMMENT); 
					}
<INITIALU,INITIAL,CS_TABLE>"/*"           { 
					PushState(GetCurrentState());
					MultiLineComment++;
					ChangeToState(MCOMMENT);  
					}


	/*
	 * Symbols.
	 */


	/* Generic. */
<INITIALU,INITIAL>"#"	{ 
  ChangeToState(CONSTANT_ONLY); return '#';
}

<INITIALU,INITIAL>"@"	{
  return '@';
}

	/* Unary. */
<INITIALU,INITIAL>"+"  { 
  yylval.num = BEIF_EXPR_NODE_TYPE_UPLUS; return '+';
}
<INITIALU,INITIAL>"-"  { 
  yylval.num = BEIF_EXPR_NODE_TYPE_UMINUS; return '-';
}
<INITIALU,INITIAL>"!"  { 
  yylval.num = BEIF_EXPR_NODE_TYPE_ULNOT; return '!';
}
<INITIALU,INITIAL>"~"  { 
  yylval.num = BEIF_EXPR_NODE_TYPE_UBNOT; return '~';
}
<INITIALU,INITIAL>"&"  {
  yylval.num = BEIF_EXPR_NODE_TYPE_URAND; return '&';
}
<INITIALU,INITIAL>"~&" {
  yylval.num = BEIF_EXPR_NODE_TYPE_UBNOT; return TILDEAMPER;
}
<INITIALU,INITIAL>"|"  {
  yylval.num = BEIF_EXPR_NODE_TYPE_UOR; return '|';
}
<INITIALU,INITIAL>"~|" {
  yylval.num = BEIF_EXPR_NODE_TYPE_URNAND; return TILDEVERTBAR;
}
<INITIALU,INITIAL>"^"  {
  yylval.num = BEIF_EXPR_NODE_TYPE_URXOR; return '^';
}
<INITIALU,INITIAL>"~^" {
  yylval.num = BEIF_EXPR_NODE_TYPE_UBEQU1; return TILDECARET;
}
<INITIALU,INITIAL>"^~" {
  yylval.num = BEIF_EXPR_NODE_TYPE_UBEQU2; return CARETTILDE;
}

	/* Binary. */
<INITIALU,INITIAL>"*"    {
  return '*';
}
<INITIALU,INITIAL>"/"    {
  return '/';
}
<INITIALU,INITIAL>"%"    {
  return '%';
}
<INITIALU,INITIAL>"=="   {
  return EQUALEQUAL;
}
<INITIALU,INITIAL>"!="   {
  return EXCLAMEQUAL;
}
<INITIALU,INITIAL>"==="  {
  return EQUALEQUALEQUAL;
}
<INITIALU,INITIAL>"!==" {
  return EXCLAMEQUALEQUAL;
}
<INITIALU,INITIAL>"&&" {
  return AMPERAMPER;
}
<INITIALU,INITIAL>"||" {
  return VERTBARVERTBAR;
}
<INITIALU,INITIAL>"<"  {
  return '<';
}
<INITIALU,INITIAL>"<=" {
  return LESSEQUAL;
}
<INITIALU,INITIAL>">"  {
  return '>';
}
<INITIALU,INITIAL>">=" {
  return GREATEREQUAL;
}
<INITIALU,INITIAL>">>" {
  return GREATERGREATER;
}
<INITIALU,INITIAL>"<<" {
  return LESSLESS;
}
<INITIALU,INITIAL>"->" {
  return TRIGGER;
}
<INITIALU,INITIAL,CONSTANT_ONLY>"(" {
  if (useUpperCase) {
    ChangeToState(INITIALU);
  } else {
    ChangeToState(INITIAL);
  }
  return '(';
}
	/* Ternary. */
<INITIALU,INITIAL>"?"	{
  return '?';
}
<INITIALU,INITIAL>":"	{
  return ':';
}


	/*
	 * Keywords.
	 */


<INITIAL>always |
<INITIALU>ALWAYS        { return ALWAYSKW; }
<INITIAL>and |
<INITIALU>AND           { return ANDKW; }
<INITIAL>assign |
<INITIALU>ASSIGN        { return ASSIGNKW; }
<INITIAL>begin |
<INITIALU>BEGIN         { return BEGINKW; }
<INITIAL>buf  |
<INITIALU>BUF           { return BUFKW; }
<INITIAL>bufif0 |
<INITIALU>BUFIF0        { return BUFIF0KW; }
<INITIAL>bufif1 |
<INITIALU>BUFIF1        { return BUFIF1KW; }
<INITIAL>case |
<INITIALU>CASE          { return CASEKW; }
<INITIAL>casex |
<INITIALU>CASEX         { return CASEXKW; }
<INITIAL>casez |
<INITIALU>CASEZ         { return CASEZKW; }
<INITIAL>cmos |
<INITIALU>CMOS          { return CMOSKW; }
<INITIAL>deassign |
<INITIALU>DEASSIGN      { return DEASSIGNKW; }
<INITIAL>default |
<INITIALU>DEFAULT       { return DEFAULTKW; }
<INITIAL>defparam |
<INITIALU>DEFPARAM      { return DEFPARMKW; }
<INITIAL>disable |
<INITIALU>DISABLE       { return DISABLEKW; }
<INITIAL>edge |
<INITIALU>EDGE          { return EDGEKW; }
<INITIAL>else |
<INITIALU>ELSE          { return ELSEKW; }
<INITIAL>end |
<INITIALU>END           { return ENDKW; }
<INITIAL>endcase |
<INITIALU>ENDCASE       { return ENDCASEKW; }
<INITIAL>endfunction |
<INITIALU>ENDFUNCTION   { return ENDFUNCKW; }
<INITIAL>endmodule |
<INITIALU>ENDMODULE     { return ENDMODKW; }
<INITIAL>endprimitive |
<INITIALU>ENDPRIMITIVE  { return ENDPRIMKW; }
<INITIAL>endspecify |
<INITIALU>ENDSPECIFY    { return ENDSPECIFYKW; }
<INITIAL,CS_TABLE>endtable |
<INITIALU,CS_TABLE>ENDTABLE      { return ENDTABLEKW; }
<INITIAL>endtask |
<INITIALU>ENDTASK       { return ENDTASKKW; }
<INITIAL>event |
<INITIALU>EVENT         { yylval.num = BEIF_VAR_TYPE_EVENT; return EVENTKW; }
<INITIAL>for |
<INITIALU>FOR           { return FORKW; }
<INITIAL>force |
<INITIALU>FORCE         { return FORCEKW; }
<INITIAL>forever |
<INITIALU>FOREVER       { return FOREVERKW; }
<INITIAL>fork |
<INITIALU>FORK          { return FORKKW; }
<INITIAL>function |
<INITIALU>FUNCTION      { return FUNCKW; }
<INITIAL>highz0 |
<INITIALU>HIGHZ0        { return HIGHZ0; }
<INITIAL>highz1 |
<INITIALU>HIGHZ1        { return HIGHZ1; }
<INITIAL>if |
<INITIALU>IF            { return IFKW; }
<INITIAL>ifnone |
<INITIALU>IFNONE        { return IFNONEKW; }
<INITIAL>initial |
<INITIALU>INITIAL       { return INITKW; }
<INITIAL>inout |
<INITIALU>INOUT         { PortType = BEIF_PORT_TYPE_INOUT; return INOUTKW; }
<INITIAL>input |
<INITIALU>INPUT         { PortType = BEIF_PORT_TYPE_INPUT; return INPUTKW; }
<INITIAL>integer |
<INITIALU>INTEGER       { yylval.num = BEIF_VAR_TYPE_INTEGER; return INTKW; }
<INITIAL>join |
<INITIALU>JOIN          { return JOINKW; }
<INITIAL>large |
<INITIALU>LARGE         { return LARGEKW; }
<INITIAL>macromodule |
<INITIALU>MACROMODULE   { return MACMODKW; }
<INITIAL>medium |
<INITIALU>MEDIUM        { return MEDIUMKW; }
<INITIAL>module |
<INITIALU>MODULE        { return MODKW; }
<INITIAL>nand |
<INITIALU>NAND          { return NANDKW; }
<INITIAL>negedge |
<INITIALU>NEGEDGE       { return NEGEDGEKW; }
<INITIAL>nmos |
<INITIALU>NMOS          { return NMOSKW; }
<INITIAL>nor |
<INITIALU>NOR           { return NORKW; }
<INITIAL>not |
<INITIALU>NOT           { return NOTKW; }
<INITIAL>notif0 |
<INITIALU>NOTIF0        { return NOTIF0KW; }
<INITIAL>notif1 |
<INITIALU>NOTIF1        { return NOTIF1KW; }
<INITIAL>or |
<INITIALU>OR            { return ORKW; }
<INITIAL>output |
<INITIALU>OUTPUT        { PortType = BEIF_PORT_TYPE_OUTPUT; return OUTPUTKW; }
<INITIAL>parameter |
<INITIALU>PARAMETER     { return PARMKW; }
<INITIAL>pmos |
<INITIALU>PMOS          { return PMOSKW; }
<INITIAL>posedge |
<INITIALU>POSEDGE       { return POSEDGEKW; }
<INITIAL>primitive |
<INITIALU>PRIMITIVE     { return PRIMKW; }
<INITIAL>pull0 |
<INITIALU>PULL0         { return PULL0; }
<INITIAL>pull1 |
<INITIALU>PULL1         { return PULL1; }
<INITIAL>pulldown |
<INITIALU>PULLDOWN      { return PULLDOWNKW; }
<INITIAL>pullup |
<INITIALU>PULLUP        { return PULLUPKW; }
<INITIAL>rcmos |
<INITIALU>RCMOS         { return RCMOSKW; }
<INITIAL>real |
<INITIALU>REAL          { yylval.num = BEIF_VAR_TYPE_REAL; return REALKW; }
<INITIAL>realtime |
<INITIALU>REALTIME      { yylval.num = BEIF_VAR_TYPE_REALTIME; return REALTIMEKW; }
<INITIAL>reg |
<INITIALU>REG           { yylval.num = BEIF_VAR_TYPE_REG; return REGKW; }
<INITIAL>release |
<INITIALU>RELEASE       { return RELEASEKW; }
<INITIAL>repeat |
<INITIALU>REPEAT        { return REPEATKW; }
<INITIAL>rnmos |
<INITIALU>RNMOS         { return RNMOSKW; }
<INITIAL>rpmos |
<INITIALU>RPMOS         { return RPMOSKW; }
<INITIAL>rtran |
<INITIALU>RTRAN         { return RTRANKW; }
<INITIAL>rtranif0 |
<INITIALU>RTANIF0      { return RTRANIF0KW; }
<INITIAL>rtranif1 |
<INITIALU>RTRANIF1      { return RTRANIF1KW; }
<INITIAL>scalared |
<INITIALU>SCALARED      { return SCALAREDKW; }
<INITIAL>small |
<INITIALU>SMALL         { return SMALLKW; }
<INITIAL>specify |
<INITIALU>SPECIFY       { 
              if (useUpperCase) {
  							ChangeToState(SPECIFY_BLOCKU);
              } else {
   							ChangeToState(SPECIFY_BLOCK);
              }
						}
<SPECIFY_BLOCK>endspecify	|
<SPECIFY_BLOCKU>ENDSPECIFY	{
              if (useUpperCase) {
							  ChangeToState(INITIALU);
              } else {
 							  ChangeToState(INITIAL);
              }
						}
<SPECIFY_BLOCK,SPECIFY_BLOCKU>"//"		{
              if (useUpperCase) {
  							PushState(SPECIFY_BLOCKU);
              } else {
  							PushState(SPECIFY_BLOCK);
              }
							ChangeToState(SCOMMENT);
						}
<SPECIFY_BLOCK,SPECIFY_BLOCKU>"/*"		{
              if (useUpperCase) {
  							PushState(SPECIFY_BLOCKU);
              } else {
  							PushState(SPECIFY_BLOCK);
              }
							MultiLineComment++;
							ChangeToState(MCOMMENT);
						}
<SPECIFY_BLOCK,SPECIFY_BLOCKU>\"		{
              if (useUpperCase) {
  							PushState(SPECIFY_BLOCKU);
              } else {
  							PushState(SPECIFY_BLOCK);
              }
							ChangeToState(IN_STRING);
						}

<SPECIFY_BLOCK,SPECIFY_BLOCKU>[ \t\n]		{
						}
<SPECIFY_BLOCK,SPECIFY_BLOCKU>.		{
						}

<MCOMMENT>"*/"			{
							if(!(--MultiLineComment))	{
								ChangeToState(PopState());
							}
						}
<MCOMMENT>.				{
						}
<SCOMMENT>.*\n			{
							ChangeToState(PopState());
						}
<INITIAL>specparam |
<INITIALU>SPECPARAM     { return SPECPARMKW; }
<INITIAL>strong0 |
<INITIALU>STRONG0       { return STRONG0KW; }
<INITIAL>strong1 |
<INITIALU>STRONG1       { return STRONG1KW; }
<INITIAL>supply0 |
<INITIALU>SUPPLY0       { return SUPPLY0KW; }
<INITIAL>supply1 |
<INITIALU>SUPPLY1       { return SUPPLY1KW; }
<INITIAL>table |
<INITIALU>TABLE         { return TABLEKW; }
<INITIAL>task |
<INITIALU>TASK          { return TASKKW; }
<INITIAL>time |
<INITIALU>TIME          { yylval.num = BEIF_VAR_TYPE_TIME; return TIMEKW; }
<INITIAL>tran |
<INITIALU>TRAN          { return TRANKW; }
<INITIAL>tranif0 |
<INITIALU>TRANIF0       { return TRANIF0KW; }
<INITIAL>tranif1 |
<INITIALU>TRANIF1       { return TRANIF1KW; }
<INITIAL>tri |
<INITIALU>TRI           { return TRIKW; }
<INITIAL>tri0 |
<INITIALU>TRI0          { return TRI0KW; }
<INITIAL>tri1 |
<INITIALU>TRI1          { return TRI1KW; }
<INITIAL>triand |
<INITIALU>TRIAND        { return TRIANDKW; }
<INITIAL>trior |
<INITIALU>TRIOR         { return TRIORKW; }
<INITIAL>trireg |
<INITIALU>TRIREG        { return TRIREGKW; }
<INITIAL>vectored |
<INITIALU>VECTORED      { return VECTOREDKW; }
<INITIAL>wait |
<INITIALU>WAIT          { return WAITKW; }
<INITIAL>wand |
<INITIALU>WAND          { return WANDKW; }
<INITIAL>weak0 |
<INITIALU>WEAK0         { return WEAK0; }
<INITIAL>weak1 |
<INITIALU>WEAK1         { return WEAK1; }
<INITIAL>wor |
<INITIALU>WOR           { return WORKW; }
<INITIAL>while |
<INITIALU>WHILE         { return WHILEKW; }
<INITIAL>wire |
<INITIALU>WIRE          { return WIREKW; }
<INITIAL>xnor |
<INITIALU>XNOR          { return XNORKW; }
<INITIAL>xor |
<INITIALU>XOR           { return XORKW; }


	/*
	 * Others.
	 */

<<EOF>>                 { return YYENDOFFILE; }


<INITIALU,INITIAL,CONSTANT_ONLY>[01]		    { 
    CpyString(yytext); 
    if (useUpperCase) {
      ChangeToState(INITIALU);
    } else {
      ChangeToState(INITIAL);
    }
    return (InitVal ? INIT_VAL : CONST);
  }

<INITIALU,INITIAL>1'[bB][ \t]*[01xX]		    {
    CpyString(yytext);
    return (InitVal ? INIT_VAL : BINNUMBER);
  }

<INITIALU,INITIAL,CONSTANT_ONLY>\${DWord}		  {
    CpyString(yytext);
    HierNameFlag=0;
    if (useUpperCase) {
      ChangeToState(INITIALU);
    } else {
      ChangeToState(INITIAL);
    }
    return SYSIDENT;
  }


<INITIALU,INITIAL>{Binary}		    { CpyString(yytext); return BINNUMBER; }
<INITIALU,INITIAL>{Octal}		    { CpyString(yytext); return OCTNUMBER; } 
<INITIALU,INITIAL>{Decimal}		    { CpyString(yytext);  return DECNUMBER; } 
<INITIALU,INITIAL>{Hexdecimal}	            { CpyString(yytext);  return HEXNUMBER; }
<INITIALU,INITIAL,CONSTANT_ONLY>{Number}		    {
  CpyString(yytext);
  if (useUpperCase) {
    ChangeToState(INITIALU);
  } else {
    ChangeToState(INITIAL);
  }
  return CONST; }
<INITIALU,INITIAL,CONSTANT_ONLY>{Simpreal}		  { 
  CpyString(yytext);
  if (useUpperCase) {
    ChangeToState(INITIALU);
  } else {
    ChangeToState(INITIAL);
  }
  return REALNUMBER; }
<INITIALU,INITIAL,CONSTANT_ONLY>{Real0}		    {
  CpyString(yytext);
  if (useUpperCase) {
    ChangeToState(INITIALU);
  } else {
    ChangeToState(INITIAL);
  }
  return REALNUMBER; }
<INITIALU,INITIAL,CONSTANT_ONLY>{Real1}		    {
  CpyString(yytext);
  if (useUpperCase) {
    ChangeToState(INITIALU);
  } else {
    ChangeToState(INITIAL);
  }
  return REALNUMBER; }
<INITIALU,INITIAL,CONSTANT_ONLY>{Real2}		    {
  CpyString(yytext);
  if (useUpperCase) {
    ChangeToState(INITIALU);
  } else {
    ChangeToState(INITIAL);
  }
  return REALNUMBER; }
<INITIALU,INITIAL,CONSTANT_ONLY>{Real3}		    { 
  CpyString(yytext);
  if (useUpperCase) {
    ChangeToState(INITIALU);
  } else {
    ChangeToState(INITIAL);
  }
  return REALNUMBER; }

<CONSTANT_ONLY>[ \t\n] 
 /* This causes problems for #d where d is an IDENT
<CONSTANT_ONLY>.  { return yytext[0];}
 */

<INITIALU,INITIAL>\"					{ 
    if (useUpperCase) {
      PushState(INITIALU);
    } else {
      PushState(INITIAL);
    }
    ChangeToState(IN_STRING); 
}
<IN_STRING>\\.				{
	yymore();
}
<IN_STRING>\"				{ 
	int State=PopState();

	ChangeToState(State);
	if((State == INITIAL)	|| (State == INITIALU)) {
           CpyString1(yytext);
           return STRING; 
	}
}
<IN_STRING>{NL}				{
	char TmpStr[200];

        BeIfRegisterError("Unterminated string",(char *)NULL);
	yymore();
}
<IN_STRING>.				{ yymore(); }

<INITIALU,INITIAL,CONSTANT_ONLY>{DWord}			    { 
  CpyString(yytext);
  if (useUpperCase) {
    ChangeToState(INITIALU);
  } else {
    ChangeToState(INITIAL);
  }
  HierNameFlag=0;
  return IDENT; }


 /* 
<INITIALU,INITIAL,CONSTANT_ONLY>{Word}([ ]*\.[ ]*{Word})+	 {
    CpyString(yytext);
    if (useUpperCase) {
      ChangeToState(INITIALU);
    } else {
      ChangeToState(INITIAL);
    }
    HierNameFlag=1;
    return IDENT;
  }
 */

<INITIALU,INITIAL,CONSTANT_ONLY>\\[^ \t\n]+[ \t]*	{
    CpyEscapedString(yytext);
    if (useUpperCase) {
      ChangeToState(INITIALU);
    } else {
      ChangeToState(INITIAL);
    }
    return IDENT;
  }


<INITIALU,INITIAL,CONSTANT_ONLY>({Word}|\\[^ \t\n]+)[ \t]*\.[ \t]* 	{
    ChangeToState(IN_HIER);
    HierNameFlag = 1;
    yymore();
  }

<IN_HIER,CONSTANT_ONLY>({Word}|\\[^ \t\n]+)[ \t]*\.[ \t]* { yymore(); }

<IN_HIER,CONSTANT_ONLY>{Word}|\\[^ \t\n]+ {
    if (useUpperCase) {
      ChangeToState(INITIALU);
    } else {
      ChangeToState(INITIAL);
    }
    CpyString(yytext);
    return IDENT;
  }


<CS_TABLE>[bBxX01?]		{
	return CS_SYMBOL;
}

<CS_TABLE>[rRfFpPnN*]	{
	return EDGE_SYMBOL;
}
 

\n   {  }

<INITIALU,INITIAL,CS_TABLE>.				      { return(yytext[0]); }



%%

int
reset_lex(yyin)
FILE	*yyin;
{
  yyrestart(yyin);
  return 0;
}


#define STRING_BUF_SIZE 16384

static char StringBuf[STRING_BUF_SIZE];
static char *StrPtr=&StringBuf[0];
static char *EndStr=&StringBuf[STRING_BUF_SIZE-1];



void
InitLexer()
{
  StrPtr=&StringBuf[0];
  EndStr=&StringBuf[STRING_BUF_SIZE-1];
  StateList=NULL;
  LastState=NULL;
  MultiLineComment=0;
  if (useUpperCase) {
    CurrentState=INITIALU;
    ChangeToState(INITIALU);
  } else {
    CurrentState=INITIAL;
    ChangeToState(INITIAL);
  }
  yy_init = 1;
  yy_c_buf_p = (char *) 0;
}


void
CpyString1(char *str)
{

  int   i;
  int   NotEnoughRoom;
  char  *OrigStrPtr;

  NotEnoughRoom = 0;
  if (StrPtr >= EndStr) {
    StrPtr = &StringBuf[0];
  }
  OrigStrPtr = StrPtr;
  *StrPtr = '\"';
  StrPtr++; 
  for (i=0; str[i] != '\0'; i++) {
    *StrPtr = str[i];
    StrPtr++;
    if (StrPtr >= EndStr) {
      NotEnoughRoom = 1;
      break;
    }
  }
  if (NotEnoughRoom) {
    StrPtr = &StringBuf[0];
    OrigStrPtr = StrPtr;
    for (i=0; str[i] != '\0'; i++) {
      *StrPtr = str[i];
      StrPtr++;
    }
  }
  *StrPtr = '\0';
  StrPtr++;
  yylval.string = OrigStrPtr;
}


void
CpyString(char *str)
{

  int   i;
  int   NotEnoughRoom;
  char  *OrigStrPtr;

  NotEnoughRoom = 0;
  if (StrPtr >= EndStr) {
    StrPtr = &StringBuf[0];
  }
  OrigStrPtr = StrPtr;
  for (i=0; str[i] != '\0'; i++) {
    *StrPtr = str[i];
    StrPtr++;
    if (StrPtr >= EndStr) {
      NotEnoughRoom = 1;
      break;
    }
  }
  if (NotEnoughRoom) {
    StrPtr = &StringBuf[0];
    OrigStrPtr = StrPtr;
    for (i=0; str[i] != '\0'; i++) {
      *StrPtr = str[i];
      StrPtr++;
    }
  }
  *StrPtr = '\0';
  StrPtr++;
  yylval.string = OrigStrPtr;
}


void
CpyEscapedString(char *str)
{

  int   i, last;
  int   NotEnoughRoom;
  char  *OrigStrPtr;
  char  *newStr, *cPtr;
  int   flag=0;


  last = strlen(str)-1;

  NotEnoughRoom = 0;
  if (StrPtr >= EndStr) {
    StrPtr = &StringBuf[0];
  }
#ifdef RLDEBUG
printf("escaped name Ident - \"%s\"\n", str);
#endif

  last = strlen(str)-1; 
  OrigStrPtr = StrPtr;
  if (str[last] == ']') {
     for (i=last-1; i >= 0; i--) {
         if (str[i] == '[') {
            flag = 1; break;
         }
     }
  } else if (str[last] == ' ' && last-1 >= 0 && str[last-1] == ']') {
     for (i=last-2; i >= 0; i--) {
         if (str[i] == '[') {
            flag = 1; break;
         }
     }
  } else if (strlen(str) >= 3 && str[last] == '}' && str[1] == '{') {
     flag = 1;
  } else if (strlen(str) >= 4 && str[last] == ' ' && str[last-1] == '}' && str[1] == '{') {
     flag = 1;
  } else if (index(str, '.')) {
     flag = 1;
  }

  if (!flag) {
     for (i=1; str[i] != '\0'; i++) {
        if (!(i == last && str[last] == ' ')) {
           *StrPtr = str[i];
           StrPtr++;
           if (StrPtr >= EndStr) {
              NotEnoughRoom = 1;
              break;
           }
        }
     }
     if (NotEnoughRoom) {
       StrPtr = &StringBuf[0];
       OrigStrPtr = StrPtr;
       for (i=1; str[i] != '\0'; i++) {
          if (!(i == last && str[last] == ' ')) {
             *StrPtr = str[i];
             StrPtr++;
          }
       }
     }
  } else {

     for (i=0; str[i] != '\0'; i++) {
        if (!(i == last && str[last] == ' ')) {
           *StrPtr = str[i];
           StrPtr++;
           if (StrPtr >= EndStr) {
              NotEnoughRoom = 1;
              break;
           }
        }
     }
     if (NotEnoughRoom) {
       StrPtr = &StringBuf[0];
       OrigStrPtr = StrPtr;
       for (i=0; str[i] != '\0'; i++) {
          if (!(i == last && str[last] == ' ')) {
             *StrPtr = str[i];
             StrPtr++;
          }
       }
     }
     *StrPtr = str[0];
     StrPtr++;
  }
  *StrPtr = '\0';
  StrPtr++;
  yylval.string = OrigStrPtr;

#ifdef RLDEBUG
printf("OrigStrPtr - \"%s\"\n", OrigStrPtr);
#endif
}



void PushState(int State)
{
register StateData *Tmp;

	Tmp=(StateData *)malloc(sizeof(StateData));
	Tmp->State=State;
	Tmp->Next=NULL;
	if(LastState == NULL)	{
		LastState=StateList=Tmp;
		Tmp->Prev=NULL;
	}
	else	{
		Tmp->Prev=LastState;
		LastState=LastState->Next=Tmp;
	}
}

int PopState()
{
int State;
register StateData *Tmp;

	State=LastState->State;
	Tmp=LastState->Prev;
	if(Tmp)
		Tmp->Next=NULL;
	else	{
		free(LastState);
		LastState=Tmp;
	}
	return State;
}

void ChangeToState(int NewState)
{
	CurrentState=NewState;
	BEGIN NewState;
}

void BeginState(char *NewState)
{
	if(NewState == NULL)
		return;

	if(strcmp(NewState,"INITIAL") == 0)	{
		ChangeToState(INITIAL);
		return;
	}
	if(strcmp(NewState,"INITIALU") == 0)	{
		ChangeToState(INITIALU);
		return;
	}
	if(strcmp(NewState,"CS_TABLE") == 0)	{
		ChangeToState(CS_TABLE);
		return;
	}
}

int GetCurrentState()
{
	return CurrentState;
}



void LexPrintState()
{
  int state;

  state = (yy_start - 1) / 2;
  switch (state) {
   case MCOMMENT:
     printf("Lex State is  MCOMMENT\n");
     break;

 case SCOMMENT:
     printf("Lex State is  SCOMMENT\n");
     break;

 case IN_STRING:
     printf("Lex State is  IN_STRING\n");
     break;

 case SPECIFY_BLOCK:
     printf("Lex State is  SPECIFY_BLOCK\n");
     break;

 case CS_TABLE:
     printf("Lex State is  CS_TABLE\n");
     break;

 case CONSTANT_ONLY:
     printf("Lex State is  CONSTANT_ONLY\n");
     break;

 case INITIALU:
     printf("Lex State is  INITIALU\n");
     break;

 case SPECIFY_BLOCKU:
     printf("Lex State is  SPECIFY_BLOCKU\n");
     break;

  }
}