X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fexpressions%2Fparse.c;h=f2b4f1c78b4cc2b4a85f6ea752e74990d19c952b;hb=751d7694b0904b580fad3903205341c85c04d421;hp=40b0a7ab53c1be8b25b515c021f244551e2002e7;hpb=a9acce47d67e0ab35ce1690e4f1b1ac0121c2d78;p=pspp

diff --git a/src/language/expressions/parse.c b/src/language/expressions/parse.c
index 40b0a7ab53..f2b4f1c78b 100644
--- a/src/language/expressions/parse.c
+++ b/src/language/expressions/parse.c
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc.
+   Copyright (C) 1997-9, 2000, 2006, 2010 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -344,7 +344,13 @@ type_coercion_core (struct expression *e,
         {
           /* Convert numeric to boolean. */
           if (do_coercion)
-            *node = expr_allocate_unary (e, OP_NUM_TO_BOOLEAN, *node);
+            {
+              union any_node *op_name;
+
+              op_name = expr_allocate_string (e, ss_cstr (operator_name));
+              *node = expr_allocate_binary (e, OP_NUM_TO_BOOLEAN, *node,
+                                            op_name);
+            }
           return true;
         }
       break;
@@ -577,7 +583,7 @@ parse_binary_operators (struct lexer *lexer, struct expression *e, union any_nod
     }
 
   if (op_count > 1 && chain_warning != NULL)
-    msg (SW, chain_warning);
+    msg (SW, "%s", chain_warning);
 
   return node;
 }
@@ -610,7 +616,7 @@ static union any_node *
 parse_or (struct lexer *lexer, struct expression *e)
 {
   static const struct operator op =
-    { T_OR, OP_OR, "logical disjunction (\"OR\")" };
+    { T_OR, OP_OR, "logical disjunction (`OR')" };
 
   return parse_binary_operators (lexer, e, parse_and (lexer, e), &op, 1, parse_and, NULL);
 }
