summary refs log tree commit diff stats
path: root/nim/ast.pas
diff options
context:
space:
mode:
Diffstat (limited to 'nim/ast.pas')
-rw-r--r--nim/ast.pas459
1 files changed, 230 insertions, 229 deletions
diff --git a/nim/ast.pas b/nim/ast.pas
index be967a568..c22385805 100644
--- a/nim/ast.pas
+++ b/nim/ast.pas
@@ -65,148 +65,148 @@ for key, val in enums.items():
   cog.out(a)

   cog.out(b)

 ]]]*)

-type

-  TTypeFlag = (

-    tfVarargs, tfFinal, tfAcyclic, tfEnumHasWholes);

-  TTypeFlags = set of TTypeFlag;

-const

-  TypeFlagToStr: array [TTypeFlag] of string = (

-    'tfVarargs', 'tfFinal', 'tfAcyclic', 'tfEnumHasWholes');

-type

-  TTypeKind = (

-    tyNone, tyBool, tyChar, tyEmpty, 

-    tyArrayConstr, tyNil, tyGeneric, tyGenericInst, 

-    tyGenericParam, tyEnum, tyAnyEnum, tyArray, 

-    tyObject, tyTuple, tySet, tyRange, 

-    tyPtr, tyRef, tyVar, tySequence, 

-    tyProc, tyPointer, tyOpenArray, tyString, 

-    tyCString, tyForward, tyInt, tyInt8, 

-    tyInt16, tyInt32, tyInt64, tyFloat, 

-    tyFloat32, tyFloat64, tyFloat128);

-  TTypeKinds = set of TTypeKind;

-const

-  TypeKindToStr: array [TTypeKind] of string = (

-    'tyNone', 'tyBool', 'tyChar', 'tyEmpty', 

-    'tyArrayConstr', 'tyNil', 'tyGeneric', 'tyGenericInst', 

-    'tyGenericParam', 'tyEnum', 'tyAnyEnum', 'tyArray', 

-    'tyObject', 'tyTuple', 'tySet', 'tyRange', 

-    'tyPtr', 'tyRef', 'tyVar', 'tySequence', 

-    'tyProc', 'tyPointer', 'tyOpenArray', 'tyString', 

-    'tyCString', 'tyForward', 'tyInt', 'tyInt8', 

-    'tyInt16', 'tyInt32', 'tyInt64', 'tyFloat', 

-    'tyFloat32', 'tyFloat64', 'tyFloat128');

-type

-  TSymFlag = (

-    sfUsed, sfStar, sfMinus, sfInInterface, 

-    sfFromGeneric, sfGlobal, sfForward, sfImportc, 

-    sfExportc, sfVolatile, sfRegister, sfPure, 

-    sfResult, sfNoSideEffect, sfMainModule, sfSystemModule, 

-    sfNoReturn, sfAddrTaken, sfCompilerProc, sfCppMethod, 

-    sfDiscriminant, sfDeprecated, sfInClosure, sfTypeCheck, 

-    sfCompileTime, sfThreadVar, sfMerge);

-  TSymFlags = set of TSymFlag;

-const

-  SymFlagToStr: array [TSymFlag] of string = (

-    'sfUsed', 'sfStar', 'sfMinus', 'sfInInterface', 

-    'sfFromGeneric', 'sfGlobal', 'sfForward', 'sfImportc', 

-    'sfExportc', 'sfVolatile', 'sfRegister', 'sfPure', 

-    'sfResult', 'sfNoSideEffect', 'sfMainModule', 'sfSystemModule', 

-    'sfNoReturn', 'sfAddrTaken', 'sfCompilerProc', 'sfCppMethod', 

-    'sfDiscriminant', 'sfDeprecated', 'sfInClosure', 'sfTypeCheck', 

-    'sfCompileTime', 'sfThreadVar', 'sfMerge');

-type

-  TNodeFlag = (

-    nfNone, nfBase2, nfBase8, nfBase16, 

-    nfAllConst, nfTransf, nfSem);

-  TNodeFlags = set of TNodeFlag;

-const

-  NodeFlagToStr: array [TNodeFlag] of string = (

-    'nfNone', 'nfBase2', 'nfBase8', 'nfBase16', 

-    'nfAllConst', 'nfTransf', 'nfSem');

-type

-  TSymKind = (

-    skUnknownSym, skConditional, skDynLib, skParam, 

-    skTypeParam, skTemp, skType, skConst, 

-    skVar, skProc, skIterator, skConverter, 

-    skMacro, skTemplate, skField, skEnumField, 

-    skForVar, skModule, skLabel, skStub);

-  TSymKinds = set of TSymKind;

-const

-  SymKindToStr: array [TSymKind] of string = (

-    'skUnknownSym', 'skConditional', 'skDynLib', 'skParam', 

-    'skTypeParam', 'skTemp', 'skType', 'skConst', 

-    'skVar', 'skProc', 'skIterator', 'skConverter', 

-    'skMacro', 'skTemplate', 'skField', 'skEnumField', 

-    'skForVar', 'skModule', 'skLabel', 'skStub');

-type

