/* filter - postprocessing of flex output through filters */

/*  This file is part of flex. */

/*  Redistribution and use in source and binary forms, with or without */

/*  modification, are permitted provided that the following conditions */

/*  are met: */

/*  1. Redistributions of source code must retain the above copyright */

/*     notice, this list of conditions and the following disclaimer. */

/*  2. Redistributions in binary form must reproduce the above copyright */

/*     notice, this list of conditions and the following disclaimer in the */

/*     documentation and/or other materials provided with the distribution. */

/*  Neither the name of the University nor the names of its contributors */

/*  may be used to endorse or promote products derived from this software */

/*  without specific prior written permission. */

/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */

/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */

/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */

/*  PURPOSE. */

#include "flexdef.h"

static const char * check_4_gnu_m4 =

    "m4_dnl ifdef(`__gnu__', ,"

    "`errprint(Flex requires GNU M4. Set the PATH or set the M4 environment variable to its path name.)"

    " m4exit(2)')\n";

/** global chain. */

struct filter *output_chain = NULL;

/* Allocate and initialize an external filter.

 * @param chain the current chain or NULL for new chain

 * @param cmd the command to execute.

 * @param ... a NULL terminated list of (const char*) arguments to command,

 *            not including argv[0].

 * @return newest filter in chain

 */

struct filter *filter_create_ext (struct filter *chain, const char *cmd,

				  ...)

{

	struct filter *f;

	int     max_args;

	const char *s;

	va_list ap;

	/* allocate and initialize new filter */

	f = malloc(sizeof(struct filter));

	if (!f)

		flexerror(_("malloc failed (f) in filter_create_ext"));

	memset (f, 0, sizeof (*f));

	f->filter_func = NULL;

	f->extra = NULL;

	f->next = NULL;

	f->argc = 0;

	if (chain != NULL) {

		/* append f to end of chain */

		while (chain->next)

			chain = chain->next;

		chain->next = f;

	}

	/* allocate argv, and populate it with the argument list. */

	max_args = 8;

	f->argv = malloc(sizeof(char *) * (size_t) (max_args + 1));

	if (!f->argv)

		flexerror(_("malloc failed (f->argv) in filter_create_ext"));

	f->argv[f->argc++] = cmd;

	va_start (ap, cmd);

	while ((s = va_arg (ap, const char *)) != NULL) {

		if (f->argc >= max_args) {

			max_args += 8;

			f->argv = realloc(f->argv, sizeof(char*) * (size_t) (max_args + 1));

		}

		f->argv[f->argc++] = s;

	}

	f->argv[f->argc] = NULL;

	va_end (ap);

	return f;

}

/* Allocate and initialize an internal filter.

 * @param chain the current chain or NULL for new chain

 * @param filter_func The function that will perform the filtering.

 *        filter_func should return 0 if successful, and -1

 *        if an error occurs -- or it can simply exit().

 * @param extra optional user-defined data to pass to the filter.

 * @return newest filter in chain

 */

struct filter *filter_create_int (struct filter *chain,

				  int (*filter_func) (struct filter *),

				  void *extra)

{

	struct filter *f;

	/* allocate and initialize new filter */

	f = malloc(sizeof(struct filter));

	if (!f)

		flexerror(_("malloc failed in filter_create_int"));

	memset (f, 0, sizeof (*f));

	f->next = NULL;

	f->argc = 0;

	f->argv = NULL;

	f->filter_func = filter_func;

	f->extra = extra;

	if (chain != NULL) {

		/* append f to end of chain */

		while (chain->next)

			chain = chain->next;

		chain->next = f;

	}

	return f;

}

/** Fork and exec entire filter chain.

 *  @param chain The head of the chain.

 *  @return true on success.

 */

bool filter_apply_chain (struct filter * chain)

