Add skeleton index.html interface file.
Flesh out html of interface.

Still not functional, though!
Add stylesheet.

Just basic pretty-fication, cobbled together
from other sources (e.g. Internet).
Add basic read/parse/display capability.

The parse and display functionality is just a couple
of stub functions.
Add default value to input text box.

Default value instructrs user where
to input commands.

Uses an HTML5 feature, so users without compliant
browsers just won't see the default.
Automatically put users cursor in input box upon loading.

This uses an HTML5 feature, so users without
compliant browsers will still have to click on the box.
Create a formatting function, to display results properly.
Merge branch 'interface' into master.

Finished preliminary work on a web-based user-interface.
FIX: Add missing semicolon to end of parseLine function.
Create namespace for parser.js file.

This consists of creating an object Parse
to which all of the file-local functions and variables
will be added.
Create token type in parser.js.
Set up skeleton of scanner function.

Just the private data and public functions,
but the actual logic of the constructor,
which does the actual scanning,
is just a piece of pseudocode right now.
Write pseudocode for scanning logic in Scanner ctor.
Implement main logic of Scanner.

Not implemented: error-reporting in the
event that a token begins with an unknown
character.

Also, there are a couple possible inefficiencies:
        * Most matching is done using the built-in
                regex functionality, which may be
                overkill and thus slow for the simple
                character matching needed here.
        * The token stream is stored as an array, and
                since pop/peak must return the tokens
                in the same order as they were seen,
                when adding a new token it must be
                added to the beginning, using the
                'unshift' array method. This, I think,
                is O(n). But, this way, the pop method
                used to get the tokens, should be constant
                time.
Add skeleton of Parse function.

Currently just has dummy functionality
(it just returns a string of the types
of the input tokens).
Add todo about sanitizing input.
Clarify explanation.

Correct variable naming rules, and mention
the use of parentheses.
FIX: Add forgotten 'equals' token to scanner.
FIX: Remove exponentiation operator (^).

Since the exponentiation won't be immediately implemented,
the reference to it in the explanation should be removed.
Add simple virtual machine.

In a new file, virtual-machine.js, a new
VirtualMachine type is defined.

It can execute simple assembly-like instructions:
        Load/Load-Immediate
        Store/Store-Immediate
        Add, Subtract, Multiply, and Divide

It has a bank of registers (unlimited in number),
and a block of memory.
Both of these things are represented as arrays.

Instructions can be given to the machine in the format
{opcode: <op>, reg: <reg>, mem: <mem>, ...}
where the exact configuration of registers and memory locations
varies according to the specific instruction.
An instruction with opcode: 'stop' will terminate the execution
of an array of instructions, at which point the run method
returns with the value of the 0-register.
The machine retains state (registers and memory, as well as
heap and stack pointers), after this termination, though.

Memory can be allocated using an allocate method.
It increments the heap pointer, and returns the location
of the allocated memory for later reference.

TODO:
        Implement stack operations (push/pop etc.)
        Implement logical tests for branching and looping
        Implement jumps for branching and function calling