io Programmo 40/IOPROG_40.ISO/SOFT/NETFrameworkSDK.exe/comsdk.cab/samples1.exe/smc/macros.i.checked

Text File | 2000-06-23 | 79.3 KB | 5,844 lines

#line 1 "macros.cpp"








#line 1 "smcPCH.h"



















#line 10 "macros.cpp"
#pragma hdrstop


#line 1 "macros.h"







#line 9 "macros.h"










#line 20 "macros.h"

#line 14 "macros.cpp"


#line 17 "macros.cpp"





#line 1 "tokens.h"









enum tokens
{








    #line 1 "keywords.h"







#line 9 "keywords.h"




#line 14 "keywords.h"






















tkNone,



tkABSTRACT,
tkAPPDOMAIN,
tkARRAYLEN,
tkASSERT,
tkASYNCH,
tkATTRIBUTE,

tkBASECLASS,
tkBOOL,
tkBREAK,
tkBYREF,
tkBYTE,
tkCAPABILITY,
tkCASE,
tkCATCH,
tkCHAR,
tkCLASS,
tkCOMPARE,
tkCONST,
tkCONTEXTFUL,
tkCONTINUE,
tkDEFINED,
tkDEFAULT,
tkDELEGATE,
tkDELETE,
tkDO,
tkDOUBLE,
tkELSE,
tkENUM,
tkEQUALS,
tkEXCEPT,
tkEXCLUSIVE,

tkEXPLICIT,
tkEXTERN,
tkFALSE,
tkFINALLY,
tkFLOAT,
tkFOR,
tkGOTO,
tkIF,
tkIMPLEMENTS,
tkIMPLICIT,
tkIN,
tkINCLUDES,
tkINLINE,
tkINOUT,
tkINT,
tkINT8,
tkINT16,
tkINT32,
tkINT64,
tkINTERFACE,
tkISTYPE,
tkLONGINT,
tkMANAGED,
tkMULTICAST,
tkNAMESPACE,
tkNATIVE,
tkNATURALINT,
tkNATURALUINT,
tkNEW,
tkNULL,
tkOUT,
tkOPERATOR,
tkOVERRIDE,
tkOVERLOAD,
tkPERMISSION,
tkPRIVATE,
tkPROPERTY,
tkPROTECTED,
tkPUBLIC,
tkREFADDR,
tkREGISTER,
tkRETURN,
tkSEALED,
tkSERIALIZABLE,
tkSHORT,
tkSIGNED,
tkSIZEOF,
tkSTATIC,
tkSTRUCT,
tkSWITCH,
tkTHIS,
tkTHROW,
tkTRANSIENT,
tkTYPEOF,
tkTYPEDEF,
tkTRUE,
tkTRY,
tkUINT8,
tkUINT16,
tkUINT32,
tkUINT64,
tkUINT,
tkULONGINT,
tkUNION,
tkUNMANAGED,
tkUNSAFE,
tkUNSIGNED,
tkUSHORT,
tkUSING,
tkVOID,
tkVIRTUAL,
tkVOLATILE,
tkWCHAR,
tkWHILE,
tkFILE,
tkLINE,



tkComma, tkFirstOper =tkComma,

tkAsg,
tkAsgAdd,
tkAsgSub,
tkAsgMul,
tkAsgDiv,
tkAsgMod,

tkAsgAnd,
tkAsgXor,
tkAsgOr,

tkAsgLsh,
tkAsgRsh,
tkAsgRsz,

tkAsgCnc,

tkQMark,
tkColon,

tkLogOr,
tkLogAnd,

tkOr,

tkXor,
tkAnd,

tkConcat,

tkEQ,
tkNE,

tkLT,
tkLE,
tkGE,
tkGT,

tkLsh,
tkRsh,
tkRsz,

tkAdd,
tkSub,

tkMul,
tkDiv,
tkPct,

tkTilde,
tkBang,
tkInc,
tkDec,

tkLParen,
tkLBrack,
tkDot,
tkArrow,

tkSColon,
tkRParen,
tkRBrack,
tkLCurly,
tkRCurly,
tkColon2,
tkDot2,
tkEllipsis,


tkID, tkKwdCount, tkKwdLast = tkKwdCount-1,
tkQUALID,
tkHACKID,



tkEOL,
tkEOF,

tkAtComment,

tkIntCon,
tkLngCon,
tkFltCon,
tkDblCon,
tkStrCon,






#line 21 "tokens.h"

    tkCount,



    tkPragma,

    tkIntConM,
    tkIntCon0,
    tkIntCon1,
    tkIntCon2,
    tkIntConB,

    tkLnoAdd1,
    tkLnoAdd2,
    tkLnoAdd3,
    tkLnoAdd4,
    tkLnoAdd5,
    tkLnoAdd6,
    tkLnoAdd7,
    tkLnoAdd8,
    tkLnoAdd9,
    tkLnoAddB,
    tkLnoAddI,

    tkBrkSeq,
    tkEndSeq,

    tkLastValue,

    tkNoToken = 0x12345678
};


#line 56 "tokens.h"

#line 23 "macros.cpp"
#line 1 "treeops.h"





enum treeOps
{

    #line 1 "toplist.h"















TN_ERROR,
TN_NONE,





TN_NAME,
TN_THIS,
TN_BASE,
TN_DBGBRK,





TN_CNS_INT,
TN_CNS_LNG,
TN_CNS_FLT,
TN_CNS_DBL,
TN_CNS_STR,
TN_NULL,





TN_ADDROF,

TN_NOT,
TN_LOG_NOT,
TN_NOP,
TN_NEG,
TN_THROW,

TN_INC_POST,
TN_DEC_POST,
TN_INC_PRE,
TN_DEC_PRE,

TN_TYPE,
TN_TOKEN,

TN_INST_STUB,





TN_ADD,
TN_SUB,
TN_MUL,
TN_DIV,
TN_MOD,

TN_AND,
TN_XOR,
TN_OR,

TN_LSH,
TN_RSH,
TN_RSZ,

TN_EQ,
TN_NE,
TN_LT,
TN_LE,
TN_GE,
TN_GT,



TN_ASG,
TN_ASG_ADD,
TN_ASG_SUB,
TN_ASG_MUL,
TN_ASG_DIV,
TN_ASG_MOD,

TN_ASG_AND,
TN_ASG_XOR,
TN_ASG_OR,

TN_ASG_LSH,
TN_ASG_RSH,
TN_ASG_RSZ,

TN_ASG_CNC,

TN_COMMA,

TN_QMARK,
TN_COLON,

TN_LOG_OR,
TN_LOG_AND,

TN_ISTYPE,

TN_INDEX,
TN_CALL,
TN_ARROW,

TN_REFADDR,





TN_IND,

TN_NEW,
TN_DELETE,

TN_CONCAT,
TN_CONCAT_ASG,

TN_AND_NOSTR,
TN_ANA_NOSTR,

TN_LIST,

TN_CAST,

TN_CLASS,

TN_TRY,
TN_CATCH,
TN_EXCEPT,
TN_FINALLY,

TN_DOT,
TN_DOT_NAME,

TN_GOTO,
TN_LABEL,

TN_ARR_INIT,
TN_ARR_LEN,

TN_SIZEOF,
TN_TYPEOF,

TN_BOX,
TN_UNBOX,





TN_EXPR_STMT,

TN_IF,

TN_DO,
TN_FOR,
TN_WHILE,

TN_EXCLUDE,

TN_BREAK,
TN_CONTINUE,

TN_SWITCH,
TN_CASE,

TN_RETURN,

TN_ASSERT,

TN_VARARG_BEG,
TN_VARARG_GET,





TN_NAMESPACE,
TN_ANY_SYM,
TN_LCL_SYM,
TN_MEM_SYM,
TN_VAR_SYM,
TN_BFM_SYM,
TN_FNC_SYM,
TN_FNC_PTR,
TN_PROPERTY,

TN_BLOCK,





TN_VAR_DECL,
TN_SLV_INIT,





TN_DCL_VAR,





TN_DEFINED,




#line 10 "treeops.h"

    TN_COUNT
};


#line 16 "treeops.h"

#line 24 "macros.cpp"




#line 1 "symsizes.h"





const   size_t  symDef_size_base    = (((size_t)&(((SymDefRec*)0)->sdBase)));

const   size_t  symDef_size_err     = (((size_t)&(((SymDefRec*)0)->sdBase)));
const   size_t  symDef_size_var     = ((((size_t)&(((SymDefRec*)0)->sdVar)) + sizeof(((SymDefRec *)0)->sdVar)));
const   size_t  symDef_size_fnc     = ((((size_t)&(((SymDefRec*)0)->sdFnc)) + sizeof(((SymDefRec *)0)->sdFnc)));
const   size_t  symDef_size_prop    = ((((size_t)&(((SymDefRec*)0)->sdProp)) + sizeof(((SymDefRec *)0)->sdProp)));
const   size_t  symDef_size_label   = ((((size_t)&(((SymDefRec*)0)->sdLabel)) + sizeof(((SymDefRec *)0)->sdLabel)));
const   size_t  symDef_size_using   = ((((size_t)&(((SymDefRec*)0)->sdUsing)) + sizeof(((SymDefRec *)0)->sdUsing)));
const   size_t  symDef_size_genarg  = ((((size_t)&(((SymDefRec*)0)->sdGenArg)) + sizeof(((SymDefRec *)0)->sdGenArg)));
const   size_t  symDef_size_enumval = ((((size_t)&(((SymDefRec*)0)->sdEnumVal)) + sizeof(((SymDefRec *)0)->sdEnumVal)));
const   size_t  symDef_size_typedef = ((((size_t)&(((SymDefRec*)0)->sdTypeDef)) + sizeof(((SymDefRec *)0)->sdTypeDef)));
const   size_t  symDef_size_comp    = ((((size_t)&(((SymDefRec*)0)->sdComp)) + sizeof(((SymDefRec *)0)->sdComp)));

const   size_t  symDef_size_enum    = ((((size_t)&(((SymDefRec*)0)->sdEnum)) + sizeof(((SymDefRec *)0)->sdEnum)));
const   size_t  symDef_size_class   = ((((size_t)&(((SymDefRec*)0)->sdClass)) + sizeof(((SymDefRec *)0)->sdClass)));
const   size_t  symDef_size_NS      = ((((size_t)&(((SymDefRec*)0)->sdNS)) + sizeof(((SymDefRec *)0)->sdNS)));
const   size_t  symDef_size_scope   = ((((size_t)&(((SymDefRec*)0)->sdScope)) + sizeof(((SymDefRec *)0)->sdScope)));


#line 26 "symsizes.h"

#line 29 "macros.cpp"
#line 1 "typsizes.h"






const   size_t  typDef_size_base    = (((size_t)&(((TypDefRec*)0)->tdIntrinsic)));

const   size_t  typDef_size_array   = ((((size_t)&(((TypDefRec*)0)->tdArr)) + sizeof(((TypDefRec *)0)->tdArr)));
const   size_t  typDef_size_fnc     = ((((size_t)&(((TypDefRec*)0)->tdFnc)) + sizeof(((TypDefRec *)0)->tdFnc)));
const   size_t  typDef_size_ptr     = ((((size_t)&(((TypDefRec*)0)->tdRef)) + sizeof(((TypDefRec *)0)->tdRef)));
const   size_t  typDef_size_ref     = ((((size_t)&(((TypDefRec*)0)->tdRef)) + sizeof(((TypDefRec *)0)->tdRef)));
const   size_t  typDef_size_enum    = ((((size_t)&(((TypDefRec*)0)->tdEnum)) + sizeof(((TypDefRec *)0)->tdEnum)));
const   size_t  typDef_size_undef   = ((((size_t)&(((TypDefRec*)0)->tdUndef)) + sizeof(((TypDefRec *)0)->tdUndef)));
const   size_t  typDef_size_class   = ((((size_t)&(((TypDefRec*)0)->tdClass)) + sizeof(((TypDefRec *)0)->tdClass)));
const   size_t  typDef_size_typedef = ((((size_t)&(((TypDefRec*)0)->tdTypedef)) + sizeof(((TypDefRec *)0)->tdTypedef)));


#line 20 "typsizes.h"

#line 30 "macros.cpp"
#line 31 "macros.cpp"



#line 1 "config.h"





enum compilerPhases
{
    CPH_NONE,
    CPH_START,
    CPH_PARSING,
};

struct  compConfig
{
    compilerPhases  ccCurPhase;


    #line 1 "options.h"






bool ccQuiet;
bool ccSafeMode;
bool ccPedantic;
bool ccChkUseDef;

const char * ccBaseLibs;
StrList ccSuckList;
StrList ccSuckLast;
StrList ccPathList;
StrList ccPathLast;

unsigned ccOutBase;
unsigned ccOutSize;
bool ccOutDLL;

unsigned ccSubsystem;

bool ccNoDefines;
StrList ccMacList;
StrList ccMacLast;

bool ccStrValCmp;

bool ccOldStyle;

bool ccNewMDnames;

unsigned char ccAsserts;

unsigned char ccAlignVal;

bool ccGenDebug;
bool ccLineNums;
bool ccParamNames;

const char * ccOutFileName;


int ccVerbose;
bool ccDispCode;
bool ccDispILcd;
#line 49 "options.h"

GUID ccOutGUID;
const char * ccOutName;
const char * ccRCfile;
const char * ccMainCls;
bool ccSkipATC;

StrList ccModList;
StrList ccModLast;

StrList ccMRIlist;
StrList ccMRIlast;












bool ccRecDir;

signed char ccWarnLvl;
bool ccWarnErr;

unsigned ccMaxErrs;

bool ccAssembly;
bool ccAsmNoPubTp;
bool ccAsmNonCLS;

bool ccAmbigHack;

bool ccAsynchIO;

bool ccTgt64bit;
bool ccIntEnums;

unsigned ccTestMask;


#line 19 "config.h"

    BYTE            ccWarning[WRNcountWarn];
};

enum    enumConfig
{

