move lots of source files around to match their actual placement in the original treemain

1 files changed, 0 insertions, 1880 deletions

diff --git a/compiler_and_linker/unsorted/CTemplateNew.c b/compiler_and_linker/unsorted/CTemplateNew.c
deleted file mode 100644
index c33534a..0000000
--- a/compiler_and_linker/unsorted/CTemplateNew.c
+++ /dev/null
@@ -1,1880 +0,0 @@
-#include "compiler/CTemplateNew.h"
-#include "compiler/CBrowse.h"
-#include "compiler/CDecl.h"
-#include "compiler/CError.h"
-#include "compiler/CExpr.h"
-#include "compiler/CFunc.h"
-#include "compiler/CInit.h"
-#include "compiler/CInline.h"
-#include "compiler/CMachine.h"
-#include "compiler/CMangler.h"
-#include "compiler/CParser.h"
-#include "compiler/CPrep.h"
-#include "compiler/CPrepTokenizer.h"
-#include "compiler/CScope.h"
-#include "compiler/CTemplateClass.h"
-#include "compiler/CTemplateTools.h"
-#include "compiler/CompilerTools.h"
-#include "compiler/ObjGenMachO.h"
-#include "compiler/objects.h"
-#include "compiler/scopes.h"
-#include "compiler/templates.h"
-
-TemplClass *ctempl_templates;
-TemplateFunction *ctempl_templatefuncs;
-TemplStack *ctempl_curinstance;
-static jmp_buf ctempl_parseparse;
-static Boolean ctempl_scanfuncparams;
-
-// forward decls
-static TemplParam *CTempl_ParseParamList(NameSpace *nspace, UInt8 nindex);
-static Boolean CTempl_GenClassInstance(TemplClassInst *inst, Boolean flag);
-
-void CTempl_Setup(void) {
-    ctempl_curinstance = NULL;
-    ctempl_templates = NULL;
-    ctempl_templatefuncs = NULL;
-    ctempl_instdepth = 0;
-    ctempl_scanfuncparams = 0;
-}
-
-void CTempl_Cleanup(void) {
-}
-
-static short CTempl_MemberParseLex(void) {
-    switch ((tk = lex())) {
-        case ';':
-        case '=':
-        case '{':
-        case '}':
-            longjmp(ctempl_parseparse, 1);
-    }
-
-    return tk;
-}
-
-static void CTempl_MemberParseTemplArgList(void) {
-    struct {
-        char ch;
-        char flag;
-    } stack[256];
-    int pos;
-
-    stack[0].ch = '>';
-    stack[0].flag = 1;
-    pos = 0;
-    while (1) {
-        switch (CTempl_MemberParseLex()) {
-            case '<':
-                if (stack[pos].flag) {
-                    if (pos >= 255)
-                        longjmp(ctempl_parseparse, 1);
-                    stack[++pos].ch = '>';
-                    stack[pos].flag = 1;
-                }
-                continue;
-            case '(':
-                if (pos >= 255)
-                    longjmp(ctempl_parseparse, 1);
-                stack[++pos].ch = ')';
-                stack[pos].flag = 0;
-                continue;
-            case '[':
-                if (pos >= 255)
-                    longjmp(ctempl_parseparse, 1);
-                stack[++pos].ch = ']';
-                stack[pos].flag = 0;
-                continue;
-            case '>':
-                if (!(stack[pos].flag))
-                    continue;
-            case ')':
-            case ']':
-                break;
-            default:
-                continue;
-        }
-
-        if (tk != stack[pos].ch)
-            longjmp(ctempl_parseparse, 1);
-        if (--pos < 0)
-            break;
-    }
-}
-
-static Type *CTempl_MemberParseTempl(HashNameNode *name) {
-    Type *type;
-
-    type = CScope_GetTagType(cscope_current, name);
-    if (!type || !IS_TEMPL_CLASS(type))
-        longjmp(ctempl_parseparse, 1);
-
-    CTempl_MemberParseTemplArgList();
-    if (lookahead() != TK_COLON_COLON)
-        return NULL;
-    CTempl_MemberParseLex();
-
-    while (1) {
-        switch (CTempl_MemberParseLex()) {
-            case TK_IDENTIFIER:
-                switch (lookahead()) {
-                    case '(':
-                    case ')':
-                    case ';':
-                    case '=':
-                    case '[':
-                        return type;
-                    case TK_COLON_COLON:
-                        CTempl_MemberParseLex();
-                        continue;
-                    default:
-                        return NULL;
-                }
-                break;
-            case '~':
-            case TK_OPERATOR:
-                return type;
-            default:
-                return NULL;
-        }
-    }
-}
-
-static Boolean CTempl_ParseTemplateMember(void) {
-    HashNameNode *name;
-    SInt32 state;
-
-    CPrep_UnLex();
-    CPrep_TokenStreamGetState(&state);
-
-    if (setjmp(ctempl_parseparse) == 0) {
-        while (1) {
-            switch (CTempl_MemberParseLex()) {
-                case TK_IDENTIFIER:
-                    name = tkidentifier;
-                    switch (lookahead()) {
-                        case '<':
-                            CTempl_MemberParseLex();
-                            if (CTempl_MemberParseTempl(name)) {
-                                CError_FATAL(228);
-                                return 1;
-                            }
-                            break;
-                        case TK_COLON_COLON:
-                            CTempl_MemberParseLex();
-                            while (1) {
-                                if (CTempl_MemberParseLex() != TK_IDENTIFIER)
-                                    break;
-                                if (lookahead() != TK_COLON_COLON)
-                                    break;
-                                CTempl_MemberParseLex();
-                            }
-                            break;
-                    }
-                    break;
-                case 0:
-                    return 0;
-                default:
-                    continue;
-            }
-            break;
-        }
-
-        while (1) {
-            switch (CTempl_MemberParseLex()) {
-                case TK_IDENTIFIER:
-                    name = tkidentifier;
-                    if (CTempl_MemberParseLex() == '<') {
-                        if (CTempl_MemberParseTempl(name)) {
-                            CError_FATAL(265);
-                            return 1;
-                        }
-                    }
-                    break;
-                case 0:
-                    return 0;
-                default:
-                    continue;
-            }
-            break;
-        }
-    }
-
-    CPrep_TokenStreamSetState(&state);
-    tk = lex();
-    return 0;
-}
-
-static Type *CTempl_ParseTemplArgType(UInt32 *resultQual) {
-    DeclInfo di;
-
-    memclrw(&di, sizeof(di));
-    CParser_GetDeclSpecs(&di, 0);
-
-    if (di.storageclass)
-        CError_Error(CErrorStr177);
-    if (di.x48)
-        CError_Error(CErrorStr121);
-
-    CError_QualifierCheck(di.qual & ~(Q_CONST | Q_VOLATILE | Q_PASCAL | Q_REFERENCE | Q_ALIGNED_MASK));
-
-    scandeclarator(&di);
-    if (di.name)
-        CError_Error(CErrorStr121);
-
-    CTemplTool_CheckTemplArgType(di.thetype);
-
-    *resultQual = di.qual;
-    return di.thetype;
-}
-
-static ENode *CTempl_ParseTemplArgExpr(Type *type, UInt32 qual) {
-    ENode *expr;
-    ENode *copy;
-
-    disallowgreaterthan = 1;
-    if (copts.old_argmatch)
-        expr = conv_assignment_expression();
-    else
-        expr = assignment_expression();
-    disallowgreaterthan = 0;
-
-    if (type && !CTemplTool_IsTemplateArgumentDependentType(type) && !IS_TYPE_TEMPLDEPEXPR(expr->rtype)) {
-        expr = argumentpromotion(expr, type, qual, 1);
-        if (IS_TYPE_POINTER_ONLY(type)) {
-            if (ENODE_IS(expr, ETYPCON) && ENODE_IS(expr->data.monadic, EINTCONST))
-                expr = expr->data.monadic;
-            if (ENODE_IS(expr, EINTCONST))
-                expr->rtype = type;
-        }
-    }
-
-    if (!IS_TYPE_TEMPLDEPEXPR(expr->rtype)) {
-        if (!copts.old_argmatch)
-            expr = pointer_generation(expr);
-
-        switch (expr->type) {
-            case EINTCONST:
-                break;
-            case EOBJREF:
-                if (CParser_HasInternalLinkage2(expr->data.objref))
-                    CError_Error(CErrorStr357);
-                break;
-            case EOBJLIST:
-                CError_Error(CErrorStr199);
-                expr = nullnode();
-                break;
-            default:
-                CError_Error(CErrorStr371);
-                expr = nullnode();
-        }
-
-        copy = galloc(sizeof(ENode));
-        *copy = *expr;
-        return copy;
-    } else {
-        return CInline_CopyExpression(expr, CopyMode1);
-    }
-}
-
-static Type *CTempl_ParseTemplArgTempl(TemplParam *params) {
-    NameResult pr;
-
-    if (
-        (tk != TK_IDENTIFIER && tk != TK_COLON_COLON) ||
-        !CScope_ParseDeclName(&pr) ||
-        !pr.type
-        )
-    {
-        CError_Error(CErrorStr121);
-        tk = lex();
-        return NULL;
-    }
-
-    if (IS_TEMPL_CLASS(pr.type)) {
-        if (params && !CTemplTool_EqualParams(params->data.templparam.plist, TEMPL_CLASS(pr.type)->templ__params, 0)) {
-            CError_Error(CErrorStr235);
-            tk = lex();
-            return NULL;
-        }
-    } else {
-        if (!CTemplTool_IsTemplateArgumentDependentType(pr.type))
-            CError_Error(CErrorStr146);
-    }
-
-    tk = lex();
-    return pr.type;
-}
-
-static UInt8 CTempl_GetTemplateNestIndex(NameSpace *nspace) {
-    UInt8 count = 0;
-
-    while (nspace) {
-        if (nspace->theclass && (nspace->theclass->flags & CLASS_IS_TEMPL_ANY))
-            count++;
-        nspace = nspace->parent;
-    }
-
-    return count;
-}
-
-static TemplParam *CTempl_ParseParam(NameSpace *nspace, TemplParam *param, UInt16 index, UInt8 nindex) {
-    DeclInfo di;
-    SInt32 savedState;
-    short startToken;
-
-    param = galloc(sizeof(TemplParam));
-    memclrw(param, sizeof(TemplParam));
-
-    param->pid.index = index;
-    param->pid.nindex = nindex;
-
-    CPrep_TokenStreamGetState(&savedState);
-
-    switch ((startToken = tk)) {
-        case TK_CLASS:
-        case TK_TYPENAME:
-            if ((tk = lex()) == TK_IDENTIFIER) {
-                param->name = tkidentifier;
-                tk = lex();
-            }
-
-            switch (tk) {
-                case ',':
-                case '>':
-                    break;
-                case '=':
-                    tk = lex();
-                    param->data.typeparam.type = CTempl_ParseTemplArgType(&param->data.typeparam.qual);
-                    break;
-                default:
-                    param->name = NULL;
-                    CPrep_TokenStreamSetState(&savedState);
-                    tk = startToken;
-                    goto defaultProc;
-            }
-
-            param->pid.type = TPT_TYPE;
-            break;
-
-        case TK_TEMPLATE:
-            if ((tk = lex()) != '<') {
-                CError_Error(CErrorStr230);
-                return NULL;
-            }
-
-            tk = lex();
-            param->data.templparam.plist = CTempl_ParseParamList(nspace, 0);
-
-            if (tk == '>')
-                tk = lex();
-            else
-                CError_Error(CErrorStr231);
-
-            if (tk == TK_CLASS)
-                tk = lex();
-            else
-                CError_Error(CErrorStr121);
-
-            if (tk == TK_IDENTIFIER) {
-                param->name = tkidentifier;
-                tk = lex();
-            }
-
-            if (tk == '=') {
-                tk = lex();
-                param->data.templparam.defaultarg = CTempl_ParseTemplArgTempl(param);
-            }
-
-            param->pid.type = TPT_TEMPLATE;
-            break;
-
-        default:
-        defaultProc:
-            memclrw(&di, sizeof(di));
-            CParser_GetDeclSpecs(&di, 0);
-
-            if (di.storageclass)
-                CError_Error(CErrorStr177);
-
-            CError_QualifierCheck(di.qual & ~(Q_CONST | Q_VOLATILE | Q_PASCAL | Q_REFERENCE | Q_ALIGNED_MASK));
-
-            scandeclarator(&di);
-
-            switch (di.thetype->type) {
-                case TYPEARRAY:
-                    di.thetype = CDecl_NewPointerType(TPTR_TARGET(di.thetype));
-                    break;
-                case TYPEFUNC:
-                    di.thetype = CDecl_NewPointerType(di.thetype);
-                    break;
-                case TYPEMEMBERPOINTER:
-                    CError_Error(CErrorStr190);
-                    di.thetype = TYPE(&stsignedint);
-                    break;
-                case TYPEINT:
-                case TYPEENUM:
-                case TYPETEMPLATE:
-                case TYPEPOINTER:
-                    break;
-                default:
-                    CError_Error(CErrorStr229);
-                    di.thetype = TYPE(&stsignedint);
-            }
-
-            di.thetype = CParser_RemoveTopMostQualifiers(di.thetype, &di.qual);
-            param->name = di.name;
-            param->data.paramdecl.type = di.thetype;
-            param->data.paramdecl.qual = di.qual;
-            if (tk == '=') {
-                tk = lex();
-                param->data.paramdecl.defaultarg = CTempl_ParseTemplArgExpr(di.thetype, di.qual);
-            }
-
-            param->pid.type = TPT_NONTYPE;
-            break;
-    }
-
-    if (param->name)
-        CTemplTool_InsertTemplateParameter(nspace, param);
-
-    return param;
-}
-
-static TemplParam *CTempl_ParseParamList(NameSpace *nspace, UInt8 nindex) {
-    TemplParam *params;
-    TemplParam **ptr;
-    TemplParam *param;
-    TemplParam *scan;
-    UInt16 index;
-
-    params = NULL;
-    index = 0;
-    ptr = &params;
-
-    while (1) {
-        param = CTempl_ParseParam(nspace, params, index, nindex);
-        if (!param)
-            break;
-
-        if (param->name) {
-            for (scan = params; scan; scan = scan->next) {
-                if (scan->name == param->name)
-                    CError_Error(CErrorStr122, param->name->name);
-            }
-        }
-
-        *ptr = param;
-        ptr = &param->next;
-
-        if (tk != ',')
-            break;
-
-        tk = lex();
-        index++;
-    }
-
-    if (!params)
-        CError_Error(CErrorStr229);
-
-    return params;
-}
-
-TemplArg *CTempl_ParseUncheckTemplArgs(TemplParam *params, Boolean is_global) {
-    TemplArg *args;
-    TemplArg *last;
-    UInt16 index;
-
-    if (tk != '<') {
-        CError_Error(CErrorStr230);
-        return NULL;
-    }
-
-    if ((tk = lex()) == '>')
-        return NULL;
-
-    args = NULL;
-    index = 0;
-    while (1) {
-        if (is_global) {
-            if (args) {
-                last->next = galloc(sizeof(TemplArg));
-                last = last->next;
-            } else {
-                last = galloc(sizeof(TemplArg));
-                args = last;
-            }
-        } else {
-            if (args) {
-                last->next = lalloc(sizeof(TemplArg));
-                last = last->next;
-            } else {
-                last = galloc(sizeof(TemplArg));
-                args = last;
-            }
-        }
-
-        last->next = NULL;
-
-        if (!params) {
-            Type *type;
-            UInt32 qual;
-            Boolean flag;
-
-            last->pid.index = index;
-            last->pid.nindex = 0;
-
-            if ((type = CParser_ParseTypeID(&qual, &flag))) {
-                if (flag) {
-                    last->data.ttargtype = type;
-                    last->pid.type = TPT_TEMPLATE;
-                } else {
-                    last->data.typeparam.type = type;
-                    last->data.typeparam.qual = qual;
-                    last->pid.type = TPT_TYPE;
-                }
-            } else {
-                last->data.paramdecl.expr = CTempl_ParseTemplArgExpr(NULL, 0);
-                last->pid.type = TPT_NONTYPE;
-            }
-        } else {
-            last->pid = params->pid;
-            switch (last->pid.type) {
-                case TPT_TYPE:
-                    last->data.typeparam.type = CTempl_ParseTemplArgType(&last->data.typeparam.qual);
-                    break;
-                case TPT_NONTYPE:
-                    last->data.paramdecl.expr = CTempl_ParseTemplArgExpr(NULL, 0);
-                    break;
-                case TPT_TEMPLATE:
-                    if (!(last->data.ttargtype = CTempl_ParseTemplArgTempl(params)))
-                        return NULL;
-                    break;
-                default:
-                    CError_FATAL(674);
-            }
-            params = params->next;
-        }
-
-        if (tk == '>')
-            return args;
-
-        if (tk != ',') {
-            CError_Error(CErrorStr116);
-            return NULL;
-        }
-
-        tk = lex();
-        index++;
-    }
-}
-
-static TemplArg *CTempl_ParseTemplArgs(TemplClass **resultTempl, TemplArg **resultArgs) {
-    TemplParam *param;
-    TemplParam *params;
-    TemplArg *args;
-    TemplArg **ptr;
-    TemplArg *arg;
-
-    params = (*resultTempl)->templ__params;
-    *resultArgs = NULL;
-
-    if (tk != '<') {
-        CError_Error(CErrorStr230);
-        return NULL;
-    }
-
-    tk = lex();
-
-    param = params;
-    args = NULL;
-    ptr = &args;
-
-    while (param) {
-        arg = galloc(sizeof(TemplArg));
-        memclrw(arg, sizeof(TemplArg));
-
-        *ptr = arg;
-        ptr = &arg->next;
-
-        arg->pid = param->pid;
-
-        if (tk != '>') {
-            switch (arg->pid.type) {
-                case TPT_TYPE:
-                    arg->data.typeparam.type = CTempl_ParseTemplArgType(&arg->data.typeparam.qual);
-                    break;
-
-                case TPT_NONTYPE:
-                    if (CTemplTool_IsTemplateArgumentDependentType(param->data.paramdecl.type)) {
-                        Type *type;
-                        UInt32 qual;
-
-                        type = CTemplTool_DeduceArgDepType(args, param->data.paramdecl.type, param->data.paramdecl.qual, &qual);
-                        arg->data.paramdecl.expr = CTempl_ParseTemplArgExpr(type, qual);
-                    } else {
-                        arg->data.paramdecl.expr = CTempl_ParseTemplArgExpr(param->data.paramdecl.type, param->data.paramdecl.qual);
-                    }
-                    break;
-
-                case TPT_TEMPLATE:
-                    if (!(arg->data.ttargtype = CTempl_ParseTemplArgTempl(param)))
-                        return NULL;
-                    break;
-
-                default:
-                    CError_FATAL(742);
-            }
-
-            if (tk != '>') {
-                if (tk != ',') {
-                    CError_Error(CErrorStr232);
-                    return NULL;
-                }
-
-                if ((tk = lex()) == '>') {
-                    CError_Error(CErrorStr232);
-                    return NULL;
-                }
-            }
-        } else {
-            switch (arg->pid.type) {
-                case TPT_TYPE:
-                    if (!param->data.typeparam.type) {
-                        CError_Error(CErrorStr232);
-                        return NULL;
-                    }
-
-                    arg->data.typeparam.type = param->data.typeparam.type;
-                    arg->data.typeparam.qual = param->data.typeparam.qual;
-
-                    if (CTemplTool_IsTemplateArgumentDependentType(param->data.typeparam.type)) {
-                        TypeDeduce deduce;
-                        memclrw(&deduce, sizeof(deduce));
-                        deduce.tmclass = *resultTempl;
-                        deduce.inst = NULL;
-                        deduce.params = params;
-                        deduce.args = args;
-
-                        arg->data.typeparam.qual = param->data.typeparam.qual;
-                        arg->data.typeparam.type = CTemplTool_DeduceTypeCopy(&deduce, arg->data.typeparam.type, &arg->data.typeparam.qual);
-                    }
-                    break;
-
-                case TPT_NONTYPE:
-                    if (!param->data.paramdecl.defaultarg) {
-                        CError_Error(CErrorStr232);
-                        return NULL;
-                    }
-
-                    if (IS_TYPE_TEMPLDEPEXPR(param->data.paramdecl.defaultarg->rtype)) {
-                        TypeDeduce deduce;
-                        memclrw(&deduce, sizeof(deduce));
-                        deduce.tmclass = *resultTempl;
-                        deduce.inst = NULL;
-                        deduce.params = params;
-                        deduce.args = args;
-
-                        arg->data.paramdecl.expr = CInline_CopyExpression(
-                            CTemplTool_DeduceExpr(&deduce, param->data.paramdecl.defaultarg), CopyMode1);
-                    } else {
-                        arg->data.paramdecl.expr = param->data.paramdecl.defaultarg;
-                    }
-                    break;
-
-                case TPT_TEMPLATE:
-                    if (!param->data.templparam.defaultarg) {
-                        CError_Error(CErrorStr232);
-                        return NULL;
-                    }
-
-                    if (IS_TEMPL_CLASS(param->data.templparam.defaultarg)) {
-                        arg->data.ttargtype = param->data.templparam.defaultarg;
-                        break;
-                    }
-
-                    if (CTemplTool_IsTemplateArgumentDependentType(param->data.templparam.defaultarg)) {
-                        CError_Error(CErrorStr190);
-                        return NULL;
-                    }
-
-                    CError_FATAL(817);
-
-                default:
-                    CError_FATAL(820);
-            }
-        }
-
-        param = param->next;
-    }
-
-    if (tk != '>') {
-        CError_Error(CErrorStr231);
-        return NULL;
-    }
-
-    if ((*resultTempl)->pspecs)
-        return args;
-
-    return args;
-}
-
-Type *CTempl_ParseTemplTemplParam(TypeTemplDep *type) {
-    TemplArg *args;
-    Type *newType;
-
-    tk = lex();
-    if (!(args = CTempl_ParseUncheckTemplArgs(NULL, 1))) {
-        CError_Error(CErrorStr121);
-        return TYPE(&stsignedint);
-    }
-
-    newType = CDecl_NewTemplDepType(TEMPLDEP_QUALTEMPL);
-    TYPE_TEMPLATE(newType)->u.qualtempl.type = type;
-    TYPE_TEMPLATE(newType)->u.qualtempl.args = args;
-    return newType;
-}
-
-Type *CTempl_ClassGetType(TemplClass *templ) {
-    TemplClass *owner;
-    TemplArg *ownerArgs;
-    TemplArg *args;
-    Type *type;
-
-    owner = templ;
-    if (templ->pspec_owner)
-        owner = templ->pspec_owner;
-
-    if (!(args = CTempl_ParseTemplArgs(&owner, &ownerArgs)))
-        return &stvoid;
-
-    if ((type = CTemplTool_IsDependentTemplate(owner, args)))
-        return type;
-
-    return TYPE(CTemplClass_GetInstance(owner, args, ownerArgs));
-}
-
-static void CTempl_SetupClassParamNameSpace(DeclFucker *what_is_this, TypeClass *tclass) {
-    cscope_current = tclass->nspace;
-}
-
-Boolean CTempl_IsQualifiedMember(DeclInfo *di, Type *type, NameSpace **resultnspace) {
-    if (
-        TYPE_TEMPLATE(type)->dtype == TEMPLDEP_QUALNAME &&
-        (type = CTemplTool_GetSelfRefTemplate(TYPE(TYPE_TEMPLATE(type)->u.qual.type)))
-        )
-    {
-        *resultnspace = TYPE_CLASS(type)->nspace;
-        CError_ASSERT(948, di->fucker34 && (*resultnspace)->theclass);
-
-        CTempl_SetupClassParamNameSpace(di->fucker34, (*resultnspace)->theclass);
-        di->fucker34 = NULL;
-        return 1;
-    }
-
-    return 0;
-}
-
-static void *CTempl_ParseMemberFunction(int unk1, int unk2, int unk3, Object *func) {
-    // no idea what should've been here, it's not called
-
-    CError_ASSERT(974, TYPE_FUNC(func->type)->flags & FUNC_METHOD);
-
-    return NULL;
-}
-
-static void CTempl_ParseMember(TemplParam *params, TemplClass *templ, DeclInfo *di, SInt32 *startOffset) {
-    Object *object;
-    NameSpaceObjectList *nsol;
-    TokenStream stream;
-    CPrepFileInfo *file;
-    SInt32 offset;
-    Boolean saveForceLoc;
-    TemplateMember *member;
-
-    if (templ->theclass.flags & CLASS_IS_TEMPL)
-        di->thetype = CTemplTool_ResolveMemberSelfRefs(templ, di->thetype, &di->qual);
-
-    if (IS_TYPE_FUNC(di->thetype)) {
-        Boolean flag;
-        if (!(object = CDecl_GetFunctionObject(di, NULL, &flag, 0))) {
-            CError_Error(CErrorStr140, di->name->name);
-            return;
-        }
-
-        if (tk != '{' && tk != TK_TRY && tk != ':') {
-            if (tk != ';')
-                CError_Error(CErrorStr123);
-            else
-                tk = lex();
-            return;
-        }
-
-        if (
-            (TYPE_FUNC(object->type)->flags & FUNC_DEFINED) &&
-            (!(TYPE_FUNC(object->type)->flags & FUNC_IS_TEMPL) || object->u.func.u.templ->instances)
-            )
-            CError_Error(CErrorStr333, object);
-
-        TYPE_FUNC(object->type)->flags |= FUNC_IS_TEMPL_INSTANCE | FUNC_DEFINED;
-
-        CPrep_StreamGetBlock(&stream, NULL, 1);
-        saveForceLoc = gForceSourceLoc;
-        gForceSourceLoc = 1;
-        CPrep_BrowserFilePosition(&file, &offset);
-        gForceSourceLoc = saveForceLoc;
-
-        if (file && file->recordbrowseinfo && *startOffset >= 0 && offset > *startOffset)
-            CBrowse_NewFunction(object, file, file, *startOffset, offset + 1);
-    } else {
-        if (!(nsol = CScope_GetLocalObject(templ->theclass.nspace, di->name))) {
-            CError_Error(CErrorStr140, di->name->name);
-            return;
-        }
-
-        object = OBJECT(nsol->object);
-        if (object->otype != OT_OBJECT) {
-            CError_Error(CErrorStr122, di->name->name);
-            return;
-        }
-
-        if (
-            !is_typesame(di->thetype, object->type) ||
-            (object->qual & (Q_CONST | Q_VOLATILE | Q_PASCAL)) != (di->qual & (Q_CONST | Q_VOLATILE | Q_PASCAL))
-            )
-        {
-            CError_Error(CErrorStr249, CError_GetObjectName(object), object->type, object->qual, di->thetype, di->qual);
-            return;
-        }
-
-        CError_ASSERT(1070, object->datatype == DDATA);
-
-        CPrep_StreamGetSemicolon(&stream, NULL);
-    }
-
-    if (stream.tokens) {
-        if (IS_TEMPL_FUNC(object->type) != 0) {
-            if (!CTemplTool_EqualParams(object->u.func.u.templ->params, params, 0))
-                CError_Error(CErrorStr235);
-
-            object->u.func.u.templ->stream = stream;
-        } else {
-            if (!(templ->theclass.flags & CLASS_IS_TEMPL)) {
-                CError_Error(CErrorStr190);
-                return;
-            }
-
-            member = CTemplClass_DefineMember(templ, object, &cparser_fileoffset, &stream);
-            if (templ->templ__params) {
-                if (!CTemplTool_EqualParams(templ->templ__params, params, 0)) {
-                    CError_Error(CErrorStr235);
-                    return;
-                }
-
-                member->params = params;
-            }
-        }
-    }
-}
-
-static TemplateFunction *CTempl_DeclareTemplateFunction(DeclInfo *di, TemplParam *params, TypeClass *tclass, AccessType access, Boolean flag) {
-    TemplateFunction *templ;
-    Object *object;
-
-    if (tclass) {
-        CError_ASSERT(1122, cscope_current->theclass);
-        di->thetype = TYPE(CDecl_MakeTypeMemberFunc(TYPE_FUNC(di->thetype), cscope_current->theclass, flag));
-    } else {
-        access = ACCESSPUBLIC;
-    }
-
-    templ = galloc(sizeof(TemplateFunction));
-    memclrw(templ, sizeof(TemplateFunction));
-
-    templ->next = ctempl_templatefuncs;
-    ctempl_templatefuncs = templ;
-
-    templ->params = params;
-    templ->name = di->name;
-    templ->deftoken = symdecltoken;
-
-    object = CParser_NewFunctionObject(NULL);
-    object->access = access;
-    object->name = di->name;
-    object->u.func.linkname = CParser_GetUniqueName();
-    object->type = di->thetype;
-    object->qual = di->qual | Q_MANGLE_NAME;
-    object->sclass = di->storageclass;
-    TYPE_FUNC(object->type)->flags |= FUNC_IS_TEMPL;
-    object->u.func.u.templ = templ;
-
-    if (di->qual & Q_INLINE)
-        object->sclass = TK_STATIC;
-
-    templ->tfunc = object;
-    CScope_AddObject(cscope_current, di->name, OBJ_BASE(object));
-
-    return templ;
-}
-
-static void CTempl_ParseTemplateFunction(TemplateFunction *templ, TypeClass *tclass, SInt32 *startOffset) {
-    Object *object;
-    CPrepFileInfo *file;
-    SInt32 offset;
-    Boolean saveForceLoc;
-
-    object = templ->tfunc;
-
-    if (tk == '{' || tk == ':' || tk == TK_TRY) {
-        if (tclass) {
-            object->qual |= Q_INLINE;
-            object->sclass = TK_STATIC;
-        }
-
-        if (TYPE_FUNC(object->type)->flags & FUNC_DEFINED)
-            CError_Error(CErrorStr333, object);
-
-        TYPE_FUNC(object->type)->flags |= FUNC_DEFINED | FUNC_IS_TEMPL_INSTANCE;
-
-        CPrep_StreamGetBlock(&templ->stream, NULL, 0);
-
-        if (lookahead() == ';')
-            tk = lex();
-        else
-            tk = ';';
-
-        saveForceLoc = gForceSourceLoc;
-        gForceSourceLoc = 1;
-        CPrep_BrowserFilePosition(&file, &offset);
-        gForceSourceLoc = saveForceLoc;
-
-        if (file && *startOffset >= 0 && offset > *startOffset) {
-            templ->srcfile = file;
-            templ->startoffset = *startOffset;
-            templ->endoffset = offset + 1;
-            if (cparamblkptr->browseoptions.recordTemplates && file->recordbrowseinfo)
-                CBrowse_NewTemplateFunc(templ);
-        }
-
-    } else {
-        if (tk != ';')
-            CError_Error(CErrorStr121);
-    }
-}
-
-static HashNameNode *CTempl_FindConversionFuncName(TypeClass *tclass, Type *type, UInt32 qual) {
-    Object *object;
-    CScopeObjectIterator iter;
-
-    CScope_InitObjectIterator(&iter, tclass->nspace);
-    do {
-        if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
-            return NULL;
-    } while (
-        !IS_TYPE_FUNC(object->type) ||
-        !(TYPE_FUNC(object->type)->flags & FUNC_CONVERSION) ||
-        (TYPE_FUNC(object->type)->qual & (Q_CONST | Q_VOLATILE)) != (qual & (Q_CONST | Q_VOLATILE)) ||
-        !is_typesame(TYPE_FUNC(object->type)->functype, type)
-        );
-
-    return object->name;
-}
-
-static void CTempl_ParseConversionFunctionTemplate(DeclInfo *di, DeclFucker *what_is_this, TemplParam *params, TypeClass *tclass, SInt32 *startOffset, AccessType access) {
-    tk = lex();
-    if (!tclass) {
-        CError_Error(CErrorStr121);
-        return;
-    }
-
-    tclass->flags = tclass->flags | CLASS_IS_CONVERTIBLE;
-    CError_QualifierCheck(di->qual & ~Q_INLINE);
-
-    conversion_type_name(di);
-    CDecl_NewConvFuncType(di);
-
-    if (cscope_current->is_templ) {
-        CError_ASSERT(1260, cscope_current == what_is_this->nspace);
-        cscope_current = what_is_this->nspace->parent;
-    }
-
-    CTempl_ParseTemplateFunction(CTempl_DeclareTemplateFunction(di, params, tclass, access, 0), tclass, startOffset);
-}
-
-static void CTempl_ParseFunctionOrMemberTemplate(DeclFucker *what_is_this, TemplParam *params, TypeClass *tclass, SInt32 *startOffset, AccessType access, Boolean mysteryFlag) {
-    NameSpaceObjectList *nsol;
-    Object *object;
-    TemplParam *param;
-    TemplateFunction *templfunc;
-    Boolean disallowCVFlag;
-    TypeClass *tclass2;
-    Type *type;
-    UInt32 qual;
-    DeclInfo di;
-
-    for (param = params; param; param = param->next) {
-        switch (param->pid.type) {
-            case TPT_TYPE:
-                if (param->data.typeparam.type) {
-                    CError_Error(CErrorStr378);
-                    param->data.typeparam.type = NULL;
-                }
-                break;
-            case TPT_NONTYPE:
-                if (param->data.paramdecl.defaultarg) {
-                    CError_Error(CErrorStr378);
-                    param->data.paramdecl.defaultarg = NULL;
-                }
-                break;
-            case TPT_TEMPLATE:
-                if (param->data.templparam.defaultarg) {
-                    CError_Error(CErrorStr378);
-                    param->data.templparam.defaultarg = NULL;
-                }
-                break;
-            default:
-                CError_FATAL(1317);
-        }
-    }
-
-    disallowCVFlag = 0;
-    ctempl_scanfuncparams = 1;
-
-    memclrw(&di, sizeof(di));
-    di.x51 = mysteryFlag;
-
-    if (tk == TK_OPERATOR) {
-        CTempl_ParseConversionFunctionTemplate(&di, what_is_this, params, tclass, startOffset, access);
-        return;
-    }
-
-    CParser_GetDeclSpecs(&di, 1);
-    if (tk == ';' && IS_TEMPL_CLASS(di.thetype))
-        return;
-
-    if (di.x10 || di.x14) {
-        TypeFunc *tfunc;
-
-        if (di.x14) {
-            di.x10 = OBJECT(di.x14->object);
-            CError_ASSERT(1342, di.x10->otype == OT_OBJECT);
-        }
-
-        CError_ASSERT(1344, IS_TYPE_FUNC(di.x10->type));
-
-        tfunc = TYPE_FUNC(di.x10->type);
-        if (tfunc->flags & FUNC_CONVERSION) {
-            di.thetype = tfunc->functype;
-            di.qual |= tfunc->qual;
-            di.nspace = di.x10->nspace;
-            di.name = di.x10->name;
-        } else if (tfunc->flags & FUNC_IS_CTOR) {
-            di.thetype = TYPE(&void_ptr);
-            di.nspace = di.x10->nspace;
-            di.name = di.x10->name;
-        } else {
-            CError_Error(CErrorStr121);
-            return;
-        }
-
-        if ((tk = lex()) == '(') {
-            tk = lex();
-            CDecl_ParseDirectFuncDecl(&di);
-            if (IS_TYPE_FUNC(di.thetype))
-                goto skipPastStuff;
-        } else {
-            CError_Error(CErrorStr114);
-        }
-    }
-
-    if (di.storageclass) {
-        if (tclass) {
-            if (di.storageclass == TK_STATIC)
-                disallowCVFlag = 1;
-            else
-                CError_Error(CErrorStr177);
-            di.storageclass = 0;
-        } else {
-            if (di.storageclass != TK_STATIC && di.storageclass != TK_EXTERN) {
-                CError_Error(CErrorStr177);
-                di.storageclass = 0;
-            }
-        }
-    }
-
-    CError_QualifierCheck(di.qual & ~(Q_CONST | Q_VOLATILE | Q_ASM | Q_PASCAL | Q_INLINE | Q_EXPLICIT | Q_20000 | Q_WEAK | Q_ALIGNED_MASK));
-
-    if (tk == TK_OPERATOR && di.x4A) {
-        CTempl_ParseConversionFunctionTemplate(&di, what_is_this, params, tclass, startOffset, access);
-        return;
-    }
-
-    if (!di.x53) {
-        if (tclass && IS_TYPE_CLASS(di.thetype) && TYPE_CLASS(di.thetype) == tclass && tk == '(') {
-            CError_ASSERT(1418, cscope_current == tclass->nspace);
-            CError_QualifierCheck(di.qual & ~(Q_INLINE | Q_EXPLICIT));
-
-            di.thetype = TYPE(&void_ptr);
-            di.x4B = 1;
-
-            tk = lex();
-            CDecl_ParseDirectFuncDecl(&di);
-
-            if (IS_TYPE_FUNC(di.thetype)) {
-                if (TYPE_FUNC(di.thetype)->args && !TYPE_FUNC(di.thetype)->args->next && TYPE_FUNC(di.thetype)->args->type == TYPE(tclass)) {
-                    CError_Error(CErrorStr239);
-                    TYPE_FUNC(di.thetype)->args = NULL;
-                }
-
-                if (tclass->flags & CLASS_HAS_VBASES)
-                    CDecl_AddArgument(TYPE_FUNC(di.thetype), TYPE(&stsignedshort));
-
-                TYPE_FUNC(di.thetype)->flags |= FUNC_IS_CTOR;
-                di.name = constructor_name_node;
-
-                what_is_this->nspace->tparams = NULL;
-
-                CTempl_ParseTemplateFunction(
-                    CTempl_DeclareTemplateFunction(&di, params, tclass, access, disallowCVFlag),
-                    tclass, startOffset);
-
-                return;
-            } else {
-                CError_Error(CErrorStr241);
-            }
-        }
-
-        if (IS_TYPE_TEMPLATE(di.thetype)) {
-            if (
-                tk == '(' &&
-                TYPE_TEMPLATE(di.thetype)->dtype == TEMPLDEP_QUALNAME &&
-                (tclass2 = TYPE_CLASS(CTemplTool_GetSelfRefTemplate(TYPE(TYPE_TEMPLATE(di.thetype)->u.qual.type)))) &&
-                TYPE_TEMPLATE(di.thetype)->u.qual.name == tclass2->classname
-                )
-            {
-                if (tclass)
-                    CError_Error(CErrorStr229);
-
-                di.thetype = TYPE(&void_ptr);
-                di.x4B = 1;
-
-                CTempl_SetupClassParamNameSpace(what_is_this, tclass2);
-
-                tk = lex();
-                CDecl_ParseDirectFuncDecl(&di);
-
-                if (IS_TYPE_FUNC(di.thetype)) {
-                    di.name = constructor_name_node;
-                    if (tclass2->flags & CLASS_HAS_VBASES)
-                        CDecl_AddArgument(TYPE_FUNC(di.thetype), TYPE(&stsignedshort));
-
-                    TYPE_FUNC(di.thetype)->flags |= FUNC_IS_CTOR;
-                    CTempl_ParseMember(params, TEMPL_CLASS(tclass2), &di, startOffset);
-                } else {
-                    CError_Error(CErrorStr241);
-                }
-
-                return;
-            }
-
-            if (
-                tk == TK_COLON_COLON &&
-                TYPE_TEMPLATE(di.thetype)->dtype == TEMPLDEP_TEMPLATE &&
-                (tclass2 = TYPE_CLASS(CTemplTool_GetSelfRefTemplate(di.thetype)))
-                )
-            {
-                if (tclass)
-                    CError_Error(CErrorStr229);
-
-                if ((tk = lex()) == '~') {
-                    if (
-                        (tk = lex()) != TK_IDENTIFIER ||
-                        tkidentifier != tclass2->classname ||
-                        (tk = lex()) != '('
-                    )
-                    {
-                        if (tk == '<') {
-                            DeclInfo di2;
-
-                            CPrep_UnLex();
-                            tk = TK_IDENTIFIER;
-                            tkidentifier = tclass2->classname;
-
-                            memclrw(&di2, sizeof(di2));
-                            CParser_GetDeclSpecs(&di2, 0);
-                            if (tk != '(')
-                                CError_Error(CErrorStr241);
-
-                            if (di2.thetype != TYPE(tclass2) && (!IS_TYPE_TEMPLATE(di2.thetype) || CTemplTool_IsTemplate(
-                                TYPE_TEMPLATE(di2.thetype)) != TEMPL_CLASS(tclass2)))
-                            {
-                                CError_Error(CErrorStr241);
-                            }
-                        } else {
-                            CError_Error(CErrorStr241);
-                        }
-                    }
-
-                    di.thetype = TYPE(&void_ptr);
-
-                    CTempl_SetupClassParamNameSpace(what_is_this, tclass2);
-                    tk = lex();
-                    CDecl_ParseDirectFuncDecl(&di);
-
-                    if (IS_TYPE_FUNC(di.thetype)) {
-                        if (tclass2->sominfo)
-                            di.qual |= Q_VIRTUAL;
-                        else
-                            CDecl_AddArgument(TYPE_FUNC(di.thetype), TYPE(&stsignedshort));
-
-                        di.name = destructor_name_node;
-                        TYPE_FUNC(di.thetype)->flags |= FUNC_IS_DTOR;
-                        CTempl_ParseMember(params, TEMPL_CLASS(tclass2), &di, startOffset);
-                    } else {
-                        CError_Error(CErrorStr241);
-                    }
-                } else if (tk == TK_OPERATOR) {
-                    CTempl_SetupClassParamNameSpace(what_is_this, tclass2);
-                    if (CMangler_OperatorName((tk = lex()))) {
-                        CError_Error(CErrorStr349);
-                        return;
-                    }
-
-                    CError_QualifierCheck(di.qual & ~(Q_INLINE | Q_VIRTUAL));
-                    conversion_type_name(&di);
-
-                    type = di.thetype;
-                    qual = di.qual;
-                    CDecl_NewConvFuncType(&di);
-
-                    if (CTemplTool_IsTemplateArgumentDependentType(type)) {
-                        di.name = CTempl_FindConversionFuncName(tclass2, type, qual);
-                        if (!di.name) {
-                            CError_Error(CErrorStr150, "conversion function");
-                            return;
-                        }
-                    }
-                    CTempl_ParseMember(params, TEMPL_CLASS(tclass2), &di, startOffset);
-                } else {
-                    CError_Error(CErrorStr121);
-                }
-
-                return;
-            }
-
-            if (TYPE_TEMPLATE(di.thetype)->dtype == TEMPLDEP_QUALNAME && !di.x49)
-                CError_Warning(CErrorStr355);
-        }
-    }
-
-    di.x30 = params;
-    di.fucker34 = what_is_this;
-    scandeclarator(&di);
-    ctempl_scanfuncparams = 0;
-
-skipPastStuff:
-    if (cscope_current->is_templ) {
-        CError_ASSERT(1589, cscope_current == what_is_this->nspace);
-        what_is_this->nspace->tparams = NULL;
-    }
-
-    if (!di.name) {
-        CError_Error(CErrorStr229);
-        return;
-    }
-
-    if (di.nspace) {
-        if (di.nspace->theclass) {
-            if (tclass)
-                CError_Error(CErrorStr229);
-            CTempl_ParseMember(params, TEMPL_CLASS(di.nspace->theclass), &di, startOffset);
-            return;
-        }
-
-        if (!IS_TYPE_FUNC(di.thetype)) {
-            CError_Error(CErrorStr229);
-            return;
-        }
-
-        CScope_FindName(di.nspace, di.name);
-    } else {
-        if (!IS_TYPE_FUNC(di.thetype)) {
-            CError_Error(CErrorStr229);
-            return;
-        }
-
-        CScope_FindName(cscope_current, di.name);
-    }
-
-    nsol = CScope_FindName(di.nspace ? di.nspace : cscope_current, di.name);
-    while (nsol) {
-        object = OBJECT(nsol->object);
-        if (object->otype == OT_OBJECT && IS_TEMPL_FUNC(object->type)) {
-            templfunc = CTemplTool_GetFuncTempl(object);
-            if (CTemplTool_EqualParams(templfunc->params, params, 0) && is_typesame(object->type, di.thetype)) {
-                if (tk != ';' && templfunc->stream.tokens)
-                    CError_Error(CErrorStr234);
-
-                if (tk == '{' || tk == ':' || tk == TK_TRY)
-                    CError_ASSERT(1654, CTemplTool_EqualParams(templfunc->params, params, 1));
-
-                if (di.qual & Q_INLINE)
-                    object->qual |= Q_INLINE;
-                TYPE_FUNC(object->type)->args = TYPE_FUNC(di.thetype)->args;
-                break;
-            }
-        }
-        nsol = nsol->next;
-    }
-
-    if (!nsol) {
-        if (di.nspace)
-            CError_Error(CErrorStr229);
-        templfunc = CTempl_DeclareTemplateFunction(&di, params, tclass, access, disallowCVFlag);
-    }
-
-    CTempl_ParseTemplateFunction(templfunc, tclass, startOffset);
-}
-
-static void CTempl_ExplicitInstantiation(void) {
-    Boolean flag;
-    short saveToken;
-    Object *object;
-    DeclInfo di;
-
-    memclrw(&di, sizeof(di));
-    di.x51 = 1;
-    flag = 1;
-
-    if (tk == TK_IDENTIFIER && !strcmp(tkidentifier->name, "__dont_instantiate")) {
-        flag = 0;
-        tk = lex();
-    }
-
-    switch (tk) {
-        case TK_STRUCT:
-        case TK_UNION:
-        case TK_CLASS:
-            memclrw(&di, sizeof(di));
-            CParser_GetDeclSpecs(&di, 0);
-            if (tk == ';') {
-                if (IS_TEMPL_CLASS_INST(di.thetype)) {
-                    CTempl_InstantiateTemplateClass(TYPE_CLASS(di.thetype));
-                    if ((TYPE_CLASS(di.thetype)->flags & CLASS_COMPLETED) && !(TYPE_CLASS(di.thetype)->eflags & CLASS_EFLAGS_IMPORT)) {
-                        if (flag)
-                            CTempl_GenClassInstance(TEMPL_CLASS_INST(di.thetype), 1);
-                        else
-                            TEMPL_CLASS_INST(di.thetype)->is_extern = 1;
-                    } else {
-                        CError_Error(CErrorStr136, TYPE_CLASS(di.thetype), 0);
-                    }
-                } else {
-                    CError_Error(CErrorStr238);
-                }
-                return;
-            }
-            break;
-        default:
-            memclrw(&di, sizeof(di));
-            CParser_GetDeclSpecs(&di, 0);
-    }
-
-    di.x51 = 1;
-
-    scandeclarator(&di);
-
-    saveToken = tk;
-
-    di.x38 = NULL;
-    if (
-        di.name &&
-        IS_TYPE_FUNC(di.thetype) &&
-        (object = CDecl_GetFunctionObject(&di, di.nspace, NULL, 1)) &&
-        IS_TYPE_FUNC(object->type) &&
-        object->u.func.inst &&
-        di.x38
-        )
-    {
-        if (!flag)
-            object->u.func.inst->is_extern = 1;
-        else
-            CTempl_GenFuncInstance(di.x38, object->u.func.inst, 1);
-    } else {
-        CError_Error(CErrorStr238);
-    }
-
-    if (saveToken != ';')
-        CError_Error(CErrorStr123);
-}
-
-static void CTempl_ExplicitSpecialization(void) {
-    Boolean flag;
-    TemplParam *params;
-    int counter;
-    DeclFucker what_is_this;
-    DeclInfo di;
-
-    flag = 0;
-    counter = 1;
-    while (tk == TK_TEMPLATE) {
-        if ((tk = lex()) != '<') {
-            CError_Error(CErrorStr230);
-            break;
-        }
-
-        if ((tk = lex()) != '>') {
-            if (!flag) {
-                what_is_this.nspace = cscope_current;
-                what_is_this.mystery4 = NULL;
-                cscope_current->tparams = NULL;
-                flag = 1;
-            }
-
-            params = CTempl_ParseParamList(what_is_this.nspace, counter);
-            if (tk != '>')
-                CError_Error(CErrorStr231);
-        } else {
-            if (flag)
-                CError_Error(CErrorStr335);
-        }
-
-        counter++;
-        tk = lex();
-    }
-
-    if (flag) {
-        SInt32 startOffset = -1;
-        CTempl_ParseFunctionOrMemberTemplate(&what_is_this, params, NULL, &startOffset, ACCESSPUBLIC, 1);
-        return;
-    }
-
-    memclrw(&di, sizeof(di));
-    di.x3C = counter;
-    di.x51 = 1;
-    CParser_GetDeclSpecs(&di, 1);
-
-    if (tk == ';') {
-        if (IS_TEMPL_CLASS_INST(di.thetype))
-            TEMPL_CLASS_INST(di.thetype)->is_specialized = 1;
-        else
-            CError_Error(CErrorStr335);
-    } else {
-        scandeclaratorlist(&di);
-        if ((tk != ';' && tk != '}') || di.x3C)
-            CError_Error(CErrorStr335);
-    }
-
-    if (flag)
-        what_is_this.nspace->tparams = NULL;
-}
-
-void CTempl_Parse(TemplClass *templ, AccessType access) {
-    TemplParam *params;
-    UInt8 i;
-    short mode;
-    Boolean flag;
-    UInt8 classDeclSpec;
-    SInt32 startOffset;
-    SInt32 savedState;
-    CScopeSave savedScope;
-    DeclFucker what_is_this;
-
-    startOffset = CPrep_BrowserFileOffset();
-    CScope_GetScope(&savedScope);
-
-    if ((tk = lex()) != '<') {
-        if (templ)
-            CError_Error(CErrorStr238);
-        CTempl_ExplicitInstantiation();
-        CScope_RestoreScope(&savedScope);
-        return;
-    }
-
-    if ((tk = lex()) == '>') {
-        if (templ)
-            CError_Error(CErrorStr335);
-        tk = lex();
-        CTempl_ExplicitSpecialization();
-        CScope_RestoreScope(&savedScope);
-        return;
-    }
-
-    what_is_this.nspace = cscope_current;
-    what_is_this.mystery4 = NULL;
-    cscope_current->tparams = NULL;
-    i = CTempl_GetTemplateNestIndex(what_is_this.nspace);
-
-    while (1) {
-        params = CTempl_ParseParamList(what_is_this.nspace, i);
-        if (tk != '>')
-            CError_Error(CErrorStr231);
-
-        if ((tk = lex()) != TK_TEMPLATE)
-            break;
-
-        if (templ)
-            CError_Error(CErrorStr121);
-
-        if ((tk = lex()) != '<')
-            CError_Error(CErrorStr230);
-        else
-            tk = lex();
-
-        i++;
-    }
-
-    switch (tk) {
-        case TK_CLASS:
-            mode = CLASS_MODE_CLASS;
-            break;
-        case TK_UNION:
-            mode = CLASS_MODE_UNION;
-            break;
-        case TK_STRUCT:
-            mode = CLASS_MODE_STRUCT;
-            break;
-        default:
-            mode = -1;
-    }
-
-    if (mode >= 0) {
-        classDeclSpec = 0;
-        flag = 0;
-
-        CPrep_TokenStreamGetState(&savedState);
-        if ((tk = lex()) == TK_UU_DECLSPEC)
-            CDecl_ParseClassDeclSpec(&classDeclSpec);
-
-        if (tk == TK_IDENTIFIER) {
-            if ((tk = lex()) == '<') {
-                if (setjmp(ctempl_parseparse) == 0) {
-                    CTempl_MemberParseTemplArgList();
-                    flag = 1;
-                    tk = lex();
-                }
-            }
-
-            switch (tk) {
-                case ':':
-                case ';':
-                case '{':
-                    CPrep_TokenStreamSetCurState(&savedState);
-                    if (flag)
-                        CTemplClass_ParsePartialSpecialization(&what_is_this, params, mode, &startOffset);
-                    else
-                        CTemplClass_ParseClass(&what_is_this, params, mode, &startOffset);
-                    goto done;
-            }
-        }
-
-        CPrep_TokenStreamSetCurState(&savedState);
-    }
-
-    CTempl_ParseFunctionOrMemberTemplate(&what_is_this, params, TYPE_CLASS(templ), &startOffset, access, 0);
-
-done:
-    what_is_this.nspace->tparams = NULL;
-    CScope_RestoreScope(&savedScope);
-}
-
-void CTempl_ParseInstanceScopeFunction(Object *funcobj, TemplClassInst *inst, TypeClass *tclass) {
-    TemplParam *params;
-    NameSpace *nspace;
-    TemplateMember *member;
-    Object *parent;
-    DeclInfo di;
-    CScopeSave savedScope;
-    TemplStack stack;
-
-    params = inst->templ->templ__params;
-    if (funcobj->qual & Q_IS_TEMPLATED) {
-        for (member = CTemplClass_GetMasterTemplate(inst->templ)->members, parent = OBJECT_TEMPL(funcobj)->parent; member; member = member->next) {
-            if (member->object == parent) {
-                if (member->params)
-                    params = member->params;
-                break;
-            }
-        }
-    }
-
-    CTemplTool_PushInstance(&stack, NULL, funcobj);
-    nspace = CTemplTool_InsertTemplateArgumentNameSpace(params, inst, &savedScope);
-    if (tclass)
-        cscope_current = tclass->nspace;
-
-    memclrw(&di, sizeof(di));
-    CFunc_ParseFuncDef(funcobj, &di, NULL, 0, 0, tclass ? cscope_current : NULL);
-
-    CTemplTool_RemoveTemplateArgumentNameSpace(nspace, inst, &savedScope);
-    CTemplTool_PopInstance(&stack);
-}
-
-Boolean CTempl_GenFuncInstance(TemplateFunction *templ, TemplFuncInstance *inst, Boolean flag) {
-    Boolean saveDebugInfo;
-    NameSpace *nspace;
-    SInt32 streamState;
-    TemplStack stack;
-    DeclInfo di;
-
-    if (!flag && copts.no_implicit_templates && inst->object->sclass != TK_STATIC)
-        return 0;
-
-    if (inst->is_extern && !flag)
-        return 0;
-
-    while (1) {
-        if (templ->stream.tokens)
-            break;
-        if (!templ->unk4)
-            break;
-        templ = templ->unk4;
-    }
-
-    if (!templ->stream.tokens) {
-        if (flag) {
-            CError_SetErrorToken(&templ->deftoken);
-            CError_Error(CErrorStr233, inst->object);
-        }
-        return 0;
-    }
-
-    inst->is_instantiated = 1;
-
-    CPrep_StreamInsert(&templ->stream, &streamState);
-
-    saveDebugInfo = copts.filesyminfo;
-    if (copts.nosyminline || !templ->deftoken.tokenfile)
-        copts.filesyminfo = 0;
-
-    CError_ASSERT(2112, (tk = lex()) == '{' || tk == ':' || tk == TK_TRY);
-
-    symdecltoken = *CPrep_CurStreamElement();
-
-    if (copts.filesyminfo) {
-        CPrep_NewFileOffsetInfo(&cparser_fileoffset, &templ->deftoken);
-        symdecloffset = cparser_fileoffset.tokenline;
-    }
-
-    if (inst->object->sclass != TK_STATIC)
-        inst->object->qual |= Q_WEAK;
-
-    memclrw(&di, sizeof(di));
-    di.file2 = templ->srcfile;
-    di.file = CPrep_BrowserCurrentFile();
-    di.sourceoffset = templ->startoffset;
-
-    CTemplTool_PushInstance(&stack, NULL, inst->object);
-    CTemplTool_MergeArgNames(TYPE_FUNC(templ->tfunc->type), TYPE_FUNC(inst->object->type));
-
-    nspace = CTemplTool_SetupTemplateArgumentNameSpace(templ->params, inst->args, 0);
-    nspace->parent = inst->object->nspace;
-    inst->object->nspace = nspace;
-
-    CTemplTool_SetupOuterTemplateArgumentNameSpace(nspace);
-    CFunc_ParseFuncDef(inst->object, &di, NULL, 0, 0, nspace);
-    CTemplTool_RemoveOuterTemplateArgumentNameSpace(nspace);
-
-    inst->object->nspace = nspace->parent;
-
-    CTemplTool_PopInstance(&stack);
-
-    CPrep_StreamRemove(&templ->stream, &streamState);
-    copts.filesyminfo = saveDebugInfo;
-
-    if (di.file->recordbrowseinfo)
-        CBrowse_NewFunction(inst->object, di.file, di.file2, di.sourceoffset, templ->endoffset);
-
-    return 1;
-}
-
-void CTempl_InstantiateMember(TemplClass *templ, TemplClassInst *inst, TemplateMember *tmemb, Object *object, Boolean flag) {
-    Boolean saveDebugInfo;
-    NameSpace *nspace;
-    Boolean saveSourceLoc;
-
-    DeclInfo di;
-    CScopeSave savedScope;
-    TemplStack stack;
-    SInt32 savedState;
-
-    if (!flag && copts.no_implicit_templates)
-        return;
-
-    CTemplTool_PushInstance(&stack, NULL, object);
-    nspace = CTemplTool_InsertTemplateArgumentNameSpace(
-        tmemb->params ? tmemb->params : templ->templ__params, inst, &savedScope);
-    CPrep_StreamInsert(&tmemb->stream, &savedState);
-
-    saveSourceLoc = gForceSourceLoc;
-    gForceSourceLoc = 1;
-    symdecltoken.tokenoffset = tmemb->startoffset;
-    tk = lex();
-
-    symdecltoken = *CPrep_CurStreamElement();
-
-    saveDebugInfo = copts.filesyminfo;
-    if (copts.filesyminfo) {
-        CPrep_NewFileOffsetInfo(&cparser_fileoffset, &symdecltoken);
-        symdecloffset = cparser_fileoffset.tokenline;
-    }
-
-    if (object->sclass != TK_STATIC)
-        object->qual |= Q_WEAK;
-
-    memclrw(&di, sizeof(di));
-    di.file2 = tmemb->srcfile;
-    di.file = CPrep_BrowserCurrentFile();
-    di.sourceoffset = tmemb->startoffset;
-
-    switch (object->datatype) {
-        case DFUNC:
-        case DVFUNC:
-            CTemplTool_MergeArgNames(TYPE_FUNC(tmemb->object->type), TYPE_FUNC(object->type));
-            CFunc_ParseFuncDef(object, &di, TYPE_CLASS(inst), 0, 0, NULL);
-            break;
-
-        case DDATA:
-            CDecl_CompleteType(object->type);
-            CInit_InitializeData(object);
-            break;
-
-        default:
-            CError_FATAL(2227);
-    }
-
-    CTemplTool_PopInstance(&stack);
-    CTemplTool_RemoveTemplateArgumentNameSpace(nspace, inst, &savedScope);
-    CPrep_StreamRemove(&tmemb->stream, &savedState);
-    copts.filesyminfo = saveDebugInfo;
-    gForceSourceLoc = saveSourceLoc;
-}
-
-static Boolean CTempl_GenMemberInstance(TemplClassInst *inst, ObjectTemplated *objtempl, Boolean flag) {
-    TemplateMember *member;
-    Object *parent = objtempl->parent;
-
-    for (member = CTemplClass_GetMasterTemplate(inst->templ)->members; member; member = member->next) {
-        if (member->object == parent) {
-            CTempl_InstantiateMember(inst->templ, inst, member, OBJECT(objtempl), flag);
-            return 1;
-        }
-    }
-
-    if (flag)
-        CError_Warning(CErrorStr233, objtempl);
-    return 0;
-}
-
-static Boolean CTempl_GenClassInstance(TemplClassInst *inst, Boolean flag) {
-    Object *object;
-    Boolean result;
-    CScopeObjectIterator iter;
-
-    result = 0;
-
-    if (!flag && copts.no_implicit_templates)
-        return 0;
-    if (!flag && inst->is_extern)
-        return 0;
-
-    CScope_InitObjectIterator(&iter, inst->theclass.nspace);
-    while ((object = OBJECT(CScope_NextObjectIteratorObject(&iter)))) {
-        if (IS_TYPE_FUNC(object->type) && object->datatype != DALIAS) {
-            if (
-                (flag || (object->flags & OBJECT_FLAGS_2)) &&
-                !(TYPE_FUNC(object->type)->flags & (FUNC_DEFINED | FUNC_AUTO_GENERATED)) &&
-                CTempl_GenMemberInstance(inst, OBJECT_TEMPL(object), flag) &&
-                (TYPE_FUNC(object->type)->flags & FUNC_DEFINED)
-                )
-                result = 1;
-        } else {
-            if (
-                !inst->static_instantiated &&
-                object->datatype == DDATA &&
-                !(object->qual & Q_INLINE_DATA) &&
-                !(object->flags & OBJECT_DEFINED) &&
-                CTempl_GenMemberInstance(inst, OBJECT_TEMPL(object), flag)
-                )
-                result = 1;
-        }
-    }
-
-    inst->static_instantiated = 1;
-    return result;
-}
-
-Boolean CTempl_Instantiate(void) {
-    Boolean result = 0;
-    TemplClass *templ;
-    TemplClassInst *inst;
-    TemplPartialSpec *pspec;
-    TemplFuncInstance *instf;
-    TemplateFunction *templf;
-
-    for (templ = ctempl_templates; templ; templ = templ->next) {
-        for (inst = templ->instances; inst; inst = inst->next) {
-            if (
-                (inst->theclass.flags & CLASS_IS_TEMPL_INST) &&
-                !inst->is_specialized &&
-                CTempl_GenClassInstance(inst, 0)
-                )
-                result = 1;
-        }
-
-        for (pspec = templ->pspecs; pspec; pspec = pspec->next) {
-            for (inst = pspec->templ->instances; inst; inst = inst->next) {
-                if (
-                    (inst->theclass.flags & CLASS_IS_TEMPL_INST) &&
-                    !inst->is_specialized &&
-                    CTempl_GenClassInstance(inst, 0)
-                    )
-                    result = 1;
-            }
-        }
-    }
-
-    for (templf = ctempl_templatefuncs; templf; templf = templf->next) {
-        for (instf = templf->instances; instf; instf = instf->next) {
-            if (
-                !instf->is_instantiated &&
-                !instf->is_specialized &&
-                (instf->object->flags & OBJECT_FLAGS_2) &&
-                !(TYPE_FUNC(instf->object->type)->flags & FUNC_DEFINED)
-                )
-            {
-                instf->is_instantiated = 1;
-                if (CTempl_GenFuncInstance(templf, instf, 0))
-                    result = 1;
-            }
-        }
-    }
-
-    return result;
-}
-
-Boolean CTempl_InlineFunctionCheck(Object *funcobj) {
-    TemplClassInst *inst;
-    TemplateMember *member;
-    Object *parent;
-
-    CError_ASSERT(2422, IS_TYPE_FUNC(funcobj->type) && (funcobj->qual & Q_IS_TEMPLATED));
-
-    if (!(TYPE_FUNC(funcobj->type)->flags & FUNC_DEFINED)) {
-        inst = TEMPL_CLASS_INST(TYPE_METHOD(funcobj->type)->theclass);
-        if (!inst->is_specialized) {
-            parent = OBJECT_TEMPL(funcobj)->parent;
-            if (parent->qual & Q_INLINE) {
-                for (member = CTemplClass_GetMasterTemplate(inst->templ)->members; member; member = member->next) {
-                    funcobj->qual |= Q_INLINE;
-                    if (member->object == parent) {
-                        CTemplTool_MergeArgNames(TYPE_FUNC(member->object->type), TYPE_FUNC(funcobj->type));
-                        CInline_AddInlineFunctionAction(funcobj, TYPE_CLASS(inst), &member->fileoffset, &member->stream, 0);
-                        return 1;
-                    }
-                }
-            }
-        }
-    }
-
-    return 0;
-}