filter.c

   1 /* filter - postprocessing of flex output through filters */
   2
   3 /*  This file is part of flex. */
   4
   5 /*  Redistribution and use in source and binary forms, with or without */
   6 /*  modification, are permitted provided that the following conditions */
   7 /*  are met: */
   8
   9 /*  1. Redistributions of source code must retain the above copyright */
  10 /*     notice, this list of conditions and the following disclaimer. */
  11 /*  2. Redistributions in binary form must reproduce the above copyright */
  12 /*     notice, this list of conditions and the following disclaimer in the */
  13 /*     documentation and/or other materials provided with the distribution. */
  14
  15 /*  Neither the name of the University nor the names of its contributors */
  16 /*  may be used to endorse or promote products derived from this software */
  17 /*  without specific prior written permission. */
  18
  19 /*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
  20 /*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
  21 /*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
  22 /*  PURPOSE. */
  23
  24 #include "flexdef.h"
  25 static const char * check_4_gnu_m4 =
  26     "m4_dnl ifdef(`__gnu__', ,"
  27     "`errprint(Flex requires GNU M4. Set the PATH or set the M4 environment variable to its path name.)"
  28     " m4exit(2)')\n";
  29
  30
  31 /** global chain. */
  32 struct filter *output_chain = NULL;
  33
  34 /* Allocate and initialize an external filter.
  35  * @param chain the current chain or NULL for new chain
  36  * @param cmd the command to execute.
  37  * @param ... a NULL terminated list of (const char*) arguments to command,
  38  *            not including argv[0].
  39  * @return newest filter in chain
  40  */
  41 struct filter *filter_create_ext (struct filter *chain, const char *cmd,
  42                                   ...)
  43 {
  44         struct filter *f;
  45         int     max_args;
  46         const char *s;
  47         va_list ap;
  48
  49         /* allocate and initialize new filter */
  50         f = (struct filter *) flex_alloc (sizeof (struct filter));
  51         if (!f)
  52                 flexerror (_("flex_alloc failed (f) in filter_create_ext"));
  53         memset (f, 0, sizeof (*f));
  54         f->filter_func = NULL;
  55         f->extra = NULL;
  56         f->next = NULL;
  57         f->argc = 0;
  58
  59         if (chain != NULL) {
  60                 /* append f to end of chain */
  61                 while (chain->next)
  62                         chain = chain->next;
  63                 chain->next = f;
  64         }
  65
  66
  67         /* allocate argv, and populate it with the argument list. */
  68         max_args = 8;
  69         f->argv =
  70                 (const char **) flex_alloc (sizeof (char *) *
  71                                             (max_args + 1));
  72         if (!f->argv)
  73                 flexerror (_("flex_alloc failed (f->argv) in filter_create_ext"));
  74         f->argv[f->argc++] = cmd;
  75
  76         va_start (ap, cmd);
  77         while ((s = va_arg (ap, const char *)) != NULL) {
  78                 if (f->argc >= max_args) {
  79                         max_args += 8;
  80                         f->argv =
  81                                 (const char **) flex_realloc (f->argv,
  82                                                               sizeof (char
  83                                                                       *) *
  84                                                               (max_args +
  85                                                                1));
  86                 }
  87                 f->argv[f->argc++] = s;
  88         }
  89         f->argv[f->argc] = NULL;
  90
  91         va_end (ap);
  92         return f;
  93 }
  94
  95 /* Allocate and initialize an internal filter.
  96  * @param chain the current chain or NULL for new chain
  97  * @param filter_func The function that will perform the filtering.
  98  *        filter_func should return 0 if successful, and -1
  99  *        if an error occurs -- or it can simply exit().
 100  * @param extra optional user-defined data to pass to the filter.
 101  * @return newest filter in chain
 102  */
 103 struct filter *filter_create_int (struct filter *chain,
 104                                   int (*filter_func) (struct filter *),
 105                                   void *extra)
 106 {
 107         struct filter *f;
 108
 109         /* allocate and initialize new filter */
 110         f = (struct filter *) flex_alloc (sizeof (struct filter));
 111         if (!f)
 112                 flexerror (_("flex_alloc failed in filter_create_int"));
 113         memset (f, 0, sizeof (*f));
 114         f->next = NULL;
 115         f->argc = 0;
 116         f->argv = NULL;
 117
 118         f->filter_func = filter_func;
 119         f->extra = extra;
 120
 121         if (chain != NULL) {
 122                 /* append f to end of chain */
 123                 while (chain->next)
 124                         chain = chain->next;
 125                 chain->next = f;
 126         }
 127
 128         return f;
 129 }
 130
 131 /** Fork and exec entire filter chain.
 132  *  @param chain The head of the chain.
 133  *  @return true on success.
 134  */
 135 bool filter_apply_chain (struct filter * chain)
 136 {
 137         int     pid, pipes[2];
 138         int     r;
 139         const int readsz = 512;
 140         char   *buf;
 141
 142
 143         /* Tricky recursion, since we want to begin the chain
 144          * at the END. Why? Because we need all the forked processes
 145          * to be children of the main flex process.
 146          */
 147         if (chain)
 148                 filter_apply_chain (chain->next);
 149         else
 150                 return true;
 151
 152         /* Now we are the right-most unprocessed link in the chain.
 153          */
 154
 155         fflush (stdout);
 156         fflush (stderr);
 157
 158
 159         if (pipe (pipes) == -1)
 160                 flexerror (_("pipe failed"));
 161
 162         if ((pid = fork ()) == -1)
 163                 flexerror (_("fork failed"));
 164
 165         if (pid == 0) {
 166                 /* child */
 167
 168         /* We need stdin (the FILE* stdin) to connect to this new pipe.
 169          * There is no portable way to set stdin to a new file descriptor,
 170          * as stdin is not an lvalue on some systems (BSD).
 171          * So we dup the new pipe onto the stdin descriptor and use a no-op fseek
 172          * to sync the stream. This is a Hail Mary situation. It seems to work.
 173          */
 174                 close (pipes[1]);
 175 clearerr(stdin);
 176                 if (dup2 (pipes[0], fileno (stdin)) == -1)
 177                         flexfatal (_("dup2(pipes[0],0)"));
 178                 close (pipes[0]);
 179         fseek (stdin, 0, SEEK_CUR);
 180
 181                 /* run as a filter, either internally or by exec */
 182                 if (chain->filter_func) {
 183                         int     r;
 184
 185                         if ((r = chain->filter_func (chain)) == -1)
 186                                 flexfatal (_("filter_func failed"));
 187                         exit (0);
 188                 }
 189                 else {
 190                         execvp (chain->argv[0],
 191                                 (char **const) (chain->argv));
 192             lerrsf_fatal ( _("exec of %s failed"),
 193                     chain->argv[0]);
 194                 }
 195
 196                 exit (1);
 197         }
 198
 199         /* Parent */
 200         close (pipes[0]);
 201         if (dup2 (pipes[1], fileno (stdout)) == -1)
 202                 flexfatal (_("dup2(pipes[1],1)"));
 203         close (pipes[1]);
 204     fseek (stdout, 0, SEEK_CUR);
 205
 206         return true;
 207 }
 208
 209 /** Truncate the chain to max_len number of filters.
 210  * @param chain the current chain.
 211  * @param max_len the maximum length of the chain.
 212  * @return the resulting length of the chain.
 213  */
 214 int filter_truncate (struct filter *chain, int max_len)
 215 {
 216         int     len = 1;
 217
 218         if (!chain)
 219                 return 0;
 220
 221         while (chain->next && len < max_len) {
 222                 chain = chain->next;
 223                 ++len;
 224         }
 225
 226         chain->next = NULL;
 227         return len;
 228 }
 229
 230 /** Splits the chain in order to write to a header file.
 231  *  Similar in spirit to the 'tee' program.
 232  *  The header file name is in extra.
 233  *  @return 0 (zero) on success, and -1 on failure.
 234  */
 235 int filter_tee_header (struct filter *chain)
 236 {
 237         /* This function reads from stdin and writes to both the C file and the
 238          * header file at the same time.
 239          */
 240
 241         const int readsz = 512;
 242         char   *buf;
 243         int     to_cfd = -1;
 244         FILE   *to_c = NULL, *to_h = NULL;
 245         bool    write_header;
 246
 247         write_header = (chain->extra != NULL);
 248
 249         /* Store a copy of the stdout pipe, which is already piped to C file
 250          * through the running chain. Then create a new pipe to the H file as
 251          * stdout, and fork the rest of the chain again.
 252          */
 253
 254         if ((to_cfd = dup (1)) == -1)
 255                 flexfatal (_("dup(1) failed"));
 256         to_c = fdopen (to_cfd, "w");
 257
 258         if (write_header) {
 259                 if (freopen ((char *) chain->extra, "w", stdout) == NULL)
 260                         flexfatal (_("freopen(headerfilename) failed"));
 261
 262                 filter_apply_chain (chain->next);
 263                 to_h = stdout;
 264         }
 265
 266         /* Now to_c is a pipe to the C branch, and to_h is a pipe to the H branch.
 267          */
 268
 269         if (write_header) {
 270         fputs (check_4_gnu_m4, to_h);
 271                 fputs ("m4_changecom`'m4_dnl\n", to_h);
 272                 fputs ("m4_changequote`'m4_dnl\n", to_h);
 273                 fputs ("m4_changequote([[,]])[[]]m4_dnl\n", to_h);
 274             fputs ("m4_define([[M4_YY_NOOP]])[[]]m4_dnl\n", to_h);
 275                 fputs ("m4_define( [[M4_YY_IN_HEADER]],[[]])m4_dnl\n",
 276                        to_h);
 277                 fprintf (to_h, "#ifndef %sHEADER_H\n", prefix);
 278                 fprintf (to_h, "#define %sHEADER_H 1\n", prefix);
 279                 fprintf (to_h, "#define %sIN_HEADER 1\n\n", prefix);
 280                 fprintf (to_h,
 281                          "m4_define( [[M4_YY_OUTFILE_NAME]],[[%s]])m4_dnl\n",
 282                          headerfilename ? headerfilename : "<stdout>");
 283
 284         }
 285
 286     fputs (check_4_gnu_m4, to_c);
 287         fputs ("m4_changecom`'m4_dnl\n", to_c);
 288         fputs ("m4_changequote`'m4_dnl\n", to_c);
 289         fputs ("m4_changequote([[,]])[[]]m4_dnl\n", to_c);
 290         fputs ("m4_define([[M4_YY_NOOP]])[[]]m4_dnl\n", to_c);
 291         fprintf (to_c, "m4_define( [[M4_YY_OUTFILE_NAME]],[[%s]])m4_dnl\n",
 292                  outfilename ? outfilename : "<stdout>");
 293
 294         buf = (char *) flex_alloc (readsz);
 295         if (!buf)
 296                 flexerror (_("flex_alloc failed in filter_tee_header"));
 297         while (fgets (buf, readsz, stdin)) {
 298                 fputs (buf, to_c);
 299                 if (write_header)
 300                         fputs (buf, to_h);
 301         }
 302
 303         if (write_header) {
 304                 fprintf (to_h, "\n");
 305
 306                 /* write a fake line number. It will get fixed by the linedir filter. */
 307                 fprintf (to_h, "#line 4000 \"M4_YY_OUTFILE_NAME\"\n");
 308
 309                 fprintf (to_h, "#undef %sIN_HEADER\n", prefix);
 310                 fprintf (to_h, "#endif /* %sHEADER_H */\n", prefix);
 311                 fputs ("m4_undefine( [[M4_YY_IN_HEADER]])m4_dnl\n", to_h);
 312
 313                 fflush (to_h);
 314                 if (ferror (to_h))
 315                         lerrsf (_("error writing output file %s"),
 316                                 (char *) chain->extra);
 317
 318                 else if (fclose (to_h))
 319                         lerrsf (_("error closing output file %s"),
 320                                 (char *) chain->extra);
 321         }
 322
 323         fflush (to_c);
 324         if (ferror (to_c))
 325                 lerrsf (_("error writing output file %s"),
 326                         outfilename ? outfilename : "<stdout>");
 327
 328         else if (fclose (to_c))
 329                 lerrsf (_("error closing output file %s"),
 330                         outfilename ? outfilename : "<stdout>");
 331
 332         while (wait (0) > 0) ;
 333
 334         exit (0);
 335         return 0;
 336 }
 337
 338 /** Adjust the line numbers in the #line directives of the generated scanner.
 339  * After the m4 expansion, the line numbers are incorrect since the m4 macros
 340  * can add or remove lines.  This only adjusts line numbers for generated code,
 341  * not user code. This also happens to be a good place to squeeze multiple
 342  * blank lines into a single blank line.
 343  */
 344 int filter_fix_linedirs (struct filter *chain)
 345 {
 346         char   *buf;
 347         const int readsz = 512;
 348         int     lineno = 1;
 349         bool    in_gen = true;  /* in generated code */
 350         bool    last_was_blank = false;
 351
 352         if (!chain)
 353                 return 0;
 354
 355         buf = (char *) flex_alloc (readsz);
 356         if (!buf)
 357                 flexerror (_("flex_alloc failed in filter_fix_linedirs"));
 358
 359         while (fgets (buf, readsz, stdin)) {
 360
 361                 regmatch_t m[10];
 362
 363                 /* Check for #line directive. */
 364                 if (buf[0] == '#'
 365                         && regexec (&regex_linedir, buf, 3, m, 0) == 0) {
 366
 367                         int     num;
 368                         char   *fname;
 369
 370                         /* extract the line number and filename */
 371                         num = regmatch_strtol (&m[1], buf, NULL, 0);
 372                         fname = regmatch_dup (&m[2], buf);
 373
 374                         if (strcmp (fname,
 375                                 outfilename ? outfilename : "<stdout>")
 376                                         == 0
 377                          || strcmp (fname,
 378                                 headerfilename ? headerfilename : "<stdout>")
 379                                         == 0) {
 380
 381                                 char    *s1, *s2;
 382                                 char    filename[MAXLINE];
 383
 384                                 s1 = fname;
 385                                 s2 = filename;
 386
 387                                 while ((s2 - filename) < (MAXLINE - 1) && *s1) {
 388                                         /* Escape the backslash */
 389                                         if (*s1 == '\\')
 390                                                 *s2++ = '\\';
 391                                         /* Escape the double quote */
 392                                         if (*s1 == '\"')
 393                                                 *s2++ = '\\';
 394                                         /* Copy the character as usual */
 395                                         *s2++ = *s1++;
 396                                 }
 397
 398                                 *s2 = '\0';
 399
 400                                 /* Adjust the line directives. */
 401                                 in_gen = true;
 402                                 snprintf (buf, readsz, "#line %d \"%s\"\n",
 403                                           lineno + 1, filename);
 404                         }
 405                         else {
 406                                 /* it's a #line directive for code we didn't write */
 407                                 in_gen = false;
 408                         }
 409
 410                         free (fname);
 411                         last_was_blank = false;
 412                 }
 413
 414                 /* squeeze blank lines from generated code */
 415                 else if (in_gen
 416                          && regexec (&regex_blank_line, buf, 0, NULL,
 417                                      0) == 0) {
 418                         if (last_was_blank)
 419                                 continue;
 420                         else
 421                                 last_was_blank = true;
 422                 }
 423
 424                 else {
 425                         /* it's a line of normal, non-empty code. */
 426                         last_was_blank = false;
 427                 }
 428
 429                 fputs (buf, stdout);
 430                 lineno++;
 431         }
 432         fflush (stdout);
 433         if (ferror (stdout))
 434                 lerrsf (_("error writing output file %s"),
 435                         outfilename ? outfilename : "<stdout>");
 436
 437         else if (fclose (stdout))
 438                 lerrsf (_("error closing output file %s"),
 439                         outfilename ? outfilename : "<stdout>");
 440
 441         return 0;
 442 }
 443
 444 /* vim:set expandtab cindent tabstop=4 softtabstop=4 shiftwidth=4 textwidth=0: */