add rockbox cross-compiler

1 files changed, 448 insertions, 5 deletions

diff --git a/src/compile.c b/src/compile.c
index a5c3f9a..72b41c1 100644
--- a/src/compile.c
+++ b/src/compile.c
@@ -2,6 +2,9 @@
 #include <platform.h>
 
 #include "opcodes.h"
+#ifdef DUCKY_ROCKBOX
+#include "hid_codes.h"
+#endif
 
 /*******************************************************************************
  * Bytecode format (all numbers are little-endian):
@@ -750,7 +753,7 @@ static vartype eval_expr(char *str)
             }
         }
     }
-    
+
     if(tstart)
     {
         //push_numstack(getValue(tstart, expr));
@@ -961,17 +964,194 @@ static int logchar_handler(char **save)
     {
         eval_expr(tok);
         write_instr(LOGASCII);
-        return OK;
     }
     else
         error("expected expression after LOGCHAR");
 
+    return OK;
+}
+
+#ifdef DUCKY_ROCKBOX
+#define KEY_HANDLER(KEY, NAME)                            \
+    static int NAME ## _handler(char **save)              \
+    {                                                     \
+        write_instr(PUSHIMM);                             \
+        write_imm(KEY);                                   \
+        write_instr(SENDKEY);                             \
+        return OK;                                        \
+    }
+
+KEY_HANDLER(HID_KEYBOARD_RETURN, enter);
+KEY_HANDLER(HID_KEYBOARD_DELETE, del);
+KEY_HANDLER(HID_KEYBOARD_TAB, tab);
+KEY_HANDLER(HID_KEYBOARD_ESCAPE, esc);
+KEY_HANDLER(HID_KEYBOARD_LEFT_GUI, gui);
+KEY_HANDLER(HID_KEYBOARD_RIGHT_GUI, rgui);
+KEY_HANDLER(HID_KEYBOARD_LEFT_CONTROL, ctrl);
+KEY_HANDLER(HID_KEYBOARD_RIGHT_CONTROL, rctrl);
+KEY_HANDLER(HID_KEYBOARD_LEFT_ALT, alt);
+KEY_HANDLER(HID_KEYBOARD_RIGHT_ALT, ralt);
+KEY_HANDLER(HID_KEYBOARD_LEFT_SHIFT, shift)
+KEY_HANDLER(HID_KEYBOARD_RIGHT_SHIFT, rshift);
+KEY_HANDLER(HID_KEYBOARD_MENU, menu);
+KEY_HANDLER(HID_KEYBOARD_PAUSE, pause);
+KEY_HANDLER(HID_KEYBOARD_PRINT_SCREEN, psn);
+KEY_HANDLER(HID_KEYPAD_NUM_LOCK_AND_CLEAR, numlck);
+KEY_HANDLER(HID_KEYBOARD_CAPS_LOCK, cpslck);
+KEY_HANDLER(HID_KEYBOARD_SCROLL_LOCK, scrllck);
+KEY_HANDLER(HID_KEYBOARD_SPACEBAR, space);
+KEY_HANDLER(HID_KEYBOARD_BACKSPACE, bksp);
+KEY_HANDLER(HID_KEYBOARD_UP_ARROW, up);
+KEY_HANDLER(HID_KEYBOARD_DOWN_ARROW, down);
+KEY_HANDLER(HID_KEYBOARD_LEFT_ARROW, left);
+KEY_HANDLER(HID_KEYBOARD_RIGHT_ARROW, right);
+KEY_HANDLER(HID_KEYBOARD_PAGE_UP, pgup);
+KEY_HANDLER(HID_KEYBOARD_PAGE_DOWN, pgdn);
+KEY_HANDLER(HID_KEYBOARD_INSERT, ins);
+KEY_HANDLER(HID_KEYBOARD_HOME, home);
+KEY_HANDLER(HID_KEYBOARD_F1, f1);
+KEY_HANDLER(HID_KEYBOARD_F2, f2);
+KEY_HANDLER(HID_KEYBOARD_F3, f3);
+KEY_HANDLER(HID_KEYBOARD_F4, f4);
+KEY_HANDLER(HID_KEYBOARD_F5, f5);
+KEY_HANDLER(HID_KEYBOARD_F6, f6);
+KEY_HANDLER(HID_KEYBOARD_F7, f7);
+KEY_HANDLER(HID_KEYBOARD_F8, f8);
+KEY_HANDLER(HID_KEYBOARD_F9, f9);
+KEY_HANDLER(HID_KEYBOARD_F10, f10);
+KEY_HANDLER(HID_KEYBOARD_F11, f11);
+KEY_HANDLER(HID_KEYBOARD_F12, f12);
+
+static int dfldel_handler(char **save)
+{
+    char *tok = strtok_r(NULL, ";", save);
+    if(tok)
+    {
+        eval_expr(tok);
+        write_instr(DFL_DELAY);
+    }
+    else
+        error("expected expression for DEFAULT_DELAY");
+    return OK;
+}
+
+static int strdel_handler(char **save)
+{
+    char *tok = strtok_r(NULL, ";", save);
+    if(tok)
+    {
+        eval_expr(tok);
+        write_instr(STR_DELAY);
+    }
+    else
+        error("expected expression for STRING_DELAY");
+    return OK;
+}
+
+static int out_handler(char **save)
+{
+    char *tok = strtok_r(NULL, ";", save);
+    if(tok)
+    {
+        eval_expr(tok);
+        /* types the expression in decimal */
+        write_instr(TYPE_DEC);
+    }
+    else
+        error("expected expression for default delay");
+    return OK;
 }
 
