From 6f1fc1b5ba7f74fde21467f5f0bfd294ad9292f3 Mon Sep 17 00:00:00 2001
From: Araq <rumpf_a@web.de>
Date: Thu, 22 Aug 2013 08:38:47 +0200
Subject: fixed and documented computedGoto pragma

---
 compiler/ccgstmts.nim |  5 ++++-
 compiler/nimsets.nim  | 27 ++++++---------------------
 compiler/vm.nim       |  1 -
 compiler/vmgen.nim    | 42 +++++++++++++++++++++++++++++++++---------
 4 files changed, 43 insertions(+), 32 deletions(-)

(limited to 'compiler')

diff --git a/compiler/ccgstmts.nim b/compiler/ccgstmts.nim
index 4d52e3aab..01c734524 100644
--- a/compiler/ccgstmts.nim
+++ b/compiler/ccgstmts.nim
@@ -322,6 +322,7 @@ proc genComputedGoto(p: BProc; n: PNode) =
   gotoArray.appf("&&TMP$#};$n", (id+arraySize).toRope)
   line(p, cpsLocals, gotoArray)
   
+  for j in 0 .. casePos-1: genStmts(p, n.sons[j])
   let caseStmt = n.sons[casePos]
   var a: TLoc
   initLocExpr(p, caseStmt.sons[0], a)
@@ -329,6 +330,7 @@ proc genComputedGoto(p: BProc; n: PNode) =
   lineF(p, cpsStmts, "goto *$#[$#];$n", tmp, a.rdLoc)
   
   for i in 1 .. <caseStmt.len:
+    startBlock(p)
     let it = caseStmt.sons[i]
     for j in 0 .. it.len-2:
       if it.sons[j].kind == nkRange:
@@ -336,12 +338,13 @@ proc genComputedGoto(p: BProc; n: PNode) =
         return
       let val = getOrdValue(it.sons[j])
       lineF(p, cpsStmts, "TMP$#:$n", intLiteral(val+id+1))
-    for j in 0 .. casePos-1: genStmts(p, n.sons[j])
     genStmts(p, it.lastSon)
     for j in casePos+1 .. <n.len: genStmts(p, n.sons[j])
+    for j in 0 .. casePos-1: genStmts(p, n.sons[j])
     var a: TLoc
     initLocExpr(p, caseStmt.sons[0], a)
     lineF(p, cpsStmts, "goto *$#[$#];$n", tmp, a.rdLoc)
+    endBlock(p)
 
 proc genWhileStmt(p: BProc, t: PNode) =
   # we don't generate labels here as for example GCC would produce
diff --git a/compiler/nimsets.nim b/compiler/nimsets.nim
index f874ccdca..34f79e14b 100644
--- a/compiler/nimsets.nim
+++ b/compiler/nimsets.nim
@@ -117,32 +117,17 @@ proc ToTreeSet(s: TBitSet, settype: PType, info: TLineInfo): PNode =
       e = b
     Inc(e)
 
-type 
-  TSetOP = enum 
-    soUnion, soDiff, soSymDiff, soIntersect
-
-proc nodeSetOp(a, b: PNode, op: TSetOp): PNode = 
+template nodeSetOp(a, b: PNode, op: expr) {.dirty.} = 
   var x, y: TBitSet
   toBitSet(a, x)
   toBitSet(b, y)
-  case op
-  of soUnion: BitSetUnion(x, y)
-  of soDiff: BitSetDiff(x, y)
-  of soSymDiff: BitSetSymDiff(x, y)
-  of soIntersect: BitSetIntersect(x, y)
+  op(x, y)
   result = toTreeSet(x, a.typ, a.info)
 
-proc unionSets(a, b: PNode): PNode = 
-  result = nodeSetOp(a, b, soUnion)
-
-proc diffSets(a, b: PNode): PNode = 
-  result = nodeSetOp(a, b, soDiff)
-
-proc intersectSets(a, b: PNode): PNode = 
-  result = nodeSetOp(a, b, soIntersect)
-
-proc symdiffSets(a, b: PNode): PNode = 
-  result = nodeSetOp(a, b, soSymDiff)
+proc unionSets(a, b: PNode): PNode = nodeSetOp(a, b, BitSetUnion)
+proc diffSets(a, b: PNode): PNode = nodeSetOp(a, b, BitSetDiff)
+proc intersectSets(a, b: PNode): PNode = nodeSetOp(a, b, BitSetIntersect)
+proc symdiffSets(a, b: PNode): PNode = nodeSetOp(a, b, BitSetSymDiff)
 
 proc containsSets(a, b: PNode): bool = 
   var x, y: TBitSet
diff --git a/compiler/vm.nim b/compiler/vm.nim
index b02de405e..c0ce047ea 100644
--- a/compiler/vm.nim
+++ b/compiler/vm.nim
@@ -352,7 +352,6 @@ proc execute(c: PCtx, start: int) =
       if not inSet(regs[ra], regs[rb]): addSon(regs[ra], copyTree(regs[rb]))
     of opcExcl:
       decodeB(nkCurly)