    #line 1 "options.h"






CC_Quiet,
CC_SafeMode,
CC_Pedantic,
CC_ChkUseDef,

CC_BaseLibs,
CC_SuckList,
CC_SuckLast,
CC_PathList,
CC_PathLast,

CC_OutBase,
CC_OutSize,
CC_OutDLL,

CC_Subsystem,

CC_NoDefines,
CC_MacList,
CC_MacLast,

CC_StrValCmp,

CC_OldStyle,

CC_NewMDnames,

CC_Asserts,

CC_AlignVal,

CC_GenDebug,
CC_LineNums,
CC_ParamNames,

CC_OutFileName,


CC_Verbose,
CC_DispCode,
CC_DispILcd,
#line 49 "options.h"

CC_OutGUID,
CC_OutName,
CC_RCfile,
CC_MainCls,
CC_SkipATC,

CC_ModList,
CC_ModLast,

CC_MRIlist,
CC_MRIlast,












CC_RecDir,

CC_WarnLvl,
CC_WarnErr,

CC_MaxErrs,

CC_Assembly,
CC_AsmNoPubTp,
CC_AsmNonCLS,

CC_AmbigHack,

CC_AsynchIO,

CC_Tgt64bit,
CC_IntEnums,

CC_TestMask,


#line 27 "config.h"

    CC_COUNT
};




struct  optionDesc
{
    unsigned            odValueOffs :16;
    unsigned            odValueSize :8;

    unsigned            odMaxPhase  :8;

    int                 odDefault;
};






#line 50 "config.h"

#line 35 "macros.cpp"

optionDesc      optionInfo[] =
{








    #line 1 "options.h"






{ ((size_t)&(((compConfig*)0)->ccQuiet)), sizeof(bool), CPH_NONE, (int)false },
{ ((size_t)&(((compConfig*)0)->ccSafeMode)), sizeof(bool), CPH_NONE, (int)false },
{ ((size_t)&(((compConfig*)0)->ccPedantic)), sizeof(bool), CPH_NONE, (int)false },
{ ((size_t)&(((compConfig*)0)->ccChkUseDef)), sizeof(bool), CPH_NONE, (int)true },

{ ((size_t)&(((compConfig*)0)->ccBaseLibs)), sizeof(const char *), CPH_NONE, (int)"" },
{ ((size_t)&(((compConfig*)0)->ccSuckList)), sizeof(StrList), CPH_NONE, (int)NULL },
{ ((size_t)&(((compConfig*)0)->ccSuckLast)), sizeof(StrList), CPH_NONE, (int)NULL },
{ ((size_t)&(((compConfig*)0)->ccPathList)), sizeof(StrList), CPH_NONE, (int)NULL },
{ ((size_t)&(((compConfig*)0)->ccPathLast)), sizeof(StrList), CPH_NONE, (int)NULL },

{ ((size_t)&(((compConfig*)0)->ccOutBase)), sizeof(unsigned), CPH_NONE, (int)0 },
{ ((size_t)&(((compConfig*)0)->ccOutSize)), sizeof(unsigned), CPH_NONE, (int)0 },
{ ((size_t)&(((compConfig*)0)->ccOutDLL)), sizeof(bool), CPH_NONE, (int)false },

{ ((size_t)&(((compConfig*)0)->ccSubsystem)), sizeof(unsigned), CPH_NONE, (int)IMAGE_SUBSYSTEM_WINDOWS_CUI },

{ ((size_t)&(((compConfig*)0)->ccNoDefines)), sizeof(bool), CPH_NONE, (int)false },
{ ((size_t)&(((compConfig*)0)->ccMacList)), sizeof(StrList), CPH_NONE, (int)NULL },
{ ((size_t)&(((compConfig*)0)->ccMacLast)), sizeof(StrList), CPH_NONE, (int)NULL },

{ ((size_t)&(((compConfig*)0)->ccStrValCmp)), sizeof(bool), CPH_PARSING, (int)false },

{ ((size_t)&(((compConfig*)0)->ccOldStyle)), sizeof(bool), CPH_PARSING, (int)false },

{ ((size_t)&(((compConfig*)0)->ccNewMDnames)), sizeof(bool), CPH_NONE, (int)true },

{ ((size_t)&(((compConfig*)0)->ccAsserts)), sizeof(unsigned char), CPH_NONE, (int)0 },

{ ((size_t)&(((compConfig*)0)->ccAlignVal)), sizeof(unsigned char), CPH_NONE, (int)sizeof(int) },

{ ((size_t)&(((compConfig*)0)->ccGenDebug)), sizeof(bool), CPH_NONE, (int)false },
{ ((size_t)&(((compConfig*)0)->ccLineNums)), sizeof(bool), CPH_NONE, (int)false },
{ ((size_t)&(((compConfig*)0)->ccParamNames)), sizeof(bool), CPH_NONE, (int)false },

{ ((size_t)&(((compConfig*)0)->ccOutFileName)), sizeof(const char *), CPH_NONE, (int)NULL },


{ ((size_t)&(((compConfig*)0)->ccVerbose)), sizeof(int), CPH_NONE, (int)false },
{ ((size_t)&(((compConfig*)0)->ccDispCode)), sizeof(bool), CPH_NONE, (int)false },
{ ((size_t)&(((compConfig*)0)->ccDispILcd)), sizeof(bool), CPH_NONE, (int)false },
#line 49 "options.h"

{ ((size_t)&(((compConfig*)0)->ccOutGUID)), sizeof(GUID), CPH_NONE, (int)NULL },
{ ((size_t)&(((compConfig*)0)->ccOutName)), sizeof(const char *), CPH_NONE, (int)NULL },
{ ((size_t)&(((compConfig*)0)->ccRCfile)), sizeof(const char *), CPH_NONE, (int)NULL },
{ ((size_t)&(((compConfig*)0)->ccMainCls)), sizeof(const char *), CPH_NONE, (int)NULL },
{ ((size_t)&(((compConfig*)0)->ccSkipATC)), sizeof(bool), CPH_NONE, (int)false },

{ ((size_t)&(((compConfig*)0)->ccModList)), sizeof(StrList), CPH_NONE, (int)NULL },
{ ((size_t)&(((compConfig*)0)->ccModLast)), sizeof(StrList), CPH_NONE, (int)NULL },

{ ((size_t)&(((compConfig*)0)->ccMRIlist)), sizeof(StrList), CPH_NONE, (int)NULL },
{ ((size_t)&(((compConfig*)0)->ccMRIlast)), sizeof(StrList), CPH_NONE, (int)NULL },












{ ((size_t)&(((compConfig*)0)->ccRecDir)), sizeof(bool), CPH_NONE, (int)false },

{ ((size_t)&(((compConfig*)0)->ccWarnLvl)), sizeof(signed char), CPH_NONE, (int)1 },
{ ((size_t)&(((compConfig*)0)->ccWarnErr)), sizeof(bool), CPH_NONE, (int)false },

{ ((size_t)&(((compConfig*)0)->ccMaxErrs)), sizeof(unsigned), CPH_NONE, (int)50 },

{ ((size_t)&(((compConfig*)0)->ccAssembly)), sizeof(bool), CPH_NONE, (int)true },
{ ((size_t)&(((compConfig*)0)->ccAsmNoPubTp)), sizeof(bool), CPH_PARSING, (int)false },
{ ((size_t)&(((compConfig*)0)->ccAsmNonCLS)), sizeof(bool), CPH_PARSING, (int)false },

{ ((size_t)&(((compConfig*)0)->ccAmbigHack)), sizeof(bool), CPH_NONE, (int)false },

{ ((size_t)&(((compConfig*)0)->ccAsynchIO)), sizeof(bool), CPH_NONE, (int)false },

{ ((size_t)&(((compConfig*)0)->ccTgt64bit)), sizeof(bool), CPH_NONE, (int)false },
{ ((size_t)&(((compConfig*)0)->ccIntEnums)), sizeof(bool), CPH_NONE, (int)false },

{ ((size_t)&(((compConfig*)0)->ccTestMask)), sizeof(unsigned), CPH_PARSING, (int)0 },


#line 47 "macros.cpp"
};











enum    errors
{
    #line 1 "errors.h"


ERRnone,
ERRinternal,
ERR2manyErrs,
ERRnoMemory,
ERRerrDir,
ERRbltinNS,
ERRbltinTp,
ERRbltinMeth,

ERRopenRdErr,
ERRopenWrErr,
ERRreadErr,
ERRopenMDerr,
ERRreadMD,
ERRopenMDbad,
ERRwriteErr,
ERRopenCOR,
ERRmetadata,
ERRdebugInfo,
ERRundefTref,
ERRbadInputFF,
ERRnoOutfName,



ERRidTooLong,
ERRbadNumber,
ERRillegalChar,
ERRbadCharCns,
ERRbadEscCh,
ERRnoStrEnd,
ERRnoCmtEnd,
ERRnestCmt,
ERRnoUnicodeEsc,
ERRbadPPdir,
ERRnoEOL,
ERRnoEndif,

ERRnoClassDef,
ERRnoEnumDef,
ERRnoEOF,
ERRnoColon,
ERRnoComma,
ERRnoSemic,
ERRnoLparen,
ERRnoRparen,
ERRnoRbrack,
ERRnoLcurly,
ERRnoRcurly,
ERRnoEqual,
ERRnoGt,
ERRnoCmRc,
ERRnoCmSc,
ERRnoSmLc,
ERRnoIN,

ERRbadLcurly,
ERRbadElse,
ERRbadEndif,
ERRnoEOX,

ERRnoDecl,
ERRnoIdent,
ERRnoString,
ERRnoType,
ERRbadQualid,
ERRbadQualName,
ERRidNotType,
ERRundefName,
ERRnoSuchMem,
ERRbadMain,
ERRbadAccSpec,
ERRdupModifier,
ERRdupIntfc,
ERRbadModifier,
ERRdmModifier,
ERRfmModifier,
ERRlvModifier,
ERRfmModifier2,
ERRlvAccess,
ERRnoClassName,
ERRnotAclass,
ERRbadIdent,
ERRbadNSmem,
ERRredefMem,
ERRredefName,
ERRredefBody,
ERRredefEnum,
ERRredefClass,
ERRredefLcl,
ERRcircDep,
ERRundefCls,
ERRnoCnsInit,
ERRnoVarInit,
ERRdupMemInit,
ERRrecClass,
ERRextCns,
ERRbadInit,
ERRnoIntType,
ERRnoIntExpr,
ERRnoCnsExpr,
ERRbadArrSize,
ERRbadFnBody,
ERRbadBfld,

ERRstmBfld,
ERRbadBFsize,
ERRbfldAddr,
ERRbadOvl,
ERRbadUTag,
ERRbadUmem,
ERRmulUmem,
ERRbadExpTp,
ERRnoNspMem,
ERRnoClsMem,
ERRnoTPmems,
ERRnoMems,
ERRnoGlobNm,
ERRbadCall,
ERRnoOvlMatch,
ERRnoDlgMatch,
ERRhideMatch,
ERRmisgArg,
ERRmanyArg,
ERRbadArgValNam,
ERRbadArgValNum,
ERRbadMgdMod,
ERRmgdGlobVar,
ERRmgdStatVar,
ERRbadUnmInt,
ERRbadGlobInt,
ERRassgCns,
ERRassgLit,
ERRnotLvalue,
ERRbadIndex,
ERRnoArrDim,
ERRbadBrInit,
ERRbadBrNew,
ERRnoArrSize,
ERRbadUndimMem,
ERRemptyArray,
ERRbadPtrUse,
ERRbadMgInit,
ERRarrInitMany,
ERRstrInitMany,
ERRlvInvisible,
ERRnoNSnm,
ERRambigUse,
ERRdiffMethRet,
ERRdiffVirtRet,
ERRvirtAccess,
ERRdiffPropTp,
ERRdupDefProp,
ERRnoPropDef,
ERRpropAccDef,
ERRnewIntf,
ERRnewAbstract,
ERRbadNewTyp,
ERRnewNoVal,
ERRnoCtorMatch,
ERRintfImpl,
ERRintfBase,
ERRsealedInh,
ERRstrInhCls,
ERRunmIntf,
ERRinclCls,
ERRxMgdInh,
ERRxCtxInh,
ERRctxAddr,
ERRbadEHtype,
ERRbadReThrow,
ERRtryNoBlk,
ERRnoHandler,
ERRfinExit,
ERRbadFNbody,
ERRdupProp,
ERRdupArg,
ERRnotClass,
ERRsyntax,
ERRnoDim,
ERRbadSizeof,
ERRoperType,
ERRoperType2,
ERRnotAfunc,
ERRtypedefNm,
ERRmemWOthis,
ERRundefNspm,
ERRbadDotOp,
ERRbadArrOp,
ERRnotMember,
ERRmsgArgs,
ERRbadArgs,
ERRambigCall,
ERRambigConv,
ERRambigMem,
ERRbadCastImp,
ERRbadCastExp,
ERRbadCastNul,
ERRdivZero,
ERRbadMgdTyp,
ERRbadUnmTyp,
ERRbadArrowNC,
ERRbadIndir,
ERRlabRedef,
ERRundefLab,
ERRbadBreak,
ERRbadCont,
ERRbadCase,
ERRbadDefl,
ERRdupDefl,
ERRdupCaseVal,
ERRnoMemName,
ERRredefAnMem,
ERRbadThis,
ERRnoWhile,
ERRbadVoid,
ERRbadInitSt,
ERRinitNotCns,
ERRnoLinkStr,
ERRbadLinkStr,
ERRbadArrLen,
ERRcantRet,
ERRmisgRet,
ERRbadOperNm,
ERRintfDM,
ERRintfDup,
ERRtypeidOp,
ERRbadConcat,
ERRchgClsFlv,
ERRnotClsVal,
ERRbadOvlOp,
ERRbadOvlOpC,
ERRbadOvlOp1,
ERRbadOvlOp2,
ERRbadOvlOp12,
ERRbadOvlOpT,
ERRbadOvlRet,
ERRbadOvlAcc,
ERRbadOvlEq,
ERRbadOvlCmp,
ERRdefOvlVal,
ERRimplAbst,
ERRabsFNbody,
ERRabsPFbody,
ERRabsNotVirt,
ERRmsgPFbody,
ERRintfFNacc,
ERRnoPropSym,
ERRnoPropOvl,
ERRbadBaseCall,
ERRctorRetTP,
ERRbadAlign,
ERRnoAccess,
ERRnotFlx,
ERRnotHnd,
ERRumgRef,
ERRmgdPtr,
ERRbyref2refany,
ERRbadRefArr,
ERRbadTagMem,
ERRbadStrCase,
ERRumgFldMgd,
ERRchgMgmt,
ERRrecFld,
ERRsafeInd,
ERRsafeDel,
ERRsafeArrX,
ERRunsafeCast,
ERRmulEntry,
ERRnoEntry,
ERRundefUse,
ERRbadVarArg,
ERRnotArgIter,
ERRnotLastArg,
ERRbadVAtype,
ERRbadDelete,
ERRnoFnDef,
ERRnoPropGet,
ERRnoPropSet,
ERRbadCFNret,
ERRbadNameUse,
ERRmanyUmgIxx,
ERRindexCnt,
ERRua2manyDims,
ERRnoDimDcl,
ERRarrInitCnt,
ERRbadVAarg,
ERRbadTypeExpr,
ERRnoBaseInit,
ERRbadPrgOpt,
ERRerrPos,
ERRunknownMD,

ERRbadMacDef,
ERRmacPlace,
ERRmacRedef,

ERRdlgNonFn,
ERRdlgCTarg,
ERRdlgNoMFN,
ERRmulDlgRet,

ERRbadAtCmPlc,
ERRbadAtCmSubd,
ERRbadAtCmForm,
ERRnoDLLname,
ERRclsImpName,

ERRbadSecActn,
ERRnonCnsAA,
ERRcustAttrPlc,
ERRcustAttrDup,
ERRcustAttrMsk,

ERRnoClsGt,
ERRnoCmGt,
ERRumgGenCls,
ERRmisgGenArg,
ERRgenArg,
ERRgenArgBase,
ERRgenArgIntf,
ERRgenNested,

ERRbadAttr,
ERRplcAttr,
ERRbadGUID,



WRNasgNoUse, WRNfirstWarn = WRNasgNoUse,
WRNbadPragma,
WRNbadPrep,
WRNignoreCV,
WRNenumComp,
WRNloseBits,
WRNzeroPtr,
WRNvoidFnc,
WRNignoreLnk,
WRNgeneric,
WRNunkAttr,
WRNnoArgName,
WRNunreach,
WRNimplAbst,
WRNbadAtCm,
WRNignAtCm,
WRNmgdBF,
WRNbadMgdStr,
WRNundefUse,
WRNnoFnDef,
WRNignoring,
WRNnoNSnm,
WRNdepCall,
WRNdepCls,
WRNdepFld,
WRNdepProp,
WRNdepEnum,
WRNmacroArgs,
WRNconvert,
WRNbadEsc,
WRNskipAtCm,
WRNstmtNoUse,
WRNpgm2big,
WRNimplOut,
WRNenum2str,
WRNunsConst,
WRNaddStrings,
WRNstrRefCmp,
WRNhideVirt,
WRNobsoleteStr,
WRNoperPrec,
WRNctxFlavor,
WRNobsolete,
WRNstrValCmp,
WRNenumConv,

#line 62 "macros.cpp"

