tables work in 'const' sections; echo supports 'nil' strings; minor cleanups

6 files changed, 29 insertions, 47 deletions

diff --git a/compiler/ccgexprs.nim b/compiler/ccgexprs.nim
index 32678d472..9b45c4492 100644
--- a/compiler/ccgexprs.nim
+++ b/compiler/ccgexprs.nim
@@ -83,7 +83,9 @@ proc genLiteral(p: BProc, n: PNode, ty: PType): PRope =
     else:
       result = toRope("NIM_NIL")
   of nkStrLit..nkTripleStrLit:
-    if skipTypes(ty, abstractVarRange).kind == tyString:
+    if n.strVal.isNil:
+      result = ropecg(p.module, "((#NimStringDesc*) NIM_NIL)", [])
+    elif skipTypes(ty, abstractVarRange).kind == tyString:
       var id = nodeTableTestOrSet(p.module.dataCache, n, gBackendId)
       if id == gBackendId:
         # string literal not found in the cache:
@@ -950,7 +952,7 @@ proc genEcho(p: BProc, n: PNode) =
   var a: TLoc
   for i in countup(0, n.len-1):
     initLocExpr(p, n.sons[i], a)
-    appf(args, ", ($1)->data", [rdLoc(a)])
+    appf(args, ", $1? ($1)->data:\"nil\"", [rdLoc(a)])
   linefmt(p, cpsStmts, "printf($1$2);$n",
           makeCString(repeatStr(n.len, "%s") & tnl), args)
 
@@ -2173,7 +2175,7 @@ proc genConstExpr(p: BProc, n: PNode): PRope =
     var cs: TBitSet
     toBitSet(n, cs)
     result = genRawSetData(cs, int(getSize(n.typ)))
-  of nkBracket, nkPar, nkClosure:
+  of nkBracket, nkPar, nkClosure, nkObjConstr:
     var t = skipTypes(n.typ, abstractInst)
     if t.kind == tySequence:
       result = genConstSeq(p, n, t)
diff --git a/compiler/ccgstmts.nim b/compiler/ccgstmts.nim
index f5a2c0ef4..18705c974 100644
--- a/compiler/ccgstmts.nim
+++ b/compiler/ccgstmts.nim
@@ -253,15 +253,6 @@ proc genConstStmt(p: BProc, t: PNode) =
     elif c.typ.kind in ConstantDataTypes and lfNoDecl notin c.loc.flags and
         c.ast.len != 0:
       if not emitLazily(c): requestConstImpl(p, c)
-      when false:
-        # generate the data:
-        fillLoc(c.loc, locData, c.typ, mangleName(c), OnUnknown)
-        if sfImportc in c.flags: 
-          appf(p.module.s[cfsData], "extern NIM_CONST $1 $2;$n", 
-               [getTypeDesc(p.module, c.typ), c.loc.r])
-        else: 
-          appf(p.module.s[cfsData], "NIM_CONST $1 $2 = $3;$n", 
-               [getTypeDesc(p.module, c.typ), c.loc.r, genConstExpr(p, c.ast)])
 
 proc genIf(p: BProc, n: PNode, d: var TLoc) =
   #
diff --git a/compiler/llstream.nim b/compiler/llstream.nim
index be469548d..69475965d 100644
--- a/compiler/llstream.nim
+++ b/compiler/llstream.nim
@@ -30,47 +30,32 @@ type
   
   PLLStream* = ref TLLStream
 
