22.3.0

Author: ThomasDarkson

CHANGELOG.md

@@ -1,3 +1,13 @@
+# 22.3.0
+## Additions
+- Added Static Extensions, with some limitations 
+
+## Changes
+- `presetter` is replaced with `presetMode`
+
+## Fixes
+- Some micro optimizations
+
 # 22.2.2
 ## Fixes
 - You can now edit the properties of special objects in scripts

README.md

@@ -113,6 +113,45 @@ class Main
 }
 ```
 
+#### Static Extensions
+SScript supports Static Extensions with the `using` keyword.
+
+```haxe
+import hscript.SScript;
+
+class Main 
+{
+	static function main()
+	{
+		var script:SScript = new SScript();
+		script.setClass(IntExtender);
+		script.doString("
+			using IntExtender;
+			using StringTools;
+
+			trace(1.triple()); // 3
+			trace(.1.triple()); // 0.30000000000000004
+			/*
+				SScript doesn't check types in extension methods,
+				so 'triple' returns a Float even though it should return an Int.
+				Use it with caution.
+			*/
+
+			var str = 'str-end';
+			trace(str.startsWith('str'), str.endsWith('-end')); // true,true
+		");
+	}
+}
+
+class IntExtender {
+	static public function triple(i:Int):Int {
+		return i * 3;
+	}
+}
+```
+
+As explained above, SScript doesn’t check types. It also doesn’t verify if the correct number of arguments is used; therefore, if an incorrect number of arguments is provided (such as passing two arguments to `endsWith` like `str.endsWith(str, "-end")`), Haxe will throw a vague `Something went wrong` error.
+
 #### String Interpolation
 SScript supports string interpolation. Just like in Haxe, special identifiers denoted by the dollar sign `$` within a string (enclosed by single quotes `'`) are evaluated as expressions.
 

haxelib.json

@@ -9,7 +9,7 @@
         "script"
     ],
     "description": "SScript (also known as SuperlativeScript), fork of HScript with fixes and improvements.",
-    "version": "22.2.2",
+    "version": "22.3.0",
     "classPath": "src/",
     "releasenote": "Check CHANGELOG.md",
     "contributors": [

src/hscript/SScript.hx

@@ -119,7 +119,6 @@ class SScript
 
 		**MINI** contains only basic classes like `Math`.
 
-
 		**REGULAR** contains most cross-target Haxe classes.
 
 		**FULL** contains all existing classes.
@@ -202,9 +201,11 @@ class SScript
 	public var notAllowedClasses(default, null):Array<Class<Dynamic>> = [];
 
 	/**
-		Preset tool for this script.
+		Preset mode of this script. 
+
+		@see SScript.defaultPreset
 	**/
-	public var presetter(default, null):Preset;
+	public var presetMode(default, set):PresetMode;
 
 	/**
 		Use this to access to interpreter's variables!
@@ -294,7 +295,7 @@ class SScript
 
 		parser = new Parser();
 
-		presetter = new Preset(this);
+		presetMode = defaultPreset;
 		if (preset)
 			this.preset();
 
@@ -419,9 +420,11 @@ class SScript
 		This is a helper function for setting classes easily.
 		For example, if `cl` is the `sys.io.File` class, it will be set as `File`.
 		@param cl The class to set.
+		@param setAsFinal Whether to set the object as final. If set as final,
+		the object will act as a final variable and cannot be changed in the script.
 		@return this instance for chaining.
 	**/
-	public function setClass(cl:Class<Dynamic>):SScript
+	public function setClass(cl:Class<Dynamic>, ?setAsFinal:Bool = false):SScript
 	{
 		if (_destroyed)
 			return null;
@@ -445,7 +448,7 @@ class SScript
 				clName = splitCl[splitCl.length - 1];
 			}
 
-			set(clName, cl);
+			set(clName, cl, setAsFinal);
 		}
 		return this;
 	}
@@ -454,9 +457,11 @@ class SScript
 		Sets a class in this script from a string.
 		`cl` will be formatted. For example: `sys.io.File` -> `File`.
 		@param cl The class to set.
+		@param setAsFinal Whether to set the object as final. If set as final,
+		the object will act as a final variable and cannot be changed in the script.
 		@return this instance for chaining.
 	**/
-	public function setClassString(cl:String):SScript
+	public function setClassString(cl:String, ?setAsFinal:Bool = false):SScript
 	{
 		if (_destroyed)
 			return null;
@@ -476,7 +481,7 @@ class SScript
 			if (parts.length > 1)
 				cl = parts[parts.length - 1];
 
-			set(cl, cls);
+			set(cl, cls, setAsFinal);
 		}
 		return this;
 	}
@@ -788,7 +793,7 @@ class SScript
 		if (!active)
 			return;
 
-		presetter.preset();
+		Preset.preset(this);
 	}
 
 	function resetInterp():Void
@@ -807,6 +812,7 @@ class SScript
 			return;
 
 		interp.specialObject = null;
+		interp.usingMethods = null;
 		interp.script = null;
 		interp.locals = null;
 		interp.variables = null;
@@ -1032,8 +1038,6 @@ class SScript
 		if (ID != null && global.exists(Std.string(ID)))
 			global.remove(Std.string(ID));
 
-		presetter.destroy();
-
 		removeSpecialObject();
 		clear();
 		resetInterp();
@@ -1110,4 +1114,10 @@ class SScript
 
 		return defaultPreset = value;
 	}
+
+	function set_presetMode(value:PresetMode):PresetMode {
+		if (_destroyed)
+			return null;
+		return presetMode = value;
+	}
 }

src/hscript/backend/MultiMap.hx

