Added internal filter ability.

Deleted various unused variables.

diff --git a/buf.c b/buf.c
index 49c87f2dfc8b618e9c81ecac4cfd244b62cf4a16..53f2fa84aa223ce1e3d6f31180073bf1bf9afe5e 100644 (file)
--- a/buf.c
+++ b/buf.c
@@ -51,6 +51,7 @@ struct Buf *buf_print_strings(struct Buf * buf, FILE* out)
         if(s)
             fprintf(out, "%s", s);
     }
+    return buf;
 }
 
 /* Append a "%s" formatted string to a string buffer */
@@ -119,6 +120,7 @@ struct Buf *buf_m4_define (struct Buf *buf, const char* def, const char* val)
 
     sprintf(str, fmt, def, val);
     buf_append(buf, &str, 1);
+    return buf;
 }
 
 /** Pushes "m4_undefine([[def]])m4_dnl" to end of buffer.
@@ -135,6 +137,7 @@ struct Buf *buf_m4_undefine (struct Buf *buf, const char* def)
 
     sprintf(str, fmt, def);
     buf_append(buf, &str, 1);
+    return buf;
 }
 
 /* create buf with 0 elements, each of size elem_size. */

diff --git a/filter.c b/filter.c
index 787b4988ec6a4bf16a20cb03e3b4cce9ec3453bb..7a93a4efc92c7d280ff21f8c0147e092019b13a6 100644 (file)
--- a/filter.c
+++ b/filter.c
@@ -36,14 +36,15 @@
 /** global chain. */
 struct filter *output_chain = NULL;
 
-/* Allocate and initialize a filter.
+/* 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 (struct filter *chain, const char *cmd, ...)
+struct filter *filter_create_ext (struct filter *chain, const char *cmd,
+                                 ...)
 {
        struct filter *f;
        int     max_args;
@@ -53,6 +54,8 @@ struct filter *filter_create (struct filter *chain, const char *cmd, ...)
        /* allocate and initialize new filter */
        f = (struct filter *) flex_alloc (sizeof (struct filter));
        memset (f, 0, sizeof (*f));
+       f->filter_func = NULL;
+       f->extra = NULL;
        f->next = NULL;
        f->argc = 0;
 
@@ -90,6 +93,39 @@ struct filter *filter_create (struct filter *chain, const char *cmd, ...)
        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 = (struct filter *) flex_alloc (sizeof (struct filter));
+       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.
@@ -119,9 +155,24 @@ bool filter_apply_chain (struct filter * chain)
                if ((stdin = fdopen (0, "r")) == NULL)
                        flexfatal (_("fdopen(0) failed"));
 
+        /* recursively apply rest of chain. */
                filter_apply_chain (chain->next);
-               execvp (chain->argv[0], (char **const) (chain->argv));
-               flexfatal (_("exec failed"));
+
+        /* run this filter, either internally or by execvp */
+        if  (chain->filter_func){
+            int r = chain->filter_func(chain);
+            if (r == -1)
+                flexfatal (_("filter_func failed"));
+            else{
+                close(0);
+                close(1);
+                exit(0);
+            }
+        }
+        else{
+            execvp (chain->argv[0], (char **const) (chain->argv));
+            flexfatal (_("exec failed"));
+        }
                exit (1);
        }
 
@@ -157,4 +208,21 @@ int filter_truncate (struct filter *chain, int max_len)
        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.
+ */
+int filter_tee (struct filter *chain)
+{
+    const int readsz = 512;
+    char * buf;
+    
+    buf = (char*)flex_alloc(readsz);
+    header_out = fopen (headerfilename, "w");
+    
+    execlp("cat","cat",NULL);
+
+    return 0;
+}
+
 /* vim:set expandtab cindent tabstop=4 softtabstop=4 shiftwidth=4 textwidth=0: */

diff --git a/flexdef.h b/flexdef.h
index 4cbcdf86d2fd6bb6bd8d78e4af390ae2507cc2da..f7aa8d4b130fd164b91c501e98f93b7377ac0854 100644 (file)
--- a/flexdef.h
+++ b/flexdef.h
@@ -1140,28 +1140,25 @@ bool range_covers_case (int c1, int c2);
 /*
  *  From "filter.c"
  */
+
+/** A single stdio filter to execute.
+ *  The filter may be external, such as "sed", or it
+ *  may be internal, as a function call.
+ */
 struct filter {
-       int     argc;
-       const char ** argv;
-    struct filter * next;
+    int    (*filter_func)(struct filter*); /**< internal filter function */
+    void * extra;         /**< extra data passed to filter_func */
+       int     argc;         /**< arg count */
+       const char ** argv;   /**< arg vector, \0-terminated */
+    struct filter * next; /**< next filter or NULL */
 };
 
 /* output filter chain */
 extern struct filter * output_chain;
-
-/* Allocate and initialize a 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
- */
-extern struct filter *filter_create PROTO((struct filter * chain, const char *cmd, ...));
-
-/* Fork and exec entire filter chain.
- *  @param chain The head of the chain.
- * @return true on success.
- */
+extern struct filter *filter_create_ext PROTO((struct filter * chain, const char *cmd, ...));
+struct filter *filter_create_int PROTO((struct filter *chain,
+                                 int (*filter_func) (struct filter *),
+                  void *extra));
 extern bool filter_apply_chain PROTO((struct filter * chain));
 extern int filter_truncate (struct filter * chain, int max_len);
 

diff --git a/main.c b/main.c
index b5474487672152fd955b8946c161596ed684563c..1c2b787068947ec21790925003ff4a2f78921299 100644 (file)
--- a/main.c
+++ b/main.c
@@ -341,8 +341,8 @@ void check_options ()
        }
 
     /* Setup the filter chain. */
-    output_chain = filter_create(NULL,"m4","-P",0);
-    /* filter_create(output_chain,"cat",0); */
+    output_chain = filter_create_int(NULL, filter_tee, headerfilename);
+    filter_create_ext(output_chain,"m4","-P",0);
 
     /* For debugging, only run the requested number of filters. */
     if (preproc_level > 0) {

diff --git a/misc.c b/misc.c
index e3ad77702b8cee5cbc6956e58b503df6e0531094..3af602a008e639d603d1d9df8c010fb96625096a 100644 (file)
--- a/misc.c
+++ b/misc.c
@@ -118,7 +118,6 @@ void action_define (defname, value)
 void action_m4_define (const char *defname, const char * value)
 {
        char    buf[MAXLINE];
-       char   *cpy;
 
     flexfatal ("DO NOT USE THIS FUNCTION!");