big repo cleanup

compiler/c2nim/c2nim.cfg

@@ -1,4 +1,4 @@
 # Use the modules of the compiler
 
-path: "$nimrod/rod"
+path: "$nimrod/compiler"
 

compiler/nimrod.ini

@@ -46,18 +46,12 @@ Files: "icons/koch.ico"
 Files: "icons/koch.rc"
 Files: "icons/koch.res"
 
-Files: "rod/readme.txt"
-Files: "rod/nimrod.ini"
-Files: "rod/nimrod.cfg"
-Files: "rod/*.nim"
+Files: "compiler/readme.txt"
+Files: "compiler/nimrod.ini"
+Files: "compiler/nimrod.cfg"
+Files: "compiler/*.nim"
 Files: "build/empty.txt"
 Files: "bin/empty.txt"
-Files: "nim/*.*"
-
-Files: "data/*.yml"
-Files: "data/*.txt"
-Files: "obj/*.txt"
-Files: "diff/*.txt"
 
 [Lib]
 Files: "lib/nimbase.h;lib/cycle.h"
@@ -116,11 +110,11 @@ Files: "examples/*.tmpl"
 Files: "bin/nimrod.exe"
 Files: "bin/c2nim.exe"
 Files: "bin/niminst.exe"
-Files: "deps/*.dll"
+Files: "dist/*.dll"
 Files: "koch.exe"
 Files: "dist/mingw"
 Files: "start.bat"
-BinPath: r"bin;dist\mingw\bin;deps"
+BinPath: r"bin;dist\mingw\bin;dist"
 InnoSetup: "Yes"
 
 [UnixBin]

compiler/pas2nim/pas2nim.cfg

@@ -1,4 +1,4 @@
 # Use the modules of the compiler
 
-path: "$nimrod/rod"
+path: "$nimrod/compiler"
 

data/ast.yml

