Fix change log.
[pspp-builds.git] / src / language / line-buffer.c
1 /* PSPP - computes sample statistics.
2    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
3    Written by Ben Pfaff <blp@gnu.org>.
4
5    This program is free software; you can redistribute it and/or
6    modify it under the terms of the GNU General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    This program is distributed in the hope that it will be useful, but
11    WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software
17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18    02110-1301, USA. */
19
20 #include <config.h>
21
22 #include <language/line-buffer.h>
23
24 #include <stdio.h>
25 #include <errno.h>
26 #include <stdlib.h>
27
28 #include <data/file-name.h>
29 #include <data/settings.h>
30 #include <data/variable.h>
31 #include <language/command.h>
32 #include <language/lexer/lexer.h>
33 #include <libpspp/alloc.h>
34 #include <libpspp/message.h>
35 #include <libpspp/message.h>
36 #include <libpspp/str.h>
37 #include <libpspp/verbose-msg.h>
38 #include <libpspp/version.h>
39 #include <output/table.h>
40
41 #include "gettext.h"
42 #define _(msgid) gettext (msgid)
43
44 /* Source file. */
45 struct getl_source
46   {
47     struct getl_source *included_from;  /* File that this is nested inside. */
48     struct getl_source *includes;       /* File nested inside this file. */
49     struct getl_source *next;           /* Next file in list. */
50
51     /* Current location. */
52     char *fn;                           /* File name. */
53     int ln;                             /* Line number. */
54
55     enum getl_source_type
56       {
57         SYNTAX_FILE,
58         FILTER,
59         FUNCTION,
60         INTERACTIVE
61       }
62     type;
63
64     union 
65       {
66         /* SYNTAX_FILE. */
67         FILE *syntax_file;
68
69         /* FILTER. */
70         struct 
71           {
72             void (*filter) (struct string *line, void *aux);
73             void (*close) (void *aux);
74             void *aux;
75           }
76         filter;
77
78         /* FUNCTION. */
79         struct 
80           {
81             bool (*read) (struct string *line, char **fn, int *ln, void *aux);
82             void (*close) (void *aux);
83             void *aux;
84           }
85         function;
86
87         /* INTERACTIVE. */
88         bool (*interactive) (struct string *line, const char *prompt);
89       }
90     u;
91
92   };
93
94 /* List of source files. */
95 static struct getl_source *cur_source;
96 static struct getl_source *last_source;
97
98 static struct string getl_include_path;
99
100 struct string getl_buf;
101
102 static void close_source (void);
103
104 static void init_prompts (void);
105 static void uninit_prompts (void);
106 static const char *get_prompt (void);
107
108 /* Initialize getl. */
109 void
110 getl_initialize (void)
111 {
112   ds_create (&getl_include_path,
113              fn_getenv_default ("STAT_INCLUDE_PATH", include_path));
114   ds_init (&getl_buf, 256);
115   init_prompts ();
116 }
117
118 /* Delete everything from the include path. */
119 void
120 getl_clear_include_path (void)
121 {
122   ds_clear (&getl_include_path);
123 }
124
125 /* Add to the include path. */
126 void
127 getl_add_include_dir (const char *path)
128 {
129   if (ds_length (&getl_include_path))
130     ds_putc (&getl_include_path, ':');
131
132   ds_puts (&getl_include_path, path);
133 }
134
135 /* Appends source S to the list of source files. */
136 static void
137 append_source (struct getl_source *s) 
138 {
139   s->included_from = s->includes = s->next = NULL;
140   if (last_source == NULL)
141     cur_source = s;
142   else
143     last_source->next = s;
144   last_source = s;
145 }
146
147 /* Nests source S within the current source file. */
148 static void
149 include_source (struct getl_source *s) 
150 {
151   if (last_source == NULL)
152     append_source (s);
153   else 
154     {
155       s->included_from = cur_source;
156       s->includes = s->next = NULL;
157       s->next = NULL;
158       cur_source->includes = s;
159       cur_source = s;
160     }
161 }
162
163 /* Creates a source of the given TYPE.
164    Type-specific data must be initialized by the caller. */
165 static struct getl_source *
166 create_source (enum getl_source_type type) 
167 {
168   struct getl_source *s = xmalloc (sizeof *s);
169   s->fn = NULL;
170   s->ln = 0;
171   s->type = type;
172   return s;
173 }
174
175 /* Creates a syntax file source with file name FN. */
176 static struct getl_source *
177 create_syntax_file_source (const char *fn) 
178 {
179   struct getl_source *s = create_source (SYNTAX_FILE);
180   s->fn = xstrdup (fn);
181   s->u.syntax_file = NULL;
182   return s;
183 }
184
185 /* Creates a filter source with the given FILTER and CLOSE
186    functions that receive auxiliary data AUX. */
187 static struct getl_source *
188 create_filter_source (void (*filter) (struct string *, void *aux),
189                       void (*close) (void *aux),
190                       void *aux)
191 {
192   struct getl_source *s = create_source (FILTER);
193   s->u.filter.filter = filter;
194   s->u.filter.close = close;
195   s->u.filter.aux = aux;
196   return s;
197 }
198
199 /* Creates a function source with the given READ and CLOSE
200    functions that receive auxiliary data AUX. */
201 static struct getl_source *
202 create_function_source (bool (*read) (struct string *line,
203                                       char **fn, int *ln, void *aux),
204                         void (*close) (void *aux),
205                         void *aux)
206 {
207   struct getl_source *s = create_source (FUNCTION);
208   s->u.function.read = read;
209   s->u.function.close = close;
210   s->u.function.aux = aux;
211   return s;
212 }
213
214 /* Creates an interactive source with the given FUNCTION. */
215 static struct getl_source *
216 create_interactive_source (bool (*function) (struct string *line,
217                                              const char *prompt)) 
218 {
219   struct getl_source *s = xmalloc (sizeof *s);
220   s->fn = NULL;
221   s->ln = 0;
222   s->type = INTERACTIVE;
223   s->u.interactive = function;
224   return s;
225 }
226
227 /* Adds FN to the tail end of the list of source files to
228    execute. */
229 void
230 getl_append_syntax_file (const char *fn)
231 {
232   append_source (create_syntax_file_source (fn));
233 }
234
235 /* Inserts the given file with name FN into the current file
236    after the current line. */
237 void
238 getl_include_syntax_file (const char *fn)
239 {
240   if (cur_source != NULL) 
241     {
242       char *found_fn = fn_search_path (fn, ds_c_str (&getl_include_path),
243                                        fn_dir_name (cur_source->fn));
244       if (found_fn != NULL) 
245         {
246           include_source (create_syntax_file_source (found_fn));
247           free (found_fn); 
248         }
249       else
250         msg (SE, _("Can't find `%s' in include file search path."), fn);
251     }
252   else 
253     getl_append_syntax_file (fn); 
254 }
255
256 /* Inserts the given filter into the current file after the
257    current line.  Each line read while the filter is in place
258    will be passed through FILTER, which may modify it as
259    necessary.  When the filter is closed, CLOSE will be called.
260    AUX will be passed to both functions.
261
262    The filter cannot itself output any new lines, and it will be
263    closed as soon as any line would be read from it.  This means
264    that, for a filter to be useful, another source must be nested
265    inside it with, e.g., getl_include_syntax_file(). */
266 void
267 getl_include_filter (void (*filter) (struct string *, void *aux),
268                      void (*close) (void *aux),
269                      void *aux) 
270 {
271   include_source (create_filter_source (filter, close, aux));
272 }
273
274 /* Inserts the given functional source into the current file
275    after the current line.  Lines are read by calling READ, which
276    should write the next line in LINE, store the file name and
277    line number of the line in *FN and *LN, and return true.  The
278    string stored in *FN will not be freed by getl.  When no lines
279    are left, READ should return false.
280
281    When the source is closed, CLOSE will be called.
282
283    AUX will be passed to both READ and CLOSE. */
284 void
285 getl_include_function (bool (*read) (struct string *line,
286                                      char **fn, int *ln, void *aux),
287                        void (*close) (void *aux),
288                        void *aux) 
289 {
290   include_source (create_function_source (read, close, aux));
291 }
292
293 /* Adds an interactive source to the end of the list of sources.
294    FUNCTION will be called to obtain a line.  It should store the
295    line in LINE.  PROMPT is the prompt to be displayed to the
296    user.  FUNCTION should return true when a line has been
297    obtained or false at end of file. */
298 void
299 getl_append_interactive (bool (*function) (struct string *line,
300                                            const char *prompt)) 
301 {
302   append_source (create_interactive_source (function));
303 }
304
305 /* Closes all sources until an interactive source is
306    encountered. */
307 void
308 getl_abort_noninteractive (void) 
309 {
310   while (cur_source != NULL && cur_source->type != INTERACTIVE)
311     close_source ();
312 }
313
314 /* Returns true if the current source is interactive,
315    false otherwise. */
316 bool
317 getl_is_interactive (void) 
318 {
319   return cur_source != NULL && cur_source->type == INTERACTIVE;
320 }
321
322 /* Closes the current file, whether it be a main file or included
323    file, then moves cur_source to the next file in the chain. */
324 static void
325 close_source (void)
326 {
327   struct getl_source *s;
328
329   s = cur_source;
330   switch (s->type) 
331     {
332     case SYNTAX_FILE:
333       if (s->u.syntax_file && EOF == fn_close (s->fn, s->u.syntax_file))
334         msg (MW, _("Closing `%s': %s."), s->fn, strerror (errno));
335       free (s->fn);
336       break;
337
338     case FILTER:
339       if (s->u.filter.close != NULL)
340         s->u.filter.close (s->u.filter.aux);
341       break;
342
343     case FUNCTION:
344       if (s->u.function.close != NULL)
345         s->u.function.close (s->u.function.aux);
346       break;
347
348     case INTERACTIVE:
349       break;
350     }
351
352   if (s->included_from != NULL)
353     {
354       cur_source = s->included_from;
355       cur_source->includes = NULL;
356     }
357   else
358     {
359       cur_source = s->next;
360       if (cur_source == NULL)
361         last_source = NULL;
362     }
363
364   free (s);
365 }
366
367 /* Puts the current file and line number in *FN and *LN, respectively,
368    or NULL and -1 if none. */
369 void
370 getl_location (const char **fn, int *ln)
371 {
372   if (fn != NULL)
373     *fn = cur_source ? cur_source->fn : "";
374   if (ln != NULL)
375     *ln = cur_source ? cur_source->ln : -1;
376 }
377
378 /* File locator stack. */
379 static const struct msg_locator **file_loc;
380 static int nfile_loc, mfile_loc;
381 \f
382 /* Close getl. */
383 void
384 getl_uninitialize (void)
385 {
386   while (cur_source != NULL)
387     close_source ();
388   ds_destroy (&getl_buf);
389   ds_destroy (&getl_include_path);
390   free(file_loc);
391   file_loc = NULL;
392   nfile_loc = mfile_loc = 0;
393   uninit_prompts ();
394 }
395
396
397 /* File locator stack functions. */
398
399 /* Pushes F onto the stack of file locations. */
400 void
401 msg_push_msg_locator (const struct msg_locator *loc)
402 {
403   if (nfile_loc >= mfile_loc)
404     {
405       if (mfile_loc == 0)
406         mfile_loc = 8;
407       else
408         mfile_loc *= 2;
409
410       file_loc = xnrealloc (file_loc, mfile_loc, sizeof *file_loc);
411     }
412
413   file_loc[nfile_loc++] = loc;
414 }
415
416 /* Pops F off the stack of file locations.
417    Argument F is only used for verification that that is actually the
418    item on top of the stack. */
419 void
420 msg_pop_msg_locator (const struct msg_locator *loc)
421 {
422   assert (nfile_loc >= 0 && file_loc[nfile_loc - 1] == loc);
423   nfile_loc--;
424 }
425
426 /* Puts the current file and line number in F, or NULL and -1 if
427    none. */
428 void
429 msg_location (struct msg_locator *loc)
430 {
431   if (nfile_loc)
432     *loc = *file_loc[nfile_loc - 1];
433   else
434     getl_location (&loc->file_name, &loc->line_number);
435 }
436
437 /* Reads a line from syntax file source S into LINE.
438    Returns true if successful, false at end of file. */
439 static bool
440 read_syntax_file (struct string *line, struct getl_source *s)
441 {
442   /* Open file, if not yet opened. */
443   if (s->u.syntax_file == NULL)
444     {
445       verbose_msg (1, _("opening \"%s\" as syntax file"), s->fn);
446       s->u.syntax_file = fn_open (s->fn, "r");
447
448       if (s->u.syntax_file == NULL)
449         {
450           msg (ME, _("Opening `%s': %s."), s->fn, strerror (errno));
451           return false;
452         }
453     }
454
455   /* Read line from file and remove new-line.
456      Skip initial "#! /usr/bin/pspp" line. */
457   do 
458     {
459       s->ln++;
460       if (!ds_gets (line, s->u.syntax_file))
461         {
462           if (ferror (s->u.syntax_file))
463             msg (ME, _("Reading `%s': %s."), s->fn, strerror (errno));
464           return false;
465         }
466       ds_chomp (line, '\n');
467     }
468   while (s->ln == 1 && !memcmp (ds_c_str (line), "#!", 2));
469
470   /* Echo to listing file, if configured to do so. */
471   if (get_echo ())
472     tab_output_text (TAB_LEFT | TAB_FIX, ds_c_str (line));
473
474   return true;
475 }
476
477 /* Reads a line from source S into LINE.
478    Returns true if successful, false at end of file. */
479 static bool
480 read_line_from_source (struct string *line, struct getl_source *s)
481 {
482   ds_clear (line);
483   switch (s->type) 
484     {
485     case SYNTAX_FILE:
486       return read_syntax_file (line, s);
487     case FILTER:
488       return false;
489     case FUNCTION:
490       return s->u.function.read (line, &s->fn, &s->ln, s->u.function.aux);
491     case INTERACTIVE:
492       return s->u.interactive (line, get_prompt ());
493     }
494
495   abort ();
496 }
497
498 /* Reads a single line into LINE.
499    Returns true when a line has been read, false at end of input.
500    If INTERACTIVE is non-null, then when true is returned
501    *INTERACTIVE will be set to true if the line was obtained
502    interactively, false otherwise. */
503 static bool
504 do_read_line (struct string *line, bool *interactive)
505 {
506   while (cur_source != NULL)
507     {
508       struct getl_source *s = cur_source;
509       if (read_line_from_source (line, s))
510         {
511           if (interactive != NULL)
512             *interactive = s->type == INTERACTIVE;
513
514           while ((s = s->included_from) != NULL)
515             if (s->type == FILTER)
516               s->u.filter.filter (line, s->u.filter.aux);
517
518           return true;
519         }
520       close_source ();
521     }
522
523   return false;
524 }
525
526 /* Reads a single line into getl_buf.
527    Returns true when a line has been read, false at end of input.
528    If INTERACTIVE is non-null, then when true is returned
529    *INTERACTIVE will be set to true if the line was obtained
530    interactively, false otherwise. */
531 bool
532 getl_read_line (bool *interactive)
533 {
534   return do_read_line (&getl_buf, interactive);
535 }
536 \f
537 /* Current prompts in each style. */
538 static char *prompts[GETL_PROMPT_CNT];
539
540 /* Current prompting style. */
541 static enum getl_prompt_style current_style;
542
543 /* Initializes prompts. */
544 static void
545 init_prompts (void) 
546 {
547   prompts[GETL_PROMPT_FIRST] = xstrdup ("PSPP> ");
548   prompts[GETL_PROMPT_LATER] = xstrdup ("    > ");
549   prompts[GETL_PROMPT_DATA] = xstrdup ("data> ");
550   current_style = GETL_PROMPT_FIRST;
551 }
552
553 /* Frees prompts. */
554 static void
555 uninit_prompts (void) 
556 {
557   int i;
558
559   for (i = 0; i < GETL_PROMPT_CNT; i++) 
560     {
561       free (prompts[i]);
562       prompts[i] = NULL;
563     }
564 }
565
566 /* Gets the command prompt for the given STYLE. */
567 const char * 
568 getl_get_prompt (enum getl_prompt_style style)
569 {
570   assert (style < GETL_PROMPT_CNT);
571   return prompts[style];
572 }
573
574 /* Sets the given STYLE's prompt to STRING. */
575 void
576 getl_set_prompt (enum getl_prompt_style style, const char *string)
577 {
578   assert (style < GETL_PROMPT_CNT);
579   free (prompts[style]);
580   prompts[style] = xstrdup (string);
581 }
582
583 /* Sets STYLE as the current prompt style. */
584 void
585 getl_set_prompt_style (enum getl_prompt_style style) 
586 {
587   assert (style < GETL_PROMPT_CNT);
588   current_style = style;
589 }
590
591 /* Returns the current prompt. */
592 static const char *
593 get_prompt (void) 
594 {
595   return prompts[current_style];
596 }