preproc.c

CC386 is a general-purpose 32-bit C compiler. It is not an optimizing compiler but given that the co

        return incldepth == 0;
    }
    if ((spo = basesearch(unmangid, &defsyms, 0)) != 0)
        undef2();

    ++global_flag; /* always do #define as globals */
    sp = makesym(sc_static);
    sp->name = litlate(unmangid);
    def = xalloc(sizeof(DEFSTRUCT));
    def->args = 0;
    def->argcount = 0;
    if (lastch == '(')
    {
        int gotcomma=FALSE,nullargs=TRUE;
        getdefsym();
        getdefsym();
        while (lastst == id)
        {
            int j;
            char buf[256];
            gotcomma = FALSE;
            nullargs = FALSE;
            args[count++] = plitlate(unmangid);
            for (j=0; j < count-1; j++)
                if (!pstrcmp(args[count-1],args[j])) {
                    for (j=0; j < pstrlen(unmangid); j++)
                        buf[j] = ((short *)unmangid)[j] ;
                    buf[j] = 0 ;
                    gensymerror(ERR_DUPSYM,buf) ;
                    break ;
                }
            getdefsym();
            if (lastst != comma)
                break;
            gotcomma = TRUE;
            getdefsym();
        }
        if (prm_c99 && lastst == ellipse && (gotcomma || nullargs)) 
        {
            def->flags |= DS_VARARGS;
            gotcomma = FALSE;
            getsym();
        }
        if (lastst != closepa || gotcomma)
            generror(ERR_PUNCT, closepa, 0);
        olptr = lptr - 1;
        def->args = xalloc(count *sizeof(short*));
        memcpy(def->args, args, count *sizeof(short*));
        def->argcount = count + 1;
    }
    while (isspace(*olptr))
        olptr++;
    p = pstrlen(olptr);
    if (olptr[p - 1] == '\n')
        olptr[--p] = 0;
    for (i=0,j=0; i < p+1; i++,j++)
        if (olptr[i]=='#' && olptr[i+1] == '#') {
            olptr[j] = REPLACED_TOKENIZING;
            i++;
        } else
            olptr[j] = olptr[i];
    def->string = plitlate(olptr);
    sp->value.s = (char*)def;
    if (spo)
    {
        int same = TRUE;
        DEFSTRUCT *odef = (DEFSTRUCT*)spo->value.s;
        if (def->argcount != odef->argcount)
            same = FALSE;
        else
        {
            int i;
            short *p, *q;
            for (i = 0; i < def->argcount - 1 && same; i++)
                if (pstrcmp(def->args[i], odef->args[i]))
                    same = FALSE;
            p = def->string;
            q = odef->string;
            while (*p && *q) {
                if (isspace(*p))
                    if (isspace(*q)) {
                        while (isspace(*p)) p++;
                        while (isspace(*q)) q++;
                    } else {
                        break ;
                    }
                else
                    if (isspace(*q)) {
                        break ;
                    }
                    else if (*p++ != *q++)
                        break ;
            }
            if (*p || *q)
                same = FALSE;
        }
        if (!same) {
            char buf[256],*p=buf;
            if (prm_cmangle)
                *p++ = '_';
            strcpy(p,sp->name);
            gensymerror(ERR_REDEFINE, buf);
        }
    }
    insert(sp, &defsyms);
    --global_flag;
    browse_define(unmangid, defline);
    return incldepth == 0;
}

/*
 * Undefine
 */
int doundef(void)
{
    getch();
    while (isspace(lastch))
        getch();
    if (!isstartchar(lastch))
    {
        generror(ERR_IDEXPECT, 0, 0);
        return incldepth == 0;
    }
    else
        getid();
    if (!ifskip)
        undef2();
    return (incldepth == 0);
}

//-------------------------------------------------------------------------

int undef2(void)
{
    if (lastst != id)
        generror(ERR_IDEXPECT, 0, 0);
    else
    {
        SYM **p = (SYM **)LookupHash(unmangid, defhash, HASHTABLESIZE);
        if (p)
        {
            *p = (*p)->next;
        }
    }
}

//-------------------------------------------------------------------------

