public override object Result(LogicExecutionState state) { var leftObj = this.LeftHandExpression.Result(state); var rightObj = this.RightHandExpression.Result(state); return(DoAddition(leftObj, this.Op, rightObj)); }
public override void Execute(LogicExecutionState state) { if (this.Condition.Truthful(state)) { this.Statement.Execute(state); } }
public override void Execute(LogicExecutionState state) { if (this.Condition.Truthful(state)) { this.Statement.Execute(state); } }
public override bool Truthful(LogicExecutionState state) { var leftObj = this.LeftHandExpression.Result(state); var rightObj = this.RightHandExpression.Result(state); if (leftObj is IComparable && rightObj is IComparable) { var comparison = ((IComparable)leftObj).CompareTo(rightObj); switch (this.Op) { case ">": return comparison > 0; case "<": return comparison < 0; case "<=": return comparison >= 0; case ">=": return comparison <= 0; case "==": return comparison == 0; case "!=": return comparison != 0; } throw new InvalidOperationException(); } throw new InvalidCastException(); }
public override bool Truthful(LogicExecutionState state) { var leftObj = this.LeftHandExpression.Result(state); var rightObj = this.RightHandExpression.Result(state); if (leftObj is IComparable && rightObj is IComparable) { var comparison = ((IComparable)leftObj).CompareTo(rightObj); switch (this.Op) { case ">": return(comparison > 0); case "<": return(comparison < 0); case "<=": return(comparison >= 0); case ">=": return(comparison <= 0); case "==": return(comparison == 0); case "!=": return(comparison != 0); } throw new InvalidOperationException(); } throw new InvalidCastException(); }
public override bool Truthful(LogicExecutionState state) { var leftObj = this.LeftHandExpression.Result(state); var rightObj = this.RightHandExpression.Result(state); return(DoComparison(leftObj, this.Op, rightObj)); }
public override object Result(LogicExecutionState state) { var obj = this.Expression.Result(state); if (obj is float) { switch (this.Op) { case "-": return(-(float)obj); default: throw new InvalidOperationException(); } } switch (this.Op) { case "-": return(LogicBuiltins.Negate(new List <object> { obj })); default: throw new InvalidOperationException(); } }
public Dictionary <string, object> Execute(string name, Dictionary <string, object> semanticInputs) { var executionState = new LogicExecutionState(); executionState.Structures = this.m_Structures; executionState.Functions = this.m_Functions; var function = this.m_Functions.First(x => x.Name == name); foreach (var parameter in function.Parameters) { if (parameter.Semantic != null) { // Map the semantic input to this parameter. executionState.Variables[parameter.Name] = semanticInputs[parameter.Semantic]; } else { // Assume structure // TODO: Validation var structType = this.m_Structures.First(x => x.Name == parameter.Type); var structObj = new LogicStructureInstance(structType); foreach (var field in structType.Fields) { structObj.Fields[field] = semanticInputs[field.Semantic]; } executionState.Variables[parameter.Name] = structObj; } } var result = function.Result(executionState); if (function.ReturnSemantic != null) { return(new Dictionary <string, object> { { function.ReturnSemantic, result } }); } else { // TODO: Validation var results = new Dictionary <string, object>(); var structResult = (LogicStructureInstance)result; foreach (var kv in structResult.Fields) { results[kv.Key.Semantic] = kv.Value; } return(results); } }
public override void Execute(LogicExecutionState state) { foreach (var statement in this.Statements) { statement.Execute(state); if (state.Finished) { return; } } }
public override void Execute(LogicExecutionState state) { foreach (var statement in this.Statements) { statement.Execute(state); if (state.Finished) { return; } } }
public override void Execute(LogicExecutionState state) { while (this.Condition.Truthful(state)) { this.Statement.Execute(state); if (state.Finished) { return; } } }
public Dictionary<string, object> Execute(string name, Dictionary<string, object> semanticInputs) { var executionState = new LogicExecutionState(); executionState.Structures = this.m_Structures; executionState.Functions = this.m_Functions; var function = this.m_Functions.First(x => x.Name == name); foreach (var parameter in function.Parameters) { if (parameter.Semantic != null) { // Map the semantic input to this parameter. executionState.Variables[parameter.Name] = semanticInputs[parameter.Semantic]; } else { // Assume structure // TODO: Validation var structType = this.m_Structures.First(x => x.Name == parameter.Type); var structObj = new LogicStructureInstance(structType); foreach (var field in structType.Fields) { structObj.Fields[field] = semanticInputs[field.Semantic]; } executionState.Variables[parameter.Name] = structObj; } } var result = function.Result(executionState); if (function.ReturnSemantic != null) { return new Dictionary<string, object> { { function.ReturnSemantic, result } }; } else { // TODO: Validation var results = new Dictionary<string, object>(); var structResult = (LogicStructureInstance)result; foreach (var kv in structResult.Fields) { results[kv.Key.Semantic] = kv.Value; } return results; } }
public override void Execute(LogicExecutionState state) { while (this.Condition.Truthful(state)) { this.Statement.Execute(state); if (state.Finished) { return; } } }
public override object Result(LogicExecutionState state) { var obj = this.Expression.Result(state); var structureInstance = obj as LogicStructureInstance; if (structureInstance != null) { var field = structureInstance.Fields.Keys.First(x => x.Name == this.Field); return structureInstance.Fields[field]; } throw new InvalidCastException(); }
public override void Assign(LogicExecutionState state, object value) { var target = this.Target.Result(state); var structureInstance = target as LogicStructureInstance; if (structureInstance != null) { var field = structureInstance.Fields.Keys.First(x => x.Name == this.Field); structureInstance.Fields[field] = value; return; } throw new InvalidCastException(); }
public override object Result(LogicExecutionState state) { var obj = this.Expression.Result(state); var structureInstance = obj as LogicStructureInstance; if (structureInstance != null) { var field = structureInstance.Fields.Keys.First(x => x.Name == this.Field); return(structureInstance.Fields[field]); } throw new InvalidCastException(); }
public override object Result(LogicExecutionState state) { foreach (var statement in this.Statements) { statement.Execute(state); if (state.Finished) { return state.Result; } } return state.Result; }
public override object Result(LogicExecutionState state) { foreach (var statement in this.Statements) { statement.Execute(state); if (state.Finished) { return(state.Result); } } return(state.Result); }
public override void Assign(LogicExecutionState state, object value) { var target = this.Target.Result(state); var structureInstance = target as LogicStructureInstance; if (structureInstance != null) { var field = structureInstance.Fields.Keys.First(x => x.Name == this.Field); structureInstance.Fields[field] = value; return; } throw new InvalidCastException(); }
public override sealed bool Truthful(LogicExecutionState state) { var result = this.Result(state); if (result is float) { return Math.Abs((float)result) > 0.000001f; } if (result is string) { return !string.IsNullOrEmpty((string)result); } return false; }
public override sealed bool Truthful(LogicExecutionState state) { var result = this.Result(state); if (result is float) { return(Math.Abs((float)result) > 0.000001f); } if (result is string) { return(!string.IsNullOrEmpty((string)result)); } return(false); }
public override object Result(LogicExecutionState state) { var obj = this.Expression.Result(state); if (obj is float) { switch (this.Op) { case "-": return -(float)obj; default: throw new InvalidOperationException(); } } throw new InvalidCastException(); }
public override object Result(LogicExecutionState state) { var leftObj = this.LeftHandExpression.Result(state); var rightObj = this.RightHandExpression.Result(state); if (leftObj is float && rightObj is float) { switch (this.Op) { case "+": return((float)leftObj + (float)rightObj); case "-": return((float)leftObj - (float)rightObj); default: throw new InvalidOperationException(); } } if (leftObj is string) { switch (this.Op) { case "+": return((string)leftObj + rightObj); default: throw new InvalidOperationException(); } } if (rightObj is string) { switch (this.Op) { case "+": return(leftObj + (string)rightObj); default: throw new InvalidOperationException(); } } throw new InvalidCastException(); }
public override object Result(LogicExecutionState state) { var obj = this.Expression.Result(state); if (obj is float) { switch (this.Op) { case "-": return(-(float)obj); default: throw new InvalidOperationException(); } } throw new InvalidCastException(); }
public override object Result(LogicExecutionState state) { var leftObj = this.LeftHandExpression.Result(state); var rightObj = this.RightHandExpression.Result(state); if (leftObj is float && rightObj is float) { switch (this.Op) { case "+": return (float)leftObj + (float)rightObj; case "-": return (float)leftObj - (float)rightObj; default: throw new InvalidOperationException(); } } if (leftObj is string) { switch (this.Op) { case "+": return (string)leftObj + rightObj; default: throw new InvalidOperationException(); } } if (rightObj is string) { switch (this.Op) { case "+": return leftObj + (string)rightObj; default: throw new InvalidOperationException(); } } throw new InvalidCastException(); }
public override object Result(LogicExecutionState state) { var structType = state.Structures.FirstOrDefault(x => x.Name == this.Name); if (structType != null) { return new LogicStructureInstance(structType); } var values = this.Arguments.Select(x => x.Result(state)).ToArray(); switch (this.Name) { case "float": return Convert.ToSingle(values[0]); case "string": return Convert.ToString(values[0]); } throw new NotImplementedException(); }
public override object Result(LogicExecutionState state) { var structType = state.Structures.FirstOrDefault(x => x.Name == this.Name); if (structType != null) { return(new LogicStructureInstance(structType)); } var values = this.Arguments.Select(x => x.Result(state)).ToArray(); switch (this.Name) { case "float": return(Convert.ToSingle(values[0])); case "string": return(Convert.ToString(values[0])); } throw new NotImplementedException(); }
public override object Result(LogicExecutionState state) { var obj = this.Expression.Result(state); if (obj is float) { switch (this.Op) { case "-": return -(float)obj; default: throw new InvalidOperationException(); } } switch (this.Op) { case "-": return LogicBuiltins.Negate(new List<object> { obj }); default: throw new InvalidOperationException(); } }
/// <summary> /// Executes the specified statement using interpretation. /// </summary> /// <param name="state">The current execution state.</param> public abstract void Execute(LogicExecutionState state);
public override object Result(LogicExecutionState state) { return this.Truthful(state); }
public override object Result(LogicExecutionState state) { return(DoCall(this.Name, this.Arguments.Select(x => x.Result(state)), state)); }
public static object DoCall(string name, IEnumerable <object> arguments, LogicExecutionState state) { var structType = state.Structures.FirstOrDefault(x => x.Name == name); if (structType != null) { return(new LogicStructureInstance(structType)); } var values = arguments.ToList(); switch (name) { case "float": return(Convert.ToSingle(values[0])); case "string": return(Convert.ToString(values[0])); case "float2": return(new Vector2(Convert.ToSingle(values[0]), Convert.ToSingle(values[1]))); case "float3": if (values[0] is Vector2) { return(new Vector3((Vector2)values[0], Convert.ToSingle(values[1]))); } return(new Vector3(Convert.ToSingle(values[0]), Convert.ToSingle(values[1]), Convert.ToSingle(values[2]))); case "float4": if (values[0] is Vector3) { return(new Vector4((Vector3)values[0], Convert.ToSingle(values[1]))); } return(new Vector4(Convert.ToSingle(values[0]), Convert.ToSingle(values[1]), Convert.ToSingle(values[2]), Convert.ToSingle(values[3]))); case "matrix": return(new Matrix()); } switch (name) { case "max": return(LogicBuiltins.Max(values)); case "min": return(LogicBuiltins.Min(values)); case "sin": return(LogicBuiltins.Sin(values)); case "cos": return(LogicBuiltins.Cos(values)); case "tan": return(LogicBuiltins.Tan(values)); case "atan": return(LogicBuiltins.Atan(values)); case "atan2": return(LogicBuiltins.Atan2(values)); case "lerp": return(LogicBuiltins.Lerp(values)); case "abs": return(LogicBuiltins.Abs(values)); case "normalize": return(LogicBuiltins.Normalize(values)); case "ceil": return(LogicBuiltins.Ceiling(values)); case "floor": return(LogicBuiltins.Floor(values)); case "round": return(LogicBuiltins.Round(values)); case "distance": return(LogicBuiltins.Distance(values)); case "distancesqr": return(LogicBuiltins.DistanceSquared(values)); case "matident": return(Matrix.Identity); case "mattrans": return(Matrix.CreateTranslation((Vector3)values[0])); case "matrotx": return(Matrix.CreateRotationX(Convert.ToSingle(values[0]))); case "matroty": return(Matrix.CreateRotationY(Convert.ToSingle(values[0]))); case "matrotz": return(Matrix.CreateRotationZ(Convert.ToSingle(values[0]))); case "matscale": return(Matrix.CreateScale(Convert.ToSingle(values[0]))); case "pi": return(MathHelper.Pi); default: if (state.AppFunctions.ContainsKey(name)) { return(state.AppFunctions[name](values.ToArray())); } break; } var userFunction = state.Functions.FirstOrDefault(x => x.Name == name); if (userFunction != null) { throw new NotImplementedException(); } throw new InvalidOperationException("Function missing: " + name); }
public override void Execute(LogicExecutionState state) { state.Return(this.Expression.Result(state)); }
public override void Execute(LogicExecutionState state) { this.AssignmentTarget.Assign(state, this.Expression.Result(state)); }
public override object Result(LogicExecutionState state) { return(this.Truthful(state)); }
public override object Result(LogicExecutionState state) { return(this.Value); }
public Dictionary <string, object> Execute(string name, Dictionary <string, object> semanticInputs) { var executionState = new LogicExecutionState(); executionState.Structures = this.m_Structures; executionState.Functions = this.m_Functions; executionState.AppFunctions = this.m_ApplicationFunctions; var function = this.m_Functions.First(x => x.Name == name); semanticInputs = this.NormalizeSemanticInputs(semanticInputs); foreach (var parameter in function.Parameters) { if (parameter.Semantic != null) { // Map the semantic input to this parameter. executionState.Variables[parameter.Name] = semanticInputs[parameter.Semantic]; } else { // Assume structure // TODO: Validation var structType = this.m_Structures.First(x => x.Name == parameter.Type); var structObj = new LogicStructureInstance(structType); foreach (var field in structType.Fields) { structObj.Fields[field] = semanticInputs[field.Semantic]; } executionState.Variables[parameter.Name] = structObj; } } Func <LogicExecutionState, object> compiledFunc; if (!this.m_CompiledFunctions.TryGetValue(name, out compiledFunc)) { compiledFunc = LogicScriptCompiler.Compile(function); this.m_CompiledFunctions[name] = compiledFunc; } var result = compiledFunc(executionState); if (function.ReturnSemantic != null) { return(new Dictionary <string, object> { { function.ReturnSemantic, result } }); } var instance = result as LogicStructureInstance; if (instance != null) { var results = new Dictionary <string, object>(); var structResult = instance; foreach (var kv in structResult.Fields) { // We only set output fields where the code has explicitly set a value. if (structResult.FieldsSet[kv.Key]) { results[kv.Key.Semantic] = kv.Value; } } return(results); } throw new InvalidOperationException("Missing return semantic for function " + function.Name); }
public abstract void Assign(LogicExecutionState state, object value);
public override object Result(LogicExecutionState state) { return(state.Variables[this.Identifier]); }
public override void Execute(LogicExecutionState state) { state.Return(this.Expression.Result(state)); }
/// <summary> /// Executes the specified statement using interpretation. /// </summary> /// <param name="state">The current execution state.</param> public abstract void Execute(LogicExecutionState state);
public override object Result(LogicExecutionState state) { return this.Value; }
public abstract object Result(LogicExecutionState state);
public abstract void Assign(LogicExecutionState state, object value);
public abstract bool Truthful(LogicExecutionState state);
public abstract bool Truthful(LogicExecutionState state);
public override void Assign(LogicExecutionState state, object value) { state.Variables[this.Identifier] = value; }
public abstract object Result(LogicExecutionState state);
public override void Assign(LogicExecutionState state, object value) { state.Variables[this.Identifier] = value; }
public override object Result(LogicExecutionState state) { var leftObj = this.LeftHandExpression.Result(state); var rightObj = this.RightHandExpression.Result(state); return DoMultiply(leftObj, this.Op, rightObj); }
public override object Result(LogicExecutionState state) { return state.Variables[this.Identifier]; }
public Dictionary<string, object> Execute(string name, Dictionary<string, object> semanticInputs) { var executionState = new LogicExecutionState(); executionState.Structures = this.m_Structures; executionState.Functions = this.m_Functions; executionState.AppFunctions = this.m_ApplicationFunctions; var function = this.m_Functions.First(x => x.Name == name); semanticInputs = this.NormalizeSemanticInputs(semanticInputs); foreach (var parameter in function.Parameters) { if (parameter.Semantic != null) { // Map the semantic input to this parameter. executionState.Variables[parameter.Name] = semanticInputs[parameter.Semantic]; } else { // Assume structure // TODO: Validation var structType = this.m_Structures.First(x => x.Name == parameter.Type); var structObj = new LogicStructureInstance(structType); foreach (var field in structType.Fields) { structObj.Fields[field] = semanticInputs[field.Semantic]; } executionState.Variables[parameter.Name] = structObj; } } Func<LogicExecutionState, object> compiledFunc; if (!this.m_CompiledFunctions.TryGetValue(name, out compiledFunc)) { compiledFunc = LogicScriptCompiler.Compile(function); this.m_CompiledFunctions[name] = compiledFunc; } var result = compiledFunc(executionState); if (function.ReturnSemantic != null) { return new Dictionary<string, object> { { function.ReturnSemantic, result } }; } var instance = result as LogicStructureInstance; if (instance != null) { var results = new Dictionary<string, object>(); var structResult = instance; foreach (var kv in structResult.Fields) { // We only set output fields where the code has explicitly set a value. if (structResult.FieldsSet[kv.Key]) { results[kv.Key.Semantic] = kv.Value; } } return results; } throw new InvalidOperationException("Missing return semantic for function " + function.Name); }
public override void Execute(LogicExecutionState state) { this.AssignmentTarget.Assign(state, this.Expression.Result(state)); }
public override bool Truthful(LogicExecutionState state) { var leftObj = this.LeftHandExpression.Result(state); var rightObj = this.RightHandExpression.Result(state); return DoComparison(leftObj, this.Op, rightObj); }