What kind of abomination is this...

There's no tokenizer, no lexer, no parser, no AST. Everything is parsed with fragile pattern matches. The syntax is terrible, unconventional, and counterintuitive. Who in their right mind uses '>' for method calls?

@Schmolendevice (View Post)
compiler/interpreter how-to:

1. You have a string: local x = concat(123, "moo-456", x)
2. Iterate over the characters, grouping them semantically as your language requires, obtaining a token stream: [<keyword local> <identifier x> "=" <identifier concat> "(" <number 123> "," <string moo-456> "," <identifier x> ")"]
3. Do a most likely recursive and sometimes backtracking match of your language's rules over the token stream, obtaining an AST: (local assignment "x" (function call (global "concat") (number 123, string "moo-456", global "x")))

From here on you can do multiple things:
a. Interpret the AST. Apply execution semantics to the tree and simulate the variables, function calls, and other stuff.
b. Pretend that you're executing the AST, but mark the actions you're performing. With some polishing these actions translate directly to assembly.
c. Do the above, except translate everything to your own made up kind of assembly which you're later going to emulate. This lets us split execution semantics between the compiler part and the executor part in any way we wish. For example in lua, the VM operates on lua datatypes, inherits coercion semantics and metamethod invocation. However the VM doesn't know anything about variables. Compiler translates named variables like 'local x' into numbers on the stack, and globals like "print" into string-ey indexing into the globals table.