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

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

VxWorks

开发平台：

C/C++

shell.yacc：源码内容
  1. %{
  2. /* shell.yacc - grammar for VxWorks shell */
  4. /* Copyright 1984-2001 Wind River Systems, Inc. */
  5. #include "copyright_wrs.h"
  7. /*
  8. modification history
  9. --------------------
  10. 07m,16oct01,jn   use symFindSymbol for symbol lookups
  11. 07l,27nov01,pch  Provide floating-point exclusion based on _WRS_NO_TGT_SHELL_FP
  12.  definition instead of testing a specific CPU type.
  13. 07k,23oct01,fmk  Do not call symFindByValue and print symbol name if symbol
  14.                  value = -1 SPR 22254
  15. 07j,04sep98,cdp  apply 07i for all ARM CPUs with ARM_THUMB==TRUE.
  16. 07i,30jul97,cdp  for ARM7TDMI_T, force calls to be in Thumb state.
  17. 07h,31may96,ms   added in patch for SPR 4439.
  18. 07g,19mar95,dvs  removed tron references.
  19. 07f,02mar95,yao  removed floating point temporarily for PPC403.
  20. 07e,19mar95,dvs  removed tron references.
  21. 07d,13feb93,kdl  changed cplusLib.h to private/cplusLibP.h (SPR #1917).
  22. 07c,03sep92,wmd  modified addArg() to pass floats correcty for the i960.
  23. 07b,03sep92,rrr  reduced max function arguments from 16 to 12 (for i960).
  24. 07a,31aug92,kdl  fixed passing of more than 10 parameters during funcCall();
  25.  changed MAX_ARGS to MAX_SHELL_ARGS.
  26. 06z,19aug92,jmm  fixed problem with not recognizing <= (SPR 1517)
  27. 06y,01aug92,srh  added C++ demangling idiom to printSym.
  28.                  added include of cplusLib.h.
  29. 06x,20jul92,jmm  added group parameter to symAdd call
  30. 06w,23jun92,kdl  increased max function arguments from 10 to 16.
  31. 06v,22jun92,jmm  backed out 6u change, now identical to gae's 21dec revision
  32. 06u,22jun92,jmm  added group parameter to symAdd
  33. 06t,21dec91,gae  more ANSI cleanups.
  34. 06s,19nov91,rrr  shut up some warnings.
  35. 06r,05oct91,rrr  changed strLib.h to string.h
  36. 06q,02jun91,del  added I960 parameter alignment fixes.
  37. 06p,10aug90,kdl  added forward declarations for functions returning VOID.
  38. 06o,10jul90,dnw  spr 738: removed checking of access (checkAccess, chkLvAccess)
  39.    Access checking did vxMemProbe with 4 byte read, which
  40.    caused problems with memory or devices that couldn't do
  41.    4 byte reads but could do other types of access.
  42.    Access checking was actually a throw-back to a time when
  43.    the shell couldn't recover from bus errors, but it can now.
  44.    So I just deleted the access checking.
  45.  lint clean-up, esp to allow VOID to be void one day.
  46. 06n,10dec89,jcf  symbol table type now a SYM_TYPE.
  47. 06m,09aug89,gae  fixed copyright notice.
  48. 06l,30jul89,gae  changed obsolete sysMemProbe to vxMemProbe. 
  49. 06k,07jul88,jcf  changed malloc to match new declaration.
  50. 06j,30may88,dnw  changed to v4 names.
  51. 06i,01apr88,gae  made it work with I/O system changes -- io{G,S}etGlobalStd().
  52. 06h,20feb88,dnw  lint
  53. 06g,14dec87,dnw  removed checking for odd byte address access.
  54.  changed printing format of doubles from "%f" to "%g". 
  55. 06f,18nov87,gae  made assignment to be of type specified by rhs.
  56. 06e,07nov87,gae  fixed undefined symbol bug.
  57.  fixed history bug by redirecting LED I/O.
  58. 06d,03nov87,ecs  documentation.
  59. 06c,28oct87,gae  got rid of string type.
  60. 06b,06oct87,gae  split off "execution" portion to shellExec.c.
  61.  changed to use conventional C type casting.
  62.  provided more info for invalid yacc operations.
  63.  allowed expressions to be function addresses.
  64. 06a,01jun87,gae  added interpretation of bytes, words, floats, doubles;
  65.    expressions can now be "typed" a la assembler, .[bwfdls].
  66.  fixed redirection bug with ">>" and "<<".
  67. 05i,16jul87,ecs  fixed newSym so that new symbols will be global.
  68. 05h,01apr87,gae  made assign() not print "new value" message (duplicated
  69.    normal "value" message for expressions.
  70. 05g,25apr87,gae  fixed bug in assign() that allowed memory corruption.
  71.  checked h() parameter for greater than or equal to zero.
  72.  improved redirection detection.
  73.  now parse assignments correctly as expressions.
  74. 05f,01apr87,ecs  added include of strLib.h.
  75. 05e,20jan87,jlf  documentation.
  76. 05d,14jan87,gae  got rid of unused curLineNum.  h() now has parameter, if
  77.    non-zero then resets history to that size.
  78. 05c,20dec86,dnw  changed to not get include files from default directories.
  79. 05b,18dec86,gae  made history initialization only happen on first start of
  80.    shell.  Added neStmt to fix empty stmt assignment bug.
  81. 05a,17dec86,gae  use new shCmd() in execShell() to do Korn shell-like input.
  82. 04q,08dec86,dnw  changed shell.slex.c to shell_slex.c for VAX/VMS compatiblity.
  83.     jlf  fixed a couple bugs causing problems mainly on Heurikon port.
  84. 04p,24nov86,llk  deleted SYSTEM conditional compiles.
  85. 04o,08oct86,gae  added C assignment operators; allowed multiple assignment.
  86.  STRINGs are no longer temporary.  Added setShellPrompt().
  87. 04n,27jul86,llk  added standard error fd, setOrigErrFd.
  88. 04m,17jun86,rdc  changed memAllocates to mallocs.
  89. 04l,08apr86,dnw  added call to vxSetTaskBreakable to make shell unbreakable.
  90.  changed sstLib calls to symLib.
  91. 04k,02apr86,rdc  added routines setOrigInFd and setOrigOutFd.
  92. 04j,18jan86,dnw  removed resetting (flushing) for standard in/out upon restarts;
  93.    this is now done more appropriately by the shell restart
  94.    routine in dbgLib.
  95. ...deleted pre 86 history - see RCS
  96. */
  98. /*
  99. DESCRIPTION
  100. This is the parser for the VxWorks shell, written in yacc.
  101. It provides the basic programmer's interface to VxWorks.
  102. It is a C expression interpreter, containing no built-in commands.  
  104. SEE ALSO: "Shell"
  105. */
  107. #include "vxWorks.h"
  108. #include "sysSymTbl.h"
  109. #include "errno.h"
  110. #include "errnoLib.h"
  111. #include "ioLib.h"
  112. #include "taskLib.h"
  113. #include "stdio.h"
  114. #include "private/cplusLibP.h"
  116. #define YYSTYPE VALUE /* type of parse stack */
  118. #define MAX_SHELL_LINE 128 /* max chars on line typed to shell */
  120. #define MAX_SHELL_ARGS 30 /* max number of args on stack */
  121. #define MAX_FUNC_ARGS 12 /* max number of args to any one function */
  122. /*  NOTE: The array indices in funcCall()
  123.  *        must agree with MAX_FUNC_ARGS!!
  124.  */
  126. #define BIN_OP(op) rvOp((getRv(&yypvt[-2], &tmpVal1)), op, 
  127.       getRv(&yypvt[-0], &tmpVal2))
  129. #define RV(value) (getRv (&(value), &tmpVal2))
  130. #define NULLVAL (VALUE *) NULL
  132. #define CHECK if (semError) YYERROR
  133. #define SET_ERROR semError = TRUE
  136. typedef enum /* TYPE */
  137.     {
  138.     T_UNKNOWN,
  139.     T_BYTE,
  140.     T_WORD,
  141. #ifndef _WRS_NO_TGT_SHELL_FP
  142.     T_INT,
  143.     T_FLOAT,
  144.     T_DOUBLE
  145. #else /* _WRS_NO_TGT_SHELL_FP */
  146.     T_INT
  147. #endif /* _WRS_NO_TGT_SHELL_FP */
  148.     } TYPE;
  150. typedef enum /* SIDE */
  151.     {
  152.     LHS,
  153.     RHS,
  154.     FHS /* function: rhs -> lhs */
  155.     } SIDE;
  157. typedef struct /* VALUE */
  158.     {
  159.     SIDE side;
  160.     TYPE type;
  161.     union
  162. {
  163. int *lv; /* pointer to any of the below */
  165. char byte;
  166. short word;
  167. int rv;
  168. char *string;
  169. #ifndef _WRS_NO_TGT_SHELL_FP
  170. float fp;
  171. double dp;
  172. #endif /* _WRS_NO_TGT_SHELL_FP */
  173. } value;
  174.     } VALUE;
  176. IMPORT int redirInFd;
  177. IMPORT int redirOutFd;
  179. LOCAL BOOL semError; /* TRUE = semantic error found */
  180. LOCAL VALUE tmpVal1; /* used by BIN_OP above for expression evaluation */
  181. LOCAL VALUE tmpVal2; /* used by BIN_OP above for expression evaluation */
  182. LOCAL int argStack [MAX_SHELL_ARGS]; /* arguments to functions */
  183. LOCAL int nArgs; /* number of args currently on argStack */
  184. LOCAL BOOL usymFlag; /* TRUE = U_SYMBOL has been seen */
  185. LOCAL VALUE usymVal; /* value of U_SYMBOL which has been seen */
  186. LOCAL BOOL spawnFlag; /* TRUE if spawn is first parameter in argStack[] */
  188. %}
  190. %start line
  192. %token NL 0
  193. %token T_SYMBOL D_SYMBOL U_SYMBOL NUMBER CHAR STRING FLOAT
  194. %token OR AND EQ NE GE LE INCR DECR ROT_LEFT ROT_RIGHT UMINUS PTR TYPECAST
  195. %token ENDFILE LEX_ERROR
  197. %left '=' MULA DIVA MODA ADDA SUBA SHLA SHRA ANDA ORA XORA
  198. %right '?' ':'
  199. %left OR
  200. %left AND
  201. %left '|'
  202. %left '^'
  203. %left '&'
  204. %left EQ NE
  205. %left GE LE '>' '<'
  206. %left ROT_LEFT ROT_RIGHT
  207. %left '+' '-'
  208. %left '*' '/' '%'
  209. %left INCR DECR
  210. %left UNARY /* supplies precedence for unary operators */
  211. %left PTR '[' '('
  212. %left TYPECAST
  214. %%
  216. line : stmt
  217. | stmt ';' line
  218. ;
  219. stmt : /* empty */
  220. | expr { printValue (&$1); CHECK; }
  221. ;
  223. expr : D_SYMBOL
  224. | T_SYMBOL { $1.side = RHS; setRv (&$$, &$1); }
  225. | STRING  { $$ = $1; $$.value.rv = newString((char*)$1.value.rv);
  226.    CHECK; }
  227. | CHAR
  228. | NUMBER
  229. | FLOAT
  230. | '(' expr ')'   { $$ = $2; }
  231. | expr '(' arglist ')'
  232. { $$ = funcCall (&$1, &$3); CHECK; }
  233. | typecast expr %prec TYPECAST
  234. { 
  235. typeConvert (&$2, $1.type, $1.side); $$ = $2;
  236. CHECK;
  237. }
  238. | '*' expr  %prec UNARY { VALUE tmp;
  239.   (void)getRv (&$2, &tmp);
  240.   setLv (&$$, &tmp);
  241.   CHECK;
  242. }
  243. | '&' expr  %prec UNARY { $$.value.rv = (int)getLv (&$2);
  244.   $$.type = T_INT; $$.side = RHS; }
  245. | '-' expr  %prec UNARY { rvOp (RV($2), UMINUS, NULLVAL); }
  246. | '!' expr  %prec UNARY { rvOp (RV($2), '!', NULLVAL); }
  247. | '~' expr  %prec UNARY { rvOp (RV($2), '~', NULLVAL); }
  248. | expr '?' expr ':' expr { setRv (&$$, RV($1)->value.rv ? &$3
  249.        : &$5); }
  250. | expr '[' expr ']' { BIN_OP ('+');
  251.   typeConvert (&$$, T_INT, RHS);
  252.   setLv (&$$, &$$); }
  253. | expr PTR expr { BIN_OP ('+');
  254.   typeConvert (&$$, T_INT, RHS);
  255.   setLv (&$$, &$$); }
  256. | expr '+' expr { BIN_OP ('+'); }
  257. | expr '-' expr { BIN_OP ('-'); }
  258. | expr '*' expr { BIN_OP ('*'); }
  259. | expr '/' expr  { BIN_OP ('/'); }
  260. | expr '%' expr  { BIN_OP ('%'); }
  261. | expr ROT_RIGHT expr  { BIN_OP (ROT_RIGHT); }
  262. | expr ROT_LEFT expr  { BIN_OP (ROT_LEFT); }
  263. | expr '&' expr  { BIN_OP ('&'); }
  264. | expr '^' expr  { BIN_OP ('^'); }
  265. | expr '|' expr  { BIN_OP ('|'); }
  266. | expr AND expr  { BIN_OP (AND); }
  267. | expr OR expr  { BIN_OP (OR); }
  268. | expr EQ expr  { BIN_OP (EQ); }
  269. | expr NE expr  { BIN_OP (NE); }
  270. | expr GE expr  { BIN_OP (GE); }
  271. | expr LE expr  { BIN_OP (LE); }
  272. | expr '>' expr  { BIN_OP ('>'); }
  273. | expr '<' expr  { BIN_OP ('<'); }
  274. | INCR expr %prec UNARY { rvOp (RV($2), INCR, NULLVAL);
  275.   assign (&$2, &$$); CHECK; }
  276. | DECR expr %prec UNARY { rvOp (RV($2), DECR, NULLVAL);
  277.   assign (&$2, &$$); CHECK; }
  278. | expr INCR %prec UNARY { VALUE tmp;
  279.   tmp = $1;
  280.   rvOp (RV($1), INCR, NULLVAL);
  281.   assign (&$1, &$$); CHECK;
  282.   $$ = tmp; }
  283. | expr DECR %prec UNARY { VALUE tmp;
  284.   tmp = $1;
  285.   rvOp (RV($1), DECR, NULLVAL);
  286.   assign (&$1, &$$); CHECK;
  287.   $$ = tmp; }
  288. | expr ADDA expr { BIN_OP (ADDA); assign (&$1, &$$); CHECK;}
  289. | expr SUBA expr { BIN_OP (SUBA); assign (&$1, &$$); CHECK;}
  290. | expr ANDA expr { BIN_OP (ANDA); assign (&$1, &$$); CHECK;}
  291. | expr ORA  expr { BIN_OP (ORA);  assign (&$1, &$$); CHECK;}
  292. | expr MODA expr { BIN_OP (MODA); assign (&$1, &$$); CHECK;}
  293. | expr XORA expr { BIN_OP (XORA); assign (&$1, &$$); CHECK;}
  294. | expr MULA expr { BIN_OP (MULA); assign (&$1, &$$); CHECK;}
  295. | expr DIVA expr { BIN_OP (DIVA); assign (&$1, &$$); CHECK;}
  296. | expr SHLA expr { BIN_OP (SHLA); assign (&$1, &$$); CHECK;}
  297. | expr SHRA expr { BIN_OP (SHRA); assign (&$1, &$$); CHECK;}
  298. | expr '=' expr { assign (&$1, &$3); $$ = $1; }
  299. | U_SYMBOL
  300. /* the following is to allow "undef sym" error msg,
  301.  * instead of "syntax err" when U_SYM is not followed
  302.  * by proper assignment (see yyerror() below) */
  303. { usymFlag = TRUE; usymVal = $1; }
  304. '=' expr 
  305. {
  306. if ($1.type != T_UNKNOWN)
  307.     {
  308.     printf ("typecast of lhs not allowed.n");
  309.     YYERROR;
  310.     }
  311. else
  312.     {
  313.     $$ = newSym ((char *)$1.value.rv, $4.type); CHECK;
  314.     assign (&$$, &$4); CHECK;
  315.     }
  316. usymFlag = FALSE;
  317. }
  318. ;
  320. arglist : /* empty */
  321. { $$ = newArgList (); }
  322. | neArglist
  323. ;
  325. neArglist: expr /* non-empty arglist */
  326. { $$ = newArgList (); addArg (&$$, &$1); CHECK; }
  327. | neArglist ',' expr /* ',' is required */
  328. { addArg (&$1, &$3); CHECK; }
  329. ;
  331. typecast: '(' TYPECAST ')' { $2.side = RHS; $$ = $2; }
  332. | '(' TYPECAST '(' ')' ')' { $2.side = FHS; $$ = $2; }
  333. ;
  335. %%
  337. #include "a_out.h"
  338. #include "ctype.h"
  339. #include "stdlib.h"
  340. #include "string.h"
  341. #include "symLib.h"
  343. #include "shell_slex_c"
  345. /* forward declarations */
  347. LOCAL int newString ();
  348. LOCAL VALUE *getRv ();
  349. LOCAL int *getLv ();
  350. LOCAL VALUE evalExp ();
  351. #ifndef _WRS_NO_TGT_SHELL_FP
  352. LOCAL void doubleToInts ();
  353. #endif /* _WRS_NO_TGT_SHELL_FP */
  354. LOCAL void setRv ();
  355. LOCAL void typeConvert ();
  356. LOCAL BOOL checkLv ();
  357. LOCAL BOOL checkRv ();
  359. /*******************************************************************************
  360. *
  361. * yystart - initialize local variables
  362. *
  363. * NOMANUAL
  364. */
  366. void yystart (line)
  367.     char *line;
  369.     {
  370.     lexNewLine (line);
  371.     semError = FALSE;
  372.     usymFlag = FALSE;
  373.     nArgs = 0;
  374.     spawnFlag = FALSE;
  375.     }
  376. /*******************************************************************************
  377. *
  378. * yyerror - report error
  379. *
  380. * This routine is called by yacc when an error is detected.
  381. */
  383. LOCAL void yyerror (string)
  384.     char *string;
  386.     {
  387.     if (semError) /* semantic errors have already been reported */
  388. return;
  390.     /* print error depending on what look-ahead token is */
  392.     switch (yychar)
  393. {
  394. case U_SYMBOL: /* U_SYM not at beginning of line */
  395.     printf ("undefined symbol: %sn", (char *) yylval.value.rv);
  396.     break;
  398. case LEX_ERROR:      /* lex should have already reported the problem */
  399.     break;
  401. default:
  402.     if (usymFlag)    /* leading U_SYM was followed by invalid assign */
  403. printf ("undefined symbol: %sn", (char *)usymVal.value.rv);
  404.     else
  405. printf ("%sn", string);
  406.     break;
  407. }
  408.     }
  409. /*******************************************************************************
  410. *
  411. * rvOp - sets rhs of yyval to evaluated expression
  412. */
  414. LOCAL void rvOp (pY1, op, pY2)
  415.     VALUE *pY1;
  416.     int op;
  417.     VALUE *pY2;
  419.     {
  420.     VALUE yy;
  422.     yy = evalExp (pY1, op, pY2);
  424.     setRv (&yyval, &yy);
  425.     }
  426. /*******************************************************************************
  427. *
  428. * assign - make assignment of new value to a cell
  429. */
  431. LOCAL void assign (pLv, pRv)
  432.     FAST VALUE *pLv; /* lhs to be assigned into */
  433.     FAST VALUE *pRv; /* rhs value */
  435.     {
  436.     VALUE val;
  438.     /* verify that lv can be assigned to, then make the assignment */
  440.     if (checkLv (pLv) && checkRv (pRv))
  441. {
  442. (void)getRv (pRv, &val);
  444. /* make value agree in type */
  446. pLv->type = pRv->type;
  448. typeConvert (&val, pLv->type, RHS);
  450. switch (pLv->type)
  451.     {
  452.     case T_BYTE:
  453. * (char *)getLv (pLv) = val.value.byte;
  454. break;
  456.     case T_WORD:
  457. * (short *)getLv (pLv) = val.value.word;
  458. break;
  460.     case T_INT:
  461. *getLv (pLv) = val.value.rv;
  462. break;
  464. #ifndef _WRS_NO_TGT_SHELL_FP
  465.     case T_FLOAT:
  466. * (float *)getLv (pLv) = val.value.fp;
  467. break;
  469.     case T_DOUBLE:
  470. * (double *)getLv (pLv) = val.value.dp;
  471. break;
  472. #endif /* _WRS_NO_TGT_SHELL_FP */
  474.     default:
  475. printf ("bad assignment.n");
  476. SET_ERROR;
  477.     }
  478. }
  479.     else
  480. {
  481. printf ("bad assignment.n");
  482. SET_ERROR;
  483. }
  484.     }
  485. /*******************************************************************************
  486. *
  487. * newString - allocate and copy a string
  488. */
  490. LOCAL int newString (string)
  491.     char *string;
  493.     {
  494.     int length    = strlen (string) + 1;
  495.     char *address = (char *) malloc ((unsigned) length);
  497.     if (address == NULL)
  498. {
  499. printf ("not enough memory for new string.n");
  500. SET_ERROR;
  501. }
  502.     else
  503. bcopy (string, address, length);
  505.     return ((int)address);
  506.     }
  507. /*******************************************************************************
  508. *
  509. * newSym - allocate a new symbol and add to symbol table
  510. */
  512. LOCAL VALUE newSym (name, type)
  513.     char *name;
  514.     TYPE type;
  516.     {
  517.     VALUE value;
  518.     void *address = (void *) malloc (sizeof (double));
  520.     if (address == NULL)
  521. {
  522. printf ("not enough memory for new variable.n");
  523. SET_ERROR;
  524. }
  526.     else if (symAdd (sysSymTbl, name, (char *) address, (N_BSS | N_EXT),
  527.                      symGroupDefault) != OK)
  528. {
  529. free ((char *) address);
  530. printf ("can't add '%s' to system symbol table - error = 0x%x.n",
  531. name, errnoGet());
  532. SET_ERROR;
  533. }
  534.     else
  535. {
  536. printf ("new symbol "%s" added to symbol table.n", name);
  538. value.side = LHS;
  539. value.type = type;
  540. value.value.lv = (int *) address;
  541. }
  543.     return (value);
  544.     }
  545. /*******************************************************************************
  546. *
  547. * printSym - print symbolic value
  548. */
  550. LOCAL void printSym (val, prefix, suffix)
  551.     FAST int val;
  552.     char *prefix;
  553.     char *suffix;
  555.     {
  556.     void *    symVal;  /* symbol value      */
  557.     SYMBOL_ID symId;   /* symbol identifier */
  558.     char *    name;    /* symbol name       */
  559.     char      demangled [MAX_SYS_SYM_LEN + 1];
  560.     char *    nameToPrint;
  562.     /* Only search for symbol value and print symbol name if value is not -1 */
  563.     
  564.         if ((val != -1) && 
  565.     (symFindSymbol (sysSymTbl, NULL, (void *)val, 
  566.         SYM_MASK_NONE, SYM_MASK_NONE, &symId) == OK) &&
  567.     (symNameGet (symId, &name) == OK) &&
  568.     (symValueGet (symId, &symVal) == OK) &&
  569.     (symVal != 0) && ((val - (int)symVal) < 0x1000))
  570.     {
  571.     printf (prefix);
  573.     nameToPrint = cplusDemangle(name, demangled, sizeof (demangled));
  575.     if (val == (int) symVal)
  576.         printf ("%s", nameToPrint);
  577.     else
  578.         printf ("%s + 0x%x", nameToPrint, val - (int) symVal);
  580.     printf (suffix);
  581.     }
  582.     
  583.     }
  584. /*******************************************************************************
  585. *
  586. * newArgList - start a new argument list
  587. */
  589. LOCAL VALUE newArgList ()
  590.     {
  591.     VALUE value;
  593.     value.side    = RHS;
  594.     value.type    = T_INT;
  595.     value.value.rv = nArgs;
  597.     return (value);
  598.     }
  599. /*******************************************************************************
  600. *
  601. * addArg - add an argument to an argument list
  602. */
  604. LOCAL void addArg (pArgList, pNewArg)
  605.     VALUE *pArgList;
  606.     FAST VALUE *pNewArg;
  608.     {
  609.     VALUE val;
  610.     int partA;
  611.     int partB;
  612. #if CPU_FAMILY==I960
  613.     int nArgsSave;
  614. #endif
  615. #ifndef _WRS_NO_TGT_SHELL_FP
  616.     BOOL isfloat = pNewArg->type == T_FLOAT || pNewArg->type == T_DOUBLE;
  617. #endif /* _WRS_NO_TGT_SHELL_FP */
  618.     SYMBOL_ID   symId;  /* symbol identifier           */
  619.     SYM_TYPE    sType;  /* place to return symbol type */
  621. #ifndef _WRS_NO_TGT_SHELL_FP
  622.     if (isfloat)
  623. # if CPU_FAMILY!=I960
  624. nArgs++; /* will need an extra arg slot */
  625. # else /* CPU_FAMILY!=I960 */
  626. {
  627. nArgsSave = nArgs;
  628. if (spawnFlag)
  629.     {
  630.     if ((nArgs %2) == 0)
  631.    nArgs++;
  632.     }
  633. else
  634.     {
  635.     nArgs += nArgs % 2; /* conditionally borrow slot to double align */
  636.     nArgs++; /* borrow second slot for double-word value  */
  637.     }
  638. }
  639. # endif /* CPU_FAMILY!=I960 */
  640. #endif /* _WRS_NO_TGT_SHELL_FP */
  642.     if (nArgs == MAX_SHELL_ARGS || 
  643.         (nArgs - pArgList->value.rv) == MAX_FUNC_ARGS)
  644. {
  645. #ifndef _WRS_NO_TGT_SHELL_FP
  646. if (isfloat)
  647. # if CPU_FAMILY!=I960
  648.     nArgs--; /* return borrowed slot */
  649. # else  /* CPU_FAMILY!=I960 */
  650.     nArgs = nArgsSave; /* return borrowed slot(s) */
  651. # endif /* CPU_FAMILY!=I960 */
  652. #endif /* _WRS_NO_TGT_SHELL_FP */
  653. printf ("too many arguments to functions.n");
  654. SET_ERROR;
  655. }
  656.     else
  657. {
  658. /* push arg value on top of arg stack */
  660. (void)getRv (pNewArg, &val);
  662. #ifndef _WRS_NO_TGT_SHELL_FP
  663. if (isfloat)
  664.     {
  665. # if CPU_FAMILY==I960
  666.     if (spawnFlag == FALSE)
  667. # endif /* CPU_FAMILY==I960 */
  668. nArgs--; /* return borrowed slot */
  669.     
  670.     /* put float as integers on argStack */
  672.     doubleToInts (pNewArg->type == T_FLOAT ?
  673.   val.value.fp : val.value.dp,
  674.   &partA, &partB);
  676.     argStack[nArgs++] = partA;
  677.     argStack[nArgs++] = partB;
  678.     }
  679. else if (checkRv (&val))
  680. #else /* _WRS_NO_TGT_SHELL_FP */
  681. if (checkRv (&val))
  682. #endif /* _WRS_NO_TGT_SHELL_FP */
  683.     {
  684.     int rv;
  686.     switch (val.type)
  687. {
  688. case T_BYTE:
  689.     rv = val.value.byte;
  690.     break;
  692. case T_WORD:
  693.     rv = val.value.word;
  694.     break;
  696. case T_INT:
  697.     rv = val.value.rv;
  699.     /* 
  700.      * new symLib api - symbol name lengths are no
  701.      * longer limited 
  702.      */
  704.     if (symFindSymbol (sysSymTbl, NULL, (void *)rv, 
  705.            SYM_MASK_NONE, SYM_MASK_NONE, 
  706.        &symId) == OK)
  707.   symTypeGet (symId, &sType);
  709.     if ((nArgs == 0) && (sType == (N_TEXT + N_EXT)))
  710. spawnFlag = TRUE;
  711.     break;
  713. default:
  714.     rv = 0;
  715.     printf ("addArg: bad type.n");
  716.     SET_ERROR;
  717. }
  719.     argStack[nArgs++] = rv;
  720.     }
  721. }
  722.     }
  723. #ifndef _WRS_NO_TGT_SHELL_FP
  724. /*******************************************************************************
  725. *
  726. * doubleToInts - separate double into two integer parts
  727. */
  729. LOCAL void doubleToInts (d, partA, partB)
  730.     double d;
  731.     int *partA;
  732.     int *partB;
  734.     {
  735.     union 
  736. {
  737. struct
  738.     {
  739.     int a;
  740.     int b;
  741.     } part;
  742. double d;
  743. } val;
  745.     val.d = d;
  747.     *partA = val.part.a;
  748.     *partB = val.part.b;
  749.     }
  750. #endif /* _WRS_NO_TGT_SHELL_FP */
  751. /*******************************************************************************
  752. *
  753. * funcCall - call a function
  754. */
  756. LOCAL VALUE funcCall (pV, pArgList)
  757.     VALUE *pV;
  758.     VALUE *pArgList;
  760.     {
  761.     static int funcStatus; /* status from function calls */
  762.     int a [MAX_FUNC_ARGS];
  763.     VALUE value;
  764.     FAST int i;
  765.     FAST int argNum;
  766.     int oldInFd  = ioGlobalStdGet (STD_IN);
  767.     int oldOutFd = ioGlobalStdGet (STD_OUT);
  768.     FUNCPTR pFunc = (pV->side == LHS) ? (FUNCPTR) (int)getLv (pV)
  769.       : (FUNCPTR) pV->value.rv;
  771. #if ((CPU_FAMILY == ARM) && ARM_THUMB)
  772.     pFunc = (FUNCPTR)((UINT32)pFunc | 1); /* make it a Thumb call */
  773. #endif
  775.     /* get any specified args off stack, or pre-set all args to 0 */
  777.     for (argNum = pArgList->value.rv, i = 0; i < MAX_FUNC_ARGS; argNum++, i++)
  778. {
  779. a [i] = (argNum < nArgs) ? argStack[argNum] : 0;
  780. }
  782.     /* set standard in/out to redirection fds */
  784.     if (redirInFd >= 0)
  785. ioGlobalStdSet (STD_IN, redirInFd);
  787.     if (redirOutFd >= 0)
  788. ioGlobalStdSet (STD_OUT, redirOutFd);
  790.     /* call function and save resulting status */
  792.     errnoSet (funcStatus);
  794.     value.side = RHS;
  795.     value.type = pV->type;
  797.     switch (pV->type)
  798. {
  799. case T_BYTE:
  800. case T_WORD:
  801. case T_INT:
  802.     {
  803.     /* NOTE: THE FOLLOWING ARRAY REFERENCES MUST AGREE WITH THE
  804.      *       MAX_FUNC_ARGS COUNT DEFINED ABOVE IN THIS FILE!
  805.      */
  806.     int rv = (* pFunc) (a[0], a[1], a[2], a[3], a[4], a[5], a[6],
  807. a[7], a[8], a[9], a[10], a[11]);
  809.     switch (pV->type)
  810. {
  811. case T_BYTE:
  812.     value.value.byte = (char) rv;
  813.     break;
  815. case T_WORD:
  816.     value.value.word = (short) rv;
  817.     break;
  819. case T_INT:
  820.     value.value.rv = rv;
  821.     break;
  822. default:
  823.     break;
  824. }
  826.     break;
  827.     }
  829. #ifndef _WRS_NO_TGT_SHELL_FP
  830. case T_FLOAT:
  831.     value.value.fp = (* (float (*)())pFunc) (a[0], a[1], a[2], a[3],
  832. a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11]);
  833.     break;
  835. case T_DOUBLE:
  836.     value.value.dp = (* (double (*)())pFunc) (a[0], a[1], a[2], a[3],
  837. a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11]);
  838.     break;
  839. #endif /* _WRS_NO_TGT_SHELL_FP */
  841. default:
  842.     printf ("funcCall: bad function type.n");
  843.     SET_ERROR;
  844. }
  846.     funcStatus = errnoGet ();
  848.     /* restore original in/out fds */
  850.     if (redirInFd >= 0)
  851. ioGlobalStdSet (STD_IN, oldInFd);
  853.     if (redirOutFd >= 0)
  854. ioGlobalStdSet (STD_OUT, oldOutFd);
  856.     /* arg stack back to previous level */
  858.     nArgs = pArgList->value.rv;
  860.     return (value);
  861.     }
  862. /*******************************************************************************
  863. *
  864. * checkLv - check that a value can be used as left value
  865. */
  867. LOCAL BOOL checkLv (pValue)
  868.     VALUE *pValue;
  870.     {
  871.     if (pValue->side != LHS)
  872. {
  873. printf ("invalid application of 'address of' operator.n");
  874. SET_ERROR;
  875. return (FALSE);
  876. }
  878.     return (TRUE);
  879.     }
  880. /*******************************************************************************
  881. *
  882. * checkRv - check that a value can be used as right value
  883. */
  885. LOCAL BOOL checkRv (pValue)
  886.     VALUE *pValue;
  888.     {
  889.     if (pValue->side == LHS)
  890. return (checkLv (pValue));
  892.     return (TRUE);
  893.     }
  894. /*******************************************************************************
  895. *
  896. * getRv - get a value's right value 
  897. */
  899. LOCAL VALUE *getRv (pValue, pRv)
  900.     FAST VALUE *pValue;
  901.     FAST VALUE *pRv; /* where to put value */
  903.     {
  904.     if (pValue->side == RHS)
  905. *pRv = *pValue;
  906.     else
  907. {
  908. pRv->side = RHS;
  909. pRv->type = pValue->type;
  911. switch (pValue->type)
  912.     {
  913.     case T_BYTE:
  914. pRv->value.byte = *(char *)pValue->value.lv;
  915. break;
  917.     case T_WORD:
  918. pRv->value.word = *(short *)pValue->value.lv;
  919. break;
  921.     case T_INT:
  922. pRv->value.rv = *pValue->value.lv;
  923. break;
  925. #ifndef _WRS_NO_TGT_SHELL_FP
  926.     case T_FLOAT:
  927. pRv->value.fp = *(float *)pValue->value.lv;
  928. break;
  930.     case T_DOUBLE:
  931. pRv->value.dp = *(double *)pValue->value.lv;
  932. break;
  933. #endif /* _WRS_NO_TGT_SHELL_FP */
  935.     default:
  936. printf ("getRv: invalid rhs.");
  937. SET_ERROR;
  938.     }
  939. }
  941.     return (pRv);
  942.     }
  943. /*******************************************************************************
  944. *
  945. * getLv - get a value's left value (address)
  946. */
  948. LOCAL int *getLv (pValue)
  949.     VALUE *pValue;
  951.     {
  952.     return (checkLv (pValue) ? pValue->value.lv : 0);
  953.     }
  954. /*******************************************************************************
  955. *
  956. * setLv - set a lv
  957. */
  959. LOCAL void setLv (pVal1, pVal2)
  960.     FAST VALUE *pVal1;
  961.     FAST VALUE *pVal2;
  963.     {
  964.     if (pVal2->side == LHS)
  965. {
  966. printf ("setLv: invalid lhs.n");
  967. SET_ERROR;
  968. }
  970.     if ((int)pVal2->type != (int)T_INT)
  971. {
  972. printf ("setLv: type conflict.n");
  973. SET_ERROR;
  974. }
  976.     pVal1->side     = LHS;
  977.     pVal1->type     = pVal2->type;
  978.     pVal1->value.lv = (int *)pVal2->value.rv;
  979.     }
  980. /*******************************************************************************
  981. *
  982. * setRv - set the rv
  983. */
  985. LOCAL void setRv (pVal1, pVal2)
  986.     FAST VALUE *pVal1;
  987.     FAST VALUE *pVal2;
  989.     {
  990.     pVal1->side = RHS;
  991.     pVal1->type = pVal2->type;
  993.     switch (pVal2->type)
  994. {
  995. case T_BYTE:
  996.     pVal1->value.byte = (pVal2->side == LHS) ?
  997.     *(char *)pVal2->value.lv : pVal2->value.byte;
  998. case T_WORD:
  999.     pVal1->value.word = (pVal2->side == LHS) ?
  1000.     *(short *)pVal2->value.lv : pVal2->value.word;
  1002. case T_INT:
  1003.     pVal1->value.rv = (pVal2->side == LHS) ?
  1004.     *pVal2->value.lv : pVal2->value.rv;
  1005.     break;
  1007. #ifndef _WRS_NO_TGT_SHELL_FP
  1008. case T_FLOAT:
  1009.     pVal1->value.fp = (pVal2->side == LHS) ?
  1010.     *(float *)pVal2->value.lv : pVal2->value.fp;
  1011.     break;
  1013. case T_DOUBLE:
  1014.     pVal1->value.dp = (pVal2->side == LHS) ?
  1015.     *(double *)pVal2->value.lv : pVal2->value.dp;
  1016.     break;
  1017. #endif /* _WRS_NO_TGT_SHELL_FP */
  1019. default:
  1020.     printf ("setRv: bad type.n");
  1021.     SET_ERROR;
  1022. }
  1023.     }
  1024. /*******************************************************************************
  1025. *
  1026. * printLv - print left-hand side value
  1027. *
  1028. * "ssss + xxx = xxxx"
  1029. */
  1031. LOCAL void printLv (pValue)
  1032.     VALUE *pValue;
  1034.     {
  1035.     FAST int *lv = getLv (pValue);
  1037.     printSym ((int) lv, "", " = ");
  1039.     printf ("0x%x", (UINT) lv);
  1040.     }
  1041. /*******************************************************************************
  1042. *
  1043. * printRv - print right-hand side value
  1044. *
  1045. * The format for integers is:
  1046. *
  1047. * "nnnn = xxxx = 'c' = ssss + nnn"
  1048. *                           ^ only if nn < LIMIT for some ssss
  1049. *                 ^ only if value is printable
  1050. */
  1052. LOCAL void printRv (pValue)
  1053.     VALUE *pValue;
  1055.     {
  1056.     VALUE val;
  1057.     int rv;
  1059.     (void)getRv (pValue, &val);
  1061.     switch (pValue->type)
  1062. {
  1063. case T_BYTE:
  1064.     rv = val.value.byte;
  1065.     goto caseT_INT;
  1067. case T_WORD:
  1068.     rv = val.value.word;
  1069.     goto caseT_INT;
  1071. case T_INT:
  1072.     rv = val.value.rv;
  1073.     /* drop through */
  1075. caseT_INT:
  1076.     printf ("%d = 0x%x", rv, rv);
  1077.     if (isascii (rv) && isprint (rv))
  1078. printf (" = '%c'", rv);
  1080.     printSym (rv, " = ", "");
  1081.     break;
  1083. #ifndef _WRS_NO_TGT_SHELL_FP
  1084. case T_FLOAT:
  1085.     printf ("%g", val.value.fp);
  1086.     break;
  1088. case T_DOUBLE:
  1089.     printf ("%g", val.value.dp);
  1090.     break;
  1091. #endif /* _WRS_NO_TGT_SHELL_FP */
  1093. default:
  1094.     printf ("printRv: bad type.n");
  1095.     SET_ERROR;
  1096. }
  1097.     }
  1098. /*******************************************************************************
  1099. *
  1100. * printValue - print out value
  1101. */
  1103. LOCAL void printValue (pValue)
  1104.     FAST VALUE *pValue;
  1106.     {
  1107.     if (pValue->side == LHS)
  1108. {
  1109. if (checkLv (pValue) && checkRv (pValue))
  1110.     {
  1111.     printLv (pValue);
  1112.     printf (": value = ");
  1114.     printRv (pValue);
  1115.     printf ("n");
  1116.     }
  1117. else
  1118.     {
  1119.     printf ("invalid lhs.n");
  1120.     SET_ERROR;
  1121.     }
  1122. }
  1123.     else if (checkRv (pValue))
  1124. {
  1125. printf ("value = ");
  1127. printRv (pValue);
  1128. printf ("n");
  1129. }
  1130.     else
  1131. {
  1132. printf ("invalid rhs.n");
  1133. SET_ERROR;
  1134. }
  1135.     }
  1137. /* TYPE SUPPORT */
  1139. LOCAL VALUE evalUnknown ();
  1140. LOCAL VALUE evalByte ();
  1141. LOCAL VALUE evalWord ();
  1142. LOCAL VALUE evalInt ();
  1143. LOCAL VALUE evalFloat ();
  1144. LOCAL VALUE evalDouble ();
  1146. typedef struct /* EVAL_TYPE */
  1147.     {
  1148.     VALUE (*eval) ();
  1149.     } EVAL_TYPE;
  1151. LOCAL EVAL_TYPE evalType [] =
  1152.     {
  1153.     /* eval type */
  1154.     /* --------------- -------------- */
  1155.       { evalUnknown, /* T_UNKNOWN*/ },
  1156.       { evalByte, /* T_BYTE   */ },
  1157.       { evalWord, /* T_WORD   */ },
  1158.       { evalInt, /* T_INT    */ },
  1159. #ifndef _WRS_NO_TGT_SHELL_FP
  1160.       { evalFloat, /* T_FLOAT  */ },
  1161.       { evalDouble, /* T_DOUBLE */ },
  1162. #endif /* _WRS_NO_TGT_SHELL_FP */
  1163.     };
  1165. /*******************************************************************************
  1166. *
  1167. * evalExp - evaluate expression
  1168. */
  1170. LOCAL VALUE evalExp (pValue1, op, pValue2)
  1171.     VALUE *pValue1;
  1172.     int op;
  1173.     VALUE *pValue2;
  1175.     {
  1176.     VALUE *p1 = pValue1;
  1177.     VALUE *p2 = pValue2;
  1179.     if (pValue2 == NULLVAL) /* unary expresions must set pValue2 to something */
  1180. p2 = pValue2 = pValue1;
  1182.     /* make sure values have the same type */
  1184.     if ((int)p1->type > (int)p2->type)
  1185. typeConvert (p2, p1->type, p1->side);
  1186.     else
  1187. typeConvert (p1, p2->type, p2->side);
  1189.     return ((evalType[(int)pValue1->type].eval) (pValue1, op, pValue2));
  1190.     }
  1191. /*******************************************************************************
  1192. *
  1193. * evalUnknown - evaluate for unknown result
  1194. *
  1195. * ARGSUSED
  1196. */
  1198. LOCAL VALUE evalUnknown (pValue1, op, pValue2)
  1199.     VALUE *pValue1;
  1200.     int op;
  1201.     VALUE *pValue2;
  1203.     {
  1204.     printf ("evalUnknown: bad evaluation.n");
  1206.     SET_ERROR;
  1208.     return (*pValue1); /* have to return something */
  1209.     }
  1210. /*******************************************************************************
  1211. *
  1212. * evalByte - evaluate for byte result
  1213. */
  1215. LOCAL VALUE evalByte (pValue1, op, pValue2)
  1216.     VALUE *pValue1;
  1217.     int op;
  1218.     VALUE *pValue2;
  1220.     {
  1221.     VALUE *p1 = pValue1;
  1222.     VALUE *p2 = pValue2;
  1223.     VALUE result;
  1225.     /* evaluate as integers and then convert back */
  1227.     typeConvert (p1, T_INT, RHS);
  1228.     typeConvert (p2, T_INT, RHS);
  1230.     result = evalInt (p1, op, p2);
  1232.     typeConvert (&result, T_BYTE, RHS);
  1234.     return (result);
  1235.     }
  1236. /*******************************************************************************
  1237. *
  1238. * evalWord - evaluate for word result
  1239. */
  1241. LOCAL VALUE evalWord (pValue1, op, pValue2)
  1242.     VALUE *pValue1;
  1243.     int op;
  1244.     VALUE *pValue2;
  1246.     {
  1247.     VALUE *p1 = pValue1;
  1248.     VALUE *p2 = pValue2;
  1249.     VALUE result;
  1251.     /* evaluate as integers and then convert back */
  1253.     typeConvert (p1, T_INT, RHS);
  1254.     typeConvert (p2, T_INT, RHS);
  1256.     result = evalInt (p1, op, p2);
  1258.     typeConvert (&result, T_WORD, RHS);
  1260.     return (result);
  1261.     }
  1262. /*******************************************************************************
  1263. *
  1264. * evalInt - evaluate for integer result
  1265. */
  1267. LOCAL VALUE evalInt (pValue1, op, pValue2)
  1268.     VALUE *pValue1;
  1269.     int op;
  1270.     VALUE *pValue2;
  1272.     {
  1273. #define OP_INT(op) rv = e1 op e2; break
  1274. #define OP_INT_U(op) rv = op e1; break
  1276.     FAST int e1 = pValue1->value.rv;
  1277.     FAST int e2 = pValue2->value.rv;
  1278.     FAST int rv;
  1279.     VALUE result;
  1281.     switch (op)
  1282. {
  1283. case ADDA:
  1284. case '+':
  1285.     OP_INT(+);
  1286. case SUBA:
  1287. case '-':
  1288.     OP_INT(-);
  1289. case MULA:
  1290. case '*':
  1291.     OP_INT(*);
  1292. case DIVA:
  1293. case '/':
  1294.     OP_INT(/);
  1295. case '!':
  1296.     OP_INT_U(!);
  1297. case '~':
  1298.     OP_INT_U(~);
  1299. case MODA:
  1300. case '%':
  1301.     OP_INT(%);
  1302. case ANDA:
  1303. case '&':
  1304.     OP_INT(&);
  1305. case XORA:
  1306. case '^':
  1307.     OP_INT(^);
  1308. case ORA:
  1309. case '|':
  1310.     OP_INT(|);
  1311. case '<':
  1312.     OP_INT(<);
  1313. case '>':
  1314.     OP_INT(>);
  1315. case OR:
  1316.     OP_INT(||);
  1317. case AND:
  1318.     OP_INT(&&);
  1319. case EQ:
  1320.     OP_INT(==);
  1321. case NE:
  1322.     OP_INT(!=);
  1323. case GE:
  1324.     OP_INT(>=);
  1325. case LE:
  1326.     OP_INT(<=);
  1327. case INCR:
  1328.     OP_INT_U(++);
  1329. case DECR:
  1330.     OP_INT_U(--);
  1331. case SHLA:
  1332. case ROT_LEFT:
  1333.     OP_INT(<<);
  1334. case SHRA:
  1335. case ROT_RIGHT:
  1336.     OP_INT(>>);
  1337. case UMINUS:
  1338.     OP_INT_U(-);
  1339. default:
  1340.     rv = 0;
  1341.     printf ("operands have incompatible types.n");
  1342.     SET_ERROR;
  1343. }
  1345.     result.side     = RHS;
  1346.     result.type     = pValue1->type;
  1347.     result.value.rv = rv;
  1349.     return (result);
  1350.     }
  1351. #ifndef _WRS_NO_TGT_SHELL_FP
  1352. /*******************************************************************************
  1353. *
  1354. * evalFloat - evaluate for float result
  1355. */
  1357. LOCAL VALUE evalFloat (pValue1, op, pValue2)
  1358.     VALUE *pValue1;
  1359.     int op;
  1360.     VALUE *pValue2;
  1362.     {
  1363.     VALUE *p1 = pValue1;
  1364.     VALUE *p2 = pValue2;
  1365.     VALUE result;
  1367.     /* evaluate as doubles and then convert back */
  1369.     typeConvert (p1, T_DOUBLE, RHS);
  1370.     typeConvert (p2, T_DOUBLE, RHS);
  1372.     result = evalDouble (p1, op, p2);
  1374.     typeConvert (&result, T_FLOAT, RHS);
  1376.     return (result);
  1377.     }
  1378. /*******************************************************************************
  1379. *
  1380. * evalDouble - evaluate for double result
  1381. */
  1383. LOCAL VALUE evalDouble (pValue1, op, pValue2)
  1384.     VALUE *pValue1;
  1385.     int op;
  1386.     VALUE *pValue2;
  1388.     {
  1389. #define OP_DOUBLE(op) dp = e1 op e2; break
  1390. #define OP_DOUBLE_U(op) dp = op e1; break
  1392.     FAST double e1 = pValue1->value.dp;
  1393.     FAST double e2 = pValue2->value.dp;
  1394.     FAST double dp;
  1395.     VALUE result;
  1397.     switch (op)
  1398. {
  1399. case ADDA:
  1400. case '+':
  1401.     OP_DOUBLE(+);
  1402. case SUBA:
  1403. case '-':
  1404.     OP_DOUBLE(-);
  1405. case MULA:
  1406. case '*':
  1407.     OP_DOUBLE(*);
  1408. case DIVA:
  1409. case '/':
  1410.     OP_DOUBLE(/);
  1411. case '!':
  1412.     OP_DOUBLE_U(!);
  1414. case '<':
  1415.     OP_DOUBLE(<);
  1416. case '>':
  1417.     OP_DOUBLE(>);
  1418. case OR:
  1419.     OP_DOUBLE(||);
  1420. case AND:
  1421.     OP_DOUBLE(&&);
  1422. case EQ:
  1423.     OP_DOUBLE(==);
  1424. case NE:
  1425.     OP_DOUBLE(!=);
  1426. case GE:
  1427.     OP_DOUBLE(>=);
  1428. case LE:
  1429.     OP_DOUBLE(<=);
  1430. case INCR:
  1431.     OP_DOUBLE_U(++);
  1432. case DECR:
  1433.     OP_DOUBLE_U(--);
  1435. case UMINUS:
  1436.     OP_DOUBLE_U(-);
  1438. default:
  1439.     dp = 0;
  1440.     printf ("operands have incompatible types.n");
  1441.     SET_ERROR;
  1442. }
  1444.     result.side     = RHS;
  1445.     result.type     = T_DOUBLE;
  1446.     result.value.dp = dp;
  1448.     return (result);
  1449.     }
  1450. #endif /* _WRS_NO_TGT_SHELL_FP */
  1452. /* TYPE CONVERSION */
  1454. LOCAL void convUnknown ();
  1455. LOCAL void convByte ();
  1456. LOCAL void convWord ();
  1457. LOCAL void convInt ();
  1458. #ifndef _WRS_NO_TGT_SHELL_FP
  1459. LOCAL void convFloat ();
  1460. LOCAL void convDouble ();
  1461. #endif /* _WRS_NO_TGT_SHELL_FP */
  1463. typedef void (*VOID_FUNCPTR) (); /* ptr to a function returning void */
  1465. LOCAL VOID_FUNCPTR convType [] =
  1466.     {
  1467.     /*  conversion type     */
  1468.     /*  ---------- ----------- */
  1469. convUnknown, /* T_UNKNOWN*/
  1470. convByte, /* T_BYTE   */
  1471. convWord, /* T_WORD   */
  1472. convInt, /* T_INT    */
  1473. #ifndef _WRS_NO_TGT_SHELL_FP
  1474. convFloat, /* T_FLOAT  */
  1475. convDouble, /* T_DOUBLE */
  1476. #endif /* _WRS_NO_TGT_SHELL_FP */
  1477.     };
  1479. /*******************************************************************************
  1480. *
  1481. * typeConvert - change value to specified type
  1482. */
  1484. LOCAL void typeConvert (pValue, type, side)
  1485.     FAST VALUE *pValue;
  1486.     TYPE type;
  1487.     SIDE side;
  1489.     {
  1490.     if (side == FHS)
  1491. {
  1492. pValue->side = RHS;
  1493. pValue->type = type;
  1494. }
  1495.     else if (side == RHS)
  1496. {
  1497. if (pValue->side == LHS)
  1498.     pValue->type = type;
  1499. else
  1500.     (convType [(int) type]) (pValue);
  1501. }
  1502.     else if (pValue->side == LHS)
  1503. pValue->type = type;
  1504.     else
  1505. {
  1506. printf ("typeConvert: bad type.n");
  1507. SET_ERROR;
  1508. }
  1509.     }
  1510. /*******************************************************************************
  1511. *
  1512. * convUnknown - convert value to unknown
  1513. *
  1514. * ARGSUSED
  1515. */
  1517. LOCAL void convUnknown (pValue)
  1518.     VALUE *pValue;
  1520.     {
  1521.     printf ("convUnknown: bad type.n");
  1522.     SET_ERROR;
  1523.     }
  1524. /*******************************************************************************
  1525. *
  1526. * convByte - convert value to byte
  1527. */
  1529. LOCAL void convByte (pValue)
  1530.     FAST VALUE *pValue;
  1532.     {
  1533.     char value;
  1535.     if ((int)pValue->type > (int)T_BYTE)
  1536. {
  1537. convWord (pValue);
  1538. value = pValue->value.word;
  1539. pValue->value.byte = value;
  1540. pValue->type = T_BYTE;
  1541. }
  1542.     }
  1543. /*******************************************************************************
  1544. *
  1545. * convWord - convert value to word
  1546. */
  1548. LOCAL void convWord (pValue)
  1549.     FAST VALUE *pValue;
  1551.     {
  1552.     short value;
  1554.     if ((int)pValue->type < (int)T_WORD)
  1555. {
  1556. value = pValue->value.byte;
  1557. pValue->value.word = value;
  1558. pValue->type = T_WORD;
  1559. }
  1560.     else if ((int)pValue->type > (int)T_WORD)
  1561. {
  1562. convInt (pValue);
  1563. value = pValue->value.rv;
  1564. pValue->value.word = value;
  1565. pValue->type = T_WORD;
  1566. }
  1567.     }
  1568. /*******************************************************************************
  1569. *
  1570. * convInt - convert value to integer
  1571. */
  1573. LOCAL void convInt (pValue)
  1574.     FAST VALUE *pValue;
  1576.     {
  1577.     int value;
  1579.     if ((int)pValue->type < (int)T_INT)
  1580. {
  1581. convWord (pValue);
  1582. value = pValue->value.word;
  1583. pValue->value.rv = value;
  1584. pValue->type = T_INT;
  1585. }
  1586.     else if ((int)pValue->type > (int)T_INT)
  1587. {
  1588. #ifndef _WRS_NO_TGT_SHELL_FP
  1589. convFloat (pValue);
  1590. value = pValue->value.fp;
  1591. pValue->value.rv = value;
  1592. pValue->type = T_INT;
  1593. #endif /* _WRS_NO_TGT_SHELL_FP */
  1594. }
  1595.     }
  1596. #ifndef _WRS_NO_TGT_SHELL_FP
  1597. /*******************************************************************************
  1598. *
  1599. * convFloat - convert value to float
  1600. */
  1602. LOCAL void convFloat (pValue)
  1603.     FAST VALUE *pValue;
  1605.     {
  1606.     float value;
  1608.     if ((int)pValue->type < (int)T_FLOAT)
  1609. {
  1610. convInt (pValue);
  1611. value = pValue->value.rv;
  1612. pValue->value.fp = value;
  1613. pValue->type = T_FLOAT;
  1614. }
  1615.     else if ((int)pValue->type > (int)T_FLOAT)
  1616. {
  1617. convDouble (pValue);
  1618. value = pValue->value.dp;
  1619. pValue->value.fp = value;
  1620. pValue->type = T_FLOAT;
  1621. }
  1622.     }
  1623. /*******************************************************************************
  1624. *
  1625. * convDouble - convert value to double
  1626. */
  1628. LOCAL void convDouble (pValue)
  1629.     FAST VALUE *pValue;
  1631.     {
  1632.     double value;
  1634.     if ((int)pValue->type < (int)T_DOUBLE)
  1635. {
  1636. convFloat (pValue);
  1638. value = pValue->value.fp;
  1639. pValue->value.dp = value;
  1640. pValue->type = T_DOUBLE;
  1641. }
  1642.     }
  1643. #endif /* _WRS_NO_TGT_SHELL_FP */