    WRNafterWarn
};




const
unsigned    WRNcountWarn = WRNafterWarn - WRNfirstWarn + 1;

#line 73 "macros.cpp"







const   char *          errorTable[] =
{
    #line 1 "errors.h"


NULL,
"INTERNAL COMPILER ERROR: %s",
"Too many error messages",
"Out of memory",
"Error directive",
"Could not locate system namespace '%s'",
"Could not locate system class '%s'",
"Could not locate system method '%s'",

"Could not open source file '%s' for reading",
"Could not open target file '%s' for writing",
"Could not read source file '%s'",
"Could not open '%s' for metadata input (use -s<filename> to specify location)",
"Could not read metadata",
"Could not read metadata from file '%s'",
"Could not write to output file '%s'",
"Could not initialize COM+ Runtime",
"Could not create metadata",
"Could not emit debugging information",
"Could not resolve metadata reference to type '%s'",
"Invalid input file format in '%s': expected a %s file",
"Name of output file not specified, please use -O",



"Identifier too long",
"Invalid number",
"Invalid character",
"Invalid character constant",
"Invalid escape character",
"Unterminated string constant",
"Unterminated comment",
"Nested comment",
"Expected Unicode escape sequence",
"Malformed '#' directive",
"End of line expected",
"Missing 'endif' for directive on line %u",

"Cannot find definition for class '%s'",
"Cannot find definition for enum '%s'",
"Expected end of file",
"Expected ':'",
"Expected ','",
"Expected ';'",
"Expected '('",
"Expected ')'",
"Expected ']'",
"Expected '{'",
"Expected '}'",
"Expected '='",
"Expected '>'",
"Expected ',' or '}'",
"Expected ',' or ';'",
"Expected ';' or '{'",
"Expected 'in'",

"Unexpected '{' found",
"'else' without a matching 'if'",
"'endif' without a matching 'if'",
"Expected operator or end of expression",

"Expected declaration",
"Expected identifier",
"String expected",
"Expected type specifier",
"Qualified name not allowed here",
"Invalid qualified name '%s'",
"The name '%s' doesn't denote a type",
"Undefined name '%s'",
"The class '%s' doesn't contain a member '%s'",
"Function must be declared as 'int main(String [])'",
"This access specifier is not allowed here",
"Duplicate modifier",
"Duplicate interface include specifier",
"Illegal type modifier(s)",
"A data member cannot be declared with '%s'",
"A method cannot be declared with '%s'",
"A local variable cannot be declared with '%s'",
"A method cannot be both '%s' and '%s'",
"Access specifiers not allowed with local variables",
"Class name expected",
"'%s' does not denote a class",
"Unexpected identifier",
"Illegal namespace member",
"The member '%s' has already been declared",
"The name '%s' has already been declared",
"Two bodies given for '%s'",
"The enum type '%s' has already been defined",
"The class '%s' has already been defined",
"Local variable '%s' has already been declared",
"'%s' has a circular dependency",
"Cannot find definition for class '%s'",
"Members declared 'const' must be initialized",
"Initialization not found for '%s'",
"Member '%s' has already been initialized",
"Attempt to include a copy of class '%s' in itself",
"A variable can't be 'const' and 'extern'",
"Initializer not allowed here",
"Integer type expected",
"Integer constant expression expected",
"Constant expression expected",
"Array size must be a positive constant",
"Variable has illegal initializer",
"A bitfield may not have type '%s'",

"A bitfield may not be 'static'",
"Bitfield can't have witdh of %u (underlying type has %u bits)",
"Cannot take address of bitfield member '%s'",
"Overloaded '%s' and '%s' differ only in return type",
"Tag '%s' is not a suitable data member",
"Expected tagged union member - 'case' or 'default'",
"A tagged union section may contain only a single member",
"Expected value of type '%s' not '%s'",
"The namespace '%s' doesn't contain '%s'",
"The class '%s' doesn't contain '%s'",
"'%s' doesn't contain any types",
"'%s' doesn't contain any members",
"Undefined global name '%s'",
"Call of a non-function",
"No overloaded method matches the call '%s'",
"The argument '%s' doesn't match delegate '%s'",
"Matching base class method '%s' is hidden",
"Missing arguments in call to '%s'",
"Too many arguments in call to '%s'",
"Value for argument '%s' of '%s' cannot be converted from '%s'",
"Value for argument %s of '%s' cannot be converted from '%s'",
"Only namespaces and classes may be declared '%s'",
"File-scope variables may not have managed type for now",
"Local static variables may not have managed type for now",
"An interface cannot be declared 'unmanaged'",
"An interface cannot be declared in global scope",
"Cannot assign to constant '%s'",
"Cannot assign to a constant",
"Lvalue required here",
"A value of type '%s' cannot be indexed with '[]'",
"Array dimension missing",
"Variable of type '%s' cannot be initialized via '{}'",
"A value of type '%s' cannot be initialized with '{}'",
"Array without a dimension not allowed here",
"Undimensioned array member must be last in struct",
"Unmanaged arrays may not have 0 size",
"The pointer type '%s' cannot be used here",
"Variables of managed type '%s' cannot be initialized via '{}'",
"Too many initializers specified for array, %u expected",
"Initializer string too long, %u characters expected",
"Cannot use local variable '%s' before its declaration",
"The name '%s' doesn't denote a namespace",
"Two symbols in used namespaces match: '%s' and '%s'",
"Method '%s' was earlier declared with return type '%s'",
"Return type of virtual method '%s' differs from '%s'",
"Cannot reduce access level of overridden method '%s'",
"Type of virtual property '%s' differs from '%s'",
"Class has already has a default property with another name: '%s'",
"Expected '{' followed by property accessor method declaration",
"Method conflicts with property accessor '%s'",
"Cannot create an instance of an interface type '%s'",
"Cannot create an instance of an abstract class '%s'",
"Cannot create an instance of type '%s'",
"'new' expression for type '%s' requires an initial value",
"The class doesn't have a constructor that matches '%s'",
"Cannot create an instance of an interface type '%s'",
"A class cannot inherit from an interface: '%s'",
"Cannot inherit from sealed type '%s'",
"A struct cannot inherit from class '%s'",
"Unmanaged classes may not include interfaces",
"Only interfaces may be included: '%s'",
"Management of base class '%s' doesn't match derived class",
"Context flavor of base class '%s' doesn't match derived class",
"Cannot take address of member of a appdomain/contextful class '%s'",
"Type '%s' is not a class derived from 'Exception'",
"Argument to 'throw' is required outside of a catch block",
"'try' block expected, '{' not found",
"'catch', 'finally', or 'except' expected following 'try' block",
"Attempt to prematurely exit from a 'finally' block",
"Function body unexpected for a variable",
"Duplicate property '%s' declaration",
"More than one argument named '%s'",
"Cannot use '%s' here, it doesn't denote a class",
"Syntax error",
"Missing array dimension",
"Illegal operand of 'sizeof'",
"Can't apply operator '%s' to type '%s'",
"Can't apply operator '%s' to types '%s' and '%s'",
"Illegal call: '%s' doesn't denote a function",
"Typedef name '%s' has to match the tag name '%s'",
"Reference to non-static member '%s' without an object",
"The namespace '%s' doesn't have a member '%s'",
"The '.' operator cannot be applied to a value of type '%s'",
"The '->' operator cannot be applied to a value of type '%s'",
"The type '%s' doesn't have a member '%s'",
"Need argument list for call to member '%s'",
"The member '%s' is not a function",
"Call is ambiguous between '%s' and '%s'",
"Conversion is ambiguous: '%s' and '%s'",
"The member '%s' is ambiguous: found in '%s' and '%s'",
"Cannot implicitly convert from type '%s' to '%s'",
"A value of type '%s' cannot be cast to type '%s'",
"'null' cannot be converted to type '%s'",
"Division by constant 0",
"'managed' not followed by an array in type",
"'unmanaged' not followed by an array in type",
"'->' cannot be used after a namespace or class name",
"The indirection operator cannot be applied to '%s'",
"A label with the name '%s' has already been defined",
"The label '%s' has not been defined",
"'break' is not allowed here, not in a switch or loop",
"'continue' is not allowed here, not in a loop",
"'case' only allowed within 'switch' statements",
"'default' only allowed within 'switch' statements",
"Duplicate 'default' label in a 'switch' statement",
"The case label '%s' was specified more than once",
"A member name was expected",
"Type containing anonymous union already has a member '%s'",
"'this' can only be used in non-static methods",
"A 'do' statement must end with a 'while' condition",
"Parameters and variables cannot have type 'void'",
"A variable of type '%s' cannot be initialized this way",
"A variable initializer must be a constant value",
"A linkage name string required in import declaration",
"Linkage string must look like 'DLLname:entrypoint'",
"The type '%s' is not an acceptable operand for 'arraylen'",
"Can't return a value from a 'void' method",
"Expected return value of type '%s'",
"Operator name not valid",
"Interfaces may only include methods and constants",
"Interfaces '%s' has already been specified",
"The 'typeid' operator cannot be applied to type '%s'",
"Cannot concatenate a string and a value of type '%s'",
"Type '%s' was declared elsewhere as '%s'",
"Cannot use a value of type '%s' here, class expected",
"Overloaded operator must be a 'static' method",
"Overloaded operators must have one or two arguments",
"Overloaded operator '%s' must have one argument",
"Overloaded operator '%s' must have two arguments",
"Overloaded operator '%s' must have one or two arguments",
"Overloaded operator must take an argument of type '%s'",
"Overloaded operator must return '%s'",
"Overloaded operator must be declared 'public'        ",
"Overloaded operator '%s' must return 'bool'",
"Overloaded operator '%s' must return 'int'",
"Overloaded operator arguments may not have defaults",
"Class '%s' is implicitly abstract, it doesn't implement '%s'",
"Cannot define a body for abstract method '%s'",
"Cannot define a body for abstract property accessor '%s'",
"The method '%s' was declared 'abstract' but not 'virtual'",
"Missing body for property accessor '%s'",
"Cannot define an interface method to be 'protected' or 'private'",
"Class '%s' has no '%s' property with the name '%s'",
"Class '%s' has no '%s' property '%s' that matches the argument list",
"Use of 'baseclass' is only allowed in a constructor of a class that has a base class",
"Method name matches that of the class, if you're declaring a constructor please omit the return type",
"Alignment value must be 1,2,4,8,18 or push/pop",
"Access to '%s' is not permitted here",
"The '%s' function can only be used in a filter expression",
"The '%s' function can only be used in an SEH handler",
"References are not allowed for now (use 'out' or 'inout' for byref args)",
"Pointers to managed classes not allowed: '%s'",
"Typed byref's (void &) may not be passed by reference",
"Cannot declare an unmanaged array of '%s'",
"Tagged unions can only contain fields and methods",
"'case' labels only allowed in tagged union members",
"Members of unmanaged types may not of be managed type",
"Management is confused: '%s' was declared earlier as '%s'",
"A value type cannot contain a member with its own type",
"Pointer indirection is not allowed in typesafe mode",
"'delete' is not allowed in typesafe mode",
"Unmanaged array indexing is not allowed in typesafe mode",
"Cast from '%s' to '%s' is not allowed in typesafe mode",
"Image has more than entry point: '%s' and '%s'",
"Image has no entry point, it should be declared as 'void main(String [] args)'",
"The value of '%s' may be used before definition",
"varargs functions cannot be used here",
"Expected a local variable of type 'va_list'",
"Expected the last fixed argument of the current function",
"The type '%s' cannot be used as a vararg type",
"'delete' requires a pointer to an unmanaged class",
"No definition was found for method '%s'",
"No definition was found for 'get' accessor of property '%s'",
"No definition was found for 'set' accessor of property '%s'",
"A method marked as '@conditional' must return 'void'",
"'%s' cannot be used in this context",
"Multiple index expressions may not be used with unmanaged arrays",
"Expected %u index expressions",
"An unmanaged array may only have one dimension",
"Expected array dimension or '*'",
"Expected %u sub-array initializers, %u found",
"va_arg() expects a va_list value and a type argument",
"Expression, not type '%s', expected here",
"Base initializer expected after ':': '%s(args)' or 'baseclass(args)'",
"Invalid #pragma option parameter",
"Previous diagnostic refers to declaration at %s(%u)",
"Symbol '%s' references unknown metadata construct(s)",

"Illegal macro definition for '%s'",
"#define must precede any use of identifier '%s'",
"'%s' was referenced before definition as macro",

"A delegate must be declared as a function",
"A delegate instance must be created from a bound method",
"No method in '%s' matches '%s'",
"A multicast delegate must return 'void'",

"This '@comment' thing not allowed here",
"Invalid '%s' comment sub-directive: '%s'",
"Incorrect '%s' comment syntax",
"Missing DLL name, must be specified on method or class",
"Only DLL name may be specified for a class",

"'%s' is not a recognized security action",
"Argument %u in attribute arglist is not a constant",
"Custom atttribute '%s' not allowed here",
"Custom atttribute '%s' may not be specified more than once",
"Invalid custom atttribute placement mask",

"'class' or '>' expected",
"Expected ',' or '>'",
"Only managed classes and interfaces may be generic",
"Expected actual type for generic parameter '%s'",
"Actual type for parameter '%s' must be a managed class/interface",
"Actual type for parameter '%s' doesn't have '%s' as a base",
"Actual type for parameter '%s' doesn't have '%s' as an interface",
"Nested classes may not be generic",

"Attribute syntax incorrect (see compiler file parser.cpp for details)",
"This attribute is not allowed here",
"Invalid GUID string '%s', should be of the form HHHHHHHH-HHHH-HHHH-HHHH-HHHHHHHHHHHH",



"Local variable '%s' is initialized but never used",
"Unrecognized #pragma directive '%s' ignored",
"Ignoring unrecognized directive '#%s'",
"Ignoring const/volatile modifier",
"Comparing values of two different enum types",
"Conversion from '%s' to '%s' may lose precision",
"Using '0' instead of 'null' is in poor style",
"Using '(void)' for parameterless functions is obsolete",
"C++ external linkage specifier ignored",
"%s",
"Ignoring unrecognized attribute '%s'",
"Argument declaration without a name",
"Unreachable code",
"Class '%s' is implicitly abstract, it doesn't implement '%s'",
"Unrecognized comment directive '%s' ignored",
"Ignoring comment directive '%s'",
"Ignoring bitfield declaration in a managed class",
"Unions should not be declared 'managed', it doesn't really work right now",
"The value of '%s' may be used before definition",
"No definition was found for method '%s'",
"Ignoring %s",
"Ignoring 'using %s' - it doesn't denote a namespace",
"Call to deprecated method '%s'",
"Use of deprecated class '%s'",
"Use of deprecated field '%s'",
"Use of deprecated property '%s'",
"Use of deprecated enum value '%s'",
"Pre-processor macros with arguments not supported, ignoring #define directive",
"Converting value of type '%s' to '%s'",
"Unrecognized escape sequence \\%c",
"Found '@' gizmo in regular comment, ignoring it",
"Outermost statement expression has no side effect",
"Image size exceeds specified maximum: 0x%08X vs. 0x%08X",
"Argument %u may be modified by the call to '%s'",
"Converting '%s' to String using its underlying integer type",
"Implicit conversion of a negative constant to an unsigned type",
"Using '+' to concatenate strings is deprecated, please use '%%%%'",
"Comparing String references doesn't compare the string values",
"Base class member function '%s' hidden, not overloaded",
"'%s' has been marked as obsolete: '%s'",
"Comparisons have precedence over bitwise operators, did you forget parens?",
"Implicit conversion from '%s' to '%s' may cause context grief",
"Obsolete language feature used: %s",
"Relational operator compares string values",
"Mixing values of two different enum types",

#line 83 "macros.cpp"
};










