Changeset 5522 for trunk/tools/wrc/preproc.c

Timestamp:

Apr 16, 2001, 7:11:03 PM (24 years ago)

Author:

sandervl

Message:

updates

File:

• trunk/tools/wrc/preproc.c (modified) (11 diffs)

trunk/tools/wrc/preproc.c

@@ -9 +9 @@
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #include "wrc.h"
 #include "utils.h"
 #include "preproc.h"
-#include "parser.h"
 
 
 extern void set_pp_ignore(int); /* From parser.l */
 
-static char *current_define;
-
 #define HASHKEY         2039
-static struct pp_entry *pp_defines[HASHKEY];
+static pp_entry_t *pp_defines[HASHKEY];
 
 #define MAXIFSTACK      64
-static struct if_state ifstack[MAXIFSTACK];
-static int ifstackidx = 0;
+static if_state_t if_stack[MAXIFSTACK];
+static int if_stack_idx = 0;
 
 #if 0
+void pp_status(void) __attribute__((destructor));
 void pp_status(void)
 {
@@ -33 +32 @@
         int sum;
         int total = 0;
-        struct pp_entry *ppp;
-
-        printf("Defines statistics:\n");
+        pp_entry_t *ppp;
+
+        fprintf(stderr, "Defines statistics:\n");
         for(i = 0; i < HASHKEY; i++)
         {
@@ -42 +41 @@
                         sum++;
                 total += sum;
-                printf("%4d, %3d\n", i, sum);
-        }
-        printf("Total defines: %d\n", total);
-}
-#pragma exit pp_status
+                fprintf(stderr, "%4d, %3d\n", i, sum);
+        }
+        fprintf(stderr, "Total defines: %d\n", total);
+}
 #endif
 
 /* Don't comment on the hash, its primitive but functional... */
-int pp_hash(char *str)
+int pphash(char *str)
 {
         int sum = 0;
@@ -58 +56 @@
 }
 