-  TNodeKind = (

-    nkNone, nkEmpty, nkIdent, nkSym, 

-    nkType, nkCharLit, nkIntLit, nkInt8Lit, 

-    nkInt16Lit, nkInt32Lit, nkInt64Lit, nkFloatLit, 

-    nkFloat32Lit, nkFloat64Lit, nkStrLit, nkRStrLit, 

-    nkTripleStrLit, nkMetaNode, nkNilLit, nkDotCall, 

-    nkCommand, nkCall, nkGenericCall, nkExplicitTypeListCall, 

-    nkExprEqExpr, nkExprColonExpr, nkIdentDefs, nkInfix, 

-    nkPrefix, nkPostfix, nkPar, nkCurly, 

-    nkBracket, nkBracketExpr, nkPragmaExpr, nkRange, 

-    nkDotExpr, nkCheckedFieldExpr, nkDerefExpr, nkIfExpr, 

-    nkElifExpr, nkElseExpr, nkLambda, nkAccQuoted, 

-    nkHeaderQuoted, nkTableConstr, nkQualified, nkHiddenStdConv, 

-    nkHiddenSubConv, nkHiddenCallConv, nkConv, nkCast, 

-    nkAddr, nkHiddenAddr, nkHiddenDeref, nkObjDownConv, 

-    nkObjUpConv, nkChckRangeF, nkChckRange64, nkChckRange, 

-    nkStringToCString, nkCStringToString, nkPassAsOpenArray, nkAsgn, 

-    nkDefaultTypeParam, nkGenericParams, nkFormalParams, nkOfInherit, 

-    nkModule, nkProcDef, nkConverterDef, nkMacroDef, 

-    nkTemplateDef, nkIteratorDef, nkOfBranch, nkElifBranch, 

-    nkExceptBranch, nkElse, nkMacroStmt, nkAsmStmt, 

-    nkPragma, nkIfStmt, nkWhenStmt, nkForStmt, 

-    nkWhileStmt, nkCaseStmt, nkVarSection, nkConstSection, 

-    nkConstDef, nkTypeSection, nkTypeDef, nkYieldStmt, 

-    nkTryStmt, nkFinally, nkRaiseStmt, nkReturnStmt, 

-    nkBreakStmt, nkContinueStmt, nkBlockStmt, nkDiscardStmt, 

-    nkStmtList, nkImportStmt, nkFromStmt, nkImportAs, 

-    nkIncludeStmt, nkAccessStmt, nkCommentStmt, nkStmtListExpr, 

-    nkBlockExpr, nkStmtListType, nkBlockType, nkVm, 

-    nkTypeOfExpr, nkObjectTy, nkTupleTy, nkRecList, 

-    nkRecCase, nkRecWhen, nkRefTy, nkPtrTy, 

-    nkVarTy, nkProcTy, nkEnumTy, nkEnumFieldDef, 

-    nkReturnToken);

-  TNodeKinds = set of TNodeKind;

-const

-  NodeKindToStr: array [TNodeKind] of string = (

-    'nkNone', 'nkEmpty', 'nkIdent', 'nkSym', 

-    'nkType', 'nkCharLit', 'nkIntLit', 'nkInt8Lit', 

-    'nkInt16Lit', 'nkInt32Lit', 'nkInt64Lit', 'nkFloatLit', 

-    'nkFloat32Lit', 'nkFloat64Lit', 'nkStrLit', 'nkRStrLit', 

-    'nkTripleStrLit', 'nkMetaNode', 'nkNilLit', 'nkDotCall', 

-    'nkCommand', 'nkCall', 'nkGenericCall', 'nkExplicitTypeListCall', 

-    'nkExprEqExpr', 'nkExprColonExpr', 'nkIdentDefs', 'nkInfix', 

-    'nkPrefix', 'nkPostfix', 'nkPar', 'nkCurly', 

-    'nkBracket', 'nkBracketExpr', 'nkPragmaExpr', 'nkRange', 

-    'nkDotExpr', 'nkCheckedFieldExpr', 'nkDerefExpr', 'nkIfExpr', 

-    'nkElifExpr', 'nkElseExpr', 'nkLambda', 'nkAccQuoted', 

-    'nkHeaderQuoted', 'nkTableConstr', 'nkQualified', 'nkHiddenStdConv', 

-    'nkHiddenSubConv', 'nkHiddenCallConv', 'nkConv', 'nkCast', 

-    'nkAddr', 'nkHiddenAddr', 'nkHiddenDeref', 'nkObjDownConv', 

-    'nkObjUpConv', 'nkChckRangeF', 'nkChckRange64', 'nkChckRange', 

-    'nkStringToCString', 'nkCStringToString', 'nkPassAsOpenArray', 'nkAsgn', 

-    'nkDefaultTypeParam', 'nkGenericParams', 'nkFormalParams', 'nkOfInherit', 

-    'nkModule', 'nkProcDef', 'nkConverterDef', 'nkMacroDef', 

-    'nkTemplateDef', 'nkIteratorDef', 'nkOfBranch', 'nkElifBranch', 

-    'nkExceptBranch', 'nkElse', 'nkMacroStmt', 'nkAsmStmt', 

-    'nkPragma', 'nkIfStmt', 'nkWhenStmt', 'nkForStmt', 

-    'nkWhileStmt', 'nkCaseStmt', 'nkVarSection', 'nkConstSection', 

-    'nkConstDef', 'nkTypeSection', 'nkTypeDef', 'nkYieldStmt', 

-    'nkTryStmt', 'nkFinally', 'nkRaiseStmt', 'nkReturnStmt', 

-    'nkBreakStmt', 'nkContinueStmt', 'nkBlockStmt', 'nkDiscardStmt', 

-    'nkStmtList', 'nkImportStmt', 'nkFromStmt', 'nkImportAs', 

-    'nkIncludeStmt', 'nkAccessStmt', 'nkCommentStmt', 'nkStmtListExpr', 

-    'nkBlockExpr', 'nkStmtListType', 'nkBlockType', 'nkVm', 

-    'nkTypeOfExpr', 'nkObjectTy', 'nkTupleTy', 'nkRecList', 

-    'nkRecCase', 'nkRecWhen', 'nkRefTy', 'nkPtrTy', 

-    'nkVarTy', 'nkProcTy', 'nkEnumTy', 'nkEnumFieldDef', 

-    'nkReturnToken');

