source: trunk/tools/wrc/preproc.c@ 3459

/*
 * Copyright 1998 Bertho A. Stultiens (BS)
 *
 */

#include "config.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.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];

#define MAXIFSTACK      64
static struct if_state ifstack[MAXIFSTACK];
static int ifstackidx = 0;

#if 0
void pp_status(void)
{
        int i;
        int sum;
        int total = 0;
        struct pp_entry *ppp;

        printf("Defines statistics:\n");
        for(i = 0; i < HASHKEY; i++)
        {
                sum = 0;
                for(ppp = pp_defines[i]; ppp; ppp = ppp->next)
                        sum++;
                total += sum;
                printf("%4d, %3d\n", i, sum);
        }
        printf("Total defines: %d\n", total);
}
#pragma exit pp_status
#endif

/* Don't comment on the hash, its primitive but functional... */
int pp_hash(char *str)
{
        int sum = 0;
        while(*str)
                sum += *str++;
        return sum % HASHKEY;
}

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)
        {
                if(!strcmp(ident, ppp->ident))
                        return ppp;
        }
        return NULL;
}

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)
        {
                if(pedantic)
                        yywarning("%s was not defined", name);
                return;
        }

        index = pp_hash(name);
        if(pp_defines[index] == ppp)
        {
                pp_defines[index] = ppp->next;
                if(pp_defines[index])
                        pp_defines[index]->prev = NULL;
        }
        else
        {
                ppp->prev->next = ppp->next;
                if(ppp->next)
                        ppp->next->prev = ppp->prev;
        }
        free(ppp);
}

void add_define(char *text)
{
        int len;
        char *cptr;
        int index = pp_hash(current_define);
        struct pp_entry *ppp;
        if(pp_lookup(current_define) != 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;
        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(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)
{
        char *cpy = xstrdup(set);       /* Because gcc passes a R/O string */
        char *cptr = strchr(cpy, '=');
        if(cptr)
                *cptr = '\0';
        set_define(cpy);
        add_define(cptr ? cptr+1 : "");
        free(cpy);
}

#if defined(_Windows) || defined(__MSDOS__) || defined(__WIN32OS2__)
#define INCLUDESEPARATOR        ";"
#else
#define INCLUDESEPARATOR        ":"
#endif

static char **includepath;
static int nincludepath = 0;

void add_include_path(char *path)
{
        char *tok;
        char *cpy = xstrdup(path);

        tok = strtok(cpy, INCLUDESEPARATOR);
        while(tok)
        {
                char *dir;
                char *cptr;
                if(strlen(tok) == 0)
                        continue;
                dir = xstrdup(tok);
                for(cptr = dir; *cptr; cptr++)
                {
                        /* Convert to forward slash */
                        if(*cptr == '\\')
                                *cptr = '/';
                }
                /* Kill eventual trailing '/' */
                if(*(cptr = dir + strlen(dir)-1) == '/')
                        *cptr = '\0';

                /* Add to list */
                nincludepath++;
                includepath = (char **)xrealloc(includepath, nincludepath * sizeof(*includepath));
                includepath[nincludepath-1] = dir;
                tok = strtok(NULL, INCLUDESEPARATOR);
        }
        free(cpy);
}

FILE *open_include(const char *name, int search)
{
        char *cpy = xstrdup(name);
        char *cptr;
        FILE *fp;
        int i;

        for(cptr = cpy; *cptr; cptr++)
        {
                /* kill double backslash */
                if(*cptr == '\\' && *(cptr+1) == '\\')
                        memmove(cptr, cptr+1, strlen(cptr));
                /* Convert to forward slash */
                if(*cptr == '\\')
                        *cptr = '/';
        }

        if(search)
        {
                /* Search current dir and then -I path */
                fp = fopen(name, "rt");
                if(fp)
                {
                        if(yydebug)
                                printf("Going to include <%s>\n", name);
                        free(cpy);
                        return fp;
                }
        }
        /* Search -I path */
        for(i = 0; i < nincludepath; i++)
        {
                char *path;
                path = (char *)xmalloc(strlen(includepath[i]) + strlen(cpy) + 2);
                strcpy(path, includepath[i]);
                strcat(path, "/");
                strcat(path, cpy);
                fp = fopen(path, "rt");
                if(fp && yydebug)
                        printf("Going to include <%s>\n", path);
                free(path);
                if(fp)
                {
                        free(cpy);
                        return fp;
                }

        }
        free(cpy);
        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;
}