@@ -620,7 +626,7 @@ static union any_node *
 parse_and (struct lexer *lexer, struct expression *e)
 {
   static const struct operator op =
-    { T_AND, OP_AND, "logical conjunction (\"AND\")" };
+    { T_AND, OP_AND, "logical conjunction (`AND')" };
 
   return parse_binary_operators (lexer, e, parse_not (lexer, e),
 				 &op, 1, parse_not, NULL);
@@ -631,7 +637,7 @@ static union any_node *
 parse_not (struct lexer *lexer, struct expression *e)
 {
   static const struct operator op
-    = { T_NOT, OP_NOT, "logical negation (\"NOT\")" };
+    = { T_NOT, OP_NOT, "logical negation (`NOT')" };
   return parse_inverting_unary_operator (lexer, e, &op, parse_rel);
 }
 
@@ -640,12 +646,12 @@ static union any_node *
 parse_rel (struct lexer *lexer, struct expression *e)
 {
   const char *chain_warning =
-    _("Chaining relational operators (e.g. \"a < b < c\") will "
+    _("Chaining relational operators (e.g. `a < b < c') will "
       "not produce the mathematically expected result.  "
       "Use the AND logical operator to fix the problem "
-      "(e.g. \"a < b AND b < c\").  "
+      "(e.g. `a < b AND b < c').  "
       "If chaining is really intended, parentheses will disable "
-      "this warning (e.g. \"(a < b) < c\".)");
+      "this warning (e.g. `(a < b) < c'.)");
 
   union any_node *node = parse_add (lexer, e);
 
@@ -659,13 +665,13 @@ parse_rel (struct lexer *lexer, struct expression *e)
       {
         static const struct operator ops[] =
           {
-            { '=', 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 (\">\")" },
-            { T_LE, OP_LE, "numeric less-than-or-equal-to (\"<=\")" },
-            { T_LT, OP_LT, "numeric less than (\"<\")" },
-            { T_NE, OP_NE, "numeric inequality (\"<>\")" },
+            { '=', 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 (`>')" },
+            { T_LE, OP_LE, "numeric less-than-or-equal-to (`<=')" },
+            { T_LT, OP_LT, "numeric less than (`<')" },
+            { T_NE, OP_NE, "numeric inequality (`<>')" },
           };
 
         return parse_binary_operators (lexer, e, node, ops,
@@ -677,13 +683,13 @@ parse_rel (struct lexer *lexer, struct expression *e)
       {
         static const struct operator ops[] =
           {
-            { '=', 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 (\">\")" },
-            { T_LE, OP_LE_STRING, "string less-than-or-equal-to (\"<=\")" },
-            { T_LT, OP_LT_STRING, "string less than (\"<\")" },
-            { T_NE, OP_NE_STRING, "string inequality (\"<>\")" },
+            { '=', 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 (`>')" },
+            { T_LE, OP_LE_STRING, "string less-than-or-equal-to (`<=')" },
+            { T_LT, OP_LT_STRING, "string less than (`<')" },
+            { T_NE, OP_NE_STRING, "string inequality (`<>')" },
           };
 
         return parse_binary_operators (lexer, e, node, ops,
@@ -702,8 +708,8 @@ parse_add (struct lexer *lexer, struct expression *e)
 {
   static const struct operator ops[] =
     {
-      { '+', OP_ADD, "addition (\"+\")" },
-      { '-', OP_SUB, "subtraction (\"-\")" },
+      { '+', OP_ADD, "addition (`+')" },
+      { '-', OP_SUB, "subtraction (`-')" },
     };
 
   return parse_binary_operators (lexer, e, parse_mul (lexer, e),
@@ -717,8 +723,8 @@ parse_mul (struct lexer *lexer, struct expression *e)
 {
   static const struct operator ops[] =
     {
-      { '*', OP_MUL, "multiplication (\"*\")" },
-      { '/', OP_DIV, "division (\"/\")" },
+      { '*', OP_MUL, "multiplication (`*')" },
+      { '/', OP_DIV, "division (`/')" },
     };
 
   return parse_binary_operators (lexer, e, parse_neg (lexer, e),
@@ -730,7 +736,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 = { '-', OP_NEG, "negation (`-')" };
   return parse_inverting_unary_operator (lexer, e, &op, parse_exp);
 }
 
@@ -738,12 +744,12 @@ static union any_node *
 parse_exp (struct lexer *lexer, struct expression *e)
 {
   static const struct operator op =
-    { T_EXP, OP_POW, "exponentiation (\"**\")" };
+    { T_EXP, OP_POW, "exponentiation (`**')" };
 
   const char *chain_warning =
-    _("The exponentiation operator (\"**\") is left-associative, "
+    _("The exponentiation operator (`**') is left-associative, "
       "even though right-associative semantics are more useful.  "
-      "That is, \"a**b**c\" equals \"(a**b)**c\", not as \"a**(b**c)\".  "
+      "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,
@@ -801,9 +807,9 @@ parse_sysvar (struct lexer *lexer, struct expression *e)
                                    + tm->tm_sec);
     }
   else if (lex_match_id (lexer, "$LENGTH"))
-    return expr_allocate_number (e, get_viewlength ());
+    return expr_allocate_number (e, settings_get_viewlength ());
   else if (lex_match_id (lexer, "$WIDTH"))
-    return expr_allocate_number (e, get_viewwidth ());
+    return expr_allocate_number (e, settings_get_viewwidth ());
   else
     {
       msg (SE, _("Unknown system variable %s."), lex_tokid (lexer));
@@ -880,16 +886,13 @@ parse_primary (struct lexer *lexer, struct expression *e)
         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, ')'))
+          return NULL;
         return node;
       }
 
     default:
-      lex_error (lexer, _("in expression"));
+      lex_error (lexer, NULL);
       return NULL;
     }
 }
@@ -1079,7 +1082,7 @@ validate_function_args (const struct operation *f, int arg_cnt, int min_valid)
       && array_arg_cnt % f->array_granularity != 0)
     {
       if (f->array_granularity == 2)
-        msg (SE, _("%s must have even number of arguments in list."),
+        msg (SE, _("%s must have an even number of arguments in list."),
              f->prototype);
       else
         msg (SE, _("%s must have multiple of %d arguments in list."),
@@ -1260,7 +1263,7 @@ parse_function (struct lexer *lexer, struct expression *e)
   if (!validate_function_args (f, arg_cnt, min_valid))
     goto fail;
 
-  if ((f->flags & OPF_EXTENSION) && get_syntax () == COMPATIBLE)
+  if ((f->flags & OPF_EXTENSION) && settings_get_syntax () == COMPATIBLE)
     msg (SW, _("%s is a PSPP extension."), f->prototype);
   if (f->flags & OPF_UNIMPLEMENTED)
     {