diff options
Diffstat (limited to 'tests/manyloc/keineschweine/dependencies/genpacket')
4 files changed, 27 insertions, 322 deletions
diff --git a/tests/manyloc/keineschweine/dependencies/genpacket/genpacket.nim b/tests/manyloc/keineschweine/dependencies/genpacket/genpacket.nim deleted file mode 100644 index 3026cc4b9..000000000 --- a/tests/manyloc/keineschweine/dependencies/genpacket/genpacket.nim +++ /dev/null @@ -1,295 +0,0 @@ -import macros, macro_dsl, streams, streams_enh -from strutils import format - -template newLenName(): stmt {.immediate.} = - let lenName {.inject.} = ^("len"& $lenNames) - inc(lenNames) - -template defPacketImports*(): stmt {.immediate, dirty.} = - import macros, macro_dsl, streams, streams_enh - from strutils import format - -proc `$`*[T](x: seq[T]): string = - result = "[seq len=" - result.add($x.len) - result.add ':' - for i in 0.. <len(x): - result.add " " - result.add($x[i]) - result.add ']' - -macro defPacket*(typeNameN: expr, typeFields: expr): stmt {.immediate.} = - result = newNimNode(nnkStmtList) - let - typeName = quoted2ident(typeNameN) - packetID = ^"p" - streamID = ^"s" - var - constructorParams = newNimNode(nnkFormalParams).und(typeName) - constructor = newNimNode(nnkProcDef).und( - postfix(^("new"& $typeName.ident), "*"), - emptyNode(), - emptyNode(), - constructorParams, - emptyNode(), - emptyNode()) - pack = newNimNode(nnkProcDef).und( - postfix(^"pack", "*"), - emptyNode(), - emptyNode(), - newNimNode(nnkFormalParams).und( - emptyNode(), # : void - newNimNode(nnkIdentDefs).und( - packetID, # p: var typeName - newNimNode(nnkVarTy).und(typeName), - emptyNode()), - newNimNode(nnkIdentDefs).und( - streamID, # s: PStream - ^"PStream", - newNimNode(nnkNilLit))), - emptyNode(), - emptyNode()) - read = newNimNode(nnkProcDef).und( - newIdentNode("read"& $typeName.ident).postfix("*"), - emptyNode(), - emptyNode(), - newNimNode(nnkFormalParams).und( - typeName, #result type - newNimNode(nnkIdentDefs).und( - streamID, # s: PStream = nil - ^"PStream", - newNimNode(nnkNilLit))), - emptyNode(), - emptyNode()) - constructorBody = newNimNode(nnkStmtList) - packBody = newNimNode(nnkStmtList) - readBody = newNimNode(nnkStmtList) - lenNames = 0 - for i in 0.. typeFields.len - 1: - let - name = typeFields[i][0] - dotName = packetID.dot(name) - resName = newIdentNode(!"result").dot(name) - case typeFields[i][1].kind - of nnkBracketExpr: #ex: paddedstring[32, '\0'], array[range, type] - case $typeFields[i][1][0].ident - of "paddedstring": - let length = typeFields[i][1][1] - let padChar = typeFields[i][1][2] - packBody.add(newCall( - "writePaddedStr", streamID, dotName, length, padChar)) - ## result.name = readPaddedStr(s, length, char) - readBody.add(resName := newCall( - "readPaddedStr", streamID, length, padChar)) - ## make the type a string - typeFields[i] = newNimNode(nnkIdentDefs).und( - name, - ^"string", - newNimNode(nnkEmpty)) - of "array": - readBody.add( - newNimNode(nnkDiscardStmt).und( - newCall("readData", streamID, newNimNode(nnkAddr).und(resName), newCall("sizeof", resName)))) - packBody.add( - newCall("writeData", streamID, newNimNode(nnkAddr).und(dotName), newCall("sizeof", dotName))) - of "seq": - ## let lenX = readInt16(s) - newLenName() - let - item = ^"item" ## item name in our iterators - seqType = typeFields[i][1][1] ## type of seq - readName = newIdentNode("read"& $seqType.ident) - readBody.add(newNimNode(nnkLetSection).und( - newNimNode(nnkIdentDefs).und( - lenName, - newNimNode(nnkEmpty), - newCall("readInt16", streamID)))) - readBody.add( ## result.name = @[] - resName := ("@".prefix(newNimNode(nnkBracket))), - newNimNode(nnkForStmt).und( ## for item in 1..len: - item, - infix(1.lit, "..", lenName), - newNimNode(nnkStmtList).und( - newCall( ## add(result.name, unpack[seqType](stream)) - "add", resName, newNimNode(nnkCall).und(readName, streamID) - ) ) ) ) - packbody.add( - newNimNode(nnkVarSection).und(newNimNode(nnkIdentDefs).und( - lenName, ## var lenName = int16(len(p.name)) - newIdentNode("int16"), - newCall("int16", newCall("len", dotName)))), - newCall("writeData", streamID, newNimNode(nnkAddr).und(lenName), 2.lit), - newNimNode(nnkForStmt).und( ## for item in 0..length - 1: pack(p.name[item], stream) - item, - infix(0.lit, "..", infix(lenName, "-", 1.lit)), - newNimNode(nnkStmtList).und( - newCall("echo", item, ": ".lit), - newCall("pack", dotName[item], streamID)))) - #set the default value to @[] (new sequence) - typeFields[i][2] = "@".prefix(newNimNode(nnkBracket)) - else: - error("Unknown type: "& treeRepr(typeFields[i])) - of nnkIdent: ##normal type - case $typeFields[i][1].ident - of "string": # length encoded string - packBody.add(newCall("writeLEStr", streamID, dotName)) - readBody.add(resName := newCall("readLEStr", streamID)) - of "int8", "int16", "int32", "float32", "float64", "char", "bool": - packBody.add(newCall( - "writeData", streamID, newNimNode(nnkAddr).und(dotName), newCall("sizeof", dotName))) - readBody.add(resName := newCall("read"& $typeFields[i][1].ident, streamID)) - else: ## hopefully the type you specified was another defpacket() type - packBody.add(newCall("pack", dotName, streamID)) - readBody.add(resName := newCall("read"& $typeFields[i][1].ident, streamID)) - else: - error("I dont know what to do with: "& treerepr(typeFields[i])) - - var - toStringFunc = newNimNode(nnkProcDef).und( - newNimNode(nnkPostfix).und( - ^"*", - newNimNode(nnkAccQuoted).und(^"$")), - emptyNode(), - emptyNode(), - newNimNode(nnkFormalParams).und( - ^"string", - newNimNode(nnkIdentDefs).und( - packetID, # p: typeName - typeName, - emptyNode())), - emptyNode(), - emptyNode(), - newNimNode(nnkStmtList).und(#[6] - newNimNode(nnkAsgn).und( - ^"result", ## result = - newNimNode(nnkCall).und(#[6][0][1] - ^"format", ## format - emptyNode())))) ## "[TypeName $1 $2]" - formatStr = "["& $typeName.ident - - const emptyFields = {nnkEmpty, nnkNilLit} - var objFields = newNimNode(nnkRecList) - for i in 0.. < len(typeFields): - let fname = typeFields[i][0] - constructorParams.add(newNimNode(nnkIdentDefs).und( - fname, - typeFields[i][1], - typeFields[i][2])) - constructorBody.add((^"result").dot(fname) := fname) - #export the name - typeFields[i][0] = fname.postfix("*") - if not(typeFields[i][2].kind in emptyFields): - ## empty the type default for the type def - typeFields[i][2] = newNimNode(nnkEmpty) - objFields.add(typeFields[i]) - toStringFunc[6][0][1].add( - prefix("$", packetID.dot(fname))) - formatStr.add " $" - formatStr.add($(i + 1)) - - formatStr.add ']' - toStringFunc[6][0][1][1] = formatStr.lit() - - result.add( - newNimNode(nnkTypeSection).und( - newNimNode(nnkTypeDef).und( - typeName.postfix("*"), - newNimNode(nnkEmpty), - newNimNode(nnkObjectTy).und( - newNimNode(nnkEmpty), #not sure what this is - newNimNode(nnkEmpty), #parent: OfInherit(Ident(!"SomeObj")) - objFields)))) - result.add(constructor.und(constructorBody)) - result.add(pack.und(packBody)) - result.add(read.und(readBody)) - result.add(toStringFunc) - when defined(GenPacketShowOutput): - echo(repr(result)) - -proc `->`(a: string, b: string): NimNode {.compileTime.} = - result = newNimNode(nnkIdentDefs).und(^a, ^b, newNimNode(nnkEmpty)) -proc `->`(a: string, b: NimNode): NimNode {.compileTime.} = - result = newNimNode(nnkIdentDefs).und(^a, b, newNimNode(nnkEmpty)) -proc `->`(a, b: NimNode): NimNode {.compileTime.} = - a[2] = b - result = a - -proc newProc*(name: string, params: varargs[NimNode], resultType: NimNode): NimNode {.compileTime.} = - result = newNimNode(nnkProcDef).und( - ^name, - emptyNode(), - emptyNode(), - newNimNode(nnkFormalParams).und(resultType), - emptyNode(), - emptyNode(), - newNimNode(nnkStmtList)) - result[3].add(params) -macro forwardPacket*(typeName: expr, underlyingType: typedesc): stmt {.immediate.} = - result = newNimNode(nnkStmtList).und( - newProc( - "read"& $typeName.ident, - ["s" -> "PStream" -> newNimNode(nnkNilLit)], - typeName), - newProc( - "pack", - [ "p" -> newNimNode(nnkVarTy).und(typeName), - "s" -> "PStream" -> newNimNode(nnkNilLit)], - emptyNode())) - result[0][6].add(newNimNode(nnkDiscardStmt).und( - newCall( - "readData", ^"s", newNimNode(nnkAddr).und(^"result"), newCall("sizeof", ^"result") - ))) - result[1][6].add( - newCall( - "writeData", ^"s", newNimNode(nnkAddr).und(^"p"), newCall( - "sizeof", ^"p"))) - when defined(GenPacketShowOutput): - echo(repr(result)) - -template forwardPacketT*(typeName: expr): stmt {.dirty, immediate.} = - proc `read typeName`*(s: PStream): typeName = - discard readData(s, addr result, sizeof(result)) - proc `pack typeName`*(p: var typeName; s: PStream) = - writeData(s, addr p, sizeof(p)) - -when isMainModule: - type - SomeEnum = enum - A = 0'i8, - B, C - forwardPacket(SomeEnum, int8) - - - defPacket(Foo, tuple[x: array[0..4, int8]]) - var f = newFoo([4'i8, 3'i8, 2'i8, 1'i8, 0'i8]) - var s2 = newStringStream("") - f.pack(s2) - assert s2.data == "\4\3\2\1\0" - - var s = newStringStream() - s.flushImpl = proc(s: PStream) = - var z = PStringStream(s) - z.setPosition(0) - z.data.setLen(0) - - - s.setPosition(0) - s.data.setLen(0) - var o = B - o.pack(s) - o = A - o.pack(s) - o = C - o.pack(s) - assert s.data == "\1\0\2" - s.flush - - defPacket(Y, tuple[z: int8]) - proc `$`(z: Y): string = result = "Y("& $z.z &")" - defPacket(TestPkt, tuple[x: seq[Y]]) - var test = newTestPkt() - test.x.add([newY(5), newY(4), newY(3), newY(2), newY(1)]) - for itm in test.x: - echo(itm) - test.pack(s) - echo(repr(s.data)) diff --git a/tests/manyloc/keineschweine/dependencies/genpacket/genpacket_enet.nim b/tests/manyloc/keineschweine/dependencies/genpacket/genpacket_enet.nim index 142b190ab..d91f1cb35 100644 --- a/tests/manyloc/keineschweine/dependencies/genpacket/genpacket_enet.nim +++ b/tests/manyloc/keineschweine/dependencies/genpacket/genpacket_enet.nim @@ -1,15 +1,15 @@ import macros, macro_dsl, estreams from strutils import format -template newLenName(): stmt {.immediate.} = - let lenName {.inject.} = ^("len"& $lenNames) +template newLenName() = + let lenName {.inject.} = ^("len" & $lenNames) inc(lenNames) -template defPacketImports*(): stmt {.immediate, dirty.} = +template defPacketImports*() {.dirty.} = import macros, macro_dsl, estreams from strutils import format -macro defPacket*(typeNameN: expr, typeFields: expr): stmt {.immediate.} = +macro defPacket*(typeNameN: untyped, typeFields: untyped): untyped = result = newNimNode(nnkStmtList) let typeName = quoted2ident(typeNameN) @@ -18,7 +18,7 @@ macro defPacket*(typeNameN: expr, typeFields: expr): stmt {.immediate.} = var constructorParams = newNimNode(nnkFormalParams).und(typeName) constructor = newNimNode(nnkProcDef).und( - postfix(^("new"& $typeName.ident), "*"), + postfix(^("new" & $typeName.ident), "*"), emptyNode(), emptyNode(), constructorParams, @@ -41,7 +41,7 @@ macro defPacket*(typeNameN: expr, typeFields: expr): stmt {.immediate.} = emptyNode(), emptyNode()) read = newNimNode(nnkProcDef).und( - newIdentNode("read"& $typeName.ident).postfix("*"), + newIdentNode("read" & $typeName.ident).postfix("*"), emptyNode(), emptyNode(), newNimNode(nnkFormalParams).und( @@ -60,7 +60,7 @@ macro defPacket*(typeNameN: expr, typeFields: expr): stmt {.immediate.} = let name = typeFields[i][0] dotName = packetID.dot(name) - resName = newIdentNode(!"result").dot(name) + resName = newIdentNode("result").dot(name) case typeFields[i][1].kind of nnkBracketExpr: #ex: paddedstring[32, '\0'], array[range, type] case $typeFields[i][1][0].ident @@ -70,7 +70,7 @@ macro defPacket*(typeNameN: expr, typeFields: expr): stmt {.immediate.} = let item = ^"item" ## item name in our iterators seqType = typeFields[i][1][1] ## type of seq - readName = newIdentNode("read"& $seqType.ident) + readName = newIdentNode("read" & $seqType.ident) readBody.add(newNimNode(nnkLetSection).und( newNimNode(nnkIdentDefs).und( lenName, @@ -100,7 +100,7 @@ macro defPacket*(typeNameN: expr, typeFields: expr): stmt {.immediate.} = #set the default value to @[] (new sequence) typeFields[i][2] = "@".prefix(newNimNode(nnkBracket)) else: - error("Unknown type: "& treeRepr(typeFields[i])) + error("Unknown type: " & treeRepr(typeFields[i])) of nnkIdent: ##normal type case $typeFields[i][1].ident of "string": # length encoded string @@ -109,12 +109,12 @@ macro defPacket*(typeNameN: expr, typeFields: expr): stmt {.immediate.} = of "int8", "int16", "int32", "float32", "float64", "char", "bool": packBody.add(newCall( "writeBE", streamID, dotName)) - readBody.add(resName := newCall("read"& $typeFields[i][1].ident, streamID)) + readBody.add(resName := newCall("read" & $typeFields[i][1].ident, streamID)) else: ## hopefully the type you specified was another defpacket() type packBody.add(newCall("pack", streamID, dotName)) - readBody.add(resName := newCall("read"& $typeFields[i][1].ident, streamID)) + readBody.add(resName := newCall("read" & $typeFields[i][1].ident, streamID)) else: - error("I dont know what to do with: "& treerepr(typeFields[i])) + error("I don't know what to do with: " & treerepr(typeFields[i])) var toStringFunc = newNimNode(nnkProcDef).und( @@ -137,11 +137,11 @@ macro defPacket*(typeNameN: expr, typeFields: expr): stmt {.immediate.} = newNimNode(nnkCall).und(# [6][0][1] ^"format", ## format emptyNode())))) ## "[TypeName $1 $2]" - formatStr = "["& $typeName.ident + formatStr = "[" & $typeName.ident const emptyFields = {nnkEmpty, nnkNilLit} var objFields = newNimNode(nnkRecList) - for i in 0.. < len(typeFields): + for i in 0 ..< len(typeFields): let fname = typeFields[i][0] constructorParams.add(newNimNode(nnkIdentDefs).und( fname, @@ -200,13 +200,13 @@ proc iddefs*(a: string; b: NimNode): NimNode {.compileTime.} = proc varTy*(a: NimNode): NimNode {.compileTime.} = result = newNimNode(nnkVarTy).und(a) -macro forwardPacket*(typeName: expr, underlyingType: expr): stmt {.immediate.} = +macro forwardPacket*(typeName: untyped, underlyingType: untyped): untyped = var packetID = ^"p" streamID = ^"s" result = newNimNode(nnkStmtList).und( newProc( - (^("read"& $typeName.ident)).postfix("*"), + (^("read" & $typeName.ident)).postfix("*"), [ iddefs("s", "PBuffer", newNimNode(nnkNilLit)) ], typeName), newProc( @@ -234,7 +234,7 @@ macro forwardPacket*(typeName: expr, underlyingType: expr): stmt {.immediate.} = echo "unknown type:", repr(underlyingtype) echo(repr(result)) -template forwardPacketT*(typeName: expr; underlyingType: expr): stmt {.dirty, immediate.} = +template forwardPacketT*(typeName: untyped; underlyingType: untyped) {.dirty.} = proc `read typeName`*(buffer: PBuffer): typeName = #discard readData(s, addr result, sizeof(result)) var res: underlyingType @@ -244,7 +244,7 @@ template forwardPacketT*(typeName: expr; underlyingType: expr): stmt {.dirty, im #writeData(s, addr p, sizeof(p)) buffer.write(underlyingType(ord)) -when isMainModule: +when false: type SomeEnum = enum A = 0'i8, diff --git a/tests/manyloc/keineschweine/dependencies/genpacket/macro_dsl.nim b/tests/manyloc/keineschweine/dependencies/genpacket/macro_dsl.nim index d3a0c701d..3341f42c2 100644 --- a/tests/manyloc/keineschweine/dependencies/genpacket/macro_dsl.nim +++ b/tests/manyloc/keineschweine/dependencies/genpacket/macro_dsl.nim @@ -1,5 +1,5 @@ import macros -{.deadCodeElim: on.} + #Inline macro.add() to allow for easier nesting proc und*(a: NimNode; b: NimNode): NimNode {.compileTime.} = a.add(b) @@ -10,7 +10,7 @@ proc und*(a: NimNode; b: varargs[NimNode]): NimNode {.compileTime.} = proc `^`*(a: string): NimNode {.compileTime.} = ## new ident node - result = newIdentNode(!a) + result = newIdentNode(a) proc `[]`*(a, b: NimNode): NimNode {.compileTime.} = ## new bracket expression: node[node] not to be confused with node[indx] result = newNimNode(nnkBracketExpr).und(a, b) @@ -34,7 +34,7 @@ proc emptyNode*(): NimNode {.compileTime.} = proc dot*(left, right: NimNode): NimNode {.compileTime.} = result = newNimNode(nnkDotExpr).und(left, right) proc prefix*(a: string, b: NimNode): NimNode {.compileTime.} = - result = newNimNode(nnkPrefix).und(newIdentNode(!a), b) + result = newNimNode(nnkPrefix).und(newIdentNode(a), b) proc quoted2ident*(a: NimNode): NimNode {.compileTime.} = if a.kind != nnkAccQuoted: @@ -45,13 +45,13 @@ proc quoted2ident*(a: NimNode): NimNode {.compileTime.} = result = ^pname -macro `?`(a: expr): expr = +macro `?`(a: untyped): untyped = ## Character literal ?A #=> 'A' result = ($a[1].ident)[0].lit ## echo(?F,?a,?t,?t,?y) -when isMainModule: - macro foo(x: stmt): stmt = +when false: + macro foo(x: untyped) = result = newNimNode(nnkStmtList) result.add(newNimNode(nnkCall).und(!!"echo", "Hello thar".lit)) result.add(newCall("echo", lit("3 * 45 = "), (3.lit.infix("*", 45.lit)))) diff --git a/tests/manyloc/keineschweine/dependencies/genpacket/streams_enh.nim b/tests/manyloc/keineschweine/dependencies/genpacket/streams_enh.nim index 5a1dffc93..a0c8a7a3c 100644 --- a/tests/manyloc/keineschweine/dependencies/genpacket/streams_enh.nim +++ b/tests/manyloc/keineschweine/dependencies/genpacket/streams_enh.nim @@ -1,7 +1,7 @@ import streams from strutils import repeat -proc readPaddedStr*(s: PStream, length: int, padChar = '\0'): TaintedString = +proc readPaddedStr*(s: PStream, length: int, padChar = '\0'): string = var lastChr = length result = s.readStr(length) while lastChr >= 0 and result[lastChr - 1] == padChar: dec(lastChr) @@ -16,7 +16,7 @@ proc writePaddedStr*(s: PStream, str: string, length: int, padChar = '\0') = else: s.write(str) -proc readLEStr*(s: PStream): TaintedString = +proc readLEStr*(s: PStream): string = var len = s.readInt16() result = s.readStr(len) @@ -24,7 +24,7 @@ proc writeLEStr*(s: PStream, str: string) = s.write(str.len.int16) s.write(str) -when isMainModule: +when true: var testStream = newStringStream() testStream.writeLEStr("Hello") |