@@ -1,274 +0,0 @@
-#
-#
-#           The Nimrod Compiler
-#        (c) Copyright 2009 Andreas Rumpf
-#
-#    See the file "copying.txt", included in this
-#    distribution, for details about the copyright.
-#
-
-{
-'SymFlag': [          # already 30 flags!
-  'sfUsed',           # read access of sym (for warnings) or simply used
-  'sfStar',           # symbol has * visibility
-  'sfMinus',          # symbol has - visibility
-  'sfInInterface',    # symbol is in interface section declared
-  'sfFromGeneric',    # symbol is instantiation of a generic; this is needed 
-                      # for symbol file generation; such symbols should always
-                      # be written into the ROD file
-  'sfGlobal',         # symbol is at global scope
-
-  'sfForward',        # symbol is forward directed
-  'sfImportc',        # symbol is external; imported
-  'sfExportc',        # symbol is exported (under a specified name)
-  'sfVolatile',       # variable is volatile
-  'sfRegister',       # variable should be placed in a register
-  'sfPure',           # object is "pure" that means it has no type-information
-  
-  'sfResult',         # variable is 'result' in proc
-  'sfNoSideEffect',   # proc has no side effects
-  'sfSideEffect',     # proc may have side effects; cannot prove it has none
-  'sfMainModule',     # module is the main module
-  'sfSystemModule',   # module is the system module
-  'sfNoReturn',       # proc never returns (an exit proc)
-  'sfAddrTaken',      # the variable's address is taken (ex- or implicitely)
-  'sfCompilerProc',   # proc is a compiler proc, that is a C proc that is
-                      # needed for the code generator
-  'sfProcvar',        # proc can be passed to a proc var
-  'sfDiscriminant',   # field is a discriminant in a record/object
-  'sfDeprecated',     # symbol is deprecated
-  'sfInClosure',      # variable is accessed by a closure
-  'sfTypeCheck',      # wether macro parameters should be type checked
-  'sfCompileTime',    # proc can be evaluated at compile time
-  'sfThreadVar',      # variable is a thread variable
-  'sfMerge',          # proc can be merged with itself
-  'sfDeadCodeElim',   # dead code elimination for the module is turned on
-  'sfBorrow'          # proc is borrowed
-],
-
-'TypeFlag': [
-  'tfVarargs',        # procedure has C styled varargs
-  'tfNoSideEffect',   # procedure type does not allow side effects
-  'tfFinal',          # is the object final?
-  'tfAcyclic',        # type is acyclic (for GC optimization)
-  'tfEnumHasWholes'   # enum cannot be mapped into a range
-],
-
-'TypeKind': [        # order is important!
-                     # Don't forget to change hti.nim if you make a change here
-  'tyNone', 'tyBool', 'tyChar',
-  'tyEmpty', 'tyArrayConstr', 'tyNil', 'tyExpr', 'tyStmt', 'tyTypeDesc',
-  'tyGenericInvokation', # ``T[a, b]`` for types to invoke
-  'tyGenericBody',       # ``T[a, b, body]`` last parameter is the body
-  'tyGenericInst',       # ``T[a, b, realInstance]`` instantiated generic type
-  'tyGenericParam',      # ``a`` in the example
-  'tyDistinct',
-  'tyEnum',
-  'tyOrdinal',
-  'tyArray',
-  'tyObject',
-  'tyTuple',
-  'tySet',
-  'tyRange',
-  'tyPtr', 'tyRef',
-  'tyVar',
-  'tySequence',
-  'tyProc',
-  'tyPointer', 'tyOpenArray',
-  'tyString', 'tyCString', 'tyForward',
-  # numerical types:
-  'tyInt', 'tyInt8', 'tyInt16', 'tyInt32', 'tyInt64', # signed integers
-  'tyFloat', 'tyFloat32', 'tyFloat64', 'tyFloat128'
-],
-
-'NodeFlag': [ # keep this number under 16 for performance reasons!
-  'nfNone',
-  'nfBase2', # nfBase10 is default, so not needed
-  'nfBase8',
-  'nfBase16',
-  'nfAllConst', # used to mark complex expressions constant
-  'nfTransf',   # node has been transformed
-  'nfSem',      # node has been checked for semantics
-],
-
-'NodeKind': [  # these are pure nodes
-  # order is extremely important, because ranges are used to check whether
-  # a node belongs to a certain class
-  'nkNone',               # unknown node kind: indicates an error
-
-  # Expressions:
-  # Atoms:
-  'nkEmpty',              # the node is empty
-  'nkIdent',              # node is an identifier
-  'nkSym',                # node is a symbol
-  'nkType',               # node is used for its typ field
-
-  'nkCharLit',            # a character literal ''
-
-  'nkIntLit',             # an integer literal
-  'nkInt8Lit',
-  'nkInt16Lit',
-  'nkInt32Lit',
-  'nkInt64Lit',
-  'nkFloatLit',           # a floating point literal
-  'nkFloat32Lit',
-  'nkFloat64Lit',
-  'nkStrLit',             # a string literal ""
-  'nkRStrLit',            # a raw string literal r""
-  'nkTripleStrLit',       # a triple string literal """
-  'nkMetaNode',           # difficult to explan; represents itself
-                          # (used for macros)
-  'nkNilLit',             # the nil literal
-  # end of atoms
-  'nkDotCall',            # used to temporarily flag a nkCall node; this is used
-                          # for transforming ``s.len`` to ``len(s)``
-  'nkCommand',            # a call like ``p 2, 4`` without parenthesis
-  'nkCall',               # a call like p(x, y) or an operation like +(a, b)
-  'nkCallStrLit',         # a call with a string literal 
-                          # x"abc" has two sons: nkIdent, nkRStrLit
-                          # x"""abc""" has two sons: nkIdent, nkTripleStrLit
-  'nkExprEqExpr',         # a named parameter with equals: ''expr = expr''
-  'nkExprColonExpr',      # a named parameter with colon: ''expr: expr''
-  'nkIdentDefs',          # a definition like `a, b: typeDesc = expr`
-                          # either typeDesc or expr may be nil; used in
-                          # formal parameters, var statements, etc.
-  'nkVarTuple',           # a ``var (a, b) = expr`` construct
-  'nkInfix',              # a call like (a + b)
-  'nkPrefix',             # a call like !a
-  'nkPostfix',            # something like a! (also used for visibility)
-  'nkPar',                # syntactic (); may be a tuple constructor
-  'nkCurly',              # syntactic {}
-  'nkBracket',            # syntactic []
-  'nkBracketExpr',        # an expression like a[i..j, k]
-  'nkPragmaExpr',         # an expression like a{.pragmas.}
-  'nkRange',              # an expression like i..j
-  'nkDotExpr',            # a.b
-  'nkCheckedFieldExpr',   # a.b, but b is a field that needs to be checked
-  'nkDerefExpr',          # a^
-  'nkIfExpr',             # if as an expression
-  'nkElifExpr',
-  'nkElseExpr',
-  'nkLambda',             # lambda expression
-  'nkAccQuoted',          # `a` as a node
-
-  'nkTableConstr',        # a table constructor {expr: expr}
-  'nkBind',               # ``bind expr`` node
-  'nkSymChoice',          # symbol choice node
-  'nkHiddenStdConv',      # an implicit standard type conversion
-  'nkHiddenSubConv',      # an implicit type conversion from a subtype
-                          # to a supertype
-  'nkHiddenCallConv',     # an implicit type conversion via a type converter
-  'nkConv',               # a type conversion
-  'nkCast',               # a type cast
-  'nkAddr',               # a addr expression
-  'nkHiddenAddr',         # implicit address operator
-  'nkHiddenDeref',        # implicit ^ operator
-  'nkObjDownConv',        # down conversion between object types
-  'nkObjUpConv',          # up conversion between object types
-  'nkChckRangeF',         # range check for floats
-  'nkChckRange64',        # range check for 64 bit ints
-  'nkChckRange',          # range check for ints
-  'nkStringToCString',    # string to cstring
-  'nkCStringToString',    # cstring to string
-  'nkPassAsOpenArray',    # thing is passed as an open array
-  # end of expressions
-
-  'nkAsgn',               # a = b
-  'nkFastAsgn',           # internal node for a fast ``a = b`` (no string copy) 
-  'nkGenericParams',      # generic parameters
-  'nkFormalParams',       # formal parameters
-  'nkOfInherit',          # inherited from symbol
-
-  'nkModule',             # the syntax tree of a module
-  'nkProcDef',            # a proc
-  'nkMethodDef',          # a method
-  'nkConverterDef',       # a converter
-  'nkMacroDef',           # a macro
-  'nkTemplateDef',        # a template
-  'nkIteratorDef',        # an iterator
-
-  'nkOfBranch',           # used inside case statements for (cond, action)-pairs
-  'nkElifBranch',         # used in if statements
-  'nkExceptBranch',       # an except section
-  'nkElse',               # an else part
-  'nkMacroStmt',          # a macro statement
-  'nkAsmStmt',            # an assembler block
-  'nkPragma',             # a pragma statement
-  'nkIfStmt',             # an if statement
-  'nkWhenStmt',           # a when statement
-  'nkForStmt',            # a for statement
-  'nkWhileStmt',          # a while statement
-  'nkCaseStmt',           # a case statement
-  'nkVarSection',         # a var section
-  'nkConstSection',       # a const section
-  'nkConstDef',           # a const definition
-  'nkTypeSection',        # a type section (consists of type definitions)
-  'nkTypeDef',            # a type definition
-  'nkYieldStmt',          # the yield statement as a tree
-  'nkTryStmt',            # a try statement
-  'nkFinally',            # a finally section
-  'nkRaiseStmt',          # a raise statement
-  'nkReturnStmt',         # a return statement
-  'nkBreakStmt',          # a break statement
-  'nkContinueStmt',       # a continue statement
-  'nkBlockStmt',          # a block statement
-  'nkDiscardStmt',        # a discard statement
-  'nkStmtList',           # a list of statements
-  'nkImportStmt',         # an import statement
-  'nkFromStmt',           # a from * import statement
-  'nkIncludeStmt',        # an include statement
-  'nkCommentStmt',        # a comment statement
-  'nkStmtListExpr',       # a statement list followed by an expr; this is used
-                          # to allow powerful multi-line templates
-  'nkBlockExpr',          # a statement block ending in an expr; this is used
-                          # to allowe powerful multi-line templates that open a
-                          # temporary scope
-  'nkStmtListType',       # a statement list ending in a type; for macros
-  'nkBlockType',          # a statement block ending in a type; for macros
-  
-  # types as syntactic trees:
-  'nkTypeOfExpr',
-  'nkObjectTy',
-  'nkTupleTy',
-  'nkRecList',            # list of object parts
-  'nkRecCase',            # case section of object
-  'nkRecWhen',            # when section of object
-  'nkRefTy',
-  'nkPtrTy',
-  'nkVarTy',
-  'nkDistinctTy',         # distinct type
-  'nkProcTy',
-  'nkEnumTy',
-  'nkEnumFieldDef',       # `ident = expr` in an enumeration
-  'nkReturnToken',        # token used for interpretation
-],
-
-'SymKind': [
-  # the different symbols (start with the prefix sk);
-  # order is important for the documentation generator!
-  'skUnknown',            # unknown symbol: used for parsing assembler blocks
-                          # and first phase symbol lookup in generics
-  'skConditional',        # symbol for the preprocessor (may become obsolete)
-  'skDynLib',             # symbol represents a dynamic library; this is used
-                          # internally; it does not exist in Nimrod code
-  'skParam',              # a parameter
-  'skGenericParam',       # a generic parameter; eq in ``proc x[eq=`==`]()``
-  'skTemp',               # a temporary variable (introduced by compiler)
-  'skType',               # a type
-  'skConst',              # a constant
-  'skVar',                # a variable
-  'skProc',               # a proc
-  'skMethod',             # a method
-  'skIterator',           # an iterator
-  'skConverter',          # a type converter
-  'skMacro',              # a macro
-  'skTemplate',           # a template
-  'skField',              # a field in a record or object
-  'skEnumField',          # an identifier in an enum
-  'skForVar',             # a for loop variable
-  'skModule',             # module identifier
-  'skLabel',              # a label (for block statement)
-  'skStub'                # symbol is a stub and not yet loaded from the ROD
-                          # file (it is loaded on demand, which may mean: never)
-]
-}

