refactor/condense; add literal

1 files changed, 73 insertions, 131 deletions

diff --git a/main.c b/main.c
index 13b62ff..b9e2428 100644
--- a/main.c
+++ b/main.c
@@ -1,13 +1,7 @@
 #include <stdint.h>
 
-#define NAKED __attribute__((naked))
-
+#define NAKED       __attribute__((naked))
 #define END_OF(arr) ((arr) + (sizeof((arr)) / sizeof(*(arr))))
-#define NEXT        { goto *(*++pp); }
-
-#define LIT(x)  push, (void *)(x)
-#define FTH(w)  enter, (w##_body)
-#define EXIT    doexit
 
 #define ATTR_NATIVE     (1 << 7)
 #define ATTR_IMMEDIATE  (1 << 6)
@@ -19,24 +13,25 @@
         name##_body, prev, attr + sizeof(tname) - 1, tname \
     }; \
     const void *name##_body[] = {
-#define END    EXIT, };
-
-#define W(name, tname, prev) WORD(name, tname, prev, 0)
-#define I(name, tname, prev) WORD(name, tname, prev, ATTR_IMMEDIATE)
-#define N(name, tname, prev) \
-    extern const void *name##_body[]; \
-    struct word_t w_##name = { \
-        name##_body, prev, \
-        ATTR_NATIVE + sizeof(tname) - 1, tname \
-    }; \
-    const void *name##_body[] = { name, EXIT };
-#define C(name, tname, prev) \
+#define LIT(x)  push, (void *)(x)
+#define FTH(w)  enter, (w##_body)
+#define END    fexit, };
+#define NATIVE(name, tname, prev, attr) \
     extern const void *name##_body[]; \
+    NAKED void name(void); \
     struct word_t w_##name = { \
         name##_body, prev, \
-        (ATTR_NATIVE | ATTR_IMMEDIATE) + sizeof(tname) - 1, tname \
+        (attr | ATTR_NATIVE) + sizeof(tname) - 1, tname \
     }; \
-    const void *name##_body[] = { name, EXIT };
+    const void *name##_body[] = { name, fexit }; \
+    NAKED void name(void)
+
+#define W(name, tname, prev) WORD(name, tname, prev, 0)
+#define I(name, tname, prev) WORD(name, tname, prev, ATTR_IMMEDIATE)
+#define N(name, tname, prev) NATIVE(name, tname, prev, 0)
+#define C(name, tname, prev) NATIVE(name, tname, prev, ATTR_IMMEDIATE)
+
+#define NEXT        { goto *(*++pp); }
 
 struct word_t
 {
@@ -46,12 +41,16 @@ struct word_t
     char name[];
 } __attribute__ ((packed));
 
-intptr_t dstack[32];
-intptr_t **rstack[32];
-intptr_t dict[8192];
-struct word_t *latest;
-//char       inbuf  [ 128];
-//intptr_t   inpos;
+static intptr_t dstack[32];
+static intptr_t **rstack[32];
+static intptr_t dict[8192] = {
+    0, 10
+};
+#define state dict[0]
+#define base  dict[1]
+#define begin dict[2]
+static intptr_t *here = &begin;
+static struct word_t *latest;
 
 register intptr_t     tmp asm("r12");
 register intptr_t *   sp  asm("r13"); // pointer to stack cells
@@ -61,46 +60,10 @@ register intptr_t **  pp  asm("r15"); // pointer to ip
 #define STASH   asm("push %r12; push %r13; push %r14; push %r15")
 #define RESTORE asm("pop %r15; pop %r14; pop %r13; pop %r12")
 
-NAKED
-void enter(void)
-{
-    *--rp = ++pp;
-    pp = (intptr_t **)*pp;
-    goto *(*pp);
-}
-
-void doexit(void)
-{
-    if (rp < END_OF(rstack)) {
-        pp = *rp++;
-        NEXT;
-    }
-}
-
-intptr_t state = 0;
-intptr_t *here = dict;
-
 NAKED void   dot(void);
+NAKED void enter(void) { *--rp = ++pp; pp = (intptr_t **)*pp; goto *(*pp); }
 NAKED void  push(void) { *--sp = (intptr_t)*++pp; NEXT; }
