public static IExpressionNode CreateNode(ExpressionTypes type)
        {
            IExpressionNode node = null;

            switch (type)
            {
                case ExpressionTypes.BlockExpression:
                    node = new PExpression();
                    break;
                case ExpressionTypes.StatementExpression:
                    node = new StatementExpressionNode();
                    break;
                case ExpressionTypes.UnaryExpression:
                    break;
                case ExpressionTypes.BinaryExpression:
                    node = new BinaryExpressionNode();
                    break;
                case ExpressionTypes.TernaryExpression:
                    break;
                case ExpressionTypes.IdentifierExpression:
                    break;
                case ExpressionTypes.ValueExpression:
                    node = new ValueExpressionNode();
                    break;
            }

            return node;
        }
Example #2
0
        public BuiltInType(ExpressionTypes type, Ast src = null)
            : base(type.ToString())
        {
            ExpressionType = type;

            Src = src;
        }
Example #3
0
        public static IExpressionNode CreateNode(ExpressionTypes type)
        {
            IExpressionNode node = null;

            switch (type)
            {
            case ExpressionTypes.BlockExpression:
                node = new PExpression();
                break;

            case ExpressionTypes.StatementExpression:
                node = new StatementExpressionNode();
                break;

            case ExpressionTypes.UnaryExpression:
                break;

            case ExpressionTypes.BinaryExpression:
                node = new BinaryExpressionNode();
                break;

            case ExpressionTypes.TernaryExpression:
                break;

            case ExpressionTypes.IdentifierExpression:
                break;

            case ExpressionTypes.ValueExpression:
                node = new ValueExpressionNode();
                break;
            }

            return(node);
        }
Example #4
0
        public BuiltInType(ExpressionTypes type, Ast src = null)
            : base(type.ToString())
        {
            ExpressionType = type;

            Src = src;
        }
Example #5
0
 public Function(ExpressionTypes type, string name, int n) : base(type)
 {
     this.Name            = name + "#" + n;
     this.ForUserName     = name;
     this.ParametersCount = n;
     parameters           = new Expression[n];
 }
 public static bool EqualOrPromotable(ExpressionTypes item1, ExpressionTypes item2)
 {
     return(item1 == item2 ||
            item1 == ExpressionTypes.Method ||
            item2 == ExpressionTypes.Method ||
            item1 == ExpressionTypes.Inferred ||
            item2 == ExpressionTypes.Inferred ||
            item2 == ExpressionTypes.Nil || item1 == ExpressionTypes.Nil);
 }
Example #7
0
        /// <summary>
        /// Процедура присваивания левой части правой
        /// </summary>
        /// <param name="leftPart">Левая часть выражения присваивания</param>
        /// <param name="expression">Выражение присваивания</param>
        /// <param name="rightPart">Правая часть выражения присваивания</param>
        /// <returns></returns>
        public ExpressionStatementSyntax CreatingAssignmentExpression(
            string leftPart, ExpressionTypes expression, string rightPart)
        {
            var expr = SyntaxFactory.ExpressionStatement(
                SyntaxFactory.AssignmentExpression(
                    SyntaxKind.SimpleAssignmentExpression,
                    SyntaxFactory.IdentifierName(leftPart),
                    SyntaxFactory.Token(ExpressionType.Expression(expression)),
                    SyntaxFactory.IdentifierName(rightPart))).WithSemicolonToken(
                SyntaxFactory.Token(SyntaxKind.SemicolonToken))
                       .NormalizeWhitespace();

            return(expr);
        }
Example #8
0
        public static SyntaxKind Expression(ExpressionTypes expressionType)
        {
            SyntaxKind syntaxKind;

            switch (expressionType)
            {
            case ExpressionTypes.Equal:
                syntaxKind = SyntaxKind.EqualsToken;
                break;

            case ExpressionTypes.PlusEqual:
                syntaxKind = SyntaxKind.PlusEqualsToken;
                break;

            case ExpressionTypes.MinusEqual:
                syntaxKind = SyntaxKind.MinusEqualsToken;
                break;

            default:
                throw new Exception("Данный тип присваивания " +
                                    "не соответствует обрабатываемым типам присваивания");
            }
            return(syntaxKind);
        }
Example #9
0
 public Pluss(ExpressionTypes type, Expression p1, Expression p2) : base(type, p1, p2)
 {
 }
Example #10
0
 public Operator(ExpressionTypes type, Expression p1, Expression p2) : base(type)
 {
     this.param1 = p1;
     this.param2 = p2;
 }
Example #11
0
 public NotEqual(ExpressionTypes type, Expression p1, Expression p2) : base(type, p1, p2)
 {
 }
Example #12
0
 public void SetType(ExpressionTypes type)
 {
     base.Type = type;
 }
Example #13
0
 public Expression(ExpressionTypes type)
 {
     Type = type;
 }