enums

Author: lemz1

hscript/Expr.hx

@@ -122,6 +122,7 @@ enum ModuleDecl {
 	DImport( path : Array<String>, ?everything : Bool );
 	DClass( c : ClassDecl );
 	DTypedef( c : TypeDecl );
+	DEnum( e : EnumDecl );
 }
 
 typedef ModuleType = {
@@ -138,6 +139,21 @@ typedef ClassDecl = {> ModuleType,
 	var isExtern : Bool;
 }
 
+typedef EnumDecl = {
+	var name: String;
+	var fields : Array<EnumFieldDecl>;
+}
+
+typedef EnumFieldDecl = {
+	var name : String;
+	var args : Array<EnumArgDecl>;
+}
+
+typedef EnumArgDecl = {
+	var name : String;
+	var type : Null<CType>;
+}
+
 typedef TypeDecl = {> ModuleType,
 	var t : CType;
 }

hscript/Interp.hx

@@ -511,21 +511,50 @@ class Interp {
 		case ETernary(econd,e1,e2):
 			return if( expr(econd) == true ) expr(e1) else expr(e2);
 		case ESwitch(e, cases, def):
+			var old:Int = declared.length;
 			var val : Dynamic = expr(e);
 			var match = false;
 			for( c in cases ) {
-				for( v in c.values )
-					if( expr(v) == val ) {
-						match = true;
-						break;
+				for( v in c.values ) {
+					switch ( Tools.expr(v) ) {
+					case ECall(e, params):
+						switch ( Tools.expr(e) ) {
+						case EField(_, f):
+							var valStr:String = cast val;
+							valStr = valStr.substring(0, valStr.indexOf("("));
+							if (valStr == f) {
+								var valParams = Type.enumParameters(val);
+								for (i => p in params) {
+									switch ( Tools.expr(p) ) {
+									case EIdent(n):
+										declared.push({
+											n: n,
+											old: {r: locals.get(n)}
+										});
+										locals.set(n, {r: valParams[i]});
+									default:
+									}
+								}
+								match = true;
+								break;
+							}
+						default:
+						}
+					default:
+						if( expr(v) == val ) {
+							match = true;
+							break;
+						}
 					}
+				}
 				if( match ) {
 					val = expr(c.expr);
 					break;
 				}
 			}
 			if( !match )
 				val = def == null ? null : expr(def);
+			restore(old);
 			return val;
 		case EMeta(_, _, e):
 			return expr(e);

hscript/Parser.hx

@@ -1188,6 +1188,20 @@ class Parser {
 				isPrivate : isPrivate,
 				t : t,
 			});
+		case "enum":
+			var name = getIdent();
+			
+			var fields = [];
+			ensure(TBrOpen);
+			while( !maybe(TBrClose) ) {
+				fields.push(parseEnumField());
+				ensure(TSemicolon);
+			}
+
+			return DEnum({
+				name: name,
+				fields: fields
+			});
 		default:
 			unexpected(TId(ident));
 		}
@@ -1266,6 +1280,31 @@ class Parser {
 		return null;
 	}
 
+	function parseEnumField() : EnumFieldDecl {
+		var name = getIdent();
+
+		var args = [];
+		if( maybe(TPOpen) ) {
+			while ( !maybe(TPClose) )
+				args.push(parseEnumArg());
+		}
+		
+		return {
+			name: name,
+			args: args
+		};
+	}
+
+	function parseEnumArg() : EnumArgDecl {
+		var name = getIdent();
+		var type = maybe(TDoubleDot) ? parseType() : null;
+
+		return {
+			name: name,
+			type: type
+		};
+	}
+
 	// ------------------------ lexing -------------------------------
 
 	inline function readChar() {