data/magic.yml

@@ -1,254 +0,0 @@
-# All the magics of the system module:
-# order has been changed!
-[
-'None',
-'Defined',
-'DefinedInScope',
-'Low',
-'High',
-'SizeOf',
-'Is',
-'Echo',
-'Succ',
-'Pred',
-'Inc',
-'Dec',
-'Ord',
-
-'New',
-'NewFinalize',
-'NewSeq',
-'LengthOpenArray',
-'LengthStr',
-'LengthArray',
-'LengthSeq',
-'Incl',
-'Excl',
-'Card',
-'Chr',
-'GCref',
-'GCunref',
-
-# binary arithmetic with and without overflow checking:
-'AddI',
-'SubI',
-'MulI',
-'DivI',
-'ModI',
-'AddI64',
-'SubI64',
-'MulI64',
-'DivI64',
-'ModI64',
-
-# other binary arithmetic operators:
-'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',
-
-# comparison operators:
-'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',
-
-# unary arithmetic with and without overflow checking:
-'UnaryMinusI',
-'UnaryMinusI64',
-'AbsI',
-'AbsI64',
-
-# other unary operations:
-'Not',
-'UnaryPlusI',
-'BitnotI',
-'UnaryPlusI64',
-'BitnotI64',
-'UnaryPlusF64',
-'UnaryMinusF64',
-'AbsF64',
-'Ze8ToI',
-'Ze8ToI64',
-'Ze16ToI',
-'Ze16ToI64',
-'Ze32ToI64',
-'ZeIToI64',
-
-'ToU8',
-'ToU16',
-'ToU32',
-'ToFloat',
-'ToBiggestFloat',
-'ToInt',
-'ToBiggestInt',
-
-'CharToStr',
-'BoolToStr',
-'IntToStr',  # $ for ints
-'Int64ToStr',
-'FloatToStr',
-'CStrToStr',
-'StrToStr',
-'EnumToStr',
-
-# special ones:
-'And',
-'Or',
-'EqStr',
-'LeStr',
-'LtStr',
-'EqSet',
-'LeSet',
-'LtSet',
-'MulSet',
-'PlusSet',
-'MinusSet',
-'SymDiffSet',
-'ConStrStr',
-'ConArrArr',
-'ConArrT',
-'ConTArr',
-'ConTT',
-'Slice',
-'AppendStrCh',
-'AppendStrStr',
-'AppendSeqElem',
-'InRange',
-'InSet',
-'Repr',
-'Exit',
-'SetLengthStr',
-'SetLengthSeq',
-'Assert',
-'Swap',
-'IsNil',
-'ArrToSeq',
-'CopyStr',
-'CopyStrLast',
-'NewString',
-
-# magic types:
-'Array',
-'OpenArray',
-'Range',
-'Set',
-'Seq',
-'Ordinal',
-'Int',
-'Int8',
-'Int16',
-'Int32',
-'Int64',
-'Float',
-'Float32',
-'Float64',
-'Bool',
-'Char',
-'String',
-'Cstring',
-'Pointer', 
-'EmptySet',
-'IntSetBaseType',
-'Nil',
-'Expr',
-'Stmt',
-'TypeDesc',
-
-# magic constants:
-'IsMainModule',
-'CompileDate',
-'CompileTime',
-'NimrodVersion',
-'NimrodMajor',
-'NimrodMinor',
-'NimrodPatch',
-'CpuEndian',
-'HostOS',
-'HostCPU',
-'NaN',
-'Inf',
-'NegInf',
-
-# magics for modifying the AST (macro support)
-'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',
-'EqNimrodNode',
-'NHint',
-'NWarning',
-'NError'
-]