-NAKED void   dup(void) { --sp; sp[0] = sp[1]; NEXT; }
-NAKED void  drop(void) { ++sp; NEXT; }
-NAKED void  swap(void) { tmp = sp[0]; sp[0] = sp[1]; sp[1] = tmp; NEXT; }
-NAKED void   rot(void) { tmp = sp[0]; sp[0] = sp[2]; sp[2] = sp[1]; sp[1] = tmp; NEXT; }
-NAKED void   add(void) { sp[1] += sp[0]; ++sp; NEXT; }
-NAKED void   sub(void) { sp[1] -= sp[0]; ++sp; NEXT; }
-NAKED void   mul(void) { sp[1] *= sp[0]; ++sp; NEXT; }
-NAKED void   div(void) { sp[1] /= sp[0]; ++sp; NEXT; }
-NAKED void   mod(void) { sp[1] %= sp[0]; ++sp; NEXT; }
-NAKED void   and(void) { sp[1] &= sp[0]; ++sp; NEXT; }
-NAKED void    or(void) { sp[1] |= sp[0]; ++sp; NEXT; }
-NAKED void   xor(void) { sp[1] ^= sp[0]; ++sp; NEXT; }
-NAKED void  peek(void) { *sp = *(intptr_t *)*sp; NEXT; }
-NAKED void  poke(void) { *(intptr_t *)sp[0] = sp[1]; sp += 2; NEXT; }
-NAKED void cpeek(void) { *sp = *(char *)*sp; NEXT; }
-NAKED void cpoke(void) { *(char *)sp[0] = (char)sp[1]; sp += 2; NEXT; }
-NAKED void  comp(void) { state = -1; NEXT; }
-NAKED void  intr(void) { state = 0; NEXT; }
-NAKED void comma(void) { *here++ = *sp++; NEXT; }
+      void fexit(void) { if (rp < END_OF(rstack)) { pp = *rp++; NEXT; } }
 
 NAKED void compname(void)
 {
@@ -123,71 +86,70 @@ NAKED void compname(void)
     NEXT;
 }
 
-N(dup,    "dup",    0)
-N(drop,   "drop",   &w_dup)
-N(swap,   "swap",   &w_drop)
-N(rot,    "rot",    &w_swap)
-N(peek,   "@",      &w_rot)
-N(poke,   "!",      &w_peek)
-N(cpeek,  "c@",     &w_poke)
-N(cpoke,  "c!",     &w_cpeek)
-N(add,    "+",      &w_cpoke)
-N(sub,    "-",      &w_add)
-N(mul,    "*",      &w_sub)
-N(div,    "/",      &w_mul)
-N(mod,    "mod",    &w_div)
-N(and,    "and",    &w_mod)
-N(or,     "or",     &w_and)
-N(xor,    "xor",    &w_or)
-W(cell,   "cell",   &w_xor)    LIT(sizeof(*sp)),   END
-W(cellp,  "cell+",  &w_cell)   FTH(cell), add,     END
-W(cells,  "cells",  &w_cellp)  FTH(cell), mul,     END
-W(dict,   "_d",     &w_cells)  LIT(dict),          END
-W(here,   "here",   &w_dict)   LIT(&here), peek,   END
-W(latest, "latest", &w_here)   LIT(&latest), peek, END
-C(intr,   "[",      &w_latest)
-N(comp,   "]",      &w_intr)
-N(dot,    ".",      &w_comp)
-W(negate, "negate", &w_dot)    LIT(-1), mul, END
-W(invert, "invert", &w_negate) LIT(-1), xor, END
-W(dec,    "1-",     &w_invert) LIT(1), sub,  END
-W(inc,    "1+",     &w_dec)    LIT(1), add,  END
-W(aligned, "aligned", &w_inc) LIT(sizeof(*sp) - 1), add, LIT(~(sizeof(*sp) - 1)), and, END
+N(dup,    "dup",    0)        { --sp; sp[0] = sp[1]; NEXT; }
+N(drop,   "drop",   &w_dup)   { ++sp; NEXT; }
+N(swap,   "swap",   &w_drop)  { tmp = sp[0]; sp[0] = sp[1]; sp[1] = tmp; NEXT; }
+N(rot,    "rot",    &w_swap)  { tmp = sp[0]; sp[0] = sp[2]; sp[2] = sp[1];
+                                sp[1] = tmp; NEXT; }
+N(peek,   "@",      &w_rot)   { *sp = *(intptr_t *)*sp; NEXT; }
+N(poke,   "!",      &w_peek)  { *(intptr_t *)sp[0] = sp[1]; sp += 2; NEXT; }
+N(cpeek,  "c@",     &w_poke)  { *sp = *(char *)*sp; NEXT; }
+N(cpoke,  "c!",     &w_cpeek) { *(char *)sp[0] = (char)sp[1]; sp += 2; NEXT; }
+N(add,    "+",      &w_cpoke) { sp[1] += sp[0]; ++sp; NEXT; }
+N(sub,    "-",      &w_add)   { sp[1] -= sp[0]; ++sp; NEXT; }
+N(mul,    "*",      &w_sub)   { sp[1] *= sp[0]; ++sp; NEXT; }
+N(div,    "/",      &w_mul)   { sp[1] /= sp[0]; ++sp; NEXT; }
+N(mod,    "mod",    &w_div)   { sp[1] %= sp[0]; ++sp; NEXT; }
+N(and,    "and",    &w_mod)   { sp[1] &= sp[0]; ++sp; NEXT; }
+N(or,     "or",     &w_and)   { sp[1] |= sp[0]; ++sp; NEXT; }
+N(xor,    "xor",    &w_or)    { sp[1] ^= sp[0]; ++sp; NEXT; }
+C(intr,   "[",      &w_xor)   { state = 0; NEXT; }
+N(comp,   "]",      &w_intr)  { state = -1; NEXT; }
+N(comma,  ",",      &w_comp)  { *here++ = *sp++; NEXT; }
+W(cell,   "cell",   &w_comma)   LIT(sizeof(*sp)),   END
+W(cellp,  "cell+",  &w_cell)    FTH(cell), add,     END
+W(cells,  "cells",  &w_cellp)   FTH(cell), mul,     END
+W(dict,   "_d",     &w_cells)   LIT(dict),          END
+W(here,   "here",   &w_dict)    LIT(&here), peek,   END
+W(latest, "latest", &w_here)    LIT(&latest), peek, END
+N(dot,    ".",      &w_latest)  ;
+W(negate, "negate", &w_dot)     LIT(-1), mul, END
+W(invert, "invert", &w_negate)  LIT(-1), xor, END
+W(dec,    "1-",     &w_invert)  LIT(1), sub,  END
+W(inc,    "1+",     &w_dec)     LIT(1), add,  END
+W(aligned, "aligned", &w_inc)   LIT(sizeof(*sp) - 1), add, LIT(~(sizeof(*sp) - 1)),
+                                and, END
 W(align,  "align",  &w_aligned) FTH(here), FTH(aligned), LIT(&here), poke, END