-struct pp_entry *pp_lookup(char *ident)
-{
-        int index = pp_hash(ident);
-        struct pp_entry *ppp;
-        for(ppp = pp_defines[index]; ppp; ppp = ppp->next)
+pp_entry_t *pplookup(char *ident)
+{
+        int idx = pphash(ident);
+        pp_entry_t *ppp;
+
+        for(ppp = pp_defines[idx]; ppp; ppp = ppp->next)
         {
                 if(!strcmp(ident, ppp->ident))
@@ -70 +69 @@
 }
 
-void set_define(char *name)
-{
-        current_define = xstrdup(name);
-}
-
 void del_define(char *name)
 {
-        int index;
-        struct pp_entry *ppp;
-
-        if((ppp = pp_lookup(name)) == NULL)
+        int idx;
+        pp_entry_t *ppp;
+
+        if((ppp = pplookup(name)) == NULL)
         {
                 if(pedantic)
@@ -87 +81 @@
         }
 
-        index = pp_hash(name);
-        if(pp_defines[index] == ppp)
-        {
-                pp_defines[index] = ppp->next;
-                if(pp_defines[index])
-                        pp_defines[index]->prev = NULL;
+        if(ppp->iep)
+        {
+                if(debuglevel & DEBUGLEVEL_PPMSG)
+                        fprintf(stderr, "del_define: %s:%d: includelogic removed, include_ppp='%s', file=%s\n", input_name, line_number, name, ppp->iep->filename);
+                if(ppp->iep == includelogiclist)
+                {
+                        includelogiclist = ppp->iep->next;
+                        if(includelogiclist)
+                                includelogiclist->prev = NULL;
+                }
+                else
+                {
+                        ppp->iep->prev->next = ppp->iep->next;
+                        if(ppp->iep->next)
+                                ppp->iep->next->prev = ppp->iep->prev;
+                }
+                free(ppp->iep->filename);
+                free(ppp->iep);
+        }
+
+        idx = pphash(name);
+        if(pp_defines[idx] == ppp)
+        {
+                pp_defines[idx] = ppp->next;
+                if(pp_defines[idx])
+                        pp_defines[idx]->prev = NULL;
         }
         else
@@ -100 +114 @@
                         ppp->next->prev = ppp->prev;
         }
+
         free(ppp);
-}
-
-void add_define(char *text)
+
+        if(debuglevel & DEBUGLEVEL_PPMSG)
+                printf("Deleted (%s, %d) <%s>\n", input_name, line_number, name);
+}
+
+pp_entry_t *add_define(char *def, char *text)
 {
         int len;
         char *cptr;
-        int index = pp_hash(current_define);
-        struct pp_entry *ppp;
-        if(pp_lookup(current_define) != NULL)
+        int idx = pphash(def);
+        pp_entry_t *ppp;
+
+        if((ppp = pplookup(def)) != NULL)
         {
                 if(pedantic)
-                        yywarning("Redefinition of %s", current_define);
-                del_define(current_define);
-        }
-        ppp = (struct pp_entry *)xmalloc(sizeof(struct pp_entry));
-        ppp->ident = current_define;
-        ppp->subst = xstrdup(text);
-        ppp->next = pp_defines[index];
-        pp_defines[index] = ppp;
+                        yywarning("Redefinition of %s\n\tPrevious definition: %s:%d", def, ppp->filename, ppp->linenumber);
+                del_define(def);
+        }
+        ppp = (pp_entry_t *)xmalloc(sizeof(pp_entry_t));
+        ppp->ident = def;
+        ppp->type = def_define;
+        ppp->subst.text = text;
+        ppp->filename = input_name ? xstrdup(input_name) : "<internal or cmdline>";
+        ppp->linenumber = input_name ? line_number : 0;
+        ppp->next = pp_defines[idx];
+        pp_defines[idx] = ppp;
         if(ppp->next)
                 ppp->next->prev = ppp;
-        /* Strip trailing white space from subst text */
-        len = strlen(ppp->subst);
-        while(len && strchr(" \t\r\n", ppp->subst[len-1]))
-        {
-                ppp->subst[--len] = '\0';
-        }
-        /* Strip leading white space from subst text */
-        for(cptr = ppp->subst; *cptr && strchr(" \t\r", *cptr); cptr++)
+        if(text)
+        {
+                /* Strip trailing white space from subst text */
+                len = strlen(text);
+                while(len && strchr(" \t\r\n", text[len-1]))
+                {
+                        text[--len] = '\0';
+                }
+                /* Strip leading white space from subst text */
+                for(cptr = text; *cptr && strchr(" \t\r", *cptr); cptr++)
                 ;
-        if(ppp->subst != cptr)
-                memmove(ppp->subst, cptr, strlen(cptr)+1);
-        if(yydebug)
-                printf("Added (%s, %d) <%s> to <%s>\n", input_name, line_number, ppp->ident, ppp->subst);
-}
-
-void add_cmdline_define(char *set)
+                if(text != cptr)
+                        memmove(text, cptr, strlen(cptr)+1);
+        }
+        if(debuglevel & DEBUGLEVEL_PPMSG)
+                printf("Added define (%s, %d) <%s> to <%s>\n", input_name, line_number, ppp->ident, text ? text : "(null)");
+
+        return ppp;
+}
+
+pp_entry_t *add_cmdline_define(char *set)
 {
         char *cpy = xstrdup(set);       /* Because gcc passes a R/O string */
@@ -143 +170 @@
         if(cptr)
                 *cptr = '\0';
-        set_define(cpy);
-        add_define(cptr ? cptr+1 : "");
-        free(cpy);
-}
-
-/*kso added test for __SEMICOLON__ since __WIN32OS2__ isn't defined! */
-#if defined(__SEMICOLON__) || defined(_Windows) || defined(__MSDOS__) || defined(__WIN32OS2__)
+        return add_define(cpy, xstrdup(cptr ? cptr+1 : ""));
+}
+
+pp_entry_t *add_special_define(char *id)
+{
+        pp_entry_t *ppp = add_define(xstrdup(id), xstrdup(""));
+        ppp->type = def_special;
+        return ppp;
+}
+
+pp_entry_t *add_macro(char *id, marg_t *args[], int nargs, mtext_t *exp)
+{
+        int idx = pphash(id);
+        pp_entry_t *ppp;
+
+        if((ppp = pplookup(id)) != NULL)
+        {
+                if(pedantic)
+                        yywarning("Redefinition of %s\n\tPrevious definition: %s:%d", id, ppp->filename, ppp->linenumber);
+                del_define(id);
+        }
+        ppp = (pp_entry_t *)xmalloc(sizeof(pp_entry_t));
+        ppp->ident      = id;
+        ppp->type       = def_macro;
+        ppp->margs      = args;
+        ppp->nargs      = nargs;
+        ppp->subst.mtext= exp;
+        ppp->filename = input_name ? xstrdup(input_name) : "<internal or cmdline>";
+        ppp->linenumber = input_name ? line_number : 0;
+        ppp->next       = pp_defines[idx];
+        pp_defines[idx] = ppp;
+        if(ppp->next)
+                ppp->next->prev = ppp;
+
+        if(debuglevel & DEBUGLEVEL_PPMSG)
+        {
+                fprintf(stderr, "Added macro (%s, %d) <%s(%d)> to <", input_name, line_number, ppp->ident, nargs);
+                for(; exp; exp = exp->next)
+                {
+                        switch(exp->type)
+                        {
+                        case exp_text:
+                                fprintf(stderr, " \"%s\" ", exp->subst.text);
+                                break;
+                        case exp_stringize:
+                                fprintf(stderr, " #(%d) ", exp->subst.argidx);
+                                break;
+                        case exp_concat:
+                                fprintf(stderr, "##");
+                                break;
+                        case exp_subst:
+                                fprintf(stderr, " <%d> ", exp->subst.argidx);
+                                break;
+                        }
+                }
+                fprintf(stderr, ">\n");
+        }
+        return ppp;
+}
+
+
+/*
+ *-------------------------------------------------------------------------
+ * Include management
+ *-------------------------------------------------------------------------
+ */
+#if defined(_Windows) || defined(__MSDOS__)
 #define INCLUDESEPARATOR        ";"