{

	int     pid, pipes[2];

	/* Tricky recursion, since we want to begin the chain

	 * at the END. Why? Because we need all the forked processes

	 * to be children of the main flex process.

	 */

	if (chain)

		filter_apply_chain (chain->next);

	else

		return true;

	/* Now we are the right-most unprocessed link in the chain.

	 */

	fflush (stdout);

	fflush (stderr);

	if (pipe (pipes) == -1)

		flexerror (_("pipe failed"));

	if ((pid = fork ()) == -1)

		flexerror (_("fork failed"));

	if (pid == 0) {

		/* child */

        /* We need stdin (the FILE* stdin) to connect to this new pipe.

         * There is no portable way to set stdin to a new file descriptor,

         * as stdin is not an lvalue on some systems (BSD).

         * So we dup the new pipe onto the stdin descriptor and use a no-op fseek

         * to sync the stream. This is a Hail Mary situation. It seems to work.

         */

		close (pipes[1]);

clearerr(stdin);

		if (dup2 (pipes[0], fileno (stdin)) == -1)

			flexfatal (_("dup2(pipes[0],0)"));

		close (pipes[0]);

        fseek (stdin, 0, SEEK_CUR);

        ungetc(' ', stdin); /* still an evil hack, but one that works better */

        (void)fgetc(stdin); /* on NetBSD than the fseek attempt does */

		/* run as a filter, either internally or by exec */

		if (chain->filter_func) {

			int     r;

			if ((r = chain->filter_func (chain)) == -1)

				flexfatal (_("filter_func failed"));

			exit (0);

		}

		else {

			execvp (chain->argv[0],

				(char **const) (chain->argv));

            lerr_fatal ( _("exec of %s failed"),

                    chain->argv[0]);

		}

		exit (1);

	}

	/* Parent */

	close (pipes[0]);

	if (dup2 (pipes[1], fileno (stdout)) == -1)

		flexfatal (_("dup2(pipes[1],1)"));

	close (pipes[1]);

    fseek (stdout, 0, SEEK_CUR);

	return true;

}

/** Truncate the chain to max_len number of filters.

 * @param chain the current chain.

 * @param max_len the maximum length of the chain.

 * @return the resulting length of the chain.

 */

int filter_truncate (struct filter *chain, int max_len)

{

	int     len = 1;

	if (!chain)

		return 0;

	while (chain->next && len < max_len) {

		chain = chain->next;

		++len;

	}

	chain->next = NULL;

	return len;

}

/** Splits the chain in order to write to a header file.

 *  Similar in spirit to the 'tee' program.

 *  The header file name is in extra.

 *  @return 0 (zero) on success, and -1 on failure.

 */

int filter_tee_header (struct filter *chain)

{

	/* This function reads from stdin and writes to both the C file and the

	 * header file at the same time.

	 */

	const int readsz = 512;

	char   *buf;

	int     to_cfd = -1;

	FILE   *to_c = NULL, *to_h = NULL;

	bool    write_header;

	write_header = (chain->extra != NULL);

	/* Store a copy of the stdout pipe, which is already piped to C file

	 * through the running chain. Then create a new pipe to the H file as

	 * stdout, and fork the rest of the chain again.

	 */

	if ((to_cfd = dup (1)) == -1)

		flexfatal (_("dup(1) failed"));

	to_c = fdopen (to_cfd, "w");

	if (write_header) {

		if (freopen ((char *) chain->extra, "w", stdout) == NULL)

			flexfatal (_("freopen(headerfilename) failed"));

		filter_apply_chain (chain->next);

		to_h = stdout;

	}

	/* Now to_c is a pipe to the C branch, and to_h is a pipe to the H branch.

	 */

	if (write_header) {

        fputs (check_4_gnu_m4, to_h);

		fputs ("m4_changecom`'m4_dnl\n", to_h);

		fputs ("m4_changequote`'m4_dnl\n", to_h);

		fputs ("m4_changequote([[,]])[[]]m4_dnl\n", to_h);

	    fputs ("m4_define([[M4_YY_NOOP]])[[]]m4_dnl\n", to_h);

		fputs ("m4_define( [[M4_YY_IN_HEADER]],[[]])m4_dnl\n",

		       to_h);

		fprintf (to_h, "#ifndef %sHEADER_H\n", prefix);

		fprintf (to_h, "#define %sHEADER_H 1\n", prefix);

		fprintf (to_h, "#define %sIN_HEADER 1\n\n", prefix);

		fprintf (to_h,

			 "m4_define( [[M4_YY_OUTFILE_NAME]],[[%s]])m4_dnl\n",

			 headerfilename ? headerfilename : "<stdout>");

	}

    fputs (check_4_gnu_m4, to_c);

	fputs ("m4_changecom`'m4_dnl\n", to_c);

	fputs ("m4_changequote`'m4_dnl\n", to_c);

	fputs ("m4_changequote([[,]])[[]]m4_dnl\n", to_c);

	fputs ("m4_define([[M4_YY_NOOP]])[[]]m4_dnl\n", to_c);

	fprintf (to_c, "m4_define( [[M4_YY_OUTFILE_NAME]],[[%s]])m4_dnl\n",

		 outfilename ? outfilename : "<stdout>");

	buf = malloc((size_t) readsz);

	if (!buf)

		flexerror(_("malloc failed in filter_tee_header"));

	while (fgets (buf, readsz, stdin)) {

		fputs (buf, to_c);

		if (write_header)

			fputs (buf, to_h);

	}

	if (write_header) {

		fprintf (to_h, "\n");

		/* write a fake line number. It will get fixed by the linedir filter. */

		fprintf (to_h, "#line 4000 \"M4_YY_OUTFILE_NAME\"\n");

		fprintf (to_h, "#undef %sIN_HEADER\n", prefix);

		fprintf (to_h, "#endif /* %sHEADER_H */\n", prefix);

		fputs ("m4_undefine( [[M4_YY_IN_HEADER]])m4_dnl\n", to_h);

		fflush (to_h);

		if (ferror (to_h))

			lerr (_("error writing output file %s"),

				(char *) chain->extra);

		else if (fclose (to_h))

			lerr (_("error closing output file %s"),

				(char *) chain->extra);

	}

	fflush (to_c);

	if (ferror (to_c))

		lerr (_("error writing output file %s"),

			outfilename ? outfilename : "<stdout>");

	else if (fclose (to_c))

		lerr (_("error closing output file %s"),

			outfilename ? outfilename : "<stdout>");

	while (wait (0) > 0) ;

	exit (0);

	return 0;

}

