lexer: Get rid of lex_negative_to_dash().

[pspp] / src / language / expressions / parse.c

diff --git a/src/language/expressions/parse.c b/src/language/expressions/parse.c
index f9461f16bc222fa5f905321c3a22f3b21f27aebc..79576b4482176744d3950ca0ebefd2e61ead8da5 100644 (file)
--- a/src/language/expressions/parse.c
+++ b/src/language/expressions/parse.c
@@ -499,16 +499,14 @@ match_operator (struct lexer *lexer, const struct operator ops[], size_t op_cnt,
   const struct operator *op;
 
   for (op = ops; op < ops + op_cnt; op++)
-    {
-      if (op->token == '-')
-        lex_negative_to_dash (lexer);
-      if (lex_match (lexer, op->token))
-        {
-          if (operator != NULL)
-            *operator = op;
-          return true;
-        }
-    }
+    if (lex_token (lexer) == op->token)
+      {
+        if (op->token != T_NEG_NUM)
+          lex_get (lexer);
+        if (operator != NULL)
+          *operator = op;
+        return true;
+      }
   if (operator != NULL)
     *operator = NULL;
   return false;
@@ -665,7 +663,7 @@ parse_rel (struct lexer *lexer, struct expression *e)
       {
         static const struct operator ops[] =
           {
-            { '=', OP_EQ, "numeric equality (`=')" },
+            { T_EQUALS, OP_EQ, "numeric equality (`=')" },
             { T_EQ, OP_EQ, "numeric equality (`EQ')" },
             { T_GE, OP_GE, "numeric greater-than-or-equal-to (`>=')" },
             { T_GT, OP_GT, "numeric greater than (`>')" },
@@ -683,7 +681,7 @@ parse_rel (struct lexer *lexer, struct expression *e)
       {
         static const struct operator ops[] =
           {
-            { '=', OP_EQ_STRING, "string equality (`=')" },
+            { T_EQUALS, OP_EQ_STRING, "string equality (`=')" },
             { T_EQ, OP_EQ_STRING, "string equality (`EQ')" },
             { T_GE, OP_GE_STRING, "string greater-than-or-equal-to (`>=')" },
             { T_GT, OP_GT_STRING, "string greater than (`>')" },
@@ -708,8 +706,9 @@ parse_add (struct lexer *lexer, struct expression *e)
 {
   static const struct operator ops[] =
     {
-      { '+', OP_ADD, "addition (`+')" },
-      { '-', OP_SUB, "subtraction (`-')" },
+      { T_PLUS, OP_ADD, "addition (`+')" },
+      { T_DASH, OP_SUB, "subtraction (`-')" },
+      { T_NEG_NUM, OP_ADD, "subtraction (`-')" },
     };
 
   return parse_binary_operators (lexer, e, parse_mul (lexer, e),
@@ -723,8 +722,8 @@ parse_mul (struct lexer *lexer, struct expression *e)
 {
   static const struct operator ops[] =
     {
-      { '*', OP_MUL, "multiplication (`*')" },
-      { '/', OP_DIV, "division (`/')" },
+      { T_ASTERISK, OP_MUL, "multiplication (`*')" },
+      { T_SLASH, OP_DIV, "division (`/')" },
     };
 
   return parse_binary_operators (lexer, e, parse_neg (lexer, e),
@@ -736,7 +735,7 @@ parse_mul (struct lexer *lexer, struct expression *e)
 static union any_node *
 parse_neg (struct lexer *lexer, struct expression *e)
 {
-  static const struct operator op = { '-', OP_NEG, "negation (`-')" };
+  static const struct operator op = { T_DASH, OP_NEG, "negation (`-')" };
   return parse_inverting_unary_operator (lexer, e, &op, parse_exp);
 }
 
@@ -752,8 +751,21 @@ parse_exp (struct lexer *lexer, struct expression *e)
       "That is, `a**b**c' equals `(a**b)**c', not as `a**(b**c)'.  "
       "To disable this warning, insert parentheses.");
 
-  return parse_binary_operators (lexer, e, parse_primary (lexer, e), &op, 1,
-                                 parse_primary, chain_warning);
+  union any_node *lhs, *node;
+  bool negative = false;
+
+  if (lex_token (lexer) == T_NEG_NUM)
+    {
+      lhs = expr_allocate_number (e, -lex_tokval (lexer));
+      negative = true;
+      lex_get (lexer);
+    }
+  else
+    lhs = parse_primary (lexer, e);
+
+  node = parse_binary_operators (lexer, e, lhs, &op, 1,
+                                  parse_primary, chain_warning);
+  return negative ? expr_allocate_unary (e, OP_NEG, node) : node;
 }
 
 /* Parses system variables. */
@@ -824,7 +836,7 @@ parse_primary (struct lexer *lexer, struct expression *e)
   switch (lex_token (lexer))
     {
     case T_ID:
-      if (lex_look_ahead (lexer) == '(')
+      if (lex_look_ahead (lexer) == T_LPAREN)
         {
           /* An identifier followed by a left parenthesis may be
              a vector element reference.  If not, it's a function
@@ -881,21 +893,18 @@ parse_primary (struct lexer *lexer, struct expression *e)
        return node;
       }
 
-    case '(':
+    case T_LPAREN:
       {
         union any_node *node;
        lex_get (lexer);
        node = parse_or (lexer, e);
-       if (node != NULL && !lex_match (lexer, ')'))
-         {
-           lex_error (lexer, _("expecting `)'"));
-            return NULL;
-         }
+       if (node != NULL && !lex_force_match (lexer, T_RPAREN))
+          return NULL;
         return node;
       }
 
     default:
-      lex_error (lexer, _("in expression"));
+      lex_error (lexer, NULL);
       return NULL;
     }
 }
@@ -916,12 +925,12 @@ parse_vector_element (struct lexer *lexer, struct expression *e)
   /* Skip left parenthesis token.
      The caller must have verified that the lookahead is a left
      parenthesis. */
-  assert (lex_token (lexer) == '(');
+  assert (lex_token (lexer) == T_LPAREN);
   lex_get (lexer);
 
   element = parse_or (lexer, e);
   if (!type_coercion (e, OP_number, &element, "vector indexing")
-      || !lex_match (lexer, ')'))
+      || !lex_match (lexer, T_RPAREN))
     return NULL;
 
   return expr_allocate_binary (e, (vector_get_type (vector) == VAL_NUMERIC
@@ -1152,7 +1161,7 @@ put_invocation (struct string *s,
         ds_put_cstr (s, ", ");
       ds_put_cstr (s, operations[expr_node_returns (args[i])].prototype);
     }
-  ds_put_char (s, ')');
+  ds_put_byte (s, ')');
 }
 
 static void
@@ -1179,7 +1188,7 @@ no_match (const char *func_name,
       for (f = first; f < last; f++)
         ds_put_format (&s, "\n%s", f->prototype);
     }
-  ds_put_char (&s, '.');
+  ds_put_byte (&s, '.');
 
   msg (SE, "%s", ds_cstr (&s));
 
@@ -1210,7 +1219,7 @@ parse_function (struct lexer *lexer, struct expression *e)
     }
 
   lex_get (lexer);
-  if (!lex_force_match (lexer, '('))
+  if (!lex_force_match (lexer, T_LPAREN))
     {
       ds_destroy (&func_name);
       return NULL;
@@ -1218,11 +1227,11 @@ parse_function (struct lexer *lexer, struct expression *e)
 
   args = NULL;
   arg_cnt = arg_cap = 0;
-  if (lex_token (lexer) != ')')
+  if (lex_token (lexer) != T_RPAREN)
     for (;;)
       {
         if (lex_token (lexer) == T_ID
-            && toupper (lex_look_ahead (lexer)) == 'T')
+            && toupper (lex_look_ahead (lexer)) == T_ID)
           {
             const struct variable **vars;
             size_t var_cnt;
@@ -1243,9 +1252,9 @@ parse_function (struct lexer *lexer, struct expression *e)
 
             add_arg (&args, &arg_cnt, &arg_cap, arg);
           }
-        if (lex_match (lexer, ')'))
+        if (lex_match (lexer, T_RPAREN))
           break;
-        else if (!lex_match (lexer, ','))
+        else if (!lex_match (lexer, T_COMMA))
           {
             lex_error (lexer, _("expecting `,' or `)' invoking %s function"),
                        first->name);