home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource4 / 243_01 / cpp5.c < prev    next >
C/C++ Source or Header  |  1990-05-14  |  32KB  |  1,032 lines
  1.  
  2. /*
  3.  *                          C P P 5 . C
  4.  *              E x p r e s s i o n   E v a l u a t i o n
  5.  *
  6.  * Edit History
  7.  * 31-Aug-84    MM      USENET net.sources release
  8.  * 04-Oct-84    MM      __LINE__ and __FILE__ must call ungetstring()
  9.  *                      so they work correctly with token concatenation.
  10.  *                      Added string formal recognition.
  11.  * 25-Oct-84    MM      "Short-circuit" evaluate #if's so that we
  12.  *                      don't print unnecessary error messages for
  13.  *                      #if !defined(FOO) && FOO != 0 && 10 / FOO ...
  14.  * 31-Oct-84    ado/MM  Added token concatenation
  15.  *  6-Nov-84    MM      Split from #define stuff, added sizeof stuff
  16.  * 19-Nov-84    ado     #if error returns TRUE for (sigh) compatibility
  17.  * 22-Apr-85    ado/MM  added evalone to properly handle \value
  18.  * 29-Apr-85    ado     Cleaned up #if ... sizeof
  19.  */
  20.  
  21. #include        "cppdef.h"
  22. #include        "cpp.h"
  23.  
  24. /*
  25.  * Evaluate an #if expression.
  26.  */
  27.  
  28. static char     *opname[] = {           /* For debug and error messages */
  29. "end of expression", "val", "id",
  30.   "+",   "-",  "*",  "/",  "%",
  31.   "<<", ">>",  "&",  "|",  "^",
  32.   "==", "!=",  "<", "<=", ">=",  ">",
  33.   "&&", "||",  "?",  ":",  ",",
  34.   "unary +", "unary -", "~", "!",  "(",  ")", "(none)",
  35. };
  36.  
  37. /*
  38.  * opdope[] has the operator precedence:
  39.  *     Bits
  40.  *        7     Unused (so the value is always positive)
  41.  *      6-2     Precedence (000x .. 017x)
  42.  *      1-0     Binary op. flags:
  43.  *          01  The binop flag should be set/cleared when this op is seen.
  44.  *          10  The new value of the binop flag.
  45.  * Note:  Expected, New binop
  46.  * constant     0       1       Binop, end, or ) should follow constants
  47.  * End of line  1       0       End may not be preceeded by an operator
  48.  * binary       1       0       Binary op follows a value, value follows.
  49.  * unary        0       0       Unary op doesn't follow a value, value follows
  50.  *   (          0       0       Doesn't follow value, value or unop follows
  51.  *   )          1       1       Follows value.  Op follows.
  52.  */
  53.  
  54. static char     opdope[OP_MAX] = {
  55.   0001,                                 /* End of expression            */
  56.   0002,                                 /* Digit                        */
  57.   0000,                                 /* Letter (identifier)          */
  58.   0141, 0141, 0151, 0151, 0151,         /* ADD, SUB, MUL, DIV, MOD      */
  59.   0131, 0131, 0101, 0071, 0071,         /* ASL, ASR, AND,  OR, XOR      */
  60.   0111, 0111, 0121, 0121, 0121, 0121,   /*  EQ,  NE,  LT,  LE,  GE,  GT */
  61.   0061, 0051, 0041, 0041, 0031,         /* ANA, ORO, QUE, COL, CMA      */
  62. /*
  63.  * Unary op's follow
  64.  */
  65.   0160, 0160, 0160, 0160,               /* NEG, PLU, COM, NOT           */
  66.   0170, 0013, 0023,                     /* LPA, RPA, END                */
  67. };
  68. /*
  69.  * OP_QUE and OP_RPA have alternate precedences:
  70.  */
  71. #define OP_RPA_PREC     0013
  72. #define OP_QUE_PREC     0034
  73.  
  74. /*
  75.  * S_ANDOR and S_QUEST signal "short-circuit" boolean evaluation, so that
  76.  *      #if FOO != 0 && 10 / FOO ...
  77.  * doesn't generate an error message.  They are stored in optab.skip.
  78.  */
  79. #define S_ANDOR         2
  80. #define S_QUEST         1
  81.  
  82. typedef struct optab {
  83.     char        op;                     /* Operator                     */
  84.     char        prec;                   /* Its precedence               */
  85.     char        skip;                   /* Short-circuit: TRUE to skip  */
  86. } OPTAB;
  87. static int      evalue;                 /* Current value from evallex() */
  88.  
  89. #ifdef  nomacargs
  90. FILE_LOCAL int
  91. isbinary(op)
  92. register int    op;
  93. {
  94.         return (op >= FIRST_BINOP && op <= LAST_BINOP);
  95. }
  96.  
  97. FILE_LOCAL int
  98. isunary(op)
  99. register int    op;
  100. {
  101.         return (op >= FIRST_UNOP && op <= LAST_UNOP);
  102. }
  103. #else
  104. #define isbinary(op)    (op >= FIRST_BINOP && op <= LAST_BINOP)
  105. #define isunary(op)     (op >= FIRST_UNOP  && op <= LAST_UNOP)
  106. #endif
  107.  
  108.  
  109.  
  110.  
  111.  
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120.  
  121.  
  122.  
  123.  
  124. /*
  125.  * The following definitions are used to specify basic variable sizes.
  126.  */
  127.  
  128. #ifndef S_CHAR
  129. #define S_CHAR          (sizeof (char))
  130. #endif
  131. #ifndef S_SINT
  132. #define S_SINT          (sizeof (short int))
  133. #endif
  134. #ifndef S_INT
  135. #define S_INT           (sizeof (int))
  136. #endif
  137. #ifndef S_LINT
  138. #define S_LINT          (sizeof (long int))
  139. #endif
  140. #ifndef S_FLOAT
  141. #define S_FLOAT         (sizeof (float))
  142. #endif
  143. #ifndef S_DOUBLE
  144. #define S_DOUBLE        (sizeof (double))
  145. #endif
  146. #ifndef S_PCHAR
  147. #define S_PCHAR         (sizeof (char *))
  148. #endif
  149. #ifndef S_PSINT
  150. #define S_PSINT         (sizeof (short int *))
  151. #endif
  152. #ifndef S_PINT
  153. #define S_PINT          (sizeof (int *))
  154. #endif
  155. #ifndef S_PLINT
  156. #define S_PLINT         (sizeof (long int *))
  157. #endif
  158. #ifndef S_PFLOAT
  159. #define S_PFLOAT        (sizeof (float *))
  160. #endif
  161. #ifndef S_PDOUBLE
  162. #define S_PDOUBLE       (sizeof (double *))
  163. #endif
  164. #ifndef S_PFPTR
  165. #define S_PFPTR         (sizeof (int (*)()))
  166. #endif
  167.  
  168.  
  169.  
  170.  
  171.  
  172. typedef struct types {
  173.     short       type;                   /* This is the bit if           */
  174.     char        *name;                  /* this is the token word       */
  175.     short       excluded;               /* but these aren't legal here  */
  176. } TYPES;
  177.  
  178. #define ANYSIGN         (T_SIGNED | T_UNSIGNED)
  179. #define ANYFLOAT        (T_FLOAT  | T_DOUBLE)
  180. #define ANYINT          (T_CHAR   | T_SHORT | T_INT | T_LONG)
  181.  
  182. static TYPES basic_types[] = {
  183.         T_CHAR,         "char",         ANYFLOAT | ANYINT,
  184.         T_INT,          "int",          ANYFLOAT | T_CHAR | T_INT,
  185.         T_FLOAT,        "float",        ANYFLOAT | ANYINT | ANYSIGN,
  186.         T_DOUBLE,       "double",       ANYFLOAT | ANYINT | ANYSIGN,
  187.         T_SHORT,        "short",        ANYFLOAT | ANYINT,
  188.         T_LONG,         "long",         ANYFLOAT | ANYINT,
  189.         T_SIGNED,       "signed",       ANYFLOAT | ANYINT | T_CHAR | T_INT,
  190.         T_UNSIGNED,     "unsigned",     ANYFLOAT | ANYINT | T_CHAR | T_INT,
  191.         0,              NULL,           0       /* Signal end           */
  192. };
  193.  
  194.  
  195. /*
  196.  * The order of this table is important -- it is also referenced by
  197.  * the command line processor to allow run-time overriding of the
  198.  * built-in size values.  The order must not be changed:
  199.  *      char, short, int, long, float, double (func pointer)
  200.  */
  201. SIZES size_table[] = {
  202.     { T_CHAR,   S_CHAR,         S_PCHAR         },      /* char         */
  203.     { T_SHORT,  S_SINT,         S_PSINT         },      /* short int    */
  204.     { T_INT,    S_INT,          S_PINT          },      /* int          */
  205.     { T_LONG,   S_LINT,         S_PLINT         },      /* long         */
  206.     { T_FLOAT,  S_FLOAT,        S_PFLOAT        },      /* float        */
  207.     { T_DOUBLE, S_DOUBLE,       S_PDOUBLE       },      /* double       */
  208.     { T_FPTR,   0,              S_PFPTR         },      /* int (*())    */
  209.     { 0,        0,              0               },      /* End of table */
  210. };
  211.  
  212.  
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.  
  220. int
  221. eval()
  222. /*
  223.  * Evaluate an expression.  Straight-forward operator precedence.
  224.  * This is called from control() on encountering an #if statement.
  225.  * It calls the following routines:
  226.  * evallex      Lexical analyser -- returns the type and value of
  227.  *              the next input token.
  228.  * evaleval     Evaluate the current operator, given the values on
  229.  *              the value stack.  Returns a pointer to the (new)
  230.  *              value stack.
  231.  * For compatiblity with older cpp's, this return returns 1 (TRUE)
  232.  * if a syntax error is detected.
  233.  */
  234. {
  235.         register int    op;             /* Current operator             */
  236.         register int    *valp;          /* -> value vector              */
  237.         register OPTAB  *opp;           /* Operator stack               */
  238.         int             prec;           /* Op precedence                */
  239.         int             binop;          /* Set if binary op. needed     */
  240.         int             op1;            /* Operand from stack           */
  241.         int             skip;           /* For short-circuit testing    */
  242.         int             value[NEXP];    /* Value stack                  */
  243.         OPTAB