+static int string_handler(char **save)
+{
+    char *str = strtok_r(NULL, "", save);
+
+    write_instr(TYPE_STR);
+    while(*str)
+    {
+        write_byte(*str++);
+    }
+    write_byte('\0');
+    return OK;
+}
+#endif
+
 static struct token_t {
     const char *tok;
     int (*func)(char **save);
 } tokens[] = {
+#ifdef DUCKY_ROCKBOX
+    {  "ALT",            alt_handler       },
+    {  "APP",            menu_handler      },
+    {  "BACKSPACE",      bksp_handler      },
+    {  "BKSP",           bksp_handler      },
+    {  "BREAK",          pause_handler     },
+    {  "CAPS",           cpslck_handler    },
+    {  "CAPSLOCK",       cpslck_handler    },
+    {  "CAPS_LOCK",      cpslck_handler    },
+    {  "CONTROL",        ctrl_handler      },
+    {  "CTRL",           ctrl_handler      },
+    {  "DEFAULT_DELAY",  dfldel_handler    },
+    {  "DEL",            del_handler       },
+    {  "DELETE",         del_handler       },
+    {  "DOWN",           down_handler      },
+    {  "DOWNARROW",      down_handler      },
+    {  "ENTER",          enter_handler     },
+    {  "ESC",            esc_handler       },
+    {  "ESCAPE",         esc_handler       },
+    {  "F1",             f1_handler        },
+    {  "F2",             f2_handler        },
+    {  "F3",             f3_handler        },
+    {  "F4",             f4_handler        },
+    {  "F5",             f5_handler        },
+    {  "F6",             f6_handler        },
+    {  "F7",             f7_handler        },
+    {  "F8",             f8_handler        },
+    {  "F9",             f9_handler        },
+    {  "F10",            f10_handler       },
+    {  "F11",            f11_handler       },
+    {  "F12",            f12_handler       },
+    {  "GUI",            gui_handler       },
+    {  "HOME",           home_handler      },
+    {  "INS",            ins_handler       },
+    {  "INSERT",         ins_handler       },
+    {  "LEFT",           left_handler      },
+    {  "LEFTARROW",      left_handler      },
+    {  "LOGCHAR",        logchar_handler   },
+    {  "MENU",           menu_handler      },
+    {  "META",           alt_handler       },
+    {  "NEWLINE",        newline_handler   },
+    {  "NUMLOCK",        numlck_handler    },
+    {  "NUM_LOCK",       numlck_handler    },
+    {  "OUT",            out_handler       },
+    {  "PAGEDOWN",       pgdn_handler      },
+    {  "PAGEUP",         pgup_handler      },
+    {  "PAUSE",          pause_handler     },
+    {  "PGDOWN",         pgdn_handler      },
+    {  "PGUP",           pgup_handler      },
+    {  "PRINTSCREEN",    psn_handler       },
+    {  "PRINT_SCREEN",   psn_handler       },
+    {  "RALT",           ralt_handler      },
+    {  "RCONTROL",       rctrl_handler     },
+    {  "RCTRL",          rctrl_handler     },
+    {  "REMTA",          ralt_handler      },
+    {  "RGUI",           rgui_handler      },
+    {  "RIGHT",          right_handler     },
+    {  "RIGHTARROW",     right_handler     },
+    {  "RSHIFT",         rshift_handler    },
+    {  "SCROLL",         scrllck_handler   },
+    {  "SCROLLLOCK",     scrllck_handler   },
+    {  "SCROLL_LOCK",    scrllck_handler   },
+    {  "SHIFT",          shift_handler     },
+    {  "SPACE",          space_handler     },
+    {  "SPACEBAR",       space_handler     },
+    {  "STRING",         string_handler    },
+    {  "STRING_DELAY",   strdel_handler    },
+    {  "SYSRQ",          psn_handler       },
+    {  "TAB",            tab_handler       },
+    {  "UP",             up_handler        },
+    {  "UPARROW",        up_handler        },
+#else
     { "LET",     let_handler,     },
     { "REPEAT",  repeat_handler,  },
     { "JUMP",    goto_handler,    },
@@ -994,6 +1174,7 @@ static struct token_t {
     { "LBL",     rem_handler,     },
     { "QUIT",    quit_handler,    },
     { "EXIT",    quit_handler,    },
+#endif
 };
 
 /* once again, this lookup table is implemented with a perfect hash map */
@@ -1001,6 +1182,265 @@ static struct token_t {
 #define TOKMAP_SIZE ARRAYLEN(tokens)
 static struct token_t tokmap[TOKMAP_SIZE];
 
+#ifdef DUCKY_ROCKBOX
+/* generated with mph 1.2 */
+/* sacrifices memory for SPEED! */
+/*
+ * d=3
+ * n=87
+ * m=70
+ * c=1.23
+ * maxlen=13
+ * minklen=2
+ * maxklen=13
+ * minchar=48
+ * maxchar=95
+ * loop=0
+ * numiter=64
+ * seed=
+ */
+
+static int g[] = {
+          13,   53,    0,    0,   50,    4,    0,   40,   -1,   -1,
+          24,   27,   16,   26,   57,    1,    0,   27,   48,   -1,
+          36,   32,   39,   12,   45,    0,   23,   37,   54,   37,
+          29,   47,   37,   28,    0,    5,   27,    0,   59,   10,
+          20,    0,   16,   68,   64,   45,   -1,   -1,   45,   29,
+          21,   49,   20,   56,   29,    8,   13,   38,    0,    8,
+          20,   17,    0,   58,   56,   56,    8,    6,    5,   53,
+          33,   29,    0,    0,   34,   20,   42,   -1,    7,   23,
+          49,    0,   51,   51,   29,   12,   24,
+};
+
+static int T0[] = {
+        0x08, 0x49, 0x24, 0x38, 0x28, 0x43, 0x0d, 0x20, 0x28, 0x15,
+        0x54, 0x00, 0x3e, 0x2f, 0x53, 0x22, 0x52, 0x4a, 0x15, 0x2f,
+        0x1c, 0x3e, 0x4e, 0x1b, 0x2d, 0x49, 0x4c, 0x25, 0x1c, 0x4a,
+        0x13, 0x25, 0x3c, 0x37, 0x55, 0x0d, 0x23, 0x0b, 0x26, 0x43,
+        0x18, 0x1b, 0x44, 0x56, 0x4a, 0x40, 0x22, 0x46, 0x10, 0x19,
+        0x00, 0x27, 0x49, 0x50, 0x07, 0x20, 0x3a, 0x05, 0x0a, 0x15,
+        0x19, 0x47, 0x43, 0x3d, 0x0f, 0x53, 0x09, 0x2c, 0x02, 0x27,
+        0x2f, 0x29, 0x49, 0x10, 0x37, 0x39, 0x31, 0x31, 0x56, 0x41,
+        0x4a, 0x56, 0x09, 0x34, 0x47, 0x10, 0x55, 0x2a, 0x15, 0x00,
+        0x3f, 0x26, 0x47, 0x2b, 0x0d, 0x00, 0x35, 0x53, 0x1a, 0x07,
+        0x45, 0x38, 0x4b, 0x1b, 0x40, 0x25, 0x27, 0x4c, 0x0c, 0x52,
+        0x00, 0x07, 0x0e, 0x05, 0x0c, 0x40, 0x1c, 0x2b, 0x36, 0x38,
+        0x46, 0x16, 0x18, 0x0c, 0x44, 0x1e, 0x08, 0x23, 0x1a, 0x22,
+        0x2a, 0x00, 0x03, 0x16, 0x14, 0x3b, 0x3b, 0x3b, 0x28, 0x47,
+        0x2e, 0x20, 0x47, 0x3c, 0x36, 0x37, 0x31, 0x31, 0x43, 0x27,
+        0x49, 0x14, 0x26, 0x26, 0x29, 0x1d, 0x11, 0x0e, 0x02, 0x15,
+        0x0a, 0x3e, 0x41, 0x2d, 0x47, 0x10, 0x2c, 0x52, 0x04, 0x29,
+        0x30, 0x3e, 0x18, 0x48, 0x2b, 0x4e, 0x20, 0x54, 0x20, 0x0d,
+        0x24, 0x0a, 0x19, 0x42, 0x30, 0x42, 0x09, 0x3a, 0x48, 0x03,
+        0x4f, 0x4b, 0x41, 0x05, 0x48, 0x15, 0x18, 0x3b, 0x29, 0x52,
+        0x29, 0x24, 0x3b, 0x18, 0x0e, 0x2f, 0x36, 0x2d, 0x44, 0x53,
+        0x32, 0x15, 0x46, 0x42, 0x1b, 0x4e, 0x39, 0x34, 0x2d, 0x49,
+        0x16, 0x17, 0x00, 0x4f, 0x14, 0x40, 0x06, 0x24, 0x1c, 0x2f,
+        0x1f, 0x45, 0x4b, 0x03, 0x56, 0x51, 0x2b, 0x35, 0x27, 0x18,
+        0x2d, 0x28, 0x1f, 0x55, 0x53, 0x35, 0x31, 0x2f, 0x13, 0x55,
+        0x2c, 0x21, 0x00, 0x1e, 0x3c, 0x35, 0x43, 0x10, 0x07, 0x39,
+        0x3d, 0x4a, 0x2f, 0x14, 0x0f, 0x3d, 0x34, 0x33, 0x25, 0x23,
+        0x30, 0x4a, 0x4b, 0x4f, 0x41, 0x48, 0x2e, 0x1b, 0x20, 0x39,
+        0x11, 0x44, 0x52, 0x11, 0x0b, 0x30, 0x3e, 0x4e, 0x36, 0x51,
+        0x44, 0x19, 0x44, 0x2b, 0x22, 0x17, 0x02, 0x56, 0x44, 0x0a,
+        0x00, 0x12, 0x38, 0x0d, 0x49, 0x3b, 0x27, 0x19, 0x34, 0x0e,
+        0x4b, 0x29, 0x47, 0x03, 0x51, 0x27, 0x04, 0x51, 0x51, 0x3a,
+        0x4b, 0x3f, 0x4b, 0x38, 0x0b, 0x0e, 0x4f, 0x06, 0x0d, 0x35,
+        0x10, 0x0e, 0x47, 0x48, 0x13, 0x32, 0x17, 0x51, 0x12, 0x27,
+        0x4d, 0x37, 0x0a, 0x18, 0x0f, 0x19, 0x53, 0x18, 0x3e, 0x43,
+        0x16, 0x16, 0x28, 0x1f, 0x37, 0x4e, 0x2d, 0x30, 0x4b, 0x44,
+        0x02, 0x2b, 0x51, 0x36, 0x4c, 0x17, 0x3a, 0x0c, 0x09, 0x44,
+        0x2c, 0x56, 0x25, 0x36, 0x17, 0x2c, 0x47, 0x0c, 0x3c, 0x27,
+        0x47, 0x4a, 0x35, 0x18, 0x1e, 0x39, 0x3d, 0x2e, 0x01, 0x47,
+        0x4d, 0x07, 0x0f, 0x4f, 0x53, 0x1d, 0x37, 0x10, 0x17, 0x4b,
+        0x1b, 0x36, 0x0b, 0x1d, 0x2e, 0x52, 0x43, 0x10, 0x2c, 0x2c,
+        0x35, 0x17, 0x3f, 0x2a, 0x31, 0x06, 0x0d, 0x0f, 0x2d, 0x06,
+        0x56, 0x23, 0x0d, 0x07, 0x13, 0x02, 0x24, 0x42, 0x0a, 0x3b,
+        0x37, 0x25, 0x15, 0x42, 0x4c, 0x52, 0x25, 0x1c, 0x4e, 0x26,
+        0x49, 0x39, 0x4d, 0x50, 0x32, 0x22, 0x0e, 0x4d, 0x42, 0x2b,
+        0x3c, 0x35, 0x0c, 0x1f, 0x08, 0x23, 0x3b, 0x07, 0x3c, 0x2e,
+        0x51, 0x0b, 0x13, 0x07, 0x4d, 0x09, 0x52, 0x14, 0x1d, 0x49,
+        0x3a, 0x07, 0x23, 0x31, 0x00, 0x4d, 0x4b, 0x07, 0x3b, 0x2e,
+        0x19, 0x0c, 0x08, 0x16, 0x0f, 0x03, 0x36, 0x0a, 0x25, 0x3d,
+        0x05, 0x44, 0x01, 0x22, 0x56, 0x3c, 0x47, 0x36, 0x37, 0x02,
+        0x40, 0x45, 0x07, 0x40, 0x27, 0x08, 0x36, 0x4f, 0x4c, 0x11,
+        0x53, 0x0f, 0x1d, 0x53, 0x25, 0x24, 0x56, 0x04, 0x2e, 0x1c,
+        0x3a, 0x34, 0x0a, 0x3b, 0x4e, 0x01, 0x18, 0x3e, 0x4a, 0x09,
+        0x47, 0x23, 0x47, 0x14, 0x15, 0x48, 0x4f, 0x2e, 0x46, 0x0a,
+        0x3d, 0x44, 0x23, 0x49, 0x08, 0x3a, 0x3b, 0x42, 0x36, 0x49,
+        0x06, 0x52, 0x34, 0x46, 0x33, 0x2e, 0x14, 0x32, 0x23, 0x00,
+        0x3b, 0x13, 0x23, 0x2b, 0x28, 0x31, 0x14, 0x20, 0x00, 0x04,
+        0x2a, 0x3e, 0x40, 0x45, 0x28, 0x48, 0x36, 0x12, 0x0f, 0x2c,
+        0x14, 0x36, 0x16, 0x0b, 0x42, 0x4b, 0x33, 0x22, 0x52, 0x07,
+        0x42, 0x3a, 0x1a, 0x3c, 0x49, 0x19, 0x4e, 0x45, 0x3c, 0x05,
+        0x05, 0x54, 0x53, 0x30, 0x1b, 0x51, 0x0b, 0x51, 0x0c, 0x1a,
+        0x26, 0x20, 0x49, 0x3d, 0x24, 0x34, 0x29, 0x00, 0x4e, 0x25,
+        0x08, 0x32, 0x08, 0x1a,
+};
+
+static int T1[] = {
+        0x52, 0x34, 0x35, 0x46, 0x2e, 0x4c, 0x50, 0x13, 0x54, 0x44,
+        0x20, 0x31, 0x20, 0x04, 0x3f, 0x11, 0x13, 0x2d, 0x4a, 0x14,
+        0x52, 0x0a, 0x3b, 0x33, 0x44, 0x15, 0x30, 0x3c, 0x29, 0x28,
+        0x18, 0x1c, 0x05, 0x4e, 0x03, 0x2c, 0x3b, 0x54, 0x3f, 0x38,
+        0x39, 0x00, 0x0a, 0x03, 0x04, 0x49, 0x14, 0x17, 0x1a, 0x47,
+        0x0c, 0x40, 0x13, 0x2a, 0x04, 0x00, 0x37, 0x4c, 0x30, 0x54,
+        0x2a, 0x11, 0x23, 0x11, 0x17, 0x54, 0x3b, 0x45, 0x35, 0x41,
+        0x27, 0x0f, 0x14, 0x4d, 0x3c, 0x00, 0x34, 0x55, 0x3e, 0x4e,
+        0x3d, 0x42, 0x37, 0x48, 0x0d, 0x3b, 0x49, 0x44, 0x29, 0x1a,
+        0x3a, 0x4b, 0x2b, 0x06, 0x05, 0x42, 0x53, 0x45, 0x45, 0x55,
+        0x36, 0x44, 0x0b, 0x31, 0x40, 0x3a, 0x0a, 0x2f, 0x39, 0x04,
+        0x56, 0x1b, 0x34, 0x1d, 0x09, 0x19, 0x48, 0x19, 0x29, 0x1f,
+        0x17, 0x4a, 0x31, 0x3c, 0x00, 0x3d, 0x2a, 0x4b, 0x23, 0x18,
+        0x41, 0x02, 0x54, 0x4c, 0x2b, 0x3d, 0x28, 0x36, 0x0d, 0x0a,
+        0x32, 0x0c, 0x1d, 0x10, 0x1e, 0x1a, 0x4b, 0x1e, 0x2f, 0x36,
+        0x24, 0x44, 0x20, 0x1f, 0x34, 0x25, 0x43, 0x21, 0x4f, 0x51,
+        0x47, 0x19, 0x20, 0x25, 0x0e, 0x11, 0x49, 0x2f, 0x2d, 0x29,
+        0x2a, 0x35, 0x32, 0x49, 0x24, 0x48, 0x0c, 0x19, 0x10, 0x3c,
+        0x4f, 0x2c, 0x21, 0x19, 0x4b, 0x55, 0x36, 0x2f, 0x20, 0x26,
+        0x29, 0x08, 0x00, 0x14, 0x41, 0x15, 0x18, 0x4c, 0x0e, 0x4a,
+        0x46, 0x0d, 0x10, 0x33, 0x19, 0x0a, 0x0c, 0x16, 0x22, 0x07,
+        0x00, 0x1f, 0x05, 0x22, 0x3b, 0x40, 0x51, 0x48, 0x45, 0x09,
+        0x16, 0x2a, 0x48, 0x16, 0x3f, 0x2a, 0x2b, 0x4f, 0x1f, 0x31,
+        0x43, 0x06, 0x3f, 0x4b, 0x3a, 0x50, 0x56, 0x46, 0x10, 0x21,
+        0x4a, 0x4a, 0x14, 0x22, 0x28, 0x41, 0x4b, 0x42, 0x00, 0x51,
+        0x33, 0x4e, 0x19, 0x56, 0x22, 0x21, 0x08, 0x16, 0x04, 0x3d,
+        0x38, 0x3e, 0x0a, 0x3d, 0x0c, 0x55, 0x14, 0x47, 0x22, 0x36,
+        0x31, 0x15, 0x21, 0x3d, 0x2f, 0x49, 0x1f, 0x23, 0x2c, 0x20,
+        0x15, 0x01, 0x0f, 0x2f, 0x00, 0x31, 0x48, 0x01, 0x30, 0x0c,
+        0x34, 0x43, 0x31, 0x51, 0x35, 0x4e, 0x10, 0x09, 0x3d, 0x23,
+        0x1c, 0x15, 0x15, 0x4f, 0x02, 0x0c, 0x4a, 0x48, 0x27, 0x4b,
+        0x22, 0x04, 0x01, 0x0f, 0x2e, 0x25, 0x43, 0x4e, 0x0b, 0x1c,
+        0x03, 0x38, 0x08, 0x2c, 0x32, 0x3d, 0x24, 0x3b, 0x3e, 0x02,
+        0x07, 0x03, 0x17, 0x14, 0x52, 0x12, 0x11, 0x2e, 0x32, 0x1a,
+        0x49, 0x1a, 0x2e, 0x13, 0x55, 0x4b, 0x4b, 0x29, 0x44, 0x18,
+        0x01, 0x38, 0x4c, 0x14, 0x30, 0x16, 0x4e, 0x44, 0x4b, 0x33,
+        0x4d, 0x31, 0x4b, 0x38, 0x46, 0x43, 0x50, 0x4f, 0x1a, 0x2b,
+        0x0a, 0x04, 0x3e, 0x30, 0x18, 0x34, 0x24, 0x04, 0x06, 0x0a,
+        0x14, 0x00, 0x42, 0x09, 0x1b, 0x4a, 0x2b, 0x36, 0x3f, 0x4c,
+        0x1a, 0x0e, 0x54, 0x3d, 0x0a, 0x01, 0x06, 0x27, 0x53, 0x41,
+        0x51, 0x51, 0x25, 0x07, 0x10, 0x3b, 0x33, 0x2d, 0x0c, 0x33,
+        0x48, 0x1d, 0x41, 0x51, 0x0c, 0x05, 0x44, 0x2f, 0x33, 0x24,
+        0x1c, 0x4d, 0x32, 0x11, 0x33, 0x34, 0x0b, 0x32, 0x05, 0x07,
+        0x1c, 0x56, 0x1d, 0x17, 0x1b, 0x2f, 0x0a, 0x51, 0x47, 0x3d,
+        0x03, 0x23, 0x28, 0x18, 0x35, 0x1f, 0x33, 0x52, 0x26, 0x35,
+        0x0c, 0x23, 0x31, 0x30, 0x03, 0x03, 0x3d, 0x33, 0x4f, 0x3a,
+        0x52, 0x05, 0x44, 0x19, 0x1c, 0x08, 0x48, 0x1e, 0x52, 0x30,
+        0x53, 0x55, 0x53, 0x24, 0x0e, 0x29, 0x43, 0x39, 0x24, 0x0b,
+        0x4b, 0x01, 0x10, 0x47, 0x3d, 0x1e, 0x18, 0x01, 0x32, 0x4e,
+        0x42, 0x41, 0x2f, 0x0a, 0x2d, 0x28, 0x38, 0x54, 0x29, 0x20,
+        0x11, 0x37, 0x21, 0x1a, 0x32, 0x45, 0x18, 0x2e, 0x18, 0x48,
+        0x18, 0x04, 0x49, 0x28, 0x4b, 0x27, 0x46, 0x0c, 0x28, 0x22,
+        0x52, 0x0b, 0x04, 0x2a, 0x0d, 0x32, 0x52, 0x46, 0x53, 0x26,
+        0x4f, 0x34, 0x11, 0x08, 0x2d, 0x46, 0x31, 0x33, 0x3b, 0x0e,
+        0x19, 0x0f, 0x4c, 0x0b, 0x49, 0x2c, 0x3f, 0x06, 0x46, 0x4a,
+        0x26, 0x25, 0x33, 0x3a, 0x35, 0x07, 0x42, 0x42, 0x2b, 0x36,
+        0x09, 0x1c, 0x13, 0x1b, 0x24, 0x38, 0x02, 0x4d, 0x0c, 0x3d,
+        0x04, 0x1e, 0x44, 0x51, 0x29, 0x36, 0x43, 0x37, 0x47, 0x23,
+        0x0f, 0x38, 0x3c, 0x3d, 0x06, 0x30, 0x08, 0x3d, 0x27, 0x07,
+        0x0b, 0x09, 0x3c, 0x0a, 0x14, 0x49, 0x43, 0x35, 0x2b, 0x34,
+        0x38, 0x1e, 0x0d, 0x50, 0x01, 0x12, 0x09, 0x44, 0x41, 0x50,
+        0x08, 0x48, 0x29, 0x3d, 0x2f, 0x2f, 0x0e, 0x37, 0x0e, 0x35,
+        0x36, 0x11, 0x3e, 0x1b,
+};
+
+static int T2[] = {
+        0x00, 0x46, 0x2f, 0x0e, 0x0b, 0x0c, 0x19, 0x2b, 0x28, 0x17,
+        0x4c, 0x38, 0x30, 0x1f, 0x12, 0x55, 0x09, 0x42, 0x39, 0x2c,
+        0x30, 0x14, 0x2d, 0x51, 0x26, 0x38, 0x49, 0x4e, 0x39, 0x06,
+        0x48, 0x31, 0x44, 0x18, 0x40, 0x50, 0x24, 0x51, 0x1c, 0x4d,
+        0x11, 0x11, 0x2e, 0x41, 0x30, 0x40, 0x37, 0x31, 0x37, 0x1e,
+        0x18, 0x1d, 0x4b, 0x16, 0x22, 0x2f, 0x1a, 0x0d, 0x51, 0x2c,
+        0x4d, 0x55, 0x1a, 0x19, 0x06, 0x13, 0x4d, 0x0b, 0x38, 0x44,
+        0x24, 0x17, 0x32, 0x0a, 0x3f, 0x30, 0x1f, 0x28, 0x1b, 0x56,
+        0x47, 0x2b, 0x1c, 0x33, 0x42, 0x36, 0x0b, 0x05, 0x3c, 0x06,
+        0x29, 0x2a, 0x53, 0x43, 0x43, 0x51, 0x56, 0x0a, 0x0c, 0x28,
+        0x42, 0x20, 0x15, 0x1c, 0x4b, 0x36, 0x3a, 0x11, 0x36, 0x3d,
+        0x10, 0x07, 0x05, 0x0f, 0x01, 0x12, 0x1a, 0x02, 0x34, 0x27,
+        0x4a, 0x04, 0x0a, 0x46, 0x0d, 0x0a, 0x05, 0x0d, 0x15, 0x12,
+        0x2d, 0x4f, 0x2a, 0x42, 0x14, 0x1e, 0x19, 0x46, 0x27, 0x48,
+        0x2c, 0x2f, 0x4f, 0x2a, 0x2d, 0x54, 0x19, 0x2a, 0x29, 0x2e,
+        0x4d, 0x40, 0x30, 0x2b, 0x1a, 0x01, 0x16, 0x17, 0x28, 0x50,
+        0x03, 0x1c, 0x4f, 0x35, 0x4c, 0x39, 0x17, 0x1b, 0x0d, 0x50,
+        0x17, 0x34, 0x4c, 0x43, 0x10, 0x22, 0x38, 0x22, 0x44, 0x02,
+        0x50, 0x32, 0x3a, 0x22, 0x07, 0x54, 0x23, 0x15, 0x0c, 0x43,
+        0x0e, 0x07, 0x56, 0x47, 0x12, 0x4e, 0x0e, 0x56, 0x34, 0x43,
+        0x36, 0x27, 0x1c, 0x01, 0x55, 0x02, 0x1d, 0x01, 0x4d, 0x44,
+        0x30, 0x3b, 0x2d, 0x3c, 0x37, 0x27, 0x2a, 0x54, 0x1b, 0x21,
+        0x46, 0x28, 0x3f, 0x45, 0x18, 0x52, 0x34, 0x1f, 0x51, 0x12,
+        0x0b, 0x28, 0x31, 0x28, 0x21, 0x2f, 0x2a, 0x37, 0x28, 0x18,
+        0x4b, 0x49, 0x04, 0x50, 0x10, 0x31, 0x56, 0x53, 0x02, 0x4f,
+        0x11, 0x32, 0x51, 0x29, 0x1e, 0x45, 0x34, 0x4b, 0x10, 0x09,
+        0x41, 0x35, 0x26, 0x54, 0x45, 0x25, 0x47, 0x51, 0x4d, 0x16,
+        0x46, 0x39, 0x09, 0x43, 0x32, 0x19, 0x15, 0x29, 0x0d, 0x17,
+        0x21, 0x16, 0x41, 0x1b, 0x40, 0x09, 0x09, 0x15, 0x05, 0x1f,
+        0x34, 0x2d, 0x4c, 0x11, 0x4a, 0x0d, 0x45, 0x06, 0x20, 0x34,
+        0x3f, 0x25, 0x12, 0x3e, 0x53, 0x17, 0x1e, 0x29, 0x36, 0x4f,
+        0x29, 0x4c, 0x12, 0x17, 0x3f, 0x56, 0x3d, 0x15, 0x30, 0x42,
+        0x34, 0x0d, 0x10, 0x21, 0x17, 0x52, 0x27, 0x54, 0x01, 0x47,
+        0x31, 0x38, 0x15, 0x3c, 0x20, 0x11, 0x55, 0x29, 0x28, 0x03,
+        0x43, 0x16, 0x3a, 0x19, 0x40, 0x36, 0x01, 0x33, 0x4a, 0x0e,
+        0x56, 0x0e, 0x06, 0x3c, 0x11, 0x10, 0x1f, 0x51, 0x4b, 0x11,
+        0x01, 0x50, 0x25, 0x3c, 0x3f, 0x54, 0x05, 0x3d, 0x1e, 0x26,
+        0x41, 0x0a, 0x3c, 0x1c, 0x1b, 0x1e, 0x52, 0x15, 0x49, 0x3d,
+        0x23, 0x48, 0x4c, 0x22, 0x3b, 0x2e, 0x09, 0x4d, 0x4c, 0x3e,
+        0x42, 0x41, 0x0e, 0x14, 0x03, 0x1c, 0x4c, 0x40, 0x35, 0x48,
+        0x26, 0x04, 0x15, 0x1b, 0x35, 0x24, 0x31, 0x14, 0x29, 0x02,
+        0x2f, 0x0a, 0x19, 0x11, 0x39, 0x4c, 0x3f, 0x3b, 0x42, 0x2d,
+        0x1a, 0x2d, 0x17, 0x20, 0x41, 0x12, 0x3c, 0x2e, 0x52, 0x12,
+        0x1f, 0x1a, 0x17, 0x21, 0x23, 0x07, 0x4e, 0x26, 0x15, 0x1f,
+        0x1d, 0x16, 0x1b, 0x19, 0x48, 0x14, 0x4c, 0x1b, 0x13, 0x46,
+        0x3c, 0x37, 0x3d, 0x49, 0x0b, 0x32, 0x26, 0x3c, 0x2c, 0x1f,
+        0x07, 0x08, 0x0b, 0x1e, 0x29, 0x2e, 0x1d, 0x21, 0x4c, 0x32,
+        0x38, 0x0b, 0x40, 0x53, 0x1c, 0x31, 0x10, 0x11, 0x44, 0x1c,
+        0x42, 0x2a, 0x49, 0x29, 0x50, 0x21, 0x1a, 0x16, 0x16, 0x56,
+        0x03, 0x23, 0x4f, 0x2a, 0x04, 0x28, 0x49, 0x3b, 0x11, 0x39,
+        0x0d, 0x0b, 0x40, 0x2e, 0x07, 0x05, 0x10, 0x30, 0x19, 0x36,
+        0x4a, 0x05, 0x09, 0x3c, 0x26, 0x02, 0x55, 0x40, 0x10, 0x14,
+        0x3f, 0x0c, 0x2f, 0x2f, 0x36, 0x2b, 0x4f, 0x20, 0x35, 0x0d,
+        0x2f, 0x1c, 0x02, 0x15, 0x18, 0x2d, 0x3d, 0x41, 0x51, 0x3e,
+        0x1c, 0x0e, 0x3b, 0x29, 0x0a, 0x39, 0x55, 0x0c, 0x3e, 0x00,
+        0x27, 0x14, 0x4d, 0x16, 0x11, 0x50, 0x49, 0x00, 0x00, 0x1f,
+        0x05, 0x27, 0x33, 0x08, 0x34, 0x43, 0x2d, 0x1b, 0x2d, 0x20,
+        0x51, 0x41, 0x26, 0x2d, 0x0c, 0x30, 0x10, 0x1f, 0x32, 0x0c,
+        0x18, 0x3f, 0x34, 0x07, 0x30, 0x0b, 0x28, 0x3d, 0x0b, 0x00,
+        0x0a, 0x13, 0x1e, 0x49, 0x0c, 0x3e, 0x09, 0x41, 0x01, 0x19,
+        0x1a, 0x4e, 0x41, 0x4e, 0x35, 0x01, 0x0e, 0x3d, 0x18, 0x40,
+        0x41, 0x31, 0x28, 0x1e, 0x30, 0x50, 0x22, 0x50, 0x37, 0x2d,
+        0x49, 0x39, 0x41, 0x10,
+};
+
+#define uchar unsigned char
+
+int
+tok_hash(const uchar *key)
+{
+        int i;
+        unsigned f0, f1, f2;
+        const uchar *kp = key;
+
+        for (i=-48, f0=f1=f2=0; *kp; ++kp) {
+                if (*kp < 48 || *kp > 95)
+                        return -1;
+                if (kp-key > 12)
+                        return -1;
+                f0 += T0[i + *kp];
+                f1 += T1[i + *kp];
+                f2 += T2[i + *kp];
+                i += 48;
+        }
+
+        if (kp-key < 2)
+                return -1;
+
+        f0 %= 87;
+        f1 %= 87;
+        f2 %= 87;
+
+        return (g[f0] + g[f1] + g[f2]) % 70;
+}
+#else
+
 /* auto-generated with mph-1.2 */
 /*
  * d=3
@@ -1154,12 +1594,13 @@ tok_hash(const uchar *key)
 
         return (g[f0] + g[f1] + g[f2]) % 22;
 }
+#endif
 
 static void tokmap_insert(struct token_t *tok)
 {
     uint32_t hash = tok_hash(tok->tok) % TOKMAP_SIZE;
     if(hash < 0 || tokmap[hash].tok)
-        error("FIXME: hash map collision");
+        error("FIXME: hash map collision %s %s", tok->tok, tokmap[hash].tok);
     memcpy(tokmap+hash, tok, sizeof(*tok));
 }
 
@@ -1218,7 +1659,7 @@ void ducky_compile(int fd, bool verbose, int out)
     /* initialize some other constants */
 
     makeConstantVariable(".", 0);
-    
+
     makeConstantVariable("true", 1);
     makeConstantVariable("false", 0);
 
@@ -1271,7 +1712,9 @@ void ducky_compile(int fd, bool verbose, int out)
                 default:
                     error("FIXME: invalid return value");
                 }
-            else if(tok[0] != '#')
+            else if(tok[0] == '#')
+                goto next_line;
+            else
             {
                 error("unknown token `%s` on line %d %d", tok, current_line);
                 goto done;