Add try/catch. Fix preprocessor ordering

* Fixed ordering of preprocessor replacements since haxe's Maps do not have a defined order and since there's no OrderedMap, used an array that points to map keys.
* Added try / catch. Transpiles to xpcall in lua.
* Reverted binary operator switch. We're gonna try and keep this backwards compatible I guess.
* All instructions will be prefixed with instr_ from now on to avoid syntax errors in both haxe and compiled C++.

Author: vurvdev

README.md

@@ -18,11 +18,6 @@ Normal is a type that came before ``number``, however nobody uses it and it just
 
 ### No inputs
 For obvious reasons, there's no io or entities in this as this is meant to be run in the browser, or simply on your pc.
-
-### Fixed bitwise operators
-E2 randomly swapped || and | / & and &&. && was made into bitwise and rather than logical and.  
-*It has been switched to match typical language spec.  *
-
 ### Optimized
 The language is optimized for speed. E2 was known to be very slow, and this is no longer the case through typing and other optimizations.  
 *Although, admittedly Haxe is nowhere near the best language for trying to get something to be fast.

script.e2

@@ -22,4 +22,10 @@ switch (Var) {
 	default,
 		print("this won't")
 	break
+}
+
+try {
+	error("Hello world")
+} catch(Err) {
+	print(Err)
 }

src/Base/Parser.hx

