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 }