/// <summary> /// Constructs a new <see cref="EchoStream"/> object. /// </summary> /// <param name="primaryStream"> /// The primary stream. See <see cref="PrimaryStream"/>. /// </param> /// <param name="slaveStream"> /// The slave stream. See <see cref="SlaveStream"/>. /// </param> /// <param name="streamsOwned"> /// Controls which streams are "owned" by the <see cref="EchoStream"/>. /// See <see cref="StreamsOwned"/>. /// </param> public EchoStream( Stream primaryStream, Stream slaveStream, StreamOwnership streamsOwned) { ValueCheck.AssertNotNullArg("primaryStream", primaryStream); ValueCheck.AssertNotNullArg("slaveStream", slaveStream); m_primaryStream = primaryStream; m_slaveStream = slaveStream; m_streamsOwned = streamsOwned; }
/// <summary> /// 숫자 조건 확인. /// </summary> public static bool CheckNumberVariable(string key, float value, ValueCheck type) { bool check = false; if (EventHandler.Instance().numberVariables.ContainsKey(key) && // numberVariables : hashTable ((ValueCheck.EQUALS.Equals(type) && (float)EventHandler.Instance().numberVariables[key] == value) || //enum ValueCheck {EQUALS, LESS, GREATER}; (ValueCheck.LESS.Equals(type) && (float)EventHandler.Instance().numberVariables[key] < value) || // type : ValueCheck type (ValueCheck.GREATER.Equals(type) && (float)EventHandler.Instance().numberVariables[key] > value))) { check = true; } return(check); }
public void LinkedMethodsTest7() { BeethovenFactory beethovenFactory = new BeethovenFactory(); int calledCount = 0; ValueCheck valueCheck = new ValueCheck(); ITestMethods instance = beethovenFactory.Generate <ITestMethods>( LinkedMethodsReturnValue.Create <ITestMethods>(nameof(ITestMethods.WithParameters)) .SkipIf(valueCheck, nameof(valueCheck.HasNoValue2)) .Func((string text1, string text2) => calledCount++)); instance.WithParameters("", ""); instance.WithParameters("fegf", null); Assert.AreEqual(0, calledCount); instance.WithParameters("fdgdf", "afasf"); Assert.AreEqual(1, calledCount); }
public void LinkedMethodsTest6() { BeethovenFactory beethovenFactory = new BeethovenFactory(); int calledCount = 0; ValueCheck valueCheck = new ValueCheck(); ITestMethods instance = beethovenFactory.Generate <ITestMethods>( new LinkedMethods(nameof(ITestMethods.NoReturnValue)) .SkipIf(valueCheck, nameof(valueCheck.HasNoValue1)) .Action(delegate { calledCount++; })); instance.NoReturnValue("", "afasf"); instance.NoReturnValue(null, "afasf"); Assert.AreEqual(0, calledCount); instance.NoReturnValue("fdgdf", "afasf"); Assert.AreEqual(1, calledCount); }
private CodeExpression ParseFieldOrProperty(ParserContext parserContext, CodeExpression postfixExpr, string name, int namePosition, bool assignIsEquality, ValueCheck check) { CodeExpression fieldOrPropExpr = null; Type postFixExprType = Validator.ExpressionInfo(postfixExpr).ExpressionType; MemberInfo member = Validator.ResolveFieldOrProperty(postFixExprType, name); if (member == null) { // We could not find the field or property. Type type = Validator.ExpressionInfo(postfixExpr).ExpressionType; string message = string.Format(CultureInfo.CurrentCulture, Messages.UnknownFieldOrProperty, name, RuleDecompiler.DecompileType(type)); throw new RuleSyntaxException(ErrorNumbers.Error_UnknownFieldOrProperty, message, namePosition); } else { if (member.MemberType == MemberTypes.Field) fieldOrPropExpr = new CodeFieldReferenceExpression(postfixExpr, name); else fieldOrPropExpr = new CodePropertyReferenceExpression(postfixExpr, name); parserContext.exprPositions[fieldOrPropExpr] = namePosition; ValidateExpression(parserContext, fieldOrPropExpr, assignIsEquality, check); } return fieldOrPropExpr; }
// Parse: // member-operator --> . IDENTIFIER method-call-arguments // --> . IDENTIFIER // // method-call-arguments --> ( argument-list ) // --> ( ) // // argument-list --> argument argument-list-tail // --> argument // // argument-list-tail --> , argument argument-list-tail // --> , argument private CodeExpression ParseMemberOperator(ParserContext parserContext, CodeExpression primaryExpr, bool assignIsEquality, ValueCheck check) { System.Diagnostics.Debug.Assert(parserContext.CurrentToken.TokenID == TokenID.Dot); Token token = parserContext.NextToken(); // Consume the '.' if (token.TokenID != TokenID.Identifier) { if (parserContext.provideIntellisense && token.TokenID == TokenID.EndOfInput) { parserContext.SetTypeMemberCompletions(validation.ExpressionInfo(primaryExpr).ExpressionType, validation.ThisType, primaryExpr is CodeTypeReferenceExpression, validation); return null; } else { throw new RuleSyntaxException(ErrorNumbers.Error_MissingIdentifierAfterDot, Messages.Parser_MissingIdentifierAfterDot, parserContext.CurrentToken.StartPosition); } } string idName = (string)token.Value; int idPosition = token.StartPosition; CodeExpression postfixExpr = null; if (parserContext.NextToken().TokenID == TokenID.LParen) { postfixExpr = ParseMethodInvoke(parserContext, primaryExpr, idName, true); } else { postfixExpr = ParseFieldOrProperty(parserContext, primaryExpr, idName, idPosition, assignIsEquality, check); } return postfixExpr; }
// Parse: // postfix-operator --> member-operator // --> element-operator private CodeExpression TryParsePostfixOperator(ParserContext parserContext, CodeExpression primaryExpr, bool assignIsEquality, ValueCheck check) { CodeExpression postfixExpr = null; if (parserContext.CurrentToken.TokenID == TokenID.Dot) { postfixExpr = ParseMemberOperator(parserContext, primaryExpr, assignIsEquality, check); } else if (parserContext.CurrentToken.TokenID == TokenID.LBracket) { postfixExpr = ParseElementOperator(parserContext, primaryExpr, assignIsEquality); } return postfixExpr; }
// Parse: // postfix-expression --> primary-expression postfix-expression-tail // --> primary-expression // // postfix-expression-tail --> postfix-operator postfix-expression-tail // --> postfix-operator // // postfix-operator --> member-operator // --> element-operator private CodeExpression ParsePostfixExpression(ParserContext parserContext, bool assignIsEquality, ValueCheck check) { CodeExpression resultExpr = ParsePrimaryExpression(parserContext, assignIsEquality); CodeExpression postfixExpr = TryParsePostfixOperator(parserContext, resultExpr, assignIsEquality, check); while (postfixExpr != null) { resultExpr = postfixExpr; postfixExpr = TryParsePostfixOperator(parserContext, resultExpr, assignIsEquality, check); } return resultExpr; }
// Parse: // unary-expression --> unary-operator unary-expression // --> postfix-expression private CodeExpression ParseUnaryExpression(ParserContext parserContext, bool assignIsEquality, ValueCheck check) { Token currentToken = parserContext.CurrentToken; CodeExpression unaryResult = null; if (currentToken.TokenID == TokenID.Not) { int notPosition = currentToken.StartPosition; parserContext.NextToken(); unaryResult = ParseUnaryExpression(parserContext, true, check); // This becomes "subExpr == false" unaryResult = new CodeBinaryOperatorExpression(unaryResult, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false)); parserContext.exprPositions[unaryResult] = notPosition; ValidateExpression(parserContext, unaryResult, assignIsEquality, check); } else if (currentToken.TokenID == TokenID.Minus) { int negativePosition = currentToken.StartPosition; parserContext.NextToken(); unaryResult = ParseUnaryExpression(parserContext, true, check); // This becomes "0 - subExpr" unaryResult = new CodeBinaryOperatorExpression(new CodePrimitiveExpression(0), CodeBinaryOperatorType.Subtract, unaryResult); parserContext.exprPositions[unaryResult] = negativePosition; ValidateExpression(parserContext, unaryResult, assignIsEquality, check); } else if (currentToken.TokenID == TokenID.LParen) { int lparenPosition = currentToken.StartPosition; // Save the state. This may actually be a parenthesized subexpression. int savedTokenState = parserContext.SaveCurrentToken(); currentToken = parserContext.NextToken(); // Eat the '(' Type type = TryParseTypeSpecifier(parserContext, assignIsEquality); if (type == null || parserContext.CurrentToken.TokenID != TokenID.RParen) { // It wasn't a cast. // In some cases it may have looked like a cast up to a point, such as: // // (MyType.MyMember // // but "MyMember" is a static field, property, or enum. // Reset the scanner state, and re-parse as a postfix-expr parserContext.RestoreCurrentToken(savedTokenState); unaryResult = ParsePostfixExpression(parserContext, assignIsEquality, check); } else { // It is a cast. It must have a balancing ')'. if (parserContext.CurrentToken.TokenID != TokenID.RParen) throw new RuleSyntaxException(ErrorNumbers.Error_MissingRParenInSubexpression, Messages.Parser_MissingRParenInSubexpression, parserContext.CurrentToken.StartPosition); parserContext.NextToken(); unaryResult = ParseUnaryExpression(parserContext, true, check); CodeTypeReference typeRef = new CodeTypeReference(type); validation.AddTypeReference(typeRef, type); unaryResult = new CodeCastExpression(typeRef, unaryResult); parserContext.exprPositions[unaryResult] = lparenPosition; ValidateExpression(parserContext, unaryResult, assignIsEquality, check); } } else { unaryResult = ParsePostfixExpression(parserContext, assignIsEquality, check); } return unaryResult; }
private CodeExpression ParseUnaryExpression(ParserContext parserContext, bool assignIsEquality, ValueCheck check) { Token currentToken = parserContext.CurrentToken; CodeExpression expression = null; if (currentToken.TokenID == TokenID.Not) { int startPosition = currentToken.StartPosition; parserContext.NextToken(); expression = new CodeBinaryOperatorExpression(this.ParseUnaryExpression(parserContext, true, check), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false)); parserContext.exprPositions[expression] = startPosition; this.ValidateExpression(parserContext, expression, assignIsEquality, check); return expression; } if (currentToken.TokenID == TokenID.Minus) { int num2 = currentToken.StartPosition; parserContext.NextToken(); expression = this.ParseUnaryExpression(parserContext, true, check); expression = new CodeBinaryOperatorExpression(new CodePrimitiveExpression(0), CodeBinaryOperatorType.Subtract, expression); parserContext.exprPositions[expression] = num2; this.ValidateExpression(parserContext, expression, assignIsEquality, check); return expression; } if (currentToken.TokenID == TokenID.LParen) { int num3 = currentToken.StartPosition; int tokenValue = parserContext.SaveCurrentToken(); currentToken = parserContext.NextToken(); Type type = this.TryParseTypeSpecifier(parserContext, assignIsEquality); if ((type == null) || (parserContext.CurrentToken.TokenID != TokenID.RParen)) { parserContext.RestoreCurrentToken(tokenValue); return this.ParsePostfixExpression(parserContext, assignIsEquality, check); } if (parserContext.CurrentToken.TokenID != TokenID.RParen) { throw new RuleSyntaxException(0x184, Messages.Parser_MissingRParenInSubexpression, parserContext.CurrentToken.StartPosition); } parserContext.NextToken(); expression = this.ParseUnaryExpression(parserContext, true, check); CodeTypeReference typeRef = new CodeTypeReference(type); this.validation.AddTypeReference(typeRef, type); expression = new CodeCastExpression(typeRef, expression); parserContext.exprPositions[expression] = num3; this.ValidateExpression(parserContext, expression, assignIsEquality, check); return expression; } return this.ParsePostfixExpression(parserContext, assignIsEquality, check); }
private CodeExpression ParseFieldOrProperty(ParserContext parserContext, CodeExpression postfixExpr, string name, int namePosition, bool assignIsEquality, ValueCheck check) { CodeExpression expression = null; Type expressionType = this.Validator.ExpressionInfo(postfixExpr).ExpressionType; MemberInfo info = this.Validator.ResolveFieldOrProperty(expressionType, name); if (info == null) { Type type = this.Validator.ExpressionInfo(postfixExpr).ExpressionType; string message = string.Format(CultureInfo.CurrentCulture, Messages.UnknownFieldOrProperty, new object[] { name, RuleDecompiler.DecompileType(type) }); throw new RuleSyntaxException(390, message, namePosition); } if (info.MemberType == MemberTypes.Field) { expression = new CodeFieldReferenceExpression(postfixExpr, name); } else { expression = new CodePropertyReferenceExpression(postfixExpr, name); } parserContext.exprPositions[expression] = namePosition; this.ValidateExpression(parserContext, expression, assignIsEquality, check); return expression; }
private void ValidateExpression(ParserContext parserContext, CodeExpression expression, bool assignIsEquality, ValueCheck check) { if ((parserContext.CurrentToken.TokenID == TokenID.Assign) && !assignIsEquality) { check = ValueCheck.Write; } RuleExpressionInfo info = null; if ((check & ValueCheck.Read) != ValueCheck.Unknown) { info = RuleExpressionWalker.Validate(this.Validator, expression, false); if ((info != null) && ((check & ValueCheck.Write) != ValueCheck.Unknown)) { info = RuleExpressionWalker.Validate(this.Validator, expression, true); } } else if ((check & ValueCheck.Write) != ValueCheck.Unknown) { info = RuleExpressionWalker.Validate(this.Validator, expression, true); } if ((info == null) && (this.Validator.Errors.Count > 0)) { ValidationError error = this.Validator.Errors[0]; object key = error.UserData["ErrorObject"]; int num = 0; parserContext.exprPositions.TryGetValue(key, out num); throw new RuleSyntaxException(error.ErrorNumber, error.ErrorText, num); } }
public static ValueCheck[] Remove(int index, ValueCheck[] list) { ArrayList tmp = new ArrayList(); foreach(ValueCheck str in list) tmp.Add(str); tmp.RemoveAt(index); return tmp.ToArray(typeof(ValueCheck)) as ValueCheck[]; }
public static ValueCheck[] Add(ValueCheck n, ValueCheck[] list) { ArrayList tmp = new ArrayList(); foreach(ValueCheck str in list) tmp.Add(str); tmp.Add(n); return tmp.ToArray(typeof(ValueCheck)) as ValueCheck[]; }
private bool CheckValue(int val, int cVal, ValueCheck check) { bool valid = false; if(ValueCheck.EQUALS.Equals(check) && val == cVal) { valid = true; } else if(ValueCheck.LESS.Equals(check) && val < cVal) { valid = true; } else if(ValueCheck.GREATER.Equals(check) && val > cVal) { valid = true; } return valid; }
private CodeExpression ParsePostfixExpression(ParserContext parserContext, bool assignIsEquality, ValueCheck check) { CodeExpression primaryExpr = this.ParsePrimaryExpression(parserContext, assignIsEquality); for (CodeExpression expression2 = this.TryParsePostfixOperator(parserContext, primaryExpr, assignIsEquality, check); expression2 != null; expression2 = this.TryParsePostfixOperator(parserContext, primaryExpr, assignIsEquality, check)) { primaryExpr = expression2; } return primaryExpr; }
private CodeExpression ParseMemberOperator(ParserContext parserContext, CodeExpression primaryExpr, bool assignIsEquality, ValueCheck check) { Token token = parserContext.NextToken(); if (token.TokenID != TokenID.Identifier) { if (!parserContext.provideIntellisense || (token.TokenID != TokenID.EndOfInput)) { throw new RuleSyntaxException(0x185, Messages.Parser_MissingIdentifierAfterDot, parserContext.CurrentToken.StartPosition); } parserContext.SetTypeMemberCompletions(this.validation.ExpressionInfo(primaryExpr).ExpressionType, this.validation.ThisType, primaryExpr is CodeTypeReferenceExpression, this.validation); return null; } string methodName = (string) token.Value; int startPosition = token.StartPosition; if (parserContext.NextToken().TokenID == TokenID.LParen) { return this.ParseMethodInvoke(parserContext, primaryExpr, methodName, true); } return this.ParseFieldOrProperty(parserContext, primaryExpr, methodName, startPosition, assignIsEquality, check); }
private void ValidateExpression(ParserContext parserContext, CodeExpression expression, bool assignIsEquality, ValueCheck check) { // If the current token is an assignment operator, then make sure the expression is validated // correctly (written-to). Note that because we allow "=" (Token.Assign) as a synonym for // "==" (Token.Equal), we need to distinguish whether we're parsing a condition vs an action. // In other words, we need to be sure that the "=" really is an "=". if (parserContext.CurrentToken.TokenID == TokenID.Assign && !assignIsEquality) check = ValueCheck.Write; // use value in check RuleExpressionInfo exprInfo = null; if ((check & ValueCheck.Read) != 0) { exprInfo = RuleExpressionWalker.Validate(Validator, expression, false); // check write if set and first validate succeeded if ((exprInfo != null) && ((check & ValueCheck.Write) != 0)) exprInfo = RuleExpressionWalker.Validate(Validator, expression, true); } else if ((check & ValueCheck.Write) != 0) exprInfo = RuleExpressionWalker.Validate(Validator, expression, true); if (exprInfo == null && Validator.Errors.Count > 0) { // Choose the first one and throw it. ValidationError error = Validator.Errors[0]; // Try to get the position, or just use zero if we can't. object errorObject = error.UserData[RuleUserDataKeys.ErrorObject]; int position = 0; parserContext.exprPositions.TryGetValue(errorObject, out position); throw new RuleSyntaxException(error.ErrorNumber, error.ErrorText, position); } }
public void SetData(Hashtable ht) { this.statusNeeded = (StatusNeeded)System.Enum.Parse(typeof(StatusNeeded), (string)ht["statusneeded"]); this.comparison = (ValueCheck)System.Enum.Parse(typeof(ValueCheck), (string)ht["comparison"]); this.setter = (ValueSetter)System.Enum.Parse(typeof(ValueSetter), (string)ht["setter"]); this.statID = int.Parse((string)ht["statid"]); this.value = int.Parse((string)ht["value"]); if(ht.ContainsKey("classlevel")) this.classLevel = true; }
private CodeExpression ParseBinaryExpression(ParserContext parserContext, int precedence, bool assignIsEquality, ValueCheck check) { CodeExpression left = (precedence == (precedences.Length - 1)) ? this.ParseUnaryExpression(parserContext, assignIsEquality, check) : this.ParseBinaryExpression(parserContext, precedence + 1, assignIsEquality, check); if (left != null) { while (true) { Token currentToken = parserContext.CurrentToken; BinaryOperationDescriptor descriptor2 = precedences[precedence].FindOperation(currentToken.TokenID); if (descriptor2 == null) { return left; } parserContext.NextToken(); CodeExpression right = (precedence == (precedences.Length - 1)) ? this.ParseUnaryExpression(parserContext, true, check) : this.ParseBinaryExpression(parserContext, precedence + 1, true, check); left = descriptor2.CreateBinaryExpression(left, right, currentToken.StartPosition, this, parserContext, assignIsEquality); } } return left; }
public static bool CheckNumberVariable(string key, float value, ValueCheck type) { bool check = false; if(GameHandler.Instance().numberVariables.ContainsKey(key) && ((ValueCheck.EQUALS.Equals(type) && (float)GameHandler.Instance().numberVariables[key] == value) || (ValueCheck.LESS.Equals(type) && (float)GameHandler.Instance().numberVariables[key] < value) || (ValueCheck.GREATER.Equals(type) && (float)GameHandler.Instance().numberVariables[key] > value))) { check = true; } return check; }
// Parse: // // binary-expression --> unary-expresssion binary-expression-tail // --> unary-expression // // binary-expression-tail --> binary-operator-precedence unary-expression binary-expression-tail // --> binary-operator-precedence unary-expression // // binary-operator-precedence --> 0:{ || OR } // --> 1:{ && AND } // --> 2:{ | } // --> 3:{ & } // --> 4:{ = == != } // --> 5:{ < > <= >= } // --> 6:{ + - } // --> 7:{ * / % MOD } // // This method is still recursive descent, but parses each precedence group by using the operator precedence // tables defined in this class. private CodeExpression ParseBinaryExpression(ParserContext parserContext, int precedence, bool assignIsEquality, ValueCheck check) { // Must parse at least one left-hand operand. CodeExpression leftResult = (precedence == precedences.Length - 1) ? ParseUnaryExpression(parserContext, assignIsEquality, check) : ParseBinaryExpression(parserContext, precedence + 1, assignIsEquality, check); if (leftResult != null) { for (;;) { Token operatorToken = parserContext.CurrentToken; BinaryPrecedenceDescriptor precedenceDescriptor = precedences[precedence]; BinaryOperationDescriptor operationDescriptor = precedenceDescriptor.FindOperation(operatorToken.TokenID); if (operationDescriptor == null) break; // we're finished; no applicable binary operator token at this precedence level. parserContext.NextToken(); // Parse the right-hand side now. CodeExpression rightResult = (precedence == precedences.Length - 1) ? ParseUnaryExpression(parserContext, true, check) : ParseBinaryExpression(parserContext, precedence + 1, true, check); leftResult = operationDescriptor.CreateBinaryExpression(leftResult, rightResult, operatorToken.StartPosition, this, parserContext, assignIsEquality); } } return leftResult; }
public bool CompareTo(int checkValue, ValueCheck comparison, ValueSetter setter, Combatant c) { bool check = false; int value = this.currentValue; if(ValueSetter.PERCENT.Equals(setter)) { float v = value; float mv = this.maxValue; if(this.IsConsumable()) { mv = c.status[this.maxStatus].currentValue; } v /= (mv/100.0f); value = (int)v; } if((ValueCheck.EQUALS.Equals(comparison) && value == checkValue) || (ValueCheck.LESS.Equals(comparison) && value < checkValue) || (ValueCheck.GREATER.Equals(comparison) && value > checkValue)) { check = true; } return check; }
public MultiMap(ValueCheck <V> _valueCheck) { isValueNull = _valueCheck; }