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

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

VxWorks

开发平台：

C/C++

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