public override void Interpret(Expression[] args, FunctionBlock block, Type contextType, string exprVal, out string newExprVal, out FunctionBlock newCurBlock, out Type newContextType, bool isLast) { if (ScriptEngine.AnalyzeDebug) { Debug.Log("fit scope"); } IfStatement ifStatement = new IfStatement(); // DeclareVariableStatement cmpStmt = new DeclareVariableStatement (); // ExprInter.CleanUpContextes.Add (cmpStmt); // cmpStmt.Name = "cmp" + DeclareVariableStatement.VariableId++; // cmpStmt.Type = Type; //cmpStmt.IsContext = true; string varName = block.FindStatement <DeclareVariableStatement> (v => v.IsContext).Name; // cmpStmt.InitExpression = String.Format ("{0}.GetComponent<{1}>()", varName, Type); // ifStatement.CheckExpression = String.Format ("{0} != null", cmpStmt.Name); FunctionBlock newBlock = new FunctionBlock(block, block.Method, block.Type); DeclareVariableStatement ifValue = new DeclareVariableStatement(); ifValue.Name = "ifResult" + DeclareVariableStatement.VariableId++; ifValue.IsTemp = true; ifValue.Type = typeof(bool); block.Statements.Add(ifValue); ifStatement.CheckExpression = (ifValue.Name + " = ") + ExprInter.InterpretExpression(args [0], block).ExprString; ifStatement.TrueBlock = newBlock; //block.Statements.Add (cmpStmt); block.Statements.Add(ifStatement); newCurBlock = newBlock; newExprVal = exprVal; newContextType = contextType; if (isLast) { var res = block.FindStatement <DeclareVariableStatement> (v => v.IsResult); if (res != null) { res.Type = typeof(List <>).MakeGenericType(contextType); res.InitExpression = String.Format("new {0}()", TypeName.NameOf(res.Type)); newExprVal = res.Name; newBlock.Statements.Add(String.Format("{0}.Add({1});", res.Name, varName)); } else { newExprVal = ifValue.Name; newContextType = typeof(bool); } } //ifStatement.CheckExpression = String.Format("{0}.GetComponen") //ifStatement.CheckExpression = }
public override void Interpret(Expression[] args, FunctionBlock block, Type contextType, string exprVal, out string newExprVal, out FunctionBlock newCurBlock, out Type newContextType, bool isLast) { var thisVar = block.FindStatement <DeclareVariableStatement> (v => v.IsContext && !v.IsTemp); newExprVal = thisVar.Name; newCurBlock = block; newContextType = thisVar.Type; }
public override void Interpret(Expression[] args, FunctionBlock block, Type contextType, string exprVal, out string newExprVal, out FunctionBlock newCurBlock, out Type newContextType, bool isLast) { var retVar = block.FindStatement <DeclareVariableStatement> (v => v.IsReturn); newExprVal = retVar.Name; block.Statements.Add(String.Format("{0} = true;", retVar.Name)); newCurBlock = block; newContextType = typeof(bool); }
public Expr InterpretClosure(Expression expression, FunctionBlock block, Type closureType) { //Debug.LogFormat ("Interpret {0} as closure", expression); StringBuilder closureBuilder = new StringBuilder(); var methodInfo = closureType.GetMethod("Invoke"); var args = methodInfo.GetParameters(); FunctionBlock lambdaBlock = new FunctionBlock(block, block.Method, block.Type); if (args.Length > 0) { lambdaBlock.DefaultScope = args[0].Name; } else { lambdaBlock.DefaultScope = block.FindStatement <DeclareVariableStatement>(v => v.Type == typeof(GameObject) && v.IsContext && !v.IsTemp).Name; } closureBuilder.Append("("); DeclareVariableStatement lastArg = null; foreach (var param in args) { var argVar = new DeclareVariableStatement(); lastArg = argVar; argVar.Name = param.Name; argVar.IsArg = true; argVar.Type = param.ParameterType; lambdaBlock.Statements.Add(argVar); closureBuilder.Append(param.ParameterType).Append(" ").Append(param.Name).Append(","); } if (lastArg != null) { lastArg.IsContext = true; } if (closureBuilder [closureBuilder.Length - 1] == ',') { closureBuilder.Length -= 1; } closureBuilder.Append(")=>{"); var internals = InterpretExpression(expression, lambdaBlock); foreach (var statement in lambdaBlock.Statements) { closureBuilder.Append(statement).Append(";").Append(Environment.NewLine); } if (methodInfo.ReturnType != null) { closureBuilder.Append("return "); } closureBuilder.Append(internals.ExprString).Append(";"); closureBuilder.Append("}"); return(new Expr() { ExprString = closureBuilder.ToString() }); //return InterpretExpression (expression, block); }
public override void Interpret(Expression[] args, FunctionBlock block, Type contextType, string exprVal, out string newExprVal, out FunctionBlock newCurBlock, out Type newContextType, bool isLast) { Debug.Log("Has component scope"); IfStatement ifStatement = new IfStatement(); DeclareVariableStatement cmpStmt = new DeclareVariableStatement(); cmpStmt.IsTemp = true; cmpStmt.IsContext = true; ExprInter.CleanUpContextes.Push(cmpStmt); cmpStmt.Name = "cmp" + DeclareVariableStatement.VariableId++; cmpStmt.Type = Type; //cmpStmt.IsContext = true; var ctxVar = block.FindStatement <DeclareVariableStatement> (v => v.IsContext); string varName = ctxVar == null ? "root" : ctxVar.Name; cmpStmt.InitExpression = String.Format("({1}){0}.GetComponent(typeof({1}))", varName, Type); ifStatement.CheckExpression = String.Format("{0} != null", cmpStmt.Name); FunctionBlock newBlock = new FunctionBlock(block, block.Method, block.Type); ifStatement.TrueBlock = newBlock; block.Statements.Add(cmpStmt); block.Statements.Add(ifStatement); newCurBlock = newBlock; newExprVal = exprVal; newContextType = contextType; if (isLast) { var res = block.FindStatement <DeclareVariableStatement> (v => v.IsResult); res.Type = typeof(List <>).MakeGenericType(contextType); res.InitExpression = String.Format("new {0}()", TypeName.NameOf(res.Type)); newExprVal = res.Name; newBlock.Statements.Add(String.Format("{0}.Add({1});", res.Name, varName)); } //ifStatement.CheckExpression = String.Format("{0}.GetComponen") //ifStatement.CheckExpression = }
public override void Interpret(Expression[] args, FunctionBlock block, Type contextType, string exprVal, out string newExprVal, out FunctionBlock newCurBlock, out Type newContextType, bool isLast) { string rootRef = null; if (args.Length == 2) { rootRef = block.FindStatement <DeclareVariableStatement>(v => v.IsContext && v.Type == typeof(GameObject)).Name; } else { rootRef = ExprInter.InterpretExpression(args[1], block).ExprString; } var metricName = args[0].ToString().ClearFromBraces().Trim(' '); var otherRef = ExprInter.InterpretExpression(args.Length == 2 ? args[1] : args[2], block).ExprString; var varName = "metrics" + DeclareVariableStatement.VariableId++; block.Statements.Add("var {1} = {0} != null?{0}.GetComponent<Metrics>():null;".Fmt(rootRef, varName)); newExprVal = "({0} != null? {0}.Weight(\"{1}\", {2}) : 0f)".Fmt(varName, metricName, otherRef); newContextType = typeof(float); newCurBlock = block; }
public override void Interpret(Operator op, FunctionBlock block) { if (exprInter == null) { exprInter = Engine.GetPlugin <ExpressionInterpreter>(); } if (op.Args.Count > 0 && op.Args[0].Operands[0] is ExprAtom && (op.Args[0].Operands[0] as ExprAtom).Content is Scope && ((op.Args[0].Operands[0] as ExprAtom).Content as Scope).Parts.Count == 1) { var part = ((op.Args[0].Operands[0] as ExprAtom).Content as Scope).Parts[0]; if (!(part is string)) { Debug.Log("Wrong remove_from definition"); return; } var listName = NameTranslator.CSharpNameFromScript(part as string); DeclareVariableStatement declareVar = block.FindStatement <DeclareVariableStatement>(v => v.IsContext && v.Type.GetProperty(listName) != null); //Debug.Log (declareVar.DebugString ()); if (declareVar == null) { Debug.Log("remove_from operator can't find context variable"); } else { if (op.Context is Expression) { var exprValue = exprInter.InterpretExpression(op.Context as Expression, block); //block = exprValue.NotNullBlock; block.Statements.Add(String.Format("{0}.{1}.Remove({2});", declareVar.Name, listName, exprValue.ExprString)); } } } else { Debug.Log("Wrong remove_from definition"); } }
public override void Interpret(Expression[] args, FunctionBlock block, Type contextType, string exprVal, out string newExprVal, out FunctionBlock newCurBlock, out Type newContextType, bool isLast) { var varName = ((args [0].Operands [0] as ExprAtom).Content as Scope).Parts [0] as string; var valueExpr = args [1]; var exprData = Engine.GetPlugin <ExpressionInterpreter> ().InterpretExpression(valueExpr, block); newExprVal = exprVal; newCurBlock = block; newContextType = contextType; // if (exprData.Type != typeof(bool)) // block.Statements.Add ("return false;"); // block.Statements.Add (String.Format ("return {0};", exprData.ExprString)); var declVar = block.FindStatement <DeclareVariableStatement> (v => v.Name == varName && v.Type == exprData.Type); if (declVar != null) { Debug.Log("Adds set value"); block.Statements.Add(String.Format("{0} = {1};", varName, exprData.ExprString)); } else { Debug.LogErrorFormat("Unable to find var {0} in {1} of {2}", varName, block.Method, block.Type); } }
public override void Interpret(Operator op, FunctionBlock block) { interpret = false; if (exprInter == null) { switches = Engine.GetPlugin <ContextSwitchesPlugin> (); ops = Engine.GetPlugin <EventFunctionOperators> (); exprInter = Engine.GetPlugin <ExpressionInterpreter> (); } var varName = op.Identifier as string; if (ScriptEngine.AnalyzeDebug) { Debug.Log(block); } var sCtx = block.FindStatement <ContextStatement> (v => v.InterpretInContext(op, block) != null && (v.ContextVar.IsContext || v.ContextVar.IsArg)); var context = sCtx != null ? sCtx.ContextVar : null; if (ScriptEngine.AnalyzeDebug) { Debug.LogFormat("FOUND COUNTEXT {0} for {1}", context, op.Identifier); } if (listT == null) { if (op.Context is Expression) { if (ScriptEngine.AnalyzeDebug) { Debug.Log("PROPERTY " + propName); } if (context == null) { block.Statements.Add(String.Format("root.{0} = ({2})({1});", propName, exprInter.InterpretExpression(op.Context as Expression, block, propType).ExprString, TypeName.NameOf(propType))); } else { block.Statements.Add(String.Format("{2}.{0} = ({3})({1});", propName, exprInter.InterpretExpression(op.Context as Expression, block, propType).ExprString, context.Name, TypeName.NameOf(propType))); } } else if (typeof(Delegate).IsAssignableFrom(propType)) { Debug.Log("LAMBDA!"); //Interpret as lambda LambdaStatement lambda = new LambdaStatement(); lambda.DelegateType = propType; var method = propType.GetMethod("Invoke"); lambda.Params = method.GetParameters(); lambda.Name = "Lambda" + DeclareVariableStatement.VariableId++; block.Statements.Add(lambda); lambda.Block = new FunctionBlock(block); //DeclareVariableStatement lastVar = null; foreach (var param in lambda.Params) { var argVar = new DeclareVariableStatement(); // lastVar = argVar; argVar.Name = param.Name; argVar.IsArg = true; argVar.Type = param.ParameterType; lambda.Block.Statements.Add(argVar); } //if (lastVar != null) // lastVar.IsContext = true; var retType = lambda.DelegateType.GetMethod("Invoke").ReturnType; bool hasReturn = false; if (retType != null && retType != typeof(void)) { hasReturn = true; lambda.Block.Statements.Add(new DeclareVariableStatement() { Name = "return_value", InitExpression = string.Format("default({0})", retType), IsReturn = true, Type = retType }); } foreach (var entry in (op.Context as Context).Entries) { var subOp = entry as Operator; ops.GetInterpreter(subOp, lambda.Block).Interpret(subOp, lambda.Block); } if (hasReturn) { lambda.Block.Statements.Add("return return_value;"); } if (context == null) { block.Statements.Add(String.Format("root.{0} = ({2})({1});", propName, lambda.Name, TypeName.NameOf(propType))); } else { block.Statements.Add(String.Format("{2}.{0} = ({3})({1});", propName, lambda.Name, context.Name, TypeName.NameOf(propType))); } } else { return; } } else { //Debug.Log ("list of" + listT); ForStatement statement = new ForStatement(); string listVarContent = context == null ? "root." + propName : context.Name + "." + propName; string listVarName = "list" + DeclareVariableStatement.VariableId++; DeclareVariableStatement listVar = new DeclareVariableStatement(); listVar.IsTemp = true; listVar.Name = listVarName; listVar.InitExpression = listVarContent; listVar.Type = propType; block.Statements.Add(listVar); string iterName = "i" + DeclareVariableStatement.VariableId++; statement.InsideExpr = String.Format("int {0} = 0; {1} != null && {0} < {1}.Count; {0}++", iterName, listVarName); FunctionBlock repeatBlock = new FunctionBlock(block, block.Method, block.Type); statement.RepeatBlock = repeatBlock; block.Statements.Add(statement); Operator listVarOp = new Operator(); DeclareVariableStatement iterVar = new DeclareVariableStatement(); iterVar.Name = "iter" + DeclareVariableStatement.VariableId++; iterVar.IsContext = true; iterVar.IsNew = true; iterVar.Type = listT; iterVar.IsListIter = true; iterVar.InitExpression = String.Format("{0}[{1}]", listVarName, iterName); statement.RepeatBlock.Statements.Add(iterVar); var inter = switches.GetInterByType(listT); //Debug.Log(inter); inter.Interpret(op, repeatBlock); } interpret = true; }
public override void Interpret(Operator op, FunctionBlock block) { base.Interpret(op, block); if (interpret) { if (ScriptEngine.AnalyzeDebug) { Debug.LogFormat("Property {0} was interpreted by ContextPropertyInterpreter {1} already", op, propName); } return; } if (!(op.Context is Context)) { if (ScriptEngine.AnalyzeDebug) { Debug.LogFormat("Property context switch {0} has no context", op); } return; } if (ops == null) { ops = Engine.GetPlugin <EventFunctionOperators> (); } var varName = op.Identifier as string; FunctionBlock contextBlock = new FunctionBlock(block, block.Method, block.Type); block.Statements.Add(contextBlock); DeclareVariableStatement declareVar = new DeclareVariableStatement(); declareVar.Type = propType; declareVar.Name = "subContext" + DeclareVariableStatement.VariableId++; declareVar.IsContext = true; DeclareVariableStatement contextVar = block.FindStatement <DeclareVariableStatement> (v => v.Name == varName); if (contextVar == null) { var sCtx = block.FindStatement <ContextStatement> (v => v.InterpretInContext(op, block) != null && v.ContextVar.IsContext); contextVar = sCtx != null ? sCtx.ContextVar : null; } if (contextVar == null) { declareVar.InitExpression = String.Format("root.{0}", propName); } else { declareVar.InitExpression = String.Format("{1}.{0}", propName, contextVar.Name); } contextBlock.Statements.Add(declareVar); contextBlock.Statements.Add(new ContextStatement() { ContextVar = declareVar, InterpretInContext = InterpretInContext }); IfStatement isNotNull = new IfStatement(); isNotNull.CheckExpression = String.Format("{0} != null", declareVar.Name); isNotNull.TrueBlock = new FunctionBlock(contextBlock); contextBlock.Statements.Add(isNotNull); contextBlock = isNotNull.TrueBlock; foreach (var entry in (op.Context as Context).Entries) { //Debug.LogFormat("Interpreting {0} as part of {1} context", (entry as Operator).Identifier, op.Identifier); var subOp = entry as Operator; if (subOp == null) { continue; } FunctionOperatorInterpreter opInter = null; if ((opInter = ops.GetInterpreter(subOp, contextBlock)) == null) { if (!contextSwitches.TryGetValue(subOp.Identifier as string, out opInter)) { if (!functions.TryGetValue(subOp.Identifier as string, out opInter)) { if (!properties.TryGetValue(subOp.Identifier as string, out opInter)) { //Debug.LogFormat ("Can't interpret context operator {1} in {0}", block.Method.Name, subOp.Identifier); continue; } } } } opInter.Interpret(subOp, contextBlock); } }
public override void Interpret(Operator op, FunctionBlock block) { interpret = false; if (exprInter == null) { switches = Engine.GetPlugin <ContextSwitchesPlugin> (); ops = Engine.GetPlugin <EventFunctionOperators> (); exprInter = Engine.GetPlugin <ExpressionInterpreter> (); } var varName = op.Identifier as string; if (ScriptEngine.AnalyzeDebug) { Debug.Log(block); } var sCtx = block.FindStatement <ContextStatement> (v => v.InterpretInContext(op, block) != null && v.ContextVar.IsContext || v.ContextVar.IsArg); var context = sCtx != null ? sCtx.ContextVar : null; if (ScriptEngine.AnalyzeDebug) { Debug.LogFormat("FOUND COUNTEXT {0} for {1}", context, op.Identifier); } if (listT == null) { if (!(op.Context is Expression)) { return; } if (ScriptEngine.AnalyzeDebug) { Debug.Log("PROPERTY " + propName); } if (context == null) { block.Statements.Add(String.Format("root.{0} = ({2})({1});", propName, exprInter.InterpretExpression(op.Context as Expression, block).ExprString, TypeName.NameOf(propType))); } else { block.Statements.Add(String.Format("{2}.{0} = ({3})({1});", propName, exprInter.InterpretExpression(op.Context as Expression, block).ExprString, context.Name, TypeName.NameOf(propType))); } } else { Debug.Log("list of" + listT); ForStatement statement = new ForStatement(); string listVarName = context == null ? "root." + propName : context.Name + "." + propName; string iterName = "i" + DeclareVariableStatement.VariableId++; statement.InsideExpr = String.Format("int {0} = 0; {1} != null && {0} < {1}.Count; {0}++", iterName, listVarName); FunctionBlock repeatBlock = new FunctionBlock(block, block.Method, block.Type); statement.RepeatBlock = repeatBlock; block.Statements.Add(statement); Operator listVarOp = new Operator(); DeclareVariableStatement listVar = new DeclareVariableStatement(); listVar.Name = "iter" + DeclareVariableStatement.VariableId++; listVar.IsContext = true; listVar.IsNew = true; listVar.Type = listT; listVar.InitExpression = String.Format("{0}[{1}]", listVarName, iterName); statement.RepeatBlock.Statements.Add(listVar); var inter = switches.GetInterByType(listT); //Debug.Log(inter); inter.Interpret(op, repeatBlock); } interpret = true; }
public override void Interpret(Operator op, FunctionBlock block) { if (ScriptEngine.AnalyzeDebug) { Debug.LogWarning("Context function " + op.Identifier); } if (exprInter == null) { exprInter = Engine.GetPlugin <ExpressionInterpreter> (); } var any = BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static; var sCtx = block.FindStatement <ContextStatement> (v => v.InterpretInContext(op, block) != null && (v.ContextVar.IsContext || v.ContextVar.IsArg)); var contextVar = sCtx != null ? sCtx.ContextVar : null; //var contextVar = block.FindStatement<DeclareVariableStatement> (v => ); StringBuilder argsBuilder = new StringBuilder(); // if (((op.Context is Expression) && op.Args.Count + 1 != argsDef.Length) || // ((op.Context is Context) && op.Args.Count != argsDef.Length)) // { // Debug.Log ("Wrong amount of arguments"); // return; // } for (int i = 0; i < op.Args.Count; i++) { if (argsDef [i].ParameterType.IsSubclassOf(typeof(Delegate))) { argsBuilder.Append(exprInter.InterpretClosure(op.Args [i], block, argsDef [i].ParameterType).ExprString).Append(","); } else if (argsDef [i].ParameterType == typeof(string)) { argsBuilder.Append('(').Append(exprInter.InterpretExpression(op.Args [i], block).ExprString).Append(')').Append(".ToString()").Append(","); } else { argsBuilder.Append('(').Append(argsDef [i].ParameterType).Append(')').Append('(').Append(exprInter.InterpretExpression(op.Args [i], block).ExprString).Append(')').Append(","); } } if (op.Context is Expression) { if (argsDef [argsDef.Length - 1].ParameterType.IsSubclassOf(typeof(Delegate))) { argsBuilder. Append('('). Append(argsDef [argsDef.Length - 1].ParameterType). Append(')'). Append('('). Append(exprInter.InterpretClosure(op.Context as Expression, block, argsDef [argsDef.Length - 1].ParameterType).ExprString). Append(')'); } else if (argsDef [argsDef.Length - 1].ParameterType == typeof(string)) { argsBuilder.Append('(').Append(exprInter.InterpretExpression(op.Context as Expression, block).ExprString).Append(')').Append(".ToString()"); } else { argsBuilder. Append('('). Append(argsDef [argsDef.Length - 1].ParameterType). Append(')'). Append('('). Append(exprInter.InterpretExpression(op.Context as Expression, block).ExprString). Append(')'); } if (contextVar == null) { block.Statements.Add(string.Format("root.{0}({1});", funcName, argsBuilder)); } else { block.Statements.Add(string.Format("{2}.{0}({1});", funcName, argsBuilder, contextVar.Name)); } } else if (ctxInter != null) { if (op.Args.Count > 0) { argsBuilder.Length -= 1; } var ctx = op.Context as Context; FunctionBlock contextBlock = new FunctionBlock(block); block.Statements.Add(contextBlock); block = contextBlock; DeclareVariableStatement ctxVar = new DeclareVariableStatement(); ctxVar.Name = "FuncCtx" + DeclareVariableStatement.VariableId++; ctxVar.InitExpression = contextVar == null?string.Format("root.{0}({1});", funcName, argsBuilder) : string.Format("{2}.{0}({1});", funcName, argsBuilder, contextVar.Name); ctxVar.Type = returnType; ctxVar.IsContext = true; ContextStatement stmt = new ContextStatement(); stmt.ContextVar = ctxVar; stmt.InterpretInContext = ctxInter.InterpretInContext; block.Statements.Add(ctxVar); block.Statements.Add(stmt); IfStatement isNotNull = new IfStatement(); isNotNull.CheckExpression = String.Format("{0} != null", ctxVar.Name); isNotNull.TrueBlock = new FunctionBlock(block); block.Statements.Add(isNotNull); block = isNotNull.TrueBlock; for (int i = 0; i < ctx.Entries.Count; i++) { ops.GetInterpreter(ctx.Entries [i] as Operator, block).Interpret(ctx.Entries [i] as Operator, block); } } else { //Func doesn't return a context, while maybe allows for either lambda as value or context addition var lastArg = argsDef.Length > 0 ? argsDef [argsDef.Length - 1] : null; if (lastArg != null) { if (typeof(Delegate).IsAssignableFrom(lastArg.ParameterType)) { Debug.Log("LAMBDA!"); //Interpret as lambda LambdaStatement lambda = new LambdaStatement(); lambda.DelegateType = lastArg.ParameterType; var method = lastArg.ParameterType.GetMethod("Invoke"); lambda.Params = method.GetParameters(); lambda.Name = "Lambda" + DeclareVariableStatement.VariableId++; block.Statements.Add(lambda); lambda.Block = new FunctionBlock(block); //DeclareVariableStatement lastVar = null; foreach (var param in lambda.Params) { var argVar = new DeclareVariableStatement(); // lastVar = argVar; argVar.Name = param.Name; argVar.IsArg = true; argVar.Type = param.ParameterType; lambda.Block.Statements.Add(argVar); } //if (lastVar != null) // lastVar.IsContext = true; var retType = lambda.DelegateType.GetMethod("Invoke").ReturnType; bool hasReturn = false; if (retType != null && retType != typeof(void)) { hasReturn = true; lambda.Block.Statements.Add(new DeclareVariableStatement() { Name = "return_value", InitExpression = string.Format("default({0})", retType), IsReturn = true, Type = retType }); } foreach (var entry in (op.Context as Context).Entries) { var subOp = entry as Operator; ops.GetInterpreter(subOp, lambda.Block).Interpret(subOp, lambda.Block); } if (hasReturn) { lambda.Block.Statements.Add("return return_value;"); } //Don't forget to call a function and add an arugment argsBuilder.Append(lambda.Name); if (contextVar == null) { block.Statements.Add(string.Format("root.{0}({1});", funcName, argsBuilder)); } else { block.Statements.Add(string.Format("{2}.{0}({1});", funcName, argsBuilder, contextVar.Name)); } } else if (addContextInter != null) { //Interpret as new value DeclareVariableStatement newVar = new DeclareVariableStatement(); newVar.Name = "NewArg" + DeclareVariableStatement.VariableId++; newVar.IsContext = true; newVar.Type = lastArg.ParameterType; if (contextVar == null) { newVar.InitExpression = String.Format("root.AddComponent<{0}>()", newVar.Type); } else { newVar.InitExpression = String.Format("{0}.AddComponent<{0}>()", contextVar.Name, newVar.Type); } FunctionBlock contextBlock = new FunctionBlock(block); contextBlock.Statements.Add(newVar); addContextInter.Interpret(op, contextBlock); argsBuilder.Append(newVar.Name); if (contextVar == null) { contextBlock.Statements.Add(string.Format("root.{0}({1});", funcName, argsBuilder)); } else { contextBlock.Statements.Add(string.Format("{2}.{0}({1});", funcName, argsBuilder, contextVar.Name)); } block.Statements.Add(contextBlock); } } } }
public override void Interpret(Operator op, FunctionBlock block) { if (ops == null) { ops = Engine.GetPlugin <EventFunctionOperators> (); } FunctionBlock contextBlock = new FunctionBlock(block, block.Method, block.Type); block.Statements.Add(contextBlock); DeclareVariableStatement addVar = block.FindStatement <DeclareVariableStatement> (v => v.Name == op.Identifier as string); bool setContext = false; if (addVar != null && !addVar.IsContext) { setContext = addVar.IsContext = true; } if (addVar == null) { addVar = block.FindStatement <DeclareVariableStatement> (v => v.IsContext && v.Type == contextType); } //TODO: probably will fail DeclareVariableStatement contextVar = contextType == typeof(GameObject)? addVar : block.FindStatement <DeclareVariableStatement> (v => v.IsContext && v.Type == typeof(GameObject) && v != addVar); DeclareVariableStatement declareVar = null; if (addVar == null) { declareVar = new DeclareVariableStatement(); declareVar.Type = contextType; declareVar.Name = "subContext" + DeclareVariableStatement.VariableId++; declareVar.IsContext = true; if (contextVar == null) { declareVar.InitExpression = String.Format("({0})root.GetComponent(typeof({0}))", contextType); } else { declareVar.InitExpression = String.Format("({0}){1}.GetComponent(typeof({0}))", contextType, contextVar.Name); } contextBlock.Statements.Add(declareVar); } else { declareVar = addVar; } contextBlock.Statements.Add(new ContextStatement() { ContextVar = declareVar, InterpretInContext = InterpretInContext }); IfStatement isNotNull = new IfStatement(); isNotNull.CheckExpression = String.Format("{0} != null", declareVar.Name); isNotNull.TrueBlock = new FunctionBlock(contextBlock); contextBlock.Statements.Add(isNotNull); contextBlock = isNotNull.TrueBlock; contextBlock.Statements.Add(new DeclareVariableStatement() { Name = declareVar.Name, IsArg = true, IsContext = true, Type = declareVar.Type }); foreach (var entry in (op.Context as Context).Entries) { var subOp = entry as Operator; if (subOp == null) { continue; } FunctionOperatorInterpreter opInter = null; if ((opInter = ops.GetInterpreter(subOp, contextBlock)) == null) { if (!contextSwitches.TryGetValue(subOp.Identifier as string, out opInter)) { if (!functions.TryGetValue(subOp.Identifier as string, out opInter)) { if (!properties.TryGetValue(subOp.Identifier as string, out opInter)) { Debug.LogWarningFormat("Can't interpret context operator {1} in {0}", block.Method.Name, subOp.Identifier); continue; } } } } if (ScriptEngine.AnalyzeDebug) { Debug.LogFormat("Interpret {0} via {1}", subOp.Identifier, opInter); } opInter.Interpret(subOp, contextBlock); } if (setContext) { addVar.IsContext = false; } }
public FunctionOperatorInterpreter GetInterpreter(Operator op, FunctionBlock block) { FunctionOperatorInterpreter inter = null; if (op.Identifier as string == null) { exprInter.TransformScopedOperator(op, block); if (ScriptEngine.AnalyzeDebug) { Debug.Log("Transformed op " + op.ToString()); } } interpreters.TryGetValue(op.Identifier as string, out inter); if (inter == null) { var customVar = block.FindStatement <DeclareVariableStatement> (v => v.Name == (op.Identifier as string)); if (customVar == null) { foreach (var interPair in interpreters) { if (interPair.Value.Match(op, block)) { return(interPair.Value); } } var context = block.FindStatement <ContextStatement> (c => (inter = c.InterpretInContext(op, block)) != null); if (ScriptEngine.AnalyzeDebug) { if (context != null) { Debug.LogFormat("{0} is not an operator of context, found one {1}", op.Identifier, context.ContextVar); } else { Debug.LogWarningFormat("{0} is not an operator of context, not found one", op.Identifier); } } // if (context != null) // inter = context.InterpretInContext (op, block); if (inter == null && op.Context is Expression) { VarDeclareInterpreter declInter = new VarDeclareInterpreter(); declInter.Inter = exprInter; inter = declInter; } } else { if (op.Context is Expression) { VarAssignInterpreter varInter = new VarAssignInterpreter(); varInter.Var = customVar; varInter.Inter = exprInter; inter = varInter; } else { inter = switches.GetInterByType(customVar.Type); } //if(op.Context is Expression) } } if (ScriptEngine.AnalyzeDebug) { Debug.LogFormat("{0} - {1}", op, inter); } return(inter); }
void CreateEventFunction(string name, object context, CodeTypeDeclaration codeType, MethodInfo baseMethod, params object[] initStatements) { CodeMemberMethod method = new CodeMemberMethod(); method.Name = NameTranslator.CSharpNameFromScript(name); method.Attributes = MemberAttributes.Override | MemberAttributes.Public; method.ReturnType = new CodeTypeReference(baseMethod.ReturnType); var args = baseMethod.GetParameters(); FunctionBlock block = new FunctionBlock(null, method, codeType); block.Statements.Add("var root = this.root;"); //block.Statements.Add ("UnityEngine.Debug.Log(root.ToString() + IfStatement.AntiMergeValue++);"); var externVar = new DeclareVariableStatement() { Name = "External", IsArg = true, Type = Engine.GetType("External") }; block.Statements.Add(externVar); block.Statements.Add(new ContextStatement() { ContextVar = externVar, InterpretInContext = Engine.GetPlugin <ExternalFunctionsPlugin>().Ctx.InterpretInContext }); foreach (var initStmt in initStatements) { block.Statements.Add(initStmt); } //bool hasRoot = false; foreach (var arg in args) { //if (arg.Name == "root") // hasRoot = true; method.Parameters.Add(new CodeParameterDeclarationExpression(arg.ParameterType, arg.Name)); var paramVar = new DeclareVariableStatement(); paramVar.Name = arg.Name; paramVar.Type = arg.ParameterType; paramVar.IsArg = true; block.Statements.Add(paramVar); } var rootVar = new DeclareVariableStatement(); rootVar.Name = "root"; rootVar.Type = typeof(GameObject); rootVar.IsArg = true; block.Statements.Add(rootVar); foreach (var member in codeType.Members) { var field = member as CodeMemberField; if (field != null) { var cachedVar = new DeclareVariableStatement(); cachedVar.Name = field.Name; cachedVar.Type = field.UserData ["type"] as Type; cachedVar.IsArg = true; block.Statements.Add(cachedVar); } } //if (!hasRoot) //{ // Debug.LogFormat ("Method {0} in {1} has no root arg", baseMethod.Name, codeType.Name); // return; //} codeType.Members.Add(method); var table = context as Context; if (table != null) { foreach (var entry in table.Entries) { Operator op = entry as Operator; var inter = functionOperators.GetInterpreter(op, block); if (inter == null) { Debug.LogFormat("Can't find interpreter for operator {0} in {1} of {2}", op.Identifier, baseMethod.Name, codeType.Name); continue; } inter.Interpret(op, block); } var retVal = block.FindStatement <DeclareVariableStatement> (v => v.IsReturn); if (retVal != null) { block.Statements.Add(String.Format("return {0};", retVal.Name)); } } else { var expr = context as Expression; var retVal = block.FindStatement <DeclareVariableStatement> (v => v.IsReturn); //retVal.IsArg = true; block.Statements.Add(String.Format("return ({1}){0};", exprInter.InterpretExpression(expr, block).ExprString, TypeName.NameOf(retVal.Type))); } method.Statements.Add(new CodeSnippetStatement(block.ToString())); }
public override void Interpret(InternalDSL.Operator op, FunctionBlock block) { if (ops == null) { ctxs = Engine.GetPlugin <ContextSwitchesPlugin> (); ops = Engine.GetPlugin <EventFunctionOperators> (); exprInter = Engine.GetPlugin <ExpressionInterpreter> (); } if (op.Args.Count > 0) { var varName = ((op.Args [0].Operands [0] as ExprAtom).Content as Scope).Parts [0] as string; if (op.Context is Expression) { //cache(some_name) = expression // var varDecl = block.FindStatement<DeclareVariableStatement> (v => v.Name == varName); // varDecl.IsArg = true; var exprValue = exprInter.InterpretExpression(op.Context as Expression, block); Debug.Log(exprValue.ExprString); var field = new CodeMemberField(exprValue.Type, varName); field.UserData.Add("type", exprValue.Type); block.Type.Members.Add(field); block.Statements.Add(String.Format("{0} = {1};", varName, exprValue.ExprString)); block.Statements.Add(new DeclareVariableStatement() { Name = varName, IsArg = true, Type = exprValue.Type }); //var varDecl = block.FindStatement<DeclareVariableStatement> (v => v.Name == varName); } else { //cache(some_name, scope) = { ... } var exprValue = exprInter.InterpretExpression(op.Args [1], block); var field = new CodeMemberField(exprValue.Type, varName); field.UserData.Add("type", exprValue.Type); block.Type.Members.Add(field); DeclareVariableStatement cachedVar = new DeclareVariableStatement(); cachedVar.Name = varName; cachedVar.IsContext = true; cachedVar.Type = exprValue.Type; cachedVar.IsArg = true; block.Statements.Add(cachedVar); block.Statements.Add(String.Format("{0} = {1};", varName, exprValue.ExprString)); block.Statements.Add(new DeclareVariableStatement() { Name = varName, IsArg = true, Type = exprValue.Type }); var inter = ctxs.GetInterByType(exprValue.Type); inter.Interpret(op, block); } } else { //cache = some_name var varName = (((op.Context as Expression).Operands [0] as ExprAtom).Content as Scope).Parts [0] as string; var varDecl = block.FindStatement <DeclareVariableStatement> (v => v.Name == varName); //varDecl.IsArg = true; varDecl.IsDeclaration = false; var field = new CodeMemberField(varDecl.Type, varDecl.Name); field.UserData.Add("type", varDecl.Type); block.Type.Members.Add(field); //block.Statements.Add (String.Format ("this.{0} = {0};", varName)); } //new CodeMemberField() //block.Type.Members.Add (); }
public override void Interpret(Operator op, FunctionBlock block) { if (ops == null) { ops = Engine.GetPlugin <EventFunctionOperators> (); switches = Engine.GetPlugin <ContextSwitchesPlugin> (); var cmps = Engine.FindTypesCastableTo <MonoBehaviour> (); foreach (var cmp in cmps) { components.Add(NameTranslator.ScriptNameFromCSharp(cmp.Name), cmp); } } //add = cmp_type - no args, context is Expression //add(var) = cmp_type - 1 arg, context is Expression //add(cmp_type) = { ... } - 1 arg, context is Context //add(var, cmp_type) = { ... } - 2 args, context is Context DeclareVariableStatement cmpVar = null; DeclareVariableStatement contextVar = block.FindStatement <DeclareVariableStatement> (v => (v.IsContext | v.IsArg) && v.Type == typeof(GameObject)); string ctxVar = contextVar == null ? "root" : contextVar.Name; string cmpTypeName = null; try { if (op.Args.Count == 0) { var expr = op.Context as Expression; if (expr != null) { var cmpType = (((op.Context as Expression).Operands[0] as ExprAtom).Content as Scope).Parts[0] as string; block.Statements.Add(string.Format("{0}.AddComponent<{1}>();", ctxVar, components[cmpType])); } } else if (op.Args.Count == 1) { var ctx = op.Context as Context; var expr = op.Context as Expression; if (expr != null) { cmpTypeName = (((op.Context as Expression).Operands[0] as ExprAtom).Content as Scope).Parts[0] as string; var varName = ((op.Args[0].Operands[0] as ExprAtom).Content as Scope).Parts[0] as string; var cmpType = components[cmpTypeName]; cmpVar = new DeclareVariableStatement(); cmpVar.InitExpression = string.Format("{0}.AddComponent<{1}>();", ctxVar, cmpType); cmpVar.Type = cmpType; cmpVar.Name = varName; cmpVar.IsNew = true; cmpVar.IsContext = true; block.Statements.Add(cmpVar); } else if (ctx != null) { cmpTypeName = ((op.Args[0].Operands[0] as ExprAtom).Content as Scope).Parts[0] as string; var cmpType = components[cmpTypeName]; cmpVar = new DeclareVariableStatement(); cmpVar.InitExpression = string.Format("{0}.AddComponent<{1}>();", ctxVar, cmpType); cmpVar.Type = cmpType; cmpVar.IsContext = true; cmpVar.IsNew = true; cmpVar.Name = "ContextVar" + DeclareVariableStatement.VariableId++; block.Statements.Add(cmpVar); switches.GetInterByType(cmpType).Interpret(op, block); } } else if (op.Args.Count == 2) { var ctx = op.Context as Context; if (ctx != null) { cmpTypeName = ((op.Args[1].Operands[0] as ExprAtom).Content as Scope).Parts[0] as string; var varName = ((op.Args[0].Operands[0] as ExprAtom).Content as Scope).Parts[0] as string; var cmpType = components[cmpTypeName]; cmpVar = new DeclareVariableStatement(); cmpVar.InitExpression = string.Format("{0}.AddComponent<{1}>();", ctxVar, cmpType); cmpVar.Type = cmpType; cmpVar.IsContext = true; cmpVar.IsNew = true; cmpVar.Name = varName; block.Statements.Add(cmpVar); switches.GetInterByType(cmpType).Interpret(op, block); } } var entVar = block.FindStatement <DeclareVariableStatement>(v => v.ctxEntity == ctxVar && v.Type == typeof(Entity)); if (entVar == null) { entVar = new DeclareVariableStatement(); entVar.Name = "EntVar" + DeclareVariableStatement.VariableId++; entVar.Type = typeof(Entity); entVar.ctxEntity = ctxVar; entVar.InitExpression = String.Format("(Entity){0}.GetComponent(typeof(Entity));", ctxVar); block.Statements.Add(entVar); var updateSt = new StatementStringContainer(String.Format("if({0} != null) {0}.ComponentAdded();", entVar.Name)); entVar.Cnt = updateSt; block.Statements.Add(updateSt); } else { var updateSt = new StatementStringContainer(entVar.Cnt.Data); entVar.Cnt.Data = ""; entVar.Cnt = updateSt; block.Statements.Add(updateSt); } if (cmpVar != null) { cmpVar.IsContext = false; } } catch (KeyNotFoundException e) { Debug.LogErrorFormat("Can't create {0} in {1}", cmpTypeName, op); } }
public Expr ProcessOperand(object operand, FunctionBlock block, bool isInsideBoolean = false) { Expr returnExpr = new Expr(); StringBuilder exprBuilder = new StringBuilder(); bool hasSign = false; DeclareVariableStatement resultVar = new DeclareVariableStatement(); resultVar.IsHidden = true; int insertResultIndex = block.Statements.Count; block.Statements.Add(""); char signChar = ' '; if (operand is ExprAtom) { if ((operand as ExprAtom).Op == ExprAtom.UnaryOp.Inverse) { signChar = '!'; } else if ((operand as ExprAtom).Op == ExprAtom.UnaryOp.Not) { signChar = '-'; } operand = (operand as ExprAtom).Content; } BindingFlags any = BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public; if (operand is Scope) { //bool exprIsResultVar = false; var scope = (operand as Scope).Parts; bool contextVariable = true; var contextVar = block.FindStatement <DeclareVariableStatement> (v => v.Name == scope [0] as string); if (contextVariable = (contextVar == null)) { contextVar = block.FindStatement <DeclareVariableStatement> (v => v.IsContext); } if (ScriptEngine.AnalyzeDebug) { Debug.LogWarningFormat("S_CTX {0} {1}", contextVar, operand); } string contextName = null; //!contextVariable ? "root" : contextVar.Name; Type contextType = null; //!contextVariable ? typeof(GameObject) : contextVar.Type; if (contextVar == null) { contextName = block.DefaultScope; contextType = typeof(GameObject); } else { contextName = contextVar.Name; contextType = contextVar.Type; } exprBuilder.Append(contextName).Append("."); bool firstTimeList = true; FunctionBlock curBlock = block; for (int i = contextVariable ? 0 : 1; i < scope.Count; i++) { if (ScriptEngine.AnalyzeDebug) { Debug.LogWarningFormat("scope part {0} {1} {2}", scope [i], contextType.IsGenericType, contextType.IsGenericType ? (contextType.GetGenericTypeDefinition() == typeof(List <>)).ToString() : ""); } if (contextType.IsGenericType && contextType.GetGenericTypeDefinition() == typeof(List <>)) { if (firstTimeList) { CleanUpContextes.Push(resultVar); resultVar.IsTemp = true; resultVar.Name = "result" + DeclareVariableStatement.VariableId++; block.Statements [insertResultIndex] = resultVar; resultVar.IsHidden = false; resultVar.IsResult = true; //resultList.Type = contextType; //exprIsResultVar = true; firstTimeList = false; } Debug.Log("scope list " + scope [i]); DeclareVariableStatement declVar = new DeclareVariableStatement(); CleanUpContextes.Push(declVar); declVar.IsTemp = true; declVar.Name = "list" + DeclareVariableStatement.VariableId++; declVar.Type = contextType; if (exprBuilder [exprBuilder.Length - 1] == '.') { exprBuilder.Length -= 1; } if (hasSign) { declVar.InitExpression = exprBuilder.ToString(1, exprBuilder.Length - 1); exprBuilder.Length = 1; //exprBuilder.Append (declVar.Name).Append ('.'); } else { declVar.InitExpression = exprBuilder.ToString(); exprBuilder.Length = 0; //exprBuilder.Append (declVar.Name).Append ('.'); } curBlock.Statements.Add(declVar); ForStatement forStatement = new ForStatement(); forStatement.RepeatBlock = new FunctionBlock(block, block.Method, block.Type); var repeatContext = new DeclareVariableStatement(); repeatContext.IsTemp = true; CleanUpContextes.Push(repeatContext); forStatement.RepeatBlock.Statements.Add(repeatContext); curBlock.Statements.Add(forStatement); curBlock = forStatement.RepeatBlock; var iterName = "i" + DeclareVariableStatement.VariableId++; forStatement.InsideExpr = String.Format(@"int {0} = 0; {0} < {1}.Count; {0}++", iterName, declVar.Name); contextType = contextType.GetGenericArguments() [0]; repeatContext.Name = "SubContext" + DeclareVariableStatement.VariableId++; repeatContext.Type = contextType; repeatContext.IsContext = true; repeatContext.InitExpression = String.Format(@"{0}[{1}]", declVar.Name, iterName); } bool isFunc = false; if (scope [i] is FunctionCall || scope [i] is string) { // var callOp = ProcessOperand (scope [i], block); Expression[] callArgs = defaultArgsList; string callName = null; var call = scope [i] as FunctionCall; if (call != null) { callName = call.Name; callArgs = call.Args; } else { callName = scope [i] as string; } if (scopeInterpreters.ContainsKey(callName)) { var interpreter = scopeInterpreters [callName]; string outExpr = null; interpreter.Interpret(callArgs, curBlock, contextType, exprBuilder.ToString(), out outExpr, out curBlock, out contextType, i == scope.Count - 1); if (hasSign) { exprBuilder.Length = 1; exprBuilder.Append(outExpr).Append('.'); } else { exprBuilder.Length = 0; exprBuilder.Append(outExpr).Append('.'); } isFunc = true; } else { var methodName = NameTranslator.CSharpNameFromScript(callName); var method = contextType.GetMethod(methodName); if (i == 0 && method == null) { var otherContext = block.FindStatement <DeclareVariableStatement> (v => (v.IsContext || v.IsArg) && (method = v.Type.GetMethod(methodName, any)) != null); if (otherContext != null) { exprBuilder.Length = hasSign ? 1 : 0; if (ScriptEngine.AnalyzeDebug) { Debug.LogWarning("OTHER CONTEXT" + otherContext.DebugString()); } exprBuilder.Append(otherContext.Name).Append('.'); contextType = otherContext.Type; } else { if (ScriptEngine.AnalyzeDebug) { Debug.LogWarning("Can't find context for method " + methodName); } block.FindStatement <DeclareVariableStatement> (v => { if (ScriptEngine.AnalyzeDebug) { Debug.LogFormat("{0} {1} {3} ||||{2}", v.Name, v.Type, IfStatement.AntiMergeValue++, v.IsContext || v.IsArg); } return(false); }); } } if (method == null) { if (ScriptEngine.AnalyzeDebug) { Debug.LogFormat("Can't find {0} in {1}", NameTranslator.CSharpNameFromScript(callName), contextType); } } else { exprBuilder.Append(method.Name).Append("("); var argsDef = method.GetParameters(); if (callArgs != null) { for (int j = 0; j < callArgs.Length; j++) { if (argsDef [j].ParameterType.IsSubclassOf(typeof(Delegate))) { exprBuilder.Append(InterpretClosure(callArgs [j], curBlock, argsDef [j].ParameterType).ExprString).Append(","); } else { exprBuilder.Append(InterpretExpression(callArgs [j], curBlock).ExprString).Append(","); } } if (callArgs.Length > 0) { exprBuilder.Length -= 1; } } exprBuilder.Append(")"); contextType = method.ReturnType; var declVar = new DeclareVariableStatement(); CleanUpContextes.Push(declVar); declVar.IsTemp = true; declVar.Name = "prop" + DeclareVariableStatement.VariableId++; declVar.IsContext = true; if (exprBuilder.Length > 0 && exprBuilder [exprBuilder.Length - 1] == '.') { exprBuilder.Length -= 1; } if (hasSign) { declVar.InitExpression = exprBuilder.ToString(1, exprBuilder.Length - 1); exprBuilder.Length = 1; exprBuilder.Append(declVar.Name).Append('.'); } else { declVar.InitExpression = exprBuilder.ToString(); exprBuilder.Length = 0; exprBuilder.Append(declVar.Name).Append('.'); } declVar.Type = contextType; curBlock.Statements.Add(declVar); if (contextType.IsClass) { IfStatement ifSt = new IfStatement(); ifSt.CheckExpression = String.Format("{0} != null", declVar.Name); ifSt.TrueBlock = new FunctionBlock(curBlock); curBlock.Statements.Add(ifSt); curBlock = ifSt.TrueBlock; } isFunc = true; } } } if (!isFunc) { var propName = NameTranslator.CSharpNameFromScript(scope [i] as string); var prop = contextType.GetProperty(propName); if (i == 0 && prop == null) { var customVar = block.FindStatement <DeclareVariableStatement> (v => v.Name == scope [i] as string); if (customVar == null) { var otherContext = block.FindStatement <DeclareVariableStatement> (v => { //Debug.LogWarning (v.Type); //Debug.Log (v.IsContext || v.IsArg); //var props = v.Type.GetProperties (any); //foreach (var allProp in props) // Debug.Log (allProp.Name); return((v.IsContext || v.IsArg) && (prop = v.Type.GetProperty(propName, any)) != null); }); if (otherContext != null) { exprBuilder.Length = hasSign ? 1 : 0; exprBuilder.Append(otherContext.Name).Append('.'); contextType = otherContext.Type; if (contextType.IsClass && !prop.GetGetMethod().IsStatic) { IfStatement ifSt = new IfStatement(); ifSt.CheckExpression = String.Format("{0} != null", otherContext.Name); ifSt.TrueBlock = new FunctionBlock(curBlock); curBlock.Statements.Add(ifSt); curBlock = ifSt.TrueBlock; } } else if (ScriptEngine.AnalyzeDebug) { Debug.LogWarning("Can't find context for property " + propName); } } else { exprBuilder.Length = hasSign ? 1 : 0; exprBuilder.Append(customVar.Name).Append('.'); contextType = customVar.Type; if (contextType.IsClass && !prop.GetGetMethod().IsStatic) { IfStatement ifSt = new IfStatement(); ifSt.CheckExpression = String.Format("{0} != null", customVar.Name); ifSt.TrueBlock = new FunctionBlock(curBlock); curBlock.Statements.Add(ifSt); curBlock = ifSt.TrueBlock; } } } if (ScriptEngine.AnalyzeDebug) { Debug.LogWarning(prop); } if (prop == null && components.ContainsKey(scope [i] as string)) { var type = components [scope [i] as string]; string storedFromName = null; if (hasSign) { storedFromName = exprBuilder.ToString(1, exprBuilder.Length - 1); } else { storedFromName = exprBuilder.ToString(); } if (ScriptEngine.AnalyzeDebug) { Debug.LogWarning("Component found " + type); } var storedVar = curBlock.FindStatement <DeclareVariableStatement> (v => v.Type == type && v.storedOf != null && storedFromName == v.storedOf); contextType = type; if (storedVar == null) { storedVar = new DeclareVariableStatement(); CleanUpContextes.Push(storedVar); storedVar.IsTemp = true; storedVar.IsContext = true; curBlock.Statements.Add(storedVar); //block.FindStatement<DeclareVariableStatement> (v => !v.IsContext && v.Type == type); storedVar.Name = "StoredVariable" + DeclareVariableStatement.VariableId++; storedVar.Type = type; storedVar.storedOf = hasSign ? exprBuilder.ToString(1, exprBuilder.Length) : exprBuilder.ToString(0, exprBuilder.Length); exprBuilder.Append(String.Format("GetComponent(typeof({0})))", type)); exprBuilder.Insert(0, String.Format("(({0})", type)); if (hasSign) { storedVar.InitExpression = exprBuilder.ToString(1, exprBuilder.Length - 1); exprBuilder.Length = 1; exprBuilder.Append(storedVar.Name).Append('.'); } else { storedVar.InitExpression = exprBuilder.ToString(); exprBuilder.Length = 0; exprBuilder.Append(storedVar.Name).Append('.'); } } if (hasSign) { exprBuilder.Length = 1; exprBuilder.Append(storedVar.Name).Append('.'); } else { exprBuilder.Length = 0; exprBuilder.Append(storedVar.Name).Append('.'); } if (contextType.IsClass) { IfStatement ifSt = new IfStatement(); ifSt.CheckExpression = String.Format("{0} != null", storedVar.Name); ifSt.TrueBlock = new FunctionBlock(curBlock); curBlock.Statements.Add(ifSt); curBlock = ifSt.TrueBlock; } } else if (scopeInterpreters.ContainsKey(scope [i] as string)) { var interpreter = scopeInterpreters [scope [i] as string]; string outExpr = null; interpreter.Interpret(null, curBlock, contextType, exprBuilder.ToString(), out outExpr, out curBlock, out contextType, i == scope.Count - 1); if (hasSign) { exprBuilder.Length = 1; exprBuilder.Append(outExpr).Append('.'); } else { exprBuilder.Length = 0; exprBuilder.Append(outExpr).Append('.'); } } else if (prop == null && scope.Count == 1) { if (ScriptEngine.AnalyzeDebug) { Debug.LogWarningFormat("Can't find {0} in {1}, interpreting as a string", propName, contextType); } contextType = typeof(string); exprBuilder.Length = 0; exprBuilder.Append("\"").Append(scope [i]).Append("\""); break; } else if (prop == null) { Debug.LogWarningFormat("Can't find {0} in {1}", propName, contextType); break; } else { contextType = prop.PropertyType; exprBuilder.Append(propName).Append('.'); var declVar = new DeclareVariableStatement(); CleanUpContextes.Push(declVar); declVar.IsTemp = true; declVar.IsContext = true; declVar.Name = "prop" + DeclareVariableStatement.VariableId++; if (exprBuilder.Length > 0 && exprBuilder [exprBuilder.Length - 1] == '.') { exprBuilder.Length -= 1; } if (hasSign) { declVar.InitExpression = exprBuilder.ToString(1, exprBuilder.Length - 1); exprBuilder.Length = 1; exprBuilder.Append(declVar.Name).Append('.'); } else { declVar.InitExpression = exprBuilder.ToString(); exprBuilder.Length = 0; exprBuilder.Append(declVar.Name).Append('.'); } declVar.Type = contextType; curBlock.Statements.Add(declVar); if (contextType.IsClass) { IfStatement ifSt = new IfStatement(); ifSt.CheckExpression = String.Format("{0} != null", declVar.Name); ifSt.TrueBlock = new FunctionBlock(curBlock); curBlock.Statements.Add(ifSt); curBlock = ifSt.TrueBlock; } } } } returnExpr.Type = contextType; var res = resultVar; if (!res.IsHidden) { var list = curBlock.FindStatement <DeclareVariableStatement> (v => v.Type != null && v.Type.IsGenericType && v.Type.GetGenericTypeDefinition() == typeof(List <>)); var lasVar = curBlock.FindStatement <DeclareVariableStatement> (v => v.IsContext); if (list != null && !firstTimeList) { curBlock.Statements.Add(String.Format(@"{0}.Add({1});", res.Name, lasVar.Name)); res.Type = typeof(List <>).MakeGenericType(lasVar.Type); res.InitExpression = String.Format("new {0}();", TypeName.NameOf(res.Type)); } else { res.Type = lasVar.Type; curBlock.Statements.Add(String.Format(@"{0} = {1};", res.Name, lasVar.Name)); } if (hasSign) { exprBuilder.Length = 1; exprBuilder.Append(res.Name).Append('.'); } else { exprBuilder.Length = 0; exprBuilder.Append(res.Name).Append('.'); } returnExpr.Type = res.Type; } if (!res.IsHidden && res.Type != null) { var resType = res.Type; res.IsResult = false; Debug.Log(isInsideBoolean); if (isInsideBoolean && resType.IsGenericType && resType.GetGenericTypeDefinition() == typeof(List <>)) { exprBuilder.Append(String.Format(" != null ? {0}.Count : 0", exprBuilder)); } } if (exprBuilder.Length > 0 && exprBuilder [exprBuilder.Length - 1] == '.') { exprBuilder.Length -= 1; } if (res.IsHidden) { resultVar.Name = "OperandVar" + DeclareVariableStatement.VariableId++; resultVar.Type = contextType; resultVar.InitExpression = string.Format("default({0})", TypeName.NameOf(contextType)); resultVar.IsHidden = false; block.Statements [insertResultIndex] = resultVar; curBlock.Statements.Add(String.Format("{0} = {1};", resultVar.Name, exprBuilder)); exprBuilder.Length = hasSign ? 1 : 0; var resType = res.Type; if (isInsideBoolean && resType.IsGenericType && resType.GetGenericTypeDefinition() == typeof(List <>)) { exprBuilder.Append(String.Format("{0} != null ? {0}.Count : 0", resultVar.Name)); } else { exprBuilder.Append(resultVar.Name); } } } else if (operand is FunctionCall) { // var call = operand as FunctionCall; // for (int i = 0; i < call.Args.Length; i++) // { // // } } else if (operand is Expression) { var ex = InterpretExpression(operand as Expression, block, false, isInsideBoolean); exprBuilder.Append(ex.ExprString); returnExpr.Type = ex.Type; } else { returnExpr.Type = operand.GetType(); if (operand is bool) { exprBuilder.Append((bool)operand ? "true" : "false"); } else { exprBuilder.Append(operand); } if (operand is float) { exprBuilder.Append('f'); } } string head = String.Format("{0}(", signChar); exprBuilder.Insert(0, head).Append(')'); returnExpr.ExprString = exprBuilder.ToString(); return(returnExpr); }
public override void Interpret(Operator op, FunctionBlock block) { if (exprInter == null) { exprInter = Engine.GetPlugin <ExpressionInterpreter>(); } block.Method.ReturnType = new CodeTypeReference(typeof(IEnumerator)); block.Method.Attributes = MemberAttributes.Public; block.Method.Name = "ActionCoroutine"; if (!block.Method.UserData.Contains("has_transformed_action")) { var newActionMethod = new CodeMemberMethod(); newActionMethod.Name = "Action"; newActionMethod.Attributes = MemberAttributes.Public | MemberAttributes.Override; newActionMethod.Statements.Add(new CodeSnippetStatement("Coroutine = ActionCoroutine(); state = ActionState.Started;")); block.Type.Members.Add(newActionMethod); block.Method.UserData.Add("has_transformed_action", "has_transformed_action"); } var contextVar = block.FindStatement <DeclareVariableStatement>(v => (v.IsContext) && v.Type == typeof(Actor)); if (contextVar == null) { contextVar = block.FindStatement <DeclareVariableStatement>(v => (v.IsContext) && v.Type == typeof(GameObject)); } int aId = 0; if (op.Args.Count == 1) { if (op.Context is Expression) { //do(interaction_type) = target var interTypeArg = op.Args[0].ToString().ClearFromBraces(); var targetArg = exprInter.InterpretExpression(op.Context as Expression, block); aId = DeclareVariableStatement.VariableId++; block.Statements.Add(String.Format("var a{0} = Actions.Instance.GetAction(typeof(ScriptedTypes.{1}));", aId, interTypeArg)); block.Statements.Add(String.Format("a{0}.Init();", aId)); block.Statements.Add(String.Format("(a{0} as EventInteraction).Initiator = {1};", aId, (contextVar.Type == typeof(GameObject)? contextVar.Name : (contextVar.Name + ".gameObject")))); if (targetArg.Type == typeof(GameObject)) { block.Statements.Add(String.Format("a{0}.Root = {1};", aId, targetArg.ExprString)); } else { block.Statements.Add(String.Format("a{0}.Root = {1}.gameObject;", aId, targetArg.ExprString)); } block.Statements.Add(String.Format("UnityEngine.Debug.Log(a{0}.Root);", aId)); block.Statements.Add(String.Format("UnityEngine.Debug.Log((a{0} as EventInteraction).Initiator);", aId)); if (contextVar.Type == typeof(GameObject)) { block.Statements.Add(String.Format("({0}.GetComponent(typeof(Actor)) as Actor).Act(a{1});", contextVar.Name, aId)); } else { block.Statements.Add(String.Format("{0}.Act(a{1});", contextVar.Name, aId)); } } else { //do(interaction_type) = { target = some_object some_argument = some_value } var interTypeArg = op.Args[0].ToString().ClearFromBraces(); aId = DeclareVariableStatement.VariableId++; block.Statements.Add(String.Format("var a{0} = Actions.Instance.GetAction(typeof(ScriptedTypes.{1}));", aId, interTypeArg)); block.Statements.Add(String.Format("a{0}.Init();", aId)); block.Statements.Add(String.Format("(a{0} as EventInteraction).Initiator = {1};", aId, (contextVar.Type == typeof(GameObject) ? contextVar.Name : (contextVar.Name + ".gameObject")))); var type = Engine.FindType(interTypeArg); var props = type.GetProperties(); propsDict.Clear(); foreach (var prop in props) { propsDict.Add(NameTranslator.ScriptNameFromCSharp(prop.Name), prop); } foreach (var subOpObject in (op.Context as Context).Entries) { PropertyInfo prop; var subOp = subOpObject as Operator; if (subOp.Identifier as string == "target") { var targetArg = exprInter.InterpretExpression(subOp.Context as Expression, block); if (targetArg.Type == typeof(GameObject)) { block.Statements.Add(String.Format("a{0}.Root = {1};", aId, targetArg.ExprString)); } else { block.Statements.Add(String.Format("a{0}.Root = {1}.gameObject;", aId, targetArg.ExprString)); } } else if (propsDict.TryGetValue(subOp.Identifier as string, out prop)) { var propArg = exprInter.InterpretExpression(subOp.Context as Expression, block).ExprString; block.Statements.Add(String.Format("(a{0} as EventInteraction).{1} = ({3}){2};", aId, prop.Name, propArg, prop.PropertyType)); } } var propExpr = exprInter.InterpretExpression(op.Args[0], block).ExprString; //block.Statements.Add(String.Format("(a{0} as ScriptedTypes.{1}).{2} = ({4}){3}", aId, interTypeArg, prop.Name, propExpr)); if (contextVar.Type == typeof(GameObject)) { block.Statements.Add(String.Format("({0}.GetComponent(typeof(Actor)) as Actor).Act(a{1});", contextVar.Name, aId)); } else { block.Statements.Add(String.Format("{0}.Act(a{1});", contextVar.Name, aId)); } } } else if (op.Args.Count == 2) { //do(interaction_type, possible_one_argument) = target var interTypeArg = op.Args[0].ToString().ClearFromBraces(); var targetArg = exprInter.InterpretExpression(op.Context as Expression, block); aId = DeclareVariableStatement.VariableId++; block.Statements.Add(String.Format("var a{0} = Actions.Instance.GetAction(typeof(ScriptedTypes.{1}));", aId, interTypeArg)); block.Statements.Add(String.Format("a{0}.Init();", aId)); var type = Engine.FindType(interTypeArg); var props = type.GetProperties(); if (ScriptEngine.AnalyzeDebug) { if (props.Length != 1) { Debug.LogErrorFormat("Wrong number of properties for DO statement in ", block.Type.Name); } } var prop = props[0]; var propExpr = exprInter.InterpretExpression(op.Args[0], block).ExprString; block.Statements.Add(String.Format("(a{0} as EventInteraction).Initiator = {1};", aId, (contextVar.Type == typeof(GameObject) ? contextVar.Name : (contextVar.Name + ".gameObject")))); if (targetArg.Type == typeof(GameObject)) { block.Statements.Add(String.Format("a{0}.Root = {1};", aId, targetArg.ExprString)); } else { block.Statements.Add(String.Format("a{0}.Root = {1}.gameObject;", aId, targetArg.ExprString)); } block.Statements.Add(String.Format("(a{0} as ScriptedTypes.{1}).{2} = {3}", aId, interTypeArg, prop.Name, propExpr)); if (contextVar.Type == typeof(GameObject)) { block.Statements.Add(String.Format("({0}.GetComponent(typeof(Actor)) as Actor).Act(a{1});", contextVar.Name, aId)); } else { block.Statements.Add(String.Format("{0}.Act(a{1});", contextVar.Name, aId)); } } string operatorString = null; if (operatorString != null) { block.Statements.Add(operatorString); } var waitString = string.Format("while(a{0}.State != EventAction.ActionState.Finished){{ if(a{0}.State == EventAction.ActionState.Failed) {{ this.state = EventAction.ActionState.Failed; yield break; }} yield return null; }}", aId); block.Statements.Add(waitString); }