Remove BLP_INT_DIGITS. Now we use the intprops.h header file instead.
[pspp-builds.git] / src / language / control / repeat.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 #include "repeat.h"
22 #include "message.h"
23 #include <ctype.h>
24 #include <math.h>
25 #include <stdlib.h>
26 #include "alloc.h"
27 #include "command.h"
28 #include "dictionary.h"
29 #include "intprops.h"
30 #include "message.h"
31 #include "line-buffer.h"
32 #include "lexer.h"
33 #include "misc.h"
34 #include "pool.h"
35 #include "settings.h"
36 #include "str.h"
37 #include "variable.h"
38
39 #include "gettext.h"
40 #define _(msgid) gettext (msgid)
41
42 #include "debug-print.h"
43
44 /* Defines a list of lines used by DO REPEAT. */
45 struct line_list
46   {
47     struct line_list *next;     /* Next line. */
48     char *file_name;            /* File name. */
49     int line_number;            /* Line number. */
50     char *line;                 /* Contents. */
51   };
52
53 /* The type of substitution made for a DO REPEAT macro. */
54 enum repeat_entry_type 
55   {
56     VAR_NAMES,
57     OTHER
58   };
59
60 /* Describes one DO REPEAT macro. */
61 struct repeat_entry
62   {
63     struct repeat_entry *next;          /* Next entry. */
64     enum repeat_entry_type type;        /* Types of replacements. */
65     char id[LONG_NAME_LEN + 1];         /* Macro identifier. */
66     char **replacement;                 /* Macro replacement. */
67   };
68
69 /* A DO REPEAT...END REPEAT block. */
70 struct repeat_block 
71   {
72     struct pool *pool;                  /* Pool used for storage. */
73     struct line_list *first_line;       /* First line in line buffer. */
74     struct line_list *cur_line;         /* Current line in line buffer. */
75     int loop_cnt;                       /* Number of loops. */
76     int loop_idx;                       /* Number of loops so far. */
77     struct repeat_entry *macros;        /* Pointer to macro table. */
78     bool print;                         /* Print lines as executed? */
79   };
80
81 static bool parse_specification (struct repeat_block *);
82 static bool parse_lines (struct repeat_block *);
83 static void create_vars (struct repeat_block *);
84
85 static int parse_ids (struct repeat_entry *);
86 static int parse_numbers (struct repeat_entry *);
87 static int parse_strings (struct repeat_entry *);
88
89 static void do_repeat_filter (struct string *line, void *block);
90 static bool do_repeat_read (struct string *line, char **file_name,
91                             int *line_number, void *block);
92 static void do_repeat_close (void *block);
93
94 int
95 cmd_do_repeat (void)
96 {
97   struct repeat_block *block;
98
99   block = pool_create_container (struct repeat_block, pool);
100
101   if (!parse_specification (block) || !parse_lines (block))
102     goto error;
103   
104   create_vars (block);
105   
106   block->cur_line = NULL;
107   block->loop_idx = -1;
108   getl_include_filter (do_repeat_filter, do_repeat_close, block);
109   getl_include_function (do_repeat_read, NULL, block);
110
111   return CMD_SUCCESS;
112
113  error:
114   pool_destroy (block->pool);
115   return CMD_CASCADING_FAILURE;
116 }
117
118 /* Parses the whole DO REPEAT command specification.
119    Returns success. */
120 static bool
121 parse_specification (struct repeat_block *block) 
122 {
123   char first_name[LONG_NAME_LEN + 1];
124
125   block->loop_cnt = 0;
126   block->macros = NULL;
127   do
128     {
129       struct repeat_entry *e;
130       struct repeat_entry *iter;
131       int count;
132
133       /* Get a stand-in variable name and make sure it's unique. */
134       if (!lex_force_id ())
135         return false;
136       if (dict_lookup_var (default_dict, tokid))
137         msg (SW, _("Dummy variable name \"%s\" hides dictionary "
138                    "variable \"%s\"."),
139              tokid, tokid);
140       for (iter = block->macros; iter != NULL; iter = iter->next)
141         if (!strcasecmp (iter->id, tokid))
142           {
143             msg (SE, _("Dummy variable name \"%s\" is given twice."), tokid);
144             return false;
145           }
146
147       /* Make a new stand-in variable entry and link it into the
148          list. */
149       e = pool_alloc (block->pool, sizeof *e);
150       e->next = block->macros;
151       strcpy (e->id, tokid);
152       block->macros = e;
153
154       /* Skip equals sign. */
155       lex_get ();
156       if (!lex_force_match ('='))
157         return false;
158
159       /* Get the details of the variable's possible values. */
160       if (token == T_ID)
161         count = parse_ids (e);
162       else if (lex_is_number ())
163         count = parse_numbers (e);
164       else if (token == T_STRING)
165         count = parse_strings (e);
166       else
167         {
168           lex_error (NULL);
169           return false;
170         }
171       if (count == 0)
172         return false;
173
174       /* If this is the first variable then it defines how many
175          replacements there must be; otherwise enforce this number of
176          replacements. */
177       if (block->loop_cnt == 0)
178         {
179           block->loop_cnt = count;
180           strcpy (first_name, e->id);
181         }
182       else if (block->loop_cnt != count)
183         {
184           msg (SE, _("Dummy variable \"%s\" had %d "
185                      "substitutions, so \"%s\" must also, but %d "
186                      "were specified."),
187                first_name, block->loop_cnt, e->id, count);
188           return false;
189         }
190
191       lex_match ('/');
192     }
193   while (token != '.');
194
195   return true;
196 }
197
198 /* If KEYWORD appears beginning at CP, possibly preceded by white
199    space, returns a pointer to the character just after the
200    keyword.  Otherwise, returns a null pointer. */
201 static const char *
202 recognize_keyword (const char *cp, const char *keyword)
203 {
204   const char *end;
205
206   while (isspace ((unsigned char) *cp))
207     cp++;
208
209   end = lex_skip_identifier (cp);
210   if (end != cp
211       && lex_id_match_len (keyword, strlen (keyword), cp, end - cp))
212     return end;
213   else
214     return NULL;
215 }
216
217 /* Returns CP, advanced past a '+' or '-' if present. */
218 static const char *
219 skip_indentor (const char *cp) 
220 {
221   if (*cp == '+' || *cp == '-')
222     cp++;
223   return cp;
224 }
225
226 /* Returns true if LINE contains a DO REPEAT command, false
227    otherwise. */
228 static bool
229 recognize_do_repeat (const char *line) 
230 {
231   const char *cp = recognize_keyword (skip_indentor (line), "do");
232   return cp != NULL && recognize_keyword (cp, "repeat") != NULL;
233 }
234
235 /* Returns true if LINE contains an END REPEAT command, false
236    otherwise.  Sets *PRINT to true for END REPEAT PRINT, false
237    otherwise. */
238 static bool
239 recognize_end_repeat (const char *line, bool *print)
240 {
241   const char *cp = recognize_keyword (skip_indentor (line), "end");
242   if (cp == NULL)
243     return false;
244
245   cp = recognize_keyword (cp, "repeat");
246   if (cp == NULL) 
247     return false; 
248
249   *print = recognize_keyword (cp, "print");
250   return true; 
251 }
252
253 /* Read all the lines we are going to substitute, inside the DO
254    REPEAT...END REPEAT block. */
255 static bool
256 parse_lines (struct repeat_block *block) 
257 {
258   char *previous_file_name;
259   struct line_list **last_line;
260   int nesting_level;
261
262   previous_file_name = NULL;
263   block->first_line = NULL;
264   last_line = &block->first_line;
265   nesting_level = 0;
266
267   for (;;)
268     {
269       const char *cur_file_name;
270       int cur_line_number;
271       struct line_list *line;
272       bool dot;
273
274       if (!getl_read_line (NULL))
275         return false;
276
277       /* If the current file has changed then record the fact. */
278       getl_location (&cur_file_name, &cur_line_number);
279       if (previous_file_name == NULL 
280           || !strcmp (cur_file_name, previous_file_name))
281         previous_file_name = pool_strdup (block->pool, cur_file_name);
282
283       ds_rtrim_spaces (&getl_buf);
284       dot = ds_chomp (&getl_buf, get_endcmd ());
285       if (recognize_do_repeat (ds_c_str (&getl_buf))) 
286         nesting_level++; 
287       else if (recognize_end_repeat (ds_c_str (&getl_buf), &block->print)) 
288         {
289         if (nesting_level-- == 0)
290           {
291             lex_discard_line ();
292             return true;
293           } 
294         }
295       if (dot)
296         ds_putc (&getl_buf, get_endcmd ());
297       
298       line = *last_line = pool_alloc (block->pool, sizeof *line);
299       line->next = NULL;
300       line->file_name = previous_file_name;
301       line->line_number = cur_line_number;
302       line->line = pool_strdup (block->pool, ds_c_str (&getl_buf));
303       last_line = &line->next;
304     }
305
306   lex_discard_line ();
307   return true;
308 }
309
310 /* Creates variables for the given DO REPEAT. */
311 static void
312 create_vars (struct repeat_block *block)
313 {
314   struct repeat_entry *iter;
315  
316   for (iter = block->macros; iter; iter = iter->next)
317     if (iter->type == VAR_NAMES)
318       {
319         int i;
320
321         for (i = 0; i < block->loop_cnt; i++)
322           {
323             /* Ignore return value: if the variable already
324                exists there is no harm done. */
325             dict_create_var (default_dict, iter->replacement[i], 0);
326           }
327       }
328 }
329
330 /* Parses a set of ids for DO REPEAT. */
331 static int
332 parse_ids (struct repeat_entry *e)
333 {
334   size_t i;
335   size_t n = 0;
336
337   e->type = VAR_NAMES;
338   e->replacement = NULL;
339
340   do
341     {
342       char **names;
343       size_t nnames;
344
345       if (!parse_mixed_vars (&names, &nnames, PV_NONE))
346         return 0;
347
348       e->replacement = xnrealloc (e->replacement,
349                                   nnames + n, sizeof *e->replacement);
350       for (i = 0; i < nnames; i++)
351         {
352           e->replacement[n + i] = xstrdup (names[i]);
353           free (names[i]);
354         }
355       free (names);
356       n += nnames;
357     }
358   while (token != '/' && token != '.');
359
360   return n;
361 }
362
363 /* Stores VALUE into *REPL. */
364 static inline void
365 store_numeric (char **repl, long value)
366 {
367   *repl = xmalloc (INT_STRLEN_BOUND (value) + 1);
368   sprintf (*repl, "%ld", value);
369 }
370
371 /* Parses a list of numbers for DO REPEAT. */
372 static int
373 parse_numbers (struct repeat_entry *e)
374 {
375   /* First and last numbers for TO, plus the step factor. */
376   long a, b;
377
378   /* Alias to e->replacement. */
379   char **array;
380
381   /* Number of entries in array; maximum number for this allocation
382      size. */
383   int n, m;
384
385   n = m = 0;
386   e->type = OTHER;
387   e->replacement = array = NULL;
388
389   do
390     {
391       /* Parse A TO B into a, b. */
392       if (!lex_force_int ())
393         return 0;
394       a = lex_integer ();
395
396       lex_get ();
397       if (token == T_TO)
398         {
399           lex_get ();
400           if (!lex_force_int ())
401             return 0;
402           b = lex_integer ();
403
404           lex_get ();
405         }
406       else b = a;
407
408       if (n + (abs (b - a) + 1) > m)
409         {
410           m = n + (abs (b - a) + 1) + 16;
411           e->replacement = array = xnrealloc (array,
412                                               m, sizeof *e->replacement);
413         }
414
415       if (a == b)
416         store_numeric (&array[n++], a);
417       else
418         {
419           long iter;
420
421           if (a < b)
422             for (iter = a; iter <= b; iter++)
423               store_numeric (&array[n++], iter);
424           else
425             for (iter = a; iter >= b; iter--)
426               store_numeric (&array[n++], iter);
427         }
428
429       lex_match (',');
430     }
431   while (token != '/' && token != '.');
432   e->replacement = xrealloc (array, n * sizeof *e->replacement);
433
434   return n;
435 }
436
437 /* Parses a list of strings for DO REPEAT. */
438 int
439 parse_strings (struct repeat_entry *e)
440 {
441   char **string;
442   int n, m;
443
444   e->type = OTHER;
445   string = e->replacement = NULL;
446   n = m = 0;
447
448   do
449     {
450       if (token != T_STRING)
451         {
452           int i;
453           msg (SE, _("String expected."));
454           for (i = 0; i < n; i++)
455             free (string[i]);
456           free (string);
457           return 0;
458         }
459
460       if (n + 1 > m)
461         {
462           m += 16;
463           e->replacement = string = xnrealloc (string,
464                                                m, sizeof *e->replacement);
465         }
466       string[n++] = lex_token_representation ();
467       lex_get ();
468
469       lex_match (',');
470     }
471   while (token != '/' && token != '.');
472   e->replacement = xnrealloc (string, n, sizeof *e->replacement);
473
474   return n;
475 }
476 \f
477 int
478 cmd_end_repeat (void)
479 {
480   msg (SE, _("No matching DO REPEAT."));
481   return CMD_CASCADING_FAILURE;
482 }
483 \f
484 /* Finds a DO REPEAT macro with name MACRO_NAME and returns the
485    appropriate subsitution if found, or NULL if not. */
486 static char *
487 find_substitution (struct repeat_block *block, const char *name, size_t length)
488 {
489   struct repeat_entry *e;
490
491   for (e = block->macros; e; e = e->next)
492     if (!memcasecmp (e->id, name, length) && strlen (e->id) == length)
493       return e->replacement[block->loop_idx];
494   
495   return NULL;
496 }
497
498 /* Makes appropriate DO REPEAT macro substitutions within getl_buf. */
499 static void
500 do_repeat_filter (struct string *line, void *block_)
501 {
502   struct repeat_block *block = block_;
503   bool in_apos, in_quote;
504   char *cp;
505   struct string output;
506   bool dot;
507
508   ds_init (&output, ds_capacity (line));
509
510   /* Strip trailing whitespace, check for & remove terminal dot. */
511   while (isspace (ds_last (line)))
512     ds_truncate (line, ds_length (line) - 1);
513   dot = ds_chomp (line, get_endcmd ());
514
515   in_apos = in_quote = false;
516   for (cp = ds_c_str (line); cp < ds_end (line); )
517     {
518       if (*cp == '\'' && !in_quote)
519         in_apos = !in_apos;
520       else if (*cp == '"' && !in_apos)
521         in_quote = !in_quote;
522       
523       if (in_quote || in_apos || !lex_is_id1 (*cp))
524         ds_putc (&output, *cp++);
525       else 
526         {
527           const char *start = cp;
528           char *end = lex_skip_identifier (start);
529           const char *substitution = find_substitution (block,
530                                                         start, end - start);
531           if (substitution != NULL) 
532             ds_puts (&output, substitution);
533           else
534             ds_concat (&output, start, end - start);
535           cp = end;
536         }
537     }
538   if (dot)
539     ds_putc (&output, get_endcmd ());
540
541   ds_swap (line, &output);
542   ds_destroy (&output);
543 }
544
545 /* Function called by getl to read a line.
546    Puts the line in OUTPUT, sets the file name in *FILE_NAME and
547    line number in *LINE_NUMBER.  Returns true if a line was
548    obtained, false if the source is exhausted. */
549 static bool
550 do_repeat_read (struct string *output, char **file_name, int *line_number,
551                 void *block_) 
552 {
553   struct repeat_block *block = block_;
554   struct line_list *line;
555
556   if (block->cur_line == NULL) 
557     {
558       block->loop_idx++;
559       if (block->loop_idx >= block->loop_cnt)
560         return false;
561       block->cur_line = block->first_line;
562     }
563   line = block->cur_line;
564
565   ds_replace (output, line->line);
566   *file_name = line->file_name;
567   *line_number = -line->line_number;
568   block->cur_line = line->next;
569   return true;
570 }
571
572 /* Frees a DO REPEAT block.
573    Called by getl to close out the DO REPEAT block. */
574 static void
575 do_repeat_close (void *block_)
576 {
577   struct repeat_block *block = block_;
578   pool_destroy (block->pool);
579 }