-N(comma,  ",",      &w_align)
-W(colon,  ":",      &w_comma)
-    FTH(here), LIT(0), comma, FTH(latest), comma,
-    compname, FTH(align), dup, FTH(here), swap, poke, comp, END
-I(semic,  ";",      &w_colon) LIT(doexit), comma, LIT(&latest), poke, intr, END
-#define LATEST      &w_semic
+W(colon,  ":",      &w_align)   FTH(here), LIT(0), comma, FTH(latest), comma,
+                                compname, FTH(align), dup, FTH(here), swap,
+                                poke, comp, END
+I(semic,  ";",      &w_colon)   LIT(fexit), comma, LIT(&latest), poke, intr, END
+I(literal, "literal", &w_semic) LIT(push), comma, comma, END
+#define LATEST      &w_literal
 
 #include <ctype.h>
 #include <stdio.h>
 #include <string.h>
 
+extern long strtol(char *, char **, int);
+
 NAKED void dot() {
     STASH;
-    printf("%ld ", *sp++);
+    printf("%ld ", *sp);
     RESTORE;
+    ++sp;
     NEXT;
 }
 
-extern long strtol(char *, char **, int);
 static void call(void *ptr);
-//static void dump(void);
 static void init(void);
 
-int base = 10;
-
 int main()
-{
     char buf[128];
 
     init();
 
     for (;;) {
-        //dump();
-
         char c;
         do c = getchar();
         while (!isgraph(c));
@@ -236,7 +198,8 @@ int main()
             }
         }
 
-        puts(state ? "compiled" : "ok");
+        printf(state ? "compiled <%ld>\n" : "ok <%ld>\n",
+            (END_OF(dstack) - sp));
     }
 
     return 0;
@@ -251,27 +214,6 @@ void init(void)
     latest = LATEST;
 }
 
-//void dump(void)
-//{
-//    //printf("IP: %ld\n", (intptr_t)pp);
-//
-//    printf("DS: ");
-//    intptr_t *it = END_OF(dstack) - 1;
-//    while (it >= sp) {
-//        printf("%ld ", *it);
-//        --it;
-//    }
-//    putchar('\n');
-//
-//    //printf("RS: ");
-//    //intptr_t ***rt = END_OF(rstack) - 1;
-//    //while (rt >= rp) {
-//    //    printf("%ld ", (intptr_t)*rt);
-//    //    --rt;
-//    //}
-//    //putchar('\n');
-//}
-
 void call(void *ptr)
 {
     pp = ptr;