mirrors/Nim
1
0
Fork 0
mirror of https://github.com/nim-lang/Nim.git synced 2026-01-04 12:07:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

system files use new identifiers

Browse Source
This commit is contained in:
Araq
2014-08-23 00:58:04 +02:00
parent dbf9117c56
commit fc0fda14ae
13 changed files with 371 additions and 338 deletions
Download Patch File Download Diff File Expand all files Collapse all files

361
lib/system.nim
View File

@@ -1,7 +1,7 @@
#
#
# Nimrod's Runtime Library
# (c) Copyright 2013 Andreas Rumpf
# Nim's Runtime Library
# (c) Copyright 2014 Andreas Rumpf
#
# See the file "copying.txt", included in this
# distribution, for details about the copyright.
@@ -77,23 +77,23 @@ type
auto* = expr
any* = distinct auto
TSignedInt* = int|int8|int16|int32|int64
SomeSignedInt* = int|int8|int16|int32|int64
## type class matching all signed integer types
TUnsignedInt* = uint|uint8|uint16|uint32|uint64
SomeUnsignedInt* = uint|uint8|uint16|uint32|uint64
## type class matching all unsigned integer types
TInteger* = TSignedInt|TUnsignedInt
SomeInteger* = SomeSignedInt|SomeUnsignedInt
## type class matching all integer types
TOrdinal* = int|int8|int16|int32|int64|bool|enum|uint8|uint16|uint32
SomeOrdinal* = int|int8|int16|int32|int64|bool|enum|uint8|uint16|uint32
## type class matching all ordinal types; however this includes enums with
## holes.
TReal* = float|float32|float64
SomeReal* = float|float32|float64
## type class matching all floating point number types
TNumber* = TInteger|TReal
SomeNumber* = SomeInteger|SomeReal
## type class matching all number types
proc defined*(x: expr): bool {.magic: "Defined", noSideEffect.}
@@ -108,6 +108,15 @@ proc defined*(x: expr): bool {.magic: "Defined", noSideEffect.}
## # Do here programmer friendly expensive sanity checks.
## # Put here the normal code
when defined(nimalias):
{.deprecated: [
TSignedInt: SomeSignedInt,
TUnsignedInt: SomeUnsignedInt,
TInteger: SomeInteger,
TReal: SomeReal,
TNumber: SomeNumber,
TOrdinal: SomeOrdinal].}
proc declared*(x: expr): bool {.magic: "Defined", noSideEffect.}
## Special compile-time procedure that checks whether `x` is
## declared. `x` has to be an identifier or a qualified identifier.
@@ -202,10 +211,13 @@ type
set*{.magic: "Set".}[T] ## Generic type to construct bit sets.
type
TSlice* {.final, pure.}[T] = object ## builtin slice type
a*, b*: T ## the bounds
Slice* {.final, pure.}[T] = object ## builtin slice type
a*, b*: T ## the bounds
proc `..`*[T](a, b: T): TSlice[T] {.noSideEffect, inline.} =
when defined(nimalias):
{.deprecated: [TSlice: Slice].}
proc `..`*[T](a, b: T): Slice[T] {.noSideEffect, inline.} =
## `slice`:idx: operator that constructs an interval ``[a, b]``, both `a`
## and `b` are inclusive. Slices can also be used in the set constructor
## and in ordinal case statements, but then they are special-cased by the
@@ -213,7 +225,7 @@ proc `..`*[T](a, b: T): TSlice[T] {.noSideEffect, inline.} =
result.a = a
result.b = b
proc `..`*[T](b: T): TSlice[T] {.noSideEffect, inline.} =
proc `..`*[T](b: T): Slice[T] {.noSideEffect, inline.} =
## `slice`:idx: operator that constructs an interval ``[default(T), b]``
result.b = b
@@ -307,29 +319,29 @@ type
## is an int type ranging from one to the maximum value
## of an int. This type is often useful for documentation and debugging.
TObject* {.exportc: "TNimObject", inheritable.} =
RootObj* {.exportc: "TNimObject", inheritable.} =
object ## the root of Nimrod's object hierarchy. Objects should
## inherit from TObject or one of its descendants. However,
## objects that have no ancestor are allowed.
PObject* = ref TObject ## reference to TObject
RootRef* = ref RootObj ## reference to RootObj
TEffect* {.compilerproc.} = object of TObject ## \
RootEffect* {.compilerproc.} = object of RootObj ## \
## base effect class; each effect should
## inherit from `TEffect` unless you know what
## you doing.
FTime* = object of TEffect ## Time effect.
FIO* = object of TEffect ## IO effect.
FReadIO* = object of FIO ## Effect describing a read IO operation.
FWriteIO* = object of FIO ## Effect describing a write IO operation.
FExecIO* = object of FIO ## Effect describing an executing IO operation.
TimeEffect* = object of RootEffect ## Time effect.
IOEffect* = object of RootEffect ## IO effect.
ReadIOEffect* = object of IOEffect ## Effect describing a read IO operation.
WriteIOEffect* = object of IOEffect ## Effect describing a write IO operation.
ExecIOEffect* = object of IOEffect ## Effect describing an executing IO operation.
E_Base* {.compilerproc.} = object of TObject ## \
Exception* {.compilerproc.} = object of RootObj ## \
## Base exception class.
##
## Each exception has to inherit from `E_Base`. See the full `exception
## Each exception has to inherit from `Exception`. See the full `exception
## hierarchy`_.
parent: ref E_Base ## parent exception (can be used as a stack)
name: cstring ## The exception's name is its Nimrod identifier.
parent: ref Exception ## parent exception (can be used as a stack)
name: cstring ## The exception's name is its Nim identifier.
## This field is filled automatically in the
## ``raise`` statement.
msg* {.exportc: "message".}: string ## the exception's message. Not
@@ -337,130 +349,117 @@ type
## is bad style.
trace: string
EAsynch* = object of E_Base ## \
## Abstract exception class for *asynchronous exceptions* (interrupts).
##
## This is rarely needed: most exception types inherit from `ESynch
## <#ESynch>`_. See the full `exception hierarchy`_.
EControlC* = object of EAsynch ## \
## Raised for Ctrl+C key presses in console applications.
##
## See the full `exception hierarchy`_.
ESynch* = object of E_Base ## \
## Abstract exception class for *synchronous exceptions*.
##
## Most exceptions should be inherited (directly or indirectly) from
## `ESynch` instead of from `EAsynch <#EAsynch>`_. See the full `exception
## hierarchy`_.
ESystem* = object of ESynch ## \
SystemError* = object of Exception ## \
## Abstract class for exceptions that the runtime system raises.
##
## See the full `exception hierarchy`_.
EIO* = object of ESystem ## \
IOError* = object of SystemError ## \
## Raised if an IO error occured.
##
## See the full `exception hierarchy`_.
EOS* = object of ESystem ## \
OSError* = object of SystemError ## \
## Raised if an operating system service failed.
##
## See the full `exception hierarchy`_.
errorCode*: int32 ## OS-defined error code describing this error.
EInvalidLibrary* = object of EOS ## \
LibraryError* = object of OSError ## \
## Raised if a dynamic library could not be loaded.
##
## See the full `exception hierarchy`_.
EResourceExhausted* = object of ESystem ## \
ResourceExhaustedError* = object of SystemError ## \
## Raised if a resource request could not be fullfilled.
##
## See the full `exception hierarchy`_.
EArithmetic* = object of ESynch ## \
ArithmeticError* = object of Exception ## \
## Raised if any kind of arithmetic error occured.
##
## See the full `exception hierarchy`_.
EDivByZero* {.compilerproc.} = object of EArithmetic ## \
DivByZeroError* = object of ArithmeticError ## \
## Raised for runtime integer divide-by-zero errors.
##
## See the full `exception hierarchy`_.
EOverflow* {.compilerproc.} = object of EArithmetic ## \
OverflowError* = object of ArithmeticError ## \
## Raised for runtime integer overflows.
##
## This happens for calculations whose results are too large to fit in the
## provided bits. See the full `exception hierarchy`_.
EAccessViolation* {.compilerproc.} = object of ESynch ## \
AccessViolationError* {.compilerproc.} = object of Exception ## \
## Raised for invalid memory access errors
##
## See the full `exception hierarchy`_.
EAssertionFailed* {.compilerproc.} = object of ESynch ## \
AssertionError* {.compilerproc.} = object of Exception ## \
## Raised when assertion is proved wrong.
##
## Usually the result of using the `assert() template <#assert>`_. See the
## full `exception hierarchy`_.
EInvalidValue* = object of ESynch ## \
ValueError* = object of Exception ## \
## Raised for string and object conversion errors.
EInvalidKey* = object of EInvalidValue ## \
KeyError* = object of ValueError ## \
## Raised if a key cannot be found in a table.
##
## Mostly used by the `tables <tables.html>`_ module, it can also be raised
## by other collection modules like `sets <sets.html>`_ or `strtabs
## <strtabs.html>`_. See the full `exception hierarchy`_.
EOutOfMemory* = object of ESystem ## \
OutOfMemError* = object of SystemError ## \
## Raised for unsuccessful attempts to allocate memory.
##
## See the full `exception hierarchy`_.
EInvalidIndex* = object of ESynch ## \
IndexError* = object of Exception ## \
## Raised if an array index is out of bounds.
##
## See the full `exception hierarchy`_.
EInvalidField* = object of ESynch ## \
FieldError* = object of Exception ## \
## Raised if a record field is not accessible because its dicriminant's
## value does not fit.
##
## See the full `exception hierarchy`_.
EOutOfRange* = object of ESynch ## \
RangeError* = object of Exception ## \
## Raised if a range check error occurred.
##
## See the full `exception hierarchy`_.
EStackOverflow* = object of ESystem ## \
StackOverflowError* = object of SystemError ## \
## Raised if the hardware stack used for subroutine calls overflowed.
##
## See the full `exception hierarchy`_.
ENoExceptionToReraise* = object of ESynch ## \
ReraiseError* = object of Exception ## \
## Raised if there is no exception to reraise.
##
## See the full `exception hierarchy`_.
EInvalidObjectAssignment* = object of ESynch ## \
ObjectAssignmentError* = object of Exception ## \
## Raised if an object gets assigned to its parent's object.
##
## See the full `exception hierarchy`_.
EInvalidObjectConversion* = object of ESynch ## \
ObjectConversionError* = object of Exception ## \
## Raised if an object is converted to an incompatible object type.
##
## See the full `exception hierarchy`_.
EFloatingPoint* = object of ESynch ## \
FloatingPointError* = object of Exception ## \
## Base class for floating point exceptions.
##
## See the full `exception hierarchy`_.
EFloatInvalidOp* {.compilerproc.} = object of EFloatingPoint ## \
FloatInvalidOpError* = object of FloatingPointError ## \
## Raised by invalid operations according to IEEE.
##
## Raised by ``0.0/0.0``, for example. See the full `exception
## hierarchy`_.
EFloatDivByZero* {.compilerproc.} = object of EFloatingPoint ## \
FloatDivByZeroError* = object of FloatingPointError ## \
## Raised by division by zero.
##
## Divisor is zero and dividend is a finite nonzero number. See the full
## `exception hierarchy`_.
EFloatOverflow* {.compilerproc.} = object of EFloatingPoint ## \
FloatOverflowError* = object of FloatingPointError ## \
## Raised for overflows.
##
## The operation produced a result that exceeds the range of the exponent.
## See the full `exception hierarchy`_.
EFloatUnderflow* {.compilerproc.} = object of EFloatingPoint ## \
FloatUnderflowError* = object of FloatingPointError ## \
## Raised for underflows.
##
## The operation produced a result that is too small to be represented as a
## normal number. See the full `exception hierarchy`_.
EFloatInexact* {.compilerproc.} = object of EFloatingPoint ## \
FloatInexactError* = object of FloatingPointError ## \
## Raised for inexact results.
##
## The operation produced a result that cannot be represented with infinite
@@ -468,12 +467,37 @@ type
##
## **NOTE**: Nimrod currently does not detect these! See the full
## `exception hierarchy`_.
EDeadThread* = object of ESynch ## \
DeadThreadError* = object of Exception ## \
## Raised if it is attempted to send a message to a dead thread.
##
## See the full `exception hierarchy`_.
TResult* = enum Failure, Success
TResult* {.deprecated.} = enum Failure, Success
{.deprecated: [TObject: RootObj, PObject: RootRef, TEffect: RootEffect,
FTime: TimeEffect, FIO: IOEffect, FReadIO: ReadIOEffect,
FWriteIO: WriteIOEffect, FExecIO: ExecIOEffect,
E_Base: Exception, ESystem: SystemError, EIO: IOError,
EOS: OSError, EInvalidLibrary: LibraryError,
EResourceExhausted: ResourceExhaustedError,
EArithmetic: ArithmeticError, EDivByZero: DivByZeroError,
EOverflow: OverflowError, EAccessViolation: AccessViolationError,
EAssertionFailed: AssertionError, EInvalidValue: ValueError,
EInvalidKey: KeyError, EOutOfMemory: OutOfMemError,
EInvalidIndex: IndexError, EInvalidField: FieldError,
EOutOfRange: RangeError, EStackOverflow: StackOverflowError,
ENoExceptionToReraise: ReraiseError,
EInvalidObjectAssignment: ObjectAssignmentError,
EInvalidObjectConversion: ObjectConversionError,
EDeadThread: DeadThreadError,
EFloatInexact: FloatInexactError,
EFloatUnderflow: FloatUnderflowError,
EFloatingPoint: FloatingPointError,
EFloatInvalidOp: FloatInvalidOpError,
EFloatDivByZero: FloatDivByZeroError,
EFloatOverflow: FloatOverflowError
].}
proc sizeof*[T](x: T): Natural {.magic: "SizeOf", noSideEffect.}
## returns the size of ``x`` in bytes. Since this is a low-level proc,
@@ -839,7 +863,7 @@ proc contains*[T](x: set[T], y: T): bool {.magic: "InSet", noSideEffect.}
## is achieved by reversing the parameters for ``contains``; ``in`` then
## passes its arguments in reverse order.
proc contains*[T](s: TSlice[T], value: T): bool {.noSideEffect, inline.} =
proc contains*[T](s: Slice[T], value: T): bool {.noSideEffect, inline.} =
## Checks if `value` is withing the range of `s`; returns true iff
## `value >= s.a and value <= s.b`
##
@@ -978,7 +1002,7 @@ proc add*(x: var string, y: string) {.magic: "AppendStrStr", noSideEffect.}
## assert(tmp == "abcd")
type
TEndian* = enum ## is a type describing the endianness of a processor.
Endianness* = enum ## is a type describing the endianness of a processor.
littleEndian, bigEndian
const
@@ -994,23 +1018,23 @@ const
## is the time of compilation as a string of the form
## ``HH:MM:SS``. This works thanks to compiler magic.
NimrodVersion* {.magic: "NimrodVersion"}: string = "0.0.0"
NimVersion* {.magic: "NimrodVersion"}: string = "0.0.0"
## is the version of Nimrod as a string.
## This works thanks to compiler magic.
NimrodMajor* {.magic: "NimrodMajor"}: int = 0
NimMajor* {.magic: "NimrodMajor"}: int = 0
## is the major number of Nimrod's version.
## This works thanks to compiler magic.
NimrodMinor* {.magic: "NimrodMinor"}: int = 0
NimMinor* {.magic: "NimrodMinor"}: int = 0
## is the minor number of Nimrod's version.
## This works thanks to compiler magic.
NimrodPatch* {.magic: "NimrodPatch"}: int = 0
NimPatch* {.magic: "NimrodPatch"}: int = 0
## is the patch number of Nimrod's version.
## This works thanks to compiler magic.
cpuEndian* {.magic: "CpuEndian"}: TEndian = littleEndian
cpuEndian* {.magic: "CpuEndian"}: Endianness = littleEndian
## is the endianness of the target CPU. This is a valuable piece of
## information for low-level code only. This works thanks to compiler
## magic.
@@ -1025,7 +1049,10 @@ const
## "i386", "alpha", "powerpc", "sparc", "amd64", "mips", "arm".
seqShallowFlag = low(int)
{.deprecated: [TEndian: Endianness, NimrodVersion: NimVersion,
NimrodMajor: NimMajor, NimrodMinor: NimMinor, NimrodPatch: NimPatch].}
proc compileOption*(option: string): bool {.
magic: "CompileOption", noSideEffect.}
## can be used to determine an on|off compile-time option. Example:
@@ -1160,7 +1187,7 @@ proc repr*[T](x: T): string {.magic: "Repr", noSideEffect.}
## debugging tool.
type
TAddress* = int
ByteAddress* = int
## is the signed integer type that should be used for converting
## pointers to integer addresses for readability.
@@ -1174,6 +1201,8 @@ type
## compiler supports. Currently this is ``float64``, but it is
## platform-dependant in general.
{.deprecated: [TAddress: ByteAddress].}
when defined(windows):
type
clong* {.importc: "long", nodecl.} = int32
@@ -1833,7 +1862,7 @@ proc map*[T](data: var openArray[T], op: proc (x: var T) {.closure.}) =
## # --> ["142", "242", "342", "442"]
for i in 0..data.len-1: op(data[i])
iterator fields*[T: tuple|object](x: T): TObject {.
iterator fields*[T: tuple|object](x: T): RootObj {.
magic: "Fields", noSideEffect.}
## iterates over every field of `x`. Warning: This really transforms
## the 'for' and unrolls the loop. The current implementation also has a bug
@@ -1844,7 +1873,7 @@ iterator fields*[S:tuple|object, T:tuple|object](x: S, y: T): tuple[a,b: expr] {
## Warning: This is really transforms the 'for' and unrolls the loop.
## The current implementation also has a bug that affects symbol binding
## in the loop body.
iterator fieldPairs*[T: tuple|object](x: T): TObject {.
iterator fieldPairs*[T: tuple|object](x: T): RootObj {.
magic: "FieldPairs", noSideEffect.}
## Iterates over every field of `x` returning their name and value.
##
@@ -1975,13 +2004,15 @@ when not defined(nimrodVM) and hostOS != "standalone":
## Ordinary code does not need to call this (and should not).
type
TGC_Strategy* = enum ## the strategy the GC should use for the application
GC_Strategy* = enum ## the strategy the GC should use for the application
gcThroughput, ## optimize for throughput
gcResponsiveness, ## optimize for responsiveness (default)
gcOptimizeTime, ## optimize for speed
gcOptimizeSpace ## optimize for memory footprint
proc GC_setStrategy*(strategy: TGC_Strategy) {.rtl, deprecated.}
{.deprecated: [TGC_Strategy: GC_Strategy].}
proc GC_setStrategy*(strategy: GC_Strategy) {.rtl, deprecated.}
## tells the GC the desired strategy for the application.
## **Deprecated** since version 0.8.14. This has always been a nop.
@@ -2024,7 +2055,7 @@ const NimStackTrace = compileOption("stacktrace")
# of the code
var
globalRaiseHook*: proc (e: ref E_Base): bool {.nimcall, gcsafe.}
globalRaiseHook*: proc (e: ref Exception): bool {.nimcall, gcsafe.}
## with this hook you can influence exception handling on a global level.
## If not nil, every 'raise' statement ends up calling this hook. Ordinary
## application code should never set this hook! You better know what you
@@ -2032,7 +2063,7 @@ var
## exception is caught and does not propagate further through the call
## stack.
localRaiseHook* {.threadvar.}: proc (e: ref E_Base): bool {.nimcall, gcsafe.}
localRaiseHook* {.threadvar.}: proc (e: ref Exception): bool {.nimcall, gcsafe.}
## with this hook you can influence exception handling on a
## thread local level.
## If not nil, every 'raise' statement ends up calling this hook. Ordinary
@@ -2092,7 +2123,7 @@ elif hostOS != "standalone":
inc(i)
{.pop.}
proc echo*[T](x: varargs[T, `$`]) {.magic: "Echo", tags: [FWriteIO], gcsafe.}
proc echo*[T](x: varargs[T, `$`]) {.magic: "Echo", tags: [WriteIOEffect], gcsafe.}
## Writes and flushes the parameters to the standard output.
##
## Special built-in that takes a variable number of arguments. Each argument
@@ -2224,9 +2255,9 @@ when not defined(JS): #and not defined(NimrodVM):
type
CFile {.importc: "FILE", header: "<stdio.h>",
final, incompletestruct.} = object
TFile* = ptr CFile ## The type representing a file handle.
File* = ptr CFile ## The type representing a file handle.
TFileMode* = enum ## The file mode when opening a file.
FileMode* = enum ## The file mode when opening a file.
fmRead, ## Open the file for read access only.
fmWrite, ## Open the file for write access only.
fmReadWrite, ## Open the file for read and write access.
@@ -2238,49 +2269,51 @@ when not defined(JS): #and not defined(NimrodVM):
fmAppend ## Open the file for writing only; append data
## at the end.
TFileHandle* = cint ## type that represents an OS file handle; this is
## useful for low-level file access
FileHandle* = cint ## type that represents an OS file handle; this is
## useful for low-level file access
{.deprecated: [TFile: File, TFileHandle: FileHandle, TFileMode: FileMode].}
# text file handling:
var
stdin* {.importc: "stdin", header: "<stdio.h>".}: TFile
stdin* {.importc: "stdin", header: "<stdio.h>".}: File
## The standard input stream.
stdout* {.importc: "stdout", header: "<stdio.h>".}: TFile
stdout* {.importc: "stdout", header: "<stdio.h>".}: File
## The standard output stream.
stderr* {.importc: "stderr", header: "<stdio.h>".}: TFile
stderr* {.importc: "stderr", header: "<stdio.h>".}: File
## The standard error stream.
when defined(useStdoutAsStdmsg):
template stdmsg*: TFile = stdout
template stdmsg*: File = stdout
else:
template stdmsg*: TFile = stderr
template stdmsg*: File = stderr
## Template which expands to either stdout or stderr depending on
## `useStdoutAsStdmsg` compile-time switch.
proc open*(f: var TFile, filename: string,
mode: TFileMode = fmRead, bufSize: int = -1): bool {.tags: [],
proc open*(f: var File, filename: string,
mode: FileMode = fmRead, bufSize: int = -1): bool {.tags: [],
gcsafe.}
## Opens a file named `filename` with given `mode`.
##
## Default mode is readonly. Returns true iff the file could be opened.
## This throws no exception if the file could not be opened.
proc open*(f: var TFile, filehandle: TFileHandle,
mode: TFileMode = fmRead): bool {.tags: [], gcsafe.}
proc open*(f: var File, filehandle: FileHandle,
mode: FileMode = fmRead): bool {.tags: [], gcsafe.}
## Creates a ``TFile`` from a `filehandle` with given `mode`.
##
## Default mode is readonly. Returns true iff the file could be opened.
proc open*(filename: string,
mode: TFileMode = fmRead, bufSize: int = -1): TFile =
mode: FileMode = fmRead, bufSize: int = -1): File =
## Opens a file named `filename` with given `mode`.
##
## Default mode is readonly. Raises an ``IO`` exception if the file
## could not be opened.
if not open(result, filename, mode, bufSize):
sysFatal(EIO, "cannot open: ", filename)
sysFatal(IOError, "cannot open: ", filename)
proc reopen*(f: TFile, filename: string, mode: TFileMode = fmRead): bool {.
proc reopen*(f: File, filename: string, mode: FileMode = fmRead): bool {.
tags: [], gcsafe.}
## reopens the file `f` with given `filename` and `mode`. This
## is often used to redirect the `stdin`, `stdout` or `stderr`
@@ -2288,52 +2321,52 @@ when not defined(JS): #and not defined(NimrodVM):
##
## Default mode is readonly. Returns true iff the file could be reopened.
proc close*(f: TFile) {.importc: "fclose", header: "<stdio.h>", tags: [].}
proc close*(f: File) {.importc: "fclose", header: "<stdio.h>", tags: [].}
## Closes the file.
proc endOfFile*(f: TFile): bool {.tags: [], gcsafe.}
proc endOfFile*(f: File): bool {.tags: [], gcsafe.}
## Returns true iff `f` is at the end.
proc readChar*(f: TFile): char {.
importc: "fgetc", header: "<stdio.h>", tags: [FReadIO].}
proc readChar*(f: File): char {.
importc: "fgetc", header: "<stdio.h>", tags: [ReadIOEffect].}
## Reads a single character from the stream `f`.
proc flushFile*(f: TFile) {.
importc: "fflush", header: "<stdio.h>", tags: [FWriteIO].}
proc flushFile*(f: File) {.
importc: "fflush", header: "<stdio.h>", tags: [WriteIOEffect].}
## Flushes `f`'s buffer.
proc readAll*(file: TFile): TaintedString {.tags: [FReadIO], gcsafe.}
proc readAll*(file: File): TaintedString {.tags: [ReadIOEffect], gcsafe.}
## Reads all data from the stream `file`.
##
## Raises an IO exception in case of an error. It is an error if the
## current file position is not at the beginning of the file.
proc readFile*(filename: string): TaintedString {.tags: [FReadIO], gcsafe.}
proc readFile*(filename: string): TaintedString {.tags: [ReadIOEffect], gcsafe.}
## Opens a file named `filename` for reading. Then calls `readAll`
## and closes the file afterwards. Returns the string.
## Raises an IO exception in case of an error.
proc writeFile*(filename, content: string) {.tags: [FWriteIO], gcsafe.}
proc writeFile*(filename, content: string) {.tags: [WriteIOEffect], gcsafe.}
## Opens a file named `filename` for writing. Then writes the
## `content` completely to the file and closes the file afterwards.
## Raises an IO exception in case of an error.
proc write*(f: TFile, r: float32) {.tags: [FWriteIO], gcsafe.}
proc write*(f: TFile, i: int) {.tags: [FWriteIO], gcsafe.}
proc write*(f: TFile, i: BiggestInt) {.tags: [FWriteIO], gcsafe.}
proc write*(f: TFile, r: BiggestFloat) {.tags: [FWriteIO], gcsafe.}
proc write*(f: TFile, s: string) {.tags: [FWriteIO], gcsafe.}
proc write*(f: TFile, b: bool) {.tags: [FWriteIO], gcsafe.}
proc write*(f: TFile, c: char) {.tags: [FWriteIO], gcsafe.}
proc write*(f: TFile, c: cstring) {.tags: [FWriteIO], gcsafe.}
proc write*(f: TFile, a: varargs[string, `$`]) {.tags: [FWriteIO], gcsafe.}
proc write*(f: File, r: float32) {.tags: [WriteIOEffect], gcsafe.}
proc write*(f: File, i: int) {.tags: [WriteIOEffect], gcsafe.}
proc write*(f: File, i: BiggestInt) {.tags: [WriteIOEffect], gcsafe.}
proc write*(f: File, r: BiggestFloat) {.tags: [WriteIOEffect], gcsafe.}
proc write*(f: File, s: string) {.tags: [WriteIOEffect], gcsafe.}
proc write*(f: File, b: bool) {.tags: [WriteIOEffect], gcsafe.}
proc write*(f: File, c: char) {.tags: [WriteIOEffect], gcsafe.}
proc write*(f: File, c: cstring) {.tags: [WriteIOEffect], gcsafe.}
proc write*(f: File, a: varargs[string, `$`]) {.tags: [WriteIOEffect], gcsafe.}
## Writes a value to the file `f`. May throw an IO exception.
proc readLine*(f: TFile): TaintedString {.tags: [FReadIO], gcsafe.}
proc readLine*(f: File): TaintedString {.tags: [ReadIOEffect], gcsafe.}
## reads a line of text from the file `f`. May throw an IO exception.
## A line of text may be delimited by ``CR``, ``LF`` or
## ``CRLF``. The newline character(s) are not part of the returned string.
proc readLine*(f: TFile, line: var TaintedString): bool {.tags: [FReadIO],
proc readLine*(f: File, line: var TaintedString): bool {.tags: [ReadIOEffect],
gcsafe.}
## reads a line of text from the file `f` into `line`. `line` must not be
## ``nil``! May throw an IO exception.
@@ -2343,63 +2376,63 @@ when not defined(JS): #and not defined(NimrodVM):
## otherwise. If ``false`` is returned `line` contains no new data.
when not defined(booting):
proc writeln*[Ty](f: TFile, x: varargs[Ty, `$`]) {.inline,
tags: [FWriteIO], gcsafe.}
proc writeln*[Ty](f: File, x: varargs[Ty, `$`]) {.inline,
tags: [WriteIOEffect], gcsafe.}
## writes the values `x` to `f` and then writes "\n".
## May throw an IO exception.
else:
proc writeln*[Ty](f: TFile, x: varargs[Ty, `$`]) {.inline,
tags: [FWriteIO].}
proc writeln*[Ty](f: File, x: varargs[Ty, `$`]) {.inline,
tags: [WriteIOEffect].}
proc getFileSize*(f: TFile): int64 {.tags: [FReadIO], gcsafe.}
proc getFileSize*(f: File): int64 {.tags: [ReadIOEffect], gcsafe.}
## retrieves the file size (in bytes) of `f`.
proc readBytes*(f: TFile, a: var openArray[int8], start, len: int): int {.
tags: [FReadIO], gcsafe.}
proc readBytes*(f: File, a: var openArray[int8], start, len: int): int {.
tags: [ReadIOEffect], gcsafe.}
## reads `len` bytes into the buffer `a` starting at ``a[start]``. Returns
## the actual number of bytes that have been read which may be less than
## `len` (if not as many bytes are remaining), but not greater.
proc readChars*(f: TFile, a: var openArray[char], start, len: int): int {.
tags: [FReadIO], gcsafe.}
proc readChars*(f: File, a: var openArray[char], start, len: int): int {.
tags: [ReadIOEffect], gcsafe.}
## reads `len` bytes into the buffer `a` starting at ``a[start]``. Returns
## the actual number of bytes that have been read which may be less than
## `len` (if not as many bytes are remaining), but not greater.
proc readBuffer*(f: TFile, buffer: pointer, len: int): int {.
tags: [FReadIO], gcsafe.}
proc readBuffer*(f: File, buffer: pointer, len: int): int {.
tags: [ReadIOEffect], gcsafe.}
## reads `len` bytes into the buffer pointed to by `buffer`. Returns
## the actual number of bytes that have been read which may be less than
## `len` (if not as many bytes are remaining), but not greater.
proc writeBytes*(f: TFile, a: openArray[int8], start, len: int): int {.
tags: [FWriteIO], gcsafe.}
proc writeBytes*(f: File, a: openArray[int8], start, len: int): int {.
tags: [WriteIOEffect], gcsafe.}
## writes the bytes of ``a[start..start+len-1]`` to the file `f`. Returns
## the number of actual written bytes, which may be less than `len` in case
## of an error.
proc writeChars*(f: TFile, a: openArray[char], start, len: int): int {.
tags: [FWriteIO], gcsafe.}
proc writeChars*(f: File, a: openArray[char], start, len: int): int {.
tags: [WriteIOEffect], gcsafe.}
## writes the bytes of ``a[start..start+len-1]`` to the file `f`. Returns
## the number of actual written bytes, which may be less than `len` in case
## of an error.
proc writeBuffer*(f: TFile, buffer: pointer, len: int): int {.
tags: [FWriteIO], gcsafe.}
proc writeBuffer*(f: File, buffer: pointer, len: int): int {.
tags: [WriteIOEffect], gcsafe.}
## writes the bytes of buffer pointed to by the parameter `buffer` to the
## file `f`. Returns the number of actual written bytes, which may be less
## than `len` in case of an error.
proc setFilePos*(f: TFile, pos: int64) {.gcsafe.}
proc setFilePos*(f: File, pos: int64) {.gcsafe.}
## sets the position of the file pointer that is used for read/write
## operations. The file's first byte has the index zero.
proc getFilePos*(f: TFile): int64 {.gcsafe.}
proc getFilePos*(f: File): int64 {.gcsafe.}
## retrieves the current position of the file pointer that is used to
## read from the file `f`. The file's first byte has the index zero.
proc fileHandle*(f: TFile): TFileHandle {.importc: "fileno",
header: "<stdio.h>"}
proc getFileHandle*(f: File): FileHandle {.importc: "fileno",
header: "<stdio.h>"}
## returns the OS file handle of the file ``f``. This is only useful for
## platform specific programming.
@@ -2454,7 +2487,7 @@ when not defined(JS): #and not defined(NimrodVM):
status: int
context: C_JmpBuf
hasRaiseAction: bool
raiseAction: proc (e: ref E_Base): bool {.closure.}
raiseAction: proc (e: ref Exception): bool {.closure.}
when declared(initAllocator):
initAllocator()
@@ -2470,14 +2503,14 @@ when not defined(JS): #and not defined(NimrodVM):
## allows you to override the behaviour of your application when CTRL+C
## is pressed. Only one such hook is supported.
proc writeStackTrace*() {.tags: [FWriteIO].}
proc writeStackTrace*() {.tags: [WriteIOEffect].}
## writes the current stack trace to ``stderr``. This is only works
## for debug builds.
when hostOS != "standalone":
proc getStackTrace*(): string
## gets the current stack trace. This only works for debug builds.
proc getStackTrace*(e: ref E_Base): string
proc getStackTrace*(e: ref Exception): string
## gets the stack trace associated with `e`, which is the stack that
## lead to the ``raise`` statement. This only works for debug builds.
@@ -2505,7 +2538,7 @@ when not defined(JS): #and not defined(NimrodVM):
proc getDiscriminant(aa: pointer, n: ptr TNimNode): int =
sysAssert(n.kind == nkCase, "getDiscriminant: node != nkCase")
var d: int
var a = cast[TAddress](aa)
var a = cast[ByteAddress](aa)
case n.typ.size
of 1: d = ze(cast[ptr int8](a +% n.offset)[])
of 2: d = ze(cast[ptr int16](a +% n.offset)[])
@@ -2534,7 +2567,7 @@ when not defined(JS): #and not defined(NimrodVM):
include "system/sysio"
when hostOS != "standalone":
iterator lines*(filename: string): TaintedString {.tags: [FReadIO].} =
iterator lines*(filename: string): TaintedString {.tags: [ReadIOEffect].} =
## Iterates over any line in the file named `filename`.
##
## If the file does not exist `EIO` is raised. The trailing newline
@@ -2553,14 +2586,14 @@ when not defined(JS): #and not defined(NimrodVM):
while f.readLine(res): yield res
close(f)
iterator lines*(f: TFile): TaintedString {.tags: [FReadIO].} =
iterator lines*(f: File): TaintedString {.tags: [ReadIOEffect].} =
## Iterate over any line in the file `f`.
##
## The trailing newline character(s) are removed from the iterated lines.
## Example:
##
## .. code-block:: nimrod
## proc countZeros(filename: TFile): tuple[lines, zeros: int] =
## proc countZeros(filename: File): tuple[lines, zeros: int] =
## for line in filename.lines:
## for letter in line:
## if letter == '0':
@@ -2573,7 +2606,7 @@ when not defined(JS): #and not defined(NimrodVM):
include "system/assign"
include "system/repr"
proc getCurrentException*(): ref E_Base {.compilerRtl, inl, gcsafe.} =
proc getCurrentException*(): ref Exception {.compilerRtl, inl, gcsafe.} =
## retrieves the current exception; if there is none, nil is returned.
result = currException
@@ -2583,7 +2616,7 @@ when not defined(JS): #and not defined(NimrodVM):
var e = getCurrentException()
return if e == nil: "" else: e.msg
proc onRaise*(action: proc(e: ref E_Base): bool{.closure.}) =
proc onRaise*(action: proc(e: ref Exception): bool{.closure.}) =
## can be used in a ``try`` statement to setup a Lisp-like
## `condition system`:idx:\: This prevents the 'raise' statement to
## raise an exception but instead calls ``action``.
@@ -2721,11 +2754,11 @@ template spliceImpl(s, a, L, b: expr): stmt {.immediate.} =
for i in 0 .. <b.len: s[i+a] = b[i]
when hostOS != "standalone":
proc `[]`*(s: string, x: TSlice[int]): string {.inline.} =
proc `[]`*(s: string, x: Slice[int]): string {.inline.} =
## slice operation for strings. Negative indexes are supported.
result = s.substr(x.a-|s, x.b-|s)
proc `[]=`*(s: var string, x: TSlice[int], b: string) =
proc `[]=`*(s: var string, x: Slice[int], b: string) =
## slice assignment for strings. Negative indexes are supported. If
## ``b.len`` is not exactly the number of elements that are referred to
## by `x`, a `splice`:idx: is performed:
@@ -2741,7 +2774,7 @@ when hostOS != "standalone":
else:
spliceImpl(s, a, L, b)
proc `[]`*[Idx, T](a: array[Idx, T], x: TSlice[int]): seq[T] =
proc `[]`*[Idx, T](a: array[Idx, T], x: Slice[int]): seq[T] =
## slice operation for arrays. Negative indexes are **not** supported
## because the array might have negative bounds.
when low(a) < 0:
@@ -2750,7 +2783,7 @@ proc `[]`*[Idx, T](a: array[Idx, T], x: TSlice[int]): seq[T] =
newSeq(result, L)
for i in 0.. <L: result[i] = a[i + x.a]
proc `[]=`*[Idx, T](a: var array[Idx, T], x: TSlice[int], b: openArray[T]) =
proc `[]=`*[Idx, T](a: var array[Idx, T], x: Slice[int], b: openArray[T]) =
## slice assignment for arrays. Negative indexes are **not** supported
## because the array might have negative bounds.
when low(a) < 0:
@@ -2759,9 +2792,9 @@ proc `[]=`*[Idx, T](a: var array[Idx, T], x: TSlice[int], b: openArray[T]) =
if L == b.len:
for i in 0 .. <L: a[i+x.a] = b[i]
else:
sysFatal(EOutOfRange, "different lengths for slice assignment")
sysFatal(RangeError, "different lengths for slice assignment")
proc `[]`*[Idx, T](a: array[Idx, T], x: TSlice[Idx]): seq[T] =
proc `[]`*[Idx, T](a: array[Idx, T], x: Slice[Idx]): seq[T] =
## slice operation for arrays. Negative indexes are **not** supported
## because the array might have negative bounds.
var L = ord(x.b) - ord(x.a) + 1
@@ -2771,7 +2804,7 @@ proc `[]`*[Idx, T](a: array[Idx, T], x: TSlice[Idx]): seq[T] =
result[i] = a[j]
inc(j)
proc `[]=`*[Idx, T](a: var array[Idx, T], x: TSlice[Idx], b: openArray[T]) =
proc `[]=`*[Idx, T](a: var array[Idx, T], x: Slice[Idx], b: openArray[T]) =
## slice assignment for arrays. Negative indexes are **not** supported
## because the array might have negative bounds.
var L = ord(x.b) - ord(x.a) + 1
@@ -2781,16 +2814,16 @@ proc `[]=`*[Idx, T](a: var array[Idx, T], x: TSlice[Idx], b: openArray[T]) =
a[j] = b[i]
inc(j)
else:
sysFatal(EOutOfRange, "different lengths for slice assignment")
sysFatal(RangeError, "different lengths for slice assignment")
proc `[]`*[T](s: seq[T], x: TSlice[int]): seq[T] =
proc `[]`*[T](s: seq[T], x: Slice[int]): seq[T] =
## slice operation for sequences. Negative indexes are supported.
var a = x.a-|s
var L = x.b-|s - a + 1
newSeq(result, L)
for i in 0.. <L: result[i] = s[i + a]
proc `[]=`*[T](s: var seq[T], x: TSlice[int], b: openArray[T]) =
proc `[]=`*[T](s: var seq[T], x: Slice[int], b: openArray[T]) =
## slice assignment for sequences. Negative indexes are supported. If
## ``b.len`` is not exactly the number of elements that are referred to
## by `x`, a `splice`:idx: is performed.
@@ -2830,13 +2863,13 @@ proc staticExec*(command: string, input = ""): string {.
## inside a pragma like `passC <nimrodc.html#passc-pragma>`_ or `passL
## <nimrodc.html#passl-pragma>`_.
proc `+=`*[T: TOrdinal|uint|uint64](x: var T, y: T) {.magic: "Inc", noSideEffect.}
proc `+=`*[T: SomeOrdinal|uint|uint64](x: var T, y: T) {.magic: "Inc", noSideEffect.}
## Increments an ordinal
proc `-=`*[T: TOrdinal|uint|uint64](x: var T, y: T) {.magic: "Dec", noSideEffect.}
proc `-=`*[T: SomeOrdinal|uint|uint64](x: var T, y: T) {.magic: "Dec", noSideEffect.}
## Decrements an ordinal
proc `*=`*[T: TOrdinal|uint|uint64](x: var T, y: T) {.inline, noSideEffect.} =
proc `*=`*[T: SomeOrdinal|uint|uint64](x: var T, y: T) {.inline, noSideEffect.} =
## Binary `*=` operator for ordinals
x = x * y
@@ -2897,7 +2930,7 @@ template currentSourcePath*: string = instantiationInfo(-1, true).filename
## returns the full file-system path of the current source
proc raiseAssert*(msg: string) {.noinline.} =
sysFatal(EAssertionFailed, msg)
sysFatal(AssertionError, msg)
when true:
proc failedAssertImpl*(msg: string) {.raises: [], tags: [].} =
@@ -3046,7 +3079,7 @@ when hostOS != "standalone":
if x == nil: x = y
else: x.add(y)
proc locals*(): TObject {.magic: "Locals", noSideEffect.} =
proc locals*(): RootObj {.magic: "Locals", noSideEffect.} =
## generates a tuple constructor expression listing all the local variables
## in the current scope. This is quite fast as it does not rely
## on any debug or runtime information. Note that in constrast to what

70
lib/system/alloc.nim
View File

@@ -218,7 +218,7 @@ proc llAlloc(a: var TMemRegion, size: int): pointer =
a.llmem.size = PageSize - sizeof(TLLChunk)
a.llmem.acc = sizeof(TLLChunk)
a.llmem.next = old
result = cast[pointer](cast[TAddress](a.llmem) + a.llmem.acc)
result = cast[pointer](cast[ByteAddress](a.llmem) + a.llmem.acc)
dec(a.llmem.size, size)
inc(a.llmem.acc, size)
zeroMem(result, size)
@@ -321,7 +321,7 @@ iterator allObjects(m: TMemRegion): pointer {.inline.} =
var c = cast[PSmallChunk](c)
let size = c.size
var a = cast[TAddress](addr(c.data))
var a = cast[ByteAddress](addr(c.data))
let limit = a + c.acc
while a <% limit:
yield cast[pointer](a)
@@ -335,27 +335,27 @@ proc isCell(p: pointer): bool {.inline.} =
# ------------- chunk management ----------------------------------------------
proc pageIndex(c: PChunk): int {.inline.} =
result = cast[TAddress](c) shr PageShift
result = cast[ByteAddress](c) shr PageShift
proc pageIndex(p: pointer): int {.inline.} =
result = cast[TAddress](p) shr PageShift
result = cast[ByteAddress](p) shr PageShift
proc pageAddr(p: pointer): PChunk {.inline.} =
result = cast[PChunk](cast[TAddress](p) and not PageMask)
result = cast[PChunk](cast[ByteAddress](p) and not PageMask)
#sysAssert(Contains(allocator.chunkStarts, pageIndex(result)))
proc requestOsChunks(a: var TMemRegion, size: int): PBigChunk =
incCurrMem(a, size)
inc(a.freeMem, size)
result = cast[PBigChunk](osAllocPages(size))
sysAssert((cast[TAddress](result) and PageMask) == 0, "requestOsChunks 1")
sysAssert((cast[ByteAddress](result) and PageMask) == 0, "requestOsChunks 1")
#zeroMem(result, size)
result.next = nil
result.prev = nil
result.used = false
result.size = size
# update next.prevSize:
var nxt = cast[TAddress](result) +% size
var nxt = cast[ByteAddress](result) +% size
sysAssert((nxt and PageMask) == 0, "requestOsChunks 2")
var next = cast[PChunk](nxt)
if pageIndex(next) in a.chunkStarts:
@@ -363,7 +363,7 @@ proc requestOsChunks(a: var TMemRegion, size: int): PBigChunk =
next.prevSize = size
# set result.prevSize:
var lastSize = if a.lastSize != 0: a.lastSize else: PageSize
var prv = cast[TAddress](result) -% lastSize
var prv = cast[ByteAddress](result) -% lastSize
sysAssert((nxt and PageMask) == 0, "requestOsChunks 3")
var prev = cast[PChunk](prv)
if pageIndex(prev) in a.chunkStarts and prev.size == lastSize:
@@ -376,7 +376,7 @@ proc requestOsChunks(a: var TMemRegion, size: int): PBigChunk =
proc freeOsChunks(a: var TMemRegion, p: pointer, size: int) =
# update next.prevSize:
var c = cast[PChunk](p)
var nxt = cast[TAddress](p) +% c.size
var nxt = cast[ByteAddress](p) +% c.size
sysAssert((nxt and PageMask) == 0, "freeOsChunks")
var next = cast[PChunk](nxt)
if pageIndex(next) in a.chunkStarts:
@@ -429,8 +429,8 @@ proc listRemove[T](head: var T, c: T) {.inline.} =
proc updatePrevSize(a: var TMemRegion, c: PBigChunk,
prevSize: int) {.inline.} =
var ri = cast[PChunk](cast[TAddress](c) +% c.size)
sysAssert((cast[TAddress](ri) and PageMask) == 0, "updatePrevSize")
var ri = cast[PChunk](cast[ByteAddress](c) +% c.size)
sysAssert((cast[ByteAddress](ri) and PageMask) == 0, "updatePrevSize")
if isAccessible(a, ri):
ri.prevSize = prevSize
@@ -439,8 +439,8 @@ proc freeBigChunk(a: var TMemRegion, c: PBigChunk) =
sysAssert(c.size >= PageSize, "freeBigChunk")
inc(a.freeMem, c.size)
when coalescRight:
var ri = cast[PChunk](cast[TAddress](c) +% c.size)
sysAssert((cast[TAddress](ri) and PageMask) == 0, "freeBigChunk 2")
var ri = cast[PChunk](cast[ByteAddress](c) +% c.size)
sysAssert((cast[ByteAddress](ri) and PageMask) == 0, "freeBigChunk 2")
if isAccessible(a, ri) and chunkUnused(ri):
sysAssert(not isSmallChunk(ri), "freeBigChunk 3")
if not isSmallChunk(ri):
@@ -449,8 +449,8 @@ proc freeBigChunk(a: var TMemRegion, c: PBigChunk) =
excl(a.chunkStarts, pageIndex(ri))
when coalescLeft:
if c.prevSize != 0:
var le = cast[PChunk](cast[TAddress](c) -% c.prevSize)
sysAssert((cast[TAddress](le) and PageMask) == 0, "freeBigChunk 4")
var le = cast[PChunk](cast[ByteAddress](c) -% c.prevSize)
sysAssert((cast[ByteAddress](le) and PageMask) == 0, "freeBigChunk 4")
if isAccessible(a, le) and chunkUnused(le):
sysAssert(not isSmallChunk(le), "freeBigChunk 5")
if not isSmallChunk(le):
@@ -468,7 +468,7 @@ proc freeBigChunk(a: var TMemRegion, c: PBigChunk) =
freeOsChunks(a, c, c.size)
proc splitChunk(a: var TMemRegion, c: PBigChunk, size: int) =
var rest = cast[PBigChunk](cast[TAddress](c) +% size)
var rest = cast[PBigChunk](cast[ByteAddress](c) +% size)
sysAssert(rest notin a.freeChunksList, "splitChunk")
rest.size = c.size - size
rest.used = false
@@ -559,7 +559,7 @@ proc rawAlloc(a: var TMemRegion, requestedSize: int): pointer =
c.prev = nil
listAdd(a.freeSmallChunks[s], c)
result = addr(c.data)
sysAssert((cast[TAddress](result) and (MemAlign-1)) == 0, "rawAlloc 4")
sysAssert((cast[ByteAddress](result) and (MemAlign-1)) == 0, "rawAlloc 4")
else:
sysAssert(allocInv(a), "rawAlloc: begin c != nil")
sysAssert c.next != c, "rawAlloc 5"
@@ -569,21 +569,21 @@ proc rawAlloc(a: var TMemRegion, requestedSize: int): pointer =
if c.freeList == nil:
sysAssert(c.acc + smallChunkOverhead() + size <= SmallChunkSize,
"rawAlloc 7")
result = cast[pointer](cast[TAddress](addr(c.data)) +% c.acc)
result = cast[pointer](cast[ByteAddress](addr(c.data)) +% c.acc)
inc(c.acc, size)
else:
result = c.freeList
sysAssert(c.freeList.zeroField == 0, "rawAlloc 8")
c.freeList = c.freeList.next
dec(c.free, size)
sysAssert((cast[TAddress](result) and (MemAlign-1)) == 0, "rawAlloc 9")
sysAssert((cast[ByteAddress](result) and (MemAlign-1)) == 0, "rawAlloc 9")
sysAssert(allocInv(a), "rawAlloc: end c != nil")
sysAssert(allocInv(a), "rawAlloc: before c.free < size")
if c.free < size:
sysAssert(allocInv(a), "rawAlloc: before listRemove test")
listRemove(a.freeSmallChunks[s], c)
sysAssert(allocInv(a), "rawAlloc: end listRemove test")
sysAssert(((cast[TAddress](result) and PageMask) - smallChunkOverhead()) %%
sysAssert(((cast[ByteAddress](result) and PageMask) - smallChunkOverhead()) %%
size == 0, "rawAlloc 21")
sysAssert(allocInv(a), "rawAlloc: end small size")
else:
@@ -594,9 +594,9 @@ proc rawAlloc(a: var TMemRegion, requestedSize: int): pointer =
sysAssert c.next == nil, "rawAlloc 11"
sysAssert c.size == size, "rawAlloc 12"
result = addr(c.data)
sysAssert((cast[TAddress](result) and (MemAlign-1)) == 0, "rawAlloc 13")
sysAssert((cast[ByteAddress](result) and (MemAlign-1)) == 0, "rawAlloc 13")
if a.root == nil: a.root = bottom
add(a, a.root, cast[TAddress](result), cast[TAddress](result)+%size)
add(a, a.root, cast[ByteAddress](result), cast[TAddress](result)+%size)
sysAssert(isAccessible(a, result), "rawAlloc 14")
sysAssert(allocInv(a), "rawAlloc: end")
when logAlloc: cprintf("rawAlloc: %ld %p\n", requestedSize, result)
@@ -613,7 +613,7 @@ proc rawDealloc(a: var TMemRegion, p: pointer) =
# `p` is within a small chunk:
var c = cast[PSmallChunk](c)
var s = c.size
sysAssert(((cast[TAddress](p) and PageMask) - smallChunkOverhead()) %%
sysAssert(((cast[ByteAddress](p) and PageMask) - smallChunkOverhead()) %%
s == 0, "rawDealloc 3")
var f = cast[ptr TFreeCell](p)
#echo("setting to nil: ", $cast[TAddress](addr(f.zeroField)))
@@ -636,7 +636,7 @@ proc rawDealloc(a: var TMemRegion, p: pointer) =
listRemove(a.freeSmallChunks[s div MemAlign], c)
c.size = SmallChunkSize
freeBigChunk(a, cast[PBigChunk](c))
sysAssert(((cast[TAddress](p) and PageMask) - smallChunkOverhead()) %%
sysAssert(((cast[ByteAddress](p) and PageMask) - smallChunkOverhead()) %%
s == 0, "rawDealloc 2")
else:
# set to 0xff to check for usage after free bugs:
@@ -655,7 +655,7 @@ proc isAllocatedPtr(a: TMemRegion, p: pointer): bool =
if not chunkUnused(c):
if isSmallChunk(c):
var c = cast[PSmallChunk](c)
var offset = (cast[TAddress](p) and (PageSize-1)) -%
var offset = (cast[ByteAddress](p) and (PageSize-1)) -%
smallChunkOverhead()
result = (c.acc >% offset) and (offset %% c.size == 0) and
(cast[ptr TFreeCell](p).zeroField >% 1)
@@ -673,12 +673,12 @@ proc interiorAllocatedPtr(a: TMemRegion, p: pointer): pointer =
if not chunkUnused(c):
if isSmallChunk(c):
var c = cast[PSmallChunk](c)
var offset = (cast[TAddress](p) and (PageSize-1)) -%
var offset = (cast[ByteAddress](p) and (PageSize-1)) -%
smallChunkOverhead()
if c.acc >% offset:
sysAssert(cast[TAddress](addr(c.data)) +% offset ==
cast[TAddress](p), "offset is not what you think it is")
var d = cast[ptr TFreeCell](cast[TAddress](addr(c.data)) +%
sysAssert(cast[ByteAddress](addr(c.data)) +% offset ==
cast[ByteAddress](p), "offset is not what you think it is")
var d = cast[ptr TFreeCell](cast[ByteAddress](addr(c.data)) +%
offset -% (offset %% c.size))
if d.zeroField >% 1:
result = d
@@ -704,7 +704,7 @@ proc interiorAllocatedPtr(a: TMemRegion, p: pointer): pointer =
sysAssert isAllocatedPtr(a, result), " result wrong pointer!"
proc ptrSize(p: pointer): int =
var x = cast[pointer](cast[TAddress](p) -% sizeof(TFreeCell))
var x = cast[pointer](cast[ByteAddress](p) -% sizeof(TFreeCell))
var c = pageAddr(p)
sysAssert(not chunkUnused(c), "ptrSize")
result = c.size -% sizeof(TFreeCell)
@@ -715,7 +715,7 @@ proc alloc(allocator: var TMemRegion, size: int): pointer =
result = rawAlloc(allocator, size+sizeof(TFreeCell))
cast[ptr TFreeCell](result).zeroField = 1 # mark it as used
sysAssert(not isAllocatedPtr(allocator, result), "alloc")
result = cast[pointer](cast[TAddress](result) +% sizeof(TFreeCell))
result = cast[pointer](cast[ByteAddress](result) +% sizeof(TFreeCell))
proc alloc0(allocator: var TMemRegion, size: int): pointer =
result = alloc(allocator, size)
@@ -723,7 +723,7 @@ proc alloc0(allocator: var TMemRegion, size: int): pointer =
proc dealloc(allocator: var TMemRegion, p: pointer) =
sysAssert(p != nil, "dealloc 0")
var x = cast[pointer](cast[TAddress](p) -% sizeof(TFreeCell))
var x = cast[pointer](cast[ByteAddress](p) -% sizeof(TFreeCell))
sysAssert(x != nil, "dealloc 1")
sysAssert(isAccessible(allocator, x), "is not accessible")
sysAssert(cast[ptr TFreeCell](x).zeroField == 1, "dealloc 2")
@@ -769,7 +769,7 @@ template instantiateForRegion(allocator: expr) =
result = interiorAllocatedPtr(allocator, p)
proc isAllocatedPtr*(p: pointer): bool =
let p = cast[pointer](cast[TAddress](p)-%TAddress(sizeof(TCell)))
let p = cast[pointer](cast[ByteAddress](p)-%TAddress(sizeof(TCell)))
result = isAllocatedPtr(allocator, p)
proc deallocOsPages = deallocOsPages(allocator)
@@ -784,7 +784,7 @@ template instantiateForRegion(allocator: expr) =
dealloc(allocator, p)
proc realloc(p: pointer, newsize: int): pointer =
result = realloc(allocator, p, newsize)
result = realloc(allocator, p, newSize)
when false:
proc countFreeMem(): int =
@@ -833,7 +833,7 @@ template instantiateForRegion(allocator: expr) =
result = realloc(sharedHeap, p, newsize)
releaseSys(heapLock)
else:
result = realloc(p, newsize)
result = realloc(p, newSize)
when hasThreadSupport:

10
lib/system/arithm.nim
View File

@@ -12,10 +12,10 @@
proc raiseOverflow {.compilerproc, noinline, noreturn.} =
# a single proc to reduce code size to a minimum
sysFatal(EOverflow, "over- or underflow")
sysFatal(OverflowError, "over- or underflow")
proc raiseDivByZero {.compilerproc, noinline, noreturn.} =
sysFatal(EDivByZero, "divison by zero")
sysFatal(DivByZeroError, "divison by zero")
proc addInt64(a, b: int64): int64 {.compilerProc, inline.} =
result = a +% b
@@ -328,16 +328,16 @@ when not declared(mulInt):
# written in other languages.
proc raiseFloatInvalidOp {.noinline, noreturn.} =
sysFatal(EFloatInvalidOp, "FPU operation caused a NaN result")
sysFatal(FloatInvalidOpError, "FPU operation caused a NaN result")
proc nanCheck(x: float64) {.compilerProc, inline.} =
if x != x: raiseFloatInvalidOp()
proc raiseFloatOverflow(x: float64) {.noinline, noreturn.} =
if x > 0.0:
sysFatal(EFloatOverflow, "FPU operation caused an overflow")
sysFatal(FloatOverflowError, "FPU operation caused an overflow")
else:
sysFatal(EFloatUnderflow, "FPU operations caused an underflow")
sysFatal(FloatUnderflowError, "FPU operations caused an underflow")
proc infCheck(x: float64) {.compilerProc, inline.} =
if x != 0.0 and x*0.5 == x: raiseFloatOverflow(x)

26
lib/system/assign.nim
View File

@@ -13,8 +13,8 @@ proc genericAssignAux(dest, src: pointer, mt: PNimType, shallow: bool) {.gcsafe.
proc genericAssignAux(dest, src: pointer, n: ptr TNimNode,
shallow: bool) {.gcsafe.} =
var
d = cast[TAddress](dest)
s = cast[TAddress](src)
d = cast[ByteAddress](dest)
s = cast[ByteAddress](src)
case n.kind
of nkSlot:
genericAssignAux(cast[pointer](d +% n.offset),
@@ -40,8 +40,8 @@ proc genericAssignAux(dest, src: pointer, n: ptr TNimNode,
proc genericAssignAux(dest, src: pointer, mt: PNimType, shallow: bool) =
var
d = cast[TAddress](dest)
s = cast[TAddress](src)
d = cast[ByteAddress](dest)
s = cast[ByteAddress](src)
sysAssert(mt != nil, "genericAssignAux 2")
case mt.kind
of tyString:
@@ -62,11 +62,11 @@ proc genericAssignAux(dest, src: pointer, mt: PNimType, shallow: bool) =
return
sysAssert(dest != nil, "genericAssignAux 3")
unsureAsgnRef(x, newSeq(mt, seq.len))
var dst = cast[TAddress](cast[PPointer](dest)[])
var dst = cast[ByteAddress](cast[PPointer](dest)[])
for i in 0..seq.len-1:
genericAssignAux(
cast[pointer](dst +% i*% mt.base.size +% GenericSeqSize),
cast[pointer](cast[TAddress](s2) +% i *% mt.base.size +%
cast[pointer](cast[ByteAddress](s2) +% i *% mt.base.size +%
GenericSeqSize),
mt.base, shallow)
of tyObject:
@@ -130,15 +130,15 @@ proc genericSeqAssign(dest, src: pointer, mt: PNimType) {.compilerProc.} =
proc genericAssignOpenArray(dest, src: pointer, len: int,
mt: PNimType) {.compilerproc.} =
var
d = cast[TAddress](dest)
s = cast[TAddress](src)
d = cast[ByteAddress](dest)
s = cast[ByteAddress](src)
for i in 0..len-1:
genericAssign(cast[pointer](d +% i*% mt.base.size),
cast[pointer](s +% i*% mt.base.size), mt.base)
proc objectInit(dest: pointer, typ: PNimType) {.compilerProc, gcsafe.}
proc objectInitAux(dest: pointer, n: ptr TNimNode) {.gcsafe.} =
var d = cast[TAddress](dest)
var d = cast[ByteAddress](dest)
case n.kind
of nkNone: sysAssert(false, "objectInitAux")
of nkSlot: objectInit(cast[pointer](d +% n.offset), n.typ)
@@ -152,7 +152,7 @@ proc objectInitAux(dest: pointer, n: ptr TNimNode) {.gcsafe.} =
proc objectInit(dest: pointer, typ: PNimType) =
# the generic init proc that takes care of initialization of complex
# objects on the stack or heap
var d = cast[TAddress](dest)
var d = cast[ByteAddress](dest)
case typ.kind
of tyObject:
# iterate over any structural type
@@ -184,7 +184,7 @@ else:
proc genericReset(dest: pointer, mt: PNimType) {.compilerProc, gcsafe.}
proc genericResetAux(dest: pointer, n: ptr TNimNode) =
var d = cast[TAddress](dest)
var d = cast[ByteAddress](dest)
case n.kind
of nkNone: sysAssert(false, "genericResetAux")
of nkSlot: genericReset(cast[pointer](d +% n.offset), n.typ)
@@ -196,7 +196,7 @@ proc genericResetAux(dest: pointer, n: ptr TNimNode) =
zeroMem(cast[pointer](d +% n.offset), n.typ.size)
proc genericReset(dest: pointer, mt: PNimType) =
var d = cast[TAddress](dest)
var d = cast[ByteAddress](dest)
sysAssert(mt != nil, "genericReset 2")
case mt.kind
of tyString, tyRef, tySequence:
@@ -223,4 +223,4 @@ proc FieldDiscriminantCheck(oldDiscVal, newDiscVal: int,
var oldBranch = selectBranch(oldDiscVal, L, a)
var newBranch = selectBranch(newDiscVal, L, a)
if newBranch != oldBranch and oldDiscVal != 0:
sysFatal(EInvalidField, "assignment to discriminant changes object branch")
sysFatal(FieldError, "assignment to discriminant changes object branch")

14
lib/system/cellsets.nim
View File

@@ -27,7 +27,7 @@ type
TBitIndex = range[0..UnitsPerPage-1]
TPageDesc {.final, pure.} = object
next: PPageDesc # all nodes are connected with this pointer
key: TAddress # start address at bit 0
key: ByteAddress # start address at bit 0
bits: array[TBitIndex, int] # a bit vector
PPageDescArray = ptr array[0..1000_000, PPageDesc]
@@ -98,7 +98,7 @@ proc nextTry(h, maxHash: int): int {.inline.} =
# generates each int in range(maxHash) exactly once (see any text on
# random-number generation for proof).
proc cellSetGet(t: TCellSet, key: TAddress): PPageDesc =
proc cellSetGet(t: TCellSet, key: ByteAddress): PPageDesc =
var h = cast[int](key) and t.max
while t.data[h] != nil:
if t.data[h].key == key: return t.data[h]
@@ -123,7 +123,7 @@ proc cellSetEnlarge(t: var TCellSet) =
dealloc(t.data)
t.data = n
proc cellSetPut(t: var TCellSet, key: TAddress): PPageDesc =
proc cellSetPut(t: var TCellSet, key: ByteAddress): PPageDesc =
var h = cast[int](key) and t.max
while true:
var x = t.data[h]
@@ -147,7 +147,7 @@ proc cellSetPut(t: var TCellSet, key: TAddress): PPageDesc =
# ---------- slightly higher level procs --------------------------------------
proc contains(s: TCellSet, cell: PCell): bool =
var u = cast[TAddress](cell)
var u = cast[ByteAddress](cell)
var t = cellSetGet(s, u shr PageShift)
if t != nil:
u = (u %% PageSize) /% MemAlign
@@ -156,13 +156,13 @@ proc contains(s: TCellSet, cell: PCell): bool =
result = false
proc incl(s: var TCellSet, cell: PCell) {.noinline.} =
var u = cast[TAddress](cell)
var u = cast[ByteAddress](cell)
var t = cellSetPut(s, u shr PageShift)
u = (u %% PageSize) /% MemAlign
t.bits[u shr IntShift] = t.bits[u shr IntShift] or (1 shl (u and IntMask))
proc excl(s: var TCellSet, cell: PCell) =
var u = cast[TAddress](cell)
var u = cast[ByteAddress](cell)
var t = cellSetGet(s, u shr PageShift)
if t != nil:
u = (u %% PageSize) /% MemAlign
@@ -170,7 +170,7 @@ proc excl(s: var TCellSet, cell: PCell) =
not (1 shl (u and IntMask)))
proc containsOrIncl(s: var TCellSet, cell: PCell): bool =
var u = cast[TAddress](cell)
var u = cast[ByteAddress](cell)
var t = cellSetGet(s, u shr PageShift)
if t != nil:
u = (u %% PageSize) /% MemAlign

14
lib/system/chcks.nim
View File

@@ -13,13 +13,13 @@ proc raiseRangeError(val: BiggestInt) {.compilerproc, noreturn, noinline.} =
when hostOS == "standalone":
sysFatal(EOutOfRange, "value out of range")
else:
sysFatal(EOutOfRange, "value out of range: ", $val)
sysFatal(RangeError, "value out of range: ", $val)
proc raiseIndexError() {.compilerproc, noreturn, noinline.} =
sysFatal(EInvalidIndex, "index out of bounds")
sysFatal(IndexError, "index out of bounds")
proc raiseFieldError(f: string) {.compilerproc, noreturn, noinline.} =
sysFatal(EInvalidField, f, " is not accessible")
sysFatal(FieldError, f, " is not accessible")
proc chckIndx(i, a, b: int): int =
if i >= a and i <= b:
@@ -46,11 +46,11 @@ proc chckRangeF(x, a, b: float): float =
when hostOS == "standalone":
sysFatal(EOutOfRange, "value out of range")
else:
sysFatal(EOutOfRange, "value out of range: ", $x)
sysFatal(RangeError, "value out of range: ", $x)
proc chckNil(p: pointer) =
if p == nil:
sysFatal(EInvalidValue, "attempt to write to a nil address")
sysFatal(ValueError, "attempt to write to a nil address")
#c_raise(SIGSEGV)
proc chckObj(obj, subclass: PNimType) {.compilerproc.} =
@@ -59,13 +59,13 @@ proc chckObj(obj, subclass: PNimType) {.compilerproc.} =
if x == subclass: return # optimized fast path
while x != subclass:
if x == nil:
sysFatal(EInvalidObjectConversion, "invalid object conversion")
sysFatal(ObjectConversionError, "invalid object conversion")
break
x = x.base
proc chckObjAsgn(a, b: PNimType) {.compilerproc, inline.} =
if a != b:
sysFatal(EInvalidObjectAssignment, "invalid object assignment")
sysFatal(ObjectAssignmentError, "invalid object assignment")
type ObjCheckCache = array[0..1, PNimType]

24
lib/system/deepcopy.nim
View File

@@ -10,8 +10,8 @@
proc genericDeepCopyAux(dest, src: pointer, mt: PNimType) {.gcsafe.}
proc genericDeepCopyAux(dest, src: pointer, n: ptr TNimNode) {.gcsafe.} =
var
d = cast[TAddress](dest)
s = cast[TAddress](src)
d = cast[ByteAddress](dest)
s = cast[ByteAddress](src)
case n.kind
of nkSlot:
genericDeepCopyAux(cast[pointer](d +% n.offset),
@@ -40,8 +40,8 @@ proc copyDeepString(src: NimString): NimString {.inline.} =
proc genericDeepCopyAux(dest, src: pointer, mt: PNimType) =
var
d = cast[TAddress](dest)
s = cast[TAddress](src)
d = cast[ByteAddress](dest)
s = cast[ByteAddress](src)
sysAssert(mt != nil, "genericDeepCopyAux 2")
case mt.kind
of tyString:
@@ -60,11 +60,11 @@ proc genericDeepCopyAux(dest, src: pointer, mt: PNimType) =
return
sysAssert(dest != nil, "genericDeepCopyAux 3")
unsureAsgnRef(x, newSeq(mt, seq.len))
var dst = cast[TAddress](cast[PPointer](dest)[])
var dst = cast[ByteAddress](cast[PPointer](dest)[])
for i in 0..seq.len-1:
genericDeepCopyAux(
cast[pointer](dst +% i*% mt.base.size +% GenericSeqSize),
cast[pointer](cast[TAddress](s2) +% i *% mt.base.size +%
cast[pointer](cast[ByteAddress](s2) +% i *% mt.base.size +%
GenericSeqSize),
mt.base)
of tyObject:
@@ -82,8 +82,8 @@ proc genericDeepCopyAux(dest, src: pointer, mt: PNimType) =
genericDeepCopyAux(cast[pointer](d +% i*% mt.base.size),
cast[pointer](s +% i*% mt.base.size), mt.base)
of tyRef:
if mt.base.deepCopy != nil:
let z = mt.base.deepCopy(cast[PPointer](src)[])
if mt.base.deepcopy != nil:
let z = mt.base.deepcopy(cast[PPointer](src)[])
unsureAsgnRef(cast[PPointer](dest), z)
else:
# we modify the header of the cell temporarily; instead of the type
@@ -116,8 +116,8 @@ proc genericDeepCopyAux(dest, src: pointer, mt: PNimType) =
genericDeepCopyAux(z, s2, realType.base)
of tyPtr:
# no cycle check here, but also not really required
if mt.base.deepCopy != nil:
cast[PPointer](dest)[] = mt.base.deepCopy(cast[PPointer](s)[])
if mt.base.deepcopy != nil:
cast[PPointer](dest)[] = mt.base.deepcopy(cast[PPointer](s)[])
else:
cast[PPointer](dest)[] = cast[PPointer](s)[]
else:
@@ -134,8 +134,8 @@ proc genericSeqDeepCopy(dest, src: pointer, mt: PNimType) {.compilerProc.} =
proc genericDeepCopyOpenArray(dest, src: pointer, len: int,
mt: PNimType) {.compilerproc.} =
var
d = cast[TAddress](dest)
s = cast[TAddress](src)
d = cast[ByteAddress](dest)
s = cast[ByteAddress](src)
for i in 0..len-1:
genericDeepCopy(cast[pointer](d +% i*% mt.base.size),
cast[pointer](s +% i*% mt.base.size), mt.base)

2
lib/system/dyncalls.nim
View File

@@ -17,7 +17,7 @@
const
NilLibHandle: TLibHandle = nil
proc rawWrite(f: TFile, s: string) =
proc rawWrite(f: File, s: string) =
# we cannot throw an exception here!
discard writeBuffer(f, cstring(s), s.len)

16
lib/system/excpt.nim
View File

@@ -11,7 +11,7 @@
# use the heap (and nor exceptions) do not include the GC or memory allocator.
var
errorMessageWriter*: (proc(msg: string) {.tags: [FWriteIO], gcsafe.})
errorMessageWriter*: (proc(msg: string) {.tags: [WriteIOEffect], gcsafe.})
## Function that will be called
## instead of stdmsg.write when printing stacktrace.
## Unstable API.
@@ -42,7 +42,7 @@ var
excHandler {.threadvar.}: PSafePoint
# list of exception handlers
# a global variable for the root of all try blocks
currException {.threadvar.}: ref E_Base
currException {.threadvar.}: ref Exception
proc popFrame {.compilerRtl, inl.} =
framePtr = framePtr.prev
@@ -58,7 +58,7 @@ proc pushSafePoint(s: PSafePoint) {.compilerRtl, inl.} =
proc popSafePoint {.compilerRtl, inl.} =
excHandler = excHandler.prev
proc pushCurrentException(e: ref E_Base) {.compilerRtl, inl.} =
proc pushCurrentException(e: ref Exception) {.compilerRtl, inl.} =
e.parent = currException
currException = e
@@ -195,7 +195,7 @@ proc quitOrDebug() {.inline.} =
else:
endbStep() # call the debugger
proc raiseExceptionAux(e: ref E_Base) =
proc raiseExceptionAux(e: ref Exception) =
if localRaiseHook != nil:
if not localRaiseHook(e): return
if globalRaiseHook != nil:
@@ -204,7 +204,7 @@ proc raiseExceptionAux(e: ref E_Base) =
if not excHandler.hasRaiseAction or excHandler.raiseAction(e):
pushCurrentException(e)
c_longjmp(excHandler.context, 1)
elif e[] of EOutOfMemory:
elif e[] of OutOfMemError:
showErrorMessage(e.name)
quitOrDebug()
else:
@@ -236,7 +236,7 @@ proc raiseExceptionAux(e: ref E_Base) =
showErrorMessage(buf)
quitOrDebug()
proc raiseException(e: ref E_Base, ename: cstring) {.compilerRtl.} =
proc raiseException(e: ref Exception, ename: cstring) {.compilerRtl.} =
e.name = ename
when hasSomeStackTrace:
e.trace = ""
@@ -245,7 +245,7 @@ proc raiseException(e: ref E_Base, ename: cstring) {.compilerRtl.} =
proc reraiseException() {.compilerRtl.} =
if currException == nil:
sysFatal(ENoExceptionToReraise, "no exception to reraise")
sysFatal(ReraiseError, "no exception to reraise")
else:
raiseExceptionAux(currException)
@@ -264,7 +264,7 @@ proc getStackTrace(): string =
else:
result = "No stack traceback available\n"
proc getStackTrace(e: ref E_Base): string =
proc getStackTrace(e: ref Exception): string =
if not isNil(e) and not isNil(e.trace):
result = e.trace
else:

36
lib/system/gc.nim
View File

@@ -111,11 +111,11 @@ proc addZCT(s: var TCellSeq, c: PCell) {.noinline.} =
proc cellToUsr(cell: PCell): pointer {.inline.} =
# convert object (=pointer to refcount) to pointer to userdata
result = cast[pointer](cast[TAddress](cell)+%TAddress(sizeof(TCell)))
result = cast[pointer](cast[ByteAddress](cell)+%TAddress(sizeof(TCell)))
proc usrToCell(usr: pointer): PCell {.inline.} =
# convert pointer to userdata to object (=pointer to refcount)
result = cast[PCell](cast[TAddress](usr)-%TAddress(sizeof(TCell)))
result = cast[PCell](cast[ByteAddress](usr)-%TAddress(sizeof(TCell)))
proc canbeCycleRoot(c: PCell): bool {.inline.} =
result = ntfAcyclic notin c.typ.flags
@@ -312,7 +312,7 @@ proc cellsetReset(s: var TCellSet) =
init(s)
proc forAllSlotsAux(dest: pointer, n: ptr TNimNode, op: TWalkOp) {.gcsafe.} =
var d = cast[TAddress](dest)
var d = cast[ByteAddress](dest)
case n.kind
of nkSlot: forAllChildrenAux(cast[pointer](d +% n.offset), n.typ, op)
of nkList:
@@ -332,7 +332,7 @@ proc forAllSlotsAux(dest: pointer, n: ptr TNimNode, op: TWalkOp) {.gcsafe.} =
of nkNone: sysAssert(false, "forAllSlotsAux")
proc forAllChildrenAux(dest: pointer, mt: PNimType, op: TWalkOp) =
var d = cast[TAddress](dest)
var d = cast[ByteAddress](dest)
if dest == nil: return # nothing to do
if ntfNoRefs notin mt.flags:
case mt.kind
@@ -358,7 +358,7 @@ proc forAllChildren(cell: PCell, op: TWalkOp) =
of tyRef: # common case
forAllChildrenAux(cellToUsr(cell), cell.typ.base, op)
of tySequence:
var d = cast[TAddress](cellToUsr(cell))
var d = cast[ByteAddress](cellToUsr(cell))
var s = cast[PGenericSeq](d)
if s != nil:
for i in 0..s.len-1:
@@ -424,7 +424,7 @@ proc rawNewObj(typ: PNimType, size: int, gch: var TGcHeap): pointer =
gcAssert(typ.kind in {tyRef, tyString, tySequence}, "newObj: 1")
collectCT(gch)
var res = cast[PCell](rawAlloc(gch.region, size + sizeof(TCell)))
gcAssert((cast[TAddress](res) and (MemAlign-1)) == 0, "newObj: 2")
gcAssert((cast[ByteAddress](res) and (MemAlign-1)) == 0, "newObj: 2")
# now it is buffered in the ZCT
res.typ = typ
when leakDetector and not hasThreadSupport:
@@ -470,7 +470,7 @@ proc newObjRC1(typ: PNimType, size: int): pointer {.compilerRtl.} =
var res = cast[PCell](rawAlloc(gch.region, size + sizeof(TCell)))
sysAssert(allocInv(gch.region), "newObjRC1 after rawAlloc")
sysAssert((cast[TAddress](res) and (MemAlign-1)) == 0, "newObj: 2")
sysAssert((cast[ByteAddress](res) and (MemAlign-1)) == 0, "newObj: 2")
# now it is buffered in the ZCT
res.typ = typ
when leakDetector and not hasThreadSupport:
@@ -511,9 +511,9 @@ proc growObj(old: pointer, newsize: int, gch: var TGcHeap): pointer =
var oldsize = cast[PGenericSeq](old).len*elemSize + GenericSeqSize
copyMem(res, ol, oldsize + sizeof(TCell))
zeroMem(cast[pointer](cast[TAddress](res)+% oldsize +% sizeof(TCell)),
zeroMem(cast[pointer](cast[ByteAddress](res)+% oldsize +% sizeof(TCell)),
newsize-oldsize)
sysAssert((cast[TAddress](res) and (MemAlign-1)) == 0, "growObj: 3")
sysAssert((cast[ByteAddress](res) and (MemAlign-1)) == 0, "growObj: 3")
sysAssert(res.refcount shr rcShift <=% 1, "growObj: 4")
#if res.refcount <% rcIncrement:
# add(gch.zct, res)
@@ -728,7 +728,7 @@ proc gcMark(gch: var TGcHeap, p: pointer) {.inline.} =
# the addresses are not as cells on the stack, so turn them to cells:
sysAssert(allocInv(gch.region), "gcMark begin")
var cell = usrToCell(p)
var c = cast[TAddress](cell)
var c = cast[ByteAddress](cell)
if c >% PageSize:
# fast check: does it look like a cell?
var objStart = cast[PCell](interiorAllocatedPtr(gch.region, cell))
@@ -778,8 +778,8 @@ when not defined(useNimRtl):
# the first init must be the one that defines the stack bottom:
if gch.stackBottom == nil: gch.stackBottom = theStackBottom
else:
var a = cast[TAddress](theStackBottom) # and not PageMask - PageSize*2
var b = cast[TAddress](gch.stackBottom)
var a = cast[ByteAddress](theStackBottom) # and not PageMask - PageSize*2
var b = cast[ByteAddress](gch.stackBottom)
#c_fprintf(c_stdout, "old: %p new: %p;\n",gch.stackBottom,theStackBottom)
when stackIncreases:
gch.stackBottom = cast[pointer](min(a, b))
@@ -854,9 +854,9 @@ else:
proc isOnStack(p: pointer): bool =
var stackTop {.volatile.}: pointer
stackTop = addr(stackTop)
var b = cast[TAddress](gch.stackBottom)
var a = cast[TAddress](stackTop)
var x = cast[TAddress](p)
var b = cast[ByteAddress](gch.stackBottom)
var a = cast[ByteAddress](stackTop)
var x = cast[ByteAddress](p)
result = a <=% x and x <=% b
template forEachStackSlot(gch, gcMark: expr) {.immediate, dirty.} =
@@ -866,8 +866,8 @@ else:
type PStackSlice = ptr array [0..7, pointer]
var registers {.noinit.}: C_JmpBuf
if c_setjmp(registers) == 0'i32: # To fill the C stack with registers.
var max = cast[TAddress](gch.stackBottom)
var sp = cast[TAddress](addr(registers))
var max = cast[ByteAddress](gch.stackBottom)
var sp = cast[ByteAddress](addr(registers))
# loop unrolled:
while sp <% max - 8*sizeof(pointer):
gcMark(gch, cast[PStackSlice](sp)[0])
@@ -1040,7 +1040,7 @@ when not defined(useNimRtl):
else:
dec(gch.recGcLock)
proc GC_setStrategy(strategy: TGC_Strategy) =
proc GC_setStrategy(strategy: GC_Strategy) =
discard
proc GC_enableMarkAndSweep() =

10
lib/system/repr.nim
View File

@@ -155,7 +155,7 @@ when not defined(useNimRtl):
var bs = typ.base.size
for i in 0..typ.size div bs - 1:
if i > 0: add result, ", "
reprAux(result, cast[pointer](cast[TAddress](p) + i*bs), typ.base, cl)
reprAux(result, cast[pointer](cast[ByteAddress](p) + i*bs), typ.base, cl)
add result, "]"
proc reprSequence(result: var string, p: pointer, typ: PNimType,
@@ -167,7 +167,7 @@ when not defined(useNimRtl):
var bs = typ.base.size
for i in 0..cast[PGenericSeq](p).len-1:
if i > 0: add result, ", "
reprAux(result, cast[pointer](cast[TAddress](p) + GenericSeqSize + i*bs),
reprAux(result, cast[pointer](cast[ByteAddress](p) + GenericSeqSize + i*bs),
typ.base, cl)
add result, "]"
@@ -178,14 +178,14 @@ when not defined(useNimRtl):
of nkSlot:
add result, $n.name
add result, " = "
reprAux(result, cast[pointer](cast[TAddress](p) + n.offset), n.typ, cl)
reprAux(result, cast[pointer](cast[ByteAddress](p) + n.offset), n.typ, cl)
of nkList:
for i in 0..n.len-1:
if i > 0: add result, ",\n"
reprRecordAux(result, p, n.sons[i], cl)
of nkCase:
var m = selectBranch(p, n)
reprAux(result, cast[pointer](cast[TAddress](p) + n.offset), n.typ, cl)
reprAux(result, cast[pointer](cast[ByteAddress](p) + n.offset), n.typ, cl)
if m != nil: reprRecordAux(result, p, m, cl)
proc reprRecord(result: var string, p: pointer, typ: PNimType,
@@ -265,7 +265,7 @@ proc reprOpenArray(p: pointer, length: int, elemtyp: PNimType): string {.
var bs = elemtyp.size
for i in 0..length - 1:
if i > 0: add result, ", "
reprAux(result, cast[pointer](cast[TAddress](p) + i*bs), elemtyp, cl)
reprAux(result, cast[pointer](cast[ByteAddress](p) + i*bs), elemtyp, cl)
add result, "]"
deinitReprClosure(cl)

122
lib/system/sysio.nim
View File

@@ -1,6 +1,6 @@
#
#
# Nimrod's Runtime Library
# Nim's Runtime Library
# (c) Copyright 2013 Andreas Rumpf
#
# See the file "copying.txt", included in this
@@ -8,7 +8,7 @@
#
# Nimrod's standard IO library. It contains high-performance
# Nim's standard IO library. It contains high-performance
# routines for reading and writing data to (buffered) files or
# TTYs.
@@ -16,33 +16,33 @@
# of the standard library!
proc fputs(c: cstring, f: TFile) {.importc: "fputs", header: "<stdio.h>",
tags: [FWriteIO].}
proc fgets(c: cstring, n: int, f: TFile): cstring {.
importc: "fgets", header: "<stdio.h>", tags: [FReadIO].}
proc fgetc(stream: TFile): cint {.importc: "fgetc", header: "<stdio.h>",
tags: [FReadIO].}
proc ungetc(c: cint, f: TFile) {.importc: "ungetc", header: "<stdio.h>",
proc fputs(c: cstring, f: File) {.importc: "fputs", header: "<stdio.h>",
tags: [WriteIOEffect].}
proc fgets(c: cstring, n: int, f: File): cstring {.
importc: "fgets", header: "<stdio.h>", tags: [ReadIOEffect].}
proc fgetc(stream: File): cint {.importc: "fgetc", header: "<stdio.h>",
tags: [ReadIOEffect].}
proc ungetc(c: cint, f: File) {.importc: "ungetc", header: "<stdio.h>",
tags: [].}
proc putc(c: char, stream: TFile) {.importc: "putc", header: "<stdio.h>",
tags: [FWriteIO].}
proc fprintf(f: TFile, frmt: cstring) {.importc: "fprintf",
header: "<stdio.h>", varargs, tags: [FWriteIO].}
proc putc(c: char, stream: File) {.importc: "putc", header: "<stdio.h>",
tags: [WriteIOEffect].}
proc fprintf(f: File, frmt: cstring) {.importc: "fprintf",
header: "<stdio.h>", varargs, tags: [WriteIOEffect].}
proc strlen(c: cstring): int {.
importc: "strlen", header: "<string.h>", tags: [].}
# C routine that is used here:
proc fread(buf: pointer, size, n: int, f: TFile): int {.
importc: "fread", header: "<stdio.h>", tags: [FReadIO].}
proc fseek(f: TFile, offset: clong, whence: int): int {.
proc fread(buf: pointer, size, n: int, f: File): int {.
importc: "fread", header: "<stdio.h>", tags: [ReadIOEffect].}
proc fseek(f: File, offset: clong, whence: int): int {.
importc: "fseek", header: "<stdio.h>", tags: [].}
proc ftell(f: TFile): int {.importc: "ftell", header: "<stdio.h>", tags: [].}
proc setvbuf(stream: TFile, buf: pointer, typ, size: cint): cint {.
proc ftell(f: File): int {.importc: "ftell", header: "<stdio.h>", tags: [].}
proc setvbuf(stream: File, buf: pointer, typ, size: cint): cint {.
importc, header: "<stdio.h>", tags: [].}
{.push stackTrace:off, profiler:off.}
proc write(f: TFile, c: cstring) = fputs(c, f)
proc write(f: File, c: cstring) = fputs(c, f)
{.pop.}
when NoFakeVars:
@@ -65,9 +65,9 @@ const
BufSize = 4000
proc raiseEIO(msg: string) {.noinline, noreturn.} =
sysFatal(EIO, msg)
sysFatal(IOError, msg)
proc readLine(f: TFile, line: var TaintedString): bool =
proc readLine(f: File, line: var TaintedString): bool =
# of course this could be optimized a bit; but IO is slow anyway...
# and it was difficult to get this CORRECT with Ansi C's methods
setLen(line.string, 0) # reuse the buffer!
@@ -84,34 +84,34 @@ proc readLine(f: TFile, line: var TaintedString): bool =
add line.string, chr(int(c))
result = true
proc readLine(f: TFile): TaintedString =
proc readLine(f: File): TaintedString =
result = TaintedString(newStringOfCap(80))
if not readLine(f, result): raiseEIO("EOF reached")
proc write(f: TFile, i: int) =
proc write(f: File, i: int) =
when sizeof(int) == 8:
fprintf(f, "%lld", i)
else:
fprintf(f, "%ld", i)
proc write(f: TFile, i: BiggestInt) =
proc write(f: File, i: BiggestInt) =
when sizeof(BiggestInt) == 8:
fprintf(f, "%lld", i)
else:
fprintf(f, "%ld", i)
proc write(f: TFile, b: bool) =
proc write(f: File, b: bool) =
if b: write(f, "true")
else: write(f, "false")
proc write(f: TFile, r: float32) = fprintf(f, "%g", r)
proc write(f: TFile, r: BiggestFloat) = fprintf(f, "%g", r)
proc write(f: File, r: float32) = fprintf(f, "%g", r)
proc write(f: File, r: BiggestFloat) = fprintf(f, "%g", r)
proc write(f: TFile, c: char) = putc(c, f)
proc write(f: TFile, a: varargs[string, `$`]) =
proc write(f: File, c: char) = putc(c, f)
proc write(f: File, a: varargs[string, `$`]) =
for x in items(a): write(f, x)
proc readAllBuffer(file: TFile): string =
# This proc is for TFile we want to read but don't know how many
proc readAllBuffer(file: File): string =
# This proc is for File we want to read but don't know how many
# bytes we need to read before the buffer is empty.
result = ""
var buffer = newString(BufSize)
@@ -124,27 +124,27 @@ proc readAllBuffer(file: TFile): string =
result.add(buffer)
break
proc rawFileSize(file: TFile): int =
proc rawFileSize(file: File): int =
# this does not raise an error opposed to `getFileSize`
var oldPos = ftell(file)
discard fseek(file, 0, 2) # seek the end of the file
result = ftell(file)
discard fseek(file, clong(oldPos), 0)
proc readAllFile(file: TFile, len: int): string =
proc readAllFile(file: File, len: int): string =
# We aquire the filesize beforehand and hope it doesn't change.
# Speeds things up.
result = newString(int(len))
if readBuffer(file, addr(result[0]), int(len)) != len:
raiseEIO("error while reading from file")
proc readAllFile(file: TFile): string =
proc readAllFile(file: File): string =
var len = rawFileSize(file)
result = readAllFile(file, len)
proc readAll(file: TFile): TaintedString =
proc readAll(file: File): TaintedString =
# Separate handling needed because we need to buffer when we
# don't know the overall length of the TFile.
# don't know the overall length of the File.
var len = rawFileSize(file)
if len >= 0:
result = readAllFile(file, len).TaintedString
@@ -165,13 +165,13 @@ proc writeFile(filename, content: string) =
finally:
close(f)
proc endOfFile(f: TFile): bool =
proc endOfFile(f: File): bool =
# do not blame me; blame the ANSI C standard this is so brain-damaged
var c = fgetc(f)
ungetc(c, f)
return c < 0'i32
proc writeln[Ty](f: TFile, x: varargs[Ty, `$`]) =
proc writeln[Ty](f: File, x: varargs[Ty, `$`]) =
for i in items(x): write(f, i)
write(f, "\n")
@@ -186,7 +186,7 @@ when (defined(windows) and not defined(useWinAnsi)) or defined(nimdoc):
when defined(windows) and not defined(useWinAnsi):
proc wfopen(filename, mode: WideCString): pointer {.
importc: "_wfopen", nodecl.}
proc wfreopen(filename, mode: WideCString, stream: TFile): TFile {.
proc wfreopen(filename, mode: WideCString, stream: File): File {.
importc: "_wfreopen", nodecl.}
proc fopen(filename, mode: cstring): pointer =
@@ -194,82 +194,82 @@ when defined(windows) and not defined(useWinAnsi):
var m = newWideCString(mode)
result = wfopen(f, m)
proc freopen(filename, mode: cstring, stream: TFile): TFile =
proc freopen(filename, mode: cstring, stream: File): File =
var f = newWideCString(filename)
var m = newWideCString(mode)
result = wfreopen(f, m, stream)
else:
proc fopen(filename, mode: cstring): pointer {.importc: "fopen", noDecl.}
proc freopen(filename, mode: cstring, stream: TFile): TFile {.
proc freopen(filename, mode: cstring, stream: File): File {.
importc: "freopen", nodecl.}
const
FormatOpen: array [TFileMode, string] = ["rb", "wb", "w+b", "r+b", "ab"]
FormatOpen: array [FileMode, string] = ["rb", "wb", "w+b", "r+b", "ab"]
#"rt", "wt", "w+t", "r+t", "at"
# we always use binary here as for Nimrod the OS line ending
# we always use binary here as for Nim the OS line ending
# should not be translated.
proc open(f: var TFile, filename: string,
mode: TFileMode = fmRead,
proc open(f: var File, filename: string,
mode: FileMode = fmRead,
bufSize: int = -1): bool =
var p: pointer = fopen(filename, FormatOpen[mode])
result = (p != nil)
f = cast[TFile](p)
f = cast[File](p)
if bufSize > 0 and bufSize <= high(cint).int:
if setvbuf(f, nil, IOFBF, bufSize.cint) != 0'i32:
sysFatal(EOutOfMemory, "out of memory")
sysFatal(OutOfMemError, "out of memory")
elif bufSize == 0:
discard setvbuf(f, nil, IONBF, 0)
proc reopen(f: TFile, filename: string, mode: TFileMode = fmRead): bool =
proc reopen(f: File, filename: string, mode: FileMode = fmRead): bool =
var p: pointer = freopen(filename, FormatOpen[mode], f)
result = p != nil
proc fdopen(filehandle: TFileHandle, mode: cstring): TFile {.
proc fdopen(filehandle: FileHandle, mode: cstring): File {.
importc: pccHack & "fdopen", header: "<stdio.h>".}
proc open(f: var TFile, filehandle: TFileHandle, mode: TFileMode): bool =
proc open(f: var File, filehandle: FileHandle, mode: FileMode): bool =
f = fdopen(filehandle, FormatOpen[mode])
result = f != nil
proc fwrite(buf: pointer, size, n: int, f: TFile): int {.
proc fwrite(buf: pointer, size, n: int, f: File): int {.
importc: "fwrite", noDecl.}
proc readBuffer(f: TFile, buffer: pointer, len: int): int =
proc readBuffer(f: File, buffer: pointer, len: int): int =
result = fread(buffer, 1, len, f)
proc readBytes(f: TFile, a: var openArray[int8], start, len: int): int =
proc readBytes(f: File, a: var openArray[int8], start, len: int): int =
result = readBuffer(f, addr(a[start]), len)
proc readChars(f: TFile, a: var openArray[char], start, len: int): int =
proc readChars(f: File, a: var openArray[char], start, len: int): int =
result = readBuffer(f, addr(a[start]), len)
{.push stackTrace:off, profiler:off.}
proc writeBytes(f: TFile, a: openArray[int8], start, len: int): int =
proc writeBytes(f: File, a: openArray[int8], start, len: int): int =
var x = cast[ptr array[0..1000_000_000, int8]](a)
result = writeBuffer(f, addr(x[start]), len)
proc writeChars(f: TFile, a: openArray[char], start, len: int): int =
proc writeChars(f: File, a: openArray[char], start, len: int): int =
var x = cast[ptr array[0..1000_000_000, int8]](a)
result = writeBuffer(f, addr(x[start]), len)
proc writeBuffer(f: TFile, buffer: pointer, len: int): int =
proc writeBuffer(f: File, buffer: pointer, len: int): int =
result = fwrite(buffer, 1, len, f)
proc write(f: TFile, s: string) =
proc write(f: File, s: string) =
if writeBuffer(f, cstring(s), s.len) != s.len:
raiseEIO("cannot write string to file")
{.pop.}
proc setFilePos(f: TFile, pos: int64) =
proc setFilePos(f: File, pos: int64) =
if fseek(f, clong(pos), 0) != 0:
raiseEIO("cannot set file position")
proc getFilePos(f: TFile): int64 =
proc getFilePos(f: File): int64 =
result = ftell(f)
if result < 0: raiseEIO("cannot retrieve file position")
proc getFileSize(f: TFile): int64 =
proc getFileSize(f: File): int64 =
var oldPos = getFilePos(f)
discard fseek(f, 0, 2) # seek the end of the file
result = getFilePos(f)

4
lib/system/sysstr.nim
View File

@@ -217,7 +217,7 @@ proc setLengthSeq(seq: PGenericSeq, elemSize, newLen: int): PGenericSeq {.
gch.tempStack.len = len0
else:
for i in newLen..result.len-1:
forAllChildrenAux(cast[pointer](cast[TAddress](result) +%
forAllChildrenAux(cast[pointer](cast[ByteAddress](result) +%
GenericSeqSize +% (i*%elemSize)),
extGetCellType(result).base, waZctDecRef)
@@ -227,7 +227,7 @@ proc setLengthSeq(seq: PGenericSeq, elemSize, newLen: int): PGenericSeq {.
# presense of user defined destructors, the user will expect the cell to be
# "destroyed" thus creating the same problem. We can destoy the cell in the
# finalizer of the sequence, but this makes destruction non-deterministic.
zeroMem(cast[pointer](cast[TAddress](result) +% GenericSeqSize +%
zeroMem(cast[pointer](cast[ByteAddress](result) +% GenericSeqSize +%
(newLen*%elemSize)), (result.len-%newLen) *% elemSize)
result.len = newLen