cbuilder: second half of cgen

compiler/cbuilderbase.nim

@@ -42,6 +42,12 @@ proc addLineEndDedent*(builder: var Builder, s: string) =
   builder.addDedent(s)
   builder.addNewline()
 
+proc addLineComment*(builder: var Builder, comment: string) =
+  # probably no-op on nifc
+  builder.add("// ")
+  builder.add(comment)
+  builder.addNewline()
+
 proc addIntValue*(builder: var Builder, val: int) =
   builder.buf.addInt(val)
 

compiler/cbuilderdecls.nim

@@ -468,6 +468,19 @@ proc addUnnamedParam(builder: var Builder, params: var ProcParamBuilder, typ: Sn
     params.needsComma = true
   builder.add(typ)
 
+proc addProcTypedParam(builder: var Builder, paramBuilder: var ProcParamBuilder, callConv: TCallingConvention, name: string, rettype, params: Snippet) =
+  if paramBuilder.needsComma:
+    builder.add(", ")
+  else:
+    paramBuilder.needsComma = true
+  builder.add(CallingConvToStr[callConv])
+  builder.add("_PTR(")
+  builder.add(rettype)
+  builder.add(", ")
+  builder.add(name)
+  builder.add(")")
+  builder.add(params)
+
 proc addVarargsParam(builder: var Builder, params: var ProcParamBuilder) =
   # does not exist in NIFC, needs to be proc pragma
   if params.needsComma:
@@ -481,6 +494,20 @@ template addProcParams(builder: var Builder, params: out ProcParamBuilder, body:
   body
   finishProcParamBuilder(builder, params)
 
+type SimpleProcParam = tuple
+  name, typ: string
+
+proc cProcParams(params: varargs[SimpleProcParam]): Snippet =
+  if params.len == 0: return "(void)"
+  result = "("
+  for i in 0 ..< params.len:
+    if i != 0: result.add(", ")
+    result.add(params[i].typ)
+    if params[i].name.len != 0:
+      result.add(" ")
+      result.add(params[i].name)
+  result.add(")")
+
 template addProcHeaderWithParams(builder: var Builder, callConv: TCallingConvention,
                                  name: string, rettype: Snippet, paramBuilder: typed) =
   # on nifc should build something like (proc name params type pragmas
@@ -502,6 +529,15 @@ proc addProcHeader(builder: var Builder, callConv: TCallingConvention,
   addProcHeaderWithParams(builder, callConv, name, rettype):
     builder.add(params)
 
+proc addProcHeader(builder: var Builder, name: string, rettype, params: Snippet, isConstructor = false) =
+  # no callconv
+  builder.add(rettype)
+  builder.add(" ")
+  if isConstructor:
+    builder.add("__attribute__((constructor)) ")
+  builder.add(name)
+  builder.add(params)
+
 proc addProcHeader(builder: var Builder, m: BModule, prc: PSym, name: string, params, rettype: Snippet, addAttributes: bool) =
   # on nifc should build something like (proc name params type pragmas
   # with no body given
@@ -560,14 +596,33 @@ proc addProcVar(builder: var Builder, m: BModule, prc: PSym, name: string, param
   builder.addLineEnd(";")
 
 proc addProcVar(builder: var Builder, callConv: TCallingConvention,
-                name: string, params, rettype: Snippet, isStatic = false) =
+                name: string, params, rettype: Snippet,
+                isStatic = false, isVolatile = false) =
   # on nifc, builds full variable
   if isStatic:
     builder.add("static ")
   builder.add(CallingConvToStr[callConv])
   builder.add("_PTR(")
   builder.add(rettype)
   builder.add(", ")
+  if isVolatile:
+    builder.add("volatile ")
+  builder.add(name)
+  builder.add(")")
+  builder.add(params)
+  # ensure we are just adding a variable:
+  builder.addLineEnd(";")
+
+proc addProcVar(builder: var Builder,
+                name: string, params, rettype: Snippet,
+                isStatic = false, isVolatile = false) =
+  # no callconv
+  if isStatic:
+    builder.add("static ")
+  builder.add(rettype)
+  builder.add(" (*")
+  if isVolatile:
+    builder.add("volatile ")
   builder.add(name)
   builder.add(")")
   builder.add(params)

compiler/cbuilderexprs.nim

@@ -14,6 +14,9 @@ proc ptrConstType(t: Snippet): Snippet =
 proc ptrType(t: Snippet): Snippet =
   t & "*"
 
+proc cppRefType(t: Snippet): Snippet =
+  t & "&"
+
 const
   CallingConvToStr: array[TCallingConvention, string] = ["N_NIMCALL",
     "N_STDCALL", "N_CDECL", "N_SAFECALL",
@@ -32,6 +35,20 @@ proc procPtrTypeUnnamedNimCall(rettype, params: Snippet): Snippet =
 proc procPtrTypeUnnamed(callConv: TCallingConvention, rettype, params: Snippet): Snippet =
   CallingConvToStr[callConv] & "_PTR(" & rettype & ", )" & params
 
+type CppCaptureKind = enum None, ByReference, ByCopy
+
+template addCppLambda(builder: var Builder, captures: CppCaptureKind, params: Snippet, body: typed) =
+  builder.add("[")
+  case captures
+  of None: discard
+  of ByReference: builder.add("&")
+  of ByCopy: builder.add("=")
+  builder.add("] ")
+  builder.add(params)
+  builder.addLineEndIndent(" {")
+  body
+  builder.addLineEndDedent("}")
+
 proc cCast(typ, value: Snippet): Snippet =
   "((" & typ & ") " & value & ")"
 

compiler/ccgthreadvars.nim

@@ -59,9 +59,6 @@ proc generateThreadVarsSize(m: BModule) =
                        sfCompileToCpp in m.module.flags: ExternC
                   else: None
     m.s[cfsProcs].addDeclWithVisibility(externc):
-      m.s[cfsProcs].addProcHeaderWithParams(ccNoConvention, "NimThreadVarsSize", "NI"):
-        var params: ProcParamBuilder
-        m.s[cfsProcs].addProcParams(params):
-          discard
+      m.s[cfsProcs].addProcHeader("NimThreadVarsSize", "NI", cProcParams())
       m.s[cfsProcs].finishProcHeaderWithBody():
         m.s[cfsProcs].addReturn(cCast("NI", cSizeof("NimThreadVars")))