Add varargs to defines, defines as C imports, and CLI mangle option (#222)

* adjust parser to accept C preprocessor vararg macros
* enable setting define's as imports
* fixing handling of untyped arguments
* setup constant defines to be var importable
* var define kind of working
* fixing outputting var consts
* adding mangle option for command line

Co-authored-by: Jaremy J. Creechley <[email protected]>

Author: elcritch

c2nim.nim

@@ -41,11 +41,17 @@ Options:
   --noconv               annotate procs with ``{.noconv.}``
   --stdcall              annotate procs with ``{.stdcall.}``
   --importc              annotate procs with ``{.importc.}``
+  --importdefines        import C defines as procs or vars with ``{.importc.}``
+  --importfuncdefines    import C define funcs as procs with ``{.importc.}``
   --ref                  convert typ* to ref typ (default: ptr typ)
   --prefix:PREFIX        strip prefix for the generated Nim identifiers
                          (multiple --prefix options are supported)
   --suffix:SUFFIX        strip suffix for the generated Nim identifiers
                          (multiple --suffix options are supported)
+  --mangle:PEG=FORMAT    extra PEG expression to mangle identifiers,
+                         for example `--mangle:'{u?}int{\d+}_t=$1int$2'` to
+                         convert C <stdint.h> to Nim equivalents
+                         (multiple --mangle options are supported)
   --paramprefix:PREFIX   add prefix to parameter name of the generated Nim proc
   --assumedef:IDENT      skips #ifndef sections for the given C identifier
                          (multiple --assumedef options are supported)

compiler/renderer.nim

@@ -1173,7 +1173,13 @@ proc gsub(g: var TSrcGen, n: PNode, c: TContext) =
     else:
       put(g, tkPtr, "ptr")
   of nkVarTy:
-    if sonsLen(n) > 0:
+    if sonsLen(n) > 2 and n.sons[1].kind == nkPragma:
+      putWithSpace(g, tkVar, "var")
+      gsub(g, n.sons[0])
+      gsub(g, n.sons[1])
+      putWithSpace(g, tkColon, ":")
+      gsub(g, n.sons[2])
+    elif sonsLen(n) > 0:
       putWithSpace(g, tkVar, "var")
       gsub(g, n.sons[0])
     else:

cparser.nim

@@ -65,7 +65,8 @@ type
     classes: StringTableRef
     toPreprocess: StringTableRef
     inheritable: StringTableRef
-    debugMode, followNep1, useHeader: bool
+    debugMode, followNep1: bool
+    useHeader, importdefines, importfuncdefines: bool
     discardablePrefixes: seq[string]
     constructor, destructor, importcLit: string
     exportPrefix*: string
@@ -148,6 +149,10 @@ proc setOption*(parserOptions: PParserOptions, key: string, val=""): bool =
   of "header":
     parserOptions.useHeader = true
     if val.len > 0: parserOptions.headerOverride = val
+  of "importfuncdefines":
+    parserOptions.importfuncdefines = true
+  of "importdefines":
+    parserOptions.importdefines = true
   of "cdecl": incl(parserOptions.flags, pfCdecl)
   of "stdcall": incl(parserOptions.flags, pfStdCall)
   of "importc": incl(parserOptions.flags, pfImportc)
@@ -158,6 +163,9 @@ proc setOption*(parserOptions: PParserOptions, key: string, val=""): bool =
     if val.len > 0: parserOptions.paramPrefix = val
   of "assumedef": parserOptions.assumeDef.add(val)
   of "assumendef": parserOptions.assumenDef.add(val)
+  of "mangle":
+    let vals = val.split("=")
+    parserOptions.mangleRules.add((parsePeg(vals[0]), vals[1]))
   of "skipinclude": incl(parserOptions.flags, pfSkipInclude)
   of "typeprefixes": incl(parserOptions.flags, pfTypePrefixes)
   of "skipcomments": incl(parserOptions.flags, pfSkipComments)

preprocessor.nim

@@ -54,14 +54,28 @@ proc parseDefine(p: var Parser; hasParams: bool): PNode =
     addSon(params, emptyNode)
     if p.tok.xkind != pxParRi:
       var identDefs = newNodeP(nkIdentDefs, p)
+      var isVariable = false
       while p.tok.xkind != pxParRi:
+        if p.tok.xkind == pxDotDotDot:
+          isVariable = true
+          getTok(p)
+          break
         addSon(identDefs, skipIdent(p, skParam))
         skipStarCom(p, nil)
         if p.tok.xkind != pxComma: break
         getTok(p)
       addSon(identDefs, newIdentNodeP("untyped", p))
       addSon(identDefs, emptyNode)
       addSon(params, identDefs)
+      if isVariable:
+        var vdefs = newNodeP(nkExprColonExpr, p)
+        addSon(vdefs, newIdentNodeP("xargs", p))
+        var vdecl =
+          newTree(nkBracketExpr, 
+            newIdentNodeP("varargs", p),
+            newIdentNodeP("untyped", p))
+        addSon(vdefs, vdecl)
+        addSon(params, vdefs)
     eat(p, pxParRi)
 
     addSon(result, emptyNode) # no generic parameters
@@ -91,6 +105,78 @@ proc parseDefine(p: var Parser; hasParams: bool): PNode =
         break
   assert result != nil
 
+proc parseDefineAsDecls(p: var Parser; hasParams: bool): PNode =
+  var origName = p.tok.s
+  if hasParams:
+    # a macro with parameters:
+    result = newNodeP(nkProcDef, p)
+    var name = skipIdentExport(p, skTemplate)
+    addSon(result, name)
+    addSon(result, emptyNode)
+    eat(p, pxParLe)
+    var params = newNodeP(nkFormalParams, p)
+    # return type; not known yet:
+    addSon(params, emptyNode)
+
+    var pragmas = newNodeP(nkPragma, p)
+
+    if p.tok.xkind != pxParRi:
+      while p.tok.xkind != pxParRi:
+        if p.tok.xkind == pxDotDotDot: # handle varargs
+          getTok(p)
+          addSon(pragmas, newIdentNodeP("varargs", p))
+          break
+        else:
+          var vdefs = newTree(nkExprColonExpr,
+            skipIdent(p, skParam),
+            newIdentNodeP("untyped", p))
+          addSon(params, vdefs)
+
+          skipStarCom(p, nil)
+          if p.tok.xkind != pxComma:
+            break
+          getTok(p)
+
+    eat(p, pxParRi)
+
+    let iname = cppImportName(p, origName)
+    addSon(pragmas,
+      newIdentStrLitPair(p.options.importcLit, iname, p),
+      getHeaderPair(p))
+
+    addSon(result, emptyNode) # no generic parameters
+    addSon(result, params)
+    addSon(result, pragmas) 
+    addSon(result, emptyNode)
+
+    addSon(result, emptyNode)
+    skipLine(p)
+
+  else:
+    # a macro without parameters:
+    result = newNodeP(nkVarTy, p)
+
+    while true:
+      let vname = skipIdentExport(p, skConst)
+      # skipStarCom(p, result)
+      let iname = cppImportName(p, origName)
+      var vpragmas = newNodeP(nkPragma, p)
+      addSon(vpragmas, newIdentStrLitPair(p.options.importcLit, iname, p))
+      addSon(vpragmas, getHeaderPair(p))
+      let vtype = newIdentNodeP("int", p)
+
+      addSon(result, vname)
+      addSon(result, vpragmas)
+      addSon(result, vtype)
+
+      skipCom(p, result)
+      skipLine(p) # eat the rest of the define, skip parsing
+      if p.tok.xkind == pxDirective and p.tok.s == "define":
+        getTok(p)
+      else:
+        break
+  assert result != nil
+
 proc dontTranslateToTemplateHeuristic(body: seq[ref Token]; closedParentheses: int): bool =
   # we list all **binary** operators here too: As these cannot start an
   # expression, we know the resulting #define cannot be a valid Nim template.
@@ -184,6 +270,9 @@ proc parseDef(p: var Parser, m: var Macro; hasParams: bool): bool =
   if hasParams:
     eat(p, pxParLe)
     while p.tok.xkind != pxParRi:
+      if p.tok.xkind == pxDotDotDot:
+        getTok(p)
+        break
       expectIdent(p)
       params.add(p.tok.s)
       getTok(p)
@@ -510,7 +599,12 @@ proc parseDir(p: var Parser; sectionParser: SectionParser): PNode =
     if not parseDef(p, p.options.macros[L], hasParams) and not isDefOverride:
       setLen(p.options.macros, L)
       backtrackContext(p)
-      result = parseDefine(p, hasParams)
+      if p.options.importdefines:
+        result = parseDefineAsDecls(p, hasParams)
+      elif p.options.importfuncdefines and hasParams:
+        result = parseDefineAsDecls(p, hasParams)
+      else:
+        result = parseDefine(p, hasParams)
     else:
       closeContext(p)