+type
+  TNodeKind = (
+    nkNone, nkEmpty, nkIdent, nkSym, 
+    nkType, nkCharLit, nkIntLit, nkInt8Lit, 
+    nkInt16Lit, nkInt32Lit, nkInt64Lit, nkFloatLit, 
+    nkFloat32Lit, nkFloat64Lit, nkStrLit, nkRStrLit, 
+    nkTripleStrLit, nkMetaNode, nkNilLit, nkDotCall, 
+    nkCommand, nkCall, nkGenericCall, nkExplicitTypeListCall, 
+    nkExprEqExpr, nkExprColonExpr, nkIdentDefs, nkVarTuple, 
+    nkInfix, nkPrefix, nkPostfix, nkPar, 
+    nkCurly, nkBracket, nkBracketExpr, nkPragmaExpr, 
+    nkRange, nkDotExpr, nkCheckedFieldExpr, nkDerefExpr, 
+    nkIfExpr, nkElifExpr, nkElseExpr, nkLambda, 
+    nkAccQuoted, nkHeaderQuoted, nkTableConstr, nkQualified, 
+    nkHiddenStdConv, nkHiddenSubConv, nkHiddenCallConv, nkConv, 
+    nkCast, nkAddr, nkHiddenAddr, nkHiddenDeref, 
+    nkObjDownConv, nkObjUpConv, nkChckRangeF, nkChckRange64, 
+    nkChckRange, nkStringToCString, nkCStringToString, nkPassAsOpenArray, 
+    nkAsgn, nkFastAsgn, nkDefaultTypeParam, nkGenericParams, 
+    nkFormalParams, nkOfInherit, nkModule, nkProcDef, 
+    nkConverterDef, nkMacroDef, nkTemplateDef, nkIteratorDef, 
+    nkOfBranch, nkElifBranch, nkExceptBranch, nkElse, 
+    nkMacroStmt, nkAsmStmt, nkPragma, nkIfStmt, 
+    nkWhenStmt, nkForStmt, nkWhileStmt, nkCaseStmt, 
+    nkVarSection, nkConstSection, nkConstDef, nkTypeSection, 
+    nkTypeDef, nkYieldStmt, nkTryStmt, nkFinally, 
+    nkRaiseStmt, nkReturnStmt, nkBreakStmt, nkContinueStmt, 
+    nkBlockStmt, nkDiscardStmt, nkStmtList, nkImportStmt, 
+    nkFromStmt, nkImportAs, nkIncludeStmt, nkAccessStmt, 
+    nkCommentStmt, nkStmtListExpr, nkBlockExpr, nkStmtListType, 
+    nkBlockType, nkVm, nkTypeOfExpr, nkObjectTy, 
+    nkTupleTy, nkRecList, nkRecCase, nkRecWhen, 
+    nkRefTy, nkPtrTy, nkVarTy, nkProcTy, 
+    nkEnumTy, nkEnumFieldDef, nkReturnToken);
+  TNodeKinds = set of TNodeKind;
+const
+  NodeKindToStr: array [TNodeKind] of string = (
+    'nkNone', 'nkEmpty', 'nkIdent', 'nkSym', 
+    'nkType', 'nkCharLit', 'nkIntLit', 'nkInt8Lit', 
+    'nkInt16Lit', 'nkInt32Lit', 'nkInt64Lit', 'nkFloatLit', 
+    'nkFloat32Lit', 'nkFloat64Lit', 'nkStrLit', 'nkRStrLit', 
+    'nkTripleStrLit', 'nkMetaNode', 'nkNilLit', 'nkDotCall', 
+    'nkCommand', 'nkCall', 'nkGenericCall', 'nkExplicitTypeListCall', 
+    'nkExprEqExpr', 'nkExprColonExpr', 'nkIdentDefs', 'nkVarTuple', 
+    'nkInfix', 'nkPrefix', 'nkPostfix', 'nkPar', 
+    'nkCurly', 'nkBracket', 'nkBracketExpr', 'nkPragmaExpr', 
+    'nkRange', 'nkDotExpr', 'nkCheckedFieldExpr', 'nkDerefExpr', 
+    'nkIfExpr', 'nkElifExpr', 'nkElseExpr', 'nkLambda', 
+    'nkAccQuoted', 'nkHeaderQuoted', 'nkTableConstr', 'nkQualified', 
+    'nkHiddenStdConv', 'nkHiddenSubConv', 'nkHiddenCallConv', 'nkConv', 
+    'nkCast', 'nkAddr', 'nkHiddenAddr', 'nkHiddenDeref', 
+    'nkObjDownConv', 'nkObjUpConv', 'nkChckRangeF', 'nkChckRange64', 
+    'nkChckRange', 'nkStringToCString', 'nkCStringToString', 'nkPassAsOpenArray', 
+    'nkAsgn', 'nkFastAsgn', 'nkDefaultTypeParam', 'nkGenericParams', 
+    'nkFormalParams', 'nkOfInherit', 'nkModule', 'nkProcDef', 
+    'nkConverterDef', 'nkMacroDef', 'nkTemplateDef', 'nkIteratorDef', 
+    'nkOfBranch', 'nkElifBranch', 'nkExceptBranch', 'nkElse', 
+    'nkMacroStmt', 'nkAsmStmt', 'nkPragma', 'nkIfStmt', 
+    'nkWhenStmt', 'nkForStmt', 'nkWhileStmt', 'nkCaseStmt', 
+    'nkVarSection', 'nkConstSection', 'nkConstDef', 'nkTypeSection', 
+    'nkTypeDef', 'nkYieldStmt', 'nkTryStmt', 'nkFinally', 
+    'nkRaiseStmt', 'nkReturnStmt', 'nkBreakStmt', 'nkContinueStmt', 
+    'nkBlockStmt', 'nkDiscardStmt', 'nkStmtList', 'nkImportStmt', 
+    'nkFromStmt', 'nkImportAs', 'nkIncludeStmt', 'nkAccessStmt', 
+    'nkCommentStmt', 'nkStmtListExpr', 'nkBlockExpr', 'nkStmtListType', 
+    'nkBlockType', 'nkVm', 'nkTypeOfExpr', 'nkObjectTy', 
+    'nkTupleTy', 'nkRecList', 'nkRecCase', 'nkRecWhen', 
+    'nkRefTy', 'nkPtrTy', 'nkVarTy', 'nkProcTy', 
+    'nkEnumTy', 'nkEnumFieldDef', 'nkReturnToken');
+type
+  TSymFlag = (
+    sfUsed, sfStar, sfMinus, sfInInterface, 
+    sfFromGeneric, sfGlobal, sfForward, sfImportc, 
+    sfExportc, sfVolatile, sfRegister, sfPure, 
+    sfResult, sfNoSideEffect, sfMainModule, sfSystemModule, 
+    sfNoReturn, sfAddrTaken, sfCompilerProc, sfCppMethod, 
+    sfDiscriminant, sfDeprecated, sfInClosure, sfTypeCheck, 
+    sfCompileTime, sfThreadVar, sfMerge, sfDeadCodeElim);
+  TSymFlags = set of TSymFlag;
+const
+  SymFlagToStr: array [TSymFlag] of string = (
+    'sfUsed', 'sfStar', 'sfMinus', 'sfInInterface', 
+    'sfFromGeneric', 'sfGlobal', 'sfForward', 'sfImportc', 
+    'sfExportc', 'sfVolatile', 'sfRegister', 'sfPure', 
+    'sfResult', 'sfNoSideEffect', 'sfMainModule', 'sfSystemModule', 
+    'sfNoReturn', 'sfAddrTaken', 'sfCompilerProc', 'sfCppMethod', 
+    'sfDiscriminant', 'sfDeprecated', 'sfInClosure', 'sfTypeCheck', 
+    'sfCompileTime', 'sfThreadVar', 'sfMerge', 'sfDeadCodeElim');
+type
+  TTypeKind = (
+    tyNone, tyBool, tyChar, tyEmpty, 
+    tyArrayConstr, tyNil, tyGeneric, tyGenericInst, 
+    tyGenericParam, tyEnum, tyAnyEnum, tyArray, 
+    tyObject, tyTuple, tySet, tyRange, 
+    tyPtr, tyRef, tyVar, tySequence, 
+    tyProc, tyPointer, tyOpenArray, tyString, 
+    tyCString, tyForward, tyInt, tyInt8, 
+    tyInt16, tyInt32, tyInt64, tyFloat, 
+    tyFloat32, tyFloat64, tyFloat128);
+  TTypeKinds = set of TTypeKind;
+const
+  TypeKindToStr: array [TTypeKind] of string = (
+    'tyNone', 'tyBool', 'tyChar', 'tyEmpty', 
+    'tyArrayConstr', 'tyNil', 'tyGeneric', 'tyGenericInst', 
+    'tyGenericParam', 'tyEnum', 'tyAnyEnum', 'tyArray', 
+    'tyObject', 'tyTuple', 'tySet', 'tyRange', 
+    'tyPtr', 'tyRef', 'tyVar', 'tySequence', 
+    'tyProc', 'tyPointer', 'tyOpenArray', 'tyString', 
+    'tyCString', 'tyForward', 'tyInt', 'tyInt8', 
+    'tyInt16', 'tyInt32', 'tyInt64', 'tyFloat', 
+    'tyFloat32', 'tyFloat64', 'tyFloat128');
+type
+  TNodeFlag = (
+    nfNone, nfBase2, nfBase8, nfBase16, 
+    nfAllConst, nfTransf, nfSem);
+  TNodeFlags = set of TNodeFlag;
+const
+  NodeFlagToStr: array [TNodeFlag] of string = (
+    'nfNone', 'nfBase2', 'nfBase8', 'nfBase16', 
+    'nfAllConst', 'nfTransf', 'nfSem');
+type
+  TTypeFlag = (
+    tfVarargs, tfFinal, tfAcyclic, tfEnumHasWholes);
+  TTypeFlags = set of TTypeFlag;
+const
+  TypeFlagToStr: array [TTypeFlag] of string = (
+    'tfVarargs', 'tfFinal', 'tfAcyclic', 'tfEnumHasWholes');
+type
+  TSymKind = (
+    skUnknownSym, skConditional, skDynLib, skParam, 
+    skTypeParam, skTemp, skType, skConst, 
+    skVar, skProc, skIterator, skConverter, 
+    skMacro, skTemplate, skField, skEnumField, 
+    skForVar, skModule, skLabel, skStub);
+  TSymKinds = set of TSymKind;
+const
+  SymKindToStr: array [TSymKind] of string = (
+    'skUnknownSym', 'skConditional', 'skDynLib', 'skParam', 
+    'skTypeParam', 'skTemp', 'skType', 'skConst', 
+    'skVar', 'skProc', 'skIterator', 'skConverter', 
+    'skMacro', 'skTemplate', 'skField', 'skEnumField', 
+    'skForVar', 'skModule', 'skLabel', 'skStub');
 {[[[end]]]}

 

 type