data/messages.yml

@@ -1,273 +0,0 @@
-# This file contains all the messages of the Nimrod compiler
-# (c) 2009 Andreas Rumpf
-
-[
-# fatal errors:
-{'errUnknown': 'unknown error'},
-{'errIllFormedAstX': 'illformed AST: $1'},
-{'errCannotOpenFile': "cannot open '$1'"},
-{'errInternal': 'internal error: $1'},
-
-# other errors:
-{'errGenerated': '$1'},
-{'errXCompilerDoesNotSupportCpp': "'$1' compiler does not support C++"},
-
-# errors:
-{'errStringLiteralExpected': 'string literal expected'},
-{'errIntLiteralExpected': 'integer literal expected'},
-{'errInvalidCharacterConstant': 'invalid character constant'},
-{'errClosingTripleQuoteExpected':
-  'closing """ expected, but end of file reached'},
-{'errClosingQuoteExpected': 'closing " expected'},
-{'errTabulatorsAreNotAllowed': 'tabulators are not allowed'},
-{'errInvalidToken': 'invalid token: $1'},
-{'errLineTooLong': 'line too long'},
-{'errInvalidNumber': '$1 is not a valid number'},
-{'errNumberOutOfRange': 'number $1 out of valid range'},
-{'errNnotAllowedInCharacter': '\\n not allowed in character literal'},
-{'errClosingBracketExpected': "closing ']' expected, but end of file reached"},
-{'errMissingFinalQuote': "missing final '"},
-{'errIdentifierExpected': "identifier expected, but found '$1'"},
-{'errOperatorExpected': "operator expected, but found '$1'"},
-{'errTokenExpected': "'$1' expected"},
-{'errStringAfterIncludeExpected': "string after 'include' expected"},
-{'errRecursiveDependencyX': "recursive dependency: '$1'"},
-{'errOnOrOffExpected': "'on' or 'off' expected"},
-{'errNoneSpeedOrSizeExpected': "'none', 'speed' or 'size' expected"},
-{'errInvalidPragma': 'invalid pragma'},
-{'errUnknownPragma': "unknown pragma: '$1'"},
-{'errInvalidDirectiveX': "invalid directive: '$1'"},
-{'errAtPopWithoutPush': "'pop' without a 'push' pragma"},
-{'errEmptyAsm': 'empty asm statement'},
-{'errInvalidIndentation': 'invalid indentation'},
-{'errExceptionExpected': 'exception expected'},
-{'errExceptionAlreadyHandled': 'exception already handled'},
-{'errYieldNotAllowedHere': "'yield' only allowed in a loop of an iterator"},
-{'errInvalidNumberOfYieldExpr': "invalid number of 'yield' expresions"},
-{'errCannotReturnExpr': 'current routine cannot return an expression'},
-{'errAttemptToRedefine': "attempt to redefine '$1'"},
-{'errStmtInvalidAfterReturn':
-  "statement not allowed after 'return', 'break' or 'raise'"},
-{'errStmtExpected': 'statement expected'},
-{'errInvalidLabel': "'$1' is no label"},
-{'errInvalidCmdLineOption': "invalid command line option: '$1'"},
-{'errCmdLineArgExpected': "argument for command line option expected: '$1'"},
-{'errCmdLineNoArgExpected': "invalid argument for command line option: '$1'"},
-{'errInvalidVarSubstitution': "invalid variable substitution in '$1'"},
-{'errUnknownVar': "unknown variable: '$1'"},
-{'errUnknownCcompiler': "unknown C compiler: '$1'"},
-{'errOnOrOffExpectedButXFound': "'on' or 'off' expected, but '$1' found"},
-{'errNoneBoehmRefcExpectedButXFound':
-  "'none', 'boehm' or 'refc' expected, but '$1' found"},
-{'errNoneSpeedOrSizeExpectedButXFound':
-  "'none', 'speed' or 'size' expected, but '$1' found"},
-{'errGuiConsoleOrLibExpectedButXFound':
-  "'gui', 'console' or 'lib' expected, but '$1' found"},
-{'errUnknownOS': "unknown OS: '$1'"},
-{'errUnknownCPU': "unknown CPU: '$1'"},
-{'errGenOutExpectedButXFound':
-  "'c', 'c++' or 'yaml' expected, but '$1' found"},
-{'errArgsNeedRunOption':
-  "arguments can only be given if the '--run' option is selected"},
-{'errInvalidMultipleAsgn': 'multiple assignment is not allowed'},
-{'errColonOrEqualsExpected': "':' or '=' expected, but found '$1'"},
-{'errExprExpected': "expression expected, but found '$1'"},
-{'errUndeclaredIdentifier': "undeclared identifier: '$1'"},
-{'errUseQualifier': "ambiguous identifier: '$1' -- use a qualifier"},
-{'errTypeExpected': 'type expected'},
-{'errSystemNeeds': "system module needs '$1'"},
-{'errExecutionOfProgramFailed': 'execution of an external program failed'},
-{'errNotOverloadable': "overloaded '$1' leads to ambiguous calls"},
-{'errInvalidArgForX': "invalid argument for '$1'"},
-{'errStmtHasNoEffect': 'statement has no effect'},
-{'errXExpectsTypeOrValue': "'$1' expects a type or value"},
-{'errXExpectsArrayType': "'$1' expects an array type"},
-{'errIteratorCannotBeInstantiated':
-  "'$1' cannot be instantiated because its body has not been compiled yet"},
-{'errExprXAmbiguous': "expression '$1' ambiguous in this context"},
-{'errConstantDivisionByZero': 'constant division by zero'},
-{'errOrdinalTypeExpected': 'ordinal type expected'},
-{'errOrdinalOrFloatTypeExpected': 'ordinal or float type expected'},
-{'errOverOrUnderflow': 'over- or underflow'},
-{'errCannotEvalXBecauseIncompletelyDefined':
-  "cannot evalutate '$1' because type is not defined completely"},
-{'errChrExpectsRange0_255': "'chr' expects an int in the range 0..255"},
-{'errDynlibRequiresExportc': "'dynlib' requires 'exportc'"},
-{'errUndeclaredFieldX': "undeclared field: '$1'"},
-{'errNilAccess': 'attempt to access a nil address'},
-{'errIndexOutOfBounds': 'index out of bounds'},
-{'errIndexTypesDoNotMatch': 'index types do not match'},
-{'errBracketsInvalidForType': "'[]' operator invalid for this type"},
-{'errValueOutOfSetBounds': 'value out of set bounds'},
-{'errFieldInitTwice': "field initialized twice: '$1'"},
-{'errFieldNotInit': "field '$1' not initialized"},
-{'errExprXCannotBeCalled': "expression '$1' cannot be called"},
-{'errExprHasNoType': 'expression has no type'},
-{'errExprXHasNoType': "expression '$1' has no type (or is ambiguous)"},
-{'errCastNotInSafeMode': "'cast' not allowed in safe mode"},
-{'errExprCannotBeCastedToX': 'expression cannot be casted to $1'},
-{'errCommaOrParRiExpected': "',' or ')' expected"},
-{'errCurlyLeOrParLeExpected': "'{' or '(' expected"},
-{'errSectionExpected': "section ('type', 'proc', etc.) expected"},
-{'errRangeExpected': 'range expected'},
-{'errAttemptToRedefineX': "attempt to redefine '$1'"},
-{'errMagicOnlyInSystem': "'magic' only allowed in system module"},
-{'errPowerOfTwoExpected': 'power of two expected'},
-{'errStringMayNotBeEmpty': 'string literal may not be empty'},
-{'errCallConvExpected': 'calling convention expected'},
-{'errProcOnlyOneCallConv': 'a proc can only have one calling convention'},
-{'errSymbolMustBeImported': "symbol must be imported if 'lib' pragma is used"},
-{'errExprMustBeBool': "expression must be of type 'bool'"},
-{'errConstExprExpected': 'constant expression expected'},
-{'errDuplicateCaseLabel': 'duplicate case label'},
-{'errRangeIsEmpty': 'range is empty'},
-{'errSelectorMustBeOfCertainTypes':
-  'selector must be of an ordinal type, real or string'},
-{'errSelectorMustBeOrdinal':
-  'selector must be of an ordinal type'},
-{'errOrdXMustNotBeNegative': 'ord($1) must not be negative'},
-{'errLenXinvalid': 'len($1) must be less than 32768'},
-{'errWrongNumberOfVariables': 'wrong number of variables'},
-{'errExprCannotBeRaised': 'only objects can be raised'},
-{'errBreakOnlyInLoop': "'break' only allowed in loop construct"},
-{'errTypeXhasUnknownSize': "type '$1' has unknown size"},
-{'errConstNeedsConstExpr':
-  'a constant can only be initialized with a constant expression'},
-{'errConstNeedsValue': 'a constant needs a value'},
-{'errResultCannotBeOpenArray': 'the result type cannot be on open array'},
-{'errSizeTooBig': "computing the type's size produced an overflow"},
-{'errSetTooBig': 'set is too large'},
-{'errBaseTypeMustBeOrdinal': 'base type of a set must be an ordinal'},
-{'errInheritanceOnlyWithNonFinalObjects':
-  'inheritance only works with non-final objects'},
-{'errInheritanceOnlyWithEnums': 'inheritance only works with an enum'},
-{'errIllegalRecursionInTypeX': "illegal recursion in type '$1'"},
-{'errCannotInstantiateX': "cannot instantiate: '$1'"},
-{'errExprHasNoAddress': "expression has no address"},
-{'errVarForOutParamNeeded':
-  "for a 'var' type a variable needs to be passed"},
-{'errPureTypeMismatch': 'type mismatch'},
-{'errTypeMismatch': 'type mismatch: got ('},
-{'errButExpected': 'but expected one of: '},
-{'errButExpectedX': "but expected '$1'"},
-{'errAmbiguousCallXYZ': 'ambiguous call; both $1 and $2 match for: $3'},
-{'errWrongNumberOfArguments': 'wrong number of arguments'},
-{'errXCannotBePassedToProcVar': "'$1' cannot be passed to a procvar"},
-{'errXCannotBeInParamDecl': '$1 cannot be declared in parameter declaration'},
-{'errPragmaOnlyInHeaderOfProc':
-  'pragmas are only in the header of a proc allowed'},
-{'errImplOfXNotAllowed': "implementation of '$1' is not allowed"},
-{'errImplOfXexpected': "implementation of '$1' expected"},
-{'errNoSymbolToBorrowFromFound': "no symbol to borrow from found"},
-{'errDiscardValue': 'value returned by statement has to be discarded'},
-{'errInvalidDiscard': 'statement returns no value that can be discarded'},
-{'errIllegalConvFromXtoY': 'conversion from $1 to $2 is invalid'},
-{'errCannotBindXTwice': "cannot bind parameter '$1' twice"},
-{'errInvalidOrderInEnumX': "invalid order in enum '$1'"},
-{'errEnumXHasWholes': "enum '$1' has wholes"},
-{'errExceptExpected': "'except' or 'finally' expected"},
-{'errInvalidTry': "after catch all 'except' or 'finally' no section may follow"},
-{'errOptionExpected': "option expected, but found '$1'"},
-{'errXisNoLabel': "'$1' is not a label"},
-{'errNotAllCasesCovered': 'not all cases are covered'},
-{'errUnkownSubstitionVar': "unknown substitution variable: '$1'"},
-{'errComplexStmtRequiresInd': 'complex statement requires indentation'},
-{'errXisNotCallable': "'$1' is not callable"},
-{'errNoPragmasAllowedForX': 'no pragmas allowed for $1'},
-{'errNoGenericParamsAllowedForX': 'no generic parameters allowed for $1'},
-{'errInvalidParamKindX': "invalid param kind: '$1'"},
-{'errDefaultArgumentInvalid': 'default argument invalid'},
-{'errNamedParamHasToBeIdent': 'named parameter has to be an identifier'},
-{'errNoReturnTypeForX': 'no return type for $1 allowed'},
-{'errConvNeedsOneArg': 'a type conversion needs exactly one argument'},
-{'errInvalidPragmaX': 'invalid pragma: $1'},
-{'errXNotAllowedHere': '$1 not allowed here'},
-{'errInvalidControlFlowX': 'invalid control flow: $1'},
-{'errATypeHasNoValue': 'a type has no value'},
-{'errXisNoType': "invalid type: '$1'"},
-{'errCircumNeedsPointer': "'^' needs a pointer or reference type"},
-{'errInvalidExpression': 'invalid expression'},
-{'errInvalidExpressionX': "invalid expression: '$1'"},
-{'errEnumHasNoValueX': "enum has no value '$1'"},
-{'errNamedExprExpected': 'named expression expected'},
-{'errNamedExprNotAllowed': 'named expression not allowed here'},
-{'errXExpectsOneTypeParam': "'$1' expects one type parameter"},
-{'errArrayExpectsTwoTypeParams': 'array expects two type parameters'},
-{'errInvalidVisibilityX': "invalid visibility: '$1'"},
-{'errInitHereNotAllowed': 'initialization not allowed here'},
-{'errXCannotBeAssignedTo': "'$1' cannot be assigned to"},
-{'errIteratorNotAllowed':
-  "iterators can only be defined at the module's top level"},
-{'errXNeedsReturnType': '$1 needs a return type'},
-{'errInvalidCommandX': "invalid command: '$1'"},
-{'errXOnlyAtModuleScope': "'$1' is only allowed at top level"},
-{'errTemplateInstantiationTooNested': 'template/macro instantiation too nested'},
-{'errInstantiationFrom': 'instantiation from here'},
-{'errInvalidIndexValueForTuple': 'invalid index value for tuple subscript'},
-{'errCommandExpectsFilename': 'command expects a filename argument'},
-{'errXExpected': "'$1' expected"},
-{'errInvalidSectionStart': 'invalid section start'},
-{'errGridTableNotImplemented': 'grid table is not implemented'},
-{'errGeneralParseError': 'general parse error'},
-{'errNewSectionExpected': 'new section expected'},
-{'errWhitespaceExpected': "whitespace expected, got '$1'"},
-{'errXisNoValidIndexFile': "'$1' is no valid index file"},
-{'errCannotRenderX': "cannot render reStructuredText element '$1'"},
-{'errVarVarTypeNotAllowed': "type 'var var' is not allowed"},
-{'errIsExpectsTwoArguments': "'is' expects two arguments"},
-{'errIsExpectsObjectTypes': "'is' expects object types"},
-{'errXcanNeverBeOfThisSubtype': "'$1' can never be of this subtype"},
-{'errTooManyIterations': "interpretation requires too many iterations"},
-{'errCannotInterpretNodeX': "cannot interpret node kind '$1'"},
-{'errFieldXNotFound': "field '$1' cannot be found"},
-{'errInvalidConversionFromTypeX': "invalid conversion from type '$1'"},
-{'errAssertionFailed': "assertion failed"},
-{'errCannotGenerateCodeForX': "cannot generate code for '$1'"},
-{'errXRequiresOneArgument': "$1 requires one parameter"},
-{'errUnhandledExceptionX': "unhandled exception: $1"},
-{'errCyclicTree': "macro returned a cyclic abstract syntax tree"},
-{'errXisNoMacroOrTemplate': "'$1' is no macro or template"},
-{'errXhasSideEffects': "'$1' can have side effects"},
-{'errIteratorExpected': "iterator within for loop context expected"},
-
-# user error message:
-{'errUser': '$1'},
-
-# warnings:
-{'warnCannotOpenFile': "cannot open '$1'"},
-{'warnOctalEscape':
-  'octal escape sequences do not exist; leading zero is ignored'},
-{'warnXIsNeverRead': "'$1' is never read"},
-{'warnXmightNotBeenInit': "'$1' might not have been initialized"},
-{'warnCannotWriteMO2': "cannot write file '$1'"},
-{'warnCannotReadMO2': "cannot read file '$1'"},
-{'warnDeprecated': "'$1' is deprecated"},
-{'warnSmallLshouldNotBeUsed':
-  "'l' should not be used as an identifier; may look like '1' (one)"},
-{'warnUnknownMagic': "unknown magic '$1' might crash the compiler"},
-{'warnRedefinitionOfLabel': "redefinition of label '$1'"},
-{'warnUnknownSubstitutionX': "unknown substitution '$1'"},
-{'warnLanguageXNotSupported': "language '$1' not supported"},
-{'warnCommentXIgnored': "comment '$1' ignored"},
-{'warnXisPassedToProcVar': "'$1' is passed to a procvar; deprecated"},
-
-# user warning message:
-{'warnUser': '$1'},
-
-# hints:
-{'hintSuccess': 'operation successful'},
-{'hintSuccessX': 'operation successful ($1 lines compiled; $2 sec total)'},
-{'hintLineTooLong': 'line too long'},
-{'hintXDeclaredButNotUsed': "'$1' is declared but not used"},
-{'hintConvToBaseNotNeeded': 'conversion to base object is not needed'},
-{'hintConvFromXtoItselfNotNeeded': 'conversion from $1 to itself is pointless'},
-{'hintExprAlwaysX': "expression evaluates always to '$1'"},
-{'hintQuitCalled': "quit() called"},
-{'hintProcessing': "$1"},
-{'hintCodeBegin': "generated code listing:"},
-{'hintCodeEnd': "end of listing"},
-{'hintConf': "used config file '$1'"},
-
-# user hint message:
-{'hintUser': '$1'}
-]

