template.c

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

        if (nm)
            p = cpponearg(p, head);
        if (tplargs != (SYM*) - 1)
        {
            if (!tplargs)
                err |= 1;
            else
                tplargs = tplargs->next;
        }
        if (lastst != comma)
            break;
        getsym();
    }
    while (TRUE);
    needpunc(gt, 0);
    if (err)
        genclasserror(ERR_TEMPLATEEXTRAARG, nm);
    if (tplargs && tplargs != (SYM*) - 1)
    {
        while (tplargs && tplargs->defalt)
        {
            if (tail)
            {
                *tail = xalloc(sizeof(LIST));
                (*tail)->data = tplargs->defalt;
                tail = &(*tail)->link;
            }
            p = cpponearg(p, tplargs->tp);
            tplargs = tplargs->next;
        }
        if (tplargs)
            genclasserror(ERR_TEMPLATEFEWARG, nm);
    }
    if (nm)
    {
        *p++ = '#';
        *p = 0;
        manglenamecount =  - 1;
    }
    matching--;
}

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

TYP *InstantiateTemplateFuncDirect(ENODE **pnode, TYP *tptr)
{
    TYP *ohead = head,  *otail = tail,  **oheadptr = headptr;
    ENODE *tcnode = 0;
    int odflt = defaulttype;
    char mangname[512], mangname2[512];
    SYM *s;
    LIST *tn = 0,  **tntail = &tn;
    struct _templatelist *tl;
    ENODE *fep;
    TYP *ftp;
    if ((*pnode)->nodetype == en_thiscall)
    {
        tcnode =  *pnode;
        *pnode = (*pnode)->v.p[1];
    } if (*pnode && (*pnode)->nodetype != en_placeholder)
        return tptr;
    getsym();
    global_flag++;
    matchandmangle(0, 0, tntail, (SYM*) - 1);
    global_flag--;
    if (lastst != openpa)
    {
        generror(ERR_PUNCT, openpa, 0);
        return tptr;
    }
    getsym();
    ftp = gatherparms(&fep, FALSE);
    {
        char *p, intrnm[256],  *nm;
        int count;
        SYM *s1;
        LIST *t = tn,  *ot = 0,  **otn = &ot;
        strcpy(intrnm, tptr->sp->name);
        s = tptr->lst.head;
        for (count = 0; t; count++, t = t->link)
            ;
        while (s)
        {
            if (s->istemplate)
            {
                if (count == s->value.classdata.templatedata->tplargcount)
                {
                    t = tn;
                    s1 = s->value.classdata.templatedata->classes.head;
                    while (t)
                    {
                        if (s1->tp->type != bt_class)
                        {
                            if (!((TYP*)t->data)->sp || ((TYP*)t->data)->sp
                                ->storage_class != sc_tconst)
                                break;
                        }
                        else if (((TYP*)t->data)->sp && ((TYP*)t->data)->sp
                            ->storage_class == sc_tconst)
                            if (scalarnonfloat(((TYP*)t->data)) !=
                                scalarnonfloat(s1->tp) && isscalar(((TYP*)t
                                ->data)) != isscalar(s1->tp))
                                break;
                        t = t->link;
                        s1 = s1->next;
                    }
                    if (!t)
                        break;
                }
            }
            s = s->next;
        }
        if (!s)
        {
            gensymerror(ERR_AMBIGTEMPLATE, intrnm);
            return tptr;
        }
        t = tn;
        s1 = s->value.classdata.templatedata->classes.head;
        p = intrnm, nm = tptr->sp->name;
        if (*nm == '$')
            cpp_unmang_intrins(&p, &nm, tptr->sp->parentclass ? tptr->sp
                ->parentclass->name: 0);
        p += prm_cmangle && p[0] == '_';
        sprintf(mangname, "@#%s$t", p);
        p = mangname + strlen(mangname);
        manglenamecount = 0;
        while (t)
        {
            if (s1->tp->type != bt_class)
                ((TYP*)t->data)->type = s1->tp->type;
            p = cpponearg(p, t->data);
            t = t->link;
            s1 = s1->next;
        }
        *p++ = '#';
        *p = 0;
        strcpy(mangname2, mangname);
        p = mangname2 + strlen(mangname2);
        *p++ = '$';
        *p++ = 'q';
        manglenamecount = 0;
        p = cppargs(p, ftp->lst.head);
        *p = 0;
        manglenamecount =  - 1;
        tl = search(mangname2, (TABLE*)templateFuncs);
        if (!tl)
        {
            global_flag++;
            tl = xalloc(sizeof(struct _templatelist));
            tl->name = litlate(mangname2);
            tl->prefixname = litlate(mangname);
            tl->sp = s;
            s1 = s->value.classdata.templatedata->classes.head;
            while (s1)
            {
                *otn = xalloc(sizeof(LIST));
                (*otn)->data = s1->tp;
                otn = &(*otn)->link;
                s1 = s1->next;
            } tl->oldtypes = ot;
            tl->newtypes = tn;
            global_flag--;
        }
    }
    if (!tl->finalsp)
    {
        savecontext();
        if (tcnode)
            declclass = tcnode->v.p[0]->v.sp;
        virtualfuncs = 1;
        interjectptr = replace(tl, tl->sp->value.classdata.templatedata);
        setunaltered();
        templatePrefix = tl->prefixname;
        templateSP = tl->finalsp;
        errfile = tl->sp->value.classdata.templatedata->filename;
        infile = tl->sp->value.classdata.templatedata->filename;
        lineno = errlineno = tl->sp->value.classdata.templatedata->lineno;
        global_flag++;
        getch();
        getsym();
        dodecl(sc_global);
        global_flag--;
        restorecontext();
        templatePrefix = 0;
        templateSP = 0;
        tl->finalsp = lastfunc;
        tl->finalsp->isinsttemplate = TRUE;
        insert((SYM*)tl, templateFuncs);
    }
    defaulttype = odflt;
    head = ohead;
    tail = otail;
    headptr = oheadptr;
    *pnode = makenode(en_napccon, (void*)tl->finalsp, 0);
    tptr = tl->finalsp->tp;
    if (tcnode)
    {
        tcnode->v.p[1] =  *pnode;
        *pnode = tcnode;
    }
    *pnode = onefunc(*pnode, &tptr, fep, ftp);
    return tptr;
}

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

