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

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

VxWorks

开发平台：

C/C++

shell.c：源码内容
  2. # line 2 "shell.yacc"
  3. /* shell.yacc - grammar for VxWorks shell */
  5. /* Copyright 1984-2001 Wind River Systems, Inc. */
  6. #include "copyright_wrs.h"
  8. /*
  9. modification history
  10. --------------------
  11. 07m,16oct01,jn   use symFindSymbol for symbol lookups
  12. 07l,27nov01,pch  Provide floating-point exclusion based on _WRS_NO_TGT_SHELL_FP
  13.  definition instead of testing a specific CPU type.
  14. 07k,23oct01,fmk  Do not call symFindByValue and print symbol name if symbol
  15.                  value = -1 SPR 22254
  16. 07j,04sep98,cdp  apply 07i for all ARM CPUs with ARM_THUMB==TRUE.
  17. 07i,30jul97,cdp  for ARM7TDMI_T, force calls to be in Thumb state.
  18. 07h,31may96,ms   added in patch for SPR 4439.
  19. 07g,19mar95,dvs  removed tron references.
  20. 07f,02mar95,yao  removed floating point temporarily for PPC403.
  21. 07e,19mar95,dvs  removed tron references.
  22. 07d,13feb93,kdl  changed cplusLib.h to private/cplusLibP.h (SPR #1917).
  23. 07c,03sep92,wmd  modified addArg() to pass floats correcty for the i960.
  24. 07b,03sep92,rrr  reduced max function arguments from 16 to 12 (for i960).
  25. 07a,31aug92,kdl  fixed passing of more than 10 parameters during funcCall();
  26.  changed MAX_ARGS to MAX_SHELL_ARGS.
  27. 06z,19aug92,jmm  fixed problem with not recognizing <= (SPR 1517)
  28. 06y,01aug92,srh  added C++ demangling idiom to printSym.
  29.                  added include of cplusLib.h.
  30. 06x,20jul92,jmm  added group parameter to symAdd call
  31. 06w,23jun92,kdl  increased max function arguments from 10 to 16.
  32. 06v,22jun92,jmm  backed out 6u change, now identical to gae's 21dec revision
  33. 06u,22jun92,jmm  added group parameter to symAdd
  34. 06t,21dec91,gae  more ANSI cleanups.
  35. 06s,19nov91,rrr  shut up some warnings.
  36. 06r,05oct91,rrr  changed strLib.h to string.h
  37. 06q,02jun91,del  added I960 parameter alignment fixes.
  38. 06p,10aug90,kdl  added forward declarations for functions returning VOID.
  39. 06o,10jul90,dnw  spr 738: removed checking of access (checkAccess, chkLvAccess)
  40.    Access checking did vxMemProbe with 4 byte read, which
  41.    caused problems with memory or devices that couldn't do
  42.    4 byte reads but could do other types of access.
  43.    Access checking was actually a throw-back to a time when
  44.    the shell couldn't recover from bus errors, but it can now.
  45.    So I just deleted the access checking.
  46.  lint clean-up, esp to allow VOID to be void one day.
  47. 06n,10dec89,jcf  symbol table type now a SYM_TYPE.
  48. 06m,09aug89,gae  fixed copyright notice.
  49. 06l,30jul89,gae  changed obsolete sysMemProbe to vxMemProbe. 
  50. 06k,07jul88,jcf  changed malloc to match new declaration.
  51. 06j,30may88,dnw  changed to v4 names.
  52. 06i,01apr88,gae  made it work with I/O system changes -- io{G,S}etGlobalStd().
  53. 06h,20feb88,dnw  lint
  54. 06g,14dec87,dnw  removed checking for odd byte address access.
  55.  changed printing format of doubles from "%f" to "%g". 
  56. 06f,18nov87,gae  made assignment to be of type specified by rhs.
  57. 06e,07nov87,gae  fixed undefined symbol bug.
  58.  fixed history bug by redirecting LED I/O.
  59. 06d,03nov87,ecs  documentation.
  60. 06c,28oct87,gae  got rid of string type.
  61. 06b,06oct87,gae  split off "execution" portion to shellExec.c.
  62.  changed to use conventional C type casting.
  63.  provided more info for invalid yacc operations.
  64.  allowed expressions to be function addresses.
  65. 06a,01jun87,gae  added interpretation of bytes, words, floats, doubles;
  66.    expressions can now be "typed" a la assembler, .[bwfdls].
  67.  fixed redirection bug with ">>" and "<<".
  68. 05i,16jul87,ecs  fixed newSym so that new symbols will be global.
  69. 05h,01apr87,gae  made assign() not print "new value" message (duplicated
  70.    normal "value" message for expressions.
  71. 05g,25apr87,gae  fixed bug in assign() that allowed memory corruption.
  72.  checked h() parameter for greater than or equal to zero.
  73.  improved redirection detection.
  74.  now parse assignments correctly as expressions.
  75. 05f,01apr87,ecs  added include of strLib.h.
  76. 05e,20jan87,jlf  documentation.
  77. 05d,14jan87,gae  got rid of unused curLineNum.  h() now has parameter, if
  78.    non-zero then resets history to that size.
  79. 05c,20dec86,dnw  changed to not get include files from default directories.
  80. 05b,18dec86,gae  made history initialization only happen on first start of
  81.    shell.  Added neStmt to fix empty stmt assignment bug.
  82. 05a,17dec86,gae  use new shCmd() in execShell() to do Korn shell-like input.
  83. 04q,08dec86,dnw  changed shell.slex.c to shell_slex.c for VAX/VMS compatiblity.
  84.     jlf  fixed a couple bugs causing problems mainly on Heurikon port.
  85. 04p,24nov86,llk  deleted SYSTEM conditional compiles.
  86. 04o,08oct86,gae  added C assignment operators; allowed multiple assignment.
  87.  STRINGs are no longer temporary.  Added setShellPrompt().
  88. 04n,27jul86,llk  added standard error fd, setOrigErrFd.
  89. 04m,17jun86,rdc  changed memAllocates to mallocs.
  90. 04l,08apr86,dnw  added call to vxSetTaskBreakable to make shell unbreakable.
  91.  changed sstLib calls to symLib.
  92. 04k,02apr86,rdc  added routines setOrigInFd and setOrigOutFd.
  93. 04j,18jan86,dnw  removed resetting (flushing) for standard in/out upon restarts;
  94.    this is now done more appropriately by the shell restart
  95.    routine in dbgLib.
  96. ...deleted pre 86 history - see RCS
  97. */
  99. /*
  100. DESCRIPTION
  101. This is the parser for the VxWorks shell, written in yacc.
  102. It provides the basic programmer's interface to VxWorks.
  103. It is a C expression interpreter, containing no built-in commands.  
  105. SEE ALSO: "Shell"
  106. */
  108. #include "vxWorks.h"
  109. #include "sysSymTbl.h"
  110. #include "errno.h"
  111. #include "errnoLib.h"
  112. #include "ioLib.h"
  113. #include "taskLib.h"
  114. #include "stdio.h"
  115. #include "private/cplusLibP.h"
  117. #define YYSTYPE VALUE /* type of parse stack */
  119. #define MAX_SHELL_LINE 128 /* max chars on line typed to shell */
  121. #define MAX_SHELL_ARGS 30 /* max number of args on stack */
  122. #define MAX_FUNC_ARGS 12 /* max number of args to any one function */
  123. /*  NOTE: The array indices in funcCall()
  124.  *        must agree with MAX_FUNC_ARGS!!
  125.  */
  127. #define BIN_OP(op) rvOp((getRv(&yypvt[-2], &tmpVal1)), op, 
  128.       getRv(&yypvt[-0], &tmpVal2))
  130. #define RV(value) (getRv (&(value), &tmpVal2))
  131. #define NULLVAL (VALUE *) NULL
  133. #define CHECK if (semError) YYERROR
  134. #define SET_ERROR semError = TRUE
  137. typedef enum /* TYPE */
  138.     {
  139.     T_UNKNOWN,
  140.     T_BYTE,
  141.     T_WORD,
  142. #ifndef _WRS_NO_TGT_SHELL_FP
  143.     T_INT,
  144.     T_FLOAT,
  145.     T_DOUBLE
  146. #else /* _WRS_NO_TGT_SHELL_FP */
  147.     T_INT
  148. #endif /* _WRS_NO_TGT_SHELL_FP */
  149.     } TYPE;
  151. typedef enum /* SIDE */
  152.     {
  153.     LHS,
  154.     RHS,
  155.     FHS /* function: rhs -> lhs */
  156.     } SIDE;
  158. typedef struct /* VALUE */
  159.     {
  160.     SIDE side;
  161.     TYPE type;
  162.     union
  163. {
  164. int *lv; /* pointer to any of the below */
  166. char byte;
  167. short word;
  168. int rv;
  169. char *string;
  170. #ifndef _WRS_NO_TGT_SHELL_FP
  171. float fp;
  172. double dp;
  173. #endif /* _WRS_NO_TGT_SHELL_FP */
  174. } value;
  175.     } VALUE;
  177. IMPORT int redirInFd;
  178. IMPORT int redirOutFd;
  180. LOCAL BOOL semError; /* TRUE = semantic error found */
  181. LOCAL VALUE tmpVal1; /* used by BIN_OP above for expression evaluation */
  182. LOCAL VALUE tmpVal2; /* used by BIN_OP above for expression evaluation */
  183. LOCAL int argStack [MAX_SHELL_ARGS]; /* arguments to functions */
  184. LOCAL int nArgs; /* number of args currently on argStack */
  185. LOCAL BOOL usymFlag; /* TRUE = U_SYMBOL has been seen */
  186. LOCAL VALUE usymVal; /* value of U_SYMBOL which has been seen */
  187. LOCAL BOOL spawnFlag; /* TRUE if spawn is first parameter in argStack[] */
  189. # define NL 0
  190. # define T_SYMBOL 258
  191. # define D_SYMBOL 259
  192. # define U_SYMBOL 260
  193. # define NUMBER 261
  194. # define CHAR 262
  195. # define STRING 263
  196. # define FLOAT 264
  197. # define OR 265
  198. # define AND 266
  199. # define EQ 267
  200. # define NE 268
  201. # define GE 269
  202. # define LE 270
  203. # define INCR 271
  204. # define DECR 272
  205. # define ROT_LEFT 273
  206. # define ROT_RIGHT 274
  207. # define UMINUS 275
  208. # define PTR 276
  209. # define TYPECAST 277
  210. # define ENDFILE 278
  211. # define LEX_ERROR 279
  212. # define MULA 280
  213. # define DIVA 281
  214. # define MODA 282
  215. # define ADDA 283
  216. # define SUBA 284
  217. # define SHLA 285
  218. # define SHRA 286
  219. # define ANDA 287
  220. # define ORA 288
  221. # define XORA 289
  222. # define UNARY 290
  224. #ifdef __STDC__
  225. #include <stdlib.h>
  226. #include <string.h>
  227. #else
  228. #include <malloc.h>
  229. #include <memory.h>
  230. #endif
  232. #if defined(__cplusplus) || defined(__STDC__)
  234. #if defined(__cplusplus) && defined(__EXTERN_C__)
  235. extern "C" {
  236. #endif
  237. #ifndef yyerror
  238. #if defined(__cplusplus)
  239. void yyerror(const char *);
  240. #endif
  241. #endif
  242. #ifndef yylex
  243. int yylex(void);
  244. #endif
  245. int yyparse(void);
  246. #if defined(__cplusplus) && defined(__EXTERN_C__)
  247. }
  248. #endif
  250. #endif
  252. #define yyclearin yychar = -1
  253. #define yyerrok yyerrflag = 0
  254. extern int yychar;
  255. extern int yyerrflag;
  256. #ifndef YYSTYPE
  257. #define YYSTYPE int
  258. #endif
  259. YYSTYPE yylval;
  260. YYSTYPE yyval;
  261. typedef int yytabelem;
  262. #ifndef YYMAXDEPTH
  263. #define YYMAXDEPTH 150
  264. #endif
  265. #if YYMAXDEPTH > 0
  266. int yy_yys[YYMAXDEPTH], *yys = yy_yys;
  267. YYSTYPE yy_yyv[YYMAXDEPTH], *yyv = yy_yyv;
  268. #else /* user does initial allocation */
  269. int *yys;
  270. YYSTYPE *yyv;
  271. #endif
  272. static int yymaxdepth = YYMAXDEPTH;
  273. # define YYERRCODE 256
  275. # line 335 "shell.yacc"
  278. #include "a_out.h"
  279. #include "ctype.h"
  280. #include "stdlib.h"
  281. #include "string.h"
  282. #include "symLib.h"
  284. #include "shell_slex_c"
  286. /* forward declarations */
  288. LOCAL int newString ();
  289. LOCAL VALUE *getRv ();
  290. LOCAL int *getLv ();
  291. LOCAL VALUE evalExp ();
  292. #ifndef _WRS_NO_TGT_SHELL_FP
  293. LOCAL void doubleToInts ();
  294. #endif /* _WRS_NO_TGT_SHELL_FP */
  295. LOCAL void setRv ();
  296. LOCAL void typeConvert ();
  297. LOCAL BOOL checkLv ();
  298. LOCAL BOOL checkRv ();
  300. /*******************************************************************************
  301. *
  302. * yystart - initialize local variables
  303. *
  304. * NOMANUAL
  305. */
  307. void yystart (line)
  308.     char *line;
  310.     {
  311.     lexNewLine (line);
  312.     semError = FALSE;
  313.     usymFlag = FALSE;
  314.     nArgs = 0;
  315.     spawnFlag = FALSE;
  316.     }
  317. /*******************************************************************************
  318. *
  319. * yyerror - report error
  320. *
  321. * This routine is called by yacc when an error is detected.
  322. */
  324. LOCAL void yyerror (string)
  325.     char *string;
  327.     {
  328.     if (semError) /* semantic errors have already been reported */
  329. return;
  331.     /* print error depending on what look-ahead token is */
  333.     switch (yychar)
  334. {
  335. case U_SYMBOL: /* U_SYM not at beginning of line */
  336.     printf ("undefined symbol: %sn", (char *) yylval.value.rv);
  337.     break;
  339. case LEX_ERROR:      /* lex should have already reported the problem */
  340.     break;
  342. default:
  343.     if (usymFlag)    /* leading U_SYM was followed by invalid assign */
  344. printf ("undefined symbol: %sn", (char *)usymVal.value.rv);
  345.     else
  346. printf ("%sn", string);
  347.     break;
  348. }
  349.     }
  350. /*******************************************************************************
  351. *
  352. * rvOp - sets rhs of yyval to evaluated expression
  353. */
  355. LOCAL void rvOp (pY1, op, pY2)
  356.     VALUE *pY1;
  357.     int op;
  358.     VALUE *pY2;
  360.     {
  361.     VALUE yy;
  363.     yy = evalExp (pY1, op, pY2);
  365.     setRv (&yyval, &yy);
  366.     }
  367. /*******************************************************************************
  368. *
  369. * assign - make assignment of new value to a cell
  370. */
  372. LOCAL void assign (pLv, pRv)
  373.     FAST VALUE *pLv; /* lhs to be assigned into */
  374.     FAST VALUE *pRv; /* rhs value */
  376.     {
  377.     VALUE val;
  379.     /* verify that lv can be assigned to, then make the assignment */
  381.     if (checkLv (pLv) && checkRv (pRv))
  382. {
  383. (void)getRv (pRv, &val);
  385. /* make value agree in type */
  387. pLv->type = pRv->type;
  389. typeConvert (&val, pLv->type, RHS);
  391. switch (pLv->type)
  392.     {
  393.     case T_BYTE:
  394. * (char *)getLv (pLv) = val.value.byte;
  395. break;
  397.     case T_WORD:
  398. * (short *)getLv (pLv) = val.value.word;
  399. break;
  401.     case T_INT:
  402. *getLv (pLv) = val.value.rv;
  403. break;
  405. #ifndef _WRS_NO_TGT_SHELL_FP
  406.     case T_FLOAT:
  407. * (float *)getLv (pLv) = val.value.fp;
  408. break;
  410.     case T_DOUBLE:
  411. * (double *)getLv (pLv) = val.value.dp;
  412. break;
  413. #endif /* _WRS_NO_TGT_SHELL_FP */
  415.     default:
  416. printf ("bad assignment.n");
  417. SET_ERROR;
  418.     }
  419. }
  420.     else
  421. {
  422. printf ("bad assignment.n");
  423. SET_ERROR;
  424. }
  425.     }
  426. /*******************************************************************************
  427. *
  428. * newString - allocate and copy a string
  429. */
  431. LOCAL int newString (string)
  432.     char *string;
  434.     {
  435.     int length    = strlen (string) + 1;
  436.     char *address = (char *) malloc ((unsigned) length);
  438.     if (address == NULL)
  439. {
  440. printf ("not enough memory for new string.n");
  441. SET_ERROR;
  442. }
  443.     else
  444. bcopy (string, address, length);
  446.     return ((int)address);
  447.     }
  448. /*******************************************************************************
  449. *
  450. * newSym - allocate a new symbol and add to symbol table
  451. */
  453. LOCAL VALUE newSym (name, type)
  454.     char *name;
  455.     TYPE type;
  457.     {
  458.     VALUE value;
  459.     void *address = (void *) malloc (sizeof (double));
  461.     if (address == NULL)
  462. {
  463. printf ("not enough memory for new variable.n");
  464. SET_ERROR;
  465. }
  467.     else if (symAdd (sysSymTbl, name, (char *) address, (N_BSS | N_EXT),
  468.                      symGroupDefault) != OK)
  469. {
  470. free ((char *) address);
  471. printf ("can't add '%s' to system symbol table - error = 0x%x.n",
  472. name, errnoGet());
  473. SET_ERROR;
  474. }
  475.     else
  476. {
  477. printf ("new symbol "%s" added to symbol table.n", name);
  479. value.side = LHS;
  480. value.type = type;
  481. value.value.lv = (int *) address;
  482. }
  484.     return (value);
  485.     }
  486. /*******************************************************************************
  487. *
  488. * printSym - print symbolic value
  489. */
  491. LOCAL void printSym (val, prefix, suffix)
  492.     FAST int val;
  493.     char *prefix;
  494.     char *suffix;
  496.     {
  497.     void *    symVal;  /* symbol value      */
  498.     SYMBOL_ID symId;   /* symbol identifier */
  499.     char *    name;    /* symbol name       */
  500.     char      demangled [MAX_SYS_SYM_LEN + 1];
  501.     char *    nameToPrint;
  503.     /* Only search for symbol value and print symbol name if value is not -1 */
  504.     
  505.         if ((val != -1) && 
  506.     (symFindSymbol (sysSymTbl, NULL, (void *)val, 
  507.         SYM_MASK_NONE, SYM_MASK_NONE, &symId) == OK) &&
  508.     (symNameGet (symId, &name) == OK) &&
  509.     (symValueGet (symId, &symVal) == OK) &&
  510.     (symVal != 0) && ((val - (int)symVal) < 0x1000))
  511.     {
  512.     printf (prefix);
  514.     nameToPrint = cplusDemangle(name, demangled, sizeof (demangled));
  516.     if (val == (int) symVal)
  517.         printf ("%s", nameToPrint);
  518.     else
  519.         printf ("%s + 0x%x", nameToPrint, val - (int) symVal);
  521.     printf (suffix);
  522.     }
  523.     
  524.     }
  525. /*******************************************************************************
  526. *
  527. * newArgList - start a new argument list
  528. */
  530. LOCAL VALUE newArgList ()
  531.     {
  532.     VALUE value;
  534.     value.side    = RHS;
  535.     value.type    = T_INT;
  536.     value.value.rv = nArgs;
  538.     return (value);
  539.     }
  540. /*******************************************************************************
  541. *
  542. * addArg - add an argument to an argument list
  543. */
  545. LOCAL void addArg (pArgList, pNewArg)
  546.     VALUE *pArgList;
  547.     FAST VALUE *pNewArg;
  549.     {
  550.     VALUE val;
  551.     int partA;
  552.     int partB;
  553. #if CPU_FAMILY==I960
  554.     int nArgsSave;
  555. #endif
  556. #ifndef _WRS_NO_TGT_SHELL_FP
  557.     BOOL isfloat = pNewArg->type == T_FLOAT || pNewArg->type == T_DOUBLE;
  558. #endif /* _WRS_NO_TGT_SHELL_FP */
  559.     SYMBOL_ID   symId;  /* symbol identifier           */
  560.     SYM_TYPE    sType;  /* place to return symbol type */
  562. #ifndef _WRS_NO_TGT_SHELL_FP
  563.     if (isfloat)
  564. #if CPU_FAMILY!=I960
  565. nArgs++; /* will need an extra arg slot */
  566. #else /* CPU_FAMILY!=I960 */
  567. {
  568. nArgsSave = nArgs;
  569. if (spawnFlag)
  570.     {
  571.     if ((nArgs %2) == 0)
  572.    nArgs++;
  573.     }
  574. else
  575.     {
  576.     nArgs += nArgs % 2; /* conditionally borrow slot to double align */
  577.     nArgs++; /* borrow second slot for double-word value  */
  578.     }
  579. }
  580. #endif /* CPU_FAMILY!=I960 */
  581. #endif /* _WRS_NO_TGT_SHELL_FP */
  583.     if (nArgs == MAX_SHELL_ARGS || 
  584.         (nArgs - pArgList->value.rv) == MAX_FUNC_ARGS)
  585. {
  586. #ifndef _WRS_NO_TGT_SHELL_FP
  587. if (isfloat)
  588. #if CPU_FAMILY!=I960
  589.     nArgs--; /* return borrowed slot */
  590. #else  /* CPU_FAMILY!=I960 */
  591.     nArgs = nArgsSave; /* return borrowed slot(s) */
  592. #endif /* CPU_FAMILY!=I960 */
  593. #endif /* _WRS_NO_TGT_SHELL_FP */
  594. printf ("too many arguments to functions.n");
  595. SET_ERROR;
  596. }
  597.     else
  598. {
  599. /* push arg value on top of arg stack */
  601. (void)getRv (pNewArg, &val);
  603. #ifndef _WRS_NO_TGT_SHELL_FP
  604. if (isfloat)
  605.     {
  606. #if CPU_FAMILY==I960
  607.     if (spawnFlag == FALSE)
  608. #endif /* CPU_FAMILY==I960 */
  609. nArgs--; /* return borrowed slot */
  610.     
  611.     /* put float as integers on argStack */
  613.     doubleToInts (pNewArg->type == T_FLOAT ?
  614.   val.value.fp : val.value.dp,
  615.   &partA, &partB);
  617.     argStack[nArgs++] = partA;
  618.     argStack[nArgs++] = partB;
  619.     }
  620. else if (checkRv (&val))
  621. #else
  622. if (checkRv (&val))
  623. #endif /* _WRS_NO_TGT_SHELL_FP */
  624.     {
  625.     int rv;
  627.     switch (val.type)
  628. {
  629. case T_BYTE:
  630.     rv = val.value.byte;
  631.     break;
  633. case T_WORD:
  634.     rv = val.value.word;
  635.     break;
  637. case T_INT:
  638.     rv = val.value.rv;
  640.     /* 
  641.      * new symLib api - symbol name lengths are no
  642.      * longer limited 
  643.      */
  645.     if (symFindSymbol (sysSymTbl, NULL, (void *)rv, 
  646.            SYM_MASK_NONE, SYM_MASK_NONE, 
  647.        &symId) == OK)
  648.   symTypeGet (symId, &sType);
  650.     if ((nArgs == 0) && (sType == (N_TEXT + N_EXT)))
  651. spawnFlag = TRUE;
  652.     break;
  654. default:
  655.     rv = 0;
  656.     printf ("addArg: bad type.n");
  657.     SET_ERROR;
  658. }
  660.     argStack[nArgs++] = rv;
  661.     }
  662. }
  663.     }
  664. #ifndef _WRS_NO_TGT_SHELL_FP
  665. /*******************************************************************************
  666. *
  667. * doubleToInts - separate double into two integer parts
  668. */
  670. LOCAL void doubleToInts (d, partA, partB)
  671.     double d;
  672.     int *partA;
  673.     int *partB;
  675.     {
  676.     union 
  677. {
  678. struct
  679.     {
  680.     int a;
  681.     int b;
  682.     } part;
  683. double d;
  684. } val;
  686.     val.d = d;
  688.     *partA = val.part.a;
  689.     *partB = val.part.b;
  690.     }
  691. #endif /* _WRS_NO_TGT_SHELL_FP */
  692. /*******************************************************************************
  693. *
  694. * funcCall - call a function
  695. */
  697. LOCAL VALUE funcCall (pV, pArgList)
  698.     VALUE *pV;
  699.     VALUE *pArgList;
  701.     {
  702.     static int funcStatus; /* status from function calls */
  703.     int a [MAX_FUNC_ARGS];
  704.     VALUE value;
  705.     FAST int i;
  706.     FAST int argNum;
  707.     int oldInFd  = ioGlobalStdGet (STD_IN);
  708.     int oldOutFd = ioGlobalStdGet (STD_OUT);
  709.     FUNCPTR pFunc = (pV->side == LHS) ? (FUNCPTR) (int)getLv (pV)
  710.       : (FUNCPTR) pV->value.rv;
  712. #if ((CPU_FAMILY == ARM) && ARM_THUMB)
  713.     pFunc = (FUNCPTR)((UINT32)pFunc | 1); /* make it a Thumb call */
  714. #endif
  716.     /* get any specified args off stack, or pre-set all args to 0 */
  718.     for (argNum = pArgList->value.rv, i = 0; i < MAX_FUNC_ARGS; argNum++, i++)
  719. {
  720. a [i] = (argNum < nArgs) ? argStack[argNum] : 0;
  721. }
  723.     /* set standard in/out to redirection fds */
  725.     if (redirInFd >= 0)
  726. ioGlobalStdSet (STD_IN, redirInFd);
  728.     if (redirOutFd >= 0)
  729. ioGlobalStdSet (STD_OUT, redirOutFd);
  731.     /* call function and save resulting status */
  733.     errnoSet (funcStatus);
  735.     value.side = RHS;
  736.     value.type = pV->type;
  738.     switch (pV->type)
  739. {
  740. case T_BYTE:
  741. case T_WORD:
  742. case T_INT:
  743.     {
  744.     /* NOTE: THE FOLLOWING ARRAY REFERENCES MUST AGREE WITH THE
  745.      *       MAX_FUNC_ARGS COUNT DEFINED ABOVE IN THIS FILE!
  746.      */
  747.     int rv = (* pFunc) (a[0], a[1], a[2], a[3], a[4], a[5], a[6],
  748. a[7], a[8], a[9], a[10], a[11]);
  750.     switch (pV->type)
  751. {
  752. case T_BYTE:
  753.     value.value.byte = (char) rv;
  754.     break;
  756. case T_WORD:
  757.     value.value.word = (short) rv;
  758.     break;
  760. case T_INT:
  761.     value.value.rv = rv;
  762.     break;
  763. default:
  764.     break;
  765. }
  767.     break;
  768.     }
  770. #ifndef _WRS_NO_TGT_SHELL_FP
  771. case T_FLOAT:
  772.     value.value.fp = (* (float (*)())pFunc) (a[0], a[1], a[2], a[3],
  773. a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11]);
  774.     break;
  776. case T_DOUBLE:
  777.     value.value.dp = (* (double (*)())pFunc) (a[0], a[1], a[2], a[3],
  778. a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11]);
  779.     break;
  780. #endif /* _WRS_NO_TGT_SHELL_FP */
  782. default:
  783.     printf ("funcCall: bad function type.n");
  784.     SET_ERROR;
  785. }
  787.     funcStatus = errnoGet ();
  789.     /* restore original in/out fds */
  791.     if (redirInFd >= 0)
  792. ioGlobalStdSet (STD_IN, oldInFd);
  794.     if (redirOutFd >= 0)
  795. ioGlobalStdSet (STD_OUT, oldOutFd);
  797.     /* arg stack back to previous level */
  799.     nArgs = pArgList->value.rv;
  801.     return (value);
  802.     }
  803. /*******************************************************************************
  804. *
  805. * checkLv - check that a value can be used as left value
  806. */
  808. LOCAL BOOL checkLv (pValue)
  809.     VALUE *pValue;
  811.     {
  812.     if (pValue->side != LHS)
  813. {
  814. printf ("invalid application of 'address of' operator.n");
  815. SET_ERROR;
  816. return (FALSE);
  817. }
  819.     return (TRUE);
  820.     }
  821. /*******************************************************************************
  822. *
  823. * checkRv - check that a value can be used as right value
  824. */
  826. LOCAL BOOL checkRv (pValue)
  827.     VALUE *pValue;
  829.     {
  830.     if (pValue->side == LHS)
  831. return (checkLv (pValue));
  833.     return (TRUE);
  834.     }
  835. /*******************************************************************************
  836. *
  837. * getRv - get a value's right value 
  838. */
  840. LOCAL VALUE *getRv (pValue, pRv)
  841.     FAST VALUE *pValue;
  842.     FAST VALUE *pRv; /* where to put value */
  844.     {
  845.     if (pValue->side == RHS)
  846. *pRv = *pValue;
  847.     else
  848. {
  849. pRv->side = RHS;
  850. pRv->type = pValue->type;
  852. switch (pValue->type)
  853.     {
  854.     case T_BYTE:
  855. pRv->value.byte = *(char *)pValue->value.lv;
  856. break;
  858.     case T_WORD:
  859. pRv->value.word = *(short *)pValue->value.lv;
  860. break;
  862.     case T_INT:
  863. pRv->value.rv = *pValue->value.lv;
  864. break;
  866. #ifndef _WRS_NO_TGT_SHELL_FP
  867.     case T_FLOAT:
  868. pRv->value.fp = *(float *)pValue->value.lv;
  869. break;
  871.     case T_DOUBLE:
  872. pRv->value.dp = *(double *)pValue->value.lv;
  873. break;
  874. #endif /* _WRS_NO_TGT_SHELL_FP */
  876.     default:
  877. printf ("getRv: invalid rhs.");
  878. SET_ERROR;
  879.     }
  880. }
  882.     return (pRv);
  883.     }
  884. /*******************************************************************************
  885. *
  886. * getLv - get a value's left value (address)
  887. */
  889. LOCAL int *getLv (pValue)
  890.     VALUE *pValue;
  892.     {
  893.     return (checkLv (pValue) ? pValue->value.lv : 0);
  894.     }
  895. /*******************************************************************************
  896. *
  897. * setLv - set a lv
  898. */
  900. LOCAL void setLv (pVal1, pVal2)
  901.     FAST VALUE *pVal1;
  902.     FAST VALUE *pVal2;
  904.     {
  905.     if (pVal2->side == LHS)
  906. {
  907. printf ("setLv: invalid lhs.n");
  908. SET_ERROR;
  909. }
  911.     if ((int)pVal2->type != (int)T_INT)
  912. {
  913. printf ("setLv: type conflict.n");
  914. SET_ERROR;
  915. }
  917.     pVal1->side     = LHS;
  918.     pVal1->type     = pVal2->type;
  919.     pVal1->value.lv = (int *)pVal2->value.rv;
  920.     }
  921. /*******************************************************************************
  922. *
  923. * setRv - set the rv
  924. */
  926. LOCAL void setRv (pVal1, pVal2)
  927.     FAST VALUE *pVal1;
  928.     FAST VALUE *pVal2;
  930.     {
  931.     pVal1->side = RHS;
  932.     pVal1->type = pVal2->type;
  934.     switch (pVal2->type)
  935. {
  936. case T_BYTE:
  937.     pVal1->value.byte = (pVal2->side == LHS) ?
  938.     *(char *)pVal2->value.lv : pVal2->value.byte;
  939. case T_WORD:
  940.     pVal1->value.word = (pVal2->side == LHS) ?
  941.     *(short *)pVal2->value.lv : pVal2->value.word;
  943. case T_INT:
  944.     pVal1->value.rv = (pVal2->side == LHS) ?
  945.     *pVal2->value.lv : pVal2->value.rv;
  946.     break;
  948. #ifndef _WRS_NO_TGT_SHELL_FP
  949. case T_FLOAT:
  950.     pVal1->value.fp = (pVal2->side == LHS) ?
  951.     *(float *)pVal2->value.lv : pVal2->value.fp;
  952.     break;
  954. case T_DOUBLE:
  955.     pVal1->value.dp = (pVal2->side == LHS) ?
  956.     *(double *)pVal2->value.lv : pVal2->value.dp;
  957.     break;
  958. #endif /* _WRS_NO_TGT_SHELL_FP */
  960. default:
  961.     printf ("setRv: bad type.n");
  962.     SET_ERROR;
  963. }
  964.     }
  965. /*******************************************************************************
  966. *
  967. * printLv - print left-hand side value
  968. *
  969. * "ssss + xxx = xxxx"
  970. */
  972. LOCAL void printLv (pValue)
  973.     VALUE *pValue;
  975.     {
  976.     FAST int *lv = getLv (pValue);
  978.     printSym ((int) lv, "", " = ");
  980.     printf ("0x%x", (UINT) lv);
  981.     }
  982. /*******************************************************************************
  983. *
  984. * printRv - print right-hand side value
  985. *
  986. * The format for integers is:
  987. *
  988. * "nnnn = xxxx = 'c' = ssss + nnn"
  989. *                           ^ only if nn < LIMIT for some ssss
  990. *                 ^ only if value is printable
  991. */
  993. LOCAL void printRv (pValue)
  994.     VALUE *pValue;
  996.     {
  997.     VALUE val;
  998.     int rv;
  1000.     (void)getRv (pValue, &val);
  1002.     switch (pValue->type)
  1003. {
  1004. case T_BYTE:
  1005.     rv = val.value.byte;
  1006.     goto caseT_INT;
  1008. case T_WORD:
  1009.     rv = val.value.word;
  1010.     goto caseT_INT;
  1012. case T_INT:
  1013.     rv = val.value.rv;
  1014.     /* drop through */
  1016. caseT_INT:
  1017.     printf ("%d = 0x%x", rv, rv);
  1018.     if (isascii (rv) && isprint (rv))
  1019. printf (" = '%c'", rv);
  1021.     printSym (rv, " = ", "");
  1022.     break;
  1024. #ifndef _WRS_NO_TGT_SHELL_FP
  1025. case T_FLOAT:
  1026.     printf ("%g", val.value.fp);
  1027.     break;
  1029. case T_DOUBLE:
  1030.     printf ("%g", val.value.dp);
  1031.     break;
  1032. #endif /* _WRS_NO_TGT_SHELL_FP */
  1034. default:
  1035.     printf ("printRv: bad type.n");
  1036.     SET_ERROR;
  1037. }
  1038.     }
  1039. /*******************************************************************************
  1040. *
  1041. * printValue - print out value
  1042. */
  1044. LOCAL void printValue (pValue)
  1045.     FAST VALUE *pValue;
  1047.     {
  1048.     if (pValue->side == LHS)
  1049. {
  1050. if (checkLv (pValue) && checkRv (pValue))
  1051.     {
  1052.     printLv (pValue);
  1053.     printf (": value = ");
  1055.     printRv (pValue);
  1056.     printf ("n");
  1057.     }
  1058. else
  1059.     {
  1060.     printf ("invalid lhs.n");
  1061.     SET_ERROR;
  1062.     }
  1063. }
  1064.     else if (checkRv (pValue))
  1065. {
  1066. printf ("value = ");
  1068. printRv (pValue);
  1069. printf ("n");
  1070. }
  1071.     else
  1072. {
  1073. printf ("invalid rhs.n");
  1074. SET_ERROR;
  1075. }
  1076.     }
  1078. /* TYPE SUPPORT */
  1080. LOCAL VALUE evalUnknown ();
  1081. LOCAL VALUE evalByte ();
  1082. LOCAL VALUE evalWord ();
  1083. LOCAL VALUE evalInt ();
  1084. LOCAL VALUE evalFloat ();
  1085. LOCAL VALUE evalDouble ();
  1087. typedef struct /* EVAL_TYPE */
  1088.     {
  1089.     VALUE (*eval) ();
  1090.     } EVAL_TYPE;
  1092. LOCAL EVAL_TYPE evalType [] =
  1093.     {
  1094.     /* eval type */
  1095.     /* --------------- -------------- */
  1096.       { evalUnknown, /* T_UNKNOWN*/ },
  1097.       { evalByte, /* T_BYTE   */ },
  1098.       { evalWord, /* T_WORD   */ },
  1099.       { evalInt, /* T_INT    */ },
  1100. #ifndef _WRS_NO_TGT_SHELL_FP
  1101.       { evalFloat, /* T_FLOAT  */ },
  1102.       { evalDouble, /* T_DOUBLE */ },
  1103. #endif /* _WRS_NO_TGT_SHELL_FP */
  1104.     };
  1106. /*******************************************************************************
  1107. *
  1108. * evalExp - evaluate expression
  1109. */
  1111. LOCAL VALUE evalExp (pValue1, op, pValue2)
  1112.     VALUE *pValue1;
  1113.     int op;
  1114.     VALUE *pValue2;
  1116.     {
  1117.     VALUE *p1 = pValue1;
  1118.     VALUE *p2 = pValue2;
  1120.     if (pValue2 == NULLVAL) /* unary expresions must set pValue2 to something */
  1121. p2 = pValue2 = pValue1;
  1123.     /* make sure values have the same type */
  1125.     if ((int)p1->type > (int)p2->type)
  1126. typeConvert (p2, p1->type, p1->side);
  1127.     else
  1128. typeConvert (p1, p2->type, p2->side);
  1130.     return ((evalType[(int)pValue1->type].eval) (pValue1, op, pValue2));
  1131.     }
  1132. /*******************************************************************************
  1133. *
  1134. * evalUnknown - evaluate for unknown result
  1135. *
  1136. * ARGSUSED
  1137. */
  1139. LOCAL VALUE evalUnknown (pValue1, op, pValue2)
  1140.     VALUE *pValue1;
  1141.     int op;
  1142.     VALUE *pValue2;
  1144.     {
  1145.     printf ("evalUnknown: bad evaluation.n");
  1147.     SET_ERROR;
  1149.     return (*pValue1); /* have to return something */
  1150.     }
  1151. /*******************************************************************************
  1152. *
  1153. * evalByte - evaluate for byte result
  1154. */
  1156. LOCAL VALUE evalByte (pValue1, op, pValue2)
  1157.     VALUE *pValue1;
  1158.     int op;
  1159.     VALUE *pValue2;
  1161.     {
  1162.     VALUE *p1 = pValue1;
  1163.     VALUE *p2 = pValue2;
  1164.     VALUE result;
  1166.     /* evaluate as integers and then convert back */
  1168.     typeConvert (p1, T_INT, RHS);
  1169.     typeConvert (p2, T_INT, RHS);
  1171.     result = evalInt (p1, op, p2);
  1173.     typeConvert (&result, T_BYTE, RHS);
  1175.     return (result);
  1176.     }
  1177. /*******************************************************************************
  1178. *
  1179. * evalWord - evaluate for word result
  1180. */
  1182. LOCAL VALUE evalWord (pValue1, op, pValue2)
  1183.     VALUE *pValue1;
  1184.     int op;
  1185.     VALUE *pValue2;
  1187.     {
  1188.     VALUE *p1 = pValue1;
  1189.     VALUE *p2 = pValue2;
  1190.     VALUE result;
  1192.     /* evaluate as integers and then convert back */
  1194.     typeConvert (p1, T_INT, RHS);
  1195.     typeConvert (p2, T_INT, RHS);
  1197.     result = evalInt (p1, op, p2);
  1199.     typeConvert (&result, T_WORD, RHS);
  1201.     return (result);
  1202.     }
  1203. /*******************************************************************************
  1204. *
  1205. * evalInt - evaluate for integer result
  1206. */
  1208. LOCAL VALUE evalInt (pValue1, op, pValue2)
  1209.     VALUE *pValue1;
  1210.     int op;
  1211.     VALUE *pValue2;
  1213.     {
  1214. #define OP_INT(op) rv = e1 op e2; break
  1215. #define OP_INT_U(op) rv = op e1; break
  1217.     FAST int e1 = pValue1->value.rv;
  1218.     FAST int e2 = pValue2->value.rv;
  1219.     FAST int rv;
  1220.     VALUE result;
  1222.     switch (op)
  1223. {
  1224. case ADDA:
  1225. case '+':
  1226.     OP_INT(+);
  1227. case SUBA:
  1228. case '-':
  1229.     OP_INT(-);
  1230. case MULA:
  1231. case '*':
  1232.     OP_INT(*);
  1233. case DIVA:
  1234. case '/':
  1235.     OP_INT(/);
  1236. case '!':
  1237.     OP_INT_U(!);
  1238. case '~':
  1239.     OP_INT_U(~);
  1240. case MODA:
  1241. case '%':
  1242.     OP_INT(%);
  1243. case ANDA:
  1244. case '&':
  1245.     OP_INT(&);
  1246. case XORA:
  1247. case '^':
  1248.     OP_INT(^);
  1249. case ORA:
  1250. case '|':
  1251.     OP_INT(|);
  1252. case '<':
  1253.     OP_INT(<);
  1254. case '>':
  1255.     OP_INT(>);
  1256. case OR:
  1257.     OP_INT(||);
  1258. case AND:
  1259.     OP_INT(&&);
  1260. case EQ:
  1261.     OP_INT(==);
  1262. case NE:
  1263.     OP_INT(!=);
  1264. case GE:
  1265.     OP_INT(>=);
  1266. case LE:
  1267.     OP_INT(<=);
  1268. case INCR:
  1269.     OP_INT_U(++);
  1270. case DECR:
  1271.     OP_INT_U(--);
  1272. case SHLA:
  1273. case ROT_LEFT:
  1274.     OP_INT(<<);
  1275. case SHRA:
  1276. case ROT_RIGHT:
  1277.     OP_INT(>>);
  1278. case UMINUS:
  1279.     OP_INT_U(-);
  1280. default:
  1281.     rv = 0;
  1282.     printf ("operands have incompatible types.n");
  1283.     SET_ERROR;
  1284. }
  1286.     result.side     = RHS;
  1287.     result.type     = pValue1->type;
  1288.     result.value.rv = rv;
  1290.     return (result);
  1291.     }
  1292. #ifndef _WRS_NO_TGT_SHELL_FP
  1293. /*******************************************************************************
  1294. *
  1295. * evalFloat - evaluate for float result
  1296. */
  1298. LOCAL VALUE evalFloat (pValue1, op, pValue2)
  1299.     VALUE *pValue1;
  1300.     int op;
  1301.     VALUE *pValue2;
  1303.     {
  1304.     VALUE *p1 = pValue1;
  1305.     VALUE *p2 = pValue2;
  1306.     VALUE result;
  1308.     /* evaluate as doubles and then convert back */
  1310.     typeConvert (p1, T_DOUBLE, RHS);
  1311.     typeConvert (p2, T_DOUBLE, RHS);
  1313.     result = evalDouble (p1, op, p2);
  1315.     typeConvert (&result, T_FLOAT, RHS);
  1317.     return (result);
  1318.     }
  1319. /*******************************************************************************
  1320. *
  1321. * evalDouble - evaluate for double result
  1322. */
  1324. LOCAL VALUE evalDouble (pValue1, op, pValue2)
  1325.     VALUE *pValue1;
  1326.     int op;
  1327.     VALUE *pValue2;
  1329.     {
  1330. #define OP_DOUBLE(op) dp = e1 op e2; break
  1331. #define OP_DOUBLE_U(op) dp = op e1; break
  1333.     FAST double e1 = pValue1->value.dp;
  1334.     FAST double e2 = pValue2->value.dp;
  1335.     FAST double dp;
  1336.     VALUE result;
  1338.     switch (op)
  1339. {
  1340. case ADDA:
  1341. case '+':
  1342.     OP_DOUBLE(+);
  1343. case SUBA:
  1344. case '-':
  1345.     OP_DOUBLE(-);
  1346. case MULA:
  1347. case '*':
  1348.     OP_DOUBLE(*);
  1349. case DIVA:
  1350. case '/':
  1351.     OP_DOUBLE(/);
  1352. case '!':
  1353.     OP_DOUBLE_U(!);
  1355. case '<':
  1356.     OP_DOUBLE(<);
  1357. case '>':
  1358.     OP_DOUBLE(>);
  1359. case OR:
  1360.     OP_DOUBLE(||);
  1361. case AND:
  1362.     OP_DOUBLE(&&);
  1363. case EQ:
  1364.     OP_DOUBLE(==);
  1365. case NE:
  1366.     OP_DOUBLE(!=);
  1367. case GE:
  1368.     OP_DOUBLE(>=);
  1369. case LE:
  1370.     OP_DOUBLE(<=);
  1371. case INCR:
  1372.     OP_DOUBLE_U(++);
  1373. case DECR:
  1374.     OP_DOUBLE_U(--);
  1376. case UMINUS:
  1377.     OP_DOUBLE_U(-);
  1379. default:
  1380.     dp = 0;
  1381.     printf ("operands have incompatible types.n");
  1382.     SET_ERROR;
  1383. }
  1385.     result.side     = RHS;
  1386.     result.type     = T_DOUBLE;
  1387.     result.value.dp = dp;
  1389.     return (result);
  1390.     }
  1391. #endif /* _WRS_NO_TGT_SHELL_FP */
  1393. /* TYPE CONVERSION */
  1395. LOCAL void convUnknown ();
  1396. LOCAL void convByte ();
  1397. LOCAL void convWord ();
  1398. LOCAL void convInt ();
  1399. #ifndef _WRS_NO_TGT_SHELL_FP
  1400. LOCAL void convFloat ();
  1401. LOCAL void convDouble ();
  1402. #endif /* _WRS_NO_TGT_SHELL_FP */
  1404. typedef void (*VOID_FUNCPTR) (); /* ptr to a function returning void */
  1406. LOCAL VOID_FUNCPTR convType [] =
  1407.     {
  1408.     /*  conversion type     */
  1409.     /*  ---------- ----------- */
  1410. convUnknown, /* T_UNKNOWN*/
  1411. convByte, /* T_BYTE   */
  1412. convWord, /* T_WORD   */
  1413. convInt, /* T_INT    */
  1414. #ifndef _WRS_NO_TGT_SHELL_FP
  1415. convFloat, /* T_FLOAT  */
  1416. convDouble, /* T_DOUBLE */
  1417. #endif /* _WRS_NO_TGT_SHELL_FP */
  1418.     };
  1420. /*******************************************************************************
  1421. *
  1422. * typeConvert - change value to specified type
  1423. */
  1425. LOCAL void typeConvert (pValue, type, side)
  1426.     FAST VALUE *pValue;
  1427.     TYPE type;
  1428.     SIDE side;
  1430.     {
  1431.     if (side == FHS)
  1432. {
  1433. pValue->side = RHS;
  1434. pValue->type = type;
  1435. }
  1436.     else if (side == RHS)
  1437. {
  1438. if (pValue->side == LHS)
  1439.     pValue->type = type;
  1440. else
  1441.     (convType [(int) type]) (pValue);
  1442. }
  1443.     else if (pValue->side == LHS)
  1444. pValue->type = type;
  1445.     else
  1446. {
  1447. printf ("typeConvert: bad type.n");
  1448. SET_ERROR;
  1449. }
  1450.     }
  1451. /*******************************************************************************
  1452. *
  1453. * convUnknown - convert value to unknown
  1454. *
  1455. * ARGSUSED
  1456. */
  1458. LOCAL void convUnknown (pValue)
  1459.     VALUE *pValue;
  1461.     {
  1462.     printf ("convUnknown: bad type.n");
  1463.     SET_ERROR;
  1464.     }
  1465. /*******************************************************************************
  1466. *
  1467. * convByte - convert value to byte
  1468. */
  1470. LOCAL void convByte (pValue)
  1471.     FAST VALUE *pValue;
  1473.     {
  1474.     char value;
  1476.     if ((int)pValue->type > (int)T_BYTE)
  1477. {
  1478. convWord (pValue);
  1479. value = pValue->value.word;
  1480. pValue->value.byte = value;
  1481. pValue->type = T_BYTE;
  1482. }
  1483.     }
  1484. /*******************************************************************************
  1485. *
  1486. * convWord - convert value to word
  1487. */
  1489. LOCAL void convWord (pValue)
  1490.     FAST VALUE *pValue;
  1492.     {
  1493.     short value;
  1495.     if ((int)pValue->type < (int)T_WORD)
  1496. {
  1497. value = pValue->value.byte;
  1498. pValue->value.word = value;
  1499. pValue->type = T_WORD;
  1500. }
  1501.     else if ((int)pValue->type > (int)T_WORD)
  1502. {
  1503. convInt (pValue);
  1504. value = pValue->value.rv;
  1505. pValue->value.word = value;
  1506. pValue->type = T_WORD;
  1507. }
  1508.     }
  1509. /*******************************************************************************
  1510. *
  1511. * convInt - convert value to integer
  1512. */
  1514. LOCAL void convInt (pValue)
  1515.     FAST VALUE *pValue;
  1517.     {
  1518.     int value;
  1520.     if ((int)pValue->type < (int)T_INT)
  1521. {
  1522. convWord (pValue);
  1523. value = pValue->value.word;
  1524. pValue->value.rv = value;
  1525. pValue->type = T_INT;
  1526. }
  1527.     else if ((int)pValue->type > (int)T_INT)
  1528. {
  1529. #ifndef _WRS_NO_TGT_SHELL_FP
  1530. convFloat (pValue);
  1531. value = pValue->value.fp;
  1532. pValue->value.rv = value;
  1533. pValue->type = T_INT;
  1534. #endif /* _WRS_NO_TGT_SHELL_FP */
  1535. }
  1536.     }
  1537. #ifndef _WRS_NO_TGT_SHELL_FP
  1538. /*******************************************************************************
  1539. *
  1540. * convFloat - convert value to float
  1541. */
  1543. LOCAL void convFloat (pValue)
  1544.     FAST VALUE *pValue;
  1546.     {
  1547.     float value;
  1549.     if ((int)pValue->type < (int)T_FLOAT)
  1550. {
  1551. convInt (pValue);
  1552. value = pValue->value.rv;
  1553. pValue->value.fp = value;
  1554. pValue->type = T_FLOAT;
  1555. }
  1556.     else if ((int)pValue->type > (int)T_FLOAT)
  1557. {
  1558. convDouble (pValue);
  1559. value = pValue->value.dp;
  1560. pValue->value.fp = value;
  1561. pValue->type = T_FLOAT;
  1562. }
  1563.     }
  1564. /*******************************************************************************
  1565. *
  1566. * convDouble - convert value to double
  1567. */
  1569. LOCAL void convDouble (pValue)
  1570.     FAST VALUE *pValue;
  1572.     {
  1573.     double value;
  1575.     if ((int)pValue->type < (int)T_DOUBLE)
  1576. {
  1577. convFloat (pValue);
  1579. value = pValue->value.fp;
  1580. pValue->value.dp = value;
  1581. pValue->type = T_DOUBLE;
  1582. }
  1583.     }
  1584. #endif /* _WRS_NO_TGT_SHELL_FP */
  1585. static const yytabelem yyexca[] ={
  1586. -1, 1,
  1587. 0, -1,
  1588. -2, 0,
  1589. };
  1590. # define YYNPROD 63
  1591. # define YYLAST 810
  1592. static const yytabelem yyact[]={
  1594.     29,    32,   106,    21,    21,    27,    25,    20,    26,   108,
  1595.     28,   105,   104,   115,   111,   107,    69,     1,    66,    11,
  1596.     68,     2,     0,    42,    55,    41,    22,    29,    32,     0,
  1597.     21,     0,    27,    25,     0,    26,     0,    28,    67,     0,
  1598.      0,     0,     0,     0,     0,     0,     0,     0,   109,     0,
  1599.     42,    55,    41,    22,    23,    23,   110,    33,     0,     0,
  1600.      0,     0,     0,     0,     0,    29,    32,     0,    21,   103,
  1601.     27,    25,     0,    26,     0,    28,     0,     0,     0,     0,
  1602.      0,    23,     0,     0,    33,     0,     0,    34,    42,    55,
  1603.     41,    22,    29,    32,     0,    21,     0,    27,    25,     0,
  1604.     26,     0,    28,     0,     0,     0,     0,     0,     0,     0,
  1605.      0,     0,     0,     0,    34,    42,    55,    41,    22,    23,
  1606.      0,     0,    33,     0,     0,     0,     0,     0,    29,    32,
  1607.      0,    21,     0,    27,    25,     0,    26,     0,    28,     0,
  1608.      0,     0,     0,     0,     0,     0,    23,     0,     0,    33,
  1609.      0,    42,    34,    41,    22,    29,    32,     0,    21,     0,
  1610.     27,    25,     0,    26,     0,    28,    29,    32,     0,    21,
  1611.      0,    27,    25,     0,    26,     0,    28,     0,    42,    34,
  1612.     41,     0,    23,     0,     0,    33,     0,    29,     0,    42,
  1613.     21,    41,    27,    25,     0,    26,     0,    28,     0,     0,
  1614.      0,     0,     0,     0,     0,     0,     0,     0,     0,    23,
  1615.      0,     0,    33,     0,     0,    34,     0,     0,     0,     0,
  1616.     23,     0,     0,    33,     0,     0,     0,     0,    36,    35,
  1617.     37,    38,    39,    40,    43,    44,    31,    30,     0,    24,
  1618.     24,    23,    34,    51,    52,    49,    45,    46,    53,    54,
  1619.     47,    48,    50,    34,     0,    36,    35,    37,    38,    39,
  1620.     40,    43,    44,    31,    30,     0,    24,    21,     0,     0,
  1621.     51,    52,    49,    45,    46,    53,    54,    47,    48,    50,
  1622.     29,    32,     0,    21,     0,    27,    25,     0,    26,     0,
  1623.     28,     0,     0,    36,    35,    37,    38,    39,    40,    43,
  1624.     44,    31,    30,    42,    24,    41,     0,     0,    51,    52,
  1625.     49,    45,    46,    53,    54,    47,    48,    50,    23,     0,
  1626.     36,    35,    37,    38,    39,    40,    43,    44,    31,    30,
  1627.      0,    24,     0,     0,    23,    51,    52,    49,    45,    46,
  1628.     53,    54,    47,    48,    50,     0,     0,     0,     0,     0,
  1629.      0,     0,     0,     0,     0,     0,    36,    35,    37,    38,
  1630.     39,    40,    43,    44,    31,    30,     0,    24,     0,     0,
  1631.     29,    32,     0,    21,     0,    27,    25,     0,    26,     0,
  1632.     28,     0,     0,     0,    35,    37,    38,    39,    40,    43,
  1633.     44,    31,    30,    42,    24,    41,    37,    38,    39,    40,
  1634.     43,    44,    31,    30,     0,    24,    29,     0,     0,    21,
  1635.      0,    27,    25,     0,    26,     0,    28,     0,     0,     0,
  1636.      0,    43,    44,     0,    23,    15,    24,    33,     0,    42,
  1637.     13,    41,    10,     0,    12,     0,     0,    14,    29,     0,
  1638.      0,    21,     0,    27,    25,     0,    26,    29,    28,     0,
  1639.     21,     0,    27,    25,     0,    26,     0,    28,     0,     0,
  1640.     23,    42,    15,    41,     0,     0,     0,    13,     0,    10,
  1641.     29,    12,     0,    21,    14,    27,     0,     0,     0,     0,
  1642.     28,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1643.      0,     0,    23,     0,     0,     0,     0,     0,    43,    44,
  1644.      0,    23,     0,    24,     0,     0,     0,     0,     0,     0,
  1645.     37,    38,    39,    40,    43,    44,    31,    30,    16,    24,
  1646.      0,     0,     0,     0,    23,     0,     0,     0,     0,     0,
  1647.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1648.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1649.      0,     0,     0,     0,     0,    16,     0,     0,     0,     0,
  1650.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1651.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1652.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1653.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1654.     37,    38,    39,    40,    43,    44,    31,    30,     0,    24,
  1655.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1656.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1657.      0,     0,     0,     0,     0,     0,    37,    38,    39,    40,
  1658.     43,    44,    31,    30,     0,    24,     0,     0,     0,     0,
  1659.      5,     4,    19,     8,     7,     6,     9,     0,     0,     0,
  1660.      0,     0,     0,    17,    18,     0,     0,     0,     0,    57,
  1661.     39,    40,    43,    44,    31,    30,     0,    24,     0,     0,
  1662.      0,    43,    44,    31,    30,     0,    24,     5,     4,    19,
  1663.      8,     7,     6,     9,     0,     0,     0,     0,     0,     3,
  1664.     17,    18,     0,     0,    43,    44,     0,     0,     0,    24,
  1665.     56,    58,    59,    60,    61,    62,    63,    64,    65,     0,
  1666.      0,    70,    71,    72,    73,    74,    75,    76,    77,    78,
  1667.     79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
  1668.     89,    90,    91,     0,     0,    92,    93,    94,    95,    96,
  1669.     97,    98,    99,   100,   101,   102,     0,     0,     0,     0,
  1670.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1671.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1672.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1673.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1674.      0,     0,     0,     0,     0,     0,   112,     0,   113,   114 };
  1675. static const yytabelem yypact[]={
  1677.    429,-10000000,   -52,    55,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,
  1678.    392,   429,   429,   429,   429,   429,   429,   429,   429,-10000000,
  1679.    429,   429,   429,   429,   429,   429,   429,   429,   429,   429,
  1680.    429,   429,   429,   429,   429,   429,   429,   429,   429,   429,
  1681.    429,   429,   429,-10000000,-10000000,   429,   429,   429,   429,   429,
  1682.    429,   429,   429,   429,   429,   429,    28,   -29,-10000000,   -36,
  1683.    -36,   -36,   -36,   -36,   -36,   -36,   -59,-10000000,   -26,   -35,
  1684.     55,   -10,   -37,-10000000,   433,   433,   227,   227,   227,   150,
  1685.    150,   369,   243,   333,   129,   118,   401,   401,   410,   410,
  1686.    410,   410,    91,    91,    91,    91,    91,    91,    91,    91,
  1687.     91,    91,    91,-10000000,-10000000,   -27,   429,-10000000,   429,   429,
  1688. -10000000,   -28,    91,    55,    91,-10000000 };
  1689. static const yytabelem yypgo[]={
  1691.      0,    17,    21,   699,    20,    19,    18,    16 };
  1692. static const yytabelem yyr1[]={
  1694.      0,     1,     1,     2,     2,     3,     3,     3,     3,     3,
  1695.      3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
  1696.      3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
  1697.      3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
  1698.      3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
  1699.      3,     3,     3,     3,     3,     6,     3,     4,     4,     7,
  1700.      7,     5,     5 };
  1701. static const yytabelem yyr2[]={
  1703.      0,     2,     6,     0,     3,     2,     3,     3,     2,     2,
  1704.      2,     7,     9,     5,     5,     5,     5,     5,     5,    11,
  1705.      9,     7,     7,     7,     7,     7,     7,     7,     7,     7,
  1706.      7,     7,     7,     7,     7,     7,     7,     7,     7,     7,
  1707.      5,     5,     5,     5,     7,     7,     7,     7,     7,     7,
  1708.      7,     7,     7,     7,     7,     1,     9,     1,     2,     3,
  1709.      7,     7,    11 };
  1710. static const yytabelem yychk[]={
  1712. -10000000,    -1,    -2,    -3,   259,   258,   263,   262,   261,   264,
  1713.     40,    -5,    42,    38,    45,    33,   126,   271,   272,   260,
  1714.     59,    40,    63,    91,   276,    43,    45,    42,    47,    37,
  1715.    274,   273,    38,    94,   124,   266,   265,   267,   268,   269,
  1716.    270,    62,    60,   271,   272,   283,   284,   287,   288,   282,
  1717.    289,   280,   281,   285,   286,    61,    -3,   277,    -3,    -3,
  1718.     -3,    -3,    -3,    -3,    -3,    -3,    -6,    -1,    -4,    -7,
  1719.     -3,    -3,    -3,    -3,    -3,    -3,    -3,    -3,    -3,    -3,
  1720.     -3,    -3,    -3,    -3,    -3,    -3,    -3,    -3,    -3,    -3,
  1721.     -3,    -3,    -3,    -3,    -3,    -3,    -3,    -3,    -3,    -3,
  1722.     -3,    -3,    -3,    41,    41,    40,    61,    41,    44,    58,
  1723.     93,    41,    -3,    -3,    -3,    41 };
  1724. static const yytabelem yydef[]={
  1726.      3,    -2,     1,     4,     5,     6,     7,     8,     9,    10,
  1727.      0,     0,     0,     0,     0,     0,     0,     0,     0,    55,
  1728.      3,    57,     0,     0,     0,     0,     0,     0,     0,     0,
  1729.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1730.      0,     0,     0,    42,    43,     0,     0,     0,     0,     0,
  1731.      0,     0,     0,     0,     0,     0,     0,     0,    13,    14,
  1732.     15,    16,    17,    18,    40,    41,     0,     2,     0,    58,
  1733.     59,     0,     0,    21,    22,    23,    24,    25,    26,    27,
  1734.     28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
  1735.     38,    39,    44,    45,    46,    47,    48,    49,    50,    51,
  1736.     52,    53,    54,    11,    61,     0,     0,    12,     0,     0,
  1737.     20,     0,    56,    60,    19,    62 };
  1738. typedef struct
  1739. #ifdef __cplusplus
  1740. yytoktype
  1741. #endif
  1742. { char *t_name; int t_val; } yytoktype;
  1743. #ifndef YYDEBUG
  1744. # define YYDEBUG 0 /* don't allow debugging */
  1745. #endif
  1747. #if YYDEBUG
  1749. yytoktype yytoks[] =
  1750. {
  1751. "NL", 0,
  1752. "T_SYMBOL", 258,
  1753. "D_SYMBOL", 259,
  1754. "U_SYMBOL", 260,
  1755. "NUMBER", 261,
  1756. "CHAR", 262,
  1757. "STRING", 263,
  1758. "FLOAT", 264,
  1759. "OR", 265,
  1760. "AND", 266,
  1761. "EQ", 267,
  1762. "NE", 268,
  1763. "GE", 269,
  1764. "LE", 270,
  1765. "INCR", 271,
  1766. "DECR", 272,
  1767. "ROT_LEFT", 273,
  1768. "ROT_RIGHT", 274,
  1769. "UMINUS", 275,
  1770. "PTR", 276,
  1771. "TYPECAST", 277,
  1772. "ENDFILE", 278,
  1773. "LEX_ERROR", 279,
  1774. "=", 61,
  1775. "MULA", 280,
  1776. "DIVA", 281,
  1777. "MODA", 282,
  1778. "ADDA", 283,
  1779. "SUBA", 284,
  1780. "SHLA", 285,
  1781. "SHRA", 286,
  1782. "ANDA", 287,
  1783. "ORA", 288,
  1784. "XORA", 289,
  1785. "?", 63,
  1786. ":", 58,
  1787. "|", 124,
  1788. "^", 94,
  1789. "&", 38,
  1790. ">", 62,
  1791. "<", 60,
  1792. "+", 43,
  1793. "-", 45,
  1794. "*", 42,
  1795. "/", 47,
  1796. "%", 37,
  1797. "UNARY", 290,
  1798. "[", 91,
  1799. "(", 40,
  1800. "-unknown-", -1 /* ends search */
  1801. };
  1803. char * yyreds[] =
  1804. {
  1805. "-no such reduction-",
  1806. "line : stmt",
  1807. "line : stmt ';' line",
  1808. "stmt : /* empty */",
  1809. "stmt : expr",
  1810. "expr : D_SYMBOL",
  1811. "expr : T_SYMBOL",
  1812. "expr : STRING",
  1813. "expr : CHAR",
  1814. "expr : NUMBER",
  1815. "expr : FLOAT",
  1816. "expr : '(' expr ')'",
  1817. "expr : expr '(' arglist ')'",
  1818. "expr : typecast expr",
  1819. "expr : '*' expr",
  1820. "expr : '&' expr",
  1821. "expr : '-' expr",
  1822. "expr : '!' expr",
  1823. "expr : '~' expr",
  1824. "expr : expr '?' expr ':' expr",
  1825. "expr : expr '[' expr ']'",
  1826. "expr : expr PTR expr",
  1827. "expr : expr '+' expr",
  1828. "expr : expr '-' expr",
  1829. "expr : expr '*' expr",
  1830. "expr : expr '/' expr",
  1831. "expr : expr '%' expr",
  1832. "expr : expr ROT_RIGHT expr",
  1833. "expr : expr ROT_LEFT expr",
  1834. "expr : expr '&' expr",
  1835. "expr : expr '^' expr",
  1836. "expr : expr '|' expr",
  1837. "expr : expr AND expr",
  1838. "expr : expr OR expr",
  1839. "expr : expr EQ expr",
  1840. "expr : expr NE expr",
  1841. "expr : expr GE expr",
  1842. "expr : expr LE expr",
  1843. "expr : expr '>' expr",
  1844. "expr : expr '<' expr",
  1845. "expr : INCR expr",
  1846. "expr : DECR expr",
  1847. "expr : expr INCR",
  1848. "expr : expr DECR",
  1849. "expr : expr ADDA expr",
  1850. "expr : expr SUBA expr",
  1851. "expr : expr ANDA expr",
  1852. "expr : expr ORA expr",
  1853. "expr : expr MODA expr",
  1854. "expr : expr XORA expr",
  1855. "expr : expr MULA expr",
  1856. "expr : expr DIVA expr",
  1857. "expr : expr SHLA expr",
  1858. "expr : expr SHRA expr",
  1859. "expr : expr '=' expr",
  1860. "expr : U_SYMBOL",
  1861. "expr : U_SYMBOL '=' expr",
  1862. "arglist : /* empty */",
  1863. "arglist : neArglist",
  1864. "neArglist : expr",
  1865. "neArglist : neArglist ',' expr",
  1866. "typecast : '(' TYPECAST ')'",
  1867. "typecast : '(' TYPECAST '(' ')' ')'",
  1868. };
  1869. #endif /* YYDEBUG */
  1870. # line 1 "/usr/ccs/bin/yaccpar"
  1871. /*
  1872.  * Copyright (c) 1993 by Sun Microsystems, Inc.
  1873.  */
  1875. #pragma ident "@(#)yaccpar 6.15 97/12/08 SMI"
  1877. /*
  1878. ** Skeleton parser driver for yacc output
  1879. */
  1881. /*
  1882. ** yacc user known macros and defines
  1883. */
  1884. #define YYERROR goto yyerrlab
  1885. #define YYACCEPT return(0)
  1886. #define YYABORT return(1)
  1887. #define YYBACKUP( newtoken, newvalue )
  1888. {
  1889. if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )
  1890. {
  1891. yyerror( "syntax error - cannot backup" );
  1892. goto yyerrlab;
  1893. }
  1894. yychar = newtoken;
  1895. yystate = *yyps;
  1896. yylval = newvalue;
  1897. goto yynewstate;
  1898. }
  1899. #define YYRECOVERING() (!!yyerrflag)
  1900. #define YYNEW(type) malloc(sizeof(type) * yynewmax)
  1901. #define YYCOPY(to, from, type) 
  1902. (type *) memcpy(to, (char *) from, yymaxdepth * sizeof (type))
  1903. #define YYENLARGE( from, type) 
  1904. (type *) realloc((char *) from, yynewmax * sizeof(type))
  1905. #ifndef YYDEBUG
  1906. # define YYDEBUG 1 /* make debugging available */
  1907. #endif
  1909. /*
  1910. ** user known globals
  1911. */
  1912. int yydebug; /* set to 1 to get debugging */
  1914. /*
  1915. ** driver internal defines
  1916. */
  1917. #define YYFLAG (-10000000)
  1919. /*
  1920. ** global variables used by the parser
  1921. */
  1922. YYSTYPE *yypv; /* top of value stack */
  1923. int *yyps; /* top of state stack */
  1925. int yystate; /* current state */
  1926. int yytmp; /* extra var (lasts between blocks) */
  1928. int yynerrs; /* number of errors */
  1929. int yyerrflag; /* error recovery flag */
  1930. int yychar; /* current input token number */
  1934. #ifdef YYNMBCHARS
  1935. #define YYLEX() yycvtok(yylex())
  1936. /*
  1937. ** yycvtok - return a token if i is a wchar_t value that exceeds 255.
  1938. ** If i<255, i itself is the token.  If i>255 but the neither 
  1939. ** of the 30th or 31st bit is on, i is already a token.
  1940. */
  1941. #if defined(__STDC__) || defined(__cplusplus)
  1942. int yycvtok(int i)
  1943. #else
  1944. int yycvtok(i) int i;
  1945. #endif
  1946. {
  1947. int first = 0;
  1948. int last = YYNMBCHARS - 1;
  1949. int mid;
  1950. wchar_t j;
  1952. if(i&0x60000000){/*Must convert to a token. */
  1953. if( yymbchars[last].character < i ){
  1954. return i;/*Giving up*/
  1955. }
  1956. while ((last>=first)&&(first>=0)) {/*Binary search loop*/
  1957. mid = (first+last)/2;
  1958. j = yymbchars[mid].character;
  1959. if( j==i ){/*Found*/ 
  1960. return yymbchars[mid].tvalue;
  1961. }else if( j<i ){
  1962. first = mid + 1;
  1963. }else{
  1964. last = mid -1;
  1965. }
  1966. }
  1967. /*No entry in the table.*/
  1968. return i;/* Giving up.*/
  1969. }else{/* i is already a token. */
  1970. return i;
  1971. }
  1972. }
  1973. #else/*!YYNMBCHARS*/
  1974. #define YYLEX() yylex()
  1975. #endif/*!YYNMBCHARS*/
  1977. /*
  1978. ** yyparse - return 0 if worked, 1 if syntax error not recovered from
  1979. */
  1980. #if defined(__STDC__) || defined(__cplusplus)
  1981. int yyparse(void)
  1982. #else
  1983. int yyparse()
  1984. #endif
  1985. {
  1986. register YYSTYPE *yypvt = 0; /* top of value stack for $vars */
  1988. #if defined(__cplusplus) || defined(lint)
  1989. /*
  1990. hacks to please C++ and lint - goto's inside switch should never be
  1991. executed; yypvt is set to 0 to avoid "used before set" warning.
  1992. */
  1993. static int __yaccpar_lint_hack__ = 0;
  1994. switch (__yaccpar_lint_hack__)
  1995. {
  1996. case 1: goto yyerrlab;
  1997. case 2: goto yynewstate;
  1998. }
  1999. #endif
  2001. /*
  2002. ** Initialize externals - yyparse may be called more than once
  2003. */
  2004. yypv = &yyv[-1];
  2005. yyps = &yys[-1];
  2006. yystate = 0;
  2007. yytmp = 0;
  2008. yynerrs = 0;
  2009. yyerrflag = 0;
  2010. yychar = -1;
  2012. #if YYMAXDEPTH <= 0
  2013. if (yymaxdepth <= 0)
  2014. {
  2015. if ((yymaxdepth = YYEXPAND(0)) <= 0)
  2016. {
  2017. yyerror("yacc initialization error");
  2018. YYABORT;
  2019. }
  2020. }
  2021. #endif
  2023. {
  2024. register YYSTYPE *yy_pv; /* top of value stack */
  2025. register int *yy_ps; /* top of state stack */
  2026. register int yy_state; /* current state */
  2027. register int  yy_n; /* internal state number info */
  2028. goto yystack; /* moved from 6 lines above to here to please C++ */
  2030. /*
  2031. ** get globals into registers.
  2032. ** branch to here only if YYBACKUP was called.
  2033. */
  2034. yynewstate:
  2035. yy_pv = yypv;
  2036. yy_ps = yyps;
  2037. yy_state = yystate;
  2038. goto yy_newstate;
  2040. /*
  2041. ** get globals into registers.
  2042. ** either we just started, or we just finished a reduction
  2043. */
  2044. yystack:
  2045. yy_pv = yypv;
  2046. yy_ps = yyps;
  2047. yy_state = yystate;
  2049. /*
  2050. ** top of for (;;) loop while no reductions done
  2051. */
  2052. yy_stack:
  2053. /*
  2054. ** put a state and value onto the stacks
  2055. */
  2056. #if YYDEBUG
  2057. /*
  2058. ** if debugging, look up token value in list of value vs.
  2059. ** name pairs.  0 and negative (-1) are special values.
  2060. ** Note: linear search is used since time is not a real
  2061. ** consideration while debugging.
  2062. */
  2063. if ( yydebug )
  2064. {
  2065. register int yy_i;
  2067. printf( "State %d, token ", yy_state );
  2068. if ( yychar == 0 )
  2069. printf( "end-of-filen" );
  2070. else if ( yychar < 0 )
  2071. printf( "-none-n" );
  2072. else
  2073. {
  2074. for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
  2075. yy_i++ )
  2076. {
  2077. if ( yytoks[yy_i].t_val == yychar )
  2078. break;
  2079. }
  2080. printf( "%sn", yytoks[yy_i].t_name );
  2081. }
  2082. }
  2083. #endif /* YYDEBUG */
  2084. if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */
  2085. {
  2086. /*
  2087. ** reallocate and recover.  Note that pointers
  2088. ** have to be reset, or bad things will happen
  2089. */
  2090. long yyps_index = (yy_ps - yys);
  2091. long yypv_index = (yy_pv - yyv);
  2092. long yypvt_index = (yypvt - yyv);
  2093. int yynewmax;
  2094. #ifdef YYEXPAND
  2095. yynewmax = YYEXPAND(yymaxdepth);
  2096. #else
  2097. yynewmax = 2 * yymaxdepth; /* double table size */
  2098. if (yymaxdepth == YYMAXDEPTH) /* first time growth */
  2099. {
  2100. char *newyys = (char *)YYNEW(int);
  2101. char *newyyv = (char *)YYNEW(YYSTYPE);
  2102. if (newyys != 0 && newyyv != 0)
  2103. {
  2104. yys = YYCOPY(newyys, yys, int);
  2105. yyv = YYCOPY(newyyv, yyv, YYSTYPE);
  2106. }
  2107. else
  2108. yynewmax = 0; /* failed */
  2109. }
  2110. else /* not first time */
  2111. {
  2112. yys = YYENLARGE(yys, int);
  2113. yyv = YYENLARGE(yyv, YYSTYPE);
  2114. if (yys == 0 || yyv == 0)
  2115. yynewmax = 0; /* failed */
  2116. }
  2117. #endif
  2118. if (yynewmax <= yymaxdepth) /* tables not expanded */
  2119. {
  2120. yyerror( "yacc stack overflow" );
  2121. YYABORT;
  2122. }
  2123. yymaxdepth = yynewmax;
  2125. yy_ps = yys + yyps_index;
  2126. yy_pv = yyv + yypv_index;
  2127. yypvt = yyv + yypvt_index;
  2128. }
  2129. *yy_ps = yy_state;
  2130. *++yy_pv = yyval;
  2132. /*
  2133. ** we have a new state - find out what to do
  2134. */
  2135. yy_newstate:
  2136. if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
  2137. goto yydefault; /* simple state */
  2138. #if YYDEBUG
  2139. /*
  2140. ** if debugging, need to mark whether new token grabbed
  2141. */
  2142. yytmp = yychar < 0;
  2143. #endif
  2144. if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) )
  2145. yychar = 0; /* reached EOF */
  2146. #if YYDEBUG
  2147. if ( yydebug && yytmp )
  2148. {
  2149. register int yy_i;
  2151. printf( "Received token " );
  2152. if ( yychar == 0 )
  2153. printf( "end-of-filen" );
  2154. else if ( yychar < 0 )
  2155. printf( "-none-n" );
  2156. else
  2157. {
  2158. for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
  2159. yy_i++ )
  2160. {
  2161. if ( yytoks[yy_i].t_val == yychar )
  2162. break;
  2163. }
  2164. printf( "%sn", yytoks[yy_i].t_name );
  2165. }
  2166. }
  2167. #endif /* YYDEBUG */
  2168. if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
  2169. goto yydefault;
  2170. if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/
  2171. {
  2172. yychar = -1;
  2173. yyval = yylval;
  2174. yy_state = yy_n;
  2175. if ( yyerrflag > 0 )
  2176. yyerrflag--;
  2177. goto yy_stack;
  2178. }
  2180. yydefault:
  2181. if ( ( yy_n = yydef[ yy_state ] ) == -2 )
  2182. {
  2183. #if YYDEBUG
  2184. yytmp = yychar < 0;
  2185. #endif
  2186. if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) )
  2187. yychar = 0; /* reached EOF */
  2188. #if YYDEBUG
  2189. if ( yydebug && yytmp )
  2190. {
  2191. register int yy_i;
  2193. printf( "Received token " );
  2194. if ( yychar == 0 )
  2195. printf( "end-of-filen" );
  2196. else if ( yychar < 0 )
  2197. printf( "-none-n" );
  2198. else
  2199. {
  2200. for ( yy_i = 0;
  2201. yytoks[yy_i].t_val >= 0;
  2202. yy_i++ )
  2203. {
  2204. if ( yytoks[yy_i].t_val
  2205. == yychar )
  2206. {
  2207. break;
  2208. }
  2209. }
  2210. printf( "%sn", yytoks[yy_i].t_name );
  2211. }
  2212. }
  2213. #endif /* YYDEBUG */
  2214. /*
  2215. ** look through exception table
  2216. */
  2217. {
  2218. register const int *yyxi = yyexca;
  2220. while ( ( *yyxi != -1 ) ||
  2221. ( yyxi[1] != yy_state ) )
  2222. {
  2223. yyxi += 2;
  2224. }
  2225. while ( ( *(yyxi += 2) >= 0 ) &&
  2226. ( *yyxi != yychar ) )
  2227. ;
  2228. if ( ( yy_n = yyxi[1] ) < 0 )
  2229. YYACCEPT;
  2230. }
  2231. }
  2233. /*
  2234. ** check for syntax error
  2235. */
  2236. if ( yy_n == 0 ) /* have an error */
  2237. {
  2238. /* no worry about speed here! */
  2239. switch ( yyerrflag )
  2240. {
  2241. case 0: /* new error */
  2242. yyerror( "syntax error" );
  2243. goto skip_init;
  2244. yyerrlab:
  2245. /*
  2246. ** get globals into registers.
  2247. ** we have a user generated syntax type error
  2248. */
  2249. yy_pv = yypv;
  2250. yy_ps = yyps;
  2251. yy_state = yystate;
  2252. skip_init:
  2253. yynerrs++;
  2254. /* FALLTHRU */
  2255. case 1:
  2256. case 2: /* incompletely recovered error */
  2257. /* try again... */
  2258. yyerrflag = 3;
  2259. /*
  2260. ** find state where "error" is a legal
  2261. ** shift action
  2262. */
  2263. while ( yy_ps >= yys )
  2264. {
  2265. yy_n = yypact[ *yy_ps ] + YYERRCODE;
  2266. if ( yy_n >= 0 && yy_n < YYLAST &&
  2267. yychk[yyact[yy_n]] == YYERRCODE) {
  2268. /*
  2269. ** simulate shift of "error"
  2270. */
  2271. yy_state = yyact[ yy_n ];
  2272. goto yy_stack;
  2273. }
  2274. /*
  2275. ** current state has no shift on
  2276. ** "error", pop stack
  2277. */
  2278. #if YYDEBUG
  2279. # define _POP_ "Error recovery pops state %d, uncovers state %dn"
  2280. if ( yydebug )
  2281. printf( _POP_, *yy_ps,
  2282. yy_ps[-1] );
  2283. # undef _POP_
  2284. #endif
  2285. yy_ps--;
  2286. yy_pv--;
  2287. }
  2288. /*
  2289. ** there is no state on stack with "error" as
  2290. ** a valid shift.  give up.
  2291. */
  2292. YYABORT;
  2293. case 3: /* no shift yet; eat a token */
  2294. #if YYDEBUG
  2295. /*
  2296. ** if debugging, look up token in list of
  2297. ** pairs.  0 and negative shouldn't occur,
  2298. ** but since timing doesn't matter when
  2299. ** debugging, it doesn't hurt to leave the
  2300. ** tests here.
  2301. */
  2302. if ( yydebug )
  2303. {
  2304. register int yy_i;
  2306. printf( "Error recovery discards " );
  2307. if ( yychar == 0 )
  2308. printf( "token end-of-filen" );
  2309. else if ( yychar < 0 )
  2310. printf( "token -none-n" );
  2311. else
  2312. {
  2313. for ( yy_i = 0;
  2314. yytoks[yy_i].t_val >= 0;
  2315. yy_i++ )
  2316. {
  2317. if ( yytoks[yy_i].t_val
  2318. == yychar )
  2319. {
  2320. break;
  2321. }
  2322. }
  2323. printf( "token %sn",
  2324. yytoks[yy_i].t_name );
  2325. }
  2326. }
  2327. #endif /* YYDEBUG */
  2328. if ( yychar == 0 ) /* reached EOF. quit */
  2329. YYABORT;
  2330. yychar = -1;
  2331. goto yy_newstate;
  2332. }
  2333. }/* end if ( yy_n == 0 ) */
  2334. /*
  2335. ** reduction by production yy_n
  2336. ** put stack tops, etc. so things right after switch
  2337. */
  2338. #if YYDEBUG
  2339. /*
  2340. ** if debugging, print the string that is the user's
  2341. ** specification of the reduction which is just about
  2342. ** to be done.
  2343. */
  2344. if ( yydebug )
  2345. printf( "Reduce by (%d) "%s"n",
  2346. yy_n, yyreds[ yy_n ] );
  2347. #endif
  2348. yytmp = yy_n; /* value to switch over */
  2349. yypvt = yy_pv; /* $vars top of value stack */
  2350. /*
  2351. ** Look in goto table for next state
  2352. ** Sorry about using yy_state here as temporary
  2353. ** register variable, but why not, if it works...
  2354. ** If yyr2[ yy_n ] doesn't have the low order bit
  2355. ** set, then there is no action to be done for
  2356. ** this reduction.  So, no saving & unsaving of
  2357. ** registers done.  The only difference between the
  2358. ** code just after the if and the body of the if is
  2359. ** the goto yy_stack in the body.  This way the test
  2360. ** can be made before the choice of what to do is needed.
  2361. */
  2362. {
  2363. /* length of production doubled with extra bit */
  2364. register int yy_len = yyr2[ yy_n ];
  2366. if ( !( yy_len & 01 ) )
  2367. {
  2368. yy_len >>= 1;
  2369. yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
  2370. yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
  2371. *( yy_ps -= yy_len ) + 1;
  2372. if ( yy_state >= YYLAST ||
  2373. yychk[ yy_state =
  2374. yyact[ yy_state ] ] != -yy_n )
  2375. {
  2376. yy_state = yyact[ yypgo[ yy_n ] ];
  2377. }
  2378. goto yy_stack;
  2379. }
  2380. yy_len >>= 1;
  2381. yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
  2382. yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
  2383. *( yy_ps -= yy_len ) + 1;
  2384. if ( yy_state >= YYLAST ||
  2385. yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
  2386. {
  2387. yy_state = yyact[ yypgo[ yy_n ] ];
  2388. }
  2389. }
  2390. /* save until reenter driver code */
  2391. yystate = yy_state;
  2392. yyps = yy_ps;
  2393. yypv = yy_pv;
  2394. }
  2395. /*
  2396. ** code supplied by user is placed in this switch
  2397. */
  2398. switch( yytmp )
  2399. {
  2401. case 4:
  2402. # line 220 "shell.yacc"
  2403. { printValue (&yypvt[-0]); CHECK; } break;
  2404. case 6:
  2405. # line 224 "shell.yacc"
  2406. { yypvt[-0].side = RHS; setRv (&yyval, &yypvt[-0]); } break;
  2407. case 7:
  2408. # line 225 "shell.yacc"
  2409. { yyval = yypvt[-0]; yyval.value.rv = newString((char*)yypvt[-0].value.rv);
  2410.    CHECK; } break;
  2411. case 11:
  2412. # line 230 "shell.yacc"
  2413. { yyval = yypvt[-1]; } break;
  2414. case 12:
  2415. # line 232 "shell.yacc"
  2416. { yyval = funcCall (&yypvt[-3], &yypvt[-1]); CHECK; } break;
  2417. case 13:
  2418. # line 234 "shell.yacc"
  2419. { 
  2420. typeConvert (&yypvt[-0], yypvt[-1].type, yypvt[-1].side); yyval = yypvt[-0];
  2421. CHECK;
  2422. } break;
  2423. case 14:
  2424. # line 238 "shell.yacc"
  2425. { VALUE tmp;
  2426.   (void)getRv (&yypvt[-0], &tmp);
  2427.   setLv (&yyval, &tmp);
  2428.   CHECK;
  2429. } break;
  2430. case 15:
  2431. # line 243 "shell.yacc"
  2432. { yyval.value.rv = (int)getLv (&yypvt[-0]);
  2433.   yyval.type = T_INT; yyval.side = RHS; } break;
  2434. case 16:
  2435. # line 245 "shell.yacc"
  2436. { rvOp (RV(yypvt[-0]), UMINUS, NULLVAL); } break;
  2437. case 17:
  2438. # line 246 "shell.yacc"
  2439. { rvOp (RV(yypvt[-0]), '!', NULLVAL); } break;
  2440. case 18:
  2441. # line 247 "shell.yacc"
  2442. { rvOp (RV(yypvt[-0]), '~', NULLVAL); } break;
  2443. case 19:
  2444. # line 248 "shell.yacc"
  2445. { setRv (&yyval, RV(yypvt[-4])->value.rv ? &yypvt[-2]
  2446.        : &yypvt[-0]); } break;
  2447. case 20:
  2448. # line 250 "shell.yacc"
  2449. { BIN_OP ('+');
  2450.   typeConvert (&yyval, T_INT, RHS);
  2451.   setLv (&yyval, &yyval); } break;
  2452. case 21:
  2453. # line 253 "shell.yacc"
  2454. { BIN_OP ('+');
  2455.   typeConvert (&yyval, T_INT, RHS);
  2456.   setLv (&yyval, &yyval); } break;
  2457. case 22:
  2458. # line 256 "shell.yacc"
  2459. { BIN_OP ('+'); } break;
  2460. case 23:
  2461. # line 257 "shell.yacc"
  2462. { BIN_OP ('-'); } break;
  2463. case 24:
  2464. # line 258 "shell.yacc"
  2465. { BIN_OP ('*'); } break;
  2466. case 25:
  2467. # line 259 "shell.yacc"
  2468. { BIN_OP ('/'); } break;
  2469. case 26:
  2470. # line 260 "shell.yacc"
  2471. { BIN_OP ('%'); } break;
  2472. case 27:
  2473. # line 261 "shell.yacc"
  2474. { BIN_OP (ROT_RIGHT); } break;
  2475. case 28:
  2476. # line 262 "shell.yacc"
  2477. { BIN_OP (ROT_LEFT); } break;
  2478. case 29:
  2479. # line 263 "shell.yacc"
  2480. { BIN_OP ('&'); } break;
  2481. case 30:
  2482. # line 264 "shell.yacc"
  2483. { BIN_OP ('^'); } break;
  2484. case 31:
  2485. # line 265 "shell.yacc"
  2486. { BIN_OP ('|'); } break;
  2487. case 32:
  2488. # line 266 "shell.yacc"
  2489. { BIN_OP (AND); } break;
  2490. case 33:
  2491. # line 267 "shell.yacc"
  2492. { BIN_OP (OR); } break;
  2493. case 34:
  2494. # line 268 "shell.yacc"
  2495. { BIN_OP (EQ); } break;
  2496. case 35:
  2497. # line 269 "shell.yacc"
  2498. { BIN_OP (NE); } break;
  2499. case 36:
  2500. # line 270 "shell.yacc"
  2501. { BIN_OP (GE); } break;
  2502. case 37:
  2503. # line 271 "shell.yacc"
  2504. { BIN_OP (LE); } break;
  2505. case 38:
  2506. # line 272 "shell.yacc"
  2507. { BIN_OP ('>'); } break;
  2508. case 39:
  2509. # line 273 "shell.yacc"
  2510. { BIN_OP ('<'); } break;
  2511. case 40:
  2512. # line 274 "shell.yacc"
  2513. { rvOp (RV(yypvt[-0]), INCR, NULLVAL);
  2514.   assign (&yypvt[-0], &yyval); CHECK; } break;
  2515. case 41:
  2516. # line 276 "shell.yacc"
  2517. { rvOp (RV(yypvt[-0]), DECR, NULLVAL);
  2518.   assign (&yypvt[-0], &yyval); CHECK; } break;
  2519. case 42:
  2520. # line 278 "shell.yacc"
  2521. { VALUE tmp;
  2522.   tmp = yypvt[-1];
  2523.   rvOp (RV(yypvt[-1]), INCR, NULLVAL);
  2524.   assign (&yypvt[-1], &yyval); CHECK;
  2525.   yyval = tmp; } break;
  2526. case 43:
  2527. # line 283 "shell.yacc"
  2528. { VALUE tmp;
  2529.   tmp = yypvt[-1];
  2530.   rvOp (RV(yypvt[-1]), DECR, NULLVAL);
  2531.   assign (&yypvt[-1], &yyval); CHECK;
  2532.   yyval = tmp; } break;
  2533. case 44:
  2534. # line 288 "shell.yacc"
  2535. { BIN_OP (ADDA); assign (&yypvt[-2], &yyval); CHECK;} break;
  2536. case 45:
  2537. # line 289 "shell.yacc"
  2538. { BIN_OP (SUBA); assign (&yypvt[-2], &yyval); CHECK;} break;
  2539. case 46:
  2540. # line 290 "shell.yacc"
  2541. { BIN_OP (ANDA); assign (&yypvt[-2], &yyval); CHECK;} break;
  2542. case 47:
  2543. # line 291 "shell.yacc"
  2544. { BIN_OP (ORA);  assign (&yypvt[-2], &yyval); CHECK;} break;
  2545. case 48:
  2546. # line 292 "shell.yacc"
  2547. { BIN_OP (MODA); assign (&yypvt[-2], &yyval); CHECK;} break;
  2548. case 49:
  2549. # line 293 "shell.yacc"
  2550. { BIN_OP (XORA); assign (&yypvt[-2], &yyval); CHECK;} break;
  2551. case 50:
  2552. # line 294 "shell.yacc"
  2553. { BIN_OP (MULA); assign (&yypvt[-2], &yyval); CHECK;} break;
  2554. case 51:
  2555. # line 295 "shell.yacc"
  2556. { BIN_OP (DIVA); assign (&yypvt[-2], &yyval); CHECK;} break;
  2557. case 52:
  2558. # line 296 "shell.yacc"
  2559. { BIN_OP (SHLA); assign (&yypvt[-2], &yyval); CHECK;} break;
  2560. case 53:
  2561. # line 297 "shell.yacc"
  2562. { BIN_OP (SHRA); assign (&yypvt[-2], &yyval); CHECK;} break;
  2563. case 54:
  2564. # line 298 "shell.yacc"
  2565. { assign (&yypvt[-2], &yypvt[-0]); yyval = yypvt[-2]; } break;
  2566. case 55:
  2567. # line 303 "shell.yacc"
  2568. { usymFlag = TRUE; usymVal = yypvt[-0]; } break;
  2569. case 56:
  2570. # line 305 "shell.yacc"
  2571. {
  2572. if (yypvt[-3].type != T_UNKNOWN)
  2573.     {
  2574.     printf ("typecast of lhs not allowed.n");
  2575.     YYERROR;
  2576.     }
  2577. else
  2578.     {
  2579.     yyval = newSym ((char *)yypvt[-3].value.rv, yypvt[-0].type); CHECK;
  2580.     assign (&yyval, &yypvt[-0]); CHECK;
  2581.     }
  2582. usymFlag = FALSE;
  2583. } break;
  2584. case 57:
  2585. # line 321 "shell.yacc"
  2586. { yyval = newArgList (); } break;
  2587. case 59:
  2588. # line 326 "shell.yacc"
  2589. { yyval = newArgList (); addArg (&yyval, &yypvt[-0]); CHECK; } break;
  2590. case 60:
  2591. # line 328 "shell.yacc"
  2592. { addArg (&yypvt[-2], &yypvt[-0]); CHECK; } break;
  2593. case 61:
  2594. # line 331 "shell.yacc"
  2595. { yypvt[-1].side = RHS; yyval = yypvt[-1]; } break;
  2596. case 62:
  2597. # line 332 "shell.yacc"
  2598. { yypvt[-3].side = FHS; yyval = yypvt[-3]; } break;
  2599. # line 531 "/usr/ccs/bin/yaccpar"
  2600. }
  2601. goto yystack; /* reset registers in driver code */
  2602. }