@@ -0,0 +1,27 @@
+package hscript.backend;
+
+import haxe.ds.Map;
+
+class MultiMap<V:Dynamic> {
+    private var data:Map<String, Array<V>>;
+
+    public function new() {
+        data = new Map<String, Array<V>>();
+    }
+
+    public function push(key:String, value:V):Void {
+        if (!data.exists(key)) {
+            data.set(key, [value]);
+        } else {
+            data.get(key).push(value);
+        }
+    }
+
+    public function get(key:String):Array<V> {
+        return data.exists(key) ? data.get(key) : [];
+    }
+
+    public function remove(key:String):Bool {
+        return data.remove(key);
+    }
+}

src/hscript/backend/Preset.hx

@@ -17,48 +17,24 @@ enum PresetMode
 @:access(hscript.SScript)
 class Preset
 {
-    public var presetMode:PresetMode;
-
-    var script:SScript;
-    var _destroyed:Bool = false;
-    public function new(script:SScript)
+    static function preset(script:SScript)
     {
         if (script == null || script._destroyed)
             return;
 
-        this.script = script;
-        presetMode = SScript.defaultPreset;
-    }
-
-    function preset()
-    {
-        if (_destroyed || script == null || script._destroyed)
-            return;
-
-        var hArray = switch presetMode {
+        var hArray = switch script.presetMode {
             case MINI: PresetClasses.miniHaxe;
             case REGULAR: PresetClasses.regularHaxe;
             #if !DISABLED_MACRO_SUPERLATIVE
             case FULL: PresetClasses.fullHaxe;
             #end
-            case _: [];
+            default: [];
         }
 
         for (i in hArray.copy()) {
             script.setClass(i);
         }
     }
-
-    function destroy()
-    {
-        if (_destroyed)
-            return;
-
-        script = null;
-        presetMode = null;
-
-        _destroyed = true;
-    }
 }
 
 class PresetClasses 

src/hscriptBase/Expr.hx

@@ -69,7 +69,7 @@ enum ExprDef {
 	ETernary( cond : Expr, e1 : Expr, e2 : Expr );
 	ESwitch( e : Expr, cases : Array<{ values : Array<Expr>, expr : Expr , ifExpr : Expr }>, ?defaultExpr : Expr);
 	EDoWhile( cond : Expr, e : Expr);
-	EUsing( op : Dynamic , n : String );
+	EUsing( c : String );
 	EImport( i : Dynamic, c : String , ?asIdent : String , ?fullName : String );
 	EImportStar( pkg : String );
 	EPackage( ?p : String );
@@ -114,6 +114,7 @@ enum ErrorDef {
 	ENullObjectReference;
 	EInvalidChar( c : Int );
 	EUnexpected( s : String );
+	ETypeNotFound( s : String );
 	EUnterminatedString;
 	EUnterminatedComment;
 	EInvalidPreprocessor( msg : String );

src/hscriptBase/Interp.hx

@@ -21,6 +21,7 @@
  */
 package hscriptBase;
 
+import hscript.backend.MultiMap;
 import haxe.ds.*;
 import haxe.PosInfos;
 import hscriptBase.Expr;
@@ -68,6 +69,8 @@ class Interp {
 	var specialObject : {obj:Dynamic , ?includeFunctions:Bool , ?exclusions:Array<String>} = {obj : null , includeFunctions: null , exclusions: null };
 	var specialObjectsFields : Array< String > = [];
 
+	var usingMethods : MultiMap< Function > = new MultiMap< Function >();
+
 	var hasPrivateAccess : Bool = false;
 	var noPrivateAccess : Bool = false;
 
@@ -732,9 +735,21 @@ class Interp {
 				finalVariables.set(c,e);
 
 			return if( strictVar ) error(EUnexpected("import")) else null;
-		case EUsing( e, c ):
-			if( c != null && e != null )
-				finalVariables.set( c , e );
+		case EUsing( c ):
+			var cl = Type.resolveClass(c);
+			if( cl == null )
+				cl = finalVariables.get(c);
+			if( cl == null )
+				cl = variables.get(c);
+			if( cl == null )
+				error(ETypeNotFound(c));
+
+			var fields = Reflect.fields(cl);
+			for( i in fields ) {
+				var f = Reflect.field(cl,i);
+				if( f != null && Reflect.isFunction(f) )
+					usingMethods.push(i,f);
+			}
 
 			return if( strictVar ) error(EUnexpected("using")) else null;
 		case EPackage(p):
@@ -1160,9 +1175,9 @@ class Interp {
 		restore(old);
 	}
 
+	static final mapClasses:Array<Dynamic> = ["Map", "StringMap", "IntMap", "ObjectMap", "HashMap", "EnumValueMap", "WeakMap"];
 	static inline function isMap(o:Dynamic):Bool {
-		var classes:Array<Dynamic> = ["Map", "StringMap", "IntMap", "ObjectMap", "HashMap", "EnumValueMap", "WeakMap"];
-		if(classes.contains(o))
+		if(mapClasses.contains(o))
 			return true;
 
 		return Std.isOfType(o, IMap);
@@ -1190,7 +1205,28 @@ class Interp {
 	}
 
 	function fcall( o : Dynamic, f : String, args : Array<Dynamic>) : Dynamic {
-		return call(o, get(o, f), args);
+		var exception = null;
+		try {
+			return call(o, get(o, f), args);
+		}
+		catch( e )
+			exception = e;
+
+		if( f != null ) {
+			var methods = usingMethods.get(f);
+			for( i in methods ) {
+				try {
+					var args = args.copy();
+					args.unshift(o);
+					return call(o, i, args);
+				}
+				catch( e ) {
+					exception = e;
+					continue;
+				}
+			}
+		}
+		return throw exception;
 	}
 
 	function call( o : Dynamic, f : Dynamic, args : Array<Dynamic>) : Dynamic {