public ContextFunctionCallInterpreter(MethodInfo method, ScriptEngine engine) { ops = engine.GetPlugin <EventFunctionOperators> (); switches = engine.GetPlugin <ContextSwitchesPlugin> (); argsDef = method.GetParameters(); if (argsDef.Length > 0) { addContextInter = switches.GetInterByType(argsDef [argsDef.Length - 1].ParameterType); } Engine = engine; returnType = method.ReturnType; if (returnType != typeof(void) && returnType != typeof(string) && (returnType.IsClass || (returnType.IsValueType && !returnType.IsEnum && returnType != typeof(bool) && returnType != typeof(float) && returnType != typeof(int))) && !(returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(List <>))) { if (ContextPropertySwitchInterpreter.allPropSwitches.ContainsKey(new ContextPropertySwitchInterpreter.PropKey(returnType, ""))) { ctxInter = ContextPropertySwitchInterpreter.allPropSwitches[new ContextPropertySwitchInterpreter.PropKey(returnType, "")]; } else { ctxInter = new ContextPropertySwitchInterpreter("", returnType, engine); } } funcName = method.Name; }
public void AddInterpreter(string name, FunctionOperatorInterpreter inter) { if (interpreters.ContainsKey(name)) { Debug.LogWarning("Already has an interpreter " + name); return; } inter.Engine = Engine; interpreters.Add(name, inter); }
public void AddInterToType(Type type, FunctionOperatorInterpreter inter) { if (!intersByType.ContainsKey(type)) { intersByType.Add(type, inter); } if (type == typeof(GameObject) && inter.GetType() == typeof(ContextSwitchInterpreter)) { if (!intersByType.ContainsKey(type)) { intersByType.Add(type, inter); } else { intersByType[type] = inter; } } }
public FunctionOperatorInterpreter InterpretInContext(Operator op, FunctionBlock block) { //Debug.Log ("interpret in context"); FunctionOperatorInterpreter opInter = null; if (!contextSwitches.TryGetValue(op.Identifier as string, out opInter)) { if (!functions.TryGetValue(op.Identifier as string, out opInter)) { if (!properties.TryGetValue(op.Identifier as string, out opInter)) { if (ScriptEngine.AnalyzeDebug) { Debug.LogFormat("Can't interpret context operator {1} in {0}", block.Method.Name, op.Identifier); } return(null); } } } return(opInter); }
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) { 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); }