X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Flexer%2Flexer.c;h=010875f5c29f654f6cbaea6b4cf98ee81a613e56;hb=af19e87064958dfbde7a6bf0d3d19c7b82068a11;hp=a356b3821de28150b848ff6ca2131f61dfdc9b84;hpb=92e42986429596633f71457a585b3266209822dd;p=pspp

diff --git a/src/language/lexer/lexer.c b/src/language/lexer/lexer.c
index a356b3821d..010875f5c2 100644
--- a/src/language/lexer/lexer.c
+++ b/src/language/lexer/lexer.c
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011 Free Software Foundation, Inc.
+   Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2013 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
@@ -337,20 +337,47 @@ lex_error_expecting (struct lexer *lexer, const char *option0, ...)
     }
 }
 
-/* Reports an error to the effect that subcommand SBC may only be
-   specified once. */
+/* Reports an error to the effect that subcommand SBC may only be specified
+   once.
+
+   This function does not take a lexer as an argument or use lex_error(),
+   because the result would ordinarily just be redundant: "Syntax error at
+   SUBCOMMAND: Subcommand SUBCOMMAND may only be specified once.", which does
+   not help the user find the error. */
 void
 lex_sbc_only_once (const char *sbc)
 {
   msg (SE, _("Subcommand %s may only be specified once."), sbc);
 }
 
-/* Reports an error to the effect that subcommand SBC is
-   missing. */
+/* Reports an error to the effect that subcommand SBC is missing.
+
+   This function does not take a lexer as an argument or use lex_error(),
+   because a missing subcommand can normally be detected only after the whole
+   command has been parsed, and so lex_error() would always report "Syntax
+   error at end of command", which does not help the user find the error. */
 void
-lex_sbc_missing (struct lexer *lexer, const char *sbc)
+lex_sbc_missing (const char *sbc)
 {
-  lex_error (lexer, _("missing required subcommand %s"), sbc);
+  msg (SE, _("Required subcommand %s was not specified."), sbc);
+}
+
+/* Reports an error to the effect that specification SPEC may only be specified
+   once within subcommand SBC. */
+void
+lex_spec_only_once (struct lexer *lexer, const char *sbc, const char *spec)
+{
+  lex_error (lexer, _("%s may only be specified once within subcommand %s"),
+             spec, sbc);
+}
+
+/* Reports an error to the effect that specification SPEC is missing within
+   subcommand SBC. */
+void
+lex_spec_missing (struct lexer *lexer, const char *sbc, const char *spec)
+{
+  lex_error (lexer, _("Required %s specification missing from %s subcommand"),
+             sbc, spec);
 }
 
 /* Prints a syntax error message containing the current token and
@@ -598,6 +625,21 @@ lex_force_string (struct lexer *lexer)
     }
 }
 
+/* If the current token is a string or an identifier, does nothing and returns
+   true.  Otherwise, reports an error and returns false.
+
+   This is meant for use in syntactic situations where we want to encourage the
+   user to supply a quoted string, but for compatibility we also accept
+   identifiers.  (One example of such a situation is file names.)  Therefore,
+   the error message issued when the current token is wrong only says that a
+   string is expected and doesn't mention that an identifier would also be
+   accepted. */
+bool
+lex_force_string_or_id (struct lexer *lexer)
+{
+  return lex_is_integer (lexer) || lex_force_string (lexer);
+}
+
 /* If the current token is an integer, does nothing and returns true.
    Otherwise, reports an error and returns false. */
 bool
@@ -788,99 +830,58 @@ lex_next_tokss (const struct lexer *lexer, int n)
   return lex_next (lexer, n)->string;
 }
 