-      # XXX arg we need types here :-(
       var b = newNodeIT(nkCurly, regs[rb].info, regs[rb].typ)
       addSon(b, regs[rb])
       var r = diffSets(regs[ra], b)
diff --git a/compiler/vmgen.nim b/compiler/vmgen.nim
index f7df31c0c..fc356018a 100644
--- a/compiler/vmgen.nim
+++ b/compiler/vmgen.nim
@@ -439,6 +439,22 @@ proc genBinaryABC(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode) =
   c.freeTemp(tmp)
   c.freeTemp(tmp2)
 
+proc genSetType(c: PCtx; n: PNode; dest: TRegister) =
+  let t = skipTypes(n.typ, abstractInst)
+  if t.kind == tySet:
+    c.gABx(n, opcSetType, dest, c.genType(t))
+
+proc genBinarySet(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode) =
+  let
+    tmp = c.genx(n.sons[1])
+    tmp2 = c.genx(n.sons[2])
+  if dest < 0: dest = c.getTemp(n.typ)
+  c.genSetType(n.sons[1], tmp)
+  c.genSetType(n.sons[2], tmp2)
+  c.gABC(n, opc, dest, tmp, tmp2)
+  c.freeTemp(tmp)
+  c.freeTemp(tmp2)
+
 proc genBinaryStmt(c: PCtx; n: PNode; opc: TOpcode) =
   let
     dest = c.genx(n.sons[1])
@@ -488,6 +504,13 @@ proc genConv(c: PCtx; n, arg: PNode; dest: var TDest; opc=opcConv) =
   c.gABx(n, opc, 0, genType(c, n.typ))
   c.freeTemp(tmp)
 
+proc genCard(c: PCtx; n: PNode; dest: var TDest) =
+  let tmp = c.genx(n.sons[1])
+  if dest < 0: dest = c.getTemp(n.typ)
+  c.genSetType(n.sons[1], tmp)
+  c.gABC(n, opc, dest, tmp)
+  c.freeTemp(tmp)
+
 proc genMagic(c: PCtx; n: PNode; dest: var TDest) =
   let m = n.sons[0].sym.magic
   case m
@@ -532,10 +555,11 @@ proc genMagic(c: PCtx; n: PNode; dest: var TDest) =
     unused(n, dest)
     var d = c.genx(n.sons[1])
     var tmp = c.genx(n.sons[2])
+    c.genSetType(n.sons[1], d)
     c.gABC(n, if m == mIncl: opcIncl else: opcExcl, d, tmp)
     c.freeTemp(d)
     c.freeTemp(tmp)
-  of mCard: genUnaryABC(c, n, dest, opcCard)
+  of mCard: genCard(c, n, dest)
   of mMulI, mMulI64: genBinaryABC(c, n, dest, opcMulInt)
   of mDivI, mDivI64: genBinaryABC(c, n, dest, opcDivInt)
   of mModI, mModI64: genBinaryABC(c, n, dest, opcModInt)
@@ -580,15 +604,15 @@ proc genMagic(c: PCtx; n: PNode; dest: var TDest) =
   of mEqStr: genBinaryABC(c, n, dest, opcEqStr)
   of mLeStr: genBinaryABC(c, n, dest, opcLeStr)
   of mLtStr: genBinaryABC(c, n, dest, opcLtStr)
-  of mEqSet: genBinaryABC(c, n, dest, opcEqSet)
-  of mLeSet: genBinaryABC(c, n, dest, opcLeSet)
-  of mLtSet: genBinaryABC(c, n, dest, opcLtSet)
-  of mMulSet: genBinaryABC(c, n, dest, opcMulSet)
-  of mPlusSet: genBinaryABC(c, n, dest, opcPlusSet)
-  of mMinusSet: genBinaryABC(c, n, dest, opcMinusSet)
-  of mSymDiffSet: genBinaryABC(c, n, dest, opcSymdiffSet)
+  of mEqSet: genBinarySet(c, n, dest, opcEqSet)
+  of mLeSet: genBinarySet(c, n, dest, opcLeSet)
+  of mLtSet: genBinarySet(c, n, dest, opcLtSet)
+  of mMulSet: genBinarySet(c, n, dest, opcMulSet)
+  of mPlusSet: genBinarySet(c, n, dest, opcPlusSet)
+  of mMinusSet: genBinarySet(c, n, dest, opcMinusSet)
+  of mSymDiffSet: genBinarySet(c, n, dest, opcSymdiffSet)
   of mConStrStr: genVarargsABC(c, n, dest, opcConcatStr)
-  of mInSet: genBinaryABC(c, n, dest, opcContainsSet)
+  of mInSet: genBinarySet(c, n, dest, opcContainsSet)
   of mRepr: genUnaryABC(c, n, dest, opcRepr)
   of mExit:
     unused(n, dest)
-- 
cgit 1.4.1-2-gfad0