-#warning "Using ; as include separator"
 #else
-#warning "Using : as include separator"
 #define INCLUDESEPARATOR        ":"
 #endif
@@ -192 +277 @@
 }
 
-FILE *open_include(const char *name, int search)
+FILE *open_include(const char *name, int search, char **newpath)
 {
         char *cpy = xstrdup(name);
@@ -212 +297 @@
         {
                 /* Search current dir and then -I path */
-                fp = fopen(name, "rt");
+                fp = fopen(cpy, "rb");
                 if(fp)
                 {
-                        if(yydebug)
+                        if(debuglevel & DEBUGLEVEL_PPMSG)
                                 printf("Going to include <%s>\n", name);
-                        free(cpy);
+                        if(newpath)
+                                *newpath = cpy;
+                        else
+                                free(cpy);
                         return fp;
                 }
@@ -229 +317 @@
                 strcat(path, "/");
                 strcat(path, cpy);
-                fp = fopen(path, "rt");
-                if(fp && yydebug)
+                fp = fopen(path, "rb");
+                if(fp && (debuglevel & DEBUGLEVEL_PPMSG))
                         printf("Going to include <%s>\n", path);
-                free(path);
                 if(fp)
                 {
+                        if(newpath)
+                                *newpath = path;
+                        else
+                                free(path);
                         free(cpy);
                         return fp;
                 }
-
+                free(path);
         }
         free(cpy);
+        if(newpath)
+                *newpath = NULL;
         return NULL;
 }
 