@@ -219,43 +219,44 @@ type
     //  if (i+1) % 6 == 0: cog.outl("")

     //cog.outl("m" + magics[-1])

     //]]]

-    mNone, mDefined, mLow, mHigh, mSizeOf, mIs, 

-    mSucc, mPred, mInc, mDec, mOrd, mNew, 

-    mNewFinalize, mNewSeq, mRegisterFinalizer, mLengthOpenArray, mLengthStr, mLengthArray, 

-    mLengthSeq, mIncl, mExcl, mCard, mChr, mGCref, 

-    mGCunref, mAddI, mSubI, mMulI, mDivI, mModI, 

-    mAddI64, mSubI64, mMulI64, mDivI64, mModI64, mShrI, 

-    mShlI, mBitandI, mBitorI, mBitxorI, mMinI, mMaxI, 

-    mShrI64, mShlI64, mBitandI64, mBitorI64, mBitxorI64, mMinI64, 

-    mMaxI64, mAddF64, mSubF64, mMulF64, mDivF64, mMinF64, 

-    mMaxF64, mAddU, mSubU, mMulU, mDivU, mModU, 

-    mAddU64, mSubU64, mMulU64, mDivU64, mModU64, mEqI, 

-    mLeI, mLtI, mEqI64, mLeI64, mLtI64, mEqF64, 