void getdefsym(void)
{
    if (backupchar !=  - 1)
    {
        lastst = backupchar;
        backupchar =  - 1;
        return ;
    }
    restart:  /* we come back here after comments */
    while (isspace(lastch))
        getch();
    if (lastch ==  - 1)
        lastst = eof;
    else if (isdigit(lastch))
        getnum();
    else if (isstartchar(lastch))
    {
        lptr--;
        defid(unmangid, &lptr, 0);
        lastch =  *lptr++;
        lastst = id;
    }
    else if (getsym2())
        goto restart;
}

/* The next few functions support recursion blocking for macros.
 * Basicall a list of all active macros is kept and if a lookup would 
 * result in one of those macros, no replacement is done.
 */
void nodefines(void)
{
    definelistcount = 0;
}

//-------------------------------------------------------------------------

int indefine(SYM *sp)
{
    int i;
    for (i = 0; i < definelistcount; i++)
        if (sp == definelist[i])
            return TRUE;

    return FALSE;
}

//-------------------------------------------------------------------------

void enterdefine(SYM *sp)
{
    definelist[definelistcount++] = sp;
}

//-------------------------------------------------------------------------

void exitdefine(void)
{
    if (definelistcount)
        definelistcount--;
}

//-------------------------------------------------------------------------

int defid(short *name, short **p, char *q)
/*
 * Get an identifier during macro replacement
 */
{
    int count = 0, i = 0;
    while (issymchar(**p))
    {
            if (count < (prm_cmangle ? 99 : 100))
            {
                name[count++] = *(*p);
                if (q)
                    q[i++] = *(*p);
            }
        (*p)++;
    }
    if (q)
        q[count] = 0;
    name[count] = 0;
    return (count);
}

/* 
 * Insert a replacement string
 */