data/pas_keyw.yml

@@ -1,26 +0,0 @@
-# Object Pascal keywords for the Pascal scanner that is part of the
-# Nimrod distribution
-# (c) Andreas Rumpf 2007
-[
-  "and", "array", "as", "asm",
-  "begin",
-  "case", "class", "const", "constructor",
-  "destructor", "div", "do", "downto",
-  "else", "end", "except", "exports",
-  "finalization", "finally", "for", "function",
-  "goto",
-  "if", "implementation", "in", "inherited", "initialization", "inline",
-  "interface", "is",
-  "label", "library",
-  "mod",
-  "nil", "not",
-  "object", "of", "or", "out",
-  "packed", "procedure", "program", "property",
-  "raise", "record", "repeat", "resourcestring",
-  "set", "shl", "shr",
-  "then", "threadvar", "to", "try", "type",
-  "unit", "until", "uses",
-  "var",
-  "while", "with",
-  "xor"
-]

data/readme.txt

@@ -1,2 +0,0 @@
-The files in this directory used to be required for building Nimrod. Now they 
-are only used for the documentation. 

diff/empty.txt

@@ -1 +0,0 @@
-This file keeps several tools from deleting this subdirectory.

doc/intern.txt

@@ -21,22 +21,17 @@ Path           Purpose
 ============   ==============================================
 ``bin``        generated binary files
 ``build``      generated C code for the installation