-void push_if(int truecase, int wastrue, int nevertrue)
-{
-        if(ifstackidx >= MAXIFSTACK-1)
-                internal_error(__FILE__, __LINE__, "#if stack overflow");
-        ifstack[ifstackidx].current = truecase && !wastrue;
-        ifstack[ifstackidx].hasbeentrue = wastrue;
-        ifstack[ifstackidx].nevertrue = nevertrue;
-        if(nevertrue || !(truecase && !wastrue))
-                set_pp_ignore(1);
-        if(yydebug)
-                printf("push_if: %d %d %d (%d %d %d)\n",
-                        truecase,
-                        wastrue,
-                        nevertrue,
-                        ifstack[ifstackidx].current,
-                        ifstack[ifstackidx].hasbeentrue,
-                        ifstack[ifstackidx].nevertrue);
-        ifstackidx++;
-}
-
-int pop_if(void)
-{
-        if(ifstackidx <= 0)
-                yyerror("#endif without #if|#ifdef|#ifndef (#if stack underflow)");
-        ifstackidx--;
-        if(yydebug)
-                printf("pop_if: %d %d %d\n",
-                        ifstack[ifstackidx].current,
-                        ifstack[ifstackidx].hasbeentrue,
-                        ifstack[ifstackidx].nevertrue);
-        if(ifstack[ifstackidx].nevertrue || !ifstack[ifstackidx].current)
-                set_pp_ignore(0);
-        return ifstack[ifstackidx].hasbeentrue || ifstack[ifstackidx].current;
-}
-
-int isnevertrue_if(void)
-{
-        return ifstackidx > 0 && ifstack[ifstackidx-1].nevertrue;
-}
-
+/*
+ *-------------------------------------------------------------------------
+ * #if, #ifdef, #ifndef, #else, #elif and #endif state management
+ *
+ * #if state transitions are made on basis of the current TOS and the next
+ * required state. The state transitions are required to housekeep because
+ * #if:s can be nested. The ignore case is activated to prevent output from
+ * within a false clause.
+ * Some special cases come from the fact that the #elif cases are not
+ * binary, but three-state. The problem is that all other elif-cases must
+ * be false when one true one has been found. A second problem is that the
+ * #else clause is a final clause. No extra #else:s may follow.
+ *
+ * The states mean:
+ * if_true      Process input to output
+ * if_false     Process input but no output
+ * if_ignore    Process input but no output
+ * if_elif      Process input but no output
+ * if_elsefalse Process input but no output
+ * if_elsettrue Process input to output
+ *
+ * The possible state-sequences are [state(stack depth)] (rest can be deduced):
+ *      TOS             #if 1           #else                   #endif
+ *      if_true(n)      if_true(n+1)    if_elsefalse(n+1)
+ *      if_false(n)     if_ignore(n+1)  if_ignore(n+1)
+ *      if_elsetrue(n)  if_true(n+1)    if_elsefalse(n+1)
+ *      if_elsefalse(n) if_ignore(n+1)  if_ignore(n+1)
+ *      if_elif(n)      if_ignore(n+1)  if_ignore(n+1)
+ *      if_ignore(n)    if_ignore(n+1)  if_ignore(n+1)
+ *
+ *      TOS             #if 1           #elif 0         #else           #endif
+ *      if_true(n)      if_true(n+1)    if_elif(n+1)    if_elif(n+1)
+ *      if_false(n)     if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *      if_elsetrue(n)  if_true(n+1)    if_elif(n+1)    if_elif(n+1)
+ *      if_elsefalse(n) if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *      if_elif(n)      if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *      if_ignore(n)    if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *
+ *      TOS             #if 0           #elif 1         #else           #endif
+ *      if_true(n)      if_false(n+1)   if_true(n+1)    if_elsefalse(n+1)
+ *      if_false(n)     if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *      if_elsetrue(n)  if_false(n+1)   if_true(n+1)    if_elsefalse(n+1)
+ *      if_elsefalse(n) if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *      if_elif(n)      if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *      if_ignore(n)    if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *
+ *-------------------------------------------------------------------------
+ */
+static char *if_state_str[] = {
+        "if_false",
+        "if_true",
+        "if_elif",
+        "if_elsefalse",
+        "if_elsetrue",
+        "if_ignore"
+};
+
+void push_if(if_state_t s)
+{
+        if(if_stack_idx >= MAXIFSTACK)
+                internal_error(__FILE__, __LINE__, "#if-stack overflow; #{if,ifdef,ifndef} nested too deeply (> %d)", MAXIFSTACK);
+
+        if(debuglevel & DEBUGLEVEL_PPLEX)
+                fprintf(stderr, "Push if %s:%d: %s(%d) -> %s(%d)\n", input_name, line_number, if_state_str[if_state()], if_stack_idx, if_state_str[s], if_stack_idx+1);
+
+        if_stack[if_stack_idx++] = s;
+
+        switch(s)
+        {
+        case if_true:
+        case if_elsetrue:
+                break;
+        case if_false:
+        case if_elsefalse:
+        case if_elif:
+        case if_ignore:
+                push_ignore_state();
+                break;
+        }
+}
+
+if_state_t pop_if(void)
+{
+        if(if_stack_idx <= 0)
+                yyerror("#{endif,else,elif} without #{if,ifdef,ifndef} (#if-stack underflow)");
+
+        switch(if_state())
+        {
+        case if_true:
+        case if_elsetrue:
+                break;
+        case if_false:
+        case if_elsefalse:
+        case if_elif:
+        case if_ignore:
+                pop_ignore_state();
+                break;
+        }
+
+        if(debuglevel & DEBUGLEVEL_PPLEX)
+                fprintf(stderr, "Pop if %s:%d: %s(%d) -> %s(%d)\n",
+                                input_name,
+                                line_number,
+                                if_state_str[if_state()],
+                                if_stack_idx,
+                                if_state_str[if_stack[if_stack_idx <= 1 ? if_true : if_stack_idx-2]],
+                                if_stack_idx-1);
+
+        return if_stack[--if_stack_idx];
+}
+
+if_state_t if_state(void)
+{
+        if(!if_stack_idx)
+                return if_true;
+        else
+                return if_stack[if_stack_idx-1];
+}
+
+
+void next_if_state(int i)
+{
+        switch(if_state())
+        {
+        case if_true:
+        case if_elsetrue:
+                push_if(i ? if_true : if_false);
+                break;
+        case if_false:
+        case if_elsefalse:
+        case if_elif:
+        case if_ignore:
+                push_if(if_ignore);
+                break;
+        default:
+                internal_error(__FILE__, __LINE__, "Invalid if_state (%d) in #{if,ifdef,ifndef} directive", (int)if_state());
+        }
+}
+
+int get_if_depth(void)
+{
+        return if_stack_idx;
+}
+