-/* If LEXER is positioned at the (pseudo)identifier S, skips it and returns
-   true.  Otherwise, returns false.
-
-   S may consist of an arbitrary number of identifiers, integers, and
-   punctuation e.g. "KRUSKAL-WALLIS", "2SLS", or "END INPUT PROGRAM".
-   Identifiers may be abbreviated to their first three letters.  Currently only
-   hyphens, slashes, and equals signs are supported as punctuation (but it
-   would be easy to add more).
-
-   S must be an ASCII string. */
-bool
-lex_match_phrase (struct lexer *lexer, const char *s)
+static bool
+lex_tokens_match (const struct token *actual, const struct token *expected)
 {
-  int tok_idx;
+  if (actual->type != expected->type)
+    return false;
 
-  for (tok_idx = 0; ; tok_idx++)
+  switch (actual->type)
     {
-      enum token_type token;
-      unsigned char c;
-
-      while (c_isspace (*s))
-        s++;
-
-      c = *s;
-      if (c == '\0')
-        {
-          int i;
-
-          for (i = 0; i < tok_idx; i++)
-            lex_get (lexer);
-          return true;
-        }
-
-      token = lex_next_token (lexer, tok_idx);
-      switch (c)
-        {
-        case '-':
-          if (token != T_DASH)
-            return false;
-          s++;
-          break;
+    case T_POS_NUM:
+    case T_NEG_NUM:
+      return actual->number == expected->number;
 
-        case '/':
-          if (token != T_SLASH)
-            return false;
-          s++;
-          break;
-
-        case '=':
-          if (token != T_EQUALS)
-            return false;
-          s++;
-          break;
+    case T_ID:
+      return lex_id_match (expected->string, actual->string);
 
-        case '0': case '1': case '2': case '3': case '4':
-        case '5': case '6': case '7': case '8': case '9':
-          {
-            unsigned int value;
+    case T_STRING:
+      return (actual->string.length == expected->string.length
+              && !memcmp (actual->string.string, expected->string.string,
+                          actual->string.length));
 
-            if (token != T_POS_NUM)
-              return false;
-
-            value = 0;
-            do
-              {
-                value = value * 10 + (*s++ - '0');
-              }
-            while (c_isdigit (*s));
-
-            if (lex_next_tokval (lexer, tok_idx) != value)
-              return false;
-          }
-          break;
+    default:
+      return true;
+    }
+}
 
-        default:
-          if (lex_is_id1 (c))
-            {
-              int len;
+/* If LEXER is positioned at the sequence of tokens that may be parsed from S,
+   skips it and returns true.  Otherwise, returns false.
 
-              if (token != T_ID)
-                return false;
+   S may consist of an arbitrary sequence of tokens, e.g. "KRUSKAL-WALLIS",
+   "2SLS", or "END INPUT PROGRAM".  Identifiers may be abbreviated to their
+   first three letters. */
+bool
+lex_match_phrase (struct lexer *lexer, const char *s)
+{
+  struct string_lexer slex;
+  struct token token;
+  int i;
 
-              len = lex_id_get_length (ss_cstr (s));
-              if (!lex_id_match (ss_buffer (s, len),
-                                 lex_next_tokss (lexer, tok_idx)))
-                return false;
+  i = 0;
+  string_lexer_init (&slex, s, SEG_MODE_INTERACTIVE);
+  while (string_lexer_next (&slex, &token))
+    if (token.type != SCAN_SKIP)
+      {
+        bool match = lex_tokens_match (lex_next (lexer, i++), &token);
+        token_destroy (&token);
+        if (!match)
+          return false;
+      }
 
-              s += len;
-            }
-          else
-            NOT_REACHED ();
-        }
-    }
+  while (i-- > 0)
+    lex_get (lexer);
+  return true;
 }
 
 static int
@@ -1167,14 +1168,18 @@ lex_source_read__ (struct lex_source *src)
   do
     {
       size_t head_ofs;
+      size_t space;
       size_t n;
 
       lex_source_expand__ (src);
 
       head_ofs = src->head - src->tail;
+      space = src->allocated - head_ofs;
       n = src->reader->class->read (src->reader, &src->buffer[head_ofs],
-                                    src->allocated - head_ofs,
+                                    space,
                                     segmenter_get_prompt (&src->segmenter));
+      assert (n <= space);
+
       if (n == 0)
         {
           /* End of input.