basic.js

//
// BASIC Compiler and Executor
//

// API:
//    var program = basic.compile(source);
//    // may throw basic.ParseError
//
//    program.init({tty: ..., hires: .e.., lores: ...})
//
//    // if TTY input is blocking:
//
//    var state;
//    do {
//        state = program.step();
//        // may throw basic.RuntimeError
//    } while (state !== basic.STATE_STOPPED);
//
//    // if TTY input is non-blocking:
//    function driver() {
//        var state;
//        do {
//            state = program.step(driver);
//            // may throw basic.RuntimeError
//        } while (state === basic.STATE_RUNNING);
//    }
//    driver(); // step until done or blocked
//    // driver will also be called after input is unblocked
//    // driver may want to yield via setTimeout() after N steps

this.basic = (function() {

  var basic = {
    STATE_STOPPED: 0,
    STATE_RUNNING: 1,
    STATE_BLOCKED: 2
  };

  //
  // Thrown if parsing fails
  //
  basic.ParseError = function(msg, line, column) {
    this.name = 'ParseError';
    this.message = msg || '';
    this.line = line;
    this.column = column;
  };
  basic.ParseError.prototype = new Error();


  //
  // Thrown when a program is running; can be caught by ONERR
  //
  basic.RuntimeError = function(msg, code) {
    this.name = 'RuntimeError';
    this.message = msg;
    this.code = code;
  };
  basic.RuntimeError.prototype = new Error();

  function runtime_error(msg) {
    if (typeof msg === 'object' && msg.length && msg.length >= 2) {
      throw new basic.RuntimeError(msg[1], msg[0]);
    } else {
      throw new basic.RuntimeError(msg);
    }
  }

  var ERRORS = {
    NEXT_WITHOUT_FOR: [0, "Next without for"],
    SYNTAX_ERROR: [16, "Syntax error"],
    RETURN_WITHOUT_GOSUB: [22, "Return without gosub"],
    OUT_OF_DATA: [42, "Out of data"],
    ILLEGAL_QUANTITY: [53, "Illegal quantity"],
    OVERFLOW: [69, "Overflow"],
    OUT_OF_MEMORY: [77, "Out of memory"],
    UNDEFINED_STATEMENT: [90, "Undefined statement"],
    BAD_SUBSCRIPT: [107, "Bad subscript"],
    REDIMED_ARRAY: [120, "Redimensioned array"],
    DIVISION_BY_ZERO: [133, "Division by zero"],
    TYPE_MISMATCH: [163, "Type mismatch"],
    STRING_TOO_LONG: [176, "String too long"],
    FORMULA_TOO_COMPLEX: [191, "Formula too complex"],
    UNDEFINED_FUNCTION: [224, "Undefined function"],
    REENTER: [254, "Re-enter"],
    INTERRUPT: [255, "Break"]
  };

  // Keyword table - these can be altered (e.g. localized) here
  var kws = {
    ABS: "ABS",
    AND: "AND",
    ASC: "ASC",
    ATN: "ATN",
    AT: "AT",
    CALL: "CALL",
    CHR$: "CHR$",
    CLEAR: "CLEAR",
    COLOR: "COLOR=",
    CONT: "CONT",
    COS: "COS",
    DATA: "DATA",
    DEF: "DEF",
    DEL: "DEL",
    DIM: "DIM",
    DRAW: "DRAW",
    END: "END",
    EXP: "EXP",
    FLASH: "FLASH",
    FN: "FN",
    FOR: "FOR",
    FRE: "FRE",
    GET: "GET",
    GOSUB: "GOSUB",
    GOTO: "GOTO",
    GR: "GR",
    HCOLOR: "HCOLOR=",
    HGR2: "HGR2",
    HGR: "HGR",
    HIMEM: "HIMEM:",
    HLIN: "HLIN",
    HOME: "HOME",
    HPLOT: "HPLOT",
    HTAB: "HTAB",
    IF: "IF",
    IN: "IN#",
    INPUT: "INPUT",
    INT: "INT",
    INVERSE: "INVERSE",
    LEFT$: "LEFT$",
    LEN: "LEN",
    LET: "LET",
    LIST: "LIST",
    LOAD: "LOAD",
    LOG: "LOG",
    LOMEM: "LOMEM:",
    MID$: "MID$",
    NEW: "NEW",
    NEXT: "NEXT",
    NORMAL: "NORMAL",
    NOTRACE: "NOTRACE",
    NOT: "NOT",
    ONERR: "ONERR",
    ON: "ON",
    OR: "OR",
    PDL: "PDL",
    PEEK: "PEEK",
    PLOT: "PLOT",
    POKE: "POKE",
    POP: "POP",
    POS: "POS",
    PRINT: "PRINT",
    PR: "PR#",
    READ: "READ",
    RECALL: "RECALL",
    REM: "REM",
    RESTORE: "RESTORE",
    RESUME: "RESUME",
    RETURN: "RETURN",
    RIGHT$: "RIGHT$",
    RND: "RND",
    ROT: "ROT=",
    RUN: "RUN",
    SAVE: "SAVE",
    SCALE: "SCALE=",
    SCRN: "SCRN",
    SGN: "SGN",
    SHLOAD: "SHLOAD",
    SIN: "SIN",
    SPC: "SPC",
    SPEED: "SPEED=",
    SQR: "SQR",
    STEP: "STEP",
    STOP: "STOP",
    STORE: "STORE",
    STR$: "STR$",
    TAB: "TAB",
    TAN: "TAN",
    TEXT: "TEXT",
    THEN: "THEN",
    TO: "TO",
    TRACE: "TRACE",
    USR: "USR",
    VAL: "VAL",
    VLIN: "VLIN",
    VTAB: "VTAB",
    WAIT: "WAIT",
    XDRAW: "XDRAW",
    AMPERSAND: "&",
    QUESTION: "?",
    HSCRN: "HSCRN"
  };

  //
  // Runtime flow control
  //
  function EndProgram() { }
  function GoToLine(n) { this.line = n; }
  function NextLine() { }
  function BlockingInput(method, callback) {
    this.method = method;
    this.callback = callback;
  }

  // Adapted from:
  // http://stackoverflow.com/questions/424292/how-to-create-my-own-javascript-random-number-generator-that-i-can-also-set-the-s
  function PRNG() {
    var S = 2345678901, // seed
        A = 48271, // const
        M = 2147483647, // const
        Q = M / A, // const
        R = M % A; // const

    this.next = function PRNG_next() {
      var hi = S / Q,
          lo = S % Q,
          t = A * lo - R * hi;
      S = (t > 0) ? t : t + M;
      this.last = S / M;
      return this.last;
    };
    this.seed = function PRNG_seed(x) {
      S = Math.floor(Math.abs(x));
    };
    this.next();
  }

  // Multidimensional array, with auto-dimensioning on first access
  function BASICArray(type, dims) {

    var array, dimensions;

    function offset(dims, subscripts) {
      if (subscripts.length !== dimensions.length) {
        runtime_error(ERRORS.BAD_SUBSCRIPT);
      }

      var k, l, s = 0, p, ss;
      for (k = 0; k < dims.length; k += 1) {

        ss = subscripts[k];
        if (ss < 0) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }
        ss = ss >> 0;
        if (ss >= dims[k]) {
          runtime_error(ERRORS.BAD_SUBSCRIPT);
        }

        p = 1;
        for (l = k + 1; l < dims.length; l += 1) {
          p *= dims[l];
        }
        s += p * ss;
      }
      return s;
    }

    this.dim = function dim(dims) {
      if (array) {
        runtime_error(ERRORS.REDIMED_ARRAY);
      }

      dimensions = dims.map(function(n) { return (Number(n) >> 0) + 1; });

      var i, len = dimensions.reduce(function(a, b) { return a * b; }),
          defval = (type === 'string') ? '' : 0;

      array = [];
      for (i = 0; i < len; i += 1) {
        array[i] = defval;
      }
    };

    this.get = function get(subscripts) {
      if (!array) {
        this.dim(subscripts.map(function() { return 10; }));
      }


      return array[offset(dimensions, subscripts)];
    };

    this.set = function set(subscripts, value) {
      if (!array) {
        this.dim(subscripts.map(function() { return 10; }));
      }

      array[offset(dimensions, subscripts)] = value;
    };

    this.toJSON = function toJSON() {
      return { type: type, dimensions: dimensions, array: array };
    };

    if (dims) {
      this.dim(dims);
    }
  }

  // Stream API, for parsing source and INPUT entry
  function Stream(string) {
    this.line = 0;
    this.column = 0;

    this.match = function match(re) {
      var m = string.match(re), lines;
      if (m) {
        string = string.substring(m[0].length);
        lines = m[0].split('\n');
        if (lines.length > 1) {
          this.line += lines.length - 1;
          this.column = lines[lines.length - 1].length;
        } else {
          this.column += m[0].length;
        }

        this.lastMatch = m;
        return m;
      }
      return (void 0);
    };

    this.eof = function eof() {
      return string.length === 0;
    };
  }

  // Used for DATA (compile-time) and INPUT (runtime)
  // Parses source string for optionally quoted, comma-
  // separated values and adds them to items. Returns
  // the substring consumed.
  var parseDataInput = (function() {

    var regexWhitespace = /^[ \t]+/,
        regexQuotedString = /^"([^"]*?)(?:"|(?=\n|\r|$))/,
        regexUnquotedString = /^[^:,\r\n]*/,
        regexComma = /^,/;

    return function parseDataInput(stream, items) {

      do {
        stream.match(regexWhitespace);

        if (stream.match(regexQuotedString)) {
          // quoted string
          items.push(stream.lastMatch[1]);
        } else if (stream.match(regexUnquotedString)) {
          // unquoted string
          items.push(stream.lastMatch[0]);
        }
      } while (stream.match(regexComma));
    };
  } ());


  basic.compile = function compile(source) {
    "use strict";

    function vartype(name) {
      var s = name.charAt(name.length - 1);
      return s === '$' ? 'string' : s === '%' ? 'int' : 'float';
    }

    //----------------------------------------------------------------------
    //
    // Runtime Environment (bound to compiled program)
    //
    //----------------------------------------------------------------------

    var env,        // Environment - passed in to program, contains tty, graphics, etc.
        state,      // Program state - initialized at runtime
        lib,        // Statement Library (closure over state and env)
        funlib,     // Function Library (closure over state and env)
        peek_table, // Native memory access shims (PEEK, POKE, CALL)
        poke_table,
        call_table;

    //
    // NOTE: tempting to make these part of env but some access/modify program state,
    // e.g. onerr
    //
    peek_table = {
      // Text window
      0x0020: function() { return env.tty.textWindow ? env.tty.textWindow.left : 0; },
      0x0021: function() { return env.tty.textWindow ? env.tty.textWindow.width : 80; },
      0x0022: function() { return env.tty.textWindow ? env.tty.textWindow.top : 0; },
      0x0023: function() { return env.tty.textWindow ? env.tty.textWindow.top + env.tty.textWindow.height : 24; },
      0x0024: function() { return env.tty.getCursorPosition().x; },
      0x0025: function() { return env.tty.getCursorPosition().y; },

      // Random number field
      0x004e: function() { return (Math.random() * 256) & 0xff; },
      0x004f: function() { return (Math.random() * 256) & 0xff; },

      // Last error code
      0x00de: function() { return state.onerr_code; },

      // Hires Plotting Page (32=1, 64=2, 96=3)
      0x00e6: function() { return env.display ? (env.display.hires_plotting_page === 2 ? 64 : 32) : 0; },

      // TODO: 0x3D0 = 0x4C if DOS is present.

      // Keyboard
      0xC000: function() { return env.tty.getKeyboardRegister ? env.tty.getKeyboardRegister() : 0; },
      0xC010: function() { return env.tty.clearKeyboardStrobe ? env.tty.clearKeyboardStrobe() : 0; },

      // Speaker toggle
      0xC030: function() { return 0; },

      // Buttons
      0xC060: function() { return env.tty.getButtonState ? env.tty.getButtonState(3) : 0; },
      0xC061: function() { return env.tty.getButtonState ? env.tty.getButtonState(0) : 0; },
      0xC062: function() { return env.tty.getButtonState ? env.tty.getButtonState(1) : 0; },
      0xC063: function() { return env.tty.getButtonState ? env.tty.getButtonState(2) : 0; },

      // Graphics State
      0xC01A: function() { return (env.display && !env.display.getState().graphics) * 128; },
      0xC01B: function() { return (env.display && !env.display.getState().full) * 128; },
      0xC01C: function() { return (env.display && !env.display.getState().page1) * 128; },
      0xC01D: function() { return (env.display && !env.display.getState().lores) * 128; },
      0xC01E: function() { return (env.tty.isAltCharset && env.tty.isAltCharset()) * 128; },
      0xC01F: function() { return (env.tty.isFirmwareActive && env.tty.isFirmwareActive()) * 128; }
    };

    poke_table = {
      // Text window
      0x0020: function(v) { if (env.tty.textWindow) { env.tty.textWindow.left = v; } },
      0x0021: function(v) { if (env.tty.textWindow) { env.tty.textWindow.width = v; } },
      0x0022: function(v) { if (env.tty.textWindow) {
        var bottom = env.tty.textWindow.top + env.tty.textWindow.height;
        env.tty.textWindow.top = v;
        env.tty.textWindow.height = bottom - env.tty.textWindow.top;
      } },
      0x0023: function(v) { if (env.tty.textWindow) { env.tty.textWindow.height = v - env.tty.textWindow.top; } },
      0x0024: function(v) { env.tty.setCursorPosition(v, void 0); },
      0x0025: function(v) { env.tty.setCursorPosition(void 0, v); },

      // ONERR flag
      0x00D8: function(v) { if (v < 0x80) { state.onerr_handler = (void 0); } },

      // Hires Plotting Page (32=1, 64=2, 96=3)
      0x00E6: function(v) { if (env.display) { env.display.hires_plotting_page = (v === 64 ? 2 : 1); } },

      // Keyboard strobe
      0xC010: function() { if (env.tty.clearKeyboardStrobe) { env.tty.clearKeyboardStrobe(); } },

      // Display switches
      0xC050: function() { if (env.display) { env.display.setState("graphics", true); } }, // Graphics
      0xC051: function() { if (env.display) { env.display.setState("graphics", false); } }, // Text
      0xC052: function() { if (env.display) { env.display.setState("full", true); } }, // Full Graphics
      0xC053: function() { if (env.display) { env.display.setState("full", false); } }, // Split Screen
      0xC054: function() { if (env.display) { env.display.setState("page1", true); } }, // Page 1
      0xC055: function() { if (env.display) { env.display.setState("page1", false); } }, // Page 2
      0xC056: function() { if (env.display) { env.display.setState("lores", true); } }, // Lo-Res
      0xC057: function() { if (env.display) { env.display.setState("lores", false); } }, // Hi-Res

      // Speaker toggle
      0xC030: function() { } // no-op
    };

    call_table = {
      0xD683: function() { // Clear stack
        state.stack = [];
      },
      0xF328: function() { // Pop error entry off stack
        var stack_record = state.stack.pop();
        if (!{}.hasOwnProperty.call(stack_record, 'resume_stmt_index')) {
          runtime_error(ERRORS.SYNTAX_ERROR);
          return;
        }
      },
      0xF3E4: function() { // Reveal hi-res page 1
        if (!env.hires) { runtime_error('Hires graphics not supported'); }
        env.display.setState('graphics', true, 'full', true, 'page1', true, 'lores', false);
      },
      0xF3F2: function() { // Clear hi-res screen to black
        var hires = env.display.hires_plotting_page === 2 ? env.hires2 : env.hires;
        if (!hires) { runtime_error('Hires graphics not supported'); }
        hires.clear();
      },
      0xF3F6: function() { // Clear hi-res screen to last color Hplotted
        var hires = env.display.hires_plotting_page === 2 ? env.hires2 : env.hires;
        if (!hires) { runtime_error('Hires graphics not supported'); }
        hires.clear(hires.color);
      },
      0xFBF4: function() { // Move cursor right
        if (env.tty.cursorRight) { env.tty.cursorRight(); }
      },
      0xFC10: function() { // Move cursor left
        if (env.tty.cursorLeft) { env.tty.cursorLeft(); }
      },
      0xFC1A: function() { // Move cursor up
        if (env.tty.cursorUp) { env.tty.cursorUp(); }
      },
      0xFC42: function() { // Clear text from cursor to bottom
        if (env.tty.clearEOS) { env.tty.clearEOS(); }
      },
      0xFC66: function() { // Move cursor down
        if (env.tty.cursorDown) { env.tty.cursorDown(); }
      },
      0xFC9C: function() { // Clear from cursor to right
        if (env.tty.clearEOL) { env.tty.clearEOL(); }
      },
      0xFD0C: function() { // Wait for key press
        throw new BlockingInput(env.tty.readChar, function(_){});
      },
      0xFE84: function() { // Normal
        if (env.tty.setTextStyle) { env.tty.setTextStyle(env.tty.TEXT_STYLE_NORMAL); }
      },
      0xFE80: function() { // Inverse
        if (env.tty.setTextStyle) { env.tty.setTextStyle(env.tty.TEXT_STYLE_INVERSE); }
      }
    };

    lib = {

      //////////////////////////////////////////////////////////////////////
      //
      // Variable Statements
      //
      //////////////////////////////////////////////////////////////////////

      'clear': function CLEAR() {
        state.clear();
      },

      'dim': function DIM(name, subscripts) {
        state.arrays[name].dim(subscripts);
      },

      'def': function DEF(name, func) {
        state.functions[name] = func;
      },

      //////////////////////////////////////////////////////////////////////
      //
      // Flow Control Statements
      //
      //////////////////////////////////////////////////////////////////////

      'goto': function GOTO(line) {
        throw new GoToLine(line);
      },

      'on_goto': function ON_GOTO(index /* , ...lines */) {
        index = Math.floor(index);
        if (index < 0 || index > 255) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }
        --index;
        var lines = Array.prototype.slice.call(arguments, 1);

        if (index >= 0 && index < lines.length) {
          throw new GoToLine(lines[index]);
        }
      },

      'gosub': function GOSUB(line) {
        state.stack.push({
          gosub_return: state.stmt_index,
          line_number: state.line_number
        });
        throw new GoToLine(line);
      },

      'on_gosub': function ON_GOSUB(index /* , ...lines */) {
        index = Math.floor(index);
        if (index < 0 || index > 255) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }
        --index;
        var lines = Array.prototype.slice.call(arguments, 1);
        if (index >= 0 && index < lines.length) {
          state.stack.push({
            gosub_return: state.stmt_index,
            line_number: state.line_number
          });
          throw new GoToLine(lines[index]);
        }
      },

      'return': function RETURN() {
        var stack_record;
        while (state.stack.length) {
          stack_record = state.stack.pop();
          if ({}.hasOwnProperty.call(stack_record, 'gosub_return')) {
            state.stmt_index = stack_record.gosub_return;
            state.line_number = stack_record.line_number;
            return;
          }
        }
        runtime_error(ERRORS.RETURN_WITHOUT_GOSUB);
      },

      'pop': function POP() {
        var stack_record = state.stack.pop();
        if (!{}.hasOwnProperty.call(stack_record, 'gosub_return')) {
          runtime_error(ERRORS.RETURN_WITHOUT_GOSUB);
          return;
        }
      },

      'for': function FOR(varname, to, step) {
        state.stack.push({
          index: varname,
          to: to,
          step: step,
          for_next: state.stmt_index,
          line_number: state.line_number
        });
      },

      'next': function NEXT(/* ...varnames */) {
        var varnames = Array.prototype.slice.call(arguments),
                    varname, stack_record, value;
        do {
          varname = varnames.shift();

          do {
            stack_record = state.stack.pop();
            if (!stack_record || !{}.hasOwnProperty.call(stack_record, 'for_next')) {
              runtime_error(ERRORS.NEXT_WITHOUT_FOR);
            }
          } while (varname !== (void 0) && stack_record.index !== varname);

          value = state.variables[stack_record.index];

          value = value + stack_record.step;
          state.variables[stack_record.index] = value;

          if (!(stack_record.step > 0 && value > stack_record.to) &&
                        !(stack_record.step < 0 && value < stack_record.to) &&
                        !(stack_record.step === 0 && value === stack_record.to)) {
            state.stack.push(stack_record);
            state.stmt_index = stack_record.for_next;
            state.line_number = stack_record.line_number;
            return;
          }
        } while (varnames.length);
      },

      'if': function IF(value) {
        if (!value) {
          throw new NextLine();
        }
      },

      'stop': function STOP() {
        runtime_error(ERRORS.INTERRUPT);
      },

      'end': function END() {
        throw new EndProgram();
      },

      //////////////////////////////////////////////////////////////////////
      //
      // Error Handling Statements
      //
      //////////////////////////////////////////////////////////////////////

      'onerr_goto': function ONERR_GOTO(line) {
        state.onerr_handler = line;
        throw new NextLine();
      },

      'resume': function RESUME() {
        var stack_record = state.stack.pop();
        if (!{}.hasOwnProperty.call(stack_record, 'resume_stmt_index')) {
          runtime_error(ERRORS.SYNTAX_ERROR);
          return;
        }
        state.line_number = stack_record.resume_line_number;
        state.stmt_index = stack_record.resume_stmt_index;
      },

      //////////////////////////////////////////////////////////////////////
      //
      // Inline Data Statements
      //
      //////////////////////////////////////////////////////////////////////

      'restore': function RESTORE() {
        state.data_index = 0;
      },

      // PERF: optimize by turning into a function, e.g. "state.parsevar(name, lib.read())"
      'read': function READ(/* ...lvalues */) {
        var lvalues = Array.prototype.slice.call(arguments);
        while (lvalues.length) {
          if (state.data_index >= state.data.length) {
            runtime_error(ERRORS.OUT_OF_DATA);
          }
          (lvalues.shift())(state.data[state.data_index]);
          state.data_index += 1;
        }
      },

      //////////////////////////////////////////////////////////////////////
      //
      // I/O Statements
      //
      //////////////////////////////////////////////////////////////////////

      'print': function PRINT(/* ...strings */) {
        var args = Array.prototype.slice.call(arguments), arg;
        while (args.length) {
          arg = args.shift();
          if (typeof arg === 'function') {
            arg = arg();
          }
          env.tty.writeString(String(arg));
        }
      },

      'comma': function COMMA() {
        return function() {
          var cur = env.tty.getCursorPosition().x,
                        pos = (cur + 16) - (cur % 16);
          if (pos >= env.tty.getScreenSize().width) {
            return '\r';
          } else {
            return ' '.repeat(pos - cur);
          }
        };
      },

      'spc': function SPC(n) {
        n = n >> 0;
        if (n < 0 || n > 255) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }
        return function() {
          return ' '.repeat(n);
        };
      },

      'tab': function TAB(n) {
        n = n >> 0;
        if (n < 0 || n > 255) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }
        if (n === 0) { n = 256; }

        return function() {
          var pos = env.tty.getCursorPosition().x + 1;
          return ' '.repeat(pos >= n ? 0 : n - pos);
        };
      },

      'get': function GET(lvalue) {
        throw new BlockingInput(env.tty.readChar, function(entry) { lvalue(entry); });
      },

      'input': function INPUT(prompt /* , ...varlist */) {
        var varlist = Array.prototype.slice.call(arguments, 1); // copy for closure
        var im = function(cb) { return env.tty.readLine(cb, prompt); };
        var ih = function(entry) {
          var parts = [],
              stream = new Stream(entry);

          parseDataInput(stream, parts);

          while (varlist.length && parts.length) {
            try {
              varlist.shift()(parts.shift());
            } catch (e) {
              if (e instanceof basic.RuntimeError &&
                  e.code === ERRORS.TYPE_MISMATCH[0]) {
                e.code = ERRORS.REENTER[0];
                e.message = ERRORS.REENTER[1];
              }
              throw e;
            }
          }

          if (varlist.length) {
            prompt = '??';
            throw new BlockingInput(im, ih);
          }

          if (parts.length) {
            env.tty.writeString('?EXTRA IGNORED\r');
          }
        };
        throw new BlockingInput(im, ih);
      },

      'home': function HOME() {
        if (env.tty.clearScreen) { env.tty.clearScreen(); }
      },

      'htab': function HTAB(pos) {
        if (pos < 1 || pos >= env.tty.getScreenSize().width + 1) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }

        if (env.tty.textWindow) {
          pos += env.tty.textWindow.left;
        }

        env.tty.setCursorPosition(pos - 1, void 0);
      },

      'vtab': function VTAB(pos) {
        if (pos < 1 || pos >= env.tty.getScreenSize().height + 1) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }
        env.tty.setCursorPosition(void 0, pos - 1);
      },

      'inverse': function INVERSE() {
        if (env.tty.setTextStyle) { env.tty.setTextStyle(env.tty.TEXT_STYLE_INVERSE); }
      },
      'flash': function FLASH() {
        if (env.tty.setTextStyle) { env.tty.setTextStyle(env.tty.TEXT_STYLE_FLASH); }
      },
      'normal': function NORMAL() {
        if (env.tty.setTextStyle) { env.tty.setTextStyle(env.tty.TEXT_STYLE_NORMAL); }
      },
      'text': function TEXT() {
        if (env.display) {
          env.display.setState("graphics", false);
        }

        if (env.tty.textWindow) {
          // Reset text window
          env.tty.textWindow = {
            left: 0,
            top: 0,
            width: env.tty.getScreenSize().width,
            height: env.tty.getScreenSize().height
          };
        }
        env.tty.setCursorPosition(0, env.tty.getScreenSize().height - 1);
      },

      //////////////////////////////////////////////////////////////////////
      //
      // Miscellaneous Statements
      //
      //////////////////////////////////////////////////////////////////////

      'notrace': function NOTRACE() {
        state.trace_mode = false;
      },
      'trace': function TRACE() {
        state.trace_mode = true;
      },

      //////////////////////////////////////////////////////////////////////
      //
      // Lores Graphics
      //
      //////////////////////////////////////////////////////////////////////

      'gr': function GR() {
        if (!env.lores) { runtime_error('Lores graphics not supported'); }
        env.display.setState("lores", true, "full", false, "graphics", true);
        env.lores.clear();

        if (env.tty.textWindow) {
          env.tty.textWindow.left = 0;
          env.tty.textWindow.width = env.tty.getScreenSize().width;
          env.tty.textWindow.top = env.tty.getScreenSize().height - 4;
          env.tty.textWindow.height = 4;
        }

        env.tty.setCursorPosition(0, env.tty.getScreenSize().height);
      },

      'color': function COLOR(n) {
        if (!env.lores) { runtime_error('Lores graphics not supported'); }

        n = n >> 0;
        if (n < 0 || n > 255) { runtime_error(ERRORS.ILLEGAL_QUANTITY); }

        env.lores.setColor(n);
      },

      'plot': function PLOT(x, y) {
        if (!env.lores) { runtime_error('Lores graphics not supported'); }

        x = x >> 0;
        y = y >> 0;

        var size = env.lores.getScreenSize();
        if (x < 0 || y < 0 || x >= size.width || y >= size.height) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }

        env.lores.plot(x, y);
      },

      'hlin': function HLIN(x1, x2, y) {
        if (!env.lores) { runtime_error('Lores graphics not supported'); }

        x1 = x1 >> 0;
        x2 = x2 >> 0;
        y = y >> 0;

        var size = env.lores.getScreenSize();
        if (x1 < 0 || x2 < 0 || y < 0 ||
                    x1 >= size.width || x2 >= size.width || y >= size.height) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }

        env.lores.hlin(x1, x2, y);
      },

      'vlin': function VLIN(y1, y2, x) {
        if (!env.lores) { runtime_error('Lores graphics not supported'); }

        y1 = y1 >> 0;
        y2 = y2 >> 0;
        x = x >> 0;

        var size = env.lores.getScreenSize();
        if (x < 0 || y1 < 0 || y2 < 0 ||
                    x >= size.width || y1 >= size.height || y2 >= size.height) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }

        env.lores.vlin(y1, y2, x);
      },


      //////////////////////////////////////////////////////////////////////
      //
      // Hires Graphics
      //
      //////////////////////////////////////////////////////////////////////


      'hgr': function HGR() {
        if (!env.hires) { runtime_error('Hires graphics not supported'); }
        env.display.setState("lores", false, "full", false, "page1", true, "graphics", true);
        env.display.hires_plotting_page = 1;
        env.hires.clear();
      },

      'hgr2': function HGR2() {
        if (!env.hires) { runtime_error('Hires graphics not supported'); }
        env.display.setState("lores", false, "full", true, "page1", false, "graphics", true);
        env.display.hires_plotting_page = 2;
        env.hires2.clear();
      },

      'hcolor': function HCOLOR(n) {
        if (!env.hires) { runtime_error('Hires graphics not supported'); }
        n = n >> 0;
        if (n < 0 || n > 7) { runtime_error(ERRORS.ILLEGAL_QUANTITY); }
        env.hires.setColor(n);
        if (env.hires2) { env.hires2.setColor(n); }
      },

      'hplot': function HPLOT(/* ...coords */) {
        var hires = env.display.hires_plotting_page === 2 ? env.hires2 : env.hires;
        if (!hires) { runtime_error('Hires graphics not supported'); }

        var coords = Array.prototype.slice.call(arguments),
                    size = hires.getScreenSize(),
                    x, y;

        x = coords.shift() >> 0;
        y = coords.shift() >> 0;

        if (x < 0 || y < 0 || x >= size.width || y >= size.height) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }

        hires.plot(x, y);
        while (coords.length) {
          x = coords.shift() >> 0;
          y = coords.shift() >> 0;
          if (x < 0 || y < 0 || x >= size.width || y >= size.height) {
            runtime_error(ERRORS.ILLEGAL_QUANTITY);
          }
          hires.plot_to(x, y);
        }
      },

      'hplot_to': function HPLOT_TO(/* ...coords */) {
        var hires = env.display.hires_plotting_page === 2 ? env.hires2 : env.hires;
        if (!hires) { runtime_error('Hires graphics not supported'); }

        var coords = Array.prototype.slice.call(arguments),
            size = hires.getScreenSize(), x, y;

        while (coords.length) {
          x = coords.shift() >> 0;
          y = coords.shift() >> 0;

          if (x < 0 || y < 0 || x >= size.width || y >= size.height) {
            runtime_error(ERRORS.ILLEGAL_QUANTITY);
          }

          hires.plot_to(x, y);
        }
      },


      //////////////////////////////////////////////////////////////////////
      //
      // Compatibility shims
      //
      //////////////////////////////////////////////////////////////////////

      'pr#': function PR(slot) {
        if (slot === 0) {
          if (env.tty.setFirmwareActive) { env.tty.setFirmwareActive(false); }
        } else if (slot === 3) {
          if (env.tty.setFirmwareActive) { env.tty.setFirmwareActive(true); }
        }
      },

      'poke': function POKE(address, value) {
        address = address & 0xffff;

        value = value >> 0;
        if (value < 0 || value > 255) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }

        if (!({}.hasOwnProperty.call(poke_table, address))) {
          runtime_error("Unsupported POKE location: " + address);
        }

        poke_table[address](value);
      },

      'call': function CALL(address) {
        address = address & 0xffff;

        if (!({}.hasOwnProperty.call(call_table, address))) {
          runtime_error("Unsupported POKE location: " + address);
        }

        call_table[address]();
      },

      'speed': function SPEED(n) {
        n = n >> 0;
        if (n < 0 || n > 255) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }

        env.tty.speed = n;
      },

      //////////////////////////////////////////////////////////////////////
      //
      // Referenced by compiled functions
      //
      //////////////////////////////////////////////////////////////////////

      'div': function div(n, d) {
        var r = n / d;
        if (!isFinite(r)) { runtime_error(ERRORS.DIVISION_BY_ZERO); }
        return r;
      },

      'fn': function fn(name, arg) {
        if (!{}.hasOwnProperty.call(state.functions, name)) {
          runtime_error(ERRORS.UNDEFINED_FUNCTION);
        }
        return state.functions[name](arg);
      },

      'checkFinite': function checkFinite(n) {
        if (!isFinite(n)) { runtime_error(ERRORS.OVERFLOW); }
        return n;
      },

      'toint': function toint(n) {
        n = n >> 0;
        if (n > 0x7fff || n < -0x8000) { runtime_error(ERRORS.ILLEGAL_QUANTITY); }
        return n;
      }
    };

    // Apply a signature [return_type, arg0_type, arg1_type, ...] to a function
    function funcsign(func /*, return_type, ...arg_types */) {
      func.signature = Array.prototype.slice.call(arguments, 1);
      return func;
    }

    funlib = {};

      //////////////////////////////////////////////////////////////////////
      //
      // Functions
      //
      // name: [ impl, returntype, [arg0type [, arg1type [, ... ] ]
      //
      //////////////////////////////////////////////////////////////////////


      funlib[kws.ABS] = funcsign(Math.abs, 'number', 'number');
      funlib[kws.ASC] = funcsign(function(s) {
        if (s.length < 1) { runtime_error(ERRORS.ILLEGAL_QUANTITY); }
        return s.charCodeAt(0);
      }, 'number', 'string');
      funlib[kws.ATN] = funcsign(Math.atan, 'number', 'number');
      funlib[kws.CHR$] = funcsign(String.fromCharCode, 'string', 'number');
      funlib[kws.COS] = funcsign(Math.cos, 'number', 'number');
      funlib[kws.EXP] = funcsign(Math.exp, 'number', 'number');
      funlib[kws.INT] = funcsign(Math.floor, 'number', 'number');
      funlib[kws.LEN] = funcsign(function LEN(s) { return s.length; }, 'number', 'string');
      funlib[kws.LOG] = funcsign(Math.log, 'number', 'number');
      funlib[kws.SGN] = funcsign(function SGN(n) { return n > 0 ? 1 : n < 0 ? -1 : 0; }, 'number', 'number');
      funlib[kws.SIN] = funcsign(Math.sin, 'number', 'number');
      funlib[kws.SQR] = funcsign(Math.sqrt, 'number', 'number');
      funlib[kws.STR$] = funcsign(function STR$(n) { return n.toString(); }, 'string', 'number');
      funlib[kws.TAN] = funcsign(Math.tan, 'number', 'number');
      funlib[kws.VAL] = funcsign(function VAL(s) {
        var n = parseFloat(s);
        return isFinite(n) ? n : 0;
      }, 'number', 'string');

      funlib[kws.RND] = funcsign(function RND(n) {
        if (n > 0) {
          // Next in PRNG sequence
          return state.prng.next();
        } else if (n < 0) {
          // Re-seed. NOTE: Not predictable as in Applesoft
          state.prng.seed(n);
          return state.prng.next();
        }
        return state.prng.last;
      }, 'number', 'number');

      funlib[kws.LEFT$] = funcsign(function LEFT$(s, n) { return s.substring(0, n); }, 'string', 'string', 'number');
      funlib[kws.MID$] = funcsign(function MID$(s, n, n2) { return n2 === (void 0) ? s.substring(n - 1) : s.substring(n - 1, n + n2 - 1); }, 'string', 'string', 'number', 'number?');
      funlib[kws.RIGHT$] = funcsign(function RIGHT$(s, n) { return s.length < n ? s : s.substring(s.length - n); }, 'string', 'string', 'number');

      funlib[kws.POS] = funcsign(function POS(n) { return env.tty.getCursorPosition().x; }, 'number', 'number');
      funlib[kws.SCRN] = funcsign(function SCRN(x, y) {
        if (!env.lores) { runtime_error("Graphics not supported"); }
        x = x >> 0;
        y = y >> 0;
        var size = env.lores.getScreenSize();
        if (x < 0 || y < 0 || x >= size.width || y >= size.height) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }

        return env.lores.getPixel(x, y);
      }, 'number', 'number', 'number');
      funlib[kws.HSCRN] = funcsign(function HSCRN(x, y) {
        var hires = env.display.hires_plotting_page === 2 ? env.hires2 : env.hires;
        if (!hires) { runtime_error("Graphics not supported"); }

        x = x >> 0;
        y = y >> 0;
        var size = hires.getScreenSize();
        if (x < 0 || y < 0 || x >= size.width || y >= size.height) {
          runtime_error(ERRORS.ILLEGAL_QUANTITY);
        }

        return hires.getPixel(x, y);
      }, 'number', 'number', 'number');

      funlib[kws.PDL] = funcsign(function PDL(n) {
        if (env.paddle) {
          return (env.paddle(n) * 255) & 0xff;
        } else {
          return runtime_error('Paddles not attached');
        }
      }, 'number', 'number');
      funlib[kws.FRE] = funcsign(function FRE(n) {
        return JSON ? JSON.stringify([state.variables, state.arrays, state.functions]).length : 0;
      }, 'number', 'number');
      funlib[kws.PEEK] = funcsign(function PEEK(address) {
        address = address & 0xffff;
        if (!{}.hasOwnProperty.call(peek_table, address)) {
          runtime_error("Unsupported PEEK location: " + address);
        }
        return peek_table[address]();
      }, 'number', 'number');

      // Not supported
      funlib[kws.USR] = funcsign(function USR(n) { runtime_error("USR Function not supported"); }, 'number', 'number');


    //----------------------------------------------------------------------
    //
    // Parser / Compiler
    //
    //----------------------------------------------------------------------

    var program = (function() {

      var identifiers = {
        variables: {},
        arrays: {}
      };

      //////////////////////////////////////////////////////////////////////
      //
      // Lexical Analysis
      //
      //////////////////////////////////////////////////////////////////////

      var match, test, endOfStatement, endOfProgram,
          currLine = 0, currColumn = 0,
          currLineNumber = 0;

      function parse_error(msg) {
        return new basic.ParseError(msg + " in line " + currLineNumber,
                                    currLine, currColumn);
      }


      (function(source) {
        function munge(kw) {
          // Escape special characters
          function escape(c) { return (/[\[\]\\\^\$\.\|\?\*\+\(\)]/).test(c) ? '\\' + c : c; }
          // Allow linear whitespace between characters
          //return kw.split('').map(escape).join('[ \\t]*');

          // Allow linear whitespace in HCOLOR=, HIMEM:, CHR$, etc
          return kw.split(/(?=\W)/).map(escape).join('[ \\t]*');
        }

        var RESERVED_WORDS = [
          kws.ABS, kws.AND, kws.ASC, kws.ATN, kws.AT, kws.CALL,
          kws.CHR$, kws.CLEAR, kws.COLOR, kws.CONT, kws.COS,
          /*kws.DATA,*/ kws.DEF, kws.DEL, kws.DIM, kws.DRAW, kws.END,
          kws.EXP, kws.FLASH, kws.FN, kws.FOR, kws.FRE, kws.GET,
          kws.GOSUB, kws.GOTO, kws.GR, kws.HCOLOR, kws.HGR2, kws.HGR,
          kws.HIMEM, kws.HLIN, kws.HOME, kws.HPLOT, kws.HTAB, kws.IF,
          kws.IN, kws.INPUT, kws.INT, kws.INVERSE, kws.LEFT$, kws.LEN,
          kws.LET, kws.LIST, kws.LOAD, kws.LOG, kws.LOMEM, kws.MID$,
          kws.NEW, kws.NEXT, kws.NORMAL, kws.NOTRACE, kws.NOT,
          kws.ONERR, kws.ON, kws.OR, kws.PDL, kws.PEEK, kws.PLOT,
          kws.POKE, kws.POP, kws.POS, kws.PRINT, kws.PR, kws.READ,
          kws.RECALL, /*kws.REM,*/ kws.RESTORE, kws.RESUME,
          kws.RETURN, kws.RIGHT$, kws.RND, kws.ROT, kws.RUN, kws.SAVE,
          kws.SCALE, kws.SCRN, kws.SGN, kws.SHLOAD, kws.SIN, kws.SPC,
          kws.SPEED, kws.SQR, kws.STEP, kws.STOP, kws.STORE, kws.STR$,
          kws.TAB, kws.TAN, kws.TEXT, kws.THEN, kws.TO, kws.TRACE,
          kws.USR, kws.VAL, kws.VLIN, kws.VTAB, kws.WAIT, kws.XDRAW,
          kws.AMPERSAND, kws.QUESTION, kws.HSCRN
        ];
        // NOTE: keywords that are stems of other words need to go after (e.g. "NOTRACE", "NOT)
        RESERVED_WORDS.sort();
        RESERVED_WORDS.reverse();

        var regexReservedWords = new RegExp("^(" + RESERVED_WORDS.map(munge).join("|") + ")", "i"),
            regexIdentifier = /^([A-Za-z][A-Za-z0-9]?)[A-Za-z0-9]*(\$|%)?/,
            regexStringLiteral = /^"([^"]*?)(?:"|(?=\n|\r|$))/,
            regexNumberLiteral = /^[0-9]*\.?[0-9]+(?:[eE]\s*[\-+]?\s*[0-9]+)?/,
            regexHexLiteral = /^\$[0-9A-Fa-f]+/,
            regexOperator = /^[;=<>+\-*\/\^(),]/,

            regexLineNumber = /^[0-9]+/,
            regexSeparator = /^:/,

            regexRemark = new RegExp('^(' + munge(kws.REM) + '([^\r\n]*))', 'i'),
            regexData = new RegExp('^(' + munge(kws.DATA) + ')', 'i'),

            regexLinearWhitespace = /^[ \t]+/,
            regexNewline = /^\r?\n/;

        // Token types:
        //    lineNumber    - start of a new line
        //    separator     - separates statements on same line
        //    reserved      - reserved keyword (command, function, etc)
        //    identifier    - variable name
        //    string        - string literal
        //    number        - number literal
        //    operator      - operator
        //    remark        - REM blah
        //    data          - DATA blah,"blah",blah

        var start = true,
            stream = new Stream(source);

        function nextToken() {
          var token = {}, newline = start, ws;
          start = false;

          currLine = stream.line + 1;
          currColumn = stream.column + 1;

          // Consume whitespace
          do {
            ws = false;
            if (stream.match(regexLinearWhitespace)) {
              ws = true;
            } else if (stream.match(regexNewline)) {
              ws = true;
              newline = true;
            }
          } while (ws);

          if (stream.eof()) {
            return (void 0);
          }

          if (newline) {
            if (stream.match(regexLineNumber)) {
              token.lineNumber = Number(stream.lastMatch[0]);
            } else if (stream.match(regexSeparator)) {
              // Extension - allow leading : to continue previous line
              token.separator = stream.lastMatch[0];
            } else {
              throw parse_error("Syntax error: Expected line number or separator");
            }
          } else if (stream.match(regexRemark)) {
            token.remark = stream.lastMatch[2];
          } else if (stream.match(regexData)) {
            token.data = [];
            parseDataInput(stream, token.data);
          } else if (stream.match(regexReservedWords)) {
            token.reserved = stream.lastMatch[1].toUpperCase().replace(/\s+/g, '');
            if (token.reserved === kws.QUESTION) { token.reserved = kws.PRINT; } // HACK
          } else if (stream.match(regexIdentifier)) {
            token.identifier = stream.lastMatch[1].toUpperCase() + (stream.lastMatch[2] || ''); // Canonicalize identifier name
          } else if (stream.match(regexStringLiteral)) {
            token.string = stream.lastMatch[1];
          } else if (stream.match(regexNumberLiteral)) {
            token.number = parseFloat(stream.lastMatch[0].replace(/\s+/g, ''));
          } else if (stream.match(regexHexLiteral)) {
            token.number = parseInt(stream.lastMatch[0].substring(1), 16);
          } else if (stream.match(regexOperator)) {
            token.operator = stream.lastMatch[0].replace(/\s+/g, '');
          } else if (stream.match(regexSeparator)) {
            token.separator = stream.lastMatch[0];
          } else {
            throw parse_error("Syntax error: Unexpected '" + source.substr(0, 40) + "'");
          }
          return token;
        }

        var lookahead = nextToken();

        match = function match(type, value) {

          if (!lookahead) {
            throw parse_error("Syntax error: Expected " + type + ", saw end of file");
          }

          var token = lookahead;
          if ('lineNumber' in token) {
            currLineNumber = token.lineNumber;
          }
          lookahead = nextToken();

          if (!{}.hasOwnProperty.call(token, type)) {
            throw parse_error("Syntax error: Expected " + type + ", saw " + JSON.stringify(token));
          }

          if (value !== (void 0) && token[type] !== value) {
            throw parse_error("Syntax error: Expected '" + value + "', saw " + JSON.stringify(token));
          }

          return token[type];
        };

        test = function test(type, value, consume) {
          if (lookahead && {}.hasOwnProperty.call(lookahead, type) &&
                        (value === (void 0) || lookahead[type] === value)) {

            if (consume) {
              var token = lookahead;
              if ('lineNumber' in token) {
                currLineNumber = token.lineNumber;
              }
              lookahead = nextToken();
            }

            return true;
          }

          return false;
        };

        endOfStatement = function endOfStatement() {
          return !lookahead ||
                        {}.hasOwnProperty.call(lookahead, 'separator') ||
                        {}.hasOwnProperty.call(lookahead, 'lineNumber');
        };

        endOfProgram = function endOfProgram() {
          return !lookahead;
        };

      } (source));


      //////////////////////////////////////////////////////////////////////
      //
      // Compiler utility functions
      //
      //////////////////////////////////////////////////////////////////////

      function quote(string) {
        return JSON.stringify(string);
      }

      //////////////////////////////////////////////////////////////////////
      //
      // Recursive Descent Parser
      //
      //////////////////////////////////////////////////////////////////////

      var parseExpression, parseSubscripts;

      //
      // Type Checking
      //

      function parseAnyExpression() {
        var expr = parseExpression();
        return expr.source;
      }

      function enforce_type(actual, expected) {
        if (actual !== expected) {
          throw parse_error('Type mismatch error: Expected ' + expected);
        }
      }

      function parseStringExpression() {
        var expr = parseExpression();
        enforce_type(expr.type, 'string');
        return expr.source;
      }

      function parseNumericExpression() {
        var expr = parseExpression();
        enforce_type(expr.type, 'number');
        return expr.source;
      }

      //
      // Variables
      //

      parseSubscripts = function() {
        var subscripts; // undefined = no subscripts

        if (test('operator', '(', true)) {

          subscripts = [];

          do {
            subscripts.push(parseNumericExpression());
          } while (test('operator', ',', true));

          match("operator", ")");

          return subscripts.join(',');
        }
        return (void 0);
      };

      function parsePValue() {
        var name = match('identifier'),
            subscripts = parseSubscripts();

        if (subscripts) {
          identifiers.arrays[name] = true;
          return '(function (value){state.parsevar(' +
                        quote(name) + ',[' + subscripts + '],value);})';
        } else {
          identifiers.variables[name] = true;
          return '(function (value){state.parsevar(' +
                        quote(name) + ',value);})';
        }
      }


      //
      // Expressions
      //

      parseExpression = (function() {
        // closure to keep things tidy

        function parseUserfunction() {
          var name = match('identifier'),
              type = vartype(name) === 'string' ? 'string' : 'number',
              expr;

          // FUTURE: Allow differing argument type and return type
          // (may require runtime type checks)

          // Determine the function argument
          match("operator", "(");
          expr = type === 'string' ? parseStringExpression() : parseNumericExpression();
          match("operator", ")");

          return { source: 'lib.fn(' + quote(name) + ',' + expr + ')', type: type };
        }


        function parsefunction(name) {
          if (!{}.hasOwnProperty.call(funlib, name)) {
            throw parse_error("Undefined function: " + name);
          }

          match("operator", "(");

          var func = funlib[name],
              funcdesc = func.signature.slice(),
              rtype = funcdesc.shift(),
              args = [],
              atype;

          while (funcdesc.length) {
            atype = funcdesc.shift();

            if (/\?$/.test(atype)) {
              if (test('operator', ')')) {
                break;
              } else {
                atype = atype.substring(0, atype.length - 1);
              }
            }
            if (args.length) {
              match("operator", ",");
            }

            if (atype === 'string') {
              args.push(parseStringExpression());
            } else if (atype === 'number') {
              args.push(parseNumericExpression());
            } else {
              throw new Error("Invalid function definition");
            }
          }

          match("operator", ")");

          return { source: 'funlib.' + name + '(' + args.join(',') + ')', type: rtype };
        }

        function parseFinalExpression() {
          if (test('number')) {
            return { source: String(match('number')), type: 'number' };
          } else if (test('string')) {
            return { source: quote(match('string')), type: 'string' };
          } else if (test('reserved', kws.FN, true)) {
            return parseUserfunction();
          } else if (test('reserved')) {
            return parsefunction(match('reserved'));
          } else if (test('identifier')) {
            var name = match('identifier'),
                type = vartype(name) === 'string' ? 'string' : 'number',
                subscripts = parseSubscripts();
            if (subscripts) {
              identifiers.arrays[name] = true;
              return { source: 'state.arrays[' + quote(name) + '].get([' + subscripts + '])', type: type };
            } else {
              identifiers.variables[name] = true;
              return { source: 'state.variables[' + quote(name) + ']', type: type };
            }
          } else {
            match("operator", "(");
            var expr = parseExpression();
            match("operator", ")");
            return expr;
          }
        }

        function parseUnaryExpression() {
          var rhs, op;

          if (test('operator', '+') || test('operator', '-')) {
            op = match('operator');
          } else if (test('reserved', kws.NOT)) {
            op = match('reserved');
          }

          if (op) {
            rhs = parseUnaryExpression();

            enforce_type(rhs.type, 'number');

            switch (op) {
              case "+": return rhs;
              case "-": return { source: '(-' + rhs.source + ')', type: 'number' };
              case kws.NOT: return { source: '((!' + rhs.source + ')?1:0)', type: 'number' };
            }
          }
          return parseFinalExpression();
        }

        function parsePowerExpression() {
          var lhs = parseUnaryExpression(), rhs;
          while (test('operator', '^', true)) {
            rhs = parseUnaryExpression();

            enforce_type(lhs.type, 'number');
            enforce_type(rhs.type, 'number');

            lhs = { source: 'Math.pow(' + lhs.source + ',' + rhs.source + ')', type: 'number' };
          }
          return lhs;
        }

        function parseMultiplicativeExpression() {
          var lhs = parsePowerExpression(), rhs, op;
          while (test('operator', '*') || test('operator', '/')) {
            op = match('operator');
            rhs = parsePowerExpression();

            enforce_type(lhs.type, 'number');
            enforce_type(rhs.type, 'number');

            switch (op) {
              case "*": lhs = { source: '(' + lhs.source + '*' + rhs.source + ')', type: 'number' }; break;
              case "/": lhs = { source: 'lib.div(' + lhs.source + ',' + rhs.source + ')', type: 'number' }; break;
            }
          }
          return lhs;
        }

        function parseAdditiveExpression() {
          var lhs = parseMultiplicativeExpression(), rhs, op;
          while (test('operator', '+') || test('operator', '-')) {
            op = match('operator');
            rhs = parseMultiplicativeExpression();

            switch (op) {
              case "+":
                enforce_type(rhs.type, lhs.type);
                lhs = { source: '(' + lhs.source + '+' + rhs.source + ')', type: lhs.type }; break;
              case "-":
                enforce_type(lhs.type, 'number');
                enforce_type(rhs.type, 'number');
                lhs = { source: '(' + lhs.source + '-' + rhs.source + ')', type: lhs.type }; break;
            }
          }
          return lhs;
        }

        function parseRelationalExpression() {
          var lhs = parseAdditiveExpression(), rhs, op;
          while (test('operator', '<') || test('operator', '>') || test('operator', '=')) {

            op = match('operator');
            switch (op) {
            case '<':
              if (test('operator', '=', true)) { op = '<='; break; }
              if (test('operator', '>', true)) { op = '!=='; break; }
              break;
            case '>':
              if (test('operator', '=', true)) { op = '>='; break; }
              if (test('operator', '<', true)) { op = '!=='; break; }
              break;
            case '=':
              if (test('operator', '<', true)) { op = '<='; break; }
              if (test('operator', '>', true)) { op = '>='; break; }
              if (test('operator', '=', true)) { op = '==='; break; }
              op = '===';
            }

            rhs = parseAdditiveExpression();

            enforce_type(rhs.type, lhs.type);
            lhs = lhs = { source: '((' + lhs.source + op + rhs.source + ')?1:0)', type: 'number' };
          }
          return lhs;
        }

        function parseAndExpression() {
          var lhs = parseRelationalExpression(), rhs;
          while (test('reserved', kws.AND, true)) {
            rhs = parseRelationalExpression();

            enforce_type(lhs.type, 'number');
            enforce_type(rhs.type, 'number');

            lhs = {
              source: '((' + lhs.source + '&&' + rhs.source + ')?1:0)',
              type: 'number'
            };
          }
          return lhs;
        }

        function parseOrExpression() {
          var lhs = parseAndExpression(), rhs;
          while (test('reserved', kws.OR, true)) {
            rhs = parseAndExpression();

            enforce_type(lhs.type, 'number');
            enforce_type(rhs.type, 'number');

            lhs = {
              source: '((' + lhs.source + '||' + rhs.source + ')?1:0)',
              type: 'number'
            };
          }
          return lhs;
        }

        return parseOrExpression;
      } ());


      //
      // Statements
      //

      function parseCommand() {

        function slib(name /* , ...args */) {
          var args = Array.prototype.slice.call(arguments, 1);
          return 'lib[' + quote(name) + '](' + args.join(',') + ');';
        }

        var keyword = test('identifier') ? kws.LET : match('reserved'),
            name, type, subscripts, is_to, expr, param, args, prompt, trailing, js;

        switch (keyword) {
          //////////////////////////////////////////////////////////////////////
          //
          // Variable Statements
          //
          //////////////////////////////////////////////////////////////////////

          case kws.CLEAR: // Clear all variables
            return slib('clear');

          case kws.LET:  // Assign a variable, LET x = expr
            name = match('identifier');
            subscripts = parseSubscripts();
            match('operator', '=');

            type = vartype(name);
            if (type === 'int') {
              expr = 'lib.toint(lib.checkFinite(' + parseNumericExpression() + '))';
            } else if (type === 'float') {
              expr = 'lib.checkFinite(' + parseNumericExpression() + ')';
            } else { // type === 'string')
              expr = parseStringExpression();
            }

            if (!subscripts) {
              identifiers.variables[name] = true;
              return 'state.variables[' + quote(name) + '] = ' + expr;
            }
            identifiers.arrays[name] = true;
            return 'state.arrays[' + quote(name) + '].set([' + subscripts + '], ' + expr + ')';

          case kws.DIM:
            js = '';
            do {
              name = match('identifier');
              subscripts = parseSubscripts();
              identifiers.arrays[name] = true;
              js += slib('dim', quote(name), '[' + subscripts + ']');
            } while (test('operator', ',', true));
            return js;

          case kws.DEF:     // DEF FN A(X) = expr
            match("reserved", kws.FN);
            name = match('identifier');
            match("operator", "(");
            param = match('identifier');
            match("operator", ")");
            match("operator", "=");

            if (vartype(name) !== vartype(param)) {
              throw parse_error("DEF FN function type and argument type must match");
            }

            expr = vartype(name) === 'string' ?
              parseStringExpression() : parseNumericExpression();

            return slib('def', quote(name),
                            'function (arg){' +
            // Save the current context/variable so we can evaluate
                            'var rv,ov=state.variables[' + quote(param) + '];' +
            // Swap in the argument
                            'state.variables[' + quote(param) + ']=arg;' +
            // Evaluate the user-function expression
                            'rv=' + expr + ';' +
            // Restore
                            'state.variables[' + quote(param) + ']=ov;' +
                            'return rv;' +
                            '}');

            //////////////////////////////////////////////////////////////////////
            //
            // Flow Control Statements
            //
            //////////////////////////////////////////////////////////////////////

          case kws.GOTO: // GOTO linenum
            return slib('goto', match("number"));

          case kws.ON:  // ON expr (GOTO|GOSUB) linenum[,linenum ... ]
            expr = parseNumericExpression();

            keyword = match('reserved');
            if (keyword !== kws.GOTO && keyword !== kws.GOSUB) {
              throw parse_error("Syntax error: Expected " + kws.GOTO + " or " + kws.GOSUB);
            }

            args = [];
            do {
              args.push(match("number"));
            } while (test("operator", ",", true));

            return slib(keyword === kws.GOSUB ? 'on_gosub' : 'on_goto', expr, args.join(','));

          case kws.GOSUB: // GOSUB linenum
            return slib('gosub', match("number"));

          case kws.RETURN: // Return from the last GOSUB
            return slib('return');

          case kws.POP: // Turn last GOSUB into a GOTO
            return slib('pop');

          case kws.FOR: // FOR i = m TO n STEP s
            name = match('identifier');
            if (vartype(name) !== 'float') {
              throw parse_error("Syntax error: Expected floating point variable");
            }
            identifiers.variables[name] = true;
            return 'state.variables[' + quote(name) + '] = ' +
                  (match("operator", "=") && parseNumericExpression()) + ';' +
                  slib('for', quote(name),
                   match("reserved", kws.TO) && parseNumericExpression(),
                   test('reserved', kws.STEP, true) ? parseNumericExpression() : '1');

          case kws.NEXT: // NEXT [i [,j ... ] ]
            args = [];
            if (test('identifier')) {
              args.push(quote(match('identifier')));
              while (test("operator", ",", true)) {
                args.push(quote(match('identifier')));
              }
            }

            return slib('next', args.join(','));

          case kws.IF:  // IF expr (GOTO linenum|THEN linenum|THEN statement [:statement ... ]
            expr = parseAnyExpression();

            js = slib('if', expr);

            if (test('reserved', kws.GOTO, true)) {
              // IF expr GOTO linenum
              return js + slib('goto', match('number'));
            }

            match('reserved', kws.THEN);
            if (test('number')) {
              // IF expr THEN linenum
              return js + slib('goto', match('number'));
            }
            // IF expr THEN statement
            return js + parseCommand(); // recurse

          case kws.END:  // End program
            return slib('end');

          case kws.STOP: // Break, like an error
            return slib('stop');

            //////////////////////////////////////////////////////////////////////
            //
            // Error Handling Statements
            //
            //////////////////////////////////////////////////////////////////////

          case kws.ONERR: // ONERR GOTO linenum
            return slib('onerr_goto',
                            match("reserved", kws.GOTO) && match("number"));

          case kws.RESUME:
            return slib('resume');

            //////////////////////////////////////////////////////////////////////
            //
            // Inline Data Statements
            //
            //////////////////////////////////////////////////////////////////////

          case kws.RESTORE:
            return slib('restore');

          case kws.READ:
            args = [];
            do {
              args.push(parsePValue());
            } while (test("operator", ",", true));

            return slib('read', args.join(','));

            //////////////////////////////////////////////////////////////////////
            //
            // I/O Statements
            //
            //////////////////////////////////////////////////////////////////////

          case kws.PRINT: // Output to the screen
            args = [];
            trailing = true;
            while (!endOfStatement()) {
              if (test('operator', ';', true)) {
                trailing = false;
              } else if (test('operator', ',', true)) {
                trailing = false;
                args.push('lib.comma()');
              } else if (test('reserved', kws.SPC) || test('reserved', kws.TAB)) {
                trailing = false;
                keyword = match('reserved');
                match("operator", "(");
                expr = parseNumericExpression();
                match("operator", ")");

                args.push('lib.' + (keyword === kws.SPC ? 'spc' : 'tab') + '(' + expr + ')');
              } else {
                trailing = true;
                args.push(parseAnyExpression());
              }
            }
            if (trailing) {
              args.push(quote('\r'));
            }

            return slib('print', args.join(','));

          case kws.INPUT: // Read input from keyboard
            prompt = '?';
            if (test('string')) {
              prompt = match('string');
              match("operator", ";");
            }

            args = [];

            do {
              args.push(parsePValue());
            } while (test("operator", ",", true));

            return slib('input', quote(prompt), args.join(','));

          case kws.GET: // Read character from keyboard
            return slib('get', parsePValue());

          case kws.HOME:  // Clear text screen
            return slib('home');

          case kws.HTAB:  // Set horizontal cursor position
            return slib('htab', parseNumericExpression());

          case kws.VTAB:  // Set vertical cursor position
            return slib('vtab', parseNumericExpression());

          case kws.INVERSE:  // Inverse text
            return slib('inverse');

          case kws.FLASH:  // Flashing text
            return slib('flash');

          case kws.NORMAL:  // Normal text
            return slib('normal');

          case kws.TEXT:  // Set display mode to text
            return slib('text');

            //////////////////////////////////////////////////////////////////////
            //
            // Miscellaneous Statements
            //
            //////////////////////////////////////////////////////////////////////

          case kws.NOTRACE:  // Turn off line tracing
            return slib('notrace');

          case kws.TRACE:  // Turn on line tracing
            return slib('trace');

            //////////////////////////////////////////////////////////////////////
            //
            // Lores Graphics
            //
            //////////////////////////////////////////////////////////////////////

          case kws.GR:   // Set display mode to lores graphics, clear screen
            return slib('gr');

          case kws.COLOR:  // Set lores color
            return slib('color', parseNumericExpression());

          case kws.PLOT:  // Plot lores point
            return slib('plot',
                            parseNumericExpression(),
                            match("operator", ",") && parseNumericExpression());

          case kws.HLIN:  // Draw lores horizontal line
            return slib('hlin',
                            parseNumericExpression(),
                            match("operator", ",") && parseNumericExpression(),
                            match("reserved", kws.AT) && parseNumericExpression());

          case kws.VLIN:  // Draw lores vertical line
            return slib('vlin',
                            parseNumericExpression(),
                            match("operator", ",") && parseNumericExpression(),
                            match("reserved", kws.AT) && parseNumericExpression());

            //////////////////////////////////////////////////////////////////////
            //
            // Hires Graphics
            //
            //////////////////////////////////////////////////////////////////////

            // Hires Display Routines
          case kws.HGR:   // Set display mode to hires graphics, clear screen
            return slib('hgr');

          case kws.HGR2:  // Set display mode to hires graphics, page 2, clear screen
            return slib('hgr2');

          case kws.HCOLOR:  // Set hires color
            return slib('hcolor', parseNumericExpression());

          case kws.HPLOT:  // Draw hires line
            is_to = test('reserved', kws.TO, true);

            args = [];
            do {
              args.push(parseNumericExpression());
              match("operator", ",");
              args.push(parseNumericExpression());
            } while (test('reserved', kws.TO, true));

            return slib(is_to ? 'hplot_to' : 'hplot', args.join(','));

            //////////////////////////////////////////////////////////////////////
            //
            // Compatibility shims
            //
            //////////////////////////////////////////////////////////////////////

          case kws.PR:   // Direct output to slot
            return slib('pr#', parseNumericExpression());

          case kws.CALL:  // Call native routine
            return slib('call', parseNumericExpression());

          case kws.POKE:  // Set memory value
            return slib('poke',
                            parseNumericExpression(),
                            match("operator", ",") && parseNumericExpression());

          case kws.SPEED:  // Output speed
            return slib('speed', parseNumericExpression());

            //////////////////////////////////////////////////////////////////////
            //
            // INTROSPECTION
            //
            //////////////////////////////////////////////////////////////////////

          case kws.LIST:  // List program statements
            throw parse_error("Introspection statement not supported: " + keyword);

            //////////////////////////////////////////////////////////////////////
            //
            // Statements that will never be implemented
            //
            //////////////////////////////////////////////////////////////////////

            // Shape tables
          case kws.ROT:   // Set rotation angle for hires shape
          case kws.SCALE: // Set rotation angle for hires shape
          case kws.DRAW:   // Draw hires shape
          case kws.XDRAW:  // XOR draw hires shape
            throw parse_error("Display statement not supported: " + keyword);

            // Interpreter Routines
          case kws.CONT:  // Continue stopped program (immediate mode)
          case kws.DEL:   // Deletes program statements
          case kws.NEW:   // Wipe program
          case kws.RUN:   // Execute program
            throw parse_error("Interpreter statement not supported: " + keyword);

            // Native Routines
          case kws.HIMEM:  // Set upper bound of variable memory
          case kws.IN:     // Direct input from slot
          case kws.LOMEM:  // Set low bound of variable memory
          case kws.WAIT:    // Wait for memory value to match a condition
          case kws.AMPERSAND:       // Command hook
            throw parse_error("Native interop statement not supported: " + keyword);

            // Tape Routines
          case kws.LOAD:    // Load program from cassette port
          case kws.RECALL:  // Load array from cassette port
          case kws.SAVE:    // Save program to cassette port
          case kws.STORE:   // Store array to cassette port
          case kws.SHLOAD:  // Load shape table from cassette port
            throw parse_error("Tape statement not supported: " + keyword);

            //////////////////////////////////////////////////////////////////////
            //
            // NYI Statements
            //
            //////////////////////////////////////////////////////////////////////

            // Parts of other statements - AT, FN, STEP, TO, THEN, etc.
          default:
            throw parse_error("Syntax error: " + keyword);
        }
      }

      //
      // Top-level Program Structure
      //

      var parseProgram = function() {

        var program = {
          statements: [], // array of: [ line-number | statement-function ]
          data: [],       // array of [ string | number ]
          jump: []        // map of: { line-number: statement-index }
        };

        function mkfun(js) {
          var fun; // NOTE: for IE; would prefer Function()
          eval('fun = (function (){' + js + '});');
          return fun;
        }

        function empty_statement() { }

        // Statement = data-declaration | remark | Command | EmptyStatement
        // Command   = identifier /*...*/ | reserved /*...*/
        function parseStatement() {
          if (test('data')) {
            program.data = program.data.concat(match('data'));
            return undefined;
          } else if (test('remark', void 0, true)) {
            return undefined;
          } else if (test('reserved') || test('identifier')) {
            return mkfun(parseCommand());
          } else {
            // So TRACE output is correct
            return empty_statement;
          }
        }

        // Line = line-number Statement { separator Statement }
        function parseLine() {
          var num = match('lineNumber');
          var statements = [];
          var statement = parseStatement();
          if (statement) statements.push(statement);
          while (test('separator', ':', true)) {
            statement = parseStatement();
            if (statement) statements.push(statement);
          }
          insertLine(num, statements);
        }

        function insertLine(number, statements) {
          var remove = 0;
          for (var i = 0, len = program.statements.length; i < len; ++i) {
            if (typeof program.statements[i] !== 'number')
              continue;
            if (program.statements[i] < number)
              continue;
            if (program.statements[i] === number) {
              var n = i;
              do {
                ++n;
                ++remove;
              } while (n < len && typeof program.statements[n] !== 'number');
            }
            break;
          }
          var args = [i, remove, number].concat(statements);
          program.statements.splice.apply(program.statements, args);
        }

        // Program = Line { Line }
        while (!endOfProgram()) {
          parseLine();
        }

        // Produce jump table
        program.statements.forEach(function(stmt, index) {
          if (typeof stmt === 'number') {
            program.jump[stmt] = index;
          }
        });

        program.variable_identifiers = Object.keys(identifiers.variables);
        program.array_identifiers = Object.keys(identifiers.arrays);

        return program;
      };

      return parseProgram();
    } ());

    program.init = function init(environment) {

      // stuff these into runtime library closure/binding
      env = environment;
      state = {
        variables: {},
        arrays: {},
        functions: {},
        data: this.data,
        data_index: 0,
        stmt_index: 0,
        line_number: 0,
        stack: [],
        prng: new PRNG(),

        onerr_code: 255,
        onerr_handler: void 0,
        trace_mode: false,

        input_continuation: null,

        clear: function() {
          program.variable_identifiers.forEach(function(identifier) {
            state.variables[identifier] = vartype(identifier) === 'string' ? '' : 0;
          });

          program.array_identifiers.forEach(function(identifier) {
            state.arrays[identifier] = new BASICArray(vartype(identifier));
          });

          state.functions = {};
          state.data_index = 0;
        }
      };

      state.clear();

      state.parsevar = function parsevar(name, subscripts, input) {

        if (arguments.length === 2) {
          input = arguments[1];
          subscripts = void 0;
        }
        var value;

        switch (vartype(name)) {
          case 'string':
            value = input;
            break;

          case 'int':
            value = Number(input);
            if (!isFinite(value)) { runtime_error(ERRORS.TYPE_MISMATCH); }
            value = lib.toint(value);
            break;

          case 'float':
            value = Number(input);
            if (!isFinite(value)) { runtime_error(ERRORS.TYPE_MISMATCH); }
            break;
        }

        if (subscripts) {
          state.arrays[name].set(subscripts, value);
        } else {
          state.variables[name] = value;
        }
      };
    };

    program.step = function step(driver) {

      function gotoline(line) {
        if (!{}.hasOwnProperty.call(program.jump, line)) {
          runtime_error(ERRORS.UNDEFINED_STATEMENT);
        }
        state.stmt_index = program.jump[line];
      }

      var stmt;

      try {
        // for RuntimeError

        try {
          if (state.input_continuation) {
            var cont = state.input_continuation;
            state.input_continuation = null;
            cont(state.input_buffer);
          } else if (state.stmt_index >= program.statements.length) {
            return basic.STATE_STOPPED;
          } else {

            stmt = program.statements[state.stmt_index];

            if (typeof stmt === 'number') {
              state.line_number = stmt;
            } else if (typeof stmt === 'function') {
              if (state.trace_mode) {
                env.tty.writeString('#' + state.line_number + ' ');
              }
              stmt();
            } else {
              throw "WTF?";
            }
          }

          state.stmt_index += 1;
          return basic.STATE_RUNNING;

        } catch (e) {
          // These may throw RuntimeError
          if (e instanceof basic.RuntimeError) {
            throw e; // let outer catch block handle it
          } else if (e instanceof GoToLine) {
            gotoline(e.line);
            return basic.STATE_RUNNING;
          } else if (e instanceof NextLine) {
            while (state.stmt_index < program.statements.length &&
                            typeof program.statements[state.stmt_index] !== 'number') {
              state.stmt_index += 1;
            }
            return basic.STATE_RUNNING;
          } else if (e instanceof BlockingInput) {
            // what to call on next step() after input is handled
            state.input_continuation = e.callback;

            // call input method to prepare async input
            e.method(function(v) {
              state.input_buffer = v;
              if (driver) { driver(); }
            });

            return basic.STATE_BLOCKED;
          } else if (e instanceof EndProgram) {
            return basic.STATE_STOPPED;
          } else if (e instanceof Error && /stack|recursion/i.test(e.message)) {
            // IE: Error "Out of stack space"
            // Firefox: InternalError "too much recursion"
            // Safari: RangeError "Maximum call stack size exceeded"
            // Chrome: RangeError "Maximum call stack size exceeded"
            // Opera: Error "Maximum recursion depth exceeded"
            runtime_error(ERRORS.FORMULA_TOO_COMPLEX);
          } else if (e instanceof Error && /memory|overflow/i.test(e.message)) {
            // IE: Error "Out of memory"
            // Firefox: InternalError "allocation size overflow"
            // Safari: Error "Out of memory"
            // Chrome: (not catchable)
            // Opera: (not catchable)
            runtime_error(ERRORS.OUT_OF_MEMORY);
            // NOTE: not reliably generated; don't unit test
          } else {
            throw e;
          }
        }
      } catch (rte) {
        if (rte instanceof basic.RuntimeError) {
          state.onerr_code = rte.code || 0;
          if (state.onerr_handler !== void 0) {
            state.stack.push({
              resume_stmt_index: state.stmt_index,
              resume_line_number: state.line_number
            });
            gotoline(state.onerr_handler);
            return basic.STATE_RUNNING;
          } else if (rte.code === ERRORS.REENTER[0]) {
            env.tty.writeString('?REENTER\r');
            return basic.STATE_RUNNING;
          } else {
            // annotate and report to the user
            rte.message += " in line " + state.line_number;
            throw rte;
          }
        } else {
          throw rte;
        }
      }
    };

    return program;
  };

  return basic;

} ());

// TODO: Unit tests for compile errors