Example #1
0
 public static WhileSyntax While(ExpressionSyntax pCondition, BlockSyntax pBody)
 {
     return(new WhileSyntax(pCondition, pBody));
 }
Example #2
0
        public static BitwiseOrExpressionSyntax BitwiseOrExpression(ExpressionSyntax pLeft, ExpressionSyntax pRight)
        {
            var a = new BitwiseOrExpressionSyntax(0, null, null);

            a.SetLeft(pLeft);
            a.SetRight(pRight);
            return(a);
        }
Example #3
0
 public static IfSyntax If(ExpressionSyntax pCondition, BlockSyntax pBlock, ElseSyntax pElse)
 {
     return(new IfSyntax(pCondition, pBlock, pElse));
 }
Example #4
0
 public static ForSyntax For(DeclarationStatementSyntax pDeclaration, ExpressionSyntax pCondition, SyntaxNode pPostLoop, BlockSyntax pBody)
 {
     return(new ForSyntax(pDeclaration, pCondition, pPostLoop, pBody));
 }
Example #5
0
 public static ArgumentExpressionSyntax ArgumentExpression(ExpressionSyntax pValue)
 {
     return(new ArgumentExpressionSyntax(false, pValue));
 }
Example #6
0
 public static DeclarationStatementSyntax DeclarationStatement(IdentifierSyntax pLeft, ExpressionSyntax pRight)
 {
     return(new DeclarationStatementSyntax(pLeft, pRight));
 }
Example #7
0
 internal static GroupAssignmentStatementSyntax GroupAssignmentStatement(IdentifierGroupSyntax pLeft, ExpressionSyntax pValue)
 {
     return(new GroupAssignmentStatementSyntax(pLeft, pValue));
 }
Example #8
0
        public static LShiftExpressionSyntax LShiftExpression(ExpressionSyntax pLeft, ExpressionSyntax pRight)
        {
            var l = new LShiftExpressionSyntax(0, null, null);

            l.SetLeft(pLeft);
            l.SetRight(pRight);
            return(l);
        }
Example #9
0
        public static MultiplicationExpressionSyntax MultiplicationExpression(ExpressionSyntax pLeft, ExpressionSyntax pRight)
        {
            var m = new MultiplicationExpressionSyntax(0, null, null);

            m.SetLeft(pLeft);
            m.SetRight(pRight);
            return(m);
        }
Example #10
0
        public static GreaterThanExpressionSyntax GreaterThanExpression(ExpressionSyntax pLeft, ExpressionSyntax pRight)
        {
            var g = new GreaterThanExpressionSyntax(0, null, null);

            g.SetLeft(pLeft);
            g.SetRight(pRight);
            return(g);
        }
Example #11
0
        public static LessThanEqualsExpressionSyntax LessThanEqualsExpression(ExpressionSyntax pLeft, ExpressionSyntax pRight)
        {
            var l = new LessThanEqualsExpressionSyntax(0, null, null);

            l.SetLeft(pLeft);
            l.SetRight(pRight);
            return(l);
        }
Example #12
0
        public static ExponentExpressionSyntax ExponentExpression(ExpressionSyntax pLeft, ExpressionSyntax pRight)
        {
            var e = new ExponentExpressionSyntax(0, null, null);

            e.SetLeft(pLeft);
            e.SetRight(pRight);
            return(e);
        }
Example #13
0
        public static DivisionExpressionSyntax DivisionExpression(ExpressionSyntax pLeft, ExpressionSyntax pRight)
        {
            var d = new DivisionExpressionSyntax(0, null, null);

            d.SetLeft(pLeft);
            d.SetRight(pRight);
            return(d);
        }
Example #14
0
        public static ConcatenateExpressionSyntax ConcatenateExpression(ExpressionSyntax pLeft, ExpressionSyntax pRight)
        {
            var c = new ConcatenateExpressionSyntax(0, null, null);

            c.SetLeft(pLeft);
            c.SetRight(pRight);
            return(c);
        }