-proc llStreamOpen*(data: string): PLLStream
-proc llStreamOpen*(f: var File): PLLStream
-proc llStreamOpen*(filename: string, mode: FileMode): PLLStream
-proc llStreamOpen*(): PLLStream
-proc llStreamOpenStdIn*(): PLLStream
-proc llStreamClose*(s: PLLStream)
-proc llStreamRead*(s: PLLStream, buf: pointer, bufLen: int): int
-proc llStreamReadLine*(s: PLLStream, line: var string): bool
-proc llStreamReadAll*(s: PLLStream): string
-proc llStreamWrite*(s: PLLStream, data: string)
-proc llStreamWrite*(s: PLLStream, data: char)
-proc llStreamWrite*(s: PLLStream, buf: pointer, buflen: int)
-proc llStreamWriteln*(s: PLLStream, data: string)
-# implementation
-
-proc llStreamOpen(data: string): PLLStream = 
+proc llStreamOpen*(data: string): PLLStream = 
   new(result)
   result.s = data
   result.kind = llsString
 
-proc llStreamOpen(f: var File): PLLStream = 
+proc llStreamOpen*(f: var File): PLLStream = 
   new(result)
   result.f = f
   result.kind = llsFile
 
-proc llStreamOpen(filename: string, mode: FileMode): PLLStream = 
+proc llStreamOpen*(filename: string, mode: FileMode): PLLStream = 
   new(result)
   result.kind = llsFile
   if not open(result.f, filename, mode): result = nil
   
-proc llStreamOpen(): PLLStream = 
+proc llStreamOpen*(): PLLStream = 
   new(result)
   result.kind = llsNone
 
-proc llStreamOpenStdIn(): PLLStream = 
+proc llStreamOpenStdIn*(): PLLStream = 
   new(result)
   result.kind = llsStdIn
   result.s = ""
   result.lineOffset = -1
 
-proc llStreamClose(s: PLLStream) = 
+proc llStreamClose*(s: PLLStream) = 
   case s.kind
   of llsNone, llsString, llsStdIn: 
     discard
@@ -130,7 +115,7 @@ proc llReadFromStdin(s: PLLStream, buf: pointer, bufLen: int): int =
     copyMem(buf, addr(s.s[s.rd]), result)
     inc(s.rd, result)
 
-proc llStreamRead(s: PLLStream, buf: pointer, bufLen: int): int = 
+proc llStreamRead*(s: PLLStream, buf: pointer, bufLen: int): int = 
   case s.kind
   of llsNone: 
     result = 0
@@ -144,7 +129,7 @@ proc llStreamRead(s: PLLStream, buf: pointer, bufLen: int): int =
   of llsStdIn: 
     result = llReadFromStdin(s, buf, bufLen)
   
-proc llStreamReadLine(s: PLLStream, line: var string): bool =
+proc llStreamReadLine*(s: PLLStream, line: var string): bool =
   setLen(line, 0)
   case s.kind
   of llsNone:
@@ -168,7 +153,7 @@ proc llStreamReadLine(s: PLLStream, line: var string): bool =
   of llsStdIn:
     result = readLine(stdin, line)
     
-proc llStreamWrite(s: PLLStream, data: string) = 
+proc llStreamWrite*(s: PLLStream, data: string) = 
   case s.kind
   of llsNone, llsStdIn: 
     discard
@@ -178,11 +163,11 @@ proc llStreamWrite(s: PLLStream, data: string) =
   of llsFile: 
     write(s.f, data)
   
-proc llStreamWriteln(s: PLLStream, data: string) = 
+proc llStreamWriteln*(s: PLLStream, data: string) = 
   llStreamWrite(s, data)
   llStreamWrite(s, "\n")
 
-proc llStreamWrite(s: PLLStream, data: char) = 
+proc llStreamWrite*(s: PLLStream, data: char) = 
   var c: char
   case s.kind
   of llsNone, llsStdIn: 
@@ -194,7 +179,7 @@ proc llStreamWrite(s: PLLStream, data: char) =
     c = data
     discard writeBuffer(s.f, addr(c), sizeof(c))
 
-proc llStreamWrite(s: PLLStream, buf: pointer, buflen: int) = 
+proc llStreamWrite*(s: PLLStream, buf: pointer, buflen: int) = 
   case s.kind
   of llsNone, llsStdIn: 
     discard
