/* shell.slex - small lex description for VxWorks shell *//*modification history--------------------02i,27nov01,pch  Provide floating-point exclusion based on _WRS_NO_TGT_SHELL_FP		 definition instead of testing a specific CPU type.02h,02mar95,yao  make floating point conditional for PPC403.02g,29aug94,ism  added ^M to nl char class so that PC scripts run (SPR#2899)02f,29aug94,ism  added \v and \a ansi escape sequences for strings (SPR#3690)02e,19aug92,jmm  fixed incorrect recognition of DATA symbols as TEXT02d,01aug92,srh  added check to match identifier against mangled C++ symbols.02c,30jul92,wmd  use N_TEXT to compare when checking for TEXT type symbol.02b,13dec91,gae  more ANSI cleanup.02a,19nov91,rrr  shut up some ansi warnings.01z,19nov91,rrr  shut up some warnings.01y,07oct91,rrr  added forward declaration for lexInit() (more forward).01x,10aug90,dnw  added forward declaration for lexInit().01w,08aug90,dnw  changed "%F" to "%lf" for ANSI compatibility.01v,10dec89,jcf  symbol table type now SYM_TYPE.01u,15oct88,dnw  improved support for Ada identifiers.		 made it conditional on sysAdaEnable.01t,09nov88,rdc  modifications to support ada identifiers.01s,30may88,dnw  changed to v4 names.01r,28may88,dnw  changed calls to atoi() and atof() to sscanf().01q,18mar88,gae  allowed '^' to occur in strings.01p,18nov87,gae  added T_UNKNOWN for undefined symbols.		 made shell float types default to double.01o,28oct87,gae  got rid of string type.01n,20oct87,gae  fixed lexScan() bug - used MAX_SHELL_LINE for temp. buffer.		   added scanning of octal chars, eg. '\377'.01m,07aug87,gae  fixed final state of octal.		 changed type specifiers to conventional C type casting.01l,01jun87,gae  added interpretation of bytes, words, floats, doubles.		 added type specifiers a la assembler, .[bwfdls].		 fixed table for "*=".01k,09jan87,gae  fixed '^', and '\^'.01j,24dec86,gae  added '->' back into table accidentally removed in 01h.01i,24nov86,llk  deleted SYSTEM conditional compiles.01h,08oct86,gae  added C assignment operators.01g,04jun86,dnw  changed sstLib calls to symLib.01f,11oct85,dnw  de-linted.01e,19jun85,dnw  added conditional compilation for BSD 4.2 load modules.01d,10sep84,dnw  included routines from lexLib directly in this module.		 fixed bug in automatic parens insertion.01c,29aug84,jlf  changed to treat "_" as a normal alphabetic character.01b,18aug84,dnw  changed to recognize and discard "/ * .... " style comments.		 changed to treat ';' like a NL for automatic insertion of ().01a,02aug84,dnw  written*/IMPORT BOOL sysAdaEnable;	/* TRUE = enable Ada support */IMPORT BOOL sysCplusEnable;	/* TRUE = enable C++ support */typedef enum		/* states for automatic insertion of parens in yylex */    {    FIRST_LEXEME,    NORMAL,    P_OPEN,    P_OPEN_DONE,    P_CLOSE,    P_CLOSE_DONE    } AUTO_STATE;LOCAL AUTO_STATE autoState;		/* state of auto parens mods */LOCAL char *nextChar;			/* ptr to next input char in line */LOCAL char tempStrings [MAX_SHELL_LINE];/* storage for strings while parsing */LOCAL char *nextTempString;		/* ptr to free space in tempStrings *//* forward declaration */static void lexNewLine (char *line);static int yylex (void);static char *addTempString (char *string);static void lexError (char *string, char *errmsg);static int getNum (char *string, char *fmtString, VALUE *pValue);static int getFloat (char *string, VALUE *pValue);static int getString (char *string, int nChars, VALUE *pValue);static int getChar (char *string, int nChars, VALUE *pValue);static int getId (char *string, VALUE *pValue);static int numAdaIdMatches (char *string, SYM_TYPE *pType, int *pValue);static BOOL countAdaIdMatch (char *symbol, int val, SYM_TYPE type, int arg);static BOOL printAdaIdMatch (char *symbol, int val, SYM_TYPE type, int arg);static BOOL adaIdMatch (char *symbol, char *id);static int typeCast (char *string);static int strToChar (char *string, char *pChar);static void lexInit (void);static int lexScan (void);static void lexRetract (void);CHAR CLASSES:			/* generates lexClass[] and lexNclasses *//* name  definition *//* ----  ---------- */    ws   SP \t    1-7  1-7    8-9  8 9    a-f  a-f A-F    xX   x X    g-z  g-w G-W y Y z Z _    eof  ^D EOF    nl	 \n ^M EOS/* char class 0 is always "other" */END#define RETRACT		lexRetract (); string[--nChars] = EOSFINAL STATES: 			/* generates lexActions() *//* name action *//* ---- ---------------------- */    WS	{ RETRACT;	}    O	{ RETRACT;	return (string[0]); }    I	{ 		return (string[0]); }    EN	{ 		lexError(string, "invalid number"); return(LEX_ERROR); }    ES	{		lexError(string, "invalid string"); return(LEX_ERROR); }    EC	{		lexError(string, "invalid char");   return(LEX_ERROR); }    ON	{ RETRACT;	return (getNum (string, "%o", &yylval)); }    XN	{ RETRACT;	return (getNum (&string[2], "%x", &yylval)); }    $N	{ RETRACT;	return (getNum (&string[1], "%x", &yylval)); }    DN	{ RETRACT;	return (getNum (string, "%d", &yylval)); }    FN	{ RETRACT;	return (getFloat (string, &yylval)); }    ID	{ RETRACT;	return (getId (string, &yylval)); }    ST	{		return (getString (string, nChars, &yylval)); }    CH	{		return (getChar (string, nChars, &yylval)); }    ||	{		return (OR); }    &&	{		return (AND); }    ==	{		return (EQ); }    !=	{		return (NE); }    >=	{		return (GE); }    <=	{		return (LE); }    >>	{ RETRACT;	return (ROT_RIGHT); }    <<	{ RETRACT;	return (ROT_LEFT); }    ->	{		return (PTR); }    ++	{		return (INCR); }    --	{		return (DECR); }    +=	{		return (ADDA); }    -=	{		return (SUBA); }    *=	{		return (MULA); }    /=	{		return (DIVA); }    %=	{		return (MODA); }    <A	{		return (SHLA); }    >A	{		return (SHRA); }    &=	{		return (ANDA); }    |=	{		return (ORA); }    ^=	{		return (XORA); }    NL	{		return (NL); }    EOF	{		return (ENDFILE); }ENDSTATE TABLE:			/* generates lexStateTable[] *//*   0   1      2   3   4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 */ other ws  0  1-7 8-9 a-f xX g-z .  \  "  '  $  |  &  =  !  >  <  -  +  /  *  %   ^ nl eof/*  -- -- --- --- --- --- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --  -- -- ---*/ini  I ws  0  dec dec  id id id .D  I  "  '  $  |  &  =  !  >  <  -  +  s  *  %   ^ NL EOFws  WS  .  WS  WS  WS  WS WS WS WS WS WS WS WS WS WS WS WS WS WS WS WS WS WS WS WS WS WS0   DN DN oct oct  EN  EN 0x EN .N DN DN DN DN DN DN DN DN DN DN DN DN DN DN DN DN DN DNoct ON ON  .   .   EN  EN EN EN ON ON ON ON ON ON ON ON ON ON ON ON ON ON ON ON ON ON ON0x  EN EN 0xh 0xh 0xh 0xh EN EN EN EN EN EN EN EN EN EN EN EN EN EN EN EN EN EN EN EN EN0xh XN XN  .   .   .   .  EN EN EN XN XN XN XN XN XN XN XN XN XN XN XN XN XN XN XN XN XN$   EN EN  $h  $h  $h  $h EN EN EN EN EN EN EN EN EN EN EN EN EN EN EN EN EN EN EN EN EN$h  $N $N  .   .   .   .  EN EN EN $N $N $N $N $N $N $N $N $N $N $N $N $N $N $N $N $N $Ndec DN DN  .   .   .   EN EN EN .N DN DN DN DN DN DN DN DN DN DN DN DN DN DN DN DN DN DN.D FN  FN  .N  .N  .N  EN EN EN EN FN FN FN FN FN FN FN FN FN FN FN FN FN FN FN FN FN FN.N  FN FN  .   .   .   EN EN EN EN FN FN FN FN FN FN FN FN FN FN FN FN FN FN FN FN FN FNid  ID ID  .   .   .   .   .  . ID ID ID ID ID ID ID ID ID ID ID ID ID ID ID ID ID ID ID"    .  .  .   .   .   .   .  .  . "\ ST  .  .  .  .  .  .  .  .  .  .  .  .  .  . ES ES"\   "  "  "   "   "   "   "  "  "  "  "  "  "  "  "  "  "  "  "  "  "  "  "  "  . ES ES'    .  .  .   .   .   .   .  .  . '\  . CH  .  .  .  .  .  .  .  .  .  .  .  .  . EC EC'\   '  '  '   '   '   '   '  '  '  '  '  '  '  '  '  '  '  '  '  '  '  '  '  '  ' EC ECs    O  O  O   O   O   O   O  O  O  O  O  O  O  O  O /=  O  O  O  O  O  O s*  O  O  O  Os*   .  .  .   .   .   .   .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . s+  .  .  .  .s+  s* s* s*  s*  s* s* s* s* s* s* s* s* s* s* s* s* s* s* s* s* s* ini s* s* s* s* s*|    O  O  O   O   O  O   O  O  O  O  O  O  O ||  O |=  O  O  O  O  O  O  O  O  O  O  O&    O  O  O   O   O  O   O  O  O  O  O  O  O  O && &=  O  O  O  O  O  O  O  O  O  O  O=    O  O  O   O   O  O   O  O  O  O  O  O  O  O  O ==  O  O  O  O  O  O  O  O  O  O  O!    O  O  O   O   O  O   O  O  O  O  O  O  O  O  O !=  O  O  O  O  O  O  O  O  O  O  O>    O  O  O   O   O  O   O  O  O  O  O  O  O  O  O >=  O >X  O  O  O  O  O  O  O  O  O<    O  O  O   O   O  O   O  O  O  O  O  O  O  O  O <=  O  O <X  O  O  O  O  O  O  O  O-    O  O  O   O   O  O   O  O  O  O  O  O  O  O  O -=  O ->  O --  O  O  O  O  O  O  O+    O  O  O   O   O  O   O  O  O  O  O  O  O  O  O +=  O  O  O  O ++  O  O  O  O  O  O*    O  O  O   O   O  O   O  O  O  O  O  O  O  O  O *=  O  O  O  O  O  O  O  O  O  O  O%    O  O  O   O   O  O   O  O  O  O  O  O  O  O  O %=  O  O  O  O  O  O  O  O  O  O  O^    O  O  O   O   O  O   O  O  O  O  O  O  O  O  O ^=  O  O  O  O  O  O  O  O  O  O  O>X  >> >> >>  >>  >> >>  >> >> >> >> >> >> >> >> >> >A >> >> >> >> >> >> >> >> >> >> >><X  << << <<  <<  << <<  << << << << << << << << << <A << << << << << << << << << << <<ENDEJECT:END/********************************************************************************* lexNewLine - initialize for lexical scan of new line** RETURNS: N/A*/LOCAL void lexNewLine    (    char *line    )    {    lexInit ();    nextChar = line;    nextTempString = tempStrings;    autoState = FIRST_LEXEME;    }/********************************************************************************* yylex - get next lexeme for yacc** This routine is called by yacc to get the next input lexeme.* In addition to simply calling lexScan to do the scan, this routine* also handles the automatic insertion of parens around the arguements* of a "top-level" routine call.  If the first lexeme scanned from a new* line is a T_SYMBOL (text id) and the second lexeme is NOT a '(',* then the second lexeme is withheld and a '(' returned instead.* The withheld lexeme is returned next.  Scanning then proceeds normally* until a NL (newline) lexeme is scanned.  The NL is withheld and a* ')' is returned instead, with the NL being returned next.** RETURNS: next lexeme.*/LOCAL int yylex (void)    {    static int heldCode;    FAST int code;    switch (autoState)	{        case FIRST_LEXEME:		/* first lex scan of new line */	    code = lexScan ();	    autoState = (code == T_SYMBOL) ? P_OPEN : NORMAL;	    break;	case NORMAL:			/* parens not required to be inserted */	    code = lexScan ();	    if (code == ';')		autoState = FIRST_LEXEME;	    break;	case P_OPEN:			/* looking for '(' */	    code = lexScan ();	    if (code == '(')		autoState = NORMAL;	    else		{		heldCode = code;		code = '(';		autoState = P_OPEN_DONE;		}	    break;	case P_OPEN_DONE:		/* artificial '(' has been returned */	    if ((heldCode == NL) || (heldCode == ';'))		{		code = ')';		autoState = P_CLOSE_DONE;		}	    else		{		code = heldCode;		autoState = P_CLOSE;		}	    break;	case P_CLOSE:			/* looking for NL or ';' */	    code = lexScan ();	    if ((code == NL) || (code == ';'))		{		heldCode = code;		code = ')';		autoState = P_CLOSE_DONE;		}	    break;	case P_CLOSE_DONE:		/* artificial ')' has been returned */	    code = heldCode;	    autoState = FIRST_LEXEME;	    break;	default:	    printf ("yylex: invalid state %#x\n", autoState);	    code = 0;	/* invalid? */	    break;	}    return (code);    }/********************************************************************************* addTempString - add string to temporary storage** This routine adds the specified string to the during-parse temporary* string storage.** RETURNS: pointer to new string appended to temporary area.*/LOCAL char *addTempString    (    char *string    )    {    char *newString = nextTempString;    while (*string != EOS)	string += strToChar (string, nextTempString++);    *(nextTempString++) = EOS;    return (newString);    }/********************************************************************************* lexError - report error in lex scan** RETURNS: N/A*/LOCAL void lexError    (    char *string,    char *errmsg    )    {    printf ("%s: %s\n", errmsg, string);    }/********************************************************************************* getNum - interpret scanned string as integer** RETURNS: NUMBER*/LOCAL int getNum    (    char *string,    char *fmtString,    VALUE *pValue    )    {    pValue->side = RHS;    pValue->type = T_INT;    sscanf (string, fmtString, &pValue->value.rv);    return (NUMBER);    }/********************************************************************************* getFloat - interpret scanned string as float** RETURNS: FLOAT*/LOCAL int getFloat    (    char *string,    VALUE *pValue    )    {#ifndef	_WRS_NO_TGT_SHELL_FP    pValue->side = RHS;    pValue->type = T_DOUBLE;    sscanf (string, "%lf", &pValue->value.dp);#endif	/* _WRS_NO_TGT_SHELL_FP */    return (FLOAT);    }/********************************************************************************* getString - interpret scanned string as quoted string** RETURNS: STRING*/LOCAL int getString    (    char *string,    int nChars,    VALUE *pValue    )    {    pValue->side = RHS;    pValue->type = T_INT;    string [nChars - 1] = EOS;    pValue->value.rv = (int)addTempString (&string[1]);    return (STRING);    }/********************************************************************************* getChar - interpret scanned string as quoted character** RETURNS: CHAR*/LOCAL int getChar    (    char *string,    int nChars,    VALUE *pValue    )    {