update to support Nim v1.6 and v2

.github/workflows/playground.yml

@@ -0,0 +1,60 @@
+name: playground-deploy
+
+# yamllint disable-line rule:truthy
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - v*.*
+  workflow_dispatch:
+
+env:
+  nim-version: 'stable'
+  git-repo-url: https://github.com/${{ github.repository }}
+  deploy-dir: .gh-pages
+jobs:
+  docs:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+    - uses: actions/checkout@v4
+    - name: Cache nimble
+      id: cache-nimble
+      uses: actions/cache@v4
+      with:
+          path: ~/.nimble
+          key: ${{ runner.os }}-nimble
+    - uses: jiro4989/setup-nim-action@v1
+      with:
+        nim-version: ${{ env.nim-version }}
+    - name: install karax
+      run: nimble install karax
+    - name: buildKarax
+      run: |
+        nimble buildKarax \
+        -d:homepage="${{ github.event.repository.homepage }}" -d:gitRepoUrl="${{ env.git-repo-url }}" \
+        -d:release --opt:size --includeJs \
+        --htmlName=index 
+    - name: "CNAME"
+      run: mkdir ${{ env.deploy-dir }} || true
+    - name: mv to deploy dir
+      run: mv index.html ${{ env.deploy-dir }}/index.html
+    - name: create deploy-dir if needed
+      run: |
+        cname=$(echo ${{ github.event.repository.homepage }} | grep -oP 'https?://\K[^/]+')
+        prefix="play."
+        # py: if not cname.startswith(prefix)
+        # bash: if [[ "${cname}" != $prefix* ]]
+        if [ ${cname##$prefix} = $cname ]; then  
+            cname="${prefix}${cname}"
+        fi
+        echo -n $cname > ${{ env.deploy-dir }}/CNAME
+        # We must re-build CNAME as we use 'peaceiris/actions-gh-pages@v4',
+        # where the old dir (including CNAME) will be purged.
+    - name: Deploy documents
+      uses: peaceiris/actions-gh-pages@v4
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        publish_dir: ${{ env.deploy-dir }}

.gitignore

@@ -8,3 +8,8 @@ trash/
 ./Objects/test.nim
 
 __pycache__/
+/bin/
+/app.html
+/app.js
+/npython.html
+/npython.js

Modules/getbuildinfo.nim

@@ -0,0 +1,55 @@
+
+
+when NimMajor > 1:
+  from std/paths import `/../`, Path, parentDir
+  template `/../`(a, b: string): untyped = string(Path(a) /../ Path b)
+  template parentDir(a: string): untyped = string(Path(a).parentDir)
+else:
+  from std/os import `/../`, parentDir
+import ./os_findExe_patch
+from std/strutils import stripLineEnd
+
+## see CPython/configure.ac
+
+const gitExe{.strdefine: "git".} = findExe("git")
+const git = (exe: gitExe)
+when git.exe == "":
+  template exec(git; sub: string): string = ""
+else:
+  const srcdir_git = currentSourcePath().parentDir /../ ".git"
+  template exec(git: typeof(git); sub: string): string =
+    bind srcdir_git
+    let res = gorgeEx(git.exe & " --git-dir " & srcdir_git & " " & sub)
+    assert res.exitCode == 0, res.output
+    var outp = res.output
+    outp.stripLineEnd
+    outp
+
+const
+  version = git.exec"rev-parse --short HEAD"
+  tag = git.exec"describe --all --always --dirty"
+  branch = git.exec"name-rev --name-only HEAD"
+
+proc gitidentifier*: string =
+  result = tag
+  if result != "" and result != "undefined":
+    return
+  result = branch
+
+
+proc getBuildInfo: string{.compileTime.} =
+  let revision = version
+  result = gitidentifier()
+  if revision != "":
+    result.add ':'
+    result.add revision
+
+  result.add ", "
+
+  #result.add &"{CompileDate:.20s}, {CompileTime:.9s}"
+  result.add CompileDate.substr(0, 19)
+  result.add ", "
+  result.add CompileTime.substr(0, 8)
+
+const buildinfo = getBuildInfo()
+proc Py_GetBuildInfo*: string = buildinfo

Modules/os_findExe_patch.nim

@@ -0,0 +1,48 @@
+
+import std/os
+import std/strutils
+
+when defined(js) and not compiles(static(fileExists".")):  
+  proc fileExists(fp: string): bool = true  # XXX: TODO: I've tried many ways
+  # to support compile-time check, but Nim just rejects when JS
+
+when true:
+  # copied from std/os, removed `readlink` part, see `XXX` below
+  proc findExe*(exe: string, followSymlinks: bool = true;
+                extensions: openArray[string]=ExeExts): string {.
+    tags: [ReadDirEffect, ReadEnvEffect, ReadIOEffect].} =
+    ## Searches for `exe` in the current working directory and then
+    ## in directories listed in the ``PATH`` environment variable.
+    ##
+    ## Returns `""` if the `exe` cannot be found. `exe`
+    ## is added the `ExeExts`_ file extensions if it has none.
+    ##
+    ## If the system supports symlinks it also resolves them until it
+    ## meets the actual file. This behavior can be disabled if desired
+    ## by setting `followSymlinks = false`.
+
+    if exe.len == 0: return
+    template checkCurrentDir() =
+      for ext in extensions:
+        result = addFileExt(exe, ext)
+        if fileExists(result): return
+    when defined(posix):
+      if '/' in exe: checkCurrentDir()
+    else:
+      checkCurrentDir()
+    let path = getEnv("PATH")
+    for candidate in split(path, PathSep):
+      if candidate.len == 0: continue
+      when defined(windows):
+        var x = (if candidate[0] == '"' and candidate[^1] == '"':
+                  substr(candidate, 1, candidate.len-2) else: candidate) /
+                exe
+      else:
+        var x = expandTilde(candidate) / exe
+      for ext in extensions:
+        var x = addFileExt(x, ext)
+        if fileExists(x):
+          # XXX: there was a branch of `when ...`, which doesn't work on nimvm
+          #  due to `readlink`, so removed
+          return x
+    result = ""

Objects/abstract.nim

@@ -0,0 +1,67 @@
+
+import std/strformat
+import ./pyobject
+import ./numobjects
+import ./[iterobject, exceptions, stringobject]
+export PyNumber_Index, PyNumber_AsSsize_t, PyNumber_AsClampedSsize_t
+
+
+template optionalTLikeArg[T](args; i: int, def: T; mapper): T =
+  if args.len > i: mapper args[i]
+  else: def
+
+template numAsIntOrRetE*(x: PyObject): int =
+  ## interpret int or int-able object `x` to `system.int`
+  var res: int
+  let e = x.PyNumber_AsSsize_t res
+  if not e.isNil:
+    return e
+  res
+
+template numAsClampedIndexOrRetE*(x: PyObject; size: int): int =
+  ## interpret int or int-able object `x` to `system.int`, clamping result in `0..<size`
+  let intObj = x.PyNumber_Index
+  if intObj.isThrownException:
+    return intObj
+  intObj.PyIntObject.getClampedIndex(size)
+
+template intLikeOptArgAt*(args: seq[PyObject]; i: int, def: int): int =
+  ## parse arg `x: Optional[<object has __index__>] = None`
+  bind optionalTLikeArg, numAsIntOrRetE
+  optionalTLikeArg(args, i, def, numAsIntOrRetE)
+
+template clampedIndexOptArgAt*(args: seq[PyObject]; i: int, def: int, size: int): int =
+  ## parse arg `x: Optional[<object has __index__>] = None`, clamped result in `0..<size`
+  bind optionalTLikeArg, numAsIntOrRetE
+  template t(x): int{.genSym.} =
+    numAsClampedIndexOrRetE(x, size)
+  optionalTLikeArg(args, i, def, t)
+
+template PySequence_Check*(o: PyObject): bool =
+  ## PY-DIFF: we check whether o has items: seq[PyObject]
+  when not compiles(o.items): false
+  else: o.items is seq[PyObject]
+template ifPySequence_Check*(o: PyObject, body) =
+  when PySequence_Check(o): body
+template ifPySequence_Check*(o: PyObject, body, elseDo): untyped =
+  when PySequence_Check(o): body
+  else: elseDo
+
+proc PyIter_Check*(obj: PyObject): bool =
+  let t = obj.getMagic(iternext)
+  not t.isNil  # PY-DIFF: never be _PyObject_NextNotImplemented
+
+template PyObject_GetIter*(o: PyObject): PyObject =
+  bind newTypeError, newPyStr, getMagic, newPySeqIter
+  bind fmt, formatValue
+  bind ifPySequence_Check
+  let f = o.getMagic(iter)
+  if f.isNil:
+    ifPySequence_Check(o):
+      newPySeqIter(o.items)
+    do:
+      let n{.inject.} = o.pyType.name
+      newTypeError newPyStr(
+        fmt"'{n:.200s}' object is not iterable"
+      )
+  else: f(o)

Objects/boolobject.nim

@@ -3,10 +3,14 @@ import pyobject
 declarePyType Bool(tpToken):
   b: bool
 
-proc newPyBool(b: bool): PyBoolObject = 
+proc newPyBoolInner(b: bool): PyBoolObject = 
   result = newPyBoolSimple()
   result.b = b
 
 
-let pyTrueObj* = newPyBool(true)
-let pyFalseObj* = newPyBool(false)
+let pyTrueObj* = newPyBoolInner(true)  ## singleton
+let pyFalseObj* = newPyBoolInner(false)  ## singleton
+
+proc newPyBool*(b: bool): PyBoolObject =
+  if b: pyTrueObj
+  else: pyFalseObj

Objects/boolobjectImpl.nim

@@ -5,22 +5,19 @@ import macros
 import pyobject
 import exceptions
 import stringobject
-import boolobject
+import ./boolobject
+export boolobject
 import numobjects
+import ./noneobject
 
-export boolobject
 
 method `$`*(obj: PyBoolObject): string = 
   $obj.b
 
 methodMacroTmpl(Bool)
 
 implBoolMagic Not:
-  if self == pyTrueObj:
-    pyFalseObj
-  else:
-    pyTrueObj
-
+  newPyBool self != pyTrueObj
 
 implBoolMagic bool:
   self
@@ -29,41 +26,57 @@ implBoolMagic bool:
 implBoolMagic And:
   let otherBoolObj = other.callMagic(bool)
   errorIfNotBool(otherBoolObj, "__bool__")
-  if self.b and PyBoolObject(otherBoolObj).b:
-    return pyTrueObj
-  else:
-    return pyFalseObj
+  newPyBool self.b and PyBoolObject(otherBoolObj).b
 
 implBoolMagic Xor:
   let otherBoolObj = other.callMagic(bool)
   errorIfNotBool(otherBoolObj, "__bool__")
-  if self.b xor PyBoolObject(otherBoolObj).b:
-    return pyTrueObj
-  else:
-    return pyFalseObj
+  newPyBool self.b xor PyBoolObject(otherBoolObj).b
 
 implBoolMagic Or:
   let otherBoolObj = other.callMagic(bool)
   errorIfNotBool(otherBoolObj, "__bool__")
-  if self.b or PyBoolObject(otherBoolObj).b:
-    return pyTrueObj
-  else:
-    return pyFalseObj
+  newPyBool self.b or PyBoolObject(otherBoolObj).b
 
 implBoolMagic eq:
   let otherBoolObj = other.callMagic(bool)
   errorIfNotBool(otherBoolObj, "__bool__")
   let otherBool = PyBoolObject(otherBoolObj).b
-  if self.b == otherBool:
-    return pyTrueObj
-  else:
-    return pyFalseObj
+  newPyBool self.b == otherBool
 
 implBoolMagic repr:
   if self.b:
-    return newPyString("True")
+    return newPyAscii("True")
   else:
-    return newPyString("False")
+    return newPyAscii("False")
 
 implBoolMagic hash:
   newPyInt(Hash(self.b))
+
+
+proc PyObject_IsTrue*(v: PyObject, res: var bool): PyBaseErrorObject =
+  template ret(b: bool) =
+    res = b
+    return nil
+  if v == pyTrueObj: ret true
+  if v == pyFalseObj: ret false
+  if v == pyNone: ret false
+  let boolMag = v.getMagic(bool)
+  if not boolMag.isNil:
+    let obj = boolMag(v)
+    errorIfNotBool obj, "__bool__"
+    ret obj.PyBoolObject.b
+  elif not v.getMagic(len).isNil:
+    let obj = v.getMagic(len)(v)
+    errorIfNot int, obj, "__bool__"
+    ret obj.PyIntObject.positive
+  # We currently don't define:
+  #   as_sequence
+  #   as_mapping
+  ret true
+
+implBoolMagic New(tp: PyObject, obj: PyObject):
+  var b: bool
+  retIfExc PyObject_IsTrue(obj, b)
+  newPyBool b
+

Objects/bundle.nim

@@ -2,9 +2,9 @@ import baseBundle
 import codeobject, dictobject, frameobject, boolobjectImpl,
   listobject, moduleobject, methodobject, funcobject,
   pyobject, stringobjectImpl, rangeobject, exceptionsImpl,
-  sliceobject, tupleobject, cellobject, methodobject
+  sliceobject, tupleobjectImpl, cellobject, setobject
 export baseBundle
 export codeobject, dictobject, frameobject,  boolobjectImpl,
   listobject, moduleobject, methodobject, funcobject,
   pyobject, stringobjectImpl, rangeobject, exceptionsImpl,
-  sliceobject, tupleobject, cellobject, methodobject
+  sliceobject, tupleobjectImpl, cellobject, setobject