Example #15
0
 public static ArrayLiteralSyntax ArrayLiteral(ExpressionSyntax pValue)
 {
     return(new ArrayLiteralSyntax(pValue));
 }
Example #16
0
        public static NotEqualsExpressionSyntax NotEqualsExpression(ExpressionSyntax pLeft, ExpressionSyntax pRight)
        {
            var n = new NotEqualsExpressionSyntax(0, null, null);

            n.SetLeft(pLeft);
            n.SetRight(pRight);
            return(n);
        }
Example #17
0
 public static ArrayAccessExpressionSyntax ArrayAccessExpression(IdentifierSyntax pValue, ExpressionSyntax pIndex)
 {
     return(new ArrayAccessExpressionSyntax(pValue, pIndex));
 }
Example #18
0
        public static RShiftExpressionSyntax RShiftExpression(ExpressionSyntax pLeft, ExpressionSyntax pRight)
        {
            var r = new RShiftExpressionSyntax(0, null, null);

            r.SetLeft(pLeft);
            r.SetRight(pRight);
            return(r);
        }
Example #19
0
 public static AssignmentStatementSyntax AssignmentStatement(IdentifierSyntax pLeft, ExpressionSyntax pRight)
 {
     return(new AssignmentStatementSyntax(pLeft, pRight));
 }
Example #20
0
 public static SubAssignmentExpressionSyntax SubAssignmentExpression(IdentifierSyntax pLeft, ExpressionSyntax pRight)
 {
     return(new SubAssignmentExpressionSyntax(0, pLeft, pRight));
 }
Example #21
0
 public static ObjectInitializerExpressionSyntax ObjectInitialzer(ExpressionSyntax pLeft)
 {
     return(new ObjectInitializerExpressionSyntax(pLeft));
 }
Example #22
0
        public static SubtractionExpressionSyntax SubtractionExpression(ExpressionSyntax pLeft, ExpressionSyntax pRight)
        {
            var s = new SubtractionExpressionSyntax(0, null, null);

            s.SetLeft(pLeft);
            s.SetRight(pRight);
            return(s);
        }
Example #23
0
 public static ArgumentExpressionSyntax ArgumentExpression(bool pIsRef, ExpressionSyntax pValue)
 {
     return(new ArgumentExpressionSyntax(pIsRef, pValue));
 }
Example #24
0
        public static TernaryExpressionSyntax TernaryExpression(ExpressionSyntax pLeft, ExpressionSyntax pCenter, ExpressionSyntax pRight)
        {
            var t = new TernaryExpressionSyntax(0, null, null, null);

            t.SetLeft(pLeft);
            t.SetCenter(pCenter);
            t.SetRight(pRight);
            return(t);
        }
Example #25
0
        internal static ExpressionSyntax AssignmentExpression(TokenType pToken, IdentifierSyntax pName, ExpressionSyntax pValue)
        {
            switch (pToken)
            {
            case TokenType.PlusEquals:
                return(new AddAssignmentExpressionSyntax(0, pName, pValue));

            case TokenType.PeriodPeriodEquals:
                return(new CatAssignmentExpressionSyntax(0, pName, pValue));

            case TokenType.SlashEquals:
                return(new DivAssignmentExpressionSyntax(0, pName, pValue));

            case TokenType.StarEquals:
                return(new MulAssignmentExpressionSyntax(0, pName, pValue));

            case TokenType.MinusEquals:
                return(new SubAssignmentExpressionSyntax(0, pName, pValue));

            default:
                throw new Exception("Unknown assignment " + pToken.ToString());
            }
        }
Example #26
0
        public static AdditionExpressionSyntax AdditionExpression(ExpressionSyntax pLeft, ExpressionSyntax pRight)
        {
            var a = new AdditionExpressionSyntax(0, null, null);

            a.SetLeft(pLeft);
            a.SetRight(pRight);
            return(a);
        }