cond switch

3 files changed, 88 insertions, 10 deletions

diff --git a/src/all.hff b/src/all.hff
index e090570..895657a 100644
--- a/src/all.hff
+++ b/src/all.hff
@@ -128,3 +128,8 @@ fn bswap32(x u32) u32 {
         | ((x << 8) & 0xFF0000)
         | (x << 24);
 }
+
+fn bswap64(x u64) u64 {
+   return (as(u64)bswap32(x) << 32)
+        | (bswap32(x >> 32));
+}
diff --git a/src/fmt.cff b/src/fmt.cff
index ecf7d74..ad28bbd 100644
--- a/src/fmt.cff
+++ b/src/fmt.cff
@@ -10,13 +10,14 @@ extern fn vpfmt(proc *fn(u8, *void) void, parg *void, fmt *const u8, ap va_list)
 
    defmacro pch(ch) [ {
       extern fn isprint(int) int;
-      if isprint(ch) != 0 {
-         p(ch);
+      let $ch = ch;
+      if isprint($ch) != 0 {
+         p($ch);
       } else {
          p('\\');
-         p('0' + (ch % 8));
-         p('0' + ((ch / 8) % 8));
-         p('0' + ((ch / 8 / 8) % 8));
+         p('0' + ($ch % 8));
+         p('0' + (($ch / 8) % 8));
+         p('0' + (($ch / 8 / 8) % 8));
       }
    } ]
 
@@ -27,12 +28,31 @@ extern fn vpfmt(proc *fn(u8, *void) void, parg *void, fmt *const u8, ap va_list)
       case :int;
          sprintf(buf, "%lld", tok.u.int);
          ps(buf);
+      case :flo;
+         sprintf(buf, "%.14f", tok.u.flo);
+         ps(buf);
+      case :bool;
+         ps(tok.u.bool ? "#t" : "#f");
       case :str;
          pfmt(proc, parg, "%S", tok.u.str);
-      case :ident;
+      case :chr;
+         let t = bswap64(tok.u.uint);
+         p('\'');
+         while t != 0 {
+            if t & 0xFF != 0 {
+               pch(t & 0xFF);
+            }
+            t >>= 8;         
+         }
+         p('\'');
+      case :null;
+         ps("#null");
+      case :ident, :macident, :gensym, :label;
          if quote { p('`');  }
          ps(tok.u.ident);
          if quote { p('\'');  }
+      case :type;
+         pfmt(proc, parg, "%t", tok.ty);
       case else
          if tok.t >= 0 and tok.t < NUM_KEYWORDS {
             if quote { p('`');  }
@@ -41,14 +61,12 @@ extern fn vpfmt(proc *fn(u8, *void) void, parg *void, fmt *const u8, ap va_list)
          } else if tok.t > 0 {
             if quote { p('`');  }
             let t = bswap32(tok.t);
-            let i = 0;
             while t != 0 {
                if t & 0xFF != 0 {
                   p(t);
                }
                t >>= 8;         
             }
-            buf[i] = '\0';
             if quote { p('\'');  }
          }
       }
diff --git a/src/parse.cff b/src/parse.cff
index bcb5763..07158fb 100644
--- a/src/parse.cff
+++ b/src/parse.cff
@@ -84,6 +84,18 @@ fn issep(c u8) bool {
    return #f;
 }
 
+fn ishsep(c u8) bool {
+   if isspace(c) {
+      return #t;
+   }
+   switch (c) {
+   case '(', ')', '[', ']', '{',
+        '}', '.', ',', ';', '"';
+      return #t;
+   }
+   return #f;
+}
+
 fn readtilsep(P *Parser, buf [#]u8, dot bool) int {
    let i = 0,
        c u8 #?;
@@ -98,6 +110,24 @@ fn readtilsep(P *Parser, buf [#]u8, dot bool) int {
    return i;
 }
 
+fn readtilhsep(P *Parser, buf [#]u8, dot bool) int {
+   let i = 0,
+       c u8 #?,
+       pred = &ishsep;
+   while (not pred(c = chrpeek(P))) or (dot and c == '.') {
+      chr(P);
+      if not issep(c) {
+         pred = &issep;
+      }
+      if i >= buf.#len - 1 {
+         return -1;
+      }
+      buf[i++] = c;
+   }
+   buf[i++] = 0;
+   return i;
+}
+
 fn eatspaces(P *Parser) void {
    for ;;chr(P) {
       if not isspace(chrpeek(P)) {
@@ -226,6 +256,18 @@ fn lex(P *Parser) Tok {
       }
       return tok;
    }
+   if c == '#' {
+      let s [100]u8 = {};
+      if readtilhsep(P, s[0::], #f) < 0 {
+         fatal(P, P.tokloc, "invalid #keyword");
+      }
+      switch {
+      case streq(s, "#");
+         tok.t = '#';
+      case else
+         fatal(P, P.tokloc, "invalid #keyword");
+      }
+   }
    if c == '"' or c == '\'' {
       chr(P);
       let delim = c;
@@ -255,8 +297,21 @@ fn lex(P *Parser) Tok {
          }
       }
 
-      tok.t = :str;
-      tok.u.str = str->compact();
+      if delim == '"' {
+         tok.t = :str;
+         tok.u.str = str->compact();
+      } else {
+         tok.t = :chr;
+         if str.len == 0 {
+            fatal(P, P.tokloc, "empty char literal");
+         } else if str.len > 8 {
+            fatal(P, P.tokloc, "too long multichar literal %qs", str.dat);
+         }
+         tok.u.uint = 0;
+         vec_each(c0, i, str,
+            tok.u.uint = (tok.u.uint << 8) | c0;   
+         )
+      }
       return tok;
    }
    switch c = chr(P) {