diff --git a/compiler/ccgexprs.nim b/compiler/ccgexprs.nim index 6e10379e6b..b03f7c5aa1 100644 --- a/compiler/ccgexprs.nim +++ b/compiler/ccgexprs.nim @@ -944,7 +944,6 @@ proc genEcho(p: BProc, n: PNode) = # this unusal way of implementing it ensures that e.g. ``echo("hallo", 45)`` # is threadsafe. internalAssert n.kind == nkBracket - p.module.includeHeader("") var args: Rope = nil var a: TLoc for i in countup(0, n.len-1): @@ -953,9 +952,15 @@ proc genEcho(p: BProc, n: PNode) = else: initLocExpr(p, n.sons[i], a) addf(args, ", $1? ($1)->data:\"nil\"", [rdLoc(a)]) - linefmt(p, cpsStmts, "printf($1$2);$n", - makeCString(repeat("%s", n.len) & tnl), args) - linefmt(p, cpsStmts, "fflush(stdout);$n") + if platform.targetOS == osGenode: + # bypass libc and print directly to the Genode LOG session + p.module.includeHeader("") + linefmt(p, cpsStmts, """Genode::log(""$1);$n""", args) + else: + p.module.includeHeader("") + linefmt(p, cpsStmts, "printf($1$2);$n", + makeCString(repeat("%s", n.len) & tnl), args) + linefmt(p, cpsStmts, "fflush(stdout);$n") proc gcUsage(n: PNode) = if gSelectedGC == gcNone: message(n.info, warnGcMem, n.renderTree) diff --git a/compiler/cgen.nim b/compiler/cgen.nim index ebdbffa5a2..fd15d07934 100644 --- a/compiler/cgen.nim +++ b/compiler/cgen.nim @@ -966,6 +966,19 @@ proc genMainProc(m: BModule) = MainProcs & "}$N$N" + GenodeNimMain = + "Libc::Env *genodeEnv;$N" & + NimMainBody + + ComponentConstruct = + "void Libc::Component::construct(Libc::Env &env) {$N" & + "\tgenodeEnv = &env;$N" & + "\tLibc::with_libc([&] () {$n\t" & + MainProcs & + "\t});$N" & + "\tenv.parent().exit(0);$N" & + "}$N$N" + var nimMain, otherMain: FormatStr if platform.targetOS == osWindows and gGlobalOptions * {optGenGuiApp, optGenDynLib} != {}: @@ -976,6 +989,9 @@ proc genMainProc(m: BModule) = nimMain = WinNimDllMain otherMain = WinCDllMain m.includeHeader("") + elif platform.targetOS == osGenode: + nimMain = GenodeNimMain + otherMain = ComponentConstruct elif optGenDynLib in gGlobalOptions: nimMain = PosixNimDllMain otherMain = PosixCDllMain diff --git a/compiler/jsgen.nim b/compiler/jsgen.nim index d64e4f7ddf..0016a8492b 100644 --- a/compiler/jsgen.nim +++ b/compiler/jsgen.nim @@ -1626,22 +1626,56 @@ proc genToArray(p: PProc; n: PNode; r: var TCompRes) = localError(x.info, "'toArray' needs an array literal") r.res.add(")") +proc genReprAux(p: PProc, n: PNode, r: var TCompRes, magic: string, typ: Rope = nil) = + useMagic(p, magic) + add(r.res, magic & "(") + var a: TCompRes + + gen(p, n.sons[1], a) + if magic == "reprAny": + # the pointer argument in reprAny is expandend to + # (pointedto, pointer), so we need to fill it + if a.address.isNil: + add(r.res, a.res) + add(r.res, ", null") + else: + add(r.res, "$1, $2" % [a.address, a.res]) + else: + add(r.res, a.res) + + if not typ.isNil: + add(r.res, ", ") + add(r.res, typ) + add(r.res, ")") + proc genRepr(p: PProc, n: PNode, r: var TCompRes) = if p.target == targetPHP: localError(n.info, "'repr' not available for PHP backend") return let t = skipTypes(n.sons[1].typ, abstractVarRange) - case t.kind - of tyInt..tyUInt64: - unaryExpr(p, n, r, "", "(\"\"+ ($1))") + case t.kind: + of tyInt..tyInt64, tyUInt..tyUInt64: + genReprAux(p, n, r, "reprInt") + of tyChar: + genReprAux(p, n, r, "reprChar") + of tyBool: + genReprAux(p, n, r, "reprBool") + of tyFloat..tyFloat128: + genReprAux(p, n, r, "reprFloat") + of tyString: + genReprAux(p, n, r, "reprStr") of tyEnum, tyOrdinal: - gen(p, n.sons[1], r) - useMagic(p, "cstrToNimstr") - r.kind = resExpr - r.res = "cstrToNimstr($1.node.sons[$2].name)" % [genTypeInfo(p, t), r.res] + genReprAux(p, n, r, "reprEnum", genTypeInfo(p, t)) + of tySet: + genReprAux(p, n, r, "reprSet", genTypeInfo(p, t)) + of tyEmpty, tyVoid: + localError(n.info, "'repr' doesn't support 'void' type") + of tyPointer: + genReprAux(p, n, r, "reprPointer") + of tyOpenArray, tyVarargs: + genReprAux(p, n, r, "reprJSONStringify") else: - # XXX: - internalError(n.info, "genRepr: Not implemented") + genReprAux(p, n, r, "reprAny", genTypeInfo(p, t)) proc genOf(p: PProc, n: PNode, r: var TCompRes) = var x: TCompRes diff --git a/compiler/platform.nim b/compiler/platform.nim index 19d0d5853f..eb0aca186f 100644 --- a/compiler/platform.nim +++ b/compiler/platform.nim @@ -21,7 +21,7 @@ type # conditionals to condsyms (end of module). osNone, osDos, osWindows, osOs2, osLinux, osMorphos, osSkyos, osSolaris, osIrix, osNetbsd, osFreebsd, osOpenbsd, osDragonfly, osAix, osPalmos, osQnx, - osAmiga, osAtari, osNetware, osMacos, osMacosx, osHaiku, osVxworks, + osAmiga, osAtari, osNetware, osMacos, osMacosx, osHaiku, osVxworks, osGenode osJS, osNimrodVM, osStandalone type @@ -147,6 +147,11 @@ const objExt: ".o", newLine: "\x0A", pathSep: ";", dirSep: "\\", scriptExt: ".sh", curDir: ".", exeExt: ".vxe", extSep: ".", props: {ospNeedsPIC, ospPosix, ospLacksThreadVars}), + (name: "Genode", pardir: "..", dllFrmt: "$1.lib.so", altDirSep: "/", + objExt: ".o", newLine: "\x0A", pathSep: ":", dirSep: "/", + scriptExt: "", curDir: "/", exeExt: "", extSep: ".", + props: {ospNeedsPIC, ospLacksThreadVars}), + (name: "JS", parDir: "..", dllFrmt: "lib$1.so", altDirSep: "/", objExt: ".o", newLine: "\x0A", diff --git a/compiler/semcall.nim b/compiler/semcall.nim index d6852859b9..2dd115b1bc 100644 --- a/compiler/semcall.nim +++ b/compiler/semcall.nim @@ -256,6 +256,7 @@ proc resolveOverloads(c: PContext, n, orig: PNode, f.ident.s[0..f.ident.s.len-2]).withInfo(n.info) let callOp = newIdentNode(getIdent".=", n.info) n.sons[0..1] = [callOp, n[1], calleeName] + excl(n.flags, nfDotSetter) orig.sons[0..1] = [callOp, orig[1], calleeName] pickBest(callOp) diff --git a/compiler/semtypinst.nim b/compiler/semtypinst.nim index fddcc7a24c..9ff0b7e78d 100644 --- a/compiler/semtypinst.nim +++ b/compiler/semtypinst.nim @@ -472,7 +472,7 @@ proc replaceTypeVarsTAux(cl: var TReplTypeVars, t: PType): PType = var r = replaceTypeVarsT(cl, result.sons[i]) if result.kind == tyObject: # carefully coded to not skip the precious tyGenericInst: - let r2 = r.skipTypes({tyGenericInst, tyAlias}) + let r2 = r.skipTypes({tyAlias}) if r2.kind in {tyPtr, tyRef}: r = skipTypes(r2, {tyPtr, tyRef}) result.sons[i] = r diff --git a/compiler/sigmatch.nim b/compiler/sigmatch.nim index ff7b0ae723..4661abda02 100644 --- a/compiler/sigmatch.nim +++ b/compiler/sigmatch.nim @@ -1268,7 +1268,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType, doBind = true): TTypeRelation = # crossing path with metatypes/aliases, so we need to separate them # by checking sym.id let genericSubtype = isGenericSubType(c, x, f, depth, f) - if not (genericSubtype and aobj.sym.id != fobj.sym.id): + if not (genericSubtype and aobj.sym.id != fobj.sym.id) and aOrig.kind != tyGenericBody: depth = -1 if depth >= 0: diff --git a/doc/grammar.txt b/doc/grammar.txt index c70a6737fd..f6b9b115f5 100644 --- a/doc/grammar.txt +++ b/doc/grammar.txt @@ -174,7 +174,8 @@ typeClass = typeClassParam ^* ',' (pragma)? ('of' typeDesc ^* ',')? typeDef = identWithPragmaDot genericParamList? '=' optInd typeDefAux indAndComment? varTuple = '(' optInd identWithPragma ^+ comma optPar ')' '=' optInd expr -variable = (varTuple / identColonEquals) indAndComment +colonBody = colcom stmt doBlocks? +variable = (varTuple / identColonEquals) colonBody? indAndComment bindStmt = 'bind' optInd qualifiedIdent ^+ comma mixinStmt = 'mixin' optInd qualifiedIdent ^+ comma pragmaStmt = pragma (':' COMMENT? stmt)? diff --git a/doc/manual/threads.txt b/doc/manual/threads.txt index fe88123d25..15121ab6d9 100644 --- a/doc/manual/threads.txt +++ b/doc/manual/threads.txt @@ -39,7 +39,7 @@ directly or indirectly through a call to a GC unsafe proc. The `gcsafe`:idx: annotation can be used to mark a proc to be gcsafe, otherwise this property is inferred by the compiler. Note that ``noSideEffect`` implies ``gcsafe``. The only way to create a thread is via ``spawn`` or -``createThead``. ``spawn`` is usually the preferable method. Either way +``createThread``. ``spawn`` is usually the preferable method. Either way the invoked proc must not use ``var`` parameters nor must any of its parameters contain a ``ref`` or ``closure`` type. This enforces the *no heap sharing restriction*. diff --git a/lib/genode_cpp/syslocks.h b/lib/genode_cpp/syslocks.h new file mode 100644 index 0000000000..8ba39abc21 --- /dev/null +++ b/lib/genode_cpp/syslocks.h @@ -0,0 +1,78 @@ +/* + * + * Nim's Runtime Library + * (c) Copyright 2017 Emery Hemingway + * + * See the file "copying.txt", included in this + * distribution, for details about the copyright. + * + */ + +#ifndef _GENODE_CPP__SYSLOCKS_H_ +#define _GENODE_CPP__SYSLOCKS_H_ + +/* Genode includes */ +#include +#include + +namespace Nim { + struct SysLock; + struct SysCond; +} + +struct Nim::SysLock +{ + Genode::Lock _lock_a, _lock_b; + bool _locked; + + void acquireSys() + { + _lock_a.lock(); + _locked = true; + _lock_a.unlock(); + _lock_b.lock(); + } + + bool tryAcquireSys() + { + if (_locked) + return false; + + _lock_a.lock(); + if (_locked) { + _lock_a.unlock(); + return false; + } else { + _locked = true; + _lock_b.lock(); + _lock_a.unlock(); + return true; + } + } + + void releaseSys() + { + _locked = false; + _lock_a.unlock(); + _lock_b.unlock(); + } +}; + +struct Nim::SysCond +{ + Genode::Semaphore _semaphore; + + void waitSysCond(SysLock &syslock) + { + syslock.releaseSys(); + _semaphore.down(); + syslock.acquireSys(); + } + + void signalSysCond() + { + _semaphore.up(); + } +}; + +#endif diff --git a/lib/genode_cpp/threads.h b/lib/genode_cpp/threads.h new file mode 100644 index 0000000000..a1cd61cd2c --- /dev/null +++ b/lib/genode_cpp/threads.h @@ -0,0 +1,69 @@ +/* + * + * Nim's Runtime Library + * (c) Copyright 2017 Emery Hemingway + * + * See the file "copying.txt", included in this + * distribution, for details about the copyright. + * + */ + + +#ifndef _GENODE_CPP__THREAD_H_ +#define _GENODE_CPP__THREAD_H_ + +#include +#include +#include + +namespace Nim { struct SysThread; } + +struct Nim::SysThread +{ + typedef void (Entry)(void*); + + struct Thread : Genode::Thread + { + void *_tls; + + Entry *_func; + void *_arg; + + void entry() override { + (_func)(_arg); } + + Thread(Genode::Env &env, Genode::size_t stack_size, Entry func, void *arg) + : Genode::Thread(env, "nim-thread", stack_size), _func(func), _arg(arg) + { + Genode::Thread::start(); + } + }; + + Genode::Constructible _thread; + + void initThread(Genode::Env *env, Genode::size_t stack_size, Entry func, void *arg) { + _thread.construct(*env, stack_size, func, arg); } + + void joinThread() { + _thread->join(); } + + static bool offMainThread() { + return dynamic_cast(Genode::Thread::myself()); } + + static void *threadVarGetValue() + { + SysThread::Thread *thr = + static_cast(Genode::Thread::myself()); + return thr->_tls; + } + + static void threadVarSetValue(void *value) + { + SysThread::Thread *thr = + static_cast(Genode::Thread::myself()); + thr->_tls = value; + } + +}; + +#endif diff --git a/lib/nimbase.h b/lib/nimbase.h index a535d0da93..714623d4ef 100644 --- a/lib/nimbase.h +++ b/lib/nimbase.h @@ -498,6 +498,11 @@ typedef int Nim_and_C_compiler_disagree_on_target_architecture[sizeof(NI) == siz # include #endif +#if defined(__GENODE__) +#include +extern Libc::Env *genodeEnv; +#endif + /* Compile with -d:checkAbi and a sufficiently C11:ish compiler to enable */ #define NIM_CHECK_SIZE(typ, sz) \ _Static_assert(sizeof(typ) == sz, "Nim & C disagree on type size") diff --git a/lib/posix/posix.nim b/lib/posix/posix.nim index b29f43eb4c..1ff861534b 100644 --- a/lib/posix/posix.nim +++ b/lib/posix/posix.nim @@ -1862,10 +1862,10 @@ when hasAioH: a4: ptr SigEvent): cint {.importc, header: "".} # arpa/inet.h -proc htonl*(a1: int32): int32 {.importc, header: "".} -proc htons*(a1: int16): int16 {.importc, header: "".} -proc ntohl*(a1: int32): int32 {.importc, header: "".} -proc ntohs*(a1: int16): int16 {.importc, header: "".} +proc htonl*(a1: uint32): uint32 {.importc, header: "".} +proc htons*(a1: uint16): uint16 {.importc, header: "".} +proc ntohl*(a1: uint32): uint32 {.importc, header: "".} +proc ntohs*(a1: uint16): uint16 {.importc, header: "".} proc inet_addr*(a1: cstring): InAddrT {.importc, header: "".} proc inet_ntoa*(a1: InAddr): cstring {.importc, header: "".} @@ -2423,11 +2423,15 @@ proc sigset*(a1: int, a2: proc (x: cint) {.noconv.}) {. proc sigsuspend*(a1: var Sigset): cint {.importc, header: "".} when defined(android): - proc sigtimedwait*(a1: var Sigset, a2: var SigInfo, - a3: var Timespec, sigsetsize: csize = sizeof(culong)*2): cint {.importc: "__rt_sigtimedwait", header:"".} + proc syscall(arg: clong): clong {.varargs, importc: "syscall", header: "".} + var NR_rt_sigtimedwait {.importc: "__NR_rt_sigtimedwait", header: "".}: clong + var NSIGMAX {.importc: "NSIG", header: "".}: clong + + proc sigtimedwait*(a1: var Sigset, a2: var SigInfo, a3: var Timespec): cint = + result = cint(syscall(NR_rt_sigtimedwait, addr(a1), addr(a2), addr(a3), NSIGMAX div 8)) else: proc sigtimedwait*(a1: var Sigset, a2: var SigInfo, - a3: var Timespec): cint {.importc, header: "".} + a3: var Timespec): cint {.importc, header: "".} proc sigwait*(a1: var Sigset, a2: var cint): cint {. importc, header: "".} diff --git a/lib/pure/concurrency/cpuinfo.nim b/lib/pure/concurrency/cpuinfo.nim index 8c87c77df5..c3390573a7 100644 --- a/lib/pure/concurrency/cpuinfo.nim +++ b/lib/pure/concurrency/cpuinfo.nim @@ -37,6 +37,10 @@ when defined(macosx) or defined(bsd): a: var csize, b: pointer, c: int): cint {. importc: "sysctl", nodecl.} +when defined(genode): + proc affinitySpaceTotal(): cuint {. + importcpp: "genodeEnv->cpu().affinity_space().total()".} + proc countProcessors*(): int {.rtl, extern: "ncpi$1".} = ## returns the numer of the processors/cores the machine has. ## Returns 0 if it cannot be detected. @@ -61,7 +65,8 @@ proc countProcessors*(): int {.rtl, extern: "ncpi$1".} = elif defined(irix): var SC_NPROC_ONLN {.importc: "_SC_NPROC_ONLN", header: "".}: cint result = sysconf(SC_NPROC_ONLN) + elif defined(genode): + result = affinitySpaceTotal().int else: result = sysconf(SC_NPROCESSORS_ONLN) if result <= 0: result = 1 - diff --git a/lib/pure/httpclient.nim b/lib/pure/httpclient.nim index 7f666fb357..62c7e20675 100644 --- a/lib/pure/httpclient.nim +++ b/lib/pure/httpclient.nim @@ -320,7 +320,7 @@ proc parseResponse(s: Socket, getBody: bool, timeout: int): Response = if line[linei] != ':': httpError("invalid headers") inc(linei) # Skip : - result.headers[name] = line[linei.. ^1].strip() + result.headers.add(name, line[linei.. ^1].strip()) # Ensure the server isn't trying to DoS us. if result.headers.len > headerLimit: httpError("too many headers") @@ -1010,7 +1010,7 @@ proc parseResponse(client: HttpClient | AsyncHttpClient, if line[linei] != ':': httpError("invalid headers") inc(linei) # Skip : - result.headers[name] = line[linei.. ^1].strip() + result.headers.add(name, line[linei.. ^1].strip()) if result.headers.len > headerLimit: httpError("too many headers") diff --git a/lib/pure/os.nim b/lib/pure/os.nim index a7f7116ef6..82acb2a59c 100644 --- a/lib/pure/os.nim +++ b/lib/pure/os.nim @@ -825,16 +825,16 @@ proc putEnv*(key, val: string) {.tags: [WriteEnvEffect].} = else: add environment, (key & '=' & val) indx = high(environment) - when defined(unix): - if c_putenv(environment[indx]) != 0'i32: - raiseOSError(osLastError()) - else: + when defined(windows): when useWinUnicode: var k = newWideCString(key) var v = newWideCString(val) if setEnvironmentVariableW(k, v) == 0'i32: raiseOSError(osLastError()) else: if setEnvironmentVariableA(key, val) == 0'i32: raiseOSError(osLastError()) + else: + if c_putenv(environment[indx]) != 0'i32: + raiseOSError(osLastError()) iterator envPairs*(): tuple[key, value: TaintedString] {.tags: [ReadEnvEffect].} = ## Iterate over all `environments variables`:idx:. In the first component @@ -1091,7 +1091,7 @@ proc rawCreateDir(dir: string): bool = result = false else: raiseOSError(osLastError()) - elif defined(unix): + elif defined(posix): let res = mkdir(dir, 0o777) if res == 0'i32: result = true @@ -1452,7 +1452,9 @@ elif defined(windows): if isNil(ownArgv): ownArgv = parseCmdLine($getCommandLine()) return TaintedString(ownArgv[i]) -elif not defined(createNimRtl) and not(defined(posix) and appType == "lib"): +elif not defined(createNimRtl) and + not(defined(posix) and appType == "lib") and + not defined(genode): # On Posix, there is no portable way to get the command line from a DLL. var cmdCount {.importc: "cmdCount".}: cint @@ -1606,6 +1608,8 @@ proc getAppFilename*(): string {.rtl, extern: "nos$1", tags: [ReadIOEffect].} = result = getApplAux("/proc/self/exe") elif defined(solaris): result = getApplAux("/proc/" & $getpid() & "/path/a.out") + elif defined(genode): + raiseOSError("POSIX command line not supported") elif defined(freebsd) or defined(dragonfly): result = getApplFreebsd() # little heuristic that may work on other POSIX-like systems: diff --git a/lib/system.nim b/lib/system.nim index 371cf8544d..f6133b7413 100644 --- a/lib/system.nim +++ b/lib/system.nim @@ -1384,25 +1384,34 @@ var programResult* {.exportc: "nim_program_result".}: int ## under normal circumstances. When the program is terminated ## prematurely using ``quit``, this value is ignored. -proc quit*(errorcode: int = QuitSuccess) {. - magic: "Exit", importc: "exit", header: "", noreturn.} - ## Stops the program immediately with an exit code. - ## - ## Before stopping the program the "quit procedures" are called in the - ## opposite order they were added with `addQuitProc <#addQuitProc>`_. - ## ``quit`` never returns and ignores any exception that may have been raised - ## by the quit procedures. It does *not* call the garbage collector to free - ## all the memory, unless a quit procedure calls `GC_fullCollect - ## <#GC_fullCollect>`_. - ## - ## The proc ``quit(QuitSuccess)`` is called implicitly when your nim - ## program finishes without incident. A raised unhandled exception is - ## equivalent to calling ``quit(QuitFailure)``. - ## - ## Note that this is a *runtime* call and using ``quit`` inside a macro won't - ## have any compile time effect. If you need to stop the compiler inside a - ## macro, use the `error `_ or `fatal - ## `_ pragmas. +when defined(nimdoc): + proc quit*(errorcode: int = QuitSuccess) {.magic: "Exit", noreturn.} + ## Stops the program immediately with an exit code. + ## + ## Before stopping the program the "quit procedures" are called in the + ## opposite order they were added with `addQuitProc <#addQuitProc>`_. + ## ``quit`` never returns and ignores any exception that may have been raised + ## by the quit procedures. It does *not* call the garbage collector to free + ## all the memory, unless a quit procedure calls `GC_fullCollect + ## <#GC_fullCollect>`_. + ## + ## The proc ``quit(QuitSuccess)`` is called implicitly when your nim + ## program finishes without incident. A raised unhandled exception is + ## equivalent to calling ``quit(QuitFailure)``. + ## + ## Note that this is a *runtime* call and using ``quit`` inside a macro won't + ## have any compile time effect. If you need to stop the compiler inside a + ## macro, use the `error `_ or `fatal + ## `_ pragmas. + + +elif defined(genode): + proc quit*(errorcode: int = QuitSuccess) {.magic: "Exit", noreturn, + importcpp: "genodeEnv->parent().exit(@)", header: "".} + +else: + proc quit*(errorcode: int = QuitSuccess) {. + magic: "Exit", importc: "exit", header: "", noreturn.} template sysAssert(cond: bool, msg: string) = when defined(useSysAssert): diff --git a/lib/system/dyncalls.nim b/lib/system/dyncalls.nim index be6275338a..2b86ddf258 100644 --- a/lib/system/dyncalls.nim +++ b/lib/system/dyncalls.nim @@ -146,6 +146,17 @@ elif defined(windows) or defined(dos): if result != nil: return procAddrError(name) +elif defined(genode): + + proc nimUnloadLibrary(lib: LibHandle) {. + error: "nimUnloadLibrary not implemented".} + + proc nimLoadLibrary(path: string): LibHandle {. + error: "nimLoadLibrary not implemented".} + + proc nimGetProcAddr(lib: LibHandle, name: cstring): ProcAddr {. + error: "nimGetProcAddr not implemented".} + else: {.error: "no implementation for dyncalls".} diff --git a/lib/system/osalloc.nim b/lib/system/osalloc.nim index a57a88e8fd..65a057772c 100644 --- a/lib/system/osalloc.nim +++ b/lib/system/osalloc.nim @@ -77,6 +77,19 @@ when defined(emscripten): var mmapDescr = cast[EmscriptenMMapBlock](mmapDescrPos) munmap(mmapDescr.realPointer, mmapDescr.realSize) +elif defined(genode): + + proc osAllocPages(size: int): pointer {. + importcpp: "genodeEnv->rm().attach(genodeEnv->ram().alloc(@))".} + + proc osTryAllocPages(size: int): pointer = + {.emit: """try {""".} + result = osAllocPages size + {.emit: """} catch (...) { }""".} + + proc osDeallocPages(p: pointer, size: int) {. + importcpp: "genodeEnv->rm().detach(#)".} + elif defined(posix): const PROT_READ = 1 # page can be read diff --git a/lib/system/reprjs.nim b/lib/system/reprjs.nim index 57237cfffa..6b0e32191e 100644 --- a/lib/system/reprjs.nim +++ b/lib/system/reprjs.nim @@ -6,18 +6,272 @@ # See the file "copying.txt", included in this # distribution, for details about the copyright. # +# The generic ``repr`` procedure for the javascript backend. proc reprInt(x: int64): string {.compilerproc.} = return $x +proc reprFloat(x: float): string {.compilerproc.} = + # Js toString doesn't differentiate between 1.0 and 1, + # but we do. + if $x == $(x.int): $x & ".0" + else: $x + +proc reprPointer(p: pointer): string {.compilerproc.} = + # Do we need to generate the full 8bytes ? In js a pointer is an int anyway + var tmp: int + {. emit: """ + if (`p`_Idx == null) { + `tmp` = 0; + } else { + `tmp` = `p`_Idx; + } + """ .} + result = $tmp + +proc reprBool(x: bool): string {.compilerRtl.} = + if x: result = "true" + else: result = "false" + +proc isUndefined[T](x: T): bool {.inline.} = {.emit: "`result` = `x` === undefined;"} proc reprEnum(e: int, typ: PNimType): string {.compilerRtl.} = - if ntfEnumHole notin typ.flags: - if e <% typ.node.len: - return $typ.node.sons[e].name + if not typ.node.sons[e].isUndefined: + result = $typ.node.sons[e].name else: - # ugh we need a slow linear search: - var n = typ.node - var s = n.sons - for i in 0 .. n.len-1: - if s[i].offset == e: return $s[i].name - result = $e & " (invalid data!)" + result = $e & " (invalid data!)" + +proc reprChar(x: char): string {.compilerRtl.} = + result = "\'" + case x + of '"': add(result, "\\\"") + of '\\': add(result, "\\\\") + of '\128'..'\255', '\0'..'\31': add( result, "\\" & reprInt(ord(x)) ) + else: add(result, x) + add(result, "\'") +proc reprStrAux(result: var string, s: cstring, len: int) = + add(result, "\"") + for i in 0 .. "", but repr of an + # array of string that is not initialized is [nil, nil, ...] ?? + add(result, "nil") + else: + reprStrAux(result, s, s.len) + +proc addSetElem(result: var string, elem: int, typ: PNimType) = + # Dispatch each set element to the correct repr proc + case typ.kind: + of tyEnum: add(result, reprEnum(elem, typ)) + of tyBool: add(result, reprBool(bool(elem))) + of tyChar: add(result, reprChar(chr(elem))) + of tyRange: addSetElem(result, elem, typ.base) # Note the base to advance towards the element type + of tyInt..tyInt64, tyUInt8, tyUInt16: add result, reprInt(elem) + else: # data corrupt --> inform the user + add(result, " (invalid data!)") + +iterator setKeys(s: int): int {.inline.} = + # The type of s is a lie, but it's expected to be a set. + # Iterate over the JS object representing a set + # and returns the keys as int. + var len: int + var yieldRes: int + var i: int = 0 + {. emit: """ + var setObjKeys = Object.getOwnPropertyNames(`s`); + `len` = setObjKeys.length; + """ .} + while i < len: + {. emit: "`yieldRes` = parseInt(setObjKeys[`i`],10);\n" .} + yield yieldRes + inc i + +proc reprSetAux(result: var string, s: int, typ: PNimType) = + add(result, "{") + var first: bool = true + for el in setKeys(s): + if first: + first = false + else: + add(result, ", ") + addSetElem(result, el, typ.base) + add(result, "}") + +proc reprSet(e: int, typ: PNimType): string {.compilerRtl.} = + result = "" + reprSetAux(result, e, typ) + +type + ReprClosure {.final.} = object + recDepth: int # do not recurse endlessly + indent: int # indentation + +proc initReprClosure(cl: var ReprClosure) = + cl.recDepth = -1 # default is to display everything! + cl.indent = 0 + +proc reprAux(result: var string, p: pointer, typ: PNimType, cl: var ReprClosure) + +proc reprArray(a: pointer, typ: PNimType, + cl: var ReprClosure): string {.compilerRtl.} = + var isNilArrayOrSeq: bool + # isnil is not enough here as it would try to deref `a` without knowing what's inside + {. emit: """ + if (`a` == null) { + `isNilArrayOrSeq` = true; + } else if (`a`[0] == null) { + `isNilArrayOrSeq` = true; + } else { + `isNilArrayOrSeq` = false; + }; + """ .} + if typ.kind == tySequence and isNilArrayOrSeq: + return "nil" + + # We prepend @ to seq, the C backend prepends the pointer to the seq. + result = if typ.kind == tySequence: "@[" else: "[" + var len: int = 0 + var i: int = 0 + + {. emit: "`len` = `a`.length;\n" .} + var dereffed: pointer = a + for i in 0 .. < len: + if i > 0 : + add(result, ", ") + # advance pointer and point to element at index + {. emit: """ + `dereffed`_Idx = `i`; + `dereffed` = `a`[`dereffed`_Idx]; + """ .} + reprAux(result, dereffed, typ.base, cl) + + add(result, "]") + +proc isPointedToNil(p: pointer): bool {.inline.}= + {. emit: "if (`p` === null) {`result` = true};\n" .} + +proc reprRef(result: var string, p: pointer, typ: PNimType, + cl: var ReprClosure) = + if p.isPointedToNil: + add(result , "nil") + return + add( result, "ref " & reprPointer(p) ) + add(result, " --> ") + if typ.base.kind != tyArray: + {. emit: """ + if (`p` != null && `p`.length > 0) { + `p` = `p`[`p`_Idx]; + } + """ .} + reprAux(result, p, typ.base, cl) + +proc reprRecordAux(result: var string, o: pointer, typ: PNimType, cl: var ReprClosure) = + add(result, "[") + + var first: bool = true + var val: pointer = o + if typ.node.len == 0: + # if the object has only one field, len is 0 and sons is nil, the field is in node + let key: cstring = typ.node.name + add(result, $key & " = ") + {. emit: "`val` = `o`[`key`];\n" .} + reprAux(result, val, typ.node.typ, cl) + else: + # if the object has more than one field, sons is not nil and contains the fields. + for i in 0 .. unknown node type + e: uint = 1234567 + + doAssert(repr(a) == "254") + doAssert(repr(b) == "65300") + doAssert(repr(c) == "4294967290") + # doAssert(repr(d) == "18446744073709551610") + doAssert(repr(e) == "1234567") + +block floats: + let + a: float32 = 3.4e38'f32 + b: float64 = 1.7976931348623157e308'f64 + c: float = 1234.567e89 + + when defined js: + doAssert(repr(a) == "3.4e+38") # in C: 3.399999952144364e+038 + doAssert(repr(b) == "1.7976931348623157e+308") # in C: 1.797693134862316e+308 + doAssert(repr(c) == "1.234567e+92") # in C: 1.234567e+092 + +block bools: + let + a: bool = true + b: bool = false + + doAssert(repr(a) == "true") + doAssert(repr(b) == "false") + +block enums: + type + AnEnum = enum + aeA + aeB + aeC + HoledEnum = enum + heA = -12 + heB = 15 + heC = 123 + + doAssert(repr(aeA) == "aeA") + doAssert(repr(aeB) == "aeB") + doAssert(repr(aeC) == "aeC") + doAssert(repr(heA) == "heA") + doAssert(repr(heB) == "heB") + doAssert(repr(heC) == "heC") + +block chars: + let + a = 'a' + b = 'z' + one = '1' + nl = '\x0A' + + doAssert(repr(a) == "'a'") + doAssert(repr(b) == "'z'") + doAssert(repr(one) == "'1'") + doAssert(repr(nl) == "'\\10'") + +block strings: + let + a: string = "12345" + b: string = "hello,repr" + c: string = "hi\nthere" + when defined js: # C prepends the pointer, JS does not. + doAssert(repr(a) == "\"12345\"") + doAssert(repr(b) == "\"hello,repr\"") + doAssert(repr(c) == "\"hi\nthere\"") + +block sets: + let + a: set[int16] = {1'i16, 2'i16, 3'i16} + b: set[char] = {'A', 'k'} + + doAssert(repr(a) == "{1, 2, 3}") + doAssert(repr(b) == "{'A', 'k'}") + +block ranges: + let + a: range[0..12] = 6 + b: range[-12..0] = -6 + doAssert(repr(a) == "6") + doAssert(repr(b) == "-6") + +block tuples: + type + ATuple = tuple + a: int + b: float + c: string + d: OtherTuple + OtherTuple = tuple + a: bool + b: int8 + + let + ot: OtherTuple = (a: true, b: 120'i8) + t: ATuple = (a: 42, b: 12.34, c: "tuple", d: ot) + when defined js: + doAssert(repr(ot) == """ +[Field0 = true, +Field1 = 120] +""") + doAssert(repr(t) == """ +[Field0 = 42, +Field1 = 12.34, +Field2 = "tuple", +Field3 = [Field0 = true, +Field1 = 120]] +""") + +block objects: + type + AnObj = object + a: int + b: float + c: OtherObj + OtherObj = object + a: bool + b: int8 + let + oo: OtherObj = OtherObj(a: true, b: 120'i8) + o: AnObj = AnObj(a: 42, b: 12.34, c: oo) + + doAssert(repr(oo) == """ +[a = true, +b = 120] +""") + doAssert(repr(o) == """ +[a = 42, +b = 12.34, +c = [a = true, +b = 120]] +""") + +block arrays: + type + AObj = object + x: int + y: array[3,float] + let + a = [0.0, 1, 2] + b = [a, a, a] + o = AObj(x: 42, y: a) + c = [o, o, o] + d = ["hi", "array", "!"] + + doAssert(repr(a) == "[0.0, 1.0, 2.0]\n") + doAssert(repr(b) == "[[0.0, 1.0, 2.0], [0.0, 1.0, 2.0], [0.0, 1.0, 2.0]]\n") + doAssert(repr(c) == """ +[[x = 42, +y = [0.0, 1.0, 2.0]], [x = 42, +y = [0.0, 1.0, 2.0]], [x = 42, +y = [0.0, 1.0, 2.0]]] +""") + doAssert(repr(d) == "[\"hi\", \"array\", \"!\"]\n") + +block seqs: + type + AObj = object + x: int + y: seq[float] + let + a = @[0.0, 1, 2] + b = @[a, a, a] + o = AObj(x: 42, y: a) + c = @[o, o, o] + d = @["hi", "array", "!"] + + doAssert(repr(a) == "@[0.0, 1.0, 2.0]\n") + doAssert(repr(b) == "@[@[0.0, 1.0, 2.0], @[0.0, 1.0, 2.0], @[0.0, 1.0, 2.0]]\n") + doAssert(repr(c) == """ +@[[x = 42, +y = @[0.0, 1.0, 2.0]], [x = 42, +y = @[0.0, 1.0, 2.0]], [x = 42, +y = @[0.0, 1.0, 2.0]]] +""") + doAssert(repr(d) == "@[\"hi\", \"array\", \"!\"]\n") + +block ptrs: + type + AObj = object + x: ptr array[2, AObj] + y: int + var + a = [12.0, 13.0, 14.0] + b = addr a[0] + c = addr a[2] + d = AObj() + + doAssert(repr(a) == "[12.0, 13.0, 14.0]\n") + doAssert(repr(b) == "ref 0 --> 12.0\n") + doAssert(repr(c) == "ref 2 --> 14.0\n") + doAssert(repr(d) == """ +[x = nil, +y = 0] +""") + +block ptrs: + type + AObj = object + x: ref array[2, AObj] + y: int + var + a = AObj() + + new(a.x) + + doAssert(repr(a) == """ +[x = ref 0 --> [[x = nil, +y = 0], [x = nil, +y = 0]], +y = 0] +""") + +block procs: + proc test(): int = + echo "hello" + var + ptest = test + nilproc: proc(): int + + doAssert(repr(test) == "0\n") + doAssert(repr(ptest) == "0\n") + doAssert(repr(nilproc) == "nil\n") + +block bunch: + type + AnEnum = enum + eA, eB, eC + B = object + a: string + b: seq[char] + A = object + a: uint32 + b: int + c: float + d: char + e: AnEnum + f: string + g: set[char] + h: set[int16] + i: array[3,string] + j: seq[string] + k: range[-12..12] + l: B + m: ref B + n: ptr B + o: tuple[x: B, y: string] + p: proc(b: B): ref B + q: cstring + + proc refB(b:B):ref B = + new result + result[] = b + + var + aa: A + bb: B = B(a: "inner", b: @['o', 'b', 'j']) + cc: A = A(a: 12, b: 1, c: 1.2, d: '\0', e: eC, + f: "hello", g: {'A'}, h: {2'i16}, + i: ["hello", "world", "array"], + j: @["hello", "world", "seq"], k: -1, + l: bb, m: refB(bb), n: addr bb, + o: (bb, "tuple!"), p: refB, q: "cstringtest" ) + + doAssert(repr(aa) == """ +[a = 0, +b = 0, +c = 0.0, +d = '\0', +e = eA, +f = nil, +g = {}, +h = {}, +i = [nil, nil, nil], +j = nil, +k = 0, +l = [a = nil, +b = nil], +m = nil, +n = nil, +o = [Field0 = [a = nil, +b = nil], +Field1 = nil], +p = nil, +q = nil] +""") + doAssert(repr(cc) == """ +[a = 12, +b = 1, +c = 1.2, +d = '\0', +e = eC, +f = "hello", +g = {'A'}, +h = {2}, +i = ["hello", "world", "array"], +j = @["hello", "world", "seq"], +k = -1, +l = [a = "inner", +b = @['o', 'b', 'j']], +m = ref 0 --> [a = "inner", +b = @['o', 'b', 'j']], +n = ref 0 --> [a = "inner", +b = @['o', 'b', 'j']], +o = [Field0 = [a = "inner", +b = @['o', 'b', 'j']], +Field1 = "tuple!"], +p = 0, +q = "cstringtest"] +""") + +block another: + type + Size1 = enum + s1a, s1b + Size2 = enum + s2c=0, s2d=20000 + Size3 = enum + s3e=0, s3f=2000000000 + + doAssert(repr([s1a, s1b]) == "[s1a, s1b]\n") + doAssert(repr([s2c, s2d]) == "[s2c, s2d]\n") + doAssert(repr([s3e, s3f]) == "[s3e, s3f]\n") + +block another2: + + type + AnEnum = enum + en1, en2, en3, en4, en5, en6 + + Point {.final.} = object + x, y, z: int + s: array[0..1, string] + e: AnEnum + + var + p: Point + q: ref Point + s: seq[ref Point] + + p.x = 0 + p.y = 13 + p.z = 45 + p.s[0] = "abc" + p.s[1] = "xyz" + p.e = en6 + + new(q) + q[] = p + + s = @[q, q, q, q] + + doAssert(repr(p) == """ +[x = 0, +y = 13, +z = 45, +s = ["abc", "xyz"], +e = en6] +""") + doAssert(repr(q) == """ +ref 0 --> [x = 0, +y = 13, +z = 45, +s = ["abc", "xyz"], +e = en6] +""") + doAssert(repr(s) == """ +@[ref 0 --> [x = 0, +y = 13, +z = 45, +s = ["abc", "xyz"], +e = en6], ref 1 --> [x = 0, +y = 13, +z = 45, +s = ["abc", "xyz"], +e = en6], ref 2 --> [x = 0, +y = 13, +z = 45, +s = ["abc", "xyz"], +e = en6], ref 3 --> [x = 0, +y = 13, +z = 45, +s = ["abc", "xyz"], +e = en6]] +""") + doAssert(repr(en4) == "en4") + + doAssert(repr({'a'..'p'}) == "{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p'}") diff --git a/web/news/e031_version_0_16_2.rst b/web/news/e031_version_0_16_2.rst index cc17052f7e..d34c7de530 100644 --- a/web/news/e031_version_0_16_2.rst +++ b/web/news/e031_version_0_16_2.rst @@ -45,11 +45,12 @@ Changes affecting backwards compatibility - If the dispatcher parameter's value used in multi method is ``nil``, a ``NilError`` exception is raised. The old behavior was that the method would be a ``nop`` then. +- ``posix.nim``: the family of ``ntohs`` procs now takes unsigned integers + instead of signed integers. - In Nim identifiers en-dash (Unicode point U+2013) is not an alias for the underscore anymore. Use underscores and fix your programming font instead. - Library Additions -----------------