BYTE                    warnDefault[] =
{
    #line 1 "errors.h"











































































































































































































































































































































0,
0,
1,
0,
0,
1,
1,
1,
1,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
9,
0,
1,
1,
1,
9,
1,
0,

#line 97 "macros.cpp"
};






#line 1 "attrs.h"





enum attrKinds
{

    #line 1 "attrlist.h"




ATTR_GUID,
ATTR_SYS_IMPORT,
ATTR_NATIVE_TYPE,
ATTR_SYS_STRUCT,


#line 10 "attrs.h"

    ATTR_COUNT
};

enum attrMasks
{

    #line 1 "attrlist.h"




ATTR_MASK_GUID = 1 << ATTR_GUID,
ATTR_MASK_SYS_IMPORT = 1 << ATTR_SYS_IMPORT,
ATTR_MASK_NATIVE_TYPE = 1 << ATTR_NATIVE_TYPE,
ATTR_MASK_SYS_STRUCT = 1 << ATTR_SYS_STRUCT,


#line 18 "attrs.h"
};


#line 22 "attrs.h"

#line 105 "macros.cpp"

const char    *     attrNames[] =
{

    #line 1 "attrlist.h"




"guid",
"sysimport",
"nativetype",
"sysstruct",


#line 110 "macros.cpp"
};



static
unsigned char       optokens[] =
{

    #line 1 "toplist.h"















tkNone,
tkNone,





tkNone,
tkNone,
tkNone,
tkNone,





tkNone,
tkNone,
tkNone,
tkNone,
tkNone,
tkNone,





tkAnd,

tkTilde,
tkBang,
tkAdd,
tkSub,
tkNone,

tkInc,
tkDec,
tkInc,
tkDec,

tkNone,
tkNone,

tkNone,





tkAdd,
tkSub,
tkMul,
tkDiv,
tkPct,

tkAnd,
tkXor,
tkOr,

tkLsh,
tkRsh,
tkRsz,

tkEQ,
tkNE,
tkLT,
tkLE,
tkGE,
tkGT,



tkAsg,
tkAsgAdd,
tkAsgSub,
tkAsgMul,
tkAsgDiv,
tkAsgMod,

tkAsgAnd,
tkAsgXor,
tkAsgOr,

tkAsgLsh,
tkAsgRsh,
tkAsgRsz,

tkAsgCnc,

tkNone,

tkQMark,
tkColon,

tkLogOr,
tkLogAnd,

tkISTYPE,

tkNone,
tkNone,
tkNone,

tkREFADDR,





tkMul,

tkNone,
tkNone,

tkNone,
tkNone,

tkNone,
tkNone,

tkNone,

tkNone,

tkNone,

tkNone,
tkNone,
tkNone,
tkNone,

tkNone,
tkNone,

tkNone,
tkNone,

tkNone,
tkNone,

tkSIZEOF,
tkTYPEOF,

tkNone,
tkNone,





tkNone,

tkNone,

tkNone,
tkNone,
tkNone,

tkNone,

tkNone,
tkNone,

tkNone,
tkNone,

tkNone,

tkNone,

tkNone,
tkNone,





tkNone,
tkNone,
tkNone,
tkNone,
tkNone,
tkNone,
tkNone,
tkNone,
tkNone,

tkNone,





tkNone,
tkNone,





tkNone,





tkNone,




#line 119 "macros.cpp"
};

tokens              treeOp2token(treeOps oper)
{
    assert(oper < (sizeof(optokens)/sizeof(*(optokens))));
    assert(optokens[oper] != tkNone);

    return (tokens)optokens[oper];
}





static
const   char *      treeNodeNames[] =
{

    #line 1 "toplist.h"















"error",
"<none>",





"name",
"this",
"base",
"debugbreak",





"int const",
"lng const",
"flt const",
"dbl const",
"str const",
"null",





"&",

"~",
"!",
"unary +",
"unary -",
"throw",

"++ post",
"-- post",
"++ pre",
"-- pre",

"<type>",
"<token>",

"inst-stub",





"+",
"-",
"*",
"/",
"%",

"&",
"^",
"|",

"<<",
">>",
">>>",

"==",
"!=",
"<",
"<=",
">=",
">",



"=",
"+=",
"-=",
"*=",
"/=",
"%=",

"&=",
"^=",
"|=",

"<<=",
">>=",
">>>=",

"%%=",

",",

"?",
":",

"||",
"&&",

"istype",

"[]",
"()",
"->",

"ref&",





"indir",

"new",
"delete",

"%%",
"%%=",

"math &",
"math &=",

"<list>",

"cast",

"className",

"try",
"catch",
"except",
"finally",

".",
"name.name",

"goto",
"label",

"arr init",
"arr length",

"sizeof",
"typeof",

"box",
"unbox",





"stmtExpr",

"if",

"do",
"for",
"while",

"excludeStmt",

"break",
"continue",

"switch",
"case",

"return",

"assert",

"vararg-beg",
"vararg-get",





"namespace",
"qualname",
"lcl var",
"member",
"variable",
"bitfield",
"function",
"meth-ptr",
"property",

"{}",





"var-decl",
"slv-init",





"varDecl",





"defined",




#line 138 "macros.cpp"
};

const   char    *   treeNodeName(treeOps op)
{
    assert(op < sizeof(treeNodeNames)/sizeof(treeNodeNames[0]));

    return  treeNodeNames[op];
}

#line 148 "macros.cpp"



const
unsigned char       TreeNode::tnOperKindTable[] =
{

    #line 1 "toplist.h"















TNK_NONE,
TNK_NONE,





TNK_LEAF,
TNK_LEAF,
TNK_LEAF,
TNK_LEAF,





TNK_LEAF|TNK_CONST,
TNK_LEAF|TNK_CONST,
TNK_LEAF|TNK_CONST,
TNK_LEAF|TNK_CONST,
TNK_LEAF|TNK_CONST,
TNK_LEAF|TNK_CONST,





TNK_UNOP,

TNK_UNOP,
TNK_UNOP,
TNK_UNOP,
TNK_UNOP,
TNK_UNOP,

TNK_UNOP,
TNK_UNOP,
TNK_UNOP,
TNK_UNOP,

TNK_UNOP,
TNK_UNOP,

TNK_UNOP,





TNK_BINOP,
TNK_BINOP,
TNK_BINOP,
TNK_BINOP,
TNK_BINOP,

TNK_BINOP|TNK_LOGOP,
TNK_BINOP|TNK_LOGOP,
TNK_BINOP|TNK_LOGOP,

TNK_BINOP,
TNK_BINOP,
TNK_BINOP,

TNK_BINOP|TNK_RELOP,
TNK_BINOP|TNK_RELOP,
TNK_BINOP|TNK_RELOP,
TNK_BINOP|TNK_RELOP,
TNK_BINOP|TNK_RELOP,
TNK_BINOP|TNK_RELOP,



TNK_BINOP|TNK_ASGOP,
TNK_BINOP|TNK_ASGOP,
TNK_BINOP|TNK_ASGOP,
TNK_BINOP|TNK_ASGOP,
TNK_BINOP|TNK_ASGOP,
TNK_BINOP|TNK_ASGOP,

TNK_BINOP|TNK_ASGOP,
TNK_BINOP|TNK_ASGOP,
TNK_BINOP|TNK_ASGOP,

TNK_BINOP|TNK_ASGOP,
TNK_BINOP|TNK_ASGOP,
TNK_BINOP|TNK_ASGOP,

TNK_BINOP|TNK_ASGOP,

TNK_BINOP,

TNK_BINOP,
TNK_BINOP,

TNK_BINOP,
TNK_BINOP,

TNK_BINOP,

TNK_BINOP,
TNK_BINOP,
TNK_BINOP,

TNK_BINOP,





TNK_UNOP,

TNK_BINOP,
TNK_UNOP,

TNK_BINOP,
TNK_BINOP|TNK_ASGOP,

TNK_BINOP,
TNK_BINOP|TNK_ASGOP,

TNK_BINOP,

TNK_BINOP,

TNK_BINOP,

TNK_BINOP,
TNK_BINOP,
TNK_BINOP,
TNK_UNOP,

TNK_BINOP,
TNK_UNOP,

TNK_UNOP,
TNK_UNOP,

TNK_UNOP,
TNK_UNOP,

TNK_UNOP,
TNK_UNOP,

TNK_UNOP,
TNK_UNOP,





TNK_UNOP,

TNK_BINOP,

TNK_BINOP,
TNK_BINOP,
TNK_BINOP,

TNK_BINOP,

TNK_UNOP,
TNK_UNOP,

TNK_BINOP,
TNK_UNOP,

TNK_BINOP,

TNK_UNOP,

TNK_BINOP,
TNK_BINOP,





TNK_NONE,
TNK_NONE,
TNK_NONE,
TNK_NONE,
TNK_NONE,
TNK_NONE,
TNK_NONE,
TNK_NONE,
TNK_NONE,

TNK_NONE,





TNK_NONE,
TNK_NONE,





TNK_NONE,





TNK_NONE,




#line 156 "macros.cpp"
};