/** Adjust the line numbers in the #line directives of the generated scanner.

 * After the m4 expansion, the line numbers are incorrect since the m4 macros

 * can add or remove lines.  This only adjusts line numbers for generated code,

 * not user code. This also happens to be a good place to squeeze multiple

 * blank lines into a single blank line.

 */

int filter_fix_linedirs (struct filter *chain)

{

	char   *buf;

	const size_t readsz = 512;

	int     lineno = 1;

	bool    in_gen = true;	/* in generated code */

	bool    last_was_blank = false;

	if (!chain)

		return 0;

	buf = malloc(readsz);

	if (!buf)

		flexerror(_("malloc failed in filter_fix_linedirs"));

	while (fgets (buf, (int) readsz, stdin)) {

		regmatch_t m[10];

		/* Check for #line directive. */

		if (buf[0] == '#'

			&& regexec (&regex_linedir, buf, 3, m, 0) == 0) {

			char   *fname;

			/* extract the line number and filename */

			fname = regmatch_dup (&m[2], buf);

			if (strcmp (fname,

				outfilename ? outfilename : "<stdout>")

					== 0

			 || strcmp (fname,

			 	headerfilename ? headerfilename : "<stdout>")

					== 0) {

				char    *s1, *s2;

				char	filename[MAXLINE];

				s1 = fname;

				s2 = filename;

				while ((s2 - filename) < (MAXLINE - 1) && *s1) {

					/* Escape the backslash */

					if (*s1 == '\\')

						*s2++ = '\\';

					/* Escape the double quote */

					if (*s1 == '\"')

						*s2++ = '\\';

					/* Copy the character as usual */

					*s2++ = *s1++;

				}

				*s2 = '\0';

				/* Adjust the line directives. */

				in_gen = true;

				snprintf (buf, readsz, "#line %d \"%s\"\n",

					  lineno + 1, filename);

			}

			else {

				/* it's a #line directive for code we didn't write */

				in_gen = false;

			}

			free (fname);

			last_was_blank = false;

		}

		/* squeeze blank lines from generated code */

		else if (in_gen

			 && regexec (&regex_blank_line, buf, 0, NULL,

				     0) == 0) {

			if (last_was_blank)

				continue;

			else

				last_was_blank = true;

		}

		else {

			/* it's a line of normal, non-empty code. */

			last_was_blank = false;

		}

		fputs (buf, stdout);

		lineno++;

	}

	fflush (stdout);

	if (ferror (stdout))

		lerr (_("error writing output file %s"),

			outfilename ? outfilename : "<stdout>");

	else if (fclose (stdout))

		lerr (_("error closing output file %s"),

			outfilename ? outfilename : "<stdout>");

	return 0;

}

/* vim:set expandtab cindent tabstop=4 softtabstop=4 shiftwidth=4 textwidth=0: */