コード例 #1
0
        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");
        }
コード例 #2
0
        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");
        }
コード例 #3
0
ファイル: CodeTypeAnalysis.cs プロジェクト: irpbc/mj
        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);
        }
コード例 #4
0
ファイル: CodeTypeAnalysis.cs プロジェクト: irpbc/mj
        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);
        }
コード例 #5
0
        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;
            }
        }
コード例 #6
0
 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);
 }
コード例 #7
0
 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);
 }
コード例 #8
0
        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;
            }
        }
コード例 #9
0
ファイル: CodeTypeAnalysis.cs プロジェクト: irpbc/mj
        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);
        }
コード例 #10
0
        // 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);
        }
コード例 #11
0
        /// <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);
        }
コード例 #12
0
        /// <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;
        }
コード例 #13
0
        /// <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);
        }
コード例 #14
0
 public Operator()
 {
     operatorSymbol = OperatorSymbol.None;
 }
コード例 #15
0
ファイル: Preprocessor.cs プロジェクト: RavenB/gridsearch
		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");
		}
コード例 #16
0
ファイル: Preprocessor.cs プロジェクト: RavenB/gridsearch
		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");
		}
コード例 #17
0
        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;
        }