const
kwdDsc              hashTab::hashKwdDescs[tkKwdCount] =
{



    #line 1 "keywords.h"

















#line 19 "keywords.h"




#line 24 "keywords.h"












{ TN_NONE,TN_NONE,0,0,tkNone,0,0 },



{ TN_NONE,TN_NONE,0,0,tkABSTRACT,DB_ABSTRACT,2 },
{ TN_NONE,TN_NONE,0,0,tkAPPDOMAIN,0,2 },
{ TN_NONE,TN_NONE,0,0,tkARRAYLEN,0,0 },
{ TN_NONE,TN_NONE,0,0,tkASSERT,0,0 },
{ TN_NONE,TN_NONE,0,0,tkASYNCH,0,0 },
{ TN_NONE,TN_NONE,0,0,tkATTRIBUTE,0,0 },

{ TN_NONE,TN_NONE,0,0,tkBASECLASS,0,0 },
{ TN_NONE,TN_NONE,0,0,tkBOOL,0,3 },
{ TN_NONE,TN_NONE,0,0,tkBREAK,0,0 },
{ TN_NONE,TN_NONE,0,0,tkBYREF,0,2 },
{ TN_NONE,TN_NONE,0,0,tkBYTE,0,3 },
{ TN_NONE,TN_NONE,0,0,tkCAPABILITY,0,0 },
{ TN_NONE,TN_NONE,0,0,tkCASE,0,0 },
{ TN_NONE,TN_NONE,0,0,tkCATCH,0,0 },
{ TN_NONE,TN_NONE,0,0,tkCHAR,0,3 },
{ TN_NONE,TN_NONE,0,0,tkCLASS,0,2 },
{ TN_NONE,TN_NONE,0,0,tkCOMPARE,0,4 },
{ TN_NONE,TN_NONE,0,0,tkCONST,DB_CONST,2 },
{ TN_NONE,TN_NONE,0,0,tkCONTEXTFUL,0,0 },
{ TN_NONE,TN_NONE,0,0,tkCONTINUE,0,0 },
{ TN_DEFINED,TN_NONE,1,0,tkDEFINED,0,0 },
{ TN_NONE,TN_NONE,0,0,tkDEFAULT,DB_DEFAULT,0 },
{ TN_NONE,TN_NONE,0,0,tkDELEGATE,0,0 },
{ TN_NONE,TN_NONE,0,0,tkDELETE,0,0 },
{ TN_NONE,TN_NONE,0,0,tkDO,0,0 },
{ TN_NONE,TN_NONE,0,0,tkDOUBLE,0,3 },
{ TN_NONE,TN_NONE,0,0,tkELSE,0,0 },
{ TN_NONE,TN_NONE,0,0,tkENUM,0,2 },
{ TN_NONE,TN_NONE,0,0,tkEQUALS,0,4 },
{ TN_NONE,TN_NONE,0,0,tkEXCEPT,0,0 },
{ TN_NONE,TN_NONE,0,0,tkEXCLUSIVE,DB_EXCLUDE,2 },

{ TN_NONE,TN_NONE,0,0,tkEXPLICIT,0,4 },
{ TN_NONE,TN_NONE,0,0,tkEXTERN,DB_EXTERN,2 },
{ TN_NONE,TN_NONE,0,0,tkFALSE,0,0 },
{ TN_NONE,TN_NONE,0,0,tkFINALLY,0,0 },
{ TN_NONE,TN_NONE,0,0,tkFLOAT,0,3 },
{ TN_NONE,TN_NONE,0,0,tkFOR,0,0 },
{ TN_NONE,TN_NONE,0,0,tkGOTO,0,0 },
{ TN_NONE,TN_NONE,0,0,tkIF,0,0 },
{ TN_NONE,TN_NONE,0,0,tkIMPLEMENTS,0,0 },
{ TN_NONE,TN_NONE,0,0,tkIMPLICIT,0,4 },
{ TN_NONE,TN_NONE,0,0,tkIN,0,0 },
{ TN_NONE,TN_NONE,0,0,tkINCLUDES,0,0 },
{ TN_NONE,TN_NONE,0,0,tkINLINE,DB_INLINE,2 },
{ TN_NONE,TN_NONE,0,0,tkINOUT,0,2 },
{ TN_NONE,TN_NONE,0,0,tkINT,0,3 },
{ TN_NONE,TN_NONE,0,0,tkINT8,0,3 },
{ TN_NONE,TN_NONE,0,0,tkINT16,0,3 },
{ TN_NONE,TN_NONE,0,0,tkINT32,0,3 },
{ TN_NONE,TN_NONE,0,0,tkINT64,0,3 },
{ TN_NONE,TN_NONE,0,0,tkINTERFACE,0,0 },
{ TN_NONE,TN_ISTYPE,0,14,tkISTYPE,0,0 },
{ TN_NONE,TN_NONE,0,0,tkLONGINT,0,3 },
{ TN_NONE,TN_NONE,0,0,tkMANAGED,DB_MANAGED,2 },
{ TN_NONE,TN_NONE,0,0,tkMULTICAST,DB_MULTICAST,2 },
{ TN_NONE,TN_NONE,0,0,tkNAMESPACE,0,2 },
{ TN_NONE,TN_NONE,0,0,tkNATIVE,DB_NATIVE,2 },
{ TN_NONE,TN_NONE,0,0,tkNATURALINT,0,3 },
{ TN_NONE,TN_NONE,0,0,tkNATURALUINT,0,3 },
{ TN_NONE,TN_NONE,0,0,tkNEW,0,0 },
{ TN_NONE,TN_NONE,0,0,tkNULL,0,0 },
{ TN_ADDROF,TN_NONE,14,0,tkOUT,0,0 },
{ TN_NONE,TN_NONE,0,0,tkOPERATOR,0,0 },
{ TN_NONE,TN_NONE,0,0,tkOVERRIDE,DB_OVERRIDE,2 },
{ TN_NONE,TN_NONE,0,0,tkOVERLOAD,DB_OVERLOAD,2 },
{ TN_NONE,TN_NONE,0,0,tkPERMISSION,0,0 },
{ TN_NONE,TN_NONE,0,0,tkPRIVATE,0,2 },
{ TN_NONE,TN_NONE,0,0,tkPROPERTY,DB_PROPERTY,2 },
{ TN_NONE,TN_NONE,0,0,tkPROTECTED,0,2 },
{ TN_NONE,TN_NONE,0,0,tkPUBLIC,0,2 },
{ TN_NONE,TN_NONE,0,0,tkREFADDR,0,0 },
{ TN_NONE,TN_NONE,0,0,tkREGISTER,0,2 },
{ TN_NONE,TN_NONE,0,0,tkRETURN,0,0 },
{ TN_NONE,TN_NONE,0,0,tkSEALED,DB_SEALED,2 },
{ TN_NONE,TN_NONE,0,0,tkSERIALIZABLE,DB_SERLZABLE,0 },
{ TN_NONE,TN_NONE,0,0,tkSHORT,0,3 },
{ TN_NONE,TN_NONE,0,0,tkSIGNED,0,3 },
{ TN_SIZEOF,TN_NONE,1,0,tkSIZEOF,0,0 },
{ TN_NONE,TN_NONE,0,0,tkSTATIC,DB_STATIC,2 },
{ TN_NONE,TN_NONE,0,0,tkSTRUCT,0,2 },
{ TN_NONE,TN_NONE,0,0,tkSWITCH,0,0 },
{ TN_NONE,TN_NONE,0,0,tkTHIS,0,0 },
{ TN_NONE,TN_NONE,0,0,tkTHROW,0,0 },
{ TN_NONE,TN_NONE,0,0,tkTRANSIENT,DB_TRANSIENT,0 },
{ TN_TYPEOF,TN_NONE,1,0,tkTYPEOF,0,0 },
{ TN_NONE,TN_NONE,0,0,tkTYPEDEF,DB_TYPEDEF,0 },
{ TN_NONE,TN_NONE,0,0,tkTRUE,0,0 },
{ TN_NONE,TN_NONE,0,0,tkTRY,0,0 },
{ TN_NONE,TN_NONE,0,0,tkUINT8,0,3 },
{ TN_NONE,TN_NONE,0,0,tkUINT16,0,3 },
{ TN_NONE,TN_NONE,0,0,tkUINT32,0,3 },
{ TN_NONE,TN_NONE,0,0,tkUINT64,0,3 },
{ TN_NONE,TN_NONE,0,0,tkUINT,0,3 },
{ TN_NONE,TN_NONE,0,0,tkULONGINT,0,3 },
{ TN_NONE,TN_NONE,0,0,tkUNION,0,2 },
{ TN_NONE,TN_NONE,0,0,tkUNMANAGED,DB_UNMANAGED,2 },
{ TN_NONE,TN_NONE,0,0,tkUNSAFE,DB_UNSAFE,2 },
{ TN_NONE,TN_NONE,0,0,tkUNSIGNED,0,3 },
{ TN_NONE,TN_NONE,0,0,tkUSHORT,0,3 },
{ TN_NONE,TN_NONE,0,0,tkUSING,0,0 },
{ TN_NONE,TN_NONE,0,0,tkVOID,0,3 },
{ TN_NONE,TN_NONE,0,0,tkVIRTUAL,DB_VIRTUAL,0 },
{ TN_NONE,TN_NONE,0,0,tkVOLATILE,DB_VOLATILE,2 },
{ TN_NONE,TN_NONE,0,0,tkWCHAR,0,3 },
{ TN_NONE,TN_NONE,0,0,tkWHILE,0,0 },
{ TN_NONE,TN_NONE,0,0,tkFILE,0,0 },
{ TN_NONE,TN_NONE,0,0,tkLINE,0,0 },



{ TN_NONE,TN_COMMA,0,1,tkComma,0,0 },

{ TN_NONE,TN_ASG,0,2,tkAsg,0,4 },
{ TN_NONE,TN_ASG_ADD,0,2,tkAsgAdd,0,4 },
{ TN_NONE,TN_ASG_SUB,0,2,tkAsgSub,0,4 },
{ TN_NONE,TN_ASG_MUL,0,2,tkAsgMul,0,4 },
{ TN_NONE,TN_ASG_DIV,0,2,tkAsgDiv,0,4 },
{ TN_NONE,TN_ASG_MOD,0,2,tkAsgMod,0,4 },

{ TN_NONE,TN_ASG_AND,0,2,tkAsgAnd,0,4 },
{ TN_NONE,TN_ASG_XOR,0,2,tkAsgXor,0,4 },
{ TN_NONE,TN_ASG_OR,0,2,tkAsgOr,0,4 },

{ TN_NONE,TN_ASG_LSH,0,2,tkAsgLsh,0,4 },
{ TN_NONE,TN_ASG_RSH,0,2,tkAsgRsh,0,4 },
{ TN_NONE,TN_ASG_RSZ,0,2,tkAsgRsz,0,4 },

{ TN_NONE,TN_ASG_CNC,0,2,tkAsgCnc,0,4 },

{ TN_NONE,TN_QMARK,0,3,tkQMark,0,0 },
{ TN_NONE,TN_NONE,0,0,tkColon,0,0 },

{ TN_NONE,TN_LOG_OR,0,4,tkLogOr,0,4 },
{ TN_NONE,TN_LOG_AND,0,5,tkLogAnd,0,4 },

{ TN_NONE,TN_OR,0,6,tkOr,0,4 },

{ TN_NONE,TN_XOR,0,7,tkXor,0,4 },
{ TN_ADDROF,TN_AND,14,7,tkAnd,0,4 },

{ TN_NONE,TN_CONCAT,0,3,tkConcat,0,4 },

{ TN_NONE,TN_EQ,0,9,tkEQ,0,4 },
{ TN_NONE,TN_NE,0,9,tkNE,0,4 },

{ TN_NONE,TN_LT,0,10,tkLT,0,4 },
{ TN_NONE,TN_LE,0,10,tkLE,0,4 },
{ TN_NONE,TN_GE,0,10,tkGE,0,4 },
{ TN_NONE,TN_GT,0,10,tkGT,0,4 },

{ TN_NONE,TN_LSH,0,11,tkLsh,0,4 },
{ TN_NONE,TN_RSH,0,11,tkRsh,0,4 },
{ TN_NONE,TN_RSZ,0,11,tkRsz,0,4 },

{ TN_NOP,TN_ADD,14,12,tkAdd,0,4 },
{ TN_NEG,TN_SUB,14,12,tkSub,0,4 },

{ TN_IND,TN_MUL,12,13,tkMul,0,4 },
{ TN_NONE,TN_DIV,0,13,tkDiv,0,4 },
{ TN_NONE,TN_MOD,0,13,tkPct,0,4 },

{ TN_NOT,TN_NONE,14,0,tkTilde,0,4 },
{ TN_LOG_NOT,TN_NONE,14,0,tkBang,0,4 },
{ TN_INC_PRE,TN_NONE,14,0,tkInc,0,4 },
{ TN_DEC_PRE,TN_NONE,14,0,tkDec,0,4 },

{ TN_NONE,TN_NONE,0,0,tkLParen,0,0 },
{ TN_NONE,TN_NONE,0,0,tkLBrack,0,0 },
{ TN_NONE,TN_NONE,0,0,tkDot,0,4 },
{ TN_NONE,TN_ARROW,0,15,tkArrow,0,4 },

{ TN_NONE,TN_NONE,0,0,tkSColon,0,0 },
{ TN_NONE,TN_NONE,0,0,tkRParen,0,0 },
{ TN_NONE,TN_NONE,0,0,tkRBrack,0,0 },
{ TN_NONE,TN_NONE,0,0,tkLCurly,0,0 },
{ TN_NONE,TN_NONE,0,0,tkRCurly,0,0 },
{ TN_NONE,TN_NONE,0,0,tkColon2,0,3 },
{ TN_NONE,TN_NONE,0,0,tkDot2,0,0 },
{ TN_NONE,TN_NONE,0,0,tkEllipsis,0,0 },


{ TN_NONE,TN_NONE,0,0,tkID,0,2 },





















#line 167 "macros.cpp"
};

const
char *              hashTab::hashKwdNtab[tkKwdCount] =
{



    #line 1 "keywords.h"

















#line 19 "keywords.h"




#line 24 "keywords.h"












NULL,



"abstract",
"appdomain",
"arraylen",
"assert",
"__asynch",
"__attribute",

"baseclass",
"bool",
"break",
"byref",
"byte",
"__capability",
"case",
"catch",
"char",
"class",
"@compare",
"const",
"contextful",
"continue",
"defined",
"default",
"delegate",
"delete",
"do",
"double",
"else",
"enum",
"@equals",
"except",
"exclusive",

"explicit",
"extern",
"false",
"finally",
"float",
"for",
"goto",
"if",
"implements",
"implicit",
"in",
"includes",
"inline",
"inout",
"int",
"__int8",
"__int16",
"__int32",
"__int64",
"interface",
"istype",
"longint",
"managed",
"multicast",
"namespace",
"native",
"naturalint",
"naturaluint",
"new",
"null",
"out",
"operator",
"override",
"overload",
"__permission",
"private",
"property",
"protected",
"public",
"__refaddr",
"register",
"return",
"sealed",
"serializable",
"short",
"signed",
"sizeof",
"static",
"struct",
"switch",
"this",
"throw",
"transient",
"typeof",
"typedef",
"true",
"try",
"__uint8",
"__uint16",
"__uint32",
"__uint64",
"uint",
"ulongint",
"union",
"unmanaged",
"unsafe",
"unsigned",
"ushort",
"using",
"void",
"virtual",
"volatile",
"wchar",
"while",
"__FILE__",
"__LINE__",



",",

"=",
"+=",
"-=",
"*=",
"/=",
"%=",

"&=",
"^=",
"|=",

"<<=",
">>=",
">>>=",

"%%=",

"?",
":",

"||",
"&&",

"|",

"^",
"&",

"%%",

"==",
"!=",

"<",
"<=",
">=",
">",

"<<",
">>",
">>>",

"+",
"-",

"*",
"/",
"%",

"~",
"!",
"++",
"--",

"(",
"[",
".",
"->",

";",
",",
"]",
"{",
"}",
"::",
"..",
"...",


"id",





















#line 176 "macros.cpp"
};