SYM *lookupTemplateFunc(SYM *tbsym, TYP *tp, char *name)
{
    struct _templatelist *val = search_template_func(tbsym, tp, tbsym->name);
    if (val && !val->finalsp)
    {
        savecontext();
        virtualfuncs = 1;
        interjectptr = replace(val, val->sp->value.classdata.templatedata);
        setunaltered();
        templatePrefix = val->prefixname;
        templateSP = val->finalsp;
        errfile = val->sp->value.classdata.templatedata->filename;
        infile = val->sp->value.classdata.templatedata->filename;
        lineno = errlineno = val->sp->value.classdata.templatedata->lineno;
        global_flag++;
        getch();
        getsym();
        dodecl(sc_global);
        global_flag--;
        restorecontext();
        templatePrefix = 0;
        templateSP = 0;
        val->finalsp = lastfunc;
        val->finalsp->isinsttemplate = TRUE;
        insert((SYM*)val, templateFuncs);
        return val->finalsp;
    } if (val)
        return val->finalsp;
    return 0;
}

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

void instantiateTemplateFuncs(SYM *tempsym, SYM *actual, LIST *tn, int recons)
{
    SYM *sp = tempsym->tp->lst.head;
    while (sp)
    {
        if (sp->storage_class == sc_defunc)
        {
            SYM *sp1 = sp->tp->lst.head;
            while (sp1)
            {
                if (sp1->value.classdata.templatedata)
                {
                    char unmangname[256],  *p;
                    int len, max;
                    LIST *to = 0,  **ton = &to;
                    SYM *sp2 = sp1->value.classdata.templatedata->classes.head;
                    while (sp2)
                    {
                        *ton = xalloc(sizeof(LIST));
                        (*ton)->data = sp2->tp;
                        ton = &(*ton)->link;
                        sp2 = sp2->next;
                    }
                    savecontext();
                    virtualfuncs = 1;
                    infile = errfile = sp1->value.classdata.templatedata
                        ->filename;
                    lineno = errlineno = sp1->value.classdata.templatedata
                        ->lineno;
                    len = sp1->value.classdata.templatedata->linelen;
                    max = sp1->value.classdata.templatedata->linemax;
                    interjectptr = replace2(sp1->value.classdata.templatedata
                        ->lines, &max, &len, to, tn);
                    if (recons && strstr(sp1->name,
                        cpp_funcname_tab[CI_CONSTRUCTOR]) || strstr(sp1->name,
                        cpp_funcname_tab[CI_DESTRUCTOR]))
                    {
                        int slen, ylen;
                        short *buf;
                        short name[256],  *p1 = name;
                        char *q1 = tempsym->name + prm_cmangle;
                        while (*q1)
                             *p1++ =  *q1++;
                        *p1 =  *q1;
                        slen = pstrlen(name);
                        // slen *shouldn't* change as a result of these calls
                        buf = matchname(interjectptr, name, &slen, FALSE);
                        if (buf)
                        {
                            buf = matchname(buf + slen, name, &slen, TRUE);
                            if (buf)
                            {
                                buf += slen;
                                unmangle(unmangname, actual->name);
                                p = strchr(unmangname, '>');
                                if (p)
                                    *(p + 1) = 0;
                                p = strchr(unmangname, '<');
                                p1 = name;
                                while (*p)
                                     *p1++ =  *p++;
                                *p1 =  *p;
                                slen = pstrlen(name);
                                if (max <= len + slen)
                                {
                                    short *buf2 = xalloc(max + 1000 * sizeof
                                        (short));
                                    max += 1000;
                                    memcpy(buf2, buf, (len + 1) *sizeof(short));
                                    buf = buf2;
                                }
                                memmove(buf + slen, buf, (len - (buf -
                                    interjectptr) + 1) *sizeof(short));
                                memcpy(buf, name, slen *sizeof(short));
                            }
                        }
                    }
                    setunaltered();
                    //               templatePrefix = fullcppmangle(0,name,sp1->tp) ;
                    templateSP = 0;
                    getch();
                    getsym();
                    dodecl(sc_global);
                    restorecontext();
                    templatePrefix = 0;
                    templateSP = 0;
                }
                sp1 = sp1->next;
            }
        }
        else if (sp->storage_class == sc_type)
        {
            if (sp->tp->type == bt_struct || sp->tp->type == bt_class)
                instantiateTemplateFuncs(sp, actual, tn, recons);
        }
        else if (sp->value.classdata.templatedata)
        {
            char unmangname[256],  *p;
            int len, max;
            LIST *to = 0,  **ton = &to;
            SYM *sp2 = sp->value.classdata.templatedata->classes.head;
            while (sp2)
            {
                *ton = xalloc(sizeof(LIST));
                (*ton)->data = sp2->tp;
                ton = &(*ton)->link;
                sp2 = sp2->next;
            }
            savecontext();
            virtualdata = 1;
            infile = errfile = sp->value.classdata.templatedata->filename;
            lineno = errlineno = sp->value.classdata.templatedata->lineno;
            len = sp->value.classdata.templatedata->linelen;
            max = sp->value.classdata.templatedata->linemax;
            interjectptr = replace2(sp->value.classdata.templatedata->lines,
                &max, &len, to, tn);
            setunaltered();
            //               templatePrefix = fullcppmangle(0,name,sp1->tp) ;
            templateSP = 0;
            getch();
            getsym();
            dodecl(sc_global);
            restorecontext();
            templatePrefix = 0;
            templateSP = 0;
            virtualdata = 0;
        }
        sp = sp->next;
    }
}

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

LIST *getTemplateName(SYM *sp, char *name)
{
    TYP *thead = head,  **theadptr = headptr,  *ttail = tail;
    SYM *rv;
    int err = 0;
    int odlft = defaulttype;
    LIST *tn = 0,  **tntail = &tn,  *tnorig;
    struct template  *tm = sp->value.classdata.templatedata;
    char mangname[512],  *p = name;
    getsym();
    matchandmangle(mangname, name, tntail, tm->classes.head);
    strcpy(name, mangname);
    defaulttype = odlft;
    head = thead;
    tail = ttail;
    headptr = theadptr;
    tnorig = tn;
    #ifdef XXXXX
        if (currentTemplate)
        {
            SYM *s1 = 0,  **ps = &s1;
            SYM *s2 = tm->classes.head;
            global_flag++;
            while (tn && s2)
            {
                TYP *tp = tn->data;
                SYM *sx = currentTemplate->classes.head;
                while (sx)
                {
                    if (sx->name && tp->sp && tp->sp->name && !strcmp(sx->name,
                        tp->sp->name))