private static bool CompareStr(OperatorSymbol oper, string val1, string val2) { switch (oper) { case OperatorSymbol.Equal: return(val1 == val2); case OperatorSymbol.NotEqual: return(val1 != val2); case OperatorSymbol.LessThan: return(val1.CompareTo(val2) < 0); case OperatorSymbol.LessThanEqual: return(val1.CompareTo(val2) <= 0); case OperatorSymbol.GreaterThan: return(val1.CompareTo(val2) > 0); case OperatorSymbol.GreaterThanEqual: return(val1.CompareTo(val2) >= 0); } throw new WarningException("Unknown operator type"); }
private static bool CompareNum(OperatorSymbol oper, int val1, int val2) { switch (oper) { case OperatorSymbol.Equal: return(val1 == val2); case OperatorSymbol.NotEqual: return(val1 != val2); case OperatorSymbol.LessThan: return(val1 < val2); case OperatorSymbol.LessThanEqual: return(val1 <= val2); case OperatorSymbol.GreaterThan: return(val1 > val2); case OperatorSymbol.GreaterThanEqual: return(val1 >= val2); } throw new WarningException("Unknown operator type"); }
public override Type visitBinary(BinaryExpressionNode binary, Environment env) { Type leftType = analyzeExpr(binary.left, env); Type rightType = analyzeExpr(binary.right, env); OperatorSymbol op = operators.resolveBinary(binary.Pos, binary.opcode, leftType, rightType); binary.operatorSym = op; return(op.type.ReturnType); }
public override Type visitUnary(UnaryExpressionNode unary, Environment env) { Type operandType = analyzeExpr(unary.operand, env); if (unary.opcode.isIncDec() && !unary.operand.IsLValue) { log.error(unary.Pos, messages.incDecArgument); } OperatorSymbol op = operators.resolveUnary(unary.Pos, unary.opcode, operandType); unary.operatorSym = op; return(op.type.ReturnType); }
public void DetectOperator(string operatorString) { switch (operatorString) { case "plusButton": operatorSymbol = OperatorSymbol.Plus; break; case "minusButton": operatorSymbol = OperatorSymbol.Minus; break; case "multiplyButton": operatorSymbol = OperatorSymbol.Multiply; break; case "divideButton": operatorSymbol = OperatorSymbol.Divide; break; case "sqrtButton": operatorSymbol = OperatorSymbol.SquareRoot; break; case "squareButton": operatorSymbol = OperatorSymbol.Square; break; case "inverseButton": operatorSymbol = OperatorSymbol.Inverse; break; case "opositeButton": operatorSymbol = OperatorSymbol.Oposite; break; case "percentageButton": operatorSymbol = OperatorSymbol.Percentage; break; default: operatorSymbol = OperatorSymbol.None; break; } }
public OperatorSymbol resolveUnary(DiagnosticPosition pos, Tag tag, Type argType) { if (argType.IsError) { return(symtab.errorOpSymbol); } OperatorSymbol[] variants = this.operators[tag.operatorIndex()]; for (var i = 0; i < variants.Length; i++) { OperatorSymbol op = variants[i]; // We check for exact match for unary operators if (op.type.ParameterTypes[0] == argType.BaseType) { return(op); } } log.error(pos, messages.unresolvedUnaryOperator, operatorNames[tag.operatorIndex()], argType); return(symtab.errorOpSymbol); }
public OperatorSymbol resolveBinary(DiagnosticPosition pos, Tag tag, Type leftType, Type rightType) { if (leftType.IsError || rightType.IsError) { return(symtab.errorOpSymbol); } OperatorSymbol[] variants = this.operators[tag.operatorIndex()]; for (var i = 0; i < variants.Length; i++) { OperatorSymbol op = variants[i]; IList <Type> paramTypes = op.type.ParameterTypes; // We take numeric promotion into account if (typings.isAssignableFrom(paramTypes[0], leftType) && typings.isAssignableFrom(paramTypes[1], rightType)) { return(op); } } log.error(pos, messages.unresolvedBinaryOperator, operatorNames[tag.operatorIndex()], leftType, rightType); return(symtab.errorOpSymbol); }
private void operation_Click(object sender, RoutedEventArgs e) { lastNum = double.Parse(resultLabel.Content.ToString()); resultLabel.Content = "0"; if (sender == divideLabel) { operatorSymbol = OperatorSymbol.Division; } if (sender == multiLabel) { operatorSymbol = OperatorSymbol.Multiplication; } if (sender == sumLabel) { operatorSymbol = OperatorSymbol.Addition; } if (sender == minusLabel) { operatorSymbol = OperatorSymbol.Substraction; } }
public override Type visitCompoundAssign(CompoundAssignNode compAssign, Environment env) { Expression assignLeft = compAssign.left; bool lValueError = !assignLeft.IsLValue; if (lValueError) { log.error(compAssign.Pos, messages.assignmentLHS); } Type lType = analyzeExpr(assignLeft, env); Type rType = analyzeExpr(compAssign.right, env); if (assignLeft is Select s && s.symbol == symtab.arrayLengthField) { log.error(s.Pos, "Array length is read only"); return(symtab.errorType); } OperatorSymbol op = operators.resolveBinary(compAssign.Pos, compAssign.opcode.baseOperator(), lType, rType); compAssign.operatorSym = op; return(op.type.ReturnType); }
// Very very simple expression parser. Can only match expressions of the form // <var> <op> <value>: // OS = Windows // OS != Linux // RuntimeMinor > 0 private bool ParseExpression(string exp) { if (exp == null) { throw new ArgumentException("Invalid expression, cannot be null"); } exp = exp.Trim(); if (exp.Length < 1) { throw new ArgumentException("Invalid expression, cannot be 0 length"); } string id = ""; string str = ""; OperatorSymbol oper = OperatorSymbol.None; bool inStr = false; for (int i = 0; i < exp.Length; i++) { char c = exp[i]; if (Char.IsWhiteSpace(c)) { continue; } if (Char.IsLetterOrDigit(c) || c == '_') { if (inStr) { str += c; } else { id += c; } } else if (c == '\"') { inStr = !inStr; if (inStr) { str = ""; } } else { if (inStr) { str += c; } else { switch (c) { case '=': oper = OperatorSymbol.Equal; break; case '!': if (NextChar(i, exp) == '=') { oper = OperatorSymbol.NotEqual; } break; case '<': if (NextChar(i, exp) == '=') { oper = OperatorSymbol.LessThanEqual; } else { oper = OperatorSymbol.LessThan; } break; case '>': if (NextChar(i, exp) == '=') { oper = OperatorSymbol.GreaterThanEqual; } else { oper = OperatorSymbol.GreaterThan; } break; } } } } if (inStr) { throw new WarningException("Expected end of string in expression"); } if (oper == OperatorSymbol.None) { throw new WarningException("Expected operator in expression"); } if (id.Length < 1) { throw new WarningException("Expected identifier in expression"); } if (str.Length < 1) { throw new WarningException("Expected value in expression"); } bool ret; try { object val = m_Variables[id.ToLower()]; if (val == null) { throw new WarningException("Unknown identifier '{0}'", id); } Type t = val.GetType(); if (t.IsAssignableFrom(typeof(int))) { int numVal = (int)val; int numVal2 = Int32.Parse(str); ret = CompareNum(oper, numVal, numVal2); } else { string strVal = val.ToString(); string strVal2 = str; ret = CompareStr(oper, strVal, strVal2); } } catch (ArgumentException ex) { ex.ToString(); throw new WarningException("Invalid value type for system variable '{0}', expected int", id); } return(ret); }
/// <summary> /// Reads an unsafe access expression. /// </summary> /// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param> /// <returns>Returns the expression.</returns> private UnsafeAccessExpression GetUnsafeAccessExpression(bool unsafeCode) { Param.Assert(unsafeCode == true, "unsafeCode", "Un unsafe access must reside in an unsafe code block."); // Get the operator symbol. Symbol symbol = this.GetNextSymbol(); OperatorType operatorType; UnsafeAccessExpression.Operator unsafeOperatorType; if (symbol.SymbolType == SymbolType.LogicalAnd) { operatorType = OperatorType.AddressOf; unsafeOperatorType = UnsafeAccessExpression.Operator.AddressOf; } else if (symbol.SymbolType == SymbolType.Multiplication) { operatorType = OperatorType.Dereference; unsafeOperatorType = UnsafeAccessExpression.Operator.Dereference; } else { Debug.Fail("Unexpected operator type."); throw new InvalidOperationException(); } // Create a token for the operator symbol. this.symbols.Advance(); OperatorSymbol token = new OperatorSymbol( symbol.Text, OperatorCategory.Reference, operatorType, symbol.Location, this.symbols.Generated); Node<CsToken> tokenNode = this.tokens.InsertLast(token); // Get the expression being accessed. Expression expression = this.GetNextExpression(ExpressionPrecedence.Unary, unsafeCode); if (expression == null || expression.Tokens.First == null) { throw new SyntaxException(this.document.SourceCode, symbol.LineNumber); } // Create the partial token list for the expression. CsTokenList partialTokens = new CsTokenList(this.tokens, tokenNode, this.tokens.Last); // Create and return the expression. return new UnsafeAccessExpression(partialTokens, unsafeOperatorType, expression); }
/// <summary> /// Reads an unsafe type expression. /// </summary> /// <param name="type">The type expression.</param> /// <param name="previousPrecedence">The precedence of the previous expression.</param> /// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param> /// <returns>Returns the expression.</returns> private UnsafeAccessExpression GetUnsafeTypeExpression( Expression type, ExpressionPrecedence previousPrecedence, bool unsafeCode) { Param.Ignore(type); Param.AssertNotNull(previousPrecedence, "previousPrecedence"); Param.Assert(unsafeCode == true, "unsafeCode", "An unsafe type must reside in an unsafe code block."); UnsafeAccessExpression expression = null; if (this.CheckPrecedence(previousPrecedence, ExpressionPrecedence.Unary)) { // Get the operator symbol. Symbol symbol = this.GetNextSymbol(); OperatorType operatorType; UnsafeAccessExpression.Operator unsafeOperatorType; if (symbol.SymbolType == SymbolType.LogicalAnd) { operatorType = OperatorType.AddressOf; unsafeOperatorType = UnsafeAccessExpression.Operator.AddressOf; } else if (symbol.SymbolType == SymbolType.Multiplication) { operatorType = OperatorType.Dereference; unsafeOperatorType = UnsafeAccessExpression.Operator.Dereference; } else { Debug.Fail("Unexpected operator type."); throw new InvalidOperationException(); } // Create a token for the operator symbol. this.symbols.Advance(); OperatorSymbol token = new OperatorSymbol( symbol.Text, OperatorCategory.Reference, operatorType, symbol.Location, this.symbols.Generated); this.tokens.Add(token); // Create the partial token list for the expression. CsTokenList partialTokens = new CsTokenList(this.tokens, type.Tokens.First, this.tokens.Last); // Create and return the expression. expression = new UnsafeAccessExpression(partialTokens, unsafeOperatorType, type); } return expression; }
/// <summary> /// Reads a unary expression. /// </summary> /// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param> /// <returns>Returns the expression.</returns> private UnaryExpression GetUnaryExpression(bool unsafeCode) { Param.Ignore(unsafeCode); // Create the token based on the type of the symbol. Symbol symbol = this.GetNextSymbol(); OperatorSymbol token; UnaryExpression.Operator operatorType; if (symbol.SymbolType == SymbolType.Plus) { operatorType = UnaryExpression.Operator.Positive; token = new OperatorSymbol(symbol.Text, OperatorCategory.Unary, OperatorType.Positive, symbol.Location, this.symbols.Generated); } else if (symbol.SymbolType == SymbolType.Minus) { operatorType = UnaryExpression.Operator.Negative; token = new OperatorSymbol(symbol.Text, OperatorCategory.Unary, OperatorType.Negative, symbol.Location, this.symbols.Generated); } else if (symbol.SymbolType == SymbolType.Not) { operatorType = UnaryExpression.Operator.Not; token = new OperatorSymbol(symbol.Text, OperatorCategory.Unary, OperatorType.Not, symbol.Location, this.symbols.Generated); } else if (symbol.SymbolType == SymbolType.Tilde) { operatorType = UnaryExpression.Operator.BitwiseCompliment; token = new OperatorSymbol(symbol.Text, OperatorCategory.Unary, OperatorType.BitwiseCompliment, symbol.Location, this.symbols.Generated); } else { // This is not a unary type. Debug.Fail("Unexpected operator type"); throw new SourceAnalysisException(); } Node<CsToken> tokenNode = this.tokens.InsertLast(token); this.symbols.Advance(); // Get the expression after the operator. Expression expression = this.GetNextExpression(ExpressionPrecedence.Unary, unsafeCode); if (expression == null || expression.Tokens.First == null) { throw this.CreateSyntaxException(); } // Create the partial token list for the expression. CsTokenList partialTokens = new CsTokenList(this.tokens, tokenNode, this.tokens.Last); // Create and return the expression. return new UnaryExpression(partialTokens, operatorType, expression); }
public Operator() { operatorSymbol = OperatorSymbol.None; }
private static bool CompareNum(OperatorSymbol oper, int val1, int val2) { switch(oper) { case OperatorSymbol.Equal: return (val1 == val2); case OperatorSymbol.NotEqual: return (val1 != val2); case OperatorSymbol.LessThan: return (val1 < val2); case OperatorSymbol.LessThanEqual: return (val1 <= val2); case OperatorSymbol.GreaterThan: return (val1 > val2); case OperatorSymbol.GreaterThanEqual: return (val1 >= val2); } throw new WarningException("Unknown operator type"); }
private static bool CompareStr(OperatorSymbol oper, string val1, string val2) { switch(oper) { case OperatorSymbol.Equal: return (val1 == val2); case OperatorSymbol.NotEqual: return (val1 != val2); case OperatorSymbol.LessThan: return (val1.CompareTo(val2) < 0); case OperatorSymbol.LessThanEqual: return (val1.CompareTo(val2) <= 0); case OperatorSymbol.GreaterThan: return (val1.CompareTo(val2) > 0); case OperatorSymbol.GreaterThanEqual: return (val1.CompareTo(val2) >= 0); } throw new WarningException("Unknown operator type"); }
public static List<Symbol> MathsTextToInFixSymbolList(string Maths) { List<Symbol> InFix = new List<Symbol>(); string buffer = ""; foreach (char c in Maths) { bool IsAnOperator = false; OperatorSymbol os = new OperatorSymbol(MathOperator.Minus); if (c == '+') { IsAnOperator = true; os = new OperatorSymbol(MathOperator.Plus); } else if (c == '-') { IsAnOperator = true; os = new OperatorSymbol(MathOperator.Minus); } else if (c == '/') { IsAnOperator = true; os = new OperatorSymbol(MathOperator.Divide); } else if (c == '*') { IsAnOperator = true; os = new OperatorSymbol(MathOperator.Multiply); } else if (c == '(') { IsAnOperator = true; os = new OperatorSymbol(MathOperator.OpenBracket); } else if (c == ')') { IsAnOperator = true; os = new OperatorSymbol(MathOperator.CloseBracket); } else if (c == '^') { IsAnOperator = true; os = new OperatorSymbol(MathOperator.Power); } else { if (c == '0' || c == '1' || c == '2' || c == '3' || c == '4' || c == '5' || c == '6' || c == '7' || c == '8' || c == '9' || c == 'p' || c == 'i' ) { IsAnOperator = false; buffer += c; } } if (IsAnOperator) { if (buffer != "") { if (buffer == "pi") { PiSymbol ps = new PiSymbol(1); InFix.Add(ps); buffer = ""; } else { long add = long.Parse(buffer); RationalSymbol rs = new RationalSymbol(new PrecMaths.Numbers.Rational(add), 1); InFix.Add(rs); } buffer = ""; } InFix.Add(os); } } if (buffer != "") { long b = long.Parse(buffer); InFix.Add(new RationalSymbol(new Numbers.Rational(b), 1)); } return InFix; }