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 = malloc(sizeof(struct filter)); 51 if (!f) 52 flexerror(_("malloc 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 = malloc(sizeof(char *) * (size_t) (max_args + 1)); 70 if (!f->argv) 71 flexerror(_("malloc failed (f->argv) in filter_create_ext")); 72 f->argv[f->argc++] = cmd; 73 74 va_start (ap, cmd); 75 while ((s = va_arg (ap, const char *)) != NULL) { 76 if (f->argc >= max_args) { 77 max_args += 8; 78 f->argv = realloc(f->argv, sizeof(char*) * (size_t) (max_args + 1)); 79 } 80 f->argv[f->argc++] = s; 81 } 82 f->argv[f->argc] = NULL; 83 84 va_end (ap); 85 return f; 86 } 87 88 /* Allocate and initialize an internal filter. 89 * @param chain the current chain or NULL for new chain 90 * @param filter_func The function that will perform the filtering. 91 * filter_func should return 0 if successful, and -1 92 * if an error occurs -- or it can simply exit(). 93 * @param extra optional user-defined data to pass to the filter. 94 * @return newest filter in chain 95 */ 96 struct filter *filter_create_int (struct filter *chain, 97 int (*filter_func) (struct filter *), 98 void *extra) 99 { 100 struct filter *f; 101 102 /* allocate and initialize new filter */ 103 f = malloc(sizeof(struct filter)); 104 if (!f) 105 flexerror(_("malloc failed in filter_create_int")); 106 memset (f, 0, sizeof (*f)); 107 f->next = NULL; 108 f->argc = 0; 109 f->argv = NULL; 110 111 f->filter_func = filter_func; 112 f->extra = extra; 113 114 if (chain != NULL) { 115 /* append f to end of chain */ 116 while (chain->next) 117 chain = chain->next; 118 chain->next = f; 119 } 120 121 return f; 122 } 123 124 /** Fork and exec entire filter chain. 125 * @param chain The head of the chain. 126 * @return true on success. 127 */ 128 bool filter_apply_chain (struct filter * chain) 129 { 130 int pid, pipes[2]; 131 132 133 /* Tricky recursion, since we want to begin the chain 134 * at the END. Why? Because we need all the forked processes 135 * to be children of the main flex process. 136 */ 137 if (chain) 138 filter_apply_chain (chain->next); 139 else 140 return true; 141 142 /* Now we are the right-most unprocessed link in the chain. 143 */ 144 145 fflush (stdout); 146 fflush (stderr); 147 148 149 if (pipe (pipes) == -1) 150 flexerror (_("pipe failed")); 151 152 if ((pid = fork ()) == -1) 153 flexerror (_("fork failed")); 154 155 if (pid == 0) { 156 /* child */ 157 158 /* We need stdin (the FILE* stdin) to connect to this new pipe. 159 * There is no portable way to set stdin to a new file descriptor, 160 * as stdin is not an lvalue on some systems (BSD). 161 * So we dup the new pipe onto the stdin descriptor and use a no-op fseek 162 * to sync the stream. This is a Hail Mary situation. It seems to work. 163 */ 164 close (pipes[1]); 165 clearerr(stdin); 166 if (dup2 (pipes[0], fileno (stdin)) == -1) 167 flexfatal (_("dup2(pipes[0],0)")); 168 close (pipes[0]); 169 fseek (stdin, 0, SEEK_CUR); 170 ungetc(' ', stdin); /* still an evil hack, but one that works better */ 171 (void)fgetc(stdin); /* on NetBSD than the fseek attempt does */ 172 173 /* run as a filter, either internally or by exec */ 174 if (chain->filter_func) { 175 int r; 176 177 if ((r = chain->filter_func (chain)) == -1) 178 flexfatal (_("filter_func failed")); 179 FLEX_EXIT (0); 180 } 181 else { 182 execvp (chain->argv[0], 183 (char **const) (chain->argv)); 184 lerr_fatal ( _("exec of %s failed"), 185 chain->argv[0]); 186 } 187 188 FLEX_EXIT (1); 189 } 190 191 /* Parent */ 192 close (pipes[0]); 193 if (dup2 (pipes[1], fileno (stdout)) == -1) 194 flexfatal (_("dup2(pipes[1],1)")); 195 close (pipes[1]); 196 fseek (stdout, 0, SEEK_CUR); 197 198 return true; 199 } 200 201 /** Truncate the chain to max_len number of filters. 202 * @param chain the current chain. 203 * @param max_len the maximum length of the chain. 204 * @return the resulting length of the chain. 205 */ 206 int filter_truncate (struct filter *chain, int max_len) 207 { 208 int len = 1; 209 210 if (!chain) 211 return 0; 212 213 while (chain->next && len < max_len) { 214 chain = chain->next; 215 ++len; 216 } 217 218 chain->next = NULL; 219 return len; 220 } 221 222 /** Splits the chain in order to write to a header file. 223 * Similar in spirit to the 'tee' program. 224 * The header file name is in extra. 225 * @return 0 (zero) on success, and -1 on failure. 226 */ 227 int filter_tee_header (struct filter *chain) 228 { 229 /* This function reads from stdin and writes to both the C file and the 230 * header file at the same time. 231 */ 232 233 const int readsz = 512; 234 char *buf; 235 int to_cfd = -1; 236 FILE *to_c = NULL, *to_h = NULL; 237 bool write_header; 238 239 write_header = (chain->extra != NULL); 240 241 /* Store a copy of the stdout pipe, which is already piped to C file 242 * through the running chain. Then create a new pipe to the H file as 243 * stdout, and fork the rest of the chain again. 244 */ 245 246 if ((to_cfd = dup (1)) == -1) 247 flexfatal (_("dup(1) failed")); 248 to_c = fdopen (to_cfd, "w"); 249 250 if (write_header) { 251 if (freopen ((char *) chain->extra, "w", stdout) == NULL) 252 flexfatal (_("freopen(headerfilename) failed")); 253 254 filter_apply_chain (chain->next); 255 to_h = stdout; 256 } 257 258 /* Now to_c is a pipe to the C branch, and to_h is a pipe to the H branch. 259 */ 260 261 if (write_header) { 262 fputs (check_4_gnu_m4, to_h); 263 fputs ("m4_changecom`'m4_dnl\n", to_h); 264 fputs ("m4_changequote`'m4_dnl\n", to_h); 265 fputs ("m4_changequote([[,]])[[]]m4_dnl\n", to_h); 266 fputs ("m4_define([[M4_YY_NOOP]])[[]]m4_dnl\n", to_h); 267 fputs ("m4_define( [[M4_YY_IN_HEADER]],[[]])m4_dnl\n", 268 to_h); 269 fprintf (to_h, "#ifndef %sHEADER_H\n", prefix); 270 fprintf (to_h, "#define %sHEADER_H 1\n", prefix); 271 fprintf (to_h, "#define %sIN_HEADER 1\n\n", prefix); 272 fprintf (to_h, 273 "m4_define( [[M4_YY_OUTFILE_NAME]],[[%s]])m4_dnl\n", 274 headerfilename ? headerfilename : "<stdout>"); 275 276 } 277 278 fputs (check_4_gnu_m4, to_c); 279 fputs ("m4_changecom`'m4_dnl\n", to_c); 280 fputs ("m4_changequote`'m4_dnl\n", to_c); 281 fputs ("m4_changequote([[,]])[[]]m4_dnl\n", to_c); 282 fputs ("m4_define([[M4_YY_NOOP]])[[]]m4_dnl\n", to_c); 283 fprintf (to_c, "m4_define( [[M4_YY_OUTFILE_NAME]],[[%s]])m4_dnl\n", 284 outfilename ? outfilename : "<stdout>"); 285 286 buf = malloc((size_t) readsz); 287 if (!buf) 288 flexerror(_("malloc failed in filter_tee_header")); 289 while (fgets (buf, readsz, stdin)) { 290 fputs (buf, to_c); 291 if (write_header) 292 fputs (buf, to_h); 293 } 294 295 if (write_header) { 296 fprintf (to_h, "\n"); 297 298 /* write a fake line number. It will get fixed by the linedir filter. */ 299 if (gen_line_dirs) 300 fprintf (to_h, "#line 4000 \"M4_YY_OUTFILE_NAME\"\n"); 301 302 fprintf (to_h, "#undef %sIN_HEADER\n", prefix); 303 fprintf (to_h, "#endif /* %sHEADER_H */\n", prefix); 304 fputs ("m4_undefine( [[M4_YY_IN_HEADER]])m4_dnl\n", to_h); 305 306 fflush (to_h); 307 if (ferror (to_h)) 308 lerr (_("error writing output file %s"), 309 (char *) chain->extra); 310 311 else if (fclose (to_h)) 312 lerr (_("error closing output file %s"), 313 (char *) chain->extra); 314 } 315 316 fflush (to_c); 317 if (ferror (to_c)) 318 lerr (_("error writing output file %s"), 319 outfilename ? outfilename : "<stdout>"); 320 321 else if (fclose (to_c)) 322 lerr (_("error closing output file %s"), 323 outfilename ? outfilename : "<stdout>"); 324 325 while (wait (0) > 0) ; 326 327 FLEX_EXIT (0); 328 return 0; 329 } 330 331 /** Adjust the line numbers in the #line directives of the generated scanner. 332 * After the m4 expansion, the line numbers are incorrect since the m4 macros 333 * can add or remove lines. This only adjusts line numbers for generated code, 334 * not user code. This also happens to be a good place to squeeze multiple 335 * blank lines into a single blank line. 336 */ 337 int filter_fix_linedirs (struct filter *chain) 338 { 339 char *buf; 340 const size_t readsz = 512; 341 int lineno = 1; 342 bool in_gen = true; /* in generated code */ 343 bool last_was_blank = false; 344 345 if (!chain) 346 return 0; 347 348 buf = malloc(readsz); 349 if (!buf) 350 flexerror(_("malloc failed in filter_fix_linedirs")); 351 352 while (fgets (buf, (int) readsz, stdin)) { 353 354 regmatch_t m[10]; 355 356 /* Check for #line directive. */ 357 if (buf[0] == '#' 358 && regexec (®ex_linedir, buf, 3, m, 0) == 0) { 359 360 char *fname; 361 362 /* extract the line number and filename */ 363 fname = regmatch_dup (&m[2], buf); 364 365 if (strcmp (fname, 366 outfilename ? outfilename : "<stdout>") 367 == 0 368 || strcmp (fname, 369 headerfilename ? headerfilename : "<stdout>") 370 == 0) { 371 372 char *s1, *s2; 373 char filename[MAXLINE]; 374 375 s1 = fname; 376 s2 = filename; 377 378 while ((s2 - filename) < (MAXLINE - 1) && *s1) { 379 /* Escape the backslash */ 380 if (*s1 == '\\') 381 *s2++ = '\\'; 382 /* Escape the double quote */ 383 if (*s1 == '\"') 384 *s2++ = '\\'; 385 /* Copy the character as usual */ 386 *s2++ = *s1++; 387 } 388 389 *s2 = '\0'; 390 391 /* Adjust the line directives. */ 392 in_gen = true; 393 snprintf (buf, readsz, "#line %d \"%s\"\n", 394 lineno, filename); 395 } 396 else { 397 /* it's a #line directive for code we didn't write */ 398 in_gen = false; 399 } 400 401 free (fname); 402 last_was_blank = false; 403 } 404 405 /* squeeze blank lines from generated code */ 406 else if (in_gen 407 && regexec (®ex_blank_line, buf, 0, NULL, 408 0) == 0) { 409 if (last_was_blank) 410 continue; 411 else 412 last_was_blank = true; 413 } 414 415 else { 416 /* it's a line of normal, non-empty code. */ 417 last_was_blank = false; 418 } 419 420 fputs (buf, stdout); 421 lineno++; 422 } 423 fflush (stdout); 424 if (ferror (stdout)) 425 lerr (_("error writing output file %s"), 426 outfilename ? outfilename : "<stdout>"); 427 428 else if (fclose (stdout)) 429 lerr (_("error closing output file %s"), 430 outfilename ? outfilename : "<stdout>"); 431 432 return 0; 433 } 434 435 /* vim:set expandtab cindent tabstop=4 softtabstop=4 shiftwidth=4 textwidth=0: */ 436