-``nim``        Pascal sources of the Nimrod compiler; this
-               has been used for bootstrapping, but new
-               development is done with the Nimrod version.
-``rod``        Nimrod sources of the Nimrod compiler;
-               automatically generated from the Pascal
-               version.
-``data``       data files that are used for generating source
-               code; not used anymore
+``compiler``   the Nimrod compiler itself; note that this
+               code has been translated from a bootstrapping 
+               version written in Pascal, so the code is **not** 
+               a poster child of good Nimrod code
+``config``     configuration files for Nimrod
+``dist``       additional packages for the distribution
 ``doc``        the documentation; it is a bunch of
                reStructuredText files
-``dist``       additional packages for the distribution
-``config``     configuration files for Nimrod
 ``lib``        the Nimrod library; ``rod`` depends on it!
 ``web``        website of Nimrod; generated by ``koch.py``
                from the ``*.txt`` and ``*.tmpl`` files
-``obj``        generated ``*.obj`` files
 ============   ==============================================
 
 

koch.nim

@@ -52,11 +52,11 @@ proc tryExec(cmd: string): bool =
   result = execShellCmd(cmd) == 0
 
 proc csource(args: string) = 
-  exec("nimrod cc $1 -r tools/niminst --var:version=$2 csource rod/nimrod $1" %
+  exec("nimrod cc $1 -r tools/niminst --var:version=$2 csource compiler/nimrod $1" %
        [args, NimrodVersion])
 
 proc zip(args: string) = 
-  exec("nimrod cc -r tools/niminst --var:version=$# zip rod/nimrod" %
+  exec("nimrod cc -r tools/niminst --var:version=$# zip compiler/nimrod" %
        NimrodVersion)
   
 proc buildTool(toolname, args: string) = 
@@ -66,8 +66,9 @@ proc buildTool(toolname, args: string) =
 proc inno(args: string) =
   # make sure we have generated the c2nim and niminst executables:
   buildTool("tools/niminst", args)
-  buildTool("rod/c2nim/c2nim", args)
-  exec("tools" / "niminst --var:version=$# inno rod/nimrod" % NimrodVersion)
+  buildTool("compiler/c2nim/c2nim", args)
+  exec("tools" / "niminst --var:version=$# inno compiler/nimrod" % 
+       NimrodVersion)
 
 proc install(args: string) = 
   exec("sh ./build.sh")
@@ -87,18 +88,6 @@ proc gitAux(dir: string) =
 proc git = 
   gitAux("build")
 
-# -------------- nim ----------------------------------------------------------
-
-proc compileNimCmd(args: string): string = 
-  var cwd = getCurrentDir()
-  result = ("fpc -Cs16777216 -gl -bl -Crtoi -Sgidh -vw -Se1 $4 -o\"$1\" " &
-            "-FU\"$2\" \"$3\"") % [cwd / "bin" / "nim".exe, 
-                                   cwd / "obj",
-                                   cwd / "nim" / "nimrod.pas",
-                                   args]
-
-proc nim(args: string) = exec(compileNimCmd(args))
-
 # -------------- boot ---------------------------------------------------------
 
 const
@@ -117,14 +106,15 @@ proc findStartNimrod: string =
   if ExistsFile(result): return
   for dir in split(getEnv("PATH"), PathSep):
     if ExistsFile(dir / nimrod): return nimrod
-  result = "bin" / "nim".exe
-  if ExistsFile(result): return
   when defined(Posix):
     const buildScript = "build.sh"
     if ExistsFile(buildScript): 
       if tryExec("./" & buildScript): return "bin" / nimrod
+  else:
+    const buildScript = "build.bat"
+    if ExistsFile(buildScript): 
+      if tryExec(buildScript): return "bin" / nimrod
   
-  if tryExec(compileNimCmd("")): return 
   echo("Found no nimrod compiler and every attempt to build one failed!")
   quit("FAILURE")
 
@@ -132,7 +122,7 @@ proc safeRemove(filename: string) =
   if existsFile(filename): removeFile(filename)
 
 proc thVersion(i: int): string = 
-  result = ("rod" / "nimrod" & $i).exe
+  result = ("compiler" / "nimrod" & $i).exe
 
 proc copyExe(source, dest: string) =
   safeRemove(dest)
@@ -140,13 +130,13 @@ proc copyExe(source, dest: string) =
   inclFilePermissions(dest, {fpUserExec})
   
 proc boot(args: string) =
-  var output = "rod" / "nimrod".exe
+  var output = "compiler" / "nimrod".exe
   var finalDest = "bin" / "nimrod".exe
   
   copyExe(findStartNimrod(), 0.thVersion)
   for i in 0..2:
     echo "iteration: ", i+1
-    exec i.thVersion & " cc $# $# rod" / "nimrod.nim" % [bootOptions, args]
+    exec i.thVersion & " cc $# $# compiler" / "nimrod.nim" % [bootOptions, args]
     if sameFileContent(output, i.thVersion):
       copyExe(output, finalDest)
       echo "executables are equal: SUCCESS!"
@@ -214,7 +204,6 @@ of cmdArgument:
   of "zip": zip(op.cmdLineRest)
   of "inno": inno(op.cmdLineRest)
   of "install": install(op.cmdLineRest)
-  of "nim": nim(op.cmdLineRest)
   of "git": git()
   else: showHelp()
 of cmdEnd: showHelp()

lib/impure/zipfiles.nim

@@ -58,8 +58,8 @@ proc addFile*(z: var TZipArchive, dest, src: string) =
   assert(z.mode != fmRead) 
   var zipsrc = zip_source_file(z.w, src, 0, -1)
   if zipsrc == nil:
-    echo("Dest: " & dest)
-    echo("Src: " & src)
+    #echo("Dest: " & dest)
+    #echo("Src: " & src)
     zipError(z)
   if zip_add(z.w, dest, zipsrc) < 0'i32:
     zip_source_free(zipsrc)