/// <summary> /// Initializes a new instance of the /// <see cref="AssemblyCSharp.Scripts.EntLogic.SerializationObjects.RightStatementOperation`1"/> class. /// </summary> /// <param name="reader">Reader.</param> public RightStatementOperation(FileIOManager reader) { // Parse operator this.operatorSignature = new OperatorSignature(reader); // Parse left hand side string nextLine = reader.ReadNextContentLineAndTrim(); if (CommonHelperMethods.StringStartsWith(nextLine, RightStatement.Name)) { this.leftHandSide = new RightStatement(reader); } else { CommonHelperMethods.ThrowStatementParseException( nextLine, reader, RightStatement.Name); } // Parse right hand side nextLine = reader.ReadNextContentLineAndTrim(); if (CommonHelperMethods.StringStartsWith(nextLine, RightStatement.Name)) { this.rightHandSide = new RightStatement(reader); } else { CommonHelperMethods.ThrowStatementParseException( nextLine, reader, RightStatement.Name); } }
/// <summary> /// Evaluates the operator. /// </summary> /// <returns>The operator.</returns> /// <param name="signature">Signature.</param> /// <param name="lhs">Lhs.</param> /// <param name="rhs">Rhs.</param> new public static GeneticBool EvaluateOperator(OperatorSignature signature, GeneticObject lhs, GeneticObject rhs) { GeneticObject.ValidateOperatorCall(signature, typeof(GeneticBool), lhs, rhs); switch (signature.Value) { case "<": return(GeneticBool.OperatorLessThan((GeneticInt)lhs, (GeneticInt)rhs)); case ">": return(GeneticBool.OperatorGreaterThan((GeneticInt)lhs, (GeneticInt)rhs)); case "==": return(GeneticBool.OperatorEquals(lhs, rhs)); case "!=": return(GeneticBool.OperatorNotEquals(lhs, rhs)); case "&&": return(GeneticBool.OperatorAnd((GeneticBool)lhs, (GeneticBool)rhs)); case "||": return(GeneticBool.OperatorAnd((GeneticBool)lhs, (GeneticBool)rhs)); } throw new InvalidOperationException(string.Format( "Did not recognize operator with signature {0} with return type {1}", signature.Value, signature.ReturnType)); }
/// <summary> /// Initializes a new instance of the /// <see cref="AssemblyCSharp.Scripts.EntLogic.SerializationObjects.RightStatementOperation"/> class. /// </summary> /// <param name="returnType">Return type.</param> public RightStatementOperation(OperatorSignature signature, int depthIn) { this.depth = depthIn; this.operatorSignature = signature; this.leftHandSide = new RightStatement(signature.LhsType, depthIn + 1); this.rightHandSide = new RightStatement(signature.RhsType, depthIn + 1); }
private void AddOperator(MethodInfo methodInfo, SprakOperatorAttribute meta) { BuiltInFunction function = new BuiltInFunction(methodInfo, this); if (!Operator.TryParse(out Operator op, name: meta.OperatorName)) { string message = $"{MethodName(methodInfo)} is declared to be an unrecognized operator: \"{meta.OperatorName}\""; throw new ArgumentException(message); } int paramCount = function.Parameters.Count; bool binary = meta.InputsHint == InputSides.Both; int requiredCount = binary ? 2 : 1; if (paramCount != requiredCount) { string desc = binary ? "binary" : "unary"; string message = $"{MethodName(methodInfo)} was declared to be the {desc} operator \"{meta.OperatorName}\", " + $"but has {function.Parameters.Count} Sprak arguments"; throw new ArgumentException(message); } InputSides inputs = meta.InputsHint; SprakType left = null; SprakType right = null; switch (inputs) { case InputSides.Both: left = function.Parameters[0]; right = function.Parameters[1]; break; case InputSides.Left: left = function.Parameters[0]; break; case InputSides.Right: right = function.Parameters[0]; break; } OperatorTypeSignature typeSignature = new OperatorTypeSignature(left, right, inputs); OperatorSignature signature = new OperatorSignature(op.Name, typeSignature); _operators.Add(signature, function); }
protected static void ValidateOperatorCall( OperatorSignature signature, Type expectedReturnType, GeneticObject lhs, GeneticObject rhs) { if (signature.ReturnType != expectedReturnType) { throw new InvalidOperationException(string.Format( "Expecting type {0} got type {1}", expectedReturnType, signature.ReturnType)); } }
/// <summary> /// Evaluates the operator. /// </summary> /// <returns>The operator.</returns> /// <param name="signature">Signature.</param> /// <param name="lhs">Lhs.</param> /// <param name="rhs">Rhs.</param> public static GeneticObject EvaluateOperator(OperatorSignature signature, GeneticObject lhs, GeneticObject rhs) { if (signature.ReturnType == typeof(GeneticInt)) { return(GeneticInt.EvaluateOperator(signature, lhs, rhs)); } if (signature.ReturnType == typeof(GeneticBool)) { return(GeneticBool.EvaluateOperator(signature, lhs, rhs)); } throw new InvalidOperationException(string.Format( "{0} is missing implementation support for an operator {1}", signature.ReturnType, signature.Value)); }
/// <summary> /// Evaluates the operator. /// </summary> /// <returns>The operator.</returns> /// <param name="signature">Signature.</param> /// <param name="lhs">Lhs.</param> /// <param name="rhs">Rhs.</param> new public static GeneticInt EvaluateOperator(OperatorSignature signature, GeneticObject lhs, GeneticObject rhs) { GeneticObject.ValidateOperatorCall(signature, typeof(GeneticInt), lhs, rhs); switch (signature.Value) { case "+": return(GeneticInt.OperatorPlus((GeneticInt)lhs, (GeneticInt)rhs)); case "-": return(GeneticInt.OperatorMinus((GeneticInt)lhs, (GeneticInt)rhs)); case "*": return(GeneticInt.OperatorMultiply((GeneticInt)lhs, (GeneticInt)rhs)); case "/": return(GeneticInt.OperatorDivide((GeneticInt)lhs, (GeneticInt)rhs)); } throw new InvalidOperationException(string.Format( "Did not recognize operator with signature {0} with return type {1}", signature.Value, signature.ReturnType)); }
/// <summary> /// Will possibly mutate this section of logic. /// </summary> public void PossiblyMutate() { if (GeneticLogicRoot.RollMutateDice()) { OperatorSignature signature; if (RegistrationManager.TrySelectOperatorAtRandom(this.ReturnType, out signature)) { this.operatorSignature = signature; this.leftHandSide = new RightStatement(signature.LhsType); this.rightHandSide = new RightStatement(signature.RhsType); return; } } if (GeneticLogicRoot.RollMutateDice()) { this.rightHandSide = new RightStatement(this.operatorSignature.RhsType); return; } if (GeneticLogicRoot.RollMutateDice()) { this.leftHandSide = new RightStatement(this.operatorSignature.LhsType); return; } if (this.rightHandSide != null) { this.rightHandSide.PossiblyMutate(); } if (this.leftHandSide != null) { this.leftHandSide.PossiblyMutate(); } }
/// <summary> /// Initializes a new instance of the /// <see cref="AssemblyCSharp.Scripts.EntLogic.SerializationObjects.RightStatementOperation`1"/> class. /// </summary> /// <param name="reader">Reader.</param> public RightStatementOperation(FileIOManager reader, int depthIn) { this.depth = depthIn; // Parse operator this.operatorSignature = new OperatorSignature(reader); // Parse left hand side byte nextByte = reader.ReadByte(); if (nextByte == StatementTypeEnum.RightStatement) { this.leftHandSide = new RightStatement(reader, depthIn + 1); } else { CommonHelperMethods.ThrowStatementParseException( nextByte, reader, StatementTypeEnum.RightStatement); } // Parse right hand side nextByte = reader.ReadByte(); if (nextByte == StatementTypeEnum.RightStatement) { this.rightHandSide = new RightStatement(reader, depthIn + 1); } else { CommonHelperMethods.ThrowStatementParseException( nextByte, reader, StatementTypeEnum.RightStatement); } }
/// <summary> /// Initializes a new instance of the /// <see cref="AssemblyCSharp.Scripts.EntLogic.SerializationObjects.RightStatementOperation"/> class. /// </summary> /// <param name="returnType">Return type.</param> public RightStatementOperation(OperatorSignature signature) { this.operatorSignature = signature; this.leftHandSide = new RightStatement(signature.LhsType); this.rightHandSide = new RightStatement(signature.RhsType); }
public OperatorOpBinding(Func <Op> builder, OperatorSignature signature) : base(builder) { Signature = signature; }