src/freeze.c

   1 /* GNU m4 -- A simple macro processor
   2
   3    Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994, 2006, 2007, 2008
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GNU M4.
   7
   8    GNU M4 is free software: you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation, either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    GNU M4 is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 /* This module handles frozen files.  */
  23
  24 #include "m4.h"
  25
  26 /*-------------------------------------------------------------------.
  27 | Destructively reverse a symbol list and return the reversed list.  |
  28 `-------------------------------------------------------------------*/
  29
  30 static symbol *
  31 reverse_symbol_list (symbol *sym)
  32 {
  33   symbol *result;
  34   symbol *next;
  35
  36   result = NULL;
  37   while (sym)
  38     {
  39       next = SYMBOL_NEXT (sym);
  40       SYMBOL_NEXT (sym) = result;
  41       result = sym;
  42       sym = next;
  43     }
  44   return result;
  45 }
  46
  47 /*------------------------------------------------.
  48 | Produce a frozen state to the given file NAME.  |
  49 `------------------------------------------------*/
  50
  51 void
  52 produce_frozen_state (const char *name)
  53 {
  54   FILE *file;
  55   int h;
  56   symbol *sym;
  57   const builtin *bp;
  58
  59   file = fopen (name, O_BINARY ? "wb" : "w");
  60   if (!file)
  61     {
  62       m4_error (0, errno, NULL, _("cannot open %s"), name);
  63       return;
  64     }
  65
  66   /* Write a recognizable header.  */
  67
  68   xfprintf (file, "# This is a frozen state file generated by %s\n",
  69            PACKAGE_STRING);
  70   xfprintf (file, "V1\n");
  71
  72   /* Dump quote delimiters.  */
  73
  74   if (strcmp (curr_quote.str1, DEF_LQUOTE)
  75       || strcmp (curr_quote.str2, DEF_RQUOTE))
  76     xfprintf (file, "Q%d,%d\n%s%s\n", (int) curr_quote.len1,
  77               (int) curr_quote.len2, curr_quote.str1, curr_quote.str2);
  78
  79   /* Dump comment delimiters.  */
  80
  81   if (strcmp (curr_comm.str1, DEF_BCOMM) || strcmp (curr_comm.str2, DEF_ECOMM))
  82     xfprintf (file, "C%d,%d\n%s%s\n", (int) curr_comm.len1,
  83               (int) curr_comm.len2, curr_comm.str1, curr_comm.str2);
  84
  85   /* Dump all symbols.  */
  86
  87   for (h = 0; h < hash_table_size; h++)
  88     {
  89
  90       /* Process all entries in one bucket, from the last to the first.
  91          This order ensures that, at reload time, pushdef's will be
  92          executed with the oldest definitions first.  */
  93
  94       symtab[h] = reverse_symbol_list (symtab[h]);
  95       for (sym = symtab[h]; sym; sym = SYMBOL_NEXT (sym))
  96         {
  97           switch (SYMBOL_TYPE (sym))
  98             {
  99             case TOKEN_TEXT:
 100               xfprintf (file, "T%d,%d\n",
 101                         (int) strlen (SYMBOL_NAME (sym)),
 102                         (int) strlen (SYMBOL_TEXT (sym)));
 103               fputs (SYMBOL_NAME (sym), file);
 104               fputs (SYMBOL_TEXT (sym), file);
 105               fputc ('\n', file);
 106               break;
 107
 108             case TOKEN_FUNC:
 109               bp = find_builtin_by_addr (SYMBOL_FUNC (sym));
 110               if (bp == NULL)
 111                 {
 112                   assert (!"produce_frozen_state");
 113                   abort ();
 114                 }
 115               xfprintf (file, "F%d,%d\n",
 116                         (int) strlen (SYMBOL_NAME (sym)),
 117                         (int) strlen (bp->name));
 118               fputs (SYMBOL_NAME (sym), file);
 119               fputs (bp->name, file);
 120               fputc ('\n', file);
 121               break;
 122
 123             case TOKEN_VOID:
 124               /* Ignore placeholder tokens that exist due to traceon.  */
 125               break;
 126
 127             default:
 128               assert (!"produce_frozen_state");
 129               abort ();
 130               break;
 131             }
 132         }
 133
 134       /* Reverse the bucket once more, putting it back as it was.  */
 135
 136       symtab[h] = reverse_symbol_list (symtab[h]);
 137     }
 138
 139   /* Let diversions be issued from output.c module, its cleaner to have this
 140      piece of code there.  */
 141
 142   freeze_diversions (file);
 143
 144   /* All done.  */
 145
 146   fputs ("# End of frozen state file\n", file);
 147   if (close_stream (file) != 0)
 148     m4_error (EXIT_FAILURE, errno, NULL, _("unable to create frozen state"));
 149 }
 150
 151 /*----------------------------------------------------------------------.
 152 | Issue a message saying that some character is an EXPECTED character.  |
 153 `----------------------------------------------------------------------*/
 154
 155 static void
 156 issue_expect_message (int expected)
 157 {
 158   if (expected == '\n')
 159     m4_error (EXIT_FAILURE, 0, NULL, _("expecting line feed in frozen file"));
 160   else
 161     m4_error (EXIT_FAILURE, 0, NULL,
 162               _("expecting character `%c' in frozen file"), expected);
 163 }
 164
 165 /*-------------------------------------------------.
 166 | Reload a frozen state from the given file NAME.  |
 167 `-------------------------------------------------*/
 168
 169 /* We are seeking speed, here.  */
 170
 171 void
 172 reload_frozen_state (const char *name)
 173 {
 174   FILE *file;
 175   int character;
 176   int operation;
 177   char *string[2];
 178   int allocated[2];
 179   int number[2];
 180   const builtin *bp;
 181
 182 #define GET_CHARACTER \
 183   (character = getc (file))
 184
 185 #define GET_NUMBER(Number) \
 186   do                                                            \
 187     {                                                           \
 188       (Number) = 0;                                             \
 189       while (isdigit (character))                               \
 190         {                                                       \
 191           (Number) = 10 * (Number) + character - '0';           \
 192           GET_CHARACTER;                                        \
 193         }                                                       \
 194     }                                                           \
 195   while (0)
 196
 197 #define VALIDATE(Expected) \
 198   do                                                            \
 199     {                                                           \
 200       if (character != (Expected))                              \
 201         issue_expect_message ((Expected));                      \
 202     }                                                           \
 203   while (0)
 204
 205   /* Skip comments (`#' at beginning of line) and blank lines, setting
 206      character to the next directive or to EOF.  */
 207
 208 #define GET_DIRECTIVE \
 209   do                                                            \
 210     {                                                           \
 211       GET_CHARACTER;                                            \
 212       if (character == '#')                                     \
 213         {                                                       \
 214           while (character != EOF && character != '\n')         \
 215             GET_CHARACTER;                                      \
 216           VALIDATE ('\n');                                      \
 217         }                                                       \
 218     }                                                           \
 219   while (character == '\n')
 220
 221   file = m4_path_search (name, NULL);
 222   if (file == NULL)
 223     m4_error (EXIT_FAILURE, errno, NULL, _("cannot open %s"), name);
 224
 225   allocated[0] = 100;
 226   string[0] = xcharalloc ((size_t) allocated[0]);
 227   allocated[1] = 100;
 228   string[1] = xcharalloc ((size_t) allocated[1]);
 229
 230   /* Validate format version.  Only `1' is acceptable for now.  */
 231   GET_DIRECTIVE;
 232   VALIDATE ('V');
 233   GET_CHARACTER;
 234   GET_NUMBER (number[0]);
 235   if (number[0] > 1)
 236     m4_error (EXIT_MISMATCH, 0, NULL,
 237               _("frozen file version %d greater than max supported of 1"),
 238               number[0]);
 239   else if (number[0] < 1)
 240     m4_error (EXIT_FAILURE, 0, NULL,
 241               _("ill-formed frozen file, version directive expected"));
 242   VALIDATE ('\n');
 243
 244   GET_DIRECTIVE;
 245   while (character != EOF)
 246     {
 247       switch (character)
 248         {
 249         default:
 250           m4_error (EXIT_FAILURE, 0, NULL, _("ill-formed frozen file"));
 251
 252         case 'C':
 253         case 'D':
 254         case 'F':
 255         case 'T':
 256         case 'Q':
 257           operation = character;
 258           GET_CHARACTER;
 259
 260           /* Get string lengths.  Accept a negative diversion number.  */
 261
 262           if (operation == 'D' && character == '-')
 263             {
 264               GET_CHARACTER;
 265               GET_NUMBER (number[0]);
 266               number[0] = -number[0];
 267             }
 268           else
 269             GET_NUMBER (number[0]);
 270           VALIDATE (',');
 271           GET_CHARACTER;
 272           GET_NUMBER (number[1]);
 273           VALIDATE ('\n');
 274
 275           if (operation != 'D')
 276             {
 277
 278               /* Get first string contents.  */
 279
 280               if (number[0] + 1 > allocated[0])
 281                 {
 282                   free (string[0]);
 283                   allocated[0] = number[0] + 1;
 284                   string[0] = xcharalloc ((size_t) allocated[0]);
 285                 }
 286
 287               if (number[0] > 0)
 288                 if (!fread (string[0], (size_t) number[0], 1, file))
 289                   m4_error (EXIT_FAILURE, 0, NULL,
 290                             _("premature end of frozen file"));
 291
 292               string[0][number[0]] = '\0';
 293             }
 294
 295           /* Get second string contents.  */
 296
 297           if (number[1] + 1 > allocated[1])
 298             {
 299               free (string[1]);
 300               allocated[1] = number[1] + 1;
 301               string[1] = xcharalloc ((size_t) allocated[1]);
 302             }
 303
 304           if (number[1] > 0)
 305             if (!fread (string[1], (size_t) number[1], 1, file))
 306               m4_error (EXIT_FAILURE, 0, NULL,
 307                         _("premature end of frozen file"));
 308
 309           string[1][number[1]] = '\0';
 310           GET_CHARACTER;
 311           VALIDATE ('\n');
 312
 313           /* Act according to operation letter.  */
 314
 315           switch (operation)
 316             {
 317             case 'C':
 318
 319               /* Change comment strings.  */
 320
 321               set_comment (string[0], string[1]);
 322               break;
 323
 324             case 'D':
 325
 326               /* Select a diversion and add a string to it.  */
 327
 328               make_diversion (number[0]);
 329               if (number[1] > 0)
 330                 output_text (string[1], number[1]);
 331               break;
 332
 333             case 'F':
 334
 335               /* Enter a macro having a builtin function as a definition.  */
 336
 337               bp = find_builtin_by_name (string[1]);
 338               define_builtin (string[0], bp, SYMBOL_PUSHDEF);
 339               break;
 340
 341             case 'T':
 342
 343               /* Enter a macro having an expansion text as a definition.  */
 344
 345               define_user_macro (string[0], number[0], string[1],
 346                                  SYMBOL_PUSHDEF);
 347               break;
 348
 349             case 'Q':
 350
 351               /* Change quote strings.  */
 352
 353               set_quotes (string[0], string[1]);
 354               break;
 355
 356             default:
 357
 358               /* Cannot happen.  */
 359
 360               break;
 361             }
 362           break;
 363
 364         }
 365       GET_DIRECTIVE;
 366     }
 367
 368   free (string[0]);
 369   free (string[1]);
 370   errno = 0;
 371   if (ferror (file) || fclose (file) != 0)
 372     m4_error (EXIT_FAILURE, errno, NULL, _("unable to read frozen state"));
 373
 374 #undef GET_CHARACTER
 375 #undef GET_DIRECTIVE
 376 #undef GET_NUMBER
 377 #undef VALIDATE
 378 }