bc8d5196c59a0edfb3db68ddac81cb392b517b85
[pspp-builds.git] / src / language / control / repeat.c
1 /* PSPP - computes sample statistics.
2    Copyright (C) 1997-9, 2000, 2007 Free Software Foundation, Inc.
3
4    This program is free software; you can redistribute it and/or
5    modify it under the terms of the GNU General Public License as
6    published by the Free Software Foundation; either version 2 of the
7    License, or (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful, but
10    WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    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, write to the Free Software
16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17    02110-1301, USA. */
18
19 #include <config.h>
20
21 #include "repeat.h"
22
23 #include <ctype.h>
24 #include <math.h>
25 #include <stdlib.h>
26
27 #include <data/dictionary.h>
28 #include <data/procedure.h>
29 #include <data/settings.h>
30 #include <libpspp/getl.h>
31 #include <language/command.h>
32 #include <language/lexer/lexer.h>
33 #include <language/lexer/variable-parser.h>
34 #include <libpspp/alloc.h>
35 #include <libpspp/ll.h>
36 #include <libpspp/message.h>
37 #include <libpspp/misc.h>
38 #include <libpspp/pool.h>
39 #include <libpspp/str.h>
40 #include <data/variable.h>
41
42 #include "intprops.h"
43
44 #include "gettext.h"
45 #define _(msgid) gettext (msgid)
46
47 /* A line repeated by DO REPEAT. */
48 struct repeat_line
49   {
50     struct ll ll;               /* In struct repeat_block line_list. */
51     const char *file_name;      /* File name. */
52     int line_number;            /* Line number. */
53     struct substring text;      /* Contents. */
54     enum getl_syntax syntax;    /* Syntax mode. */
55   };
56
57 /* The type of substitution made for a DO REPEAT macro. */
58 enum repeat_macro_type
59   {
60     VAR_NAMES,
61     OTHER
62   };
63
64 /* Describes one DO REPEAT macro. */
65 struct repeat_macro
66   {
67     struct ll ll;                       /* In struct repeat_block macros. */
68     enum repeat_macro_type type;        /* Types of replacements. */
69     struct substring name;              /* Macro name. */
70     struct substring *replacements;     /* Macro replacement. */
71   };
72
73 /* A DO REPEAT...END REPEAT block. */
74 struct repeat_block
75   {
76     struct getl_interface parent;
77
78     struct pool *pool;                  /* Pool used for storage. */
79     struct dataset *ds;                 /* The dataset for this block */
80
81     struct ll_list lines;               /* Lines in buffer. */
82     struct ll *cur_line;                /* Last line output. */
83     int loop_cnt;                       /* Number of loops. */
84     int loop_idx;                       /* Number of loops so far. */
85
86     struct ll_list macros;              /* Table of macros. */
87
88     bool print;                         /* Print lines as executed? */
89   };
90
91 static bool parse_specification (struct lexer *, struct repeat_block *);
92 static bool parse_lines (struct lexer *, struct repeat_block *);
93 static void create_vars (struct repeat_block *);
94
95 static struct repeat_macro *find_macro (struct repeat_block *,
96                                         struct substring name);
97
98 static int parse_ids (struct lexer *, const struct dictionary *dict,
99                       struct repeat_macro *, struct pool *);
100
101 static int parse_numbers (struct lexer *, struct repeat_macro *,
102                           struct pool *);
103
104 static int parse_strings (struct lexer *, struct repeat_macro *,
105                           struct pool *);
106
107 static void do_repeat_filter (struct getl_interface *,
108                               struct string *, enum getl_syntax);
109 static bool do_repeat_read (struct getl_interface *,
110                             struct string *, enum getl_syntax *);
111 static void do_repeat_close (struct getl_interface *);
112 static bool always_false (const struct getl_interface *);
113 static const char *do_repeat_name (const struct getl_interface *);
114 static int do_repeat_location (const struct getl_interface *);
115
116 int
117 cmd_do_repeat (struct lexer *lexer, struct dataset *ds)
118 {
119   struct repeat_block *block;
120
121   block = pool_create_container (struct repeat_block, pool);
122   block->ds = ds;
123   ll_init (&block->lines);
124   block->cur_line = ll_null (&block->lines);
125   block->loop_idx = 0;
126   ll_init (&block->macros);
127
128   if (!parse_specification (lexer, block) || !parse_lines (lexer, block))
129     goto error;
130
131   create_vars (block);
132
133   block->parent.read = do_repeat_read;
134   block->parent.close = do_repeat_close;
135   block->parent.filter = do_repeat_filter;
136   block->parent.interactive = always_false;
137   block->parent.name = do_repeat_name;
138   block->parent.location = do_repeat_location;
139
140   if (!ll_is_empty (&block->lines))
141     getl_include_source (lex_get_source_stream (lexer), &block->parent);
142   else
143     pool_destroy (block->pool);
144
145   return CMD_SUCCESS;
146
147  error:
148   pool_destroy (block->pool);
149   return CMD_CASCADING_FAILURE;
150 }
151
152 /* Parses the whole DO REPEAT command specification.
153    Returns success. */
154 static bool
155 parse_specification (struct lexer *lexer, struct repeat_block *block)
156 {
157   struct substring first_name;
158
159   block->loop_cnt = 0;
160   do
161     {
162       struct repeat_macro *macro;
163       struct dictionary *dict = dataset_dict (block->ds);
164       int count;
165
166       /* Get a stand-in variable name and make sure it's unique. */
167       if (!lex_force_id (lexer))
168         return false;
169       if (dict_lookup_var (dict, lex_tokid (lexer)))
170         msg (SW, _("Dummy variable name \"%s\" hides dictionary "
171                    "variable \"%s\"."),
172              lex_tokid (lexer), lex_tokid (lexer));
173       if (find_macro (block, ss_cstr (lex_tokid (lexer))))
174           {
175             msg (SE, _("Dummy variable name \"%s\" is given twice."),
176                  lex_tokid (lexer));
177             return false;
178           }
179
180       /* Make a new macro. */
181       macro = pool_alloc (block->pool, sizeof *macro);
182       ss_alloc_substring_pool (&macro->name, ss_cstr (lex_tokid (lexer)),
183                                block->pool);
184       ll_push_tail (&block->macros, &macro->ll);
185
186       /* Skip equals sign. */
187       lex_get (lexer);
188       if (!lex_force_match (lexer, '='))
189         return false;
190
191       /* Get the details of the variable's possible values. */
192       if (lex_token (lexer) == T_ID)
193         count = parse_ids (lexer, dict, macro, block->pool);
194       else if (lex_is_number (lexer))
195         count = parse_numbers (lexer, macro, block->pool);
196       else if (lex_token (lexer) == T_STRING)
197         count = parse_strings (lexer, macro, block->pool);
198       else
199         {
200           lex_error (lexer, NULL);
201           return false;
202         }
203       if (count == 0)
204         return false;
205       if (lex_token (lexer) != '/' && lex_token (lexer) != '.')
206         {
207           lex_error (lexer, NULL);
208           return false;
209         }
210
211       /* If this is the first variable then it defines how many
212          replacements there must be; otherwise enforce this number of
213          replacements. */
214       if (block->loop_cnt == 0)
215         {
216           block->loop_cnt = count;
217           first_name = macro->name;
218         }
219       else if (block->loop_cnt != count)
220         {
221           msg (SE, _("Dummy variable \"%.*s\" had %d "
222                      "substitutions, so \"%.*s\" must also, but %d "
223                      "were specified."),
224                (int) ss_length (first_name), ss_data (first_name),
225                block->loop_cnt,
226                (int) ss_length (macro->name), ss_data (macro->name),
227                count);
228           return false;
229         }
230
231       lex_match (lexer, '/');
232     }
233   while (lex_token (lexer) != '.');
234
235   return true;
236 }
237
238 /* Finds and returns a DO REPEAT macro with the given NAME, or
239    NULL if there is none */
240 static struct repeat_macro *
241 find_macro (struct repeat_block *block, struct substring name)
242 {
243   struct repeat_macro *macro;
244
245   ll_for_each (macro, struct repeat_macro, ll, &block->macros)
246     if (ss_equals (macro->name, name))
247       return macro;
248
249   return NULL;
250 }
251
252 /* Advances LINE past white space and an identifier, if present.
253    Returns true if KEYWORD matches the identifer, false
254    otherwise. */
255 static bool
256 recognize_keyword (struct substring *line, const char *keyword)
257 {
258   struct substring id;
259   ss_ltrim (line, ss_cstr (CC_SPACES));
260   ss_get_chars (line, lex_id_get_length (*line), &id);
261   return lex_id_match (ss_cstr (keyword), id);
262 }
263
264 /* Returns true if LINE contains a DO REPEAT command, false
265    otherwise. */
266 static bool
267 recognize_do_repeat (struct substring line)
268 {
269   return (recognize_keyword (&line, "do")
270           && recognize_keyword (&line, "repeat"));
271 }
272
273 /* Returns true if LINE contains an END REPEAT command, false
274    otherwise.  Sets *PRINT to true for END REPEAT PRINT, false
275    otherwise. */
276 static bool
277 recognize_end_repeat (struct substring line, bool *print)
278 {
279   if (!recognize_keyword (&line, "end")
280       || !recognize_keyword (&line, "repeat"))
281     return false;
282
283   *print = recognize_keyword (&line, "print");
284   return true;
285 }
286
287 /* Read all the lines we are going to substitute, inside the DO
288    REPEAT...END REPEAT block. */
289 static bool
290 parse_lines (struct lexer *lexer, struct repeat_block *block)
291 {
292   char *previous_file_name;
293   int nesting_level;
294
295   previous_file_name = NULL;
296   nesting_level = 0;
297
298   for (;;)
299     {
300       const char *cur_file_name;
301       struct repeat_line *line;
302       struct string text;
303       enum getl_syntax syntax;
304       bool command_ends_before_line, command_ends_after_line;
305
306       /* Retrieve an input line and make a copy of it. */
307       if (!lex_get_line_raw (lexer, &syntax))
308         return false;
309       ds_init_string (&text, lex_entire_line_ds (lexer));
310
311       /* Record file name. */
312       cur_file_name = getl_source_name (lex_get_source_stream (lexer));
313       if (cur_file_name != NULL &&
314           (previous_file_name == NULL
315            || !strcmp (cur_file_name, previous_file_name)))
316         previous_file_name = pool_strdup (block->pool, cur_file_name);
317
318       /* Create a line structure. */
319       line = pool_alloc (block->pool, sizeof *line);
320       line->file_name = previous_file_name;
321       line->line_number = getl_source_location (lex_get_source_stream (lexer));
322       ss_alloc_substring_pool (&line->text, ds_ss (&text), block->pool);
323       line->syntax = syntax;
324
325       /* Check whether the line contains a DO REPEAT or END
326          REPEAT command. */
327       lex_preprocess_line (&text, syntax,
328                            &command_ends_before_line,
329                            &command_ends_after_line);
330       if (recognize_do_repeat (ds_ss (&text)))
331         {
332           if (get_syntax () == COMPATIBLE)
333             msg (SE, _("DO REPEAT may not nest in compatibility mode."));
334           else
335             nesting_level++;
336         }
337       else if (recognize_end_repeat (ds_ss (&text), &block->print)
338                && nesting_level-- == 0)
339         {
340           lex_discard_line (lexer);
341           ds_destroy (&text);
342           return true;
343         }
344       ds_destroy (&text);
345
346       /* Add the line to the list. */
347       ll_push_tail (&block->lines, &line->ll);
348     }
349 }
350
351 /* Creates variables for the given DO REPEAT. */
352 static void
353 create_vars (struct repeat_block *block)
354 {
355   struct repeat_macro *macro;
356
357   ll_for_each (macro, struct repeat_macro, ll, &block->macros)
358     if (macro->type == VAR_NAMES)
359       {
360         int i;
361
362         for (i = 0; i < block->loop_cnt; i++)
363           {
364             /* Ignore return value: if the variable already
365                exists there is no harm done. */
366             char *var_name = ss_xstrdup (macro->replacements[i]);
367             dict_create_var (dataset_dict (block->ds), var_name, 0);
368             free (var_name);
369           }
370       }
371 }
372
373 /* Parses a set of ids for DO REPEAT. */
374 static int
375 parse_ids (struct lexer *lexer, const struct dictionary *dict,
376            struct repeat_macro *macro, struct pool *pool)
377 {
378   char **replacements;
379   size_t n, i;
380
381   macro->type = VAR_NAMES;
382   if (!parse_mixed_vars_pool (lexer, dict, pool, &replacements, &n, PV_NONE))
383     return 0;
384
385   macro->replacements = pool_nalloc (pool, n, sizeof *macro->replacements);
386   for (i = 0; i < n; i++)
387     macro->replacements[i] = ss_cstr (replacements[i]);
388   return n;
389 }
390
391 /* Adds REPLACEMENT to MACRO's list of replacements, which has
392    *USED elements and has room for *ALLOCATED.  Allocates memory
393    from POOL. */
394 static void
395 add_replacement (struct substring replacement,
396                  struct repeat_macro *macro, struct pool *pool,
397                  size_t *used, size_t *allocated)
398 {
399   if (*used == *allocated)
400     macro->replacements = pool_2nrealloc (pool, macro->replacements, allocated,
401                                           sizeof *macro->replacements);
402   macro->replacements[(*used)++] = replacement;
403 }
404
405 /* Parses a list or range of numbers for DO REPEAT. */
406 static int
407 parse_numbers (struct lexer *lexer, struct repeat_macro *macro,
408                struct pool *pool)
409 {
410   size_t used = 0;
411   size_t allocated = 0;
412
413   macro->type = OTHER;
414   macro->replacements = NULL;
415
416   do
417     {
418       bool integer_value_seen;
419       double a, b, i;
420
421       /* Parse A TO B into a, b. */
422       if (!lex_force_num (lexer))
423         return 0;
424
425       if ( (integer_value_seen = lex_is_integer (lexer) ) )
426         a = lex_integer (lexer);
427       else
428         a = lex_number (lexer);
429
430       lex_get (lexer);
431       if (lex_token (lexer) == T_TO)
432         {
433           if ( !integer_value_seen )
434             {
435               msg (SE, _("Ranges may only have integer bounds"));
436               return 0;
437             }
438           lex_get (lexer);
439           if (!lex_force_int (lexer))
440             return 0;
441           b = lex_integer (lexer);
442           if (b < a)
443             {
444               msg (SE, _("%g TO %g is an invalid range."), a, b);
445               return 0;
446             }
447           lex_get (lexer);
448         }
449       else
450         b = a;
451
452       for (i = a; i <= b; i++)
453         add_replacement (ss_cstr (pool_asprintf (pool, "%g", i)),
454                          macro, pool, &used, &allocated);
455
456       lex_match (lexer, ',');
457     }
458   while (lex_token (lexer) != '/' && lex_token (lexer) != '.');
459
460   return used;
461 }
462
463 /* Parses a list of strings for DO REPEAT. */
464 int
465 parse_strings (struct lexer *lexer, struct repeat_macro *macro, struct pool *pool)
466 {
467   size_t used = 0;
468   size_t allocated = 0;
469
470   macro->type = OTHER;
471   macro->replacements = NULL;
472
473   do
474     {
475       char *string;
476
477       if (lex_token (lexer) != T_STRING)
478         {
479           msg (SE, _("String expected."));
480           return 0;
481         }
482
483       string = lex_token_representation (lexer);
484       pool_register (pool, free, string);
485       add_replacement (ss_cstr (string), macro, pool, &used, &allocated);
486
487       lex_get (lexer);
488       lex_match (lexer, ',');
489     }
490   while (lex_token (lexer) != '/' && lex_token (lexer) != '.');
491
492   return used;
493 }
494 \f
495 int
496 cmd_end_repeat (struct lexer *lexer UNUSED, struct dataset *ds UNUSED)
497 {
498   msg (SE, _("No matching DO REPEAT."));
499   return CMD_CASCADING_FAILURE;
500 }
501 \f
502 /* Finds a DO REPEAT macro with the given NAME and returns the
503    appropriate substitution if found, or NAME otherwise. */
504 static struct substring
505 find_substitution (struct repeat_block *block, struct substring name)
506 {
507   struct repeat_macro *macro = find_macro (block, name);
508   return macro ? macro->replacements[block->loop_idx] : name;
509 }
510
511 /* Makes appropriate DO REPEAT macro substitutions within the
512    repeated lines. */
513 static void
514 do_repeat_filter (struct getl_interface *block_,
515                   struct string *line, enum getl_syntax syntax UNUSED)
516 {
517   struct repeat_block *block = (struct repeat_block *) block_;
518   bool in_apos, in_quote, dot;
519   struct substring input;
520   struct string output;
521   int c;
522
523   ds_init_empty (&output);
524
525   /* Strip trailing whitespace, check for & remove terminal dot. */
526   ds_rtrim (line, ss_cstr (CC_SPACES));
527   dot = ds_chomp (line, get_endcmd ());
528
529   input = ds_ss (line);
530   in_apos = in_quote = false;
531   while ((c = ss_first (input)) != EOF)
532     {
533       if (c == '\'' && !in_quote)
534         in_apos = !in_apos;
535       else if (c == '"' && !in_apos)
536         in_quote = !in_quote;
537
538       if (in_quote || in_apos || !lex_is_id1 (c))
539         {
540           ds_put_char (&output, c);
541           ss_advance (&input, 1);
542         }
543       else
544         {
545           struct substring id;
546           ss_get_chars (&input, lex_id_get_length (input), &id);
547           ds_put_substring (&output, find_substitution (block, id));
548         }
549     }
550   if (dot)
551     ds_put_char (&output, get_endcmd ());
552
553   ds_swap (line, &output);
554   ds_destroy (&output);
555 }
556
557 static struct repeat_line *
558 current_line (const struct getl_interface *interface)
559 {
560   struct repeat_block *block = (struct repeat_block *) interface;
561   return (block->cur_line != ll_null (&block->lines)
562           ? ll_data (block->cur_line, struct repeat_line, ll)
563           : NULL);
564 }
565
566 /* Function called by getl to read a line.  Puts the line in
567    OUTPUT and its syntax mode in *SYNTAX.  Returns true if a line
568    was obtained, false if the source is exhausted. */
569 static bool
570 do_repeat_read  (struct getl_interface *interface,
571                  struct string *output, enum getl_syntax *syntax)
572 {
573   struct repeat_block *block = (struct repeat_block *) interface;
574   struct repeat_line *line;
575
576   block->cur_line = ll_next (block->cur_line);
577   if (block->cur_line == ll_null (&block->lines))
578     {
579       block->loop_idx++;
580       if (block->loop_idx >= block->loop_cnt)
581         return false;
582
583       block->cur_line = ll_head (&block->lines);
584     }
585
586   line = current_line (interface);
587   ds_assign_substring (output, line->text);
588   *syntax = line->syntax;
589   return true;
590 }
591
592 /* Frees a DO REPEAT block.
593    Called by getl to close out the DO REPEAT block. */
594 static void
595 do_repeat_close (struct getl_interface *block_)
596 {
597   struct repeat_block *block = (struct repeat_block *) block_;
598   pool_destroy (block->pool);
599 }
600
601
602 static bool
603 always_false (const struct getl_interface *i UNUSED)
604 {
605   return false;
606 }
607
608 /* Returns the name of the source file from which the previous
609    line was originally obtained, or a null pointer if none. */
610 static const char *
611 do_repeat_name (const struct getl_interface *interface)
612 {
613   struct repeat_line *line = current_line (interface);
614   return line ? line->file_name : NULL;
615 }
616
617 /* Returns the line number in the source file from which the
618    previous line was originally obtained, or -1 if none. */
619 static int
620 do_repeat_location (const struct getl_interface *interface)
621 {
622   struct repeat_line *line = current_line (interface);
623   return line ? line->line_number : -1;
624 }