@@ -206,7 +191,7 @@ proc llStreamWrite(s: PLLStream, buf: pointer, buflen: int) =
   of llsFile: 
     discard writeBuffer(s.f, buf, buflen)
   
-proc llStreamReadAll(s: PLLStream): string = 
+proc llStreamReadAll*(s: PLLStream): string = 
   const 
     bufSize = 2048
   case s.kind
diff --git a/compiler/treetab.nim b/compiler/treetab.nim
index 63f3fc6e2..8d66d56c7 100644
--- a/compiler/treetab.nim
+++ b/compiler/treetab.nim
@@ -28,8 +28,9 @@ proc hashTree(n: PNode): THash =
   of nkFloatLit..nkFloat64Lit:
     if (n.floatVal >= - 1000000.0) and (n.floatVal <= 1000000.0): 
       result = result !& toInt(n.floatVal)
-  of nkStrLit..nkTripleStrLit: 
-    result = result !& hash(n.strVal)
+  of nkStrLit..nkTripleStrLit:
+    if not n.strVal.isNil:
+      result = result !& hash(n.strVal)
   else: 
     for i in countup(0, sonsLen(n) - 1): 
       result = result !& hashTree(n.sons[i])
diff --git a/compiler/types.nim b/compiler/types.nim
index 78d390f13..3711a9668 100644
--- a/compiler/types.nim
+++ b/compiler/types.nim
@@ -1029,16 +1029,18 @@ proc typeAllowedAux(marker: var IntSet, typ: PType, kind: TSymKind,
 
 proc typeAllowedNode(marker: var IntSet, n: PNode, kind: TSymKind,
                      flags: TTypeAllowedFlags = {}): PType =
-  if n != nil: 
+  if n != nil:
     result = typeAllowedAux(marker, n.typ, kind, flags)
     #if not result: debug(n.typ)
     if result == nil:
       case n.kind
-      of nkNone..nkNilLit: 
+      of nkNone..nkNilLit:
         discard
       else:
         for i in countup(0, sonsLen(n) - 1):
-          result = typeAllowedNode(marker, n.sons[i], kind, flags)
+          let it = n.sons[i]
+          if it.kind == nkRecCase and kind == skConst: return n.typ
+          result = typeAllowedNode(marker, it, kind, flags)
           if result != nil: break
 
 proc matchType*(a: PType, pattern: openArray[tuple[k:TTypeKind, i:int]],
@@ -1118,7 +1120,7 @@ proc typeAllowedAux(marker: var IntSet, typ: PType, kind: TSymKind,
       result = typeAllowedAux(marker, t.sons[i], kind, flags)
       if result != nil: break
   of tyObject, tyTuple:
-    if kind == skConst and t.kind == tyObject: return t
+    if kind == skConst and t.kind == tyObject and t.sons[0] != nil: return t
     let flags = flags+{taField}
     for i in countup(0, sonsLen(t) - 1):
       result = typeAllowedAux(marker, t.sons[i], kind, flags)
diff --git a/compiler/vmgen.nim b/compiler/vmgen.nim
index fe6526a34..70f81bc72 100644
--- a/compiler/vmgen.nim
+++ b/compiler/vmgen.nim
@@ -604,7 +604,8 @@ proc genNarrowU(c: PCtx; n: PNode; dest: TDest) =
   let t = skipTypes(n.typ, abstractVar-{tyTypeDesc})
   # uint is uint64 in the VM, we we only need to mask the result for
   # other unsigned types:
-  if t.kind in {tyUInt8..tyUInt32, tyInt8..tyInt32}:
+  if t.kind in {tyUInt8..tyUInt32, tyInt8..tyInt32} or
+      (t.kind == tyInt and t.size == 4):
     c.gABC(n, opcNarrowU, dest, TRegister(t.size*8))
 
 proc genBinaryABCnarrow(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode) =