-    mLeF64, mLtF64, mLeU, mLtU, mLeU64, mLtU64, 

-    mEqEnum, mLeEnum, mLtEnum, mEqCh, mLeCh, mLtCh, 

-    mEqB, mLeB, mLtB, mEqRef, mEqProc, mEqUntracedRef, 

-    mLePtr, mLtPtr, mEqCString, mXor, mUnaryMinusI, mUnaryMinusI64, 

-    mAbsI, mAbsI64, mNot, mUnaryPlusI, mBitnotI, mUnaryPlusI64, 

-    mBitnotI64, mUnaryPlusF64, mUnaryMinusF64, mAbsF64, mZe8ToI, mZe8ToI64, 

-    mZe16ToI, mZe16ToI64, mZe32ToI64, mZeIToI64, mToU8, mToU16, 

-    mToU32, mToFloat, mToBiggestFloat, mToInt, mToBiggestInt, mCharToStr, 

-    mBoolToStr, mIntToStr, mInt64ToStr, mFloatToStr, mCStrToStr, mStrToStr, 

-    mAnd, mOr, mEqStr, mLeStr, mLtStr, mEqSet, 

-    mLeSet, mLtSet, mMulSet, mPlusSet, mMinusSet, mSymDiffSet, 

-    mConStrStr, mConArrArr, mConArrT, mConTArr, mConTT, mSlice, 

-    mAppendStrCh, mAppendStrStr, mAppendSeqElem, mAppendSeqSeq, mInRange, mInSet, 

-    mAsgn, mRepr, mExit, mSetLengthStr, mSetLengthSeq, mAssert, 

-    mSwap, mIsNil, mArrToSeq, mArray, mOpenArray, mRange, 

-    mSet, mSeq, mInt, mInt8, mInt16, mInt32, 

-    mInt64, mFloat, mFloat32, mFloat64, mBool, mChar, 

-    mString, mCstring, mPointer, mAnyEnum, mEmptySet, mIntSetBaseType, 

-    mNil, mIsMainModule, mCompileDate, mCompileTime, mNimrodVersion, mNimrodMajor, 

-    mNimrodMinor, mNimrodPatch, mCpuEndian, mNaN, mInf, mNegInf, 

-    mNLen, mNChild, mNSetChild, mNAdd, mNAddMultiple, mNDel, 

-    mNKind, mNIntVal, mNFloatVal, mNSymbol, mNIdent, mNGetType, 

-    mNStrVal, mNSetIntVal, mNSetFloatVal, mNSetSymbol, mNSetIdent, mNSetType, 

-    mNSetStrVal, mNNewNimNode, mNCopyNimNode, mNCopyNimTree, mStrToIdent, mIdentToStr, 

-    mEqIdent, mNHint, mNWarning, mNError

+    mNone, mDefined, mLow, mHigh, mSizeOf, mIs, 
+    mSucc, mPred, mInc, mDec, mOrd, mNew, 
+    mNewFinalize, mNewSeq, mRegisterFinalizer, mLengthOpenArray, mLengthStr, mLengthArray, 
+    mLengthSeq, mIncl, mExcl, mCard, mChr, mGCref, 
+    mGCunref, mAddI, mSubI, mMulI, mDivI, mModI, 
+    mAddI64, mSubI64, mMulI64, mDivI64, mModI64, mShrI, 
+    mShlI, mBitandI, mBitorI, mBitxorI, mMinI, mMaxI, 
+    mShrI64, mShlI64, mBitandI64, mBitorI64, mBitxorI64, mMinI64, 
+    mMaxI64, mAddF64, mSubF64, mMulF64, mDivF64, mMinF64, 
+    mMaxF64, mAddU, mSubU, mMulU, mDivU, mModU, 
+    mAddU64, mSubU64, mMulU64, mDivU64, mModU64, mEqI, 
+    mLeI, mLtI, mEqI64, mLeI64, mLtI64, mEqF64, 
+    mLeF64, mLtF64, mLeU, mLtU, mLeU64, mLtU64, 
+    mEqEnum, mLeEnum, mLtEnum, mEqCh, mLeCh, mLtCh, 
+    mEqB, mLeB, mLtB, mEqRef, mEqProc, mEqUntracedRef, 
+    mLePtr, mLtPtr, mEqCString, mXor, mUnaryMinusI, mUnaryMinusI64, 
+    mAbsI, mAbsI64, mNot, mUnaryPlusI, mBitnotI, mUnaryPlusI64, 
+    mBitnotI64, mUnaryPlusF64, mUnaryMinusF64, mAbsF64, mZe8ToI, mZe8ToI64, 
+    mZe16ToI, mZe16ToI64, mZe32ToI64, mZeIToI64, mToU8, mToU16, 
+    mToU32, mToFloat, mToBiggestFloat, mToInt, mToBiggestInt, mCharToStr, 
+    mBoolToStr, mIntToStr, mInt64ToStr, mFloatToStr, mCStrToStr, mStrToStr, 
+    mEnumToStr, mAnd, mOr, mEqStr, mLeStr, mLtStr, 
+    mEqSet, mLeSet, mLtSet, mMulSet, mPlusSet, mMinusSet, 
+    mSymDiffSet, mConStrStr, mConArrArr, mConArrT, mConTArr, mConTT, 
+    mSlice, mAppendStrCh, mAppendStrStr, mAppendSeqElem, mAppendSeqSeq, mInRange, 
+    mInSet, mAsgn, mRepr, mExit, mSetLengthStr, mSetLengthSeq, 
+    mAssert, mSwap, mIsNil, mArrToSeq, mArray, mOpenArray, 
+    mRange, mSet, mSeq, mInt, mInt8, mInt16, 
+    mInt32, mInt64, mFloat, mFloat32, mFloat64, mBool, 
+    mChar, mString, mCstring, mPointer, mAnyEnum, mEmptySet, 
+    mIntSetBaseType, mNil, mIsMainModule, mCompileDate, mCompileTime, mNimrodVersion, 
+    mNimrodMajor, mNimrodMinor, mNimrodPatch, mCpuEndian, mHostOS, mHostCPU, 
+    mNaN, mInf, mNegInf, mNLen, mNChild, mNSetChild, 
+    mNAdd, mNAddMultiple, mNDel, mNKind, mNIntVal, mNFloatVal, 
+    mNSymbol, mNIdent, mNGetType, mNStrVal, mNSetIntVal, mNSetFloatVal, 
+    mNSetSymbol, mNSetIdent, mNSetType, mNSetStrVal, mNNewNimNode, mNCopyNimNode, 
+    mNCopyNimTree, mStrToIdent, mIdentToStr, mEqIdent, mNHint, mNWarning, 
+    mNError
     //[[[end]]]

   );

 

@@ -322,7 +323,6 @@ type
     locProc,       // location is a proc (an address of a procedure)

     locData,       // location is a constant

     locCall,       // location is a call expression

-    locImmediate,  // location is an immediate value

     locOther       // location is something other

   );

 

@@ -477,43 +477,44 @@ const // "MagicToStr" array:
     //  if (i+1) % 6 == 0: cog.outl("")

     //cog.outl("'%s'" % magics[-1])

     //]]]

-    'None', 'Defined', 'Low', 'High', 'SizeOf', 'Is', 

-    'Succ', 'Pred', 'Inc', 'Dec', 'Ord', 'New', 

-    'NewFinalize', 'NewSeq', 'RegisterFinalizer', 'LengthOpenArray', 'LengthStr', 'LengthArray', 

-    'LengthSeq', 'Incl', 'Excl', 'Card', 'Chr', 'GCref', 

-    'GCunref', 'AddI', 'SubI', 'MulI', 'DivI', 'ModI', 

-    'AddI64', 'SubI64', 'MulI64', 'DivI64', 'ModI64', 'ShrI', 

-    'ShlI', 'BitandI', 'BitorI', 'BitxorI', 'MinI', 'MaxI', 

-    'ShrI64', 'ShlI64', 'BitandI64', 'BitorI64', 'BitxorI64', 'MinI64', 

-    'MaxI64', 'AddF64', 'SubF64', 'MulF64', 'DivF64', 'MinF64', 

-    'MaxF64', 'AddU', 'SubU', 'MulU', 'DivU', 'ModU', 

-    'AddU64', 'SubU64', 'MulU64', 'DivU64', 'ModU64', 'EqI', 

-    'LeI', 'LtI', 'EqI64', 'LeI64', 'LtI64', 'EqF64', 

-    'LeF64', 'LtF64', 'LeU', 'LtU', 'LeU64', 'LtU64', 

-    'EqEnum', 'LeEnum', 'LtEnum', 'EqCh', 'LeCh', 'LtCh', 

-    'EqB', 'LeB', 'LtB', 'EqRef', 'EqProc', 'EqUntracedRef', 

-    'LePtr', 'LtPtr', 'EqCString', 'Xor', 'UnaryMinusI', 'UnaryMinusI64', 

-    'AbsI', 'AbsI64', 'Not', 'UnaryPlusI', 'BitnotI', 'UnaryPlusI64', 

-    'BitnotI64', 'UnaryPlusF64', 'UnaryMinusF64', 'AbsF64', 'Ze8ToI', 'Ze8ToI64', 

-    'Ze16ToI', 'Ze16ToI64', 'Ze32ToI64', 'ZeIToI64', 'ToU8', 'ToU16', 

-    'ToU32', 'ToFloat', 'ToBiggestFloat', 'ToInt', 'ToBiggestInt', 'CharToStr', 

-    'BoolToStr', 'IntToStr', 'Int64ToStr', 'FloatToStr', 'CStrToStr', 'StrToStr', 

-    'And', 'Or', 'EqStr', 'LeStr', 'LtStr', 'EqSet', 

-    'LeSet', 'LtSet', 'MulSet', 'PlusSet', 'MinusSet', 'SymDiffSet', 

-    'ConStrStr', 'ConArrArr', 'ConArrT', 'ConTArr', 'ConTT', 'Slice', 

-    'AppendStrCh', 'AppendStrStr', 'AppendSeqElem', 'AppendSeqSeq', 'InRange', 'InSet', 

-    'Asgn', 'Repr', 'Exit', 'SetLengthStr', 'SetLengthSeq', 'Assert', 

-    'Swap', 'IsNil', 'ArrToSeq', 'Array', 'OpenArray', 'Range', 

-    'Set', 'Seq', 'Int', 'Int8', 'Int16', 'Int32', 

-    'Int64', 'Float', 'Float32', 'Float64', 'Bool', 'Char', 

-    'String', 'Cstring', 'Pointer', 'AnyEnum', 'EmptySet', 'IntSetBaseType', 

-    'Nil', 'IsMainModule', 'CompileDate', 'CompileTime', 'NimrodVersion', 'NimrodMajor', 

-    'NimrodMinor', 'NimrodPatch', 'CpuEndian', 'NaN', 'Inf', 'NegInf', 

-    'NLen', 'NChild', 'NSetChild', 'NAdd', 'NAddMultiple', 'NDel', 

-    'NKind', 'NIntVal', 'NFloatVal', 'NSymbol', 'NIdent', 'NGetType', 

-    'NStrVal', 'NSetIntVal', 'NSetFloatVal', 'NSetSymbol', 'NSetIdent', 'NSetType', 

-    'NSetStrVal', 'NNewNimNode', 'NCopyNimNode', 'NCopyNimTree', 'StrToIdent', 'IdentToStr', 

-    'EqIdent', 'NHint', 'NWarning', 'NError'

+    'None', 'Defined', 'Low', 'High', 'SizeOf', 'Is', 
+    'Succ', 'Pred', 'Inc', 'Dec', 'Ord', 'New', 
+    'NewFinalize', 'NewSeq', 'RegisterFinalizer', 'LengthOpenArray', 'LengthStr', 'LengthArray', 
+    'LengthSeq', 'Incl', 'Excl', 'Card', 'Chr', 'GCref', 
+    'GCunref', 'AddI', 'SubI', 'MulI', 'DivI', 'ModI', 
+    'AddI64', 'SubI64', 'MulI64', 'DivI64', 'ModI64', 'ShrI', 
+    'ShlI', 'BitandI', 'BitorI', 'BitxorI', 'MinI', 'MaxI', 
+    'ShrI64', 'ShlI64', 'BitandI64', 'BitorI64', 'BitxorI64', 'MinI64', 
+    'MaxI64', 'AddF64', 'SubF64', 'MulF64', 'DivF64', 'MinF64', 
+    'MaxF64', 'AddU', 'SubU', 'MulU', 'DivU', 'ModU', 
+    'AddU64', 'SubU64', 'MulU64', 'DivU64', 'ModU64', 'EqI', 
+    'LeI', 'LtI', 'EqI64', 'LeI64', 'LtI64', 'EqF64', 
+    'LeF64', 'LtF64', 'LeU', 'LtU', 'LeU64', 'LtU64', 
+    'EqEnum', 'LeEnum', 'LtEnum', 'EqCh', 'LeCh', 'LtCh', 
+    'EqB', 'LeB', 'LtB', 'EqRef', 'EqProc', 'EqUntracedRef', 
+    'LePtr', 'LtPtr', 'EqCString', 'Xor', 'UnaryMinusI', 'UnaryMinusI64', 
+    'AbsI', 'AbsI64', 'Not', 'UnaryPlusI', 'BitnotI', 'UnaryPlusI64', 
+    'BitnotI64', 'UnaryPlusF64', 'UnaryMinusF64', 'AbsF64', 'Ze8ToI', 'Ze8ToI64', 
+    'Ze16ToI', 'Ze16ToI64', 'Ze32ToI64', 'ZeIToI64', 'ToU8', 'ToU16', 
+    'ToU32', 'ToFloat', 'ToBiggestFloat', 'ToInt', 'ToBiggestInt', 'CharToStr', 
+    'BoolToStr', 'IntToStr', 'Int64ToStr', 'FloatToStr', 'CStrToStr', 'StrToStr', 
+    'EnumToStr', 'And', 'Or', 'EqStr', 'LeStr', 'LtStr', 
+    'EqSet', 'LeSet', 'LtSet', 'MulSet', 'PlusSet', 'MinusSet', 
+    'SymDiffSet', 'ConStrStr', 'ConArrArr', 'ConArrT', 'ConTArr', 'ConTT', 
+    'Slice', 'AppendStrCh', 'AppendStrStr', 'AppendSeqElem', 'AppendSeqSeq', 'InRange', 
+    'InSet', 'Asgn', 'Repr', 'Exit', 'SetLengthStr', 'SetLengthSeq', 
+    'Assert', 'Swap', 'IsNil', 'ArrToSeq', 'Array', 'OpenArray', 
+    'Range', 'Set', 'Seq', 'Int', 'Int8', 'Int16', 
+    'Int32', 'Int64', 'Float', 'Float32', 'Float64', 'Bool', 
+    'Char', 'String', 'Cstring', 'Pointer', 'AnyEnum', 'EmptySet', 
+    'IntSetBaseType', 'Nil', 'IsMainModule', 'CompileDate', 'CompileTime', 'NimrodVersion', 
+    'NimrodMajor', 'NimrodMinor', 'NimrodPatch', 'CpuEndian', 'HostOS', 'HostCPU', 
+    'NaN', 'Inf', 'NegInf', 'NLen', 'NChild', 'NSetChild', 
+    'NAdd', 'NAddMultiple', 'NDel', 'NKind', 'NIntVal', 'NFloatVal', 
+    'NSymbol', 'NIdent', 'NGetType', 'NStrVal', 'NSetIntVal', 'NSetFloatVal', 
+    'NSetSymbol', 'NSetIdent', 'NSetType', 'NSetStrVal', 'NNewNimNode', 'NCopyNimNode', 
+    'NCopyNimTree', 'StrToIdent', 'IdentToStr', 'EqIdent', 'NHint', 'NWarning', 
+    'NError'
     //[[[end]]]

   );

 

@@ -1342,13 +1343,13 @@ end;
 

 function IntSetContains(const s: TIntSet; key: int): bool;

 var

-  u: int;

+  u: TBitScalar;

   t: PTrunk;

 begin

-  t := IntSetGet(s, key shr TrunkShift);

+  t := IntSetGet(s, shru(key, TrunkShift));

   if t <> nil then begin

     u := key and TrunkMask;

-    result := (t.bits[u shr IntShift] and (1 shl (u and IntMask))) <> 0

+    result := (t.bits[shru(u, IntShift)] and shlu(1, u and IntMask)) <> 0

   end

   else

     result := false

@@ -1356,27 +1357,27 @@ end;
 

 procedure IntSetIncl(var s: TIntSet; key: int);

 var

-  u: int;

+  u: TBitScalar;

   t: PTrunk;

 begin

-  t := IntSetPut(s, key shr TrunkShift);

+  t := IntSetPut(s, shru(key, TrunkShift));

   u := key and TrunkMask;

-  t.bits[u shr IntShift] := t.bits[u shr IntShift]

-                            or (1 shl (u and IntMask));

+  t.bits[shru(u, IntShift)] := t.bits[shru(u, IntShift)]

+                            or shlu(1, u and IntMask);

 end;

 

 function IntSetContainsOrIncl(var s: TIntSet; key: int): bool;

 var

-  u: int;

+  u: TBitScalar;

   t: PTrunk;

 begin

-  t := IntSetGet(s, key shr TrunkShift);

+  t := IntSetGet(s, shru(key, TrunkShift));

   if t <> nil then begin

     u := key and TrunkMask;

-    result := (t.bits[u shr IntShift] and (1 shl (u and IntMask))) <> 0;

+    result := (t.bits[shru(u, IntShift)] and shlu(1, u and IntMask)) <> 0;

     if not result then

-      t.bits[u shr IntShift] := t.bits[u shr IntShift]

-                                or (1 shl (u and IntMask));

+      t.bits[shru(u, IntShift)] := t.bits[shru(u, IntShift)]

+                                or shlu(1, u and IntMask);

   end

   else begin

     IntSetIncl(s, key);