bbe16cbe17a2c02305f631e8a04cfed5355a805b
[pspp] / lexer.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2013 Free Software Foundation, Inc.
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
16
17 #include <config.h>
18
19 #include "language/lexer/lexer.h"
20
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <limits.h>
24 #include <math.h>
25 #include <stdarg.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <unictype.h>
29 #include <unistd.h>
30 #include <unistr.h>
31 #include <uniwidth.h>
32
33 #include "data/file-name.h"
34 #include "language/command.h"
35 #include "language/lexer/scan.h"
36 #include "language/lexer/segment.h"
37 #include "language/lexer/token.h"
38 #include "libpspp/assertion.h"
39 #include "libpspp/cast.h"
40 #include "libpspp/deque.h"
41 #include "libpspp/i18n.h"
42 #include "libpspp/ll.h"
43 #include "libpspp/message.h"
44 #include "libpspp/misc.h"
45 #include "libpspp/str.h"
46 #include "libpspp/u8-istream.h"
47 #include "output/journal.h"
48 #include "output/text-item.h"
49
50 #include "gl/c-ctype.h"
51 #include "gl/minmax.h"
52 #include "gl/xalloc.h"
53 #include "gl/xmemdup0.h"
54
55 #include "gettext.h"
56 #define _(msgid) gettext (msgid)
57 #define N_(msgid) msgid
58
59 /* A token within a lex_source. */
60 struct lex_token
61   {
62     /* The regular token information. */
63     struct token token;
64
65     /* Location of token in terms of the lex_source's buffer.
66        src->tail <= line_pos <= token_pos <= src->head. */
67     size_t token_pos;           /* Start of token. */
68     size_t token_len;           /* Length of source for token in bytes. */
69     size_t line_pos;            /* Start of line containing token_pos. */
70     int first_line;             /* Line number at token_pos. */
71   };
72
73 /* A source of tokens, corresponding to a syntax file.
74
75    This is conceptually a lex_reader wrapped with everything needed to convert
76    its UTF-8 bytes into tokens. */
77 struct lex_source
78   {
79     struct ll ll;               /* In lexer's list of sources. */
80     struct lex_reader *reader;
81     struct segmenter segmenter;
82     bool eof;                   /* True if T_STOP was read from 'reader'. */
83
84     /* Buffer of UTF-8 bytes. */
85     char *buffer;
86     size_t allocated;           /* Number of bytes allocated. */
87     size_t tail;                /* &buffer[0] offset into UTF-8 source. */
88     size_t head;                /* &buffer[head - tail] offset into source. */
89
90     /* Positions in source file, tail <= pos <= head for each member here. */
91     size_t journal_pos;         /* First byte not yet output to journal. */
92     size_t seg_pos;             /* First byte not yet scanned as token. */
93     size_t line_pos;            /* First byte of line containing seg_pos. */
94
95     int n_newlines;             /* Number of new-lines up to seg_pos. */
96     bool suppress_next_newline;
97
98     /* Tokens. */
99     struct deque deque;         /* Indexes into 'tokens'. */
100     struct lex_token *tokens;   /* Lookahead tokens for parser. */
101   };
102
103 static struct lex_source *lex_source_create (struct lex_reader *);
104 static void lex_source_destroy (struct lex_source *);
105
106 /* Lexer. */
107 struct lexer
108   {
109     struct ll_list sources;     /* Contains "struct lex_source"s. */
110   };
111
112 static struct lex_source *lex_source__ (const struct lexer *);
113 static const struct lex_token *lex_next__ (const struct lexer *, int n);
114 static void lex_source_push_endcmd__ (struct lex_source *);
115
116 static void lex_source_pop__ (struct lex_source *);
117 static bool lex_source_get__ (const struct lex_source *);
118 static void lex_source_error_valist (struct lex_source *, int n0, int n1,
119                                      const char *format, va_list)
120    PRINTF_FORMAT (4, 0);
121 static const struct lex_token *lex_source_next__ (const struct lex_source *,
122                                                   int n);
123 \f
124 /* Initializes READER with the specified CLASS and otherwise some reasonable
125    defaults.  The caller should fill in the others members as desired. */
126 void
127 lex_reader_init (struct lex_reader *reader,
128                  const struct lex_reader_class *class)
129 {
130   reader->class = class;
131   reader->syntax = LEX_SYNTAX_AUTO;
132   reader->error = LEX_ERROR_CONTINUE;
133   reader->file_name = NULL;
134   reader->line_number = 0;
135 }
136
137 /* Frees any file name already in READER and replaces it by a copy of
138    FILE_NAME, or if FILE_NAME is null then clears any existing name. */
139 void
140 lex_reader_set_file_name (struct lex_reader *reader, const char *file_name)
141 {
142   free (reader->file_name);
143   reader->file_name = file_name != NULL ? xstrdup (file_name) : NULL;
144 }
145 \f
146 /* Creates and returns a new lexer. */
147 struct lexer *
148 lex_create (void)
149 {
150   struct lexer *lexer = xzalloc (sizeof *lexer);
151   ll_init (&lexer->sources);
152   return lexer;
153 }
154
155 /* Destroys LEXER. */
156 void
157 lex_destroy (struct lexer *lexer)
158 {
159   if (lexer != NULL)
160     {
161       struct lex_source *source, *next;
162
163       ll_for_each_safe (source, next, struct lex_source, ll, &lexer->sources)
164         lex_source_destroy (source);
165       free (lexer);
166     }
167 }
168
169 /* Inserts READER into LEXER so that the next token read by LEXER comes from
170    READER.  Before the caller, LEXER must either be empty or at a T_ENDCMD
171    token. */
172 void
173 lex_include (struct lexer *lexer, struct lex_reader *reader)
174 {
175   assert (ll_is_empty (&lexer->sources) || lex_token (lexer) == T_ENDCMD);
176   ll_push_head (&lexer->sources, &lex_source_create (reader)->ll);
177 }
178
179 /* Appends READER to LEXER, so that it will be read after all other current
180    readers have already been read. */
181 void
182 lex_append (struct lexer *lexer, struct lex_reader *reader)
183 {
184   ll_push_tail (&lexer->sources, &lex_source_create (reader)->ll);
185 }
186 \f
187 /* Advacning. */
188
189 static struct lex_token *
190 lex_push_token__ (struct lex_source *src)
191 {
192   struct lex_token *token;
193
194   if (deque_is_full (&src->deque))
195     src->tokens = deque_expand (&src->deque, src->tokens, sizeof *src->tokens);
196
197   token = &src->tokens[deque_push_front (&src->deque)];
198   token_init (&token->token);
199   return token;
200 }
201
202 static void
203 lex_source_pop__ (struct lex_source *src)
204 {
205   token_destroy (&src->tokens[deque_pop_back (&src->deque)].token);
206 }
207
208 static void
209 lex_source_pop_front (struct lex_source *src)
210 {
211   token_destroy (&src->tokens[deque_pop_front (&src->deque)].token);
212 }
213
214 /* Advances LEXER to the next token, consuming the current token. */
215 void
216 lex_get (struct lexer *lexer)
217 {
218   struct lex_source *src;
219
220   src = lex_source__ (lexer);
221   if (src == NULL)
222     return;
223
224   if (!deque_is_empty (&src->deque))
225     lex_source_pop__ (src);
226
227   while (deque_is_empty (&src->deque))
228     if (!lex_source_get__ (src))
229       {
230         lex_source_destroy (src);
231         src = lex_source__ (lexer);
232         if (src == NULL)
233           return;
234       }
235 }
236 \f
237 /* Issuing errors. */
238
239 /* Prints a syntax error message containing the current token and
240    given message MESSAGE (if non-null). */
241 void
242 lex_error (struct lexer *lexer, const char *format, ...)
243 {
244   va_list args;
245
246   va_start (args, format);
247   lex_next_error_valist (lexer, 0, 0, format, args);
248   va_end (args);
249 }
250
251 /* Prints a syntax error message containing the current token and
252    given message MESSAGE (if non-null). */
253 void
254 lex_error_valist (struct lexer *lexer, const char *format, va_list args)
255 {
256   lex_next_error_valist (lexer, 0, 0, format, args);
257 }
258
259 /* Prints a syntax error message containing the current token and
260    given message MESSAGE (if non-null). */
261 void
262 lex_next_error (struct lexer *lexer, int n0, int n1, const char *format, ...)
263 {
264   va_list args;
265
266   va_start (args, format);
267   lex_next_error_valist (lexer, n0, n1, format, args);
268   va_end (args);
269 }
270
271 /* Prints a syntax error message saying that OPTION0 or one of the other
272    strings following it, up to the first NULL, is expected. */
273 void
274 lex_error_expecting (struct lexer *lexer, const char *option0, ...)
275 {
276   enum { MAX_OPTIONS = 8 };
277   const char *options[MAX_OPTIONS + 1];
278   va_list args;
279   int n;
280
281   va_start (args, option0);
282   options[0] = option0;
283   n = 0;
284   while (n + 1 < MAX_OPTIONS && options[n] != NULL)
285     options[++n] = va_arg (args, const char *);
286   va_end (args);
287
288   switch (n)
289     {
290     case 0:
291       lex_error (lexer, NULL);
292       break;
293
294     case 1:
295       lex_error (lexer, _("expecting %s"), options[0]);
296       break;
297
298     case 2:
299       lex_error (lexer, _("expecting %s or %s"), options[0], options[1]);
300       break;
301
302     case 3:
303       lex_error (lexer, _("expecting %s, %s, or %s"), options[0], options[1],
304                  options[2]);
305       break;
306
307     case 4:
308       lex_error (lexer, _("expecting %s, %s, %s, or %s"),
309                  options[0], options[1], options[2], options[3]);
310       break;
311
312     case 5:
313       lex_error (lexer, _("expecting %s, %s, %s, %s, or %s"),
314                  options[0], options[1], options[2], options[3], options[4]);
315       break;
316
317     case 6:
318       lex_error (lexer, _("expecting %s, %s, %s, %s, %s, or %s"),
319                  options[0], options[1], options[2], options[3], options[4],
320                  options[5]);
321       break;
322
323     case 7:
324       lex_error (lexer, _("expecting %s, %s, %s, %s, %s, %s, or %s"),
325                  options[0], options[1], options[2], options[3], options[4],
326                  options[5], options[6]);
327       break;
328
329     case 8:
330       lex_error (lexer, _("expecting %s, %s, %s, %s, %s, %s, %s, or %s"),
331                  options[0], options[1], options[2], options[3], options[4],
332                  options[5], options[6], options[7]);
333       break;
334
335     default:
336       NOT_REACHED ();
337     }
338 }
339
340 /* Reports an error to the effect that subcommand SBC may only be specified
341    once.
342
343    This function does not take a lexer as an argument or use lex_error(),
344    because the result would ordinarily just be redundant: "Syntax error at
345    SUBCOMMAND: Subcommand SUBCOMMAND may only be specified once.", which does
346    not help the user find the error. */
347 void
348 lex_sbc_only_once (const char *sbc)
349 {
350   msg (SE, _("Subcommand %s may only be specified once."), sbc);
351 }
352
353 /* Reports an error to the effect that subcommand SBC is missing.
354
355    This function does not take a lexer as an argument or use lex_error(),
356    because a missing subcommand can normally be detected only after the whole
357    command has been parsed, and so lex_error() would always report "Syntax
358    error at end of command", which does not help the user find the error. */
359 void
360 lex_sbc_missing (const char *sbc)
361 {
362   msg (SE, _("Required subcommand %s was not specified."), sbc);
363 }
364
365 /* Reports an error to the effect that specification SPEC may only be specified
366    once within subcommand SBC. */
367 void
368 lex_spec_only_once (struct lexer *lexer, const char *sbc, const char *spec)
369 {
370   lex_error (lexer, _("%s may only be specified once within subcommand %s"),
371              spec, sbc);
372 }
373
374 /* Reports an error to the effect that specification SPEC is missing within
375    subcommand SBC. */
376 void
377 lex_spec_missing (struct lexer *lexer, const char *sbc, const char *spec)
378 {
379   lex_error (lexer, _("Required %s specification missing from %s subcommand"),
380              sbc, spec);
381 }
382
383 /* Prints a syntax error message containing the current token and
384    given message MESSAGE (if non-null). */
385 void
386 lex_next_error_valist (struct lexer *lexer, int n0, int n1,
387                        const char *format, va_list args)
388 {
389   struct lex_source *src = lex_source__ (lexer);
390
391   if (src != NULL)
392     lex_source_error_valist (src, n0, n1, format, args);
393   else
394     {
395       struct string s;
396
397       ds_init_empty (&s);
398       ds_put_format (&s, _("Syntax error at end of input"));
399       if (format != NULL)
400         {
401           ds_put_cstr (&s, ": ");
402           ds_put_vformat (&s, format, args);
403         }
404       ds_put_byte (&s, '.');
405       msg (SE, "%s", ds_cstr (&s));
406       ds_destroy (&s);
407     }
408 }
409
410 /* Checks that we're at end of command.
411    If so, returns a successful command completion code.
412    If not, flags a syntax error and returns an error command
413    completion code. */
414 int
415 lex_end_of_command (struct lexer *lexer)
416 {
417   if (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_STOP)
418     {
419       lex_error (lexer, _("expecting end of command"));
420       return CMD_FAILURE;
421     }
422   else
423     return CMD_SUCCESS;
424 }
425 \f
426 /* Token testing functions. */
427
428 /* Returns true if the current token is a number. */
429 bool
430 lex_is_number (struct lexer *lexer)
431 {
432   return lex_next_is_number (lexer, 0);
433 }
434
435 /* Returns true if the current token is a string. */
436 bool
437 lex_is_string (struct lexer *lexer)
438 {
439   return lex_next_is_string (lexer, 0);
440 }
441
442 /* Returns the value of the current token, which must be a
443    floating point number. */
444 double
445 lex_number (struct lexer *lexer)
446 {
447   return lex_next_number (lexer, 0);
448 }
449
450 /* Returns true iff the current token is an integer. */
451 bool
452 lex_is_integer (struct lexer *lexer)
453 {
454   return lex_next_is_integer (lexer, 0);
455 }
456
457 /* Returns the value of the current token, which must be an
458    integer. */
459 long
460 lex_integer (struct lexer *lexer)
461 {
462   return lex_next_integer (lexer, 0);
463 }
464 \f
465 /* Token testing functions with lookahead.
466
467    A value of 0 for N as an argument to any of these functions refers to the
468    current token.  Lookahead is limited to the current command.  Any N greater
469    than the number of tokens remaining in the current command will be treated
470    as referring to a T_ENDCMD token. */
471
472 /* Returns true if the token N ahead of the current token is a number. */
473 bool
474 lex_next_is_number (struct lexer *lexer, int n)
475 {
476   enum token_type next_token = lex_next_token (lexer, n);
477   return next_token == T_POS_NUM || next_token == T_NEG_NUM;
478 }
479
480 /* Returns true if the token N ahead of the current token is a string. */
481 bool
482 lex_next_is_string (struct lexer *lexer, int n)
483 {
484   return lex_next_token (lexer, n) == T_STRING;
485 }
486
487 /* Returns the value of the token N ahead of the current token, which must be a
488    floating point number. */
489 double
490 lex_next_number (struct lexer *lexer, int n)
491 {
492   assert (lex_next_is_number (lexer, n));
493   return lex_next_tokval (lexer, n);
494 }
495
496 /* Returns true if the token N ahead of the current token is an integer. */
497 bool
498 lex_next_is_integer (struct lexer *lexer, int n)
499 {
500   double value;
501
502   if (!lex_next_is_number (lexer, n))
503     return false;
504
505   value = lex_next_tokval (lexer, n);
506   return value > LONG_MIN && value <= LONG_MAX && floor (value) == value;
507 }
508
509 /* Returns the value of the token N ahead of the current token, which must be
510    an integer. */
511 long
512 lex_next_integer (struct lexer *lexer, int n)
513 {
514   assert (lex_next_is_integer (lexer, n));
515   return lex_next_tokval (lexer, n);
516 }
517 \f
518 /* Token matching functions. */
519
520 /* If the current token has the specified TYPE, skips it and returns true.
521    Otherwise, returns false. */
522 bool
523 lex_match (struct lexer *lexer, enum token_type type)
524 {
525   if (lex_token (lexer) == type)
526     {
527       lex_get (lexer);
528       return true;
529     }
530   else
531     return false;
532 }
533
534 /* If the current token matches IDENTIFIER, skips it and returns true.
535    IDENTIFIER may be abbreviated to its first three letters.  Otherwise,
536    returns false.
537
538    IDENTIFIER must be an ASCII string. */
539 bool
540 lex_match_id (struct lexer *lexer, const char *identifier)
541 {
542   return lex_match_id_n (lexer, identifier, 3);
543 }
544
545 /* If the current token is IDENTIFIER, skips it and returns true.  IDENTIFIER
546    may be abbreviated to its first N letters.  Otherwise, returns false.
547
548    IDENTIFIER must be an ASCII string. */
549 bool
550 lex_match_id_n (struct lexer *lexer, const char *identifier, size_t n)
551 {
552   if (lex_token (lexer) == T_ID
553       && lex_id_match_n (ss_cstr (identifier), lex_tokss (lexer), n))
554     {
555       lex_get (lexer);
556       return true;
557     }
558   else
559     return false;
560 }
561
562 /* If the current token is integer X, skips it and returns true.  Otherwise,
563    returns false. */
564 bool
565 lex_match_int (struct lexer *lexer, int x)
566 {
567   if (lex_is_integer (lexer) && lex_integer (lexer) == x)
568     {
569       lex_get (lexer);
570       return true;
571     }
572   else
573     return false;
574 }
575 \f
576 /* Forced matches. */
577
578 /* If this token is IDENTIFIER, skips it and returns true.  IDENTIFIER may be
579    abbreviated to its first 3 letters.  Otherwise, reports an error and returns
580    false.
581
582    IDENTIFIER must be an ASCII string. */
583 bool
584 lex_force_match_id (struct lexer *lexer, const char *identifier)
585 {
586   if (lex_match_id (lexer, identifier))
587     return true;
588   else
589     {
590       lex_error_expecting (lexer, identifier, NULL_SENTINEL);
591       return false;
592     }
593 }
594
595 /* If the current token has the specified TYPE, skips it and returns true.
596    Otherwise, reports an error and returns false. */
597 bool
598 lex_force_match (struct lexer *lexer, enum token_type type)
599 {
600   if (lex_token (lexer) == type)
601     {
602       lex_get (lexer);
603       return true;
604     }
605   else
606     {
607       char *s = xasprintf ("`%s'", token_type_to_string (type));
608       lex_error_expecting (lexer, s, NULL_SENTINEL);
609       free (s);
610       return false;
611     }
612 }
613
614 /* If the current token is a string, does nothing and returns true.
615    Otherwise, reports an error and returns false. */
616 bool
617 lex_force_string (struct lexer *lexer)
618 {
619   if (lex_is_string (lexer))
620     return true;
621   else
622     {
623       lex_error (lexer, _("expecting string"));
624       return false;
625     }
626 }
627
628 /* If the current token is a string or an identifier, does nothing and returns
629    true.  Otherwise, reports an error and returns false.
630
631    This is meant for use in syntactic situations where we want to encourage the
632    user to supply a quoted string, but for compatibility we also accept
633    identifiers.  (One example of such a situation is file names.)  Therefore,
634    the error message issued when the current token is wrong only says that a
635    string is expected and doesn't mention that an identifier would also be
636    accepted. */
637 bool
638 lex_force_string_or_id (struct lexer *lexer)
639 {
640   return lex_is_integer (lexer) || lex_force_string (lexer);
641 }
642
643 /* If the current token is an integer, does nothing and returns true.
644    Otherwise, reports an error and returns false. */
645 bool
646 lex_force_int (struct lexer *lexer)
647 {
648   if (lex_is_integer (lexer))
649     return true;
650   else
651     {
652       lex_error (lexer, _("expecting integer"));
653       return false;
654     }
655 }
656
657 /* If the current token is a number, does nothing and returns true.
658    Otherwise, reports an error and returns false. */
659 bool
660 lex_force_num (struct lexer *lexer)
661 {
662   if (lex_is_number (lexer))
663     return true;
664
665   lex_error (lexer, _("expecting number"));
666   return false;
667 }
668
669 /* If the current token is an identifier, does nothing and returns true.
670    Otherwise, reports an error and returns false. */
671 bool
672 lex_force_id (struct lexer *lexer)
673 {
674   if (lex_token (lexer) == T_ID)
675     return true;
676
677   lex_error (lexer, _("expecting identifier"));
678   return false;
679 }
680 \f
681 /* Token accessors. */
682
683 /* Returns the type of LEXER's current token. */
684 enum token_type
685 lex_token (const struct lexer *lexer)
686 {
687   return lex_next_token (lexer, 0);
688 }
689
690 /* Returns the number in LEXER's current token.
691
692    Only T_NEG_NUM and T_POS_NUM tokens have meaningful values.  For other
693    tokens this function will always return zero. */
694 double
695 lex_tokval (const struct lexer *lexer)
696 {
697   return lex_next_tokval (lexer, 0);
698 }
699
700 /* Returns the null-terminated string in LEXER's current token, UTF-8 encoded.
701
702    Only T_ID and T_STRING tokens have meaningful strings.  For other tokens
703    this functions this function will always return NULL.
704
705    The UTF-8 encoding of the returned string is correct for variable names and
706    other identifiers.  Use filename_to_utf8() to use it as a filename.  Use
707    data_in() to use it in a "union value".  */
708 const char *
709 lex_tokcstr (const struct lexer *lexer)
710 {
711   return lex_next_tokcstr (lexer, 0);
712 }
713
714 /* Returns the string in LEXER's current token, UTF-8 encoded.  The string is
715    null-terminated (but the null terminator is not included in the returned
716    substring's 'length').
717
718    Only T_ID and T_STRING tokens have meaningful strings.  For other tokens
719    this functions this function will always return NULL.
720
721    The UTF-8 encoding of the returned string is correct for variable names and
722    other identifiers.  Use filename_to_utf8() to use it as a filename.  Use
723    data_in() to use it in a "union value".  */
724 struct substring
725 lex_tokss (const struct lexer *lexer)
726 {
727   return lex_next_tokss (lexer, 0);
728 }
729 \f
730 /* Looking ahead.
731
732    A value of 0 for N as an argument to any of these functions refers to the
733    current token.  Lookahead is limited to the current command.  Any N greater
734    than the number of tokens remaining in the current command will be treated
735    as referring to a T_ENDCMD token. */
736
737 static const struct lex_token *
738 lex_next__ (const struct lexer *lexer_, int n)
739 {
740   struct lexer *lexer = CONST_CAST (struct lexer *, lexer_);
741   struct lex_source *src = lex_source__ (lexer);
742
743   if (src != NULL)
744     return lex_source_next__ (src, n);
745   else
746     {
747       static const struct lex_token stop_token =
748         { TOKEN_INITIALIZER (T_STOP, 0.0, ""), 0, 0, 0, 0 };
749
750       return &stop_token;
751     }
752 }
753
754 static const struct lex_token *
755 lex_source_next__ (const struct lex_source *src, int n)
756 {
757   while (deque_count (&src->deque) <= n)
758     {
759       if (!deque_is_empty (&src->deque))
760         {
761           struct lex_token *front;
762
763           front = &src->tokens[deque_front (&src->deque, 0)];
764           if (front->token.type == T_STOP || front->token.type == T_ENDCMD)
765             return front;
766         }
767
768       lex_source_get__ (src);
769     }
770
771   return &src->tokens[deque_back (&src->deque, n)];
772 }
773
774 /* Returns the "struct token" of the token N after the current one in LEXER.
775    The returned pointer can be invalidated by pretty much any succeeding call
776    into the lexer, although the string pointer within the returned token is
777    only invalidated by consuming the token (e.g. with lex_get()). */
778 const struct token *
779 lex_next (const struct lexer *lexer, int n)
780 {
781   return &lex_next__ (lexer, n)->token;
782 }
783
784 /* Returns the type of the token N after the current one in LEXER. */
785 enum token_type
786 lex_next_token (const struct lexer *lexer, int n)
787 {
788   return lex_next (lexer, n)->type;
789 }
790
791 /* Returns the number in the tokn N after the current one in LEXER.
792
793    Only T_NEG_NUM and T_POS_NUM tokens have meaningful values.  For other
794    tokens this function will always return zero. */
795 double
796 lex_next_tokval (const struct lexer *lexer, int n)
797 {
798   const struct token *token = lex_next (lexer, n);
799   return token->number;
800 }
801
802 /* Returns the null-terminated string in the token N after the current one, in
803    UTF-8 encoding.
804
805    Only T_ID and T_STRING tokens have meaningful strings.  For other tokens
806    this functions this function will always return NULL.
807
808    The UTF-8 encoding of the returned string is correct for variable names and
809    other identifiers.  Use filename_to_utf8() to use it as a filename.  Use
810    data_in() to use it in a "union value".  */
811 const char *
812 lex_next_tokcstr (const struct lexer *lexer, int n)
813 {
814   return lex_next_tokss (lexer, n).string;
815 }
816
817 /* Returns the string in the token N after the current one, in UTF-8 encoding.
818    The string is null-terminated (but the null terminator is not included in
819    the returned substring's 'length').
820
821    Only T_ID and T_STRING tokens have meaningful strings.  For other tokens
822    this functions this function will always return NULL.
823
824    The UTF-8 encoding of the returned string is correct for variable names and
825    other identifiers.  Use filename_to_utf8() to use it as a filename.  Use
826    data_in() to use it in a "union value".  */
827 struct substring
828 lex_next_tokss (const struct lexer *lexer, int n)
829 {
830   return lex_next (lexer, n)->string;
831 }
832
833 static bool
834 lex_tokens_match (const struct token *actual, const struct token *expected)
835 {
836   if (actual->type != expected->type)
837     return false;
838
839   switch (actual->type)
840     {
841     case T_POS_NUM:
842     case T_NEG_NUM:
843       return actual->number == expected->number;
844
845     case T_ID:
846       return lex_id_match (expected->string, actual->string);
847
848     case T_STRING:
849       return (actual->string.length == expected->string.length
850               && !memcmp (actual->string.string, expected->string.string,
851                           actual->string.length));
852
853     default:
854       return true;
855     }
856 }
857
858 /* If LEXER is positioned at the sequence of tokens that may be parsed from S,
859    skips it and returns true.  Otherwise, returns false.
860
861    S may consist of an arbitrary sequence of tokens, e.g. "KRUSKAL-WALLIS",
862    "2SLS", or "END INPUT PROGRAM".  Identifiers may be abbreviated to their
863    first three letters. */
864 bool
865 lex_match_phrase (struct lexer *lexer, const char *s)
866 {
867   struct string_lexer slex;
868   struct token token;
869   int i;
870
871   i = 0;
872   string_lexer_init (&slex, s, SEG_MODE_INTERACTIVE);
873   while (string_lexer_next (&slex, &token))
874     if (token.type != SCAN_SKIP)
875       {
876         bool match = lex_tokens_match (lex_next (lexer, i++), &token);
877         token_destroy (&token);
878         if (!match)
879           return false;
880       }
881
882   while (i-- > 0)
883     lex_get (lexer);
884   return true;
885 }
886
887 static int
888 lex_source_get_first_line_number (const struct lex_source *src, int n)
889 {
890   return lex_source_next__ (src, n)->first_line;
891 }
892
893 static int
894 count_newlines (char *s, size_t length)
895 {
896   int n_newlines = 0;
897   char *newline;
898
899   while ((newline = memchr (s, '\n', length)) != NULL)
900     {
901       n_newlines++;
902       length -= (newline + 1) - s;
903       s = newline + 1;
904     }
905
906   return n_newlines;
907 }
908
909 static int
910 lex_source_get_last_line_number (const struct lex_source *src, int n)
911 {
912   const struct lex_token *token = lex_source_next__ (src, n);
913
914   if (token->first_line == 0)
915     return 0;
916   else
917     {
918       char *token_str = &src->buffer[token->token_pos - src->tail];
919       return token->first_line + count_newlines (token_str, token->token_len) + 1;
920     }
921 }
922
923 static int
924 count_columns (const char *s_, size_t length)
925 {
926   const uint8_t *s = CHAR_CAST (const uint8_t *, s_);
927   int columns;
928   size_t ofs;
929   int mblen;
930
931   columns = 0;
932   for (ofs = 0; ofs < length; ofs += mblen)
933     {
934       ucs4_t uc;
935
936       mblen = u8_mbtouc (&uc, s + ofs, length - ofs);
937       if (uc != '\t')
938         {
939           int width = uc_width (uc, "UTF-8");
940           if (width > 0)
941             columns += width;
942         }
943       else
944         columns = ROUND_UP (columns + 1, 8);
945     }
946
947   return columns + 1;
948 }
949
950 static int
951 lex_source_get_first_column (const struct lex_source *src, int n)
952 {
953   const struct lex_token *token = lex_source_next__ (src, n);
954   return count_columns (&src->buffer[token->line_pos - src->tail],
955                         token->token_pos - token->line_pos);
956 }
957
958 static int
959 lex_source_get_last_column (const struct lex_source *src, int n)
960 {
961   const struct lex_token *token = lex_source_next__ (src, n);
962   char *start, *end, *newline;
963
964   start = &src->buffer[token->line_pos - src->tail];
965   end = &src->buffer[(token->token_pos + token->token_len) - src->tail];
966   newline = memrchr (start, '\n', end - start);
967   if (newline != NULL)
968     start = newline + 1;
969   return count_columns (start, end - start);
970 }
971
972 /* Returns the 1-based line number of the start of the syntax that represents
973    the token N after the current one in LEXER.  Returns 0 for a T_STOP token or
974    if the token is drawn from a source that does not have line numbers. */
975 int
976 lex_get_first_line_number (const struct lexer *lexer, int n)
977 {
978   const struct lex_source *src = lex_source__ (lexer);
979   return src != NULL ? lex_source_get_first_line_number (src, n) : 0;
980 }
981
982 /* Returns the 1-based line number of the end of the syntax that represents the
983    token N after the current one in LEXER, plus 1.  Returns 0 for a T_STOP
984    token or if the token is drawn from a source that does not have line
985    numbers.
986
987    Most of the time, a single token is wholly within a single line of syntax,
988    but there are two exceptions: a T_STRING token can be made up of multiple
989    segments on adjacent lines connected with "+" punctuators, and a T_NEG_NUM
990    token can consist of a "-" on one line followed by the number on the next.
991  */
992 int
993 lex_get_last_line_number (const struct lexer *lexer, int n)
994 {
995   const struct lex_source *src = lex_source__ (lexer);
996   return src != NULL ? lex_source_get_last_line_number (src, n) : 0;
997 }
998
999 /* Returns the 1-based column number of the start of the syntax that represents
1000    the token N after the current one in LEXER.  Returns 0 for a T_STOP
1001    token.
1002
1003    Column numbers are measured according to the width of characters as shown in
1004    a typical fixed-width font, in which CJK characters have width 2 and
1005    combining characters have width 0.  */
1006 int
1007 lex_get_first_column (const struct lexer *lexer, int n)
1008 {
1009   const struct lex_source *src = lex_source__ (lexer);
1010   return src != NULL ? lex_source_get_first_column (src, n) : 0;
1011 }
1012
1013 /* Returns the 1-based column number of the end of the syntax that represents
1014    the token N after the current one in LEXER, plus 1.  Returns 0 for a T_STOP
1015    token.
1016
1017    Column numbers are measured according to the width of characters as shown in
1018    a typical fixed-width font, in which CJK characters have width 2 and
1019    combining characters have width 0.  */
1020 int
1021 lex_get_last_column (const struct lexer *lexer, int n)
1022 {
1023   const struct lex_source *src = lex_source__ (lexer);
1024   return src != NULL ? lex_source_get_last_column (src, n) : 0;
1025 }
1026
1027 /* Returns the name of the syntax file from which the current command is drawn.
1028    Returns NULL for a T_STOP token or if the command's source does not have
1029    line numbers.
1030
1031    There is no version of this function that takes an N argument because
1032    lookahead only works to the end of a command and any given command is always
1033    within a single syntax file. */
1034 const char *
1035 lex_get_file_name (const struct lexer *lexer)
1036 {
1037   struct lex_source *src = lex_source__ (lexer);
1038   return src == NULL ? NULL : src->reader->file_name;
1039 }
1040
1041 /* Returns the syntax mode for the syntax file from which the current drawn is
1042    drawn.  Returns LEX_SYNTAX_AUTO for a T_STOP token or if the command's
1043    source does not have line numbers.
1044
1045    There is no version of this function that takes an N argument because
1046    lookahead only works to the end of a command and any given command is always
1047    within a single syntax file. */
1048 enum lex_syntax_mode
1049 lex_get_syntax_mode (const struct lexer *lexer)
1050 {
1051   struct lex_source *src = lex_source__ (lexer);
1052   return src == NULL ? LEX_SYNTAX_AUTO : src->reader->syntax;
1053 }
1054
1055 /* Returns the error mode for the syntax file from which the current drawn is
1056    drawn.  Returns LEX_ERROR_TERMINAL for a T_STOP token or if the command's
1057    source does not have line numbers.
1058
1059    There is no version of this function that takes an N argument because
1060    lookahead only works to the end of a command and any given command is always
1061    within a single syntax file. */
1062 enum lex_error_mode
1063 lex_get_error_mode (const struct lexer *lexer)
1064 {
1065   struct lex_source *src = lex_source__ (lexer);
1066   return src == NULL ? LEX_ERROR_TERMINAL : src->reader->error;
1067 }
1068
1069 /* If the source that LEXER is currently reading has error mode
1070    LEX_ERROR_TERMINAL, discards all buffered input and tokens, so that the next
1071    token to be read comes directly from whatever is next read from the stream.
1072
1073    It makes sense to call this function after encountering an error in a
1074    command entered on the console, because usually the user would prefer not to
1075    have cascading errors. */
1076 void
1077 lex_interactive_reset (struct lexer *lexer)
1078 {
1079   struct lex_source *src = lex_source__ (lexer);
1080   if (src != NULL && src->reader->error == LEX_ERROR_TERMINAL)
1081     {
1082       src->head = src->tail = 0;
1083       src->journal_pos = src->seg_pos = src->line_pos = 0;
1084       src->n_newlines = 0;
1085       src->suppress_next_newline = false;
1086       segmenter_init (&src->segmenter, segmenter_get_mode (&src->segmenter));
1087       while (!deque_is_empty (&src->deque))
1088         lex_source_pop__ (src);
1089       lex_source_push_endcmd__ (src);
1090     }
1091 }
1092
1093 /* Advances past any tokens in LEXER up to a T_ENDCMD or T_STOP. */
1094 void
1095 lex_discard_rest_of_command (struct lexer *lexer)
1096 {
1097   while (lex_token (lexer) != T_STOP && lex_token (lexer) != T_ENDCMD)
1098     lex_get (lexer);
1099 }
1100
1101 /* Discards all lookahead tokens in LEXER, then discards all input sources
1102    until it encounters one with error mode LEX_ERROR_TERMINAL or until it
1103    runs out of input sources. */
1104 void
1105 lex_discard_noninteractive (struct lexer *lexer)
1106 {
1107   struct lex_source *src = lex_source__ (lexer);
1108
1109   if (src != NULL)
1110     {
1111       while (!deque_is_empty (&src->deque))
1112         lex_source_pop__ (src);
1113
1114       for (; src != NULL && src->reader->error != LEX_ERROR_TERMINAL;
1115            src = lex_source__ (lexer))
1116         lex_source_destroy (src);
1117     }
1118 }
1119 \f
1120 static size_t
1121 lex_source_max_tail__ (const struct lex_source *src)
1122 {
1123   const struct lex_token *token;
1124   size_t max_tail;
1125
1126   assert (src->seg_pos >= src->line_pos);
1127   max_tail = MIN (src->journal_pos, src->line_pos);
1128
1129   /* Use the oldest token also.  (We know that src->deque cannot be empty
1130      because we are in the process of adding a new token, which is already
1131      initialized enough to use here.) */
1132   token = &src->tokens[deque_back (&src->deque, 0)];
1133   assert (token->token_pos >= token->line_pos);
1134   max_tail = MIN (max_tail, token->line_pos);
1135
1136   return max_tail;
1137 }
1138
1139 static void
1140 lex_source_expand__ (struct lex_source *src)
1141 {
1142   if (src->head - src->tail >= src->allocated)
1143     {
1144       size_t max_tail = lex_source_max_tail__ (src);
1145       if (max_tail > src->tail)
1146         {
1147           /* Advance the tail, freeing up room at the head. */
1148           memmove (src->buffer, src->buffer + (max_tail - src->tail),
1149                    src->head - max_tail);
1150           src->tail = max_tail;
1151         }
1152       else
1153         {
1154           /* Buffer is completely full.  Expand it. */
1155           src->buffer = x2realloc (src->buffer, &src->allocated);
1156         }
1157     }
1158   else
1159     {
1160       /* There's space available at the head of the buffer.  Nothing to do. */
1161     }
1162 }
1163
1164 static void
1165 lex_source_read__ (struct lex_source *src)
1166 {
1167   do
1168     {
1169       size_t head_ofs;
1170       size_t space;
1171       size_t n;
1172
1173       lex_source_expand__ (src);
1174
1175       head_ofs = src->head - src->tail;
1176       space = src->allocated - head_ofs;
1177       n = src->reader->class->read (src->reader, &src->buffer[head_ofs],
1178                                     space,
1179                                     segmenter_get_prompt (&src->segmenter));
1180       assert (n <= space);
1181
1182       if (n == 0)
1183         {
1184           /* End of input.
1185
1186              Ensure that the input always ends in a new-line followed by a null
1187              byte, as required by the segmenter library. */
1188
1189           if (src->head == src->tail
1190               || src->buffer[src->head - src->tail - 1] != '\n')
1191             src->buffer[src->head++ - src->tail] = '\n';
1192
1193           lex_source_expand__ (src);
1194           src->buffer[src->head++ - src->tail] = '\0';
1195
1196           return;
1197         }
1198
1199       src->head += n;
1200     }
1201   while (!memchr (&src->buffer[src->seg_pos - src->tail], '\n',
1202                   src->head - src->seg_pos));
1203 }
1204
1205 static struct lex_source *
1206 lex_source__ (const struct lexer *lexer)
1207 {
1208   return (ll_is_empty (&lexer->sources) ? NULL
1209           : ll_data (ll_head (&lexer->sources), struct lex_source, ll));
1210 }
1211
1212 static struct substring
1213 lex_source_get_syntax__ (const struct lex_source *src, int n0, int n1)
1214 {
1215   const struct lex_token *token0 = lex_source_next__ (src, n0);
1216   const struct lex_token *token1 = lex_source_next__ (src, MAX (n0, n1));
1217   size_t start = token0->token_pos;
1218   size_t end = token1->token_pos + token1->token_len;
1219
1220   return ss_buffer (&src->buffer[start - src->tail], end - start);
1221 }
1222
1223 static void
1224 lex_ellipsize__ (struct substring in, char *out, size_t out_size)
1225 {
1226   size_t out_maxlen;
1227   size_t out_len;
1228   int mblen;
1229
1230   assert (out_size >= 16);
1231   out_maxlen = out_size - (in.length >= out_size ? 3 : 0) - 1;
1232   for (out_len = 0; out_len < in.length; out_len += mblen)
1233     {
1234       if (in.string[out_len] == '\n'
1235           || (in.string[out_len] == '\r'
1236               && out_len + 1 < in.length
1237               && in.string[out_len + 1] == '\n'))
1238         break;
1239
1240       mblen = u8_mblen (CHAR_CAST (const uint8_t *, in.string + out_len),
1241                         in.length - out_len);
1242       if (out_len + mblen > out_maxlen)
1243         break;
1244     }
1245
1246   memcpy (out, in.string, out_len);
1247   strcpy (&out[out_len], out_len < in.length ? "..." : "");
1248 }
1249
1250 static void
1251 lex_source_error_valist (struct lex_source *src, int n0, int n1,
1252                          const char *format, va_list args)
1253 {
1254   const struct lex_token *token;
1255   struct string s;
1256   struct msg m;
1257
1258   ds_init_empty (&s);
1259
1260   token = lex_source_next__ (src, n0);
1261   if (token->token.type == T_ENDCMD)
1262     ds_put_cstr (&s, _("Syntax error at end of command"));
1263   else
1264     {
1265       struct substring syntax = lex_source_get_syntax__ (src, n0, n1);
1266       if (!ss_is_empty (syntax))
1267         {
1268           char syntax_cstr[64];
1269
1270           lex_ellipsize__ (syntax, syntax_cstr, sizeof syntax_cstr);
1271           ds_put_format (&s, _("Syntax error at `%s'"), syntax_cstr);
1272         }
1273       else
1274         ds_put_cstr (&s, _("Syntax error"));
1275     }
1276
1277   if (format)
1278     {
1279       ds_put_cstr (&s, ": ");
1280       ds_put_vformat (&s, format, args);
1281     }
1282   ds_put_byte (&s, '.');
1283
1284   m.category = MSG_C_SYNTAX;
1285   m.severity = MSG_S_ERROR;
1286   m.file_name = src->reader->file_name;
1287   m.first_line = lex_source_get_first_line_number (src, n0);
1288   m.last_line = lex_source_get_last_line_number (src, n1);
1289   m.first_column = lex_source_get_first_column (src, n0);
1290   m.last_column = lex_source_get_last_column (src, n1);
1291   m.text = ds_steal_cstr (&s);
1292   msg_emit (&m);
1293 }
1294
1295 static void PRINTF_FORMAT (2, 3)
1296 lex_get_error (struct lex_source *src, const char *format, ...)
1297 {
1298   va_list args;
1299   int n;
1300
1301   va_start (args, format);
1302
1303   n = deque_count (&src->deque) - 1;
1304   lex_source_error_valist (src, n, n, format, args);
1305   lex_source_pop_front (src);
1306
1307   va_end (args);
1308 }
1309
1310 static bool
1311 lex_source_get__ (const struct lex_source *src_)
1312 {
1313   struct lex_source *src = CONST_CAST (struct lex_source *, src_);
1314
1315   struct state
1316     {
1317       struct segmenter segmenter;
1318       enum segment_type last_segment;
1319       int newlines;
1320       size_t line_pos;
1321       size_t seg_pos;
1322     };
1323
1324   struct state state, saved;
1325   enum scan_result result;
1326   struct scanner scanner;
1327   struct lex_token *token;
1328   int n_lines;
1329   int i;
1330
1331   if (src->eof)
1332     return false;
1333
1334   state.segmenter = src->segmenter;
1335   state.newlines = 0;
1336   state.seg_pos = src->seg_pos;
1337   state.line_pos = src->line_pos;
1338   saved = state;
1339
1340   token = lex_push_token__ (src);
1341   scanner_init (&scanner, &token->token);
1342   token->line_pos = src->line_pos;
1343   token->token_pos = src->seg_pos;
1344   if (src->reader->line_number > 0)
1345     token->first_line = src->reader->line_number + src->n_newlines;
1346   else
1347     token->first_line = 0;
1348
1349   for (;;)
1350     {
1351       enum segment_type type;
1352       const char *segment;
1353       size_t seg_maxlen;
1354       int seg_len;
1355
1356       segment = &src->buffer[state.seg_pos - src->tail];
1357       seg_maxlen = src->head - state.seg_pos;
1358       seg_len = segmenter_push (&state.segmenter, segment, seg_maxlen, &type);
1359       if (seg_len < 0)
1360         {
1361           lex_source_read__ (src);
1362           continue;
1363         }
1364
1365       state.last_segment = type;
1366       state.seg_pos += seg_len;
1367       if (type == SEG_NEWLINE)
1368         {
1369           state.newlines++;
1370           state.line_pos = state.seg_pos;
1371         }
1372
1373       result = scanner_push (&scanner, type, ss_buffer (segment, seg_len),
1374                              &token->token);
1375       if (result == SCAN_SAVE)
1376         saved = state;
1377       else if (result == SCAN_BACK)
1378         {
1379           state = saved;
1380           break;
1381         }
1382       else if (result == SCAN_DONE)
1383         break;
1384     }
1385
1386   n_lines = state.newlines;
1387   if (state.last_segment == SEG_END_COMMAND && !src->suppress_next_newline)
1388     {
1389       n_lines++;
1390       src->suppress_next_newline = true;
1391     }
1392   else if (n_lines > 0 && src->suppress_next_newline)
1393     {
1394       n_lines--;
1395       src->suppress_next_newline = false;
1396     }
1397   for (i = 0; i < n_lines; i++)
1398     {
1399       const char *newline;
1400       const char *line;
1401       size_t line_len;
1402       char *syntax;
1403
1404       line = &src->buffer[src->journal_pos - src->tail];
1405       newline = rawmemchr (line, '\n');
1406       line_len = newline - line;
1407       if (line_len > 0 && line[line_len - 1] == '\r')
1408         line_len--;
1409
1410       syntax = malloc (line_len + 2);
1411       memcpy (syntax, line, line_len);
1412       syntax[line_len] = '\n';
1413       syntax[line_len + 1] = '\0';
1414
1415       text_item_submit (text_item_create_nocopy (TEXT_ITEM_SYNTAX, syntax));
1416
1417       src->journal_pos += newline - line + 1;
1418     }
1419
1420   token->token_len = state.seg_pos - src->seg_pos;
1421
1422   src->segmenter = state.segmenter;
1423   src->seg_pos = state.seg_pos;
1424   src->line_pos = state.line_pos;
1425   src->n_newlines += state.newlines;
1426
1427   switch (token->token.type)
1428     {
1429     default:
1430       break;
1431
1432     case T_STOP:
1433       token->token.type = T_ENDCMD;
1434       src->eof = true;
1435       break;
1436
1437     case SCAN_BAD_HEX_LENGTH:
1438       lex_get_error (src, _("String of hex digits has %d characters, which "
1439                             "is not a multiple of 2"),
1440                      (int) token->token.number);
1441       break;
1442
1443     case SCAN_BAD_HEX_DIGIT:
1444     case SCAN_BAD_UNICODE_DIGIT:
1445       lex_get_error (src, _("`%c' is not a valid hex digit"),
1446                      (int) token->token.number);
1447       break;
1448
1449     case SCAN_BAD_UNICODE_LENGTH:
1450       lex_get_error (src, _("Unicode string contains %d bytes, which is "
1451                             "not in the valid range of 1 to 8 bytes"),
1452                      (int) token->token.number);
1453       break;
1454
1455     case SCAN_BAD_UNICODE_CODE_POINT:
1456       lex_get_error (src, _("U+%04X is not a valid Unicode code point"),
1457                      (int) token->token.number);
1458       break;
1459
1460     case SCAN_EXPECTED_QUOTE:
1461       lex_get_error (src, _("Unterminated string constant"));
1462       break;
1463
1464     case SCAN_EXPECTED_EXPONENT:
1465       lex_get_error (src, _("Missing exponent following `%s'"),
1466                      token->token.string.string);
1467       break;
1468
1469     case SCAN_UNEXPECTED_DOT:
1470       lex_get_error (src, _("Unexpected `.' in middle of command"));
1471       break;
1472
1473     case SCAN_UNEXPECTED_CHAR:
1474       {
1475         char c_name[16];
1476         lex_get_error (src, _("Bad character %s in input"),
1477                        uc_name (token->token.number, c_name));
1478       }
1479       break;
1480
1481     case SCAN_SKIP:
1482       lex_source_pop_front (src);
1483       break;
1484     }
1485
1486   return true;
1487 }
1488 \f
1489 static void
1490 lex_source_push_endcmd__ (struct lex_source *src)
1491 {
1492   struct lex_token *token = lex_push_token__ (src);
1493   token->token.type = T_ENDCMD;
1494   token->token_pos = 0;
1495   token->token_len = 0;
1496   token->line_pos = 0;
1497   token->first_line = 0;
1498 }
1499
1500 static struct lex_source *
1501 lex_source_create (struct lex_reader *reader)
1502 {
1503   struct lex_source *src;
1504   enum segmenter_mode mode;
1505
1506   src = xzalloc (sizeof *src);
1507   src->reader = reader;
1508
1509   if (reader->syntax == LEX_SYNTAX_AUTO)
1510     mode = SEG_MODE_AUTO;
1511   else if (reader->syntax == LEX_SYNTAX_INTERACTIVE)
1512     mode = SEG_MODE_INTERACTIVE;
1513   else if (reader->syntax == LEX_SYNTAX_BATCH)
1514     mode = SEG_MODE_BATCH;
1515   else
1516     NOT_REACHED ();
1517   segmenter_init (&src->segmenter, mode);
1518
1519   src->tokens = deque_init (&src->deque, 4, sizeof *src->tokens);
1520
1521   lex_source_push_endcmd__ (src);
1522
1523   return src;
1524 }
1525
1526 static void
1527 lex_source_destroy (struct lex_source *src)
1528 {
1529   char *file_name = src->reader->file_name;
1530   if (src->reader->class->destroy != NULL)
1531     src->reader->class->destroy (src->reader);
1532   free (file_name);
1533   free (src->buffer);
1534   while (!deque_is_empty (&src->deque))
1535     lex_source_pop__ (src);
1536   free (src->tokens);
1537   ll_remove (&src->ll);
1538   free (src);
1539 }
1540 \f
1541 struct lex_file_reader
1542   {
1543     struct lex_reader reader;
1544     struct u8_istream *istream;
1545     char *file_name;
1546   };
1547
1548 static struct lex_reader_class lex_file_reader_class;
1549
1550 /* Creates and returns a new lex_reader that will read from file FILE_NAME (or
1551    from stdin if FILE_NAME is "-").  The file is expected to be encoded with
1552    ENCODING, which should take one of the forms accepted by
1553    u8_istream_for_file().  SYNTAX and ERROR become the syntax mode and error
1554    mode of the new reader, respectively.
1555
1556    Returns a null pointer if FILE_NAME cannot be opened. */
1557 struct lex_reader *
1558 lex_reader_for_file (const char *file_name, const char *encoding,
1559                      enum lex_syntax_mode syntax,
1560                      enum lex_error_mode error)
1561 {
1562   struct lex_file_reader *r;
1563   struct u8_istream *istream;
1564
1565   istream = (!strcmp(file_name, "-")
1566              ? u8_istream_for_fd (encoding, STDIN_FILENO)
1567              : u8_istream_for_file (encoding, file_name, O_RDONLY));
1568   if (istream == NULL)
1569     {
1570       msg (ME, _("Opening `%s': %s."), file_name, strerror (errno));
1571       return NULL;
1572     }
1573
1574   r = xmalloc (sizeof *r);
1575   lex_reader_init (&r->reader, &lex_file_reader_class);
1576   r->reader.syntax = syntax;
1577   r->reader.error = error;
1578   r->reader.file_name = xstrdup (file_name);
1579   r->reader.line_number = 1;
1580   r->istream = istream;
1581   r->file_name = xstrdup (file_name);
1582
1583   return &r->reader;
1584 }
1585
1586 static struct lex_file_reader *
1587 lex_file_reader_cast (struct lex_reader *r)
1588 {
1589   return UP_CAST (r, struct lex_file_reader, reader);
1590 }
1591
1592 static size_t
1593 lex_file_read (struct lex_reader *r_, char *buf, size_t n,
1594                enum prompt_style prompt_style UNUSED)
1595 {
1596   struct lex_file_reader *r = lex_file_reader_cast (r_);
1597   ssize_t n_read = u8_istream_read (r->istream, buf, n);
1598   if (n_read < 0)
1599     {
1600       msg (ME, _("Error reading `%s': %s."), r->file_name, strerror (errno));
1601       return 0;
1602     }
1603   return n_read;
1604 }
1605
1606 static void
1607 lex_file_close (struct lex_reader *r_)
1608 {
1609   struct lex_file_reader *r = lex_file_reader_cast (r_);
1610
1611   if (u8_istream_fileno (r->istream) != STDIN_FILENO)
1612     {
1613       if (u8_istream_close (r->istream) != 0)
1614         msg (ME, _("Error closing `%s': %s."), r->file_name, strerror (errno));
1615     }
1616   else
1617     u8_istream_free (r->istream);
1618
1619   free (r->file_name);
1620   free (r);
1621 }
1622
1623 static struct lex_reader_class lex_file_reader_class =
1624   {
1625     lex_file_read,
1626     lex_file_close
1627   };
1628 \f
1629 struct lex_string_reader
1630   {
1631     struct lex_reader reader;
1632     struct substring s;
1633     size_t offset;
1634   };
1635
1636 static struct lex_reader_class lex_string_reader_class;
1637
1638 /* Creates and returns a new lex_reader for the contents of S, which must be
1639    encoded in UTF-8.  The new reader takes ownership of S and will free it
1640    with ss_dealloc() when it is closed. */
1641 struct lex_reader *
1642 lex_reader_for_substring_nocopy (struct substring s)
1643 {
1644   struct lex_string_reader *r;
1645
1646   r = xmalloc (sizeof *r);
1647   lex_reader_init (&r->reader, &lex_string_reader_class);
1648   r->reader.syntax = LEX_SYNTAX_AUTO;
1649   r->s = s;
1650   r->offset = 0;
1651
1652   return &r->reader;
1653 }
1654
1655 /* Creates and returns a new lex_reader for a copy of null-terminated string S,
1656    which must be encoded in UTF-8.  The caller retains ownership of S. */
1657 struct lex_reader *
1658 lex_reader_for_string (const char *s)
1659 {
1660   struct substring ss;
1661   ss_alloc_substring (&ss, ss_cstr (s));
1662   return lex_reader_for_substring_nocopy (ss);
1663 }
1664
1665 /* Formats FORMAT as a printf()-like format string and creates and returns a
1666    new lex_reader for the formatted result.  */
1667 struct lex_reader *
1668 lex_reader_for_format (const char *format, ...)
1669 {
1670   struct lex_reader *r;
1671   va_list args;
1672
1673   va_start (args, format);
1674   r = lex_reader_for_substring_nocopy (ss_cstr (xvasprintf (format, args)));
1675   va_end (args);
1676
1677   return r;
1678 }
1679
1680 static struct lex_string_reader *
1681 lex_string_reader_cast (struct lex_reader *r)
1682 {
1683   return UP_CAST (r, struct lex_string_reader, reader);
1684 }
1685
1686 static size_t
1687 lex_string_read (struct lex_reader *r_, char *buf, size_t n,
1688                  enum prompt_style prompt_style UNUSED)
1689 {
1690   struct lex_string_reader *r = lex_string_reader_cast (r_);
1691   size_t chunk;
1692
1693   chunk = MIN (n, r->s.length - r->offset);
1694   memcpy (buf, r->s.string + r->offset, chunk);
1695   r->offset += chunk;
1696
1697   return chunk;
1698 }
1699
1700 static void
1701 lex_string_close (struct lex_reader *r_)
1702 {
1703   struct lex_string_reader *r = lex_string_reader_cast (r_);
1704
1705   ss_dealloc (&r->s);
1706   free (r);
1707 }
1708
1709 static struct lex_reader_class lex_string_reader_class =
1710   {
1711     lex_string_read,
1712     lex_string_close
1713   };