/// <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;
}