@@ -324,7 +324,7 @@ class Parser {
 
 	function acceptIfElseIf() {
 		if (this.acceptRoamingToken("keyword", "elseif"))
-			return this.instruction( this.getTokenTrace(), "_if", [this.acceptCondition(), this.acceptBlock("else if condition"), true, this.acceptIfElseIf()] );
+			return this.instruction( this.getTokenTrace(), "if", [this.acceptCondition(), this.acceptBlock("else if condition"), true, this.acceptIfElseIf()] );
 
 		return this.acceptIfElse();
 	}
@@ -523,7 +523,7 @@ class Parser {
 	function stmt1() {
 		if (this.acceptRoamingToken("keyword", "if")) {
 			var trace = this.getTokenTrace();
-			return this.instruction( trace, "_if", [this.acceptCondition(), this.acceptBlock("if condition"), false, this.acceptIfElseIf()] );
+			return this.instruction( trace, "if", [this.acceptCondition(), this.acceptBlock("if condition"), false, this.acceptIfElseIf()] );
 		}
 		return this.stmt2();
 	}
@@ -532,7 +532,7 @@ class Parser {
 		if (this.acceptRoamingToken("keyword", "while")) {
 			var trace = this.getTokenTrace();
 			this.depth++;
-			var whl = this.instruction( trace, "_while", [this.acceptCondition(), this.acceptBlock("while condition"), false] );
+			var whl = this.instruction( trace, "while", [this.acceptCondition(), this.acceptBlock("while condition"), false] );
 			this.depth--;
 			return whl;
 		}
@@ -570,7 +570,7 @@ class Parser {
 			if (!this.acceptRoamingToken("grammar", ")"))
 				this.error("Right parenthesis ()) missing, to close condition");
 
-			var sfor = this.instruction( trace, "_for", [v, estart, estop, estep, this.acceptBlock("for statement")] );
+			var sfor = this.instruction( trace, "for", [v, estart, estop, estep, this.acceptBlock("for statement")] );
 
 			this.depth--;
 			return sfor;
@@ -649,14 +649,14 @@ class Parser {
 		if (this.acceptRoamingToken("keyword", "break")) {
 			if (this.depth > 0) {
 				var trace = this.getTokenTrace();
-				return this.instruction(trace, "_break", []);
+				return this.instruction(trace, "break", []);
 			} else {
 				this.error("Break may not exist outside of a loop");
 			}
 		} else if (this.acceptRoamingToken("keyword", "continue")) {
 			if (this.depth > 0) {
 				var trace = this.getTokenTrace();
-				return this.instruction(trace, "_continue", []);
+				return this.instruction(trace, "continue", []);
 			} else {
 				this.error("Continue may not exist outside of a loop");
 			}
@@ -784,7 +784,7 @@ class Parser {
 			var cases = this.acceptSwitchBlock();
 			this.depth--;
 
-			return this.instruction(trace, "_switch", [expr, cases]);
+			return this.instruction(trace, "switch", [expr, cases]);
 		}
 
 		return stmt10();
@@ -882,14 +882,14 @@ class Parser {
 
 			// TODO: Make sure you can't overwrite existing functions with the signature.
 
-			return this.instruction( trace, "function_decl", [name, ret, type, sig, args, this.acceptBlock("function declaration")] );
+			return this.instruction( trace, "fndecl", [name, ret, type, sig, args, this.acceptBlock("function declaration")] );
 		} else if ( this.acceptRoamingToken("keyword", "return") ) {
 			var trace = this.getTokenTrace();
 
 			if ( this.acceptRoamingToken("type", "void") || (this.readtoken != null && this.readtoken.raw == "}" /* check if readtoken is rcb */ ) )
-				return this.instruction( trace, "_return", [] );
+				return this.instruction( trace, "return", [] );
 
-			return this.instruction( trace, "_return", [this.expr1()] );
+			return this.instruction( trace, "return", [this.expr1()] );
 		} else if ( this.acceptRoamingToken("type", "void") ) {
 			this.error("Void may only exist after return");
 		}
@@ -910,10 +910,42 @@ class Parser {
 
 			var condition = this.acceptCondition();
 
-			final instr = this.instruction( trace, "_while", [condition, block, true] );
+			final instr = this.instruction( trace, "while", [condition, block, true] );
 			this.depth--;
 			return instr;
 		}
+		return stmt12();
+	}
+
+	/**
+	 *	```
+	 *	try {
+	 *		error("hi")
+	 *	} catch(Err) {
+	 *		print(Err)
+	 *	}
+	**/
+	function stmt12(): Instruction {
+		if (this.acceptRoamingToken("keyword", "try")) {
+			var trace = this.getTokenTrace();
+			var stmt = this.acceptBlock("try block");
+
+			if (!this.acceptRoamingToken("keyword", "catch"))
+				this.error("Try block must be followed by catch statement");
+
+			if (!this.acceptRoamingToken("grammar", "("))
+				this.error("Left parenthesis (() expected after catch keyword");
+
+			if (!this.acceptRoamingToken("identifier"))
+				this.error("Variable expected after left parenthesis (() in catch statement");
+
+			var var_name = this.getTokenRaw();
+
+			if (!this.acceptRoamingToken("grammar", ")"))
+				this.error("Right parenthesis ()) missing, to close catch statement");
+
+			return this.instruction(trace, "try", [stmt, var_name, this.acceptBlock("catch block")] );
+		}
 		return expr1();
 	}
 
@@ -962,12 +994,12 @@ class Parser {
 		return expr;
 	}
 
-	// We flipped the binary ops back to normal programming style.
-	// || is logical OR, | is bitwise.
-	function expr3() return this.recurseLeftOp(this.expr4, ["|"], ["bor"]); // bitwise or
-	function expr4() return this.recurseLeftOp(this.expr5, ["&"], ["band"]); // bitwise and
-	function expr5() return this.recurseLeftOp(this.expr6, ["||"], ["or"]); // logical or
-	function expr6() return this.recurseLeftOp(this.expr7, ["&&"], ["and"]); // logical and
+	// Yes, || and && are swapped. They should be logical ops but they are binary ops.
+	// We're trying to keep parity with E2, so this will be kept.
+	function expr3() return this.recurseLeftOp(this.expr4, ["||"], ["bor"]); // bitwise or
+	function expr4() return this.recurseLeftOp(this.expr5, ["&&"], ["band"]); // bitwise and
+	function expr5() return this.recurseLeftOp(this.expr6, ["|"], ["or"]); // logical or
+	function expr6() return this.recurseLeftOp(this.expr7, ["&"], ["and"]); // logical and
 	function expr7() return this.recurseLeftOp(this.expr8, ["^^"], ["xor"]); // binary xor
 	function expr8() return this.recurseLeftOp(this.expr9, ["==", "!="], ["eq", "neq"]);
 	function expr9() return this.recurseLeftOp(this.expr10, [">", "<", ">=", "<="], ["gt", "lt", "geq", "leq"]);

src/Base/Preprocessor.hx

@@ -11,23 +11,29 @@ private function FILL_WHITESPACE(x: EReg) {
  * You can modify the regexes to your needs but by default will remove comments & directives.
  */
 class Preprocessor {
-	var repl: Map<EReg, (EReg)->String>;
+	var repl: Map<EReg, (EReg)->String> = [];
+	var repl_order: Array<EReg> = [];
+	var repl_order_index: UInt = 0;
 
 	public function process(script: String) {
 		var processed = script;
 
-		for (regex => with in repl)
-			processed = regex.map( processed, with );
+		for (regex in repl_order)
+			processed = regex.map( processed, this.repl[regex] );
 
 		return processed;
 	}
 
+	public function add_replacement(regex: EReg, with: (EReg)->String) {
+		// Haxe is dying with optionals for me so I can't have an override for repl_order_index. :/
+		this.repl_order[repl_order_index] = regex;
+		this.repl_order_index++;
+		this.repl[regex] = with;
+	}
+
 	public function new() {
-		final repl = [
-			~/#\[[\s\S]*\]#/g => FILL_WHITESPACE, // Single-line comment
-			~/#[^\n]*/g => FILL_WHITESPACE, // Multiline
-			~/@[^\n]*/g => FILL_WHITESPACE // Directive
-		];
-		this.repl = repl;
+		this.add_replacement( ~/#\[[\s\S]*\]#/g, FILL_WHITESPACE ); // Multiline comment
+		this.add_replacement( ~/#[^\n]*/g, FILL_WHITESPACE ); // Single line comment
+		this.add_replacement( ~/@[^\n]*/g, FILL_WHITESPACE ); // Directive
 	}
 }

src/Base/Transpiler/Lua.hx

@@ -15,14 +15,14 @@ var IN_SWITCH: Bool = false;
 
 @:keep
 class Instructions {
-	static function root(instrs: Array<Instruction>) {
+	static function instr_root(instrs: Array<Instruction>) {
 		var out = [];
 		for (instr in instrs)
 			out.push( callInstruction(instr.name, instr.args) );
 		return out.join('\n\n').replaceAll("\t\n", '');
 	}
 
-	static function call(name: String, kvargs: Map<Dynamic, Instruction>, iargs: Array<Instruction>) {
+	static function instr_call(name: String, kvargs: Map<Dynamic, Instruction>, iargs: Array<Instruction>) {
 		var args = [];
 		if (iargs != null) {
 			// Function was called with arguments
@@ -35,13 +35,13 @@ class Instructions {
 		return '$name()';
 	}
 
-	static function methodcall(meta_fname: String, meta_obj: Instruction, iargs: Array<Instruction>)
+	static function instr_methodcall(meta_fname: String, meta_obj: Instruction, iargs: Array<Instruction>)
 		return '${ callInline(meta_obj) }:$meta_fname(${ (iargs!=null) ? iargs.map(x -> callInline(x)).join(", ") : '' })';
 
-	static function literal(value: E2Type, raw: String)
+	static function instr_literal(value: E2Type, raw: String)
 		return raw;
 
-	static function _if(cond: Instruction, block: Instruction, is_elseif: Bool, ifeif: Instruction) {
+	static function instr_if(cond: Instruction, block: Instruction, is_elseif: Bool, ifeif: Instruction) {
 		if (is_elseif) {
 			return 'is_elseif';
 		}
@@ -68,7 +68,7 @@ class Instructions {
 		'end [${ ifeif != null ? callBlock(ifeif, false) : "" }]';*/
 	}
 
-	static function _for(varname: String, start: Instruction, end: Instruction, ?inc: Instruction, block: Instruction) {
+	static function instr_for(varname: String, start: Instruction, end: Instruction, ?inc: Instruction, block: Instruction) {
 		final startv = callInline(start);
 		final endv = callInline(end);
 
@@ -80,14 +80,14 @@ class Instructions {
 		+ 'end';
 	}
 
-	static function foreach(keyname: String, ?keytype: String, valname: String, valtype: String, tblexpr: Instruction, block: Instruction) {
+	static function instr_foreach(keyname: String, ?keytype: String, valname: String, valtype: String, tblexpr: Instruction, block: Instruction) {
 		return 'for $keyname, $valname in pairs(${ callInline(tblexpr) }) do\n' +
 			'\t${callBlock(block, true)}\n' +
 			'\t::continue::\n' +
 		'end';
 	}
 
-	static function _while(cond: Instruction, block: Instruction, is_dowhile: Bool) {
+	static function instr_while(cond: Instruction, block: Instruction, is_dowhile: Bool) {
 		if (is_dowhile) {
 			// Not using a repeat until
 			return 'while true do\n' +
@@ -102,10 +102,10 @@ class Instructions {
 		'end';
 	}
 
-	static function variable(name: String)
+	static function instr_variable(name: String)
 		return name;
 
-	static function _switch(topexpr: Instruction, cases: Array<{?match: Instruction, block: Instruction}>) {
+	static function instr_switch(topexpr: Instruction, cases: Array<{?match: Instruction, block: Instruction}>) {
 		IN_SWITCH = true;
 		var topvar = callInline(topexpr);
 
@@ -126,65 +126,73 @@ class Instructions {
 		return out;
 	}
 
-	static function _break()
+	static function instr_break()
 		return IN_SWITCH ? '' : "break";
 
-	static function _continue()
+	static function instr_continue()
 		return 'goto continue';
 
-	static function _return(val: Instruction)
+	static function instr_return(val: Instruction)
 		return 'return ${ callInline(val) }';
 
-	static function increment(varname: String)
+	static function instr_increment(varname: String)
 		return '$varname = $varname + 1';
 
-	static function decrement(varname: String)
+	static function instr_decrement(varname: String)
 		return '$varname = $varname - 1';
 
-	static function add(v: Instruction, addend: Instruction)
+	static function instr_add(v: Instruction, addend: Instruction)
 		return '${ callInline(v) } + ${ callInline(addend) }';
 
-	static function sub(v: Instruction, addend: Instruction)
+	static function instr_sub(v: Instruction, addend: Instruction)
 		return '${ callInline(v) } - ${ callInline(addend) }';
 
-	static function div(v: Instruction, addend: Instruction)
+	static function instr_div(v: Instruction, addend: Instruction)
 		return '${ callInline(v) } / ${ callInline(addend) }';
 
-	static function mul(v: Instruction, addend: Instruction)
+	static function instr_mul(v: Instruction, addend: Instruction)
 		return '${ callInline(v) } * ${ callInline(addend) }';
 
-	static function assign(varname: String, to: Instruction)
-		return '$varname = ${ callInline(to) }';
-
-	static function eq(v1: Instruction, v2: Instruction)
+	static function instr_eq(v1: Instruction, v2: Instruction)
 		return '${ callInline(v1) } == ${ callInline(v2) }';
 
-	static function neq(v1: Instruction, v2: Instruction)
+	static function instr_neq(v1: Instruction, v2: Instruction)
 		return '${ callInline(v1) } ~= ${ callInline(v2) }';
 
-	static function leq(v1: Instruction, v2: Instruction)
+	static function instr_leq(v1: Instruction, v2: Instruction)
 		return '${ callInline(v1) } <= ${ callInline(v2) }';
 
-	static function geq(v1: Instruction, v2: Instruction)
+	static function instr_geq(v1: Instruction, v2: Instruction)
 		return '${ callInline(v1) } >= ${ callInline(v2) }';
 
-	static function grouped_equation(v1: Instruction)
+	static function instr_grouped_equation(v1: Instruction)
 		return '(${ callInline(v1) })';
 
-	static function assignlocal(varname: String, to: Instruction)
+	static function instr_assign(varname: String, to: Instruction)
+		return '$varname = ${ callInline(to) }';
+
+	static function instr_assignlocal(varname: String, to: Instruction)
 		return 'local $varname = ${ callInline(to) }';
 
-	static function function_decl(name: String, ret_type: String, meta_type: String, sig: String, args: Array<{name: String, type: String}>, decl: Instruction) {
+	static function instr_fndecl(name: String, ret_type: String, meta_type: String, sig: String, args: Array<{name: String, type: String}>, decl: Instruction) {
 		return 'function ${(meta_type != null) ? '${meta_type}_' : ''}$name(${ args.map( (v) -> v.name ).join(", ") })\n' +
 			'\t${ callBlock(decl, true) }\n' +
 		'end';
 	}
 
-	static function ternary(cond: Instruction, success: Instruction, fallback: Instruction)
+	static function instr_ternary(cond: Instruction, success: Instruction, fallback: Instruction)
 		return '${ callInline(cond) } and ${ callInline(success) } or ${ callInline(fallback) }';
 
+	static function instr_try(block: Instruction, var_name: String, catch_block: Instruction) {
+		return 'xpcall(function()\n' +
+			'\t${ callBlock(block, true) }\n' +
+		'end, function($var_name)\n' +
+			'\t${ callBlock(catch_block, true) }\n' +
+		'end)';
+	}
+
 	// Bitwise ops
-	static function bor(v1: Instruction, v2: Instruction) {
+	static function instr_bor(v1: Instruction, v2: Instruction) {
 		#if LUA54
 			return '${ callInline(v1) } | ${ callInline(v2) }';
 		#else
@@ -195,6 +203,8 @@ class Instructions {
 
 // Expr -> Lua
 function callInstruction(name: String, args: Array<Dynamic>): String {
+	var name = 'instr_' + name;
+
 	if(!Reflect.hasField(Instructions, name))
 		throw new NotImplementedException('Instruction ["$name"] does not exist.');
 

tests/utest/Tokenizer.hx

@@ -20,11 +20,8 @@ class Tokenizer extends Test {
 	/**
 	 * Make sure we properly get the literal number value out of a basic operation.
 	 */
-	/*
-		Haxe/utest is fucking stupid 👍
 	public function testLiteralNumber() {
 		final tokens = this.tokenizer.process(this.script);
 		Assert.equals( E2Type.Number(212), tokens[2].literal );
 	}
-	*/
 }