const char *        tokenNames[] =
{

    #line 1 "keywords.h"







#line 9 "keywords.h"




#line 14 "keywords.h"




#line 19 "keywords.h"




#line 24 "keywords.h"












NULL,



"abstract",
"appdomain",
"arraylen",
"assert",
"__asynch",
"__attribute",

"baseclass",
"bool",
"break",
"byref",
"byte",
"__capability",
"case",
"catch",
"char",
"class",
"@compare",
"const",
"contextful",
"continue",
"defined",
"default",
"delegate",
"delete",
"do",
"double",
"else",
"enum",
"@equals",
"except",
"exclusive",

"explicit",
"extern",
"false",
"finally",
"float",
"for",
"goto",
"if",
"implements",
"implicit",
"in",
"includes",
"inline",
"inout",
"int",
"__int8",
"__int16",
"__int32",
"__int64",
"interface",
"istype",
"longint",
"managed",
"multicast",
"namespace",
"native",
"naturalint",
"naturaluint",
"new",
"null",
"out",
"operator",
"override",
"overload",
"__permission",
"private",
"property",
"protected",
"public",
"__refaddr",
"register",
"return",
"sealed",
"serializable",
"short",
"signed",
"sizeof",
"static",
"struct",
"switch",
"this",
"throw",
"transient",
"typeof",
"typedef",
"true",
"try",
"__uint8",
"__uint16",
"__uint32",
"__uint64",
"uint",
"ulongint",
"union",
"unmanaged",
"unsafe",
"unsigned",
"ushort",
"using",
"void",
"virtual",
"volatile",
"wchar",
"while",
"__FILE__",
"__LINE__",



",",

"=",
"+=",
"-=",
"*=",
"/=",
"%=",

"&=",
"^=",
"|=",

"<<=",
">>=",
">>>=",

"%%=",

"?",
":",

"||",
"&&",

"|",

"^",
"&",

"%%",

"==",
"!=",

"<",
"<=",
">=",
">",

"<<",
">>",
">>>",

"+",
"-",

"*",
"/",
"%",

"~",
"!",
"++",
"--",

"(",
"[",
".",
"->",

";",
",",
"]",
"{",
"}",
"::",
"..",
"...",


"id",
"qualid",
"hackid",



"EOL",
"EOF",

"@comment",

"int con",
"lng con",
"flt con",
"dbl con",
"str con",






#line 186 "macros.cpp"
};

#line 189 "macros.cpp"





enum    var_types
{

    #line 1 "typelist.h"
TYP_UNDEF,
TYP_VOID,

TYP_BOOL,
TYP_WCHAR,

TYP_CHAR,
TYP_UCHAR,
TYP_SHORT,
TYP_USHORT,
TYP_INT,
TYP_UINT,
TYP_NATINT,
TYP_NATUINT,
TYP_LONG,
TYP_ULONG,

TYP_FLOAT,
TYP_DOUBLE,
TYP_LONGDBL,
TYP_REFANY,

TYP_ARRAY,
TYP_CLASS,
TYP_FNC,
TYP_REF,
TYP_PTR,

TYP_ENUM,
TYP_TYPEDEF,

#line 198 "macros.cpp"


    TYP_COUNT,

    TYP_lastIntrins = TYP_LONGDBL
};

#line 206 "macros.cpp"



BYTE                symTab::stIntrTypeSizes[] =
{

    #line 1 "typelist.h"
1,
0,

1,
2,

1,
1,
2,
2,
4,
4,
0,
0,
8,
8,

4,
8,
8,
0,

4,
0,
0,
4,
4,

0,
0,

#line 213 "macros.cpp"

};

BYTE                symTab::stIntrTypeAligns[] =
{

    #line 1 "typelist.h"
1,
0,

1,
2,

1,
1,
2,
2,
4,
4,
8,
8,
8,
8,

4,
8,
8,
0,

4,
0,
0,
4,
4,

0,
0,

#line 220 "macros.cpp"

};

BYTE                varTypeClassification[] =
{

    #line 1 "typelist.h"
0,
0,

VTF_SCL|VTF_INT|VTF_UNS,
VTF_SCL|VTF_INT|VTF_UNS,

VTF_ARI|VTF_SCL|VTF_INT,
VTF_ARI|VTF_SCL|VTF_INT|VTF_UNS,
VTF_ARI|VTF_SCL|VTF_INT,
VTF_ARI|VTF_SCL|VTF_INT|VTF_UNS,
VTF_ARI|VTF_SCL|VTF_INT,
VTF_ARI|VTF_SCL|VTF_INT|VTF_UNS,
VTF_ARI|VTF_SCL|VTF_INT,
VTF_ARI|VTF_SCL|VTF_INT|VTF_UNS,
VTF_ARI|VTF_SCL|VTF_INT,
VTF_ARI|VTF_SCL|VTF_INT|VTF_UNS,

VTF_ARI|VTF_SCL|VTF_FLT,
VTF_ARI|VTF_SCL|VTF_FLT,
VTF_ARI|VTF_SCL|VTF_FLT,
0,

VTF_SCL |VTF_UNS,
0,
0,
VTF_SCL |VTF_UNS,
VTF_SCL |VTF_UNS,

VTF_SCL|VTF_IND|VTF_INT,
VTF_IND,

#line 227 "macros.cpp"

};

normString          symTab::stIntrinsicTypeName(var_types vt)
{
    static
    const   char *      typeNames[] =
    {

        #line 1 "typelist.h"
"<UNDEF>",
"void",

"boolean",
"wchar",

"char",
"uchar",
"short",
"ushort",
"int",
"uint",
"naturalint",
"naturaluint",
"longint",
"ulongint",

"float",
"double",
"longdbl",
"void &",

"array",
"class",
"function",
"ref",
"pointer",

"enum",
"typedef",

#line 237 "macros.cpp"

    };

    assert(vt < sizeof(typeNames)/sizeof(typeNames[0]));

    return  typeNames[vt];
}





enum    ILopcodes
{

    #line 1 "..\\..\\inc\\opcode.def"

























#line 27 "..\\..\\inc\\opcode.def"
























#line 52 "..\\..\\inc\\opcode.def"









CEE_NOP,
CEE_BREAK,
CEE_LDARG_0,
CEE_LDARG_1,
CEE_LDARG_2,
CEE_LDARG_3,
CEE_LDLOC_0,
CEE_LDLOC_1,
CEE_LDLOC_2,
CEE_LDLOC_3,
CEE_STLOC_0,
CEE_STLOC_1,
CEE_STLOC_2,
CEE_STLOC_3,
CEE_LDARG_S,
CEE_LDARGA_S,
CEE_STARG_S,
CEE_LDLOC_S,
CEE_LDLOCA_S,
CEE_STLOC_S,
CEE_LDNULL,
CEE_LDC_I4_M1,
CEE_LDC_I4_0,
CEE_LDC_I4_1,
CEE_LDC_I4_2,
CEE_LDC_I4_3,
CEE_LDC_I4_4,
CEE_LDC_I4_5,
CEE_LDC_I4_6,
CEE_LDC_I4_7,
CEE_LDC_I4_8,
CEE_LDC_I4_S,
CEE_LDC_I4,
CEE_LDC_I8,
CEE_LDC_R4,
CEE_LDC_R8,
CEE_LDPTR,
CEE_DUP,
CEE_POP,
CEE_JMP,
CEE_CALL,
CEE_CALLI,
CEE_RET,
CEE_BR_S,
CEE_BRFALSE_S,
CEE_BRTRUE_S,
CEE_BEQ_S,
CEE_BGE_S,
CEE_BGT_S,
CEE_BLE_S,
CEE_BLT_S,
CEE_BNE_UN_S,
CEE_BGE_UN_S,
CEE_BGT_UN_S,
CEE_BLE_UN_S,
CEE_BLT_UN_S,
CEE_BR,
CEE_BRFALSE,
CEE_BRTRUE,
CEE_BEQ,
CEE_BGE,
CEE_BGT,
CEE_BLE,
CEE_BLT,
CEE_BNE_UN,
CEE_BGE_UN,
CEE_BGT_UN,
CEE_BLE_UN,
CEE_BLT_UN,
CEE_SWITCH,
CEE_LDIND_I1,
CEE_LDIND_U1,
CEE_LDIND_I2,
CEE_LDIND_U2,
CEE_LDIND_I4,
CEE_LDIND_U4,
CEE_LDIND_I8,
CEE_LDIND_I,
CEE_LDIND_R4,
CEE_LDIND_R8,
CEE_LDIND_REF,
CEE_STIND_REF,
CEE_STIND_I1,
CEE_STIND_I2,
CEE_STIND_I4,
CEE_STIND_I8,
CEE_STIND_R4,
CEE_STIND_R8,
CEE_ADD,
CEE_SUB,
CEE_MUL,
CEE_DIV,
CEE_DIV_UN,
CEE_REM,
CEE_REM_UN,
CEE_AND,
CEE_OR,
CEE_XOR,
CEE_SHL,
CEE_SHR,
CEE_SHR_UN,
CEE_NEG,
CEE_NOT,
CEE_CONV_I1,
CEE_CONV_I2,
CEE_CONV_I4,
CEE_CONV_I8,
CEE_CONV_R4,
CEE_CONV_R8,
CEE_CONV_U4,
CEE_CONV_U8,
CEE_CALLVIRT,
CEE_CPOBJ,
CEE_LDOBJ,
CEE_LDSTR,
CEE_NEWOBJ,
CEE_CASTCLASS,
CEE_ISINST,
CEE_CONV_R_UN,
CEE_ANN_DATA_S,
CEE_BOX,
CEE_UNBOX,
CEE_THROW,
CEE_LDFLD,
CEE_LDFLDA,
CEE_STFLD,
CEE_LDSFLD,
CEE_LDSFLDA,
CEE_STSFLD,
CEE_STOBJ,
CEE_CONV_OVF_I1_UN,
CEE_CONV_OVF_I2_UN,
CEE_CONV_OVF_I4_UN,
CEE_CONV_OVF_I8_UN,
CEE_CONV_OVF_U1_UN,
CEE_CONV_OVF_U2_UN,
CEE_CONV_OVF_U4_UN,
CEE_CONV_OVF_U8_UN,
CEE_CONV_OVF_I_UN,
CEE_CONV_OVF_U_UN,
CEE_UNUSED49,
CEE_NEWARR,
CEE_LDLEN,
CEE_LDELEMA,
CEE_LDELEM_I1,
CEE_LDELEM_U1,
CEE_LDELEM_I2,
CEE_LDELEM_U2,
CEE_LDELEM_I4,
CEE_LDELEM_U4,
CEE_LDELEM_I8,
CEE_LDELEM_I,
CEE_LDELEM_R4,
CEE_LDELEM_R8,
CEE_LDELEM_REF,
CEE_STELEM_I,
CEE_STELEM_I1,
CEE_STELEM_I2,
CEE_STELEM_I4,
CEE_STELEM_I8,
CEE_STELEM_R4,
CEE_STELEM_R8,
CEE_STELEM_REF,
CEE_UNUSED2,
CEE_UNUSED3,
CEE_UNUSED4,
CEE_UNUSED5,
CEE_UNUSED6,
CEE_UNUSED7,
CEE_UNUSED8,
CEE_UNUSED9,
CEE_UNUSED10,
CEE_UNUSED11,
CEE_UNUSED12,
CEE_UNUSED13,
CEE_UNUSED14,
CEE_UNUSED15,
CEE_UNUSED16,
CEE_UNUSED17,
CEE_CONV_OVF_I1,
CEE_CONV_OVF_U1,
CEE_CONV_OVF_I2,
CEE_CONV_OVF_U2,
CEE_CONV_OVF_I4,
CEE_CONV_OVF_U4,
CEE_CONV_OVF_I8,
CEE_CONV_OVF_U8,
CEE_UNUSED50,
CEE_UNUSED18,
CEE_UNUSED19,
CEE_UNUSED20,
CEE_UNUSED21,
CEE_UNUSED22,
CEE_UNUSED23,
CEE_REFANYVAL,
CEE_CKFINITE,
CEE_UNUSED24,
CEE_UNUSED25,
CEE_MKREFANY,
CEE_ANN_CALL,
CEE_ANN_CATCH,
CEE_ANN_DEAD,
CEE_ANN_HOISTED,
CEE_ANN_HOISTED_CALL,
CEE_ANN_LAB,
CEE_ANN_DEF,
CEE_ANN_REF_S,
CEE_ANN_PHI,
CEE_LDTOKEN,
CEE_CONV_U2,
CEE_CONV_U1,
CEE_CONV_I,
CEE_CONV_OVF_I,
CEE_CONV_OVF_U,
CEE_ADD_OVF,
CEE_ADD_OVF_UN,
CEE_MUL_OVF,
CEE_MUL_OVF_UN,
CEE_SUB_OVF,
CEE_SUB_OVF_UN,
CEE_ENDFINALLY,
CEE_LEAVE,
CEE_LEAVE_S,
CEE_STIND_I,
CEE_CONV_U,
CEE_UNUSED26,
CEE_UNUSED27,
CEE_UNUSED28,
CEE_UNUSED29,
CEE_UNUSED30,
CEE_UNUSED31,
CEE_UNUSED32,
CEE_UNUSED33,
CEE_UNUSED34,
CEE_UNUSED35,
CEE_UNUSED36,
CEE_UNUSED37,
CEE_UNUSED38,
CEE_UNUSED39,
CEE_UNUSED40,
CEE_UNUSED41,
CEE_UNUSED42,
CEE_UNUSED43,
CEE_UNUSED44,
CEE_UNUSED45,
CEE_UNUSED46,
CEE_UNUSED47,
CEE_UNUSED48,
CEE_PREFIX7,
CEE_PREFIX6,
CEE_PREFIX5,
CEE_PREFIX4,
CEE_PREFIX3,
CEE_PREFIX2,
CEE_PREFIX1,
CEE_PREFIXREF,

CEE_ARGLIST,
CEE_CEQ,
CEE_CGT,
CEE_CGT_UN,
CEE_CLT,
CEE_CLT_UN,
CEE_LDFTN,
CEE_LDVIRTFTN,
CEE_JMPI,
CEE_LDARG,
CEE_LDARGA,
CEE_STARG,
CEE_LDLOC,
CEE_LDLOCA,
CEE_STLOC,
CEE_LOCALLOC,
CEE_UNUSED57,
CEE_ENDFILTER,
CEE_UNALIGNED,
CEE_VOLATILE,
CEE_TAILCALL,
CEE_INITOBJ,
CEE_ANN_LIVE,
CEE_CPBLK,
CEE_INITBLK,
CEE_ANN_REF,
CEE_RETHROW,
CEE_UNUSED51,
CEE_SIZEOF,
CEE_REFANYTYPE,
CEE_UNUSED52,
CEE_UNUSED53,
CEE_UNUSED54,
CEE_UNUSED55,
CEE_ANN_DATA,



CEE_ILLEGAL,
CEE_MACRO_END,






#line 365 "..\\..\\inc\\opcode.def"














#line 380 "..\\..\\inc\\opcode.def"

#line 253 "macros.cpp"


