Add files via upload

Author: Philipp Gersch

com/devkev/devscript/nativecommands/NativeLibrary.java

@@ -1,6 +1,7 @@
 package com.devkev.devscript.raw;
 
 public final class Alphabet {
+	
     public static final char BRK_0 = '(';
     public static final char BRK_1 = ')';
     public static final char STR_0 = '"';
@@ -14,6 +15,7 @@ public final class Alphabet {
     public static final char COMMENT = '#';
     public static final char LSTRING_0 = '<';
     public static final char LSTRING_1 = '>';
+    public static final char OBJECT_DOT = '.';
 
     private Alphabet() {}
 
@@ -24,6 +26,14 @@ public static boolean partOf(String checkString) {
     	return true;
     }
 
+    public static boolean notPartOfVariableDeclarator(char c) {
+    	return partOf(c) && !partOfVariableDeclarator(c);
+    }
+    
+    public static boolean partOfVariableDeclarator(char c) {
+    	return c == OBJECT_DOT || c == VAR_0 || c == ARR_0 || c == ARR_1;
+    }
+    
     public static boolean partOf(char c) {
         for (java.lang.reflect.Field f : Alphabet.class.getFields()) {
             try {

com/devkev/devscript/raw/Alphabet.java

@@ -2,9 +2,10 @@
 
 import java.util.ArrayList;
 
-import com.devkev.devscript.raw.ApplicationBuilder.Type;
+import com.devkev.devscript.raw.ProcessUtils.Type;
 
-public class Array { //For dataContainers
+public class Array {
+	
 	private final ArrayList<Object> indexes = new ArrayList<Object>(2);
 	public DataType arrayType;
 
@@ -44,9 +45,9 @@ public ArrayList<Object> getIndexes() {
 	public void updateArraytype() {
     	Type type = Type.NULL;
 		for(int j = 0; j < indexes.size(); j++) {
-			DataType containerType = ApplicationBuilder.toDataType(indexes.get(j));
+			DataType containerType = ProcessUtils.toDataType(indexes.get(j));
 			if(j > 0) {
-				DataType indexType = ApplicationBuilder.toDataType(indexes.get(j-1));
+				DataType indexType = ProcessUtils.toDataType(indexes.get(j-1));
 				if(indexType.type != containerType.type && type != Type.ANY) {
 					type = Type.ANY;
 					break;

com/devkev/devscript/raw/Array.java

@@ -2,10 +2,12 @@
 
 import java.util.ArrayList;
 
+import com.devkev.devscript.raw.ProcessUtils.ExitCodes;
+
 public class Block { //So stupid...
 
-	public static final byte DONE = 0;
-	public static final byte ERROR = 1;
+	private Process host;
+	private ArrayList<Variable> variables = new ArrayList<>();
 
 	public final StringBuilder blockCode;
 	public int executeIndex = 0;	//The current char index, that is executed or compiled. 0 < ExecuteIndex < blockCode.length() 
@@ -17,22 +19,33 @@ public class Block { //So stupid...
 	public volatile boolean continued = false;
 
 	public Block parent;
-	public volatile boolean isFunction = false; //This flag gets set to true, if a variable containing a block (= function) is made in the command = (function = {#some code#})
-	public Object functionReturn = null;
 	private byte stack = 0;
 
-	public boolean loop = false;
-	ArrayList<Command> cached = new ArrayList<>();
-//	ArrayList<CompiledCommand> compiled = new ArrayList<CompiledCommand>(0);
-	int exitCode = DONE;
+	ArrayList<Command> cached = new ArrayList<>(1);
+	int exitCode = ExitCodes.DONE;
+	
+	//Block flags
+	//This flag gets set to true, if a variable containing a block (= function) is made in the command = (function = {#some code#}) (Flag: F)
+	private volatile boolean isFunction = false;
+	public Object functionReturn = null;
+	
+	//If the block should isolate variables (A bit more complex than that) (Flag: O)
+	private volatile boolean isConstrucor = false;
+	
+	//If true, errors dont cause the script to exit. (=> the block acts like a try/catch block.) (Flag: T)
+	private volatile boolean isTryCatch = false;
+	
+	//True if the block belongs to a loop. This will affect return, continue and break commands. (Flag: L)
+	private volatile boolean isLoop = false;
 
 	class CompiledCommand {
 		Command command;
 		ArrayList<Object> args;
 	}
 
-	Block(StringBuilder blockCode, Block parent) {
+	public Block(StringBuilder blockCode, Block parent, Process host) {
 		this.blockCode = blockCode;
+		this.host = host;
 
 		if(parent != null) {
 			this.parent = parent;
@@ -41,8 +54,46 @@ class CompiledCommand {
 		} else this.stack = 0;
 	}
 
+	public boolean inheritTryCatch() {
+		Block current = this;
+		while(current.parent != null) {
+			if(current.parent == null) return current.isTryCatch;
+			else if(current.parent == host.main) return current.isTryCatch;
+			else {
+				current = current.parent;
+				if(current.isTryCatch()) return true;
+			}
+		}
+		return current.isTryCatch;
+	}
+	
+	public boolean isTryCatch() {
+		return isTryCatch;
+	}
+	
+	public void setAsTryCatch() {
+		isTryCatch = true;
+	}
+	
+	public boolean isObject() {
+		return isConstrucor;
+	}
+	
+	public void setAsObject() {
+		isConstrucor = true;
+	}
+	
+	public boolean isFunction() {
+		return isFunction;
+	}
+	
+	public void setAsFunction() {
+		isFunction = true;
+	}
+	
 	public synchronized void interrupt() {
 		interrupted = true;
+		isLoop = false;
 	}
 
 	public synchronized boolean interrupted() {
@@ -54,28 +105,17 @@ public byte getStack() {
 	}
 
 	public boolean isLoop() {
-		return loop;
-	}
-	
-	public void beginLoop() {
-		loop = true;
+		return isLoop;
 	}
 
-	public void endLoop(boolean clearcache) {
-		loop = false;
+	public void setAsLoop() {
+		isLoop = true;
 	}
 
 	public synchronized boolean isAlive() {
 		return alive;
 	}
 
-//	public void addCompiledCommand(Command command, ArrayList<Object> args) {
-//		CompiledCommand c = new CompiledCommand();
-//		c.args = args;
-//		c.command = command;
-//		compiled.add(c); //Index would be the "line"
-//	}
-	
 	void addToCache(Command c) {
 		for(int i = 0; i < cached.size(); i++) {
 			if(c.equals(cached.get(i))) return;
@@ -87,7 +127,104 @@ void clearCache() {
 		cached.clear();
 	}
 
+	private static void checkForBlockInheritage(Object obj, Block parent) {
+		if(obj instanceof Block)
+			((Block) obj).parent = parent;
+	}
+	
+	/**@return true, if handled, that means a variable with the name was found or a variable was created*/
+	public boolean setVariable(String name, Object value, boolean FINAL, boolean permanent, boolean allowCreation) {
+		if(name.equals("true")) return true;
+		else if(name.equals("false")) return true;
+		else if(name.equals("null")) return true;
+		
+		if(name.contains(" ") || Alphabet.partOf(name)) {
+			host.kill(this, "Variable name contains illegal/reserved characters");
+			return false;
+		}
+		
+		for(Variable v : variables) {
+			if(v.name.equals(name)) {
+				if(!v.FINAL) {// || v.permanent) {
+					if(!v.setValue(value, true)) {
+						host.kill(this, "Failed to assign type " + value + " to existing variable " + v.value);
+						checkForBlockInheritage(value, this);
+					}
+				}
+				return true;
+			}
+		}
+		//If not found, check the parents!
+		if(parent != null && !isConstrucor) {
+			if(parent.setVariable(name, value, FINAL, permanent, false)) {
+				checkForBlockInheritage(value, this);
+				return true;
+			}
+		}
+		
+		if(allowCreation) {
+			this.variables.add(new Variable(name, value, FINAL, permanent, this));
+			checkForBlockInheritage(value, this);
+			return true;
+		}
+		return false;
+	}
+	
+	public void clearVariables() {
+		variables.clear();
+	}
+	
+	public void removeVariable(String name) {
+		for(Variable v : variables) {
+			if(v.name.equals(name) && !v.FINAL) {
+				variables.remove(v);
+				return;
+			}
+		}
+		//Otherwise look for the next stack if the block is not a constructor (aka "isolated")
+		if(!isConstrucor && parent != null)
+			parent.removeVariable(name);
+	}
+	
+	public ArrayList<Variable> getAccessibleVariables() {
+		ArrayList<Variable> var = new ArrayList<>();
+		var.addAll(variables);
+		
+		if(parent != null)
+			var.addAll(parent.getAccessibleVariables());
+		
+		return var;
+	}
+	
+	public ArrayList<Variable> getLocalVariables() {
+		return variables;
+	}
+	
+	public Object getVariable(String name) {
+		//constants
+		if(name.equals("true")) return Process.True;
+		else if(name.equals("false")) return Process.False;
+		else if(name.equals("null")) return Process.Null;
+		else if(name.equals("n")) return "\n";
+		else if(name.equals("t")) return "\t";
+		
+		for(Variable var : variables) {
+			if(var.name.equals(name))
+				return var.value;
+		}
+		//Otherwise search the parent
+		if(parent != null)
+			return parent.getVariable(name);
+		else return null;
+	}
+	
+	public Process getHost() {
+		return host;
+	}
+	
 	public String toString() {
-		return "BLOCK:" + stack + "" + (thread != null ? " Thread: " + thread.getName() : " Thread: none");
+		return "BLOCK:" + (isFunction ? "F" : "") + (isConstrucor ? "O" : "") + (isTryCatch ? "T" : "") + (isLoop ? "L" : "") + " " + stack
+				+ (thread != null ? " Thread: " + thread.getName() : "");
+					//+ " CODE [" + blockCode + "]";
 	}
 }