开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
shell_slex_c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：23k
源码类别：

VxWorks

开发平台：

C/C++

shell_slex_c：源码内容
  1. /* shell.slex - small lex description for VxWorks shell */
  2. /*
  3. modification history
  4. --------------------
  5. 02i,27nov01,pch  Provide floating-point exclusion based on _WRS_NO_TGT_SHELL_FP
  6.  definition instead of testing a specific CPU type.
  7. 02h,02mar95,yao  make floating point conditional for PPC403.
  8. 02g,29aug94,ism  added ^M to nl char class so that PC scripts run (SPR#2899)
  9. 02f,29aug94,ism  added v and a ansi escape sequences for strings (SPR#3690)
  10. 02e,19aug92,jmm  fixed incorrect recognition of DATA symbols as TEXT
  11. 02d,01aug92,srh  added check to match identifier against mangled C++ symbols.
  12. 02c,30jul92,wmd  use N_TEXT to compare when checking for TEXT type symbol.
  13. 02b,13dec91,gae  more ANSI cleanup.
  14. 02a,19nov91,rrr  shut up some ansi warnings.
  15. 01z,19nov91,rrr  shut up some warnings.
  16. 01y,07oct91,rrr  added forward declaration for lexInit() (more forward).
  17. 01x,10aug90,dnw  added forward declaration for lexInit().
  18. 01w,08aug90,dnw  changed "%F" to "%lf" for ANSI compatibility.
  19. 01v,10dec89,jcf  symbol table type now SYM_TYPE.
  20. 01u,15oct88,dnw  improved support for Ada identifiers.
  21.  made it conditional on sysAdaEnable.
  22. 01t,09nov88,rdc  modifications to support ada identifiers.
  23. 01s,30may88,dnw  changed to v4 names.
  24. 01r,28may88,dnw  changed calls to atoi() and atof() to sscanf().
  25. 01q,18mar88,gae  allowed '^' to occur in strings.
  26. 01p,18nov87,gae  added T_UNKNOWN for undefined symbols.
  27.  made shell float types default to double.
  28. 01o,28oct87,gae  got rid of string type.
  29. 01n,20oct87,gae  fixed lexScan() bug - used MAX_SHELL_LINE for temp. buffer.
  30.    added scanning of octal chars, eg. '377'.
  31. 01m,07aug87,gae  fixed final state of octal.
  32.  changed type specifiers to conventional C type casting.
  33. 01l,01jun87,gae  added interpretation of bytes, words, floats, doubles.
  34.  added type specifiers a la assembler, .[bwfdls].
  35.  fixed table for "*=".
  36. 01k,09jan87,gae  fixed '^', and '^'.
  37. 01j,24dec86,gae  added '->' back into table accidentally removed in 01h.
  38. 01i,24nov86,llk  deleted SYSTEM conditional compiles.
  39. 01h,08oct86,gae  added C assignment operators.
  40. 01g,04jun86,dnw  changed sstLib calls to symLib.
  41. 01f,11oct85,dnw  de-linted.
  42. 01e,19jun85,dnw  added conditional compilation for BSD 4.2 load modules.
  43. 01d,10sep84,dnw  included routines from lexLib directly in this module.
  44.  fixed bug in automatic parens insertion.
  45. 01c,29aug84,jlf  changed to treat "_" as a normal alphabetic character.
  46. 01b,18aug84,dnw  changed to recognize and discard "/ * .... " style comments.
  47.  changed to treat ';' like a NL for automatic insertion of ().
  48. 01a,02aug84,dnw  written
  49. */
  50. IMPORT BOOL sysAdaEnable; /* TRUE = enable Ada support */
  51. IMPORT BOOL sysCplusEnable; /* TRUE = enable C++ support */
  52. typedef enum /* states for automatic insertion of parens in yylex */
  53.     {
  54.     FIRST_LEXEME,
  55.     NORMAL,
  56.     P_OPEN,
  57.     P_OPEN_DONE,
  58.     P_CLOSE,
  59.     P_CLOSE_DONE
  60.     } AUTO_STATE;
  61. LOCAL AUTO_STATE autoState; /* state of auto parens mods */
  62. LOCAL char *nextChar; /* ptr to next input char in line */
  63. LOCAL char tempStrings [MAX_SHELL_LINE];/* storage for strings while parsing */
  64. LOCAL char *nextTempString; /* ptr to free space in tempStrings */
  65. /* forward declaration */
  66. static void lexNewLine (char *line);
  67. static int yylex (void);
  68. static char *addTempString (char *string);
  69. static void lexError (char *string, char *errmsg);
  70. static int getNum (char *string, char *fmtString, VALUE *pValue);
  71. static int getFloat (char *string, VALUE *pValue);
  72. static int getString (char *string, int nChars, VALUE *pValue);
  73. static int getChar (char *string, int nChars, VALUE *pValue);
  74. static int getId (char *string, VALUE *pValue);
  75. static int numAdaIdMatches (char *string, SYM_TYPE *pType, int *pValue);
  76. static BOOL countAdaIdMatch (char *symbol, int val, SYM_TYPE type, int arg);
  77. static BOOL printAdaIdMatch (char *symbol, int val, SYM_TYPE type, int arg);
  78. static BOOL adaIdMatch (char *symbol, char *id);
  79. static int typeCast (char *string);
  80. static int strToChar (char *string, char *pChar);
  81. static void lexInit (void);
  82. static int lexScan (void);
  83. static void lexRetract (void);
  84. int lexNclasses;
  85. #define RETRACT lexRetract (); string[--nChars] = EOS
  86. int lexActions (state, string, nChars, pContinue)
  87.     int state; char *string; int nChars; BOOL*pContinue;
  88.     {
  89.     *pContinue = FALSE;
  90.     switch (state)
  91.         {
  92.         case 1:
  93.             { RETRACT; } break;
  94.         case 2:
  95.             { RETRACT; return (string[0]); } break;
  96.         case 3:
  97.             {  return (string[0]); } break;
  98.         case 4:
  99.             {  lexError(string, "invalid number"); return(LEX_ERROR); } break;
  100.         case 5:
  101.             { lexError(string, "invalid string"); return(LEX_ERROR); } break;
  102.         case 6:
  103.             { lexError(string, "invalid char");   return(LEX_ERROR); } break;
  104.         case 7:
  105.             { RETRACT; return (getNum (string, "%o", &yylval)); } break;
  106.         case 8:
  107.             { RETRACT; return (getNum (&string[2], "%x", &yylval)); } break;
  108.         case 9:
  109.             { RETRACT; return (getNum (&string[1], "%x", &yylval)); } break;
  110.         case 10:
  111.             { RETRACT; return (getNum (string, "%d", &yylval)); } break;
  112.         case 11:
  113.             { RETRACT; return (getFloat (string, &yylval)); } break;
  114.         case 12:
  115.             { RETRACT; return (getId (string, &yylval)); } break;
  116.         case 13:
  117.             { return (getString (string, nChars, &yylval)); } break;
  118.         case 14:
  119.             { return (getChar (string, nChars, &yylval)); } break;
  120.         case 15:
  121.             { return (OR); } break;
  122.         case 16:
  123.             { return (AND); } break;
  124.         case 17:
  125.             { return (EQ); } break;
  126.         case 18:
  127.             { return (NE); } break;
  128.         case 19:
  129.             { return (GE); } break;
  130.         case 20:
  131.             { return (LE); } break;
  132.         case 21:
  133.             { RETRACT; return (ROT_RIGHT); } break;
  134.         case 22:
  135.             { RETRACT; return (ROT_LEFT); } break;
  136.         case 23:
  137.             { return (PTR); } break;
  138.         case 24:
  139.             { return (INCR); } break;
  140.         case 25:
  141.             { return (DECR); } break;
  142.         case 26:
  143.             { return (ADDA); } break;
  144.         case 27:
  145.             { return (SUBA); } break;
  146.         case 28:
  147.             { return (MULA); } break;
  148.         case 29:
  149.             { return (DIVA); } break;
  150.         case 30:
  151.             { return (MODA); } break;
  152.         case 31:
  153.             { return (SHLA); } break;
  154.         case 32:
  155.             { return (SHRA); } break;
  156.         case 33:
  157.             { return (ANDA); } break;
  158.         case 34:
  159.             { return (ORA); } break;
  160.         case 35:
  161.             { return (XORA); } break;
  162.         case 36:
  163.             { return (NL); } break;
  164.         case 37:
  165.             { return (ENDFILE); } break;
  166.         }
  167.     *pContinue = TRUE;
  168.     return (0);
  169.     }
  171. int lexNclasses = 27;
  173. signed char lexClass [] =
  174.     {
  175.     26,
  176.     25,  0,  0,  0, 26,  0,  0,  0,  0,  1, 25,  0,  0, 25,  0,  0, 
  177.      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 
  178.      1, 16, 10,  0, 12, 23, 14, 11,  0,  0, 22, 20,  0, 19,  8, 21, 
  179.      2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  0,  0, 18, 15, 17,  0, 
  180.      0,  5,  5,  5,  5,  5,  5,  7,  7,  7,  7,  7,  7,  7,  7,  7, 
  181.      7,  7,  7,  7,  7,  7,  7,  7,  6,  7,  7,  0,  9,  0, 24,  7, 
  182.      0,  5,  5,  5,  5,  5,  5,  7,  7,  7,  7,  7,  7,  7,  7,  7, 
  183.      7,  7,  7,  7,  7,  7,  7,  7,  6,  7,  7,  0, 13,  0,  0,  0, 
  184.     };
  186. signed char lexStateTable [] =
  187.     {
  188.     -3, 1, 2, 8, 8,11,11,11, 9,-3,12,14, 6,19,20,21,22,23,24,25,26,16,27,28,29,-36,-37,
  189.     -1, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  190.     -10,-10, 3, 3,-4,-4, 4,-4,10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,
  191.     -7,-7, 3, 3,-4,-4,-4,-4,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,-7,
  192.     -4,-4, 5, 5, 5, 5,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
  193.     -8,-8, 5, 5, 5, 5,-4,-4,-4,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,
  194.     -4,-4, 7, 7, 7, 7,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
  195.     -9,-9, 7, 7, 7, 7,-4,-4,-4,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,
  196.     -10,-10, 8, 8, 8,-4,-4,-4,10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,
  197.     -11,-11,10,10,10,-4,-4,-4,-4,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,
  198.     -11,-11,10,10,10,-4,-4,-4,-4,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,-11,
  199.     -12,-12,11,11,11,11,11,11,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,-12,
  200.     12,12,12,12,12,12,12,12,12,13,-13,12,12,12,12,12,12,12,12,12,12,12,12,12,12,-5,-5,
  201.     12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,-5,-5,
  202.     14,14,14,14,14,14,14,14,14,15,14,-14,14,14,14,14,14,14,14,14,14,14,14,14,14,-6,-6,
  203.     14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,-6,-6,
  204.     -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-29,-2,-2,-2,-2,-2,-2,17,-2,-2,-2,-2,
  205.     17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,18,17,17,17,17,
  206.     17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17, 0,17,17,17,17,17,
  207.     -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-15,-2,-34,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  208.     -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-16,-33,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  209.     -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-17,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  210.     -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-18,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  211.     -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-19,-2,30,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  212.     -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-20,-2,-2,31,-2,-2,-2,-2,-2,-2,-2,-2,
  213.     -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-27,-2,-23,-2,-25,-2,-2,-2,-2,-2,-2,-2,
  214.     -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-26,-2,-2,-2,-2,-24,-2,-2,-2,-2,-2,-2,
  215.     -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-28,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  216.     -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-30,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  217.     -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-35,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  218.     -21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-32,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,-21,
  219.     -22,-22,-22,-22,-22,-22,-22,-22,-22,-22,-22,-22,-22,-22,-22,-31,-22,-22,-22,-22,-22,-22,-22,-22,-22,-22,-22,
  220.     };
  221. /*******************************************************************************
  222. *
  223. * lexNewLine - initialize for lexical scan of new line
  224. *
  225. * RETURNS: N/A
  226. */
  227. LOCAL void lexNewLine
  228.     (
  229.     char *line
  230.     )
  231.     {
  232.     lexInit ();
  233.     nextChar = line;
  234.     nextTempString = tempStrings;
  235.     autoState = FIRST_LEXEME;
  236.     }
  237. /*******************************************************************************
  238. *
  239. * yylex - get next lexeme for yacc
  240. *
  241. * This routine is called by yacc to get the next input lexeme.
  242. * In addition to simply calling lexScan to do the scan, this routine
  243. * also handles the automatic insertion of parens around the arguements
  244. * of a "top-level" routine call.  If the first lexeme scanned from a new
  245. * line is a T_SYMBOL (text id) and the second lexeme is NOT a '(',
  246. * then the second lexeme is withheld and a '(' returned instead.
  247. * The withheld lexeme is returned next.  Scanning then proceeds normally
  248. * until a NL (newline) lexeme is scanned.  The NL is withheld and a
  249. * ')' is returned instead, with the NL being returned next.
  250. *
  251. * RETURNS: next lexeme.
  252. */
  253. LOCAL int yylex (void)
  254.     {
  255.     static int heldCode;
  256.     FAST int code;
  257.     switch (autoState)
  258. {
  259.         case FIRST_LEXEME: /* first lex scan of new line */
  260.     code = lexScan ();
  261.     autoState = (code == T_SYMBOL) ? P_OPEN : NORMAL;
  262.     break;
  263. case NORMAL: /* parens not required to be inserted */
  264.     code = lexScan ();
  265.     if (code == ';')
  266. autoState = FIRST_LEXEME;
  267.     break;
  268. case P_OPEN: /* looking for '(' */
  269.     code = lexScan ();
  270.     if (code == '(')
  271. autoState = NORMAL;
  272.     else
  273. {
  274. heldCode = code;
  275. code = '(';
  276. autoState = P_OPEN_DONE;
  277. }
  278.     break;
  279. case P_OPEN_DONE: /* artificial '(' has been returned */
  280.     if ((heldCode == NL) || (heldCode == ';'))
  281. {
  282. code = ')';
  283. autoState = P_CLOSE_DONE;
  284. }
  285.     else
  286. {
  287. code = heldCode;
  288. autoState = P_CLOSE;
  289. }
  290.     break;
  291. case P_CLOSE: /* looking for NL or ';' */
  292.     code = lexScan ();
  293.     if ((code == NL) || (code == ';'))
  294. {
  295. heldCode = code;
  296. code = ')';
  297. autoState = P_CLOSE_DONE;
  298. }
  299.     break;
  300. case P_CLOSE_DONE: /* artificial ')' has been returned */
  301.     code = heldCode;
  302.     autoState = FIRST_LEXEME;
  303.     break;
  304. default:
  305.     printf ("yylex: invalid state %#xn", autoState);
  306.     code = 0; /* invalid? */
  307.     break;
  308. }
  309.     return (code);
  310.     }
  311. /*******************************************************************************
  312. *
  313. * addTempString - add string to temporary storage
  314. *
  315. * This routine adds the specified string to the during-parse temporary
  316. * string storage.
  317. *
  318. * RETURNS: pointer to new string appended to temporary area.
  319. */
  320. LOCAL char *addTempString
  321.     (
  322.     char *string
  323.     )
  324.     {
  325.     char *newString = nextTempString;
  326.     while (*string != EOS)
  327. string += strToChar (string, nextTempString++);
  328.     *(nextTempString++) = EOS;
  329.     return (newString);
  330.     }
  331. /*******************************************************************************
  332. *
  333. * lexError - report error in lex scan
  334. *
  335. * RETURNS: N/A
  336. */
  337. LOCAL void lexError
  338.     (
  339.     char *string,
  340.     char *errmsg
  341.     )
  342.     {
  343.     printf ("%s: %sn", errmsg, string);
  344.     }
  345. /*******************************************************************************
  346. *
  347. * getNum - interpret scanned string as integer
  348. *
  349. * RETURNS: NUMBER
  350. */
  351. LOCAL int getNum
  352.     (
  353.     char *string,
  354.     char *fmtString,
  355.     VALUE *pValue
  356.     )
  357.     {
  358.     pValue->side = RHS;
  359.     pValue->type = T_INT;
  360.     sscanf (string, fmtString, &pValue->value.rv);
  361.     return (NUMBER);
  362.     }
  363. /*******************************************************************************
  364. *
  365. * getFloat - interpret scanned string as float
  366. *
  367. * RETURNS: FLOAT
  368. */
  369. LOCAL int getFloat
  370.     (
  371.     char *string,
  372.     VALUE *pValue
  373.     )
  374.     {
  375. #ifndef _WRS_NO_TGT_SHELL_FP
  376.     pValue->side = RHS;
  377.     pValue->type = T_DOUBLE;
  378.     sscanf (string, "%lf", &pValue->value.dp);
  379. #endif /* _WRS_NO_TGT_SHELL_FP */
  380.     return (FLOAT);
  381.     }
  382. /*******************************************************************************
  383. *
  384. * getString - interpret scanned string as quoted string
  385. *
  386. * RETURNS: STRING
  387. */
  388. LOCAL int getString
  389.     (
  390.     char *string,
  391.     int nChars,
  392.     VALUE *pValue
  393.     )
  394.     {
  395.     pValue->side = RHS;
  396.     pValue->type = T_INT;
  397.     string [nChars - 1] = EOS;
  398.     pValue->value.rv = (int)addTempString (&string[1]);
  399.     return (STRING);
  400.     }
  401. /*******************************************************************************
  402. *
  403. * getChar - interpret scanned string as quoted character
  404. *
  405. * RETURNS: CHAR
  406. */
  407. LOCAL int getChar
  408.     (
  409.     char *string,
  410.     int nChars,
  411.     VALUE *pValue
  412.     )
  413.     {
  414.     char ch;
  415.     int n = strToChar (&string [1], &ch);
  416.     if (nChars != (n + 2))
  417. {
  418. lexError (string, "invalid char"); 
  419. return (LEX_ERROR);
  420. }
  421.     pValue->side       = RHS;
  422.     pValue->type       = T_BYTE;
  423.     pValue->value.byte = ch;
  424.     return (CHAR);
  425.     }
  426. /*******************************************************************************
  427. *
  428. * getId - interpret scanned string as identifier or keyword
  429. *
  430. * RETURNS: TYPECAST, {T,D,U}_SYMBOL
  431. */
  432. LOCAL int getId
  433.     (
  434.     char *string,
  435.     FAST VALUE *pValue
  436.     )
  437.     {
  438.     char     tempString [MAX_SHELL_LINE + 1];
  439.     SYM_TYPE type;
  440.     char     *value;
  441.     int      t = typeCast (string);
  442.     if (t != ERROR)
  443. {
  444. pValue->type = (TYPE)t;
  445. return (TYPECAST);
  446. }
  447.     tempString[0] = '_';
  448.     strncpy (&tempString[1], string, MAX_SHELL_LINE);
  449.     tempString [MAX_SHELL_LINE] = EOS;
  450.     if ((symFindByName (sysSymTbl, &tempString[1], &value, &type) == OK) ||
  451.         (symFindByName (sysSymTbl, &tempString[0], &value, &type) == OK) ||
  452.         (type = N_TEXT, value = (char *) taskNameToId (&tempString[1]),
  453.  (int) value != ERROR))
  454. {
  455. pValue->value.lv = (int *) value;
  456. pValue->type     = T_INT;
  457. pValue->side     = LHS;
  458. if ((type & 0xe) == N_TEXT) /* only need to check three bits of type*/
  459.     return (T_SYMBOL);
  460. else
  461.     return (D_SYMBOL);
  462. }
  463.     if (sysAdaEnable)
  464. {
  465. /* check for ada names of the form "_A_<symbolname>.<anything>"
  466.  * a match occurs only if the result is unambiguous. */
  467. switch (numAdaIdMatches (string, &type, (int *) &pValue->value.lv))
  468.     {
  469.     case 0:
  470. break;
  471.     case 1:
  472. pValue->type = T_INT;
  473. pValue->side = LHS;
  474. if (type & N_TEXT)
  475.     return (T_SYMBOL);
  476. else
  477.     return (D_SYMBOL);
  478.     default:
  479. printf ("%s: ambiguous Ada identifier - Possibilities include:n", string);
  480. symEach (sysSymTbl, (FUNCPTR)printAdaIdMatch, (int)string);
  481.     }
  482. }
  483.     if (sysCplusEnable)
  484. {
  485. /* check for mangled C++ names; return unique match or nothing */
  487. if (cplusMatchMangled(sysSymTbl, string, &type,
  488.     (int *) &pValue->value.lv))
  489.     {
  490.     pValue->type = T_INT;
  491.     pValue->side = LHS;
  492.       if ((type & N_TYPE) == N_TEXT)
  493. return T_SYMBOL;
  494.     else
  495. return D_SYMBOL;
  496.     }
  497. }
  498.     /* identifier not found */
  500.     pValue->side = RHS;
  501.     pValue->type = T_UNKNOWN;
  502.     pValue->value.rv = (int)addTempString (string);
  503.     return (U_SYMBOL);
  504.     }
  505. /* HIDDEN */
  506. typedef struct
  507.     {
  508.     char *string;
  509.     int numOccurrences;
  510.     SYM_TYPE type;
  511.     int value;
  512.     } ADA_MATCH;
  513. /* END HIDDEN */
  514. /*******************************************************************************
  515. *
  516. * numAdaIdMatches - attempt to match id with bizarre ada names
  517. *
  518. * RETURNS: number of potential matches
  519. */
  520. LOCAL int numAdaIdMatches
  521.     (
  522.     char *string,
  523.     SYM_TYPE *pType,
  524.     int *pValue
  525.     )
  526.     {
  527.     ADA_MATCH adaMatch;
  528.     adaMatch.string = string;
  529.     adaMatch.numOccurrences = 0;
  530.     symEach (sysSymTbl, (FUNCPTR)countAdaIdMatch, (int)&adaMatch);
  531.     *pType = adaMatch.type;
  532.     *pValue = adaMatch.value;
  533.     return (adaMatch.numOccurrences);
  534.     }
  535. /*******************************************************************************
  536. *
  537. * countAdaIdMatch - count number of symbols that match id as Ada symbol
  538. *
  539. * count ada names of the form "_A_<id>.<anything>"
  540. * called via symEach.
  541. *
  542. * RETURNS: TRUE
  543. */
  544. LOCAL BOOL countAdaIdMatch
  545.     (
  546.     char *symbol, /* symbol from symbol table */
  547.     int val,
  548.     SYM_TYPE type,
  549.     int arg
  550.     )
  551.     {
  552.     FAST ADA_MATCH *pAdaMatch = (ADA_MATCH *) arg;
  553.     if (adaIdMatch (symbol, pAdaMatch->string))
  554. {
  555. pAdaMatch->numOccurrences++;
  556. pAdaMatch->type = type;
  557. pAdaMatch->value = val;
  558. }
  559.     return (TRUE);
  560.     }
  561. /*******************************************************************************
  562. *
  563. * printAdaIdMatch - print a symbol if it is a potential ada name match
  564. *
  565. * called via symEach
  566. *
  567. * RETURNS: TRUE
  568. *
  569. * ARGSUSED2
  570. */
  571. LOCAL BOOL printAdaIdMatch
  572.     (
  573.     char *symbol, /* symbol from symbol table */
  574.     int val,
  575.     SYM_TYPE type,
  576.     int arg /* id being sought */
  577.     )
  578.     {
  579.     if (adaIdMatch (symbol, (char *) arg))
  580. printf ("%sn", symbol);
  581.     return (TRUE);
  582.     }
  583. /*******************************************************************************
  584. *
  585. * adaIdMatch - determine if a symbol is an Ada match for an id.
  586. *
  587. * RETURNS: TRUE if symbol is of form "_A_<id>" or "_A_<id>.<anything>".
  588. */
  589. LOCAL BOOL adaIdMatch
  590.     (
  591.     FAST char *symbol,
  592.     FAST char *id
  593.     )
  594.     {
  595.     if ((symbol [0] != '_') || (symbol [1] != 'A') || (symbol [2] != '_'))
  596. return (FALSE);
  597.     symbol += 3; /* skip "_A_" */
  598.     while ((*id != EOS) && (*symbol != EOS) && (*id == *symbol))
  599. {
  600. ++id;
  601. ++symbol;
  602. }
  603.     return ((*id == EOS) && ((*symbol == EOS) || (*symbol == '.')));
  604.     }
  605. /*******************************************************************************
  606. *
  607. * typeCast - determine if string is a keyword type cast
  608. *
  609. * RETURNS: T_{BYTE,WORD,INT,FLOAT,DOUBLE}, or ERROR
  610. */
  611. LOCAL int typeCast
  612.     (
  613.     FAST char *string
  614.     )
  615.     {
  616.     static char *typen [] =
  617. #ifndef _WRS_NO_TGT_SHELL_FP
  618. {"char", "short", "int", "long", "float", "double"};
  619. #else /* _WRS_NO_TGT_SHELL_FP */
  620. {"char", "short", "int", "long"};
  621. #endif /* _WRS_NO_TGT_SHELL_FP */
  622.     static TYPE  typet [] =
  623. #ifndef _WRS_NO_TGT_SHELL_FP
  624. {T_BYTE, T_WORD, T_INT, T_INT, T_FLOAT, T_DOUBLE};
  625. #else /* _WRS_NO_TGT_SHELL_FP */
  626. {T_BYTE, T_WORD, T_INT, T_INT};
  627. #endif /* _WRS_NO_TGT_SHELL_FP */
  628.     FAST int ix;
  629.     for (ix = 0; ix < NELEMENTS (typet); ix++)
  630. {
  631. if (strcmp (string, typen [ix]) == 0)
  632.     return ((int)typet [ix]);
  633. }
  634.     return (ERROR);
  635.     }
  636. /*******************************************************************************
  637. *
  638. * strToChar - get a possibly escaped character from a string
  639. *
  640. * RETURNS: number of characters parsed and character in <pChar>.
  641. */
  642. LOCAL int strToChar
  643.     (
  644.     FAST char *string,
  645.     char *pChar
  646.     )
  647.     {
  648.     FAST int nchars = 1;
  649.     int num;
  650.     FAST char ch;
  651.     if (*string != '\')
  652. {
  653. *pChar = *string;
  654. return (nchars);
  655. }
  656.     string++;
  657.     if ((*string >= '0') && (*string <= '7'))
  658. {
  659. sscanf (string, "%o", &num);
  660. ch = num % 0400;
  661. while ((*string >= '0') && (*string <= '7'))
  662.     {
  663.     ++string;
  664.     ++nchars;
  665.     }
  666. }
  667.     else
  668. {
  669. nchars++;
  670. switch (*string)
  671.     {
  672.     case 'n':  ch = 'n'; break;
  673.     case 't':  ch = 't'; break;
  674.     case 'b':  ch = 'b'; break;
  675.     case 'r':  ch = 'r'; break;
  676.     case 'f':  ch = 'f'; break;
  677.     case '\': ch = '\'; break;
  678.     case ''': ch = '''; break;
  679.     case '"':  ch = '"'; break;
  680.     case 'a':  ch = (char)0x07; break;
  681.     case 'v':  ch = (char)0x0b; break;
  682.     default:   ch = *string; break;
  683.     }
  684. }
  685.     *pChar = ch;
  686.     return (nchars);
  687.     }
  688. /* lexeme scan routines */
  689. #define EMPTY -2
  690. LOCAL int retractChar;
  691. LOCAL int lastChar;
  692. /*******************************************************************************
  693. *
  694. * lexInit - initialize lex scan routines
  695. *
  696. * RETURNS: N/A
  697. */
  698. LOCAL void lexInit (void)
  699.     {
  700.     retractChar = EMPTY;
  701.     }
  702. /*******************************************************************************
  703. *
  704. * lexScan - scan input for next lexeme
  705. *
  706. * RETURNS: next lexeme.
  707. */
  708. LOCAL int lexScan (void)
  709.     {
  710.     FAST int ch;
  711.     FAST int state;
  712.     int nChars;
  713.     int code;
  714.     BOOL scanContinue;
  715.     char string [MAX_SHELL_LINE + 1];
  716.     do
  717. {
  718. /* get first character; use any retracted character first */
  719. if (retractChar != EMPTY)
  720.     {
  721.     ch = retractChar;
  722.     retractChar = EMPTY;
  723.     }
  724. else
  725.     ch = *(nextChar++);
  726. /* consume characters until final state reached */
  727. state = 0;
  728. for (nChars = 0; nChars < MAX_SHELL_LINE; nChars++)
  729.     {
  730.     /* consume character and make state transition */
  731.     string [nChars] = ch;
  732.     state = lexStateTable [state * lexNclasses + lexClass [ch + 1]];
  733.     /* if final state reached, quit; otherwise get next character */
  734.     if (state < 0)
  735. {
  736. nChars++;
  737. break;
  738. }
  739.     ch = *(nextChar++);
  740.     }
  741. /* final state reached */
  742. state = -state;
  743. string [nChars] = EOS;
  744. lastChar = ch;
  745. code = lexActions (state, string, nChars, &scanContinue);
  746. }
  747.     while (scanContinue);
  748.     return (code);
  749.     }
  750. /*******************************************************************************
  751. *
  752. * lexRetract - retract last character consumed
  753. *
  754. * RETURNS: N/A
  755. */
  756. LOCAL void lexRetract (void)
  757.     {
  758.     retractChar = lastChar;
  759.     }