    CEE_count,

    CEE_UNREACHED,
};

#line 261 "macros.cpp"



ILencoding          ILopcodeCodes[] =
{

    #line 1 "..\\..\\inc\\opcode.def"


















































#line 52 "..\\..\\inc\\opcode.def"









{ 0xFF, 0x00, 1 },
{ 0xFF, 0x01, 1 },
{ 0xFF, 0x02, 1 },
{ 0xFF, 0x03, 1 },
{ 0xFF, 0x04, 1 },
{ 0xFF, 0x05, 1 },
{ 0xFF, 0x06, 1 },
{ 0xFF, 0x07, 1 },
{ 0xFF, 0x08, 1 },
{ 0xFF, 0x09, 1 },
{ 0xFF, 0x0A, 1 },
{ 0xFF, 0x0B, 1 },
{ 0xFF, 0x0C, 1 },
{ 0xFF, 0x0D, 1 },
{ 0xFF, 0x0E, 1 },
{ 0xFF, 0x0F, 1 },
{ 0xFF, 0x10, 1 },
{ 0xFF, 0x11, 1 },
{ 0xFF, 0x12, 1 },
{ 0xFF, 0x13, 1 },
{ 0xFF, 0x14, 1 },
{ 0xFF, 0x15, 1 },
{ 0xFF, 0x16, 1 },
{ 0xFF, 0x17, 1 },
{ 0xFF, 0x18, 1 },
{ 0xFF, 0x19, 1 },
{ 0xFF, 0x1A, 1 },
{ 0xFF, 0x1B, 1 },
{ 0xFF, 0x1C, 1 },
{ 0xFF, 0x1D, 1 },
{ 0xFF, 0x1E, 1 },
{ 0xFF, 0x1F, 1 },
{ 0xFF, 0x20, 1 },
{ 0xFF, 0x21, 1 },
{ 0xFF, 0x22, 1 },
{ 0xFF, 0x23, 1 },
{ 0xFF, 0x24, 1 },
{ 0xFF, 0x25, 1 },
{ 0xFF, 0x26, 1 },
{ 0xFF, 0x27, 1 },
{ 0xFF, 0x28, 1 },
{ 0xFF, 0x29, 1 },
{ 0xFF, 0x2A, 1 },
{ 0xFF, 0x2B, 1 },
{ 0xFF, 0x2C, 1 },
{ 0xFF, 0x2D, 1 },
{ 0xFF, 0x2E, 1 },
{ 0xFF, 0x2F, 1 },
{ 0xFF, 0x30, 1 },
{ 0xFF, 0x31, 1 },
{ 0xFF, 0x32, 1 },
{ 0xFF, 0x33, 1 },
{ 0xFF, 0x34, 1 },
{ 0xFF, 0x35, 1 },
{ 0xFF, 0x36, 1 },
{ 0xFF, 0x37, 1 },
{ 0xFF, 0x38, 1 },
{ 0xFF, 0x39, 1 },
{ 0xFF, 0x3A, 1 },
{ 0xFF, 0x3B, 1 },
{ 0xFF, 0x3C, 1 },
{ 0xFF, 0x3D, 1 },
{ 0xFF, 0x3E, 1 },
{ 0xFF, 0x3F, 1 },
{ 0xFF, 0x40, 1 },
{ 0xFF, 0x41, 1 },
{ 0xFF, 0x42, 1 },
{ 0xFF, 0x43, 1 },
{ 0xFF, 0x44, 1 },
{ 0xFF, 0x45, 1 },
{ 0xFF, 0x46, 1 },
{ 0xFF, 0x47, 1 },
{ 0xFF, 0x48, 1 },
{ 0xFF, 0x49, 1 },
{ 0xFF, 0x4A, 1 },
{ 0xFF, 0x4B, 1 },
{ 0xFF, 0x4C, 1 },
{ 0xFF, 0x4D, 1 },
{ 0xFF, 0x4E, 1 },
{ 0xFF, 0x4F, 1 },
{ 0xFF, 0x50, 1 },
{ 0xFF, 0x51, 1 },
{ 0xFF, 0x52, 1 },
{ 0xFF, 0x53, 1 },
{ 0xFF, 0x54, 1 },
{ 0xFF, 0x55, 1 },
{ 0xFF, 0x56, 1 },
{ 0xFF, 0x57, 1 },
{ 0xFF, 0x58, 1 },
{ 0xFF, 0x59, 1 },
{ 0xFF, 0x5A, 1 },
{ 0xFF, 0x5B, 1 },
{ 0xFF, 0x5C, 1 },
{ 0xFF, 0x5D, 1 },
{ 0xFF, 0x5E, 1 },
{ 0xFF, 0x5F, 1 },
{ 0xFF, 0x60, 1 },
{ 0xFF, 0x61, 1 },
{ 0xFF, 0x62, 1 },
{ 0xFF, 0x63, 1 },
{ 0xFF, 0x64, 1 },
{ 0xFF, 0x65, 1 },
{ 0xFF, 0x66, 1 },
{ 0xFF, 0x67, 1 },
{ 0xFF, 0x68, 1 },
{ 0xFF, 0x69, 1 },
{ 0xFF, 0x6A, 1 },
{ 0xFF, 0x6B, 1 },
{ 0xFF, 0x6C, 1 },
{ 0xFF, 0x6D, 1 },
{ 0xFF, 0x6E, 1 },
{ 0xFF, 0x6F, 1 },
{ 0xFF, 0x70, 1 },
{ 0xFF, 0x71, 1 },
{ 0xFF, 0x72, 1 },
{ 0xFF, 0x73, 1 },
{ 0xFF, 0x74, 1 },
{ 0xFF, 0x75, 1 },
{ 0xFF, 0x76, 1 },
{ 0xFF, 0x77, 1 },
{ 0xFF, 0x78, 1 },
{ 0xFF, 0x79, 1 },
{ 0xFF, 0x7A, 1 },
{ 0xFF, 0x7B, 1 },
{ 0xFF, 0x7C, 1 },
{ 0xFF, 0x7D, 1 },
{ 0xFF, 0x7E, 1 },
{ 0xFF, 0x7F, 1 },
{ 0xFF, 0x80, 1 },
{ 0xFF, 0x81, 1 },
{ 0xFF, 0x82, 1 },
{ 0xFF, 0x83, 1 },
{ 0xFF, 0x84, 1 },
{ 0xFF, 0x85, 1 },
{ 0xFF, 0x86, 1 },
{ 0xFF, 0x87, 1 },
{ 0xFF, 0x88, 1 },
{ 0xFF, 0x89, 1 },
{ 0xFF, 0x8A, 1 },
{ 0xFF, 0x8B, 1 },
{ 0xFF, 0x8C, 1 },
{ 0xFF, 0x8D, 1 },
{ 0xFF, 0x8E, 1 },
{ 0xFF, 0x8F, 1 },
{ 0xFF, 0x90, 1 },
{ 0xFF, 0x91, 1 },
{ 0xFF, 0x92, 1 },
{ 0xFF, 0x93, 1 },
{ 0xFF, 0x94, 1 },
{ 0xFF, 0x95, 1 },
{ 0xFF, 0x96, 1 },
{ 0xFF, 0x97, 1 },
{ 0xFF, 0x98, 1 },
{ 0xFF, 0x99, 1 },
{ 0xFF, 0x9A, 1 },
{ 0xFF, 0x9B, 1 },
{ 0xFF, 0x9C, 1 },
{ 0xFF, 0x9D, 1 },
{ 0xFF, 0x9E, 1 },
{ 0xFF, 0x9F, 1 },
{ 0xFF, 0xA0, 1 },
{ 0xFF, 0xA1, 1 },
{ 0xFF, 0xA2, 1 },
{ 0xFF, 0xA3, 1 },
{ 0xFF, 0xA4, 1 },
{ 0xFF, 0xA5, 1 },
{ 0xFF, 0xA6, 1 },
{ 0xFF, 0xA7, 1 },
{ 0xFF, 0xA8, 1 },
{ 0xFF, 0xA9, 1 },
{ 0xFF, 0xAA, 1 },
{ 0xFF, 0xAB, 1 },
{ 0xFF, 0xAC, 1 },
{ 0xFF, 0xAD, 1 },
{ 0xFF, 0xAE, 1 },
{ 0xFF, 0xAF, 1 },
{ 0xFF, 0xB0, 1 },
{ 0xFF, 0xB1, 1 },
{ 0xFF, 0xB2, 1 },
{ 0xFF, 0xB3, 1 },
{ 0xFF, 0xB4, 1 },
{ 0xFF, 0xB5, 1 },
{ 0xFF, 0xB6, 1 },
{ 0xFF, 0xB7, 1 },
{ 0xFF, 0xB8, 1 },
{ 0xFF, 0xB9, 1 },
{ 0xFF, 0xBA, 1 },
{ 0xFF, 0xBB, 1 },
{ 0xFF, 0xBC, 1 },
{ 0xFF, 0xBD, 1 },
{ 0xFF, 0xBE, 1 },
{ 0xFF, 0xBF, 1 },
{ 0xFF, 0xC0, 1 },
{ 0xFF, 0xC1, 1 },
{ 0xFF, 0xC2, 1 },
{ 0xFF, 0xC3, 1 },
{ 0xFF, 0xC4, 1 },
{ 0xFF, 0xC5, 1 },
{ 0xFF, 0xC6, 1 },
{ 0xFF, 0xC7, 1 },
{ 0xFF, 0xC8, 1 },
{ 0xFF, 0xC9, 1 },
{ 0xFF, 0xCA, 1 },
{ 0xFF, 0xCB, 1 },
{ 0xFF, 0xCC, 1 },
{ 0xFF, 0xCD, 1 },
{ 0xFF, 0xCE, 1 },
{ 0xFF, 0xCF, 1 },
{ 0xFF, 0xD0, 1 },
{ 0xFF, 0xD1, 1 },
{ 0xFF, 0xD2, 1 },
{ 0xFF, 0xD3, 1 },
{ 0xFF, 0xD4, 1 },
{ 0xFF, 0xD5, 1 },
{ 0xFF, 0xD6, 1 },
{ 0xFF, 0xD7, 1 },
{ 0xFF, 0xD8, 1 },
{ 0xFF, 0xD9, 1 },
{ 0xFF, 0xDA, 1 },
{ 0xFF, 0xDB, 1 },
{ 0xFF, 0xDC, 1 },
{ 0xFF, 0xDD, 1 },
{ 0xFF, 0xDE, 1 },
{ 0xFF, 0xDF, 1 },
{ 0xFF, 0xE0, 1 },
{ 0xFF, 0xE1, 1 },
{ 0xFF, 0xE2, 1 },
{ 0xFF, 0xE3, 1 },
{ 0xFF, 0xE4, 1 },
{ 0xFF, 0xE5, 1 },
{ 0xFF, 0xE6, 1 },
{ 0xFF, 0xE7, 1 },
{ 0xFF, 0xE8, 1 },
{ 0xFF, 0xE9, 1 },
{ 0xFF, 0xEA, 1 },
{ 0xFF, 0xEB, 1 },
{ 0xFF, 0xEC, 1 },
{ 0xFF, 0xED, 1 },
{ 0xFF, 0xEE, 1 },
{ 0xFF, 0xEF, 1 },
{ 0xFF, 0xF0, 1 },
{ 0xFF, 0xF1, 1 },
{ 0xFF, 0xF2, 1 },
{ 0xFF, 0xF3, 1 },
{ 0xFF, 0xF4, 1 },
{ 0xFF, 0xF5, 1 },
{ 0xFF, 0xF6, 1 },
{ 0xFF, 0xF7, 1 },
{ 0xFF, 0xF8, 1 },
{ 0xFF, 0xF9, 1 },
{ 0xFF, 0xFA, 1 },
{ 0xFF, 0xFB, 1 },
{ 0xFF, 0xFC, 1 },
{ 0xFF, 0xFD, 1 },
{ 0xFF, 0xFE, 1 },
{ 0xFF, 0xFF, 1 },

{ 0xFE, 0x00, 2 },
{ 0xFE, 0x01, 2 },
{ 0xFE, 0x02, 2 },
{ 0xFE, 0x03, 2 },
{ 0xFE, 0x04, 2 },
{ 0xFE, 0x05, 2 },
{ 0xFE, 0x06, 2 },
{ 0xFE, 0x07, 2 },
{ 0xFE, 0x08, 2 },
{ 0xFE, 0x09, 2 },
{ 0xFE, 0x0A, 2 },
{ 0xFE, 0x0B, 2 },
{ 0xFE, 0x0C, 2 },
{ 0xFE, 0x0D, 2 },
{ 0xFE, 0x0E, 2 },
{ 0xFE, 0x0F, 2 },
{ 0xFE, 0x10, 2 },
{ 0xFE, 0x11, 2 },
{ 0xFE, 0x12, 2 },
{ 0xFE, 0x13, 2 },
{ 0xFE, 0x14, 2 },
{ 0xFE, 0x15, 2 },
{ 0xFE, 0x16, 2 },
{ 0xFE, 0x17, 2 },
{ 0xFE, 0x18, 2 },
{ 0xFE, 0x19, 2 },
{ 0xFE, 0x1A, 2 },
{ 0xFE, 0x1B, 2 },
{ 0xFE, 0x1C, 2 },
{ 0xFE, 0x1D, 2 },
{ 0xFE, 0x1E, 2 },
{ 0xFE, 0x1F, 2 },
{ 0xFE, 0x20, 2 },
{ 0xFE, 0x21, 2 },
{ 0xFE, 0x22, 2 },



{ 0x00, 0x00, 0 },
{ 0x00, 0x00, 0 },






#line 365 "..\\..\\inc\\opcode.def"














#line 380 "..\\..\\inc\\opcode.def"

#line 268 "macros.cpp"

};





















