diff --git a/lib/gc.nim b/lib/gc.nim
index 344aa33f3..a103bfc22 100644
--- a/lib/gc.nim
+++ b/lib/gc.nim
@@ -750,7 +750,7 @@ proc collectCycles(gch: var TGcHeap) =
   CellSetDeinit(gch.cycleRoots)
   gch.cycleRoots = newRoots
 
-proc gcMark(p: pointer) {.fastcall.} =
+proc gcMark(p: pointer) = # {.fastcall.} =
   # the addresses are not as objects on the stack, so turn them to objects:
   var cell = usrToCell(p)
   var c = cast[TAddress](cell)
diff --git a/lib/macros.nim b/lib/macros.nim
index b307c00cb..809531c4c 100644
--- a/lib/macros.nim
+++ b/lib/macros.nim
@@ -30,59 +30,59 @@
 #  if key[-4:] == "Flag": continue

 #  cog.out(toEnum(key, val))

 #]]]

-type
-  TNimrodNodeKind* = enum
-    nnkNone, nnkEmpty, nnkIdent, nnkSym, 
-    nnkType, nnkCharLit, nnkIntLit, nnkInt8Lit, 
-    nnkInt16Lit, nnkInt32Lit, nnkInt64Lit, nnkFloatLit, 
-    nnkFloat32Lit, nnkFloat64Lit, nnkStrLit, nnkRStrLit, 
-    nnkTripleStrLit, nnkMetaNode, nnkNilLit, nnkDotCall, 
-    nnkCommand, nnkCall, nnkGenericCall, nnkExplicitTypeListCall, 
-    nnkExprEqExpr, nnkExprColonExpr, nnkIdentDefs, nnkInfix, 
-    nnkPrefix, nnkPostfix, nnkPar, nnkCurly, 
-    nnkBracket, nnkBracketExpr, nnkPragmaExpr, nnkRange, 
-    nnkDotExpr, nnkCheckedFieldExpr, nnkDerefExpr, nnkIfExpr, 
-    nnkElifExpr, nnkElseExpr, nnkLambda, nnkAccQuoted, 
-    nnkHeaderQuoted, nnkTableConstr, nnkQualified, nnkHiddenStdConv, 
-    nnkHiddenSubConv, nnkHiddenCallConv, nnkConv, nnkCast, 
-    nnkAddr, nnkHiddenAddr, nnkHiddenDeref, nnkObjDownConv, 
-    nnkObjUpConv, nnkChckRangeF, nnkChckRange64, nnkChckRange, 
-    nnkStringToCString, nnkCStringToString, nnkPassAsOpenArray, nnkAsgn, 
-    nnkDefaultTypeParam, nnkGenericParams, nnkFormalParams, nnkOfInherit, 
-    nnkModule, nnkProcDef, nnkConverterDef, nnkMacroDef, 
-    nnkTemplateDef, nnkIteratorDef, nnkOfBranch, nnkElifBranch, 
-    nnkExceptBranch, nnkElse, nnkMacroStmt, nnkAsmStmt, 
-    nnkPragma, nnkIfStmt, nnkWhenStmt, nnkForStmt, 
-    nnkWhileStmt, nnkCaseStmt, nnkVarSection, nnkConstSection, 
-    nnkConstDef, nnkTypeSection, nnkTypeDef, nnkYieldStmt, 
-    nnkTryStmt, nnkFinally, nnkRaiseStmt, nnkReturnStmt, 
-    nnkBreakStmt, nnkContinueStmt, nnkBlockStmt, nnkDiscardStmt, 
-    nnkStmtList, nnkImportStmt, nnkFromStmt, nnkImportAs, 
-    nnkIncludeStmt, nnkAccessStmt, nnkCommentStmt, nnkStmtListExpr, 
-    nnkBlockExpr, nnkStmtListType, nnkBlockType, nnkVm, 
-    nnkTypeOfExpr, nnkObjectTy, nnkTupleTy, nnkRecList, 
-    nnkRecCase, nnkRecWhen, nnkRefTy, nnkPtrTy, 
-    nnkVarTy, nnkProcTy, nnkEnumTy, nnkEnumFieldDef, 
-    nnkReturnToken
-  TNimNodeKinds* = set[TNimrodNodeKind]
-  TNimrodTypeKind* = enum
-    ntyNone, ntyBool, ntyChar, ntyEmpty, 
-    ntyArrayConstr, ntyNil, ntyGeneric, ntyGenericInst, 
-    ntyGenericParam, ntyEnum, ntyAnyEnum, ntyArray, 
-    ntyObject, ntyTuple, ntySet, ntyRange, 
-    ntyPtr, ntyRef, ntyVar, ntySequence, 
-    ntyProc, ntyPointer, ntyOpenArray, ntyString, 
-    ntyCString, ntyForward, ntyInt, ntyInt8, 
-    ntyInt16, ntyInt32, ntyInt64, ntyFloat, 
-    ntyFloat32, ntyFloat64, ntyFloat128
-  TNimTypeKinds* = set[TNimrodTypeKind]
-  TNimrodSymKind* = enum
-    nskUnknownSym, nskConditional, nskDynLib, nskParam, 
-    nskTypeParam, nskTemp, nskType, nskConst, 
-    nskVar, nskProc, nskIterator, nskConverter, 
-    nskMacro, nskTemplate, nskField, nskEnumField, 
-    nskForVar, nskModule, nskLabel, nskStub
-  TNimSymKinds* = set[TNimrodSymKind]
+type

+  TNimrodTypeKind* = enum

+    ntyNone, ntyBool, ntyChar, ntyEmpty, 

+    ntyArrayConstr, ntyNil, ntyGeneric, ntyGenericInst, 