int definsert(short *macro, short *end, short *begin, short *text, int len, int replen)
{
    short *q;
    int i, p, r;
    int val;
    p = pstrlen(text);
    val = p - replen;
    r = pstrlen(begin);
    if (val + r + 1 >= len)
    {
        generror(ERR_MACROSUBS, 0, 0);
        return (INT_MIN);
    }
    if (val > 0)
        for (q = begin + r + 1; q >= end; q--)
            *(q + val) =  *q;
    else
        if (val < 0)
        {
            r = pstrlen(end) + 1;
            for (q = end; q < end + r; q++)
                    *(q + val) =  *q;
        }
    for (i = 0; i < p; i++)
        begin[i] = text[i];
    return (p);
}
int defstringize(short *macro, short *end, short *begin, short *text, int len, int replen)
{
    int count = 0;
    while (begin != macro && isspace(*(begin-1)))
        begin--,count++ ;
    if (begin != macro && *(begin-1) == '#') 
    {
        short replmac[MACRO_REPLACE_SIZE];
        int r = pstrlen(text),j=0,i;
        replmac[j++] = L'"';
        for (i=0; i < r; i++) 
        {
            if (text[i] == L'\\' || text[i] == L'"')
                replmac[j++] = L'\\';
            replmac[j++] = text[i];
        }
        replmac[j++] = L'"' ;
        replmac[j] = 0;
        return definsert(macro,end,begin-1,replmac,len,end - begin + 1) - count - 1;
    }
    return MACRO_REPLACE_SIZE;
}
/* replace macro args */
int defreplaceargs(short *macro, int count, short **oldargs, short **newargs, short *varargs)
{
    int i, rv;
    int instring = 0;
    short name[256];
    short *p = macro,  *q;
    while (*p)
    {
        if (instring && *p == instring && *(p - 1) != '\\')
        {
            instring = 0;
        }
        else if (!instring && (*p == '\'' ||  *p == '"') 
            && (p == macro || *(p - 1) != '\\' || *(p - 2) == '\\'))
        {
            instring =  *p;
        }
        else if (!instring && isstartchar(*p))
        {
            short *r = p;
            q = p;
            defid(name, &p, 0);
            r = macro;
            if (prm_c99 && !pstrcmp(name,L"__VA_ARGS__")) 
            {
                if (!varargs[0]) {
                    gensymerror(ERR_WRONGMACROARGS,"___VA_ARGS__");
                }
                else
                {
                    rv = defstringize(macro,p,q,varargs, MACRO_REPLACE_SIZE - (q - macro), p-q);
                    if (rv < - MACRO_REPLACE_SIZE)
                        return rv;

                    if (rv == MACRO_REPLACE_SIZE) 
                    {
                        if ((rv = definsert(macro, p, q, varargs, MACRO_REPLACE_SIZE-(q - macro), p - q))
                                < -MACRO_REPLACE_SIZE)
                            return (FALSE);
                        else
                            p = q + rv;
                    } else
                        p = q + rv ;
                }
            }
            else for (i = 0; i < count; i++) 
            {
                static short ph[] = {TOKENIZING_PLACEHOLDER,0};
                if (!pstrcmp(name, oldargs[i]))
                {
                    rv = defstringize(macro,p,q,newargs[i], MACRO_REPLACE_SIZE - (q - macro), p-q);
                    if (rv < - MACRO_REPLACE_SIZE)
                        return rv;

                    if (rv == MACRO_REPLACE_SIZE) 
                    {
                        if (pstrlen(newargs[i]) == 0) 
                        {
                            char *r = q;
                            while (r != macro && isspace(*(r-1)))
                                r--;
                            if (r != macro && *(r-1) == REPLACED_TOKENIZING)
                                if ((rv = definsert( macro,p,q, ph+1, MACRO_REPLACE_SIZE-(q - macro), p - q))  < - MACRO_REPLACE_SIZE)
                                    return INT_MIN ;
                                else 
                                {
                                    p = q + rv ;
                                    break ;
                                }
                            else 
                            {
                                char *r = p;
                                while (*r && isspace(*r))
                                    r++;
                                if (*r && *r == REPLACED_TOKENIZING)
                                    if ((rv = definsert( macro, p, q, ph+1, MACRO_REPLACE_SIZE-(q - macro), p - q)) < - MACRO_REPLACE_SIZE)
                                        return rv ;
                                    else 
                                    {
                                        p = q + rv ;
                                        break ;
                                    }
                            }
                        }                        
                        if ((rv = definsert(macro, p, q, newargs[i], MACRO_REPLACE_SIZE-(q - macro), p - q)) 
                            < - MACRO_REPLACE_SIZE)
                            return (FALSE);
                        else
                        {
                            p = q + rv;
                            break;
                        }
                    } 
                    else 
                    {
                        p = q + rv;
                        break;
                    }
                }
            }
        }
        if (*p)
            p++;
    }
    return (TRUE);
}
void deftokenizing(short *macro)
{
    int i, rv;
    int instring = 0;
    short *p = macro,  *q;
    while (*p)
    {
        if (*p == instring && *(p - 1) != '\\')
        {
            instring = 0;
        }
        else if ((*p == '\'' ||  *p == '"') 
            && (p == macro || *(p - 1) != '\\' || *(p - 2) == '\\'))
        {
            instring =  *p;
        }
        else if (!instring && *p == REPLACED_TOKENIZING)
        {
            short *b =p, *e = p ;
            while (b != macro && isspace(*(b-1)))
                b-- ;
            while (*++e != 0 && isspace(*e)) ;
            if (b != macro && b[-1] == TOKENIZING_PLACEHOLDER)
                b--;
            if (*e == TOKENIZING_PLACEHOLDER)
                if (*b != TOKENIZING_PLACEHOLDER)
                    e++;
            p = macro;
            while (*e)
                *b++ = *e++;
            *b = 0;
        }
        if (*p)
            p++;
    }
    p = q = macro;
    while (*p) 
    {
        if (*p == TOKENIZING_PLACEHOLDER || *p == REPLACED_TOKENIZING)
            p++;
        else 
            *q++ = *p++;
    }
    *q = 0;
}

/* Handlers for default macros */
void cnvt(short *out, char *in)
{
    while (*in)
        *out++ =  *in++;
    *out = 0;
}

//-------------------------------------------------------------------------

char *fullqualify(char *string)
{
    static char buf[265];
    if (string[1] != ':')
    {
        char *p,  *q = string;
        getcwd(buf, 265);
        p = buf + strlen(buf);
        while (!strncmp(q, "..\\", 3))
        {
            q += 3;
            while (p > buf &&  *p != '\\')
                p--;
        }
        *p++ = '\\';
        strcpy(p, q);
        return buf;
    }
    return string;
}