signed  char        ILopcodeStack[] =
{

    #line 1 "..\\..\\inc\\opcode.def"


















































#line 52 "..\\..\\inc\\opcode.def"









((0)+(0)),
((0)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((0)+(-1)),
((0)+(-1)),
((0)+(-1)),
((0)+(-1)),
((1)+(0)),
((1)+(0)),
((0)+(-1)),
((1)+(0)),
((1)+(0)),
((0)+(-1)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1)+(0)),
((1+1)+(-1)),
((0)+(-1)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(-1)),
((0)+(-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(0)),
((0)+(-1)),
((0)+(-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((0)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((0)+(0)),
((0)+(-1+-1)),
((1)+(-1)),
((1)+(0)),
((1)+(0)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((0)+(0)),
((1)+(-1)),
((1)+(-1)),
((0)+(-1)),
((1)+(-1)),
((1)+(-1)),
((0)+(-1+-1)),
((1)+(0)),
((1)+(0)),
((0)+(-1)),
((0)+(-1+-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((0)+(0)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((0)+(-1+-1+-1)),
((0)+(-1+-1+-1)),
((0)+(-1+-1+-1)),
((0)+(-1+-1+-1)),
((0)+(-1+-1+-1)),
((0)+(-1+-1+-1)),
((0)+(-1+-1+-1)),
((0)+(-1+-1+-1)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((1)+(-1)),
((1)+(-1)),
((0)+(0)),
((0)+(0)),
((1)+(-1)),
((0)+(0)),
((0)+(0)),
((1)+(-1)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((1)+(0)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(-1+-1)),
((1)+(-1)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),

((1)+(0)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(-1+-1)),
((1)+(0)),
((1)+(-1)),
((0)+(-1)),
((1)+(0)),
((1)+(0)),
((0)+(-1)),
((1)+(0)),
((1)+(0)),
((0)+(-1)),
((1)+(-1)),
((0)+(0)),
((0)+(-1)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(-1)),
((1)+(-1)),
((0)+(-1+-1+-1)),
((0)+(-1+-1+-1)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((1)+(0)),
((1)+(-1)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),
((0)+(0)),



((0)+(0)),
((0)+(0)),






#line 365 "..\\..\\inc\\opcode.def"














#line 380 "..\\..\\inc\\opcode.def"

#line 295 "macros.cpp"

};





const char *        opcodeNames[] =
{

    #line 1 "..\\..\\inc\\opcode.def"


















































#line 52 "..\\..\\inc\\opcode.def"









"nop",
"break",
"ldarg.0",
"ldarg.1",
"ldarg.2",
"ldarg.3",
"ldloc.0",
"ldloc.1",
"ldloc.2",
"ldloc.3",
"stloc.0",
"stloc.1",
"stloc.2",
"stloc.3",
"ldarg.s",
"ldarga.s",
"starg.s",
"ldloc.s",
"ldloca.s",
"stloc.s",
"ldnull",
"ldc.i4.m1",
"ldc.i4.0",
"ldc.i4.1",
"ldc.i4.2",
"ldc.i4.3",
"ldc.i4.4",
"ldc.i4.5",
"ldc.i4.6",
"ldc.i4.7",
"ldc.i4.8",
"ldc.i4.s",
"ldc.i4",
"ldc.i8",
"ldc.r4",
"ldc.r8",
"ldptr",
"dup",
"pop",
"jmp",
"call",
"calli",
"ret",
"br.s",
"brfalse.s",
"brtrue.s",
"beq.s",
"bge.s",
"bgt.s",
"ble.s",
"blt.s",
"bne.un.s",
"bge.un.s",
"bgt.un.s",
"ble.un.s",
"blt.un.s",
"br",
"brfalse",
"brtrue",
"beq",
"bge",
"bgt",
"ble",
"blt",
"bne.un",
"bge.un",
"bgt.un",
"ble.un",
"blt.un",
"switch",
"ldind.i1",
"ldind.u1",
"ldind.i2",
"ldind.u2",
"ldind.i4",
"ldind.u4",
"ldind.i8",
"ldind.i",
"ldind.r4",
"ldind.r8",
"ldind.ref",
"stind.ref",
"stind.i1",
"stind.i2",
"stind.i4",
"stind.i8",
"stind.r4",
"stind.r8",
"add",
"sub",
"mul",
"div",
"div.un",
"rem",
"rem.un",
"and",
"or",
"xor",
"shl",
"shr",
"shr.un",
"neg",
"not",
"conv.i1",
"conv.i2",
"conv.i4",
"conv.i8",
"conv.r4",
"conv.r8",
"conv.u4",
"conv.u8",
"callvirt",
"cpobj",
"ldobj",
"ldstr",
"newobj",
"castclass",
"isinst",
"conv.r.un",
"ann.data.s",
"box",
"unbox",
"throw",
"ldfld",
"ldflda",
"stfld",
"ldsfld",
"ldsflda",
"stsfld",
"stobj",
"conv.ovf.i1.un",
"conv.ovf.i2.un",
"conv.ovf.i4.un",
"conv.ovf.i8.un",
"conv.ovf.u1.un",
"conv.ovf.u2.un",
"conv.ovf.u4.un",
"conv.ovf.u8.un",
"conv.ovf.i.un",
"conv.ovf.u.un",
"unused",
"newarr",
"ldlen",
"ldelema",
"ldelem.i1",
"ldelem.u1",
"ldelem.i2",
"ldelem.u2",
"ldelem.i4",
"ldelem.u4",
"ldelem.i8",
"ldelem.i",
"ldelem.r4",
"ldelem.r8",
"ldelem.ref",
"stelem.i",
"stelem.i1",
"stelem.i2",
"stelem.i4",
"stelem.i8",
"stelem.r4",
"stelem.r8",
"stelem.ref",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"conv.ovf.i1",
"conv.ovf.u1",
"conv.ovf.i2",
"conv.ovf.u2",
"conv.ovf.i4",
"conv.ovf.u4",
"conv.ovf.i8",
"conv.ovf.u8",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"refanyval",
"ckfinite",
"unused",
"unused",
"mkrefany",
"ann.call",
"ann.catch",
"ann.dead",
"ann.hoisted",
"ann.hoisted_call",
"ann.lab",
"ann.def",
"ann.ref.s",
"ann.phi",
"ldtoken",
"conv.u2",
"conv.u1",
"conv.i",
"conv.ovf.i",
"conv.ovf.u",
"add.ovf",
"add.ovf.un",
"mul.ovf",
"mul.ovf.un",
"sub.ovf",
"sub.ovf.un",
"endfinally",
"leave",
"leave.s",
"stind.i",
"conv.u",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"unused",
"prefix7",
"prefix6",
"prefix5",
"prefix4",
"prefix3",
"prefix2",
"prefix1",
"prefixref",

"arglist",
"ceq",
"cgt",
"cgt.un",
"clt",
"clt.un",
"ldftn",
"ldvirtftn",
"jmpi",
"ldarg",
"ldarga",
"starg",
"ldloc",
"ldloca",
"stloc",
"localloc",
"unused",
"endfilter",
"unaligned.",
"volatile.",
"tail.",
"initobj",
"ann.live",
"cpblk",
"initblk",
"ann.ref",
"rethrow",
"unused",
"sizeof",
"refanytype",
"unused",
"unused",
"unused",
"unused",
"ann.data",



"illegal",
"endmac",






#line 365 "..\\..\\inc\\opcode.def"














#line 380 "..\\..\\inc\\opcode.def"

#line 306 "macros.cpp"

};

const char *        opcodeName(unsigned op)
{
    assert(op < sizeof(opcodeNames)/sizeof(*opcodeNames));

    return  opcodeNames[op];
}

#line 317 "macros.cpp"



const   char *      MDnamesStr[] =
{

    #line 1 "MDnames.h"


NULL,

"op_Addition",
"op_Subtraction",
"op_Multiply",
"op_Division",
"op_Modulus",

"op_BitwiseOr",
"op_ExclusiveOr",
"op_BitwiseAnd",

"op_LeftShift",
"op_RightShift",
"op_UnsignedRightShift",

"op_Concat",

"op_Equality",
"op_Inequality",

"op_LessThan",
"op_LessThanOrEqual",
"op_GreaterThanOrEqual",
"op_GreaterThan",

"op_LogicalAnd",
"op_LogicalOr",

"op_LogicalNot",
"op_OnesComplement",

"op_UnaryPlus",
"op_UnaryNegation",

"op_Increment",
"op_Decrement",

"op_Assignment",

"op_AdditionAssignment",
"op_SubtractionAssignment",
"op_MultiplicationAssignment",
"op_DivisionAssignment",
"op_ModulusAssignment",

"op_BitwiseOrAssignment",
"op_ExclusiveOrAssignment",
"op_BitwiseAndAssignment",

"op_LeftShiftAssignment",
"op_RightShiftAssignment",
"op_UnsignedRightShiftAssignment",

"op_ConcatAssignment",

".ctor",
".cctor",

"op_Finalize",

"op_Implicit",
"op_Explicit",

"op_Equals",
"op_Compare",

"get_",
"set_",
#line 324 "macros.cpp"

};



const  ovlOpFlavors MDnamesChk[] =
{

    #line 1 "MDnames.h"


OVOP_NONE,

OVOP_ADD,
OVOP_SUB,
OVOP_MUL,
OVOP_DIV,
OVOP_MOD,

OVOP_OR,
OVOP_XOR,
OVOP_AND,

OVOP_LSH,
OVOP_RSH,
OVOP_RSZ,

OVOP_CNC,

OVOP_EQ,
OVOP_NE,

OVOP_LT,
OVOP_LE,
OVOP_GE,
OVOP_GT,

OVOP_LOG_AND,
OVOP_LOG_OR,

OVOP_LOG_NOT,
OVOP_NOT,

OVOP_NOP,
OVOP_NEG,

OVOP_INC,
OVOP_DEC,

OVOP_ASG,

OVOP_ASG_ADD,
OVOP_ASG_SUB,
OVOP_ASG_MUL,
OVOP_ASG_DIV,
OVOP_ASG_MOD,

OVOP_ASG_AND,
OVOP_ASG_XOR,
OVOP_ASG_OR,

OVOP_ASG_LSH,
OVOP_ASG_RSH,
OVOP_ASG_RSZ,

OVOP_ASG_CNC,

OVOP_CTOR_INST,
OVOP_CTOR_STAT,

OVOP_FINALIZER,

OVOP_CONV_IMP,
OVOP_CONV_EXP,

OVOP_EQUALS,
OVOP_COMPARE,

OVOP_PROP_GET,
OVOP_PROP_SET,
#line 333 "macros.cpp"

};

#line 337 "macros.cpp"

#line 1 "MDstrns.h"






#line 1 "MDnames.h"


const normString OVOP_STR_NONE = NULL;

const normString OVOP_STR_ADD = "op_Addition";
const normString OVOP_STR_SUB = "op_Subtraction";
const normString OVOP_STR_MUL = "op_Multiply";
const normString OVOP_STR_DIV = "op_Division";
const normString OVOP_STR_MOD = "op_Modulus";

const normString OVOP_STR_OR = "op_BitwiseOr";
const normString OVOP_STR_XOR = "op_ExclusiveOr";
const normString OVOP_STR_AND = "op_BitwiseAnd";

const normString OVOP_STR_LSH = "op_LeftShift";
const normString OVOP_STR_RSH = "op_RightShift";
const normString OVOP_STR_RSZ = "op_UnsignedRightShift";

const normString OVOP_STR_CNC = "op_Concat";

const normString OVOP_STR_EQ = "op_Equality";
const normString OVOP_STR_NE = "op_Inequality";

const normString OVOP_STR_LT = "op_LessThan";
const normString OVOP_STR_LE = "op_LessThanOrEqual";
const normString OVOP_STR_GE = "op_GreaterThanOrEqual";
const normString OVOP_STR_GT = "op_GreaterThan";

const normString OVOP_STR_LOG_AND = "op_LogicalAnd";
const normString OVOP_STR_LOG_OR = "op_LogicalOr";

const normString OVOP_STR_LOG_NOT = "op_LogicalNot";
const normString OVOP_STR_NOT = "op_OnesComplement";

const normString OVOP_STR_NOP = "op_UnaryPlus";
const normString OVOP_STR_NEG = "op_UnaryNegation";

const normString OVOP_STR_INC = "op_Increment";
const normString OVOP_STR_DEC = "op_Decrement";

const normString OVOP_STR_ASG = "op_Assignment";

const normString OVOP_STR_ASG_ADD = "op_AdditionAssignment";
const normString OVOP_STR_ASG_SUB = "op_SubtractionAssignment";
const normString OVOP_STR_ASG_MUL = "op_MultiplicationAssignment";
const normString OVOP_STR_ASG_DIV = "op_DivisionAssignment";
const normString OVOP_STR_ASG_MOD = "op_ModulusAssignment";

const normString OVOP_STR_ASG_AND = "op_BitwiseOrAssignment";
const normString OVOP_STR_ASG_XOR = "op_ExclusiveOrAssignment";
const normString OVOP_STR_ASG_OR = "op_BitwiseAndAssignment";

const normString OVOP_STR_ASG_LSH = "op_LeftShiftAssignment";
const normString OVOP_STR_ASG_RSH = "op_RightShiftAssignment";
const normString OVOP_STR_ASG_RSZ = "op_UnsignedRightShiftAssignment";

const normString OVOP_STR_ASG_CNC = "op_ConcatAssignment";

const normString OVOP_STR_CTOR_INST = ".ctor";
const normString OVOP_STR_CTOR_STAT = ".cctor";

const normString OVOP_STR_FINALIZER = "op_Finalize";

const normString OVOP_STR_CONV_IMP = "op_Implicit";
const normString OVOP_STR_CONV_EXP = "op_Explicit";

const normString OVOP_STR_EQUALS = "op_Equals";
const normString OVOP_STR_COMPARE = "op_Compare";

const normString OVOP_STR_PROP_GET = "get_";
const normString OVOP_STR_PROP_SET = "set_";
#line 8 "MDstrns.h"



#line 12 "MDstrns.h"

#line 339 "macros.cpp"

ovlOpFlavors        MDfindOvop(const char *name)
{
    unsigned        i;



    for (i = 0; i < (sizeof(MDnamesStr)/sizeof(*(MDnamesStr))); i++)
    {
        if  (MDnamesStr[i] && !strcmp(name, MDnamesStr[i]))
            return  (ovlOpFlavors)i;
    }

    return  OVOP_NONE;
}