+    ntyGenericParam, ntyEnum, ntyAnyEnum, ntyArray, 

+    ntyObject, ntyTuple, ntySet, ntyRange, 

+    ntyPtr, ntyRef, ntyVar, ntySequence, 

+    ntyProc, ntyPointer, ntyOpenArray, ntyString, 

+    ntyCString, ntyForward, ntyInt, ntyInt8, 

+    ntyInt16, ntyInt32, ntyInt64, ntyFloat, 

+    ntyFloat32, ntyFloat64, ntyFloat128

+  TNimTypeKinds* = set[TNimrodTypeKind]

+  TNimrodSymKind* = enum

+    nskUnknownSym, nskConditional, nskDynLib, nskParam, 

+    nskTypeParam, nskTemp, nskType, nskConst, 

+    nskVar, nskProc, nskIterator, nskConverter, 

+    nskMacro, nskTemplate, nskField, nskEnumField, 

+    nskForVar, nskModule, nskLabel, nskStub

+  TNimSymKinds* = set[TNimrodSymKind]

+  TNimrodNodeKind* = enum

+    nnkNone, nnkEmpty, nnkIdent, nnkSym, 

+    nnkType, nnkCharLit, nnkIntLit, nnkInt8Lit, 

+    nnkInt16Lit, nnkInt32Lit, nnkInt64Lit, nnkFloatLit, 

+    nnkFloat32Lit, nnkFloat64Lit, nnkStrLit, nnkRStrLit, 

+    nnkTripleStrLit, nnkMetaNode, nnkNilLit, nnkDotCall, 

+    nnkCommand, nnkCall, nnkGenericCall, nnkExplicitTypeListCall, 

+    nnkExprEqExpr, nnkExprColonExpr, nnkIdentDefs, nnkInfix, 

+    nnkPrefix, nnkPostfix, nnkPar, nnkCurly, 

+    nnkBracket, nnkBracketExpr, nnkPragmaExpr, nnkRange, 

+    nnkDotExpr, nnkCheckedFieldExpr, nnkDerefExpr, nnkIfExpr, 

+    nnkElifExpr, nnkElseExpr, nnkLambda, nnkAccQuoted, 

+    nnkHeaderQuoted, nnkTableConstr, nnkQualified, nnkHiddenStdConv, 

+    nnkHiddenSubConv, nnkHiddenCallConv, nnkConv, nnkCast, 

+    nnkAddr, nnkHiddenAddr, nnkHiddenDeref, nnkObjDownConv, 

+    nnkObjUpConv, nnkChckRangeF, nnkChckRange64, nnkChckRange, 

+    nnkStringToCString, nnkCStringToString, nnkPassAsOpenArray, nnkAsgn, 

+    nnkDefaultTypeParam, nnkGenericParams, nnkFormalParams, nnkOfInherit, 

+    nnkModule, nnkProcDef, nnkConverterDef, nnkMacroDef, 

+    nnkTemplateDef, nnkIteratorDef, nnkOfBranch, nnkElifBranch, 

+    nnkExceptBranch, nnkElse, nnkMacroStmt, nnkAsmStmt, 

+    nnkPragma, nnkIfStmt, nnkWhenStmt, nnkForStmt, 

+    nnkWhileStmt, nnkCaseStmt, nnkVarSection, nnkConstSection, 

+    nnkConstDef, nnkTypeSection, nnkTypeDef, nnkYieldStmt, 

+    nnkTryStmt, nnkFinally, nnkRaiseStmt, nnkReturnStmt, 

+    nnkBreakStmt, nnkContinueStmt, nnkBlockStmt, nnkDiscardStmt, 

+    nnkStmtList, nnkImportStmt, nnkFromStmt, nnkImportAs, 

+    nnkIncludeStmt, nnkAccessStmt, nnkCommentStmt, nnkStmtListExpr, 

+    nnkBlockExpr, nnkStmtListType, nnkBlockType, nnkVm, 

+    nnkTypeOfExpr, nnkObjectTy, nnkTupleTy, nnkRecList, 

+    nnkRecCase, nnkRecWhen, nnkRefTy, nnkPtrTy, 

+    nnkVarTy, nnkProcTy, nnkEnumTy, nnkEnumFieldDef, 

+    nnkReturnToken

+  TNimNodeKinds* = set[TNimrodNodeKind]

 #[[[end]]]

 

 type

diff --git a/nim/ast.pas b/nim/ast.pas
index 899554c4e..be967a568 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
-  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
-  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
-  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');
+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');

 {[[[end]]]}

 

 type

@@ -219,43 +219,43 @@ 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, 

+    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

     //[[[end]]]

   );

 

@@ -321,7 +321,7 @@ type
     locExpr,       // "location" is really an expression

     locProc,       // location is a proc (an address of a procedure)

     locData,       // location is a constant

-    locCall,       // location is a call expression
+    locCall,       // location is a call expression

     locImmediate,  // location is an immediate value

     locOther       // location is something other

   );

@@ -477,43 +477,43 @@ 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', 

+    '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'

     //[[[end]]]

   );

 

diff --git a/rod/nimrod.cfg b/rod/nimrod.cfg
index 51a9dc52d..2d742e431 100644
--- a/rod/nimrod.cfg
+++ b/rod/nimrod.cfg
@@ -5,7 +5,11 @@
 @if llvm_gcc or gcc:
   # GCC, LLVM and Visual C++ have a problem to optimize some modules.
   # This is really strange.
-  cgen.speed = "-O1 -fno-strict-aliasing"
+  @if windows:
+    cgen.speed = "-O0"
+  @else:
+    cgen.speed = "-O1 -fno-strict-aliasing"
+  @end
 @elif vcc:
   cgen.speed = ""
 @end