public static BinaryExpression Create(Expression left, Expression right, char oper) { BinaryExpression expr = null; switch(oper) { case '+' : expr = new AdditiveExpression(left,right); break; case '-': expr = new SubstractExpression(left, right); break; case '*' : expr = new MultiplicativeExpression(left,right); break; case '/' : expr = new DivisionExpression(left,right); break; } expr.oper = oper; return expr; }
public virtual object Walk(MultiplicativeExpression node) { if (Enter(node)) { node.LeftExpression.Accept(this); if (node.RightExpression != null) { node.RightExpression.Accept(this); } } Exit(node); return(null); }
// [30] MultiplicativeExpression = CastExpression {('*' | '/' | '%') CastExpression}. private bool IsMultiplicativeExpression(out MultiplicativeExpression multiplicativeExpression) { multiplicativeExpression = new MultiplicativeExpression(); if (!IsCastExpression(out var castExpression)) { return(false); } while (CheckToken(SyntaxKind.AsteriskToken) || CheckToken(SyntaxKind.SlashToken) || CheckToken(SyntaxKind.PercentToken)) { if (!IsCastExpression(out var moreCastExpression)) { return(false); } } return(true); }
private Expression TryParseMultiplicativeExpression() { Expression left; if ((left = TryParseUnary()) == null) { return(null); } IOperator multiplicativeOperator; while ((multiplicativeOperator = TryParseOperator()) is MultiplicativeOperator) { _scanner.Next(); Expression right = TryParseUnary() ?? throw new UnexpectedToken(_scanner.CurrentToken.Position); left = new MultiplicativeExpression(left, right, multiplicativeOperator as MultiplicativeOperator); } return(left); }
public override object Walk(MultiplicativeExpression node) { var lv = node.LeftExpression.Accept(this); var rv = node.RightExpression.Accept(this); switch (node.Operator) { case TokenType.Multiply: return(OpMultiply(lv, rv)); case TokenType.Divide: return(OpDivide(lv, rv)); case TokenType.Modulus: return(Modulus(lv, rv)); default: throw ErrorFactory.CreateInvalidProgramError("Invalid multiplicative operator"); } }
public ExprNode ParseMultiplicativeExpression() { var exp = new MultiplicativeExpression { Token = Next(), LeftExpression = ParseUnaryExpression() }; if (Next().IsNot(TokenType.Multiply) && Next().IsNot(TokenType.Divide) && Next().IsNot(TokenType.Modulus)) { return(exp.LeftExpression); } exp.Operator = Next().Type; Consume(); exp.RightExpression = ParseMultiplicativeExpression(); return(exp); }
public virtual void Exit(MultiplicativeExpression node) { }
public virtual bool Enter(MultiplicativeExpression node) { return(true); }
public void VisitMultiplicativeExpression(MultiplicativeExpression multiplicativeExpression) { VisitExpression(multiplicativeExpression.Left); object left = ReturnValue; VisitExpression(multiplicativeExpression.Right); object right = ReturnValue; ReturnValue = double.NaN; if (left != null && right != null) { switch (multiplicativeExpression.Operator) { case TokenType.Mul: ReturnValue = ConvertToNumber(left) * ConvertToNumber(right); break; case TokenType.Div: ReturnValue = ConvertToNumber(left) / ConvertToNumber(right); break; } } }
/// <summary> /// The following are rules for C expressions. /// </summary> public static void SetExpressionRules() { // expression // : assignment-expression [ ',' assignment-expression ]* Expression.Is( AssignmentExpression .OneOrMore(Comma) .Then(exprs => { if (exprs.Count == 1) { return(exprs[0]); } return(AssignmentList.Create(exprs)); }) ); // primary-expression // : identifier # Cannot be a typedef name. // | constant // | string-literal // | '(' expression ')' PrimaryExpression.Is( Either(Variable) .Or(Constant) .Or(StringLiteral) .Or( (LeftParen).Then(Expression).Then(RightParen) ) ); // An identifier for a variable must not be defined as a typedef name. Variable.Is( Identifier.Check(result => !result.Environment.IsTypedefName(result.Result)).Then(AST.Variable.Create) ); // constant // : const-char // : const-int // : const-float Constant.Is( Either(ConstChar) .Or(ConstInt) .Or(ConstFloat) ); // constant-expression // : conditional-expression // // Note: // The size of an array should be a constant. // Note that the check is actually performed in semantic analysis. ConstantExpression.Is( ConditionalExpression ); // conditional-expression // : logical-or-expression [ '?' expression ':' conditional-expression ]? ConditionalExpression.Is( (LogicalOrExpression) .Then( Given <Expr>() .Then(Question) .Then(Expression) .Then(Colon) .Then(ConditionalExpression) .Then(AST.ConditionalExpression.Create) .Optional() ) ); // assignment-expression // : unary-expression assignment-operator assignment-expression # first-set = first-set(unary-expression) // | conditional-expression # first-set = first-set(cast-expression) = first-set(unary-expression) ++ { '(' } // // Note: // Assignment operators are: // '=', '*=', '/=', '%=', '+=', '-=', '<<=', '>>=', '&=', '^=', '|=' AssignmentExpression.Is( Either( AssignmentOperator( UnaryExpression, AssignmentExpression, BinaryOperatorBuilder.Create(Assign, Assignment.Create), BinaryOperatorBuilder.Create(MultAssign, AST.MultAssign.Create), BinaryOperatorBuilder.Create(DivAssign, AST.DivAssign.Create), BinaryOperatorBuilder.Create(ModAssign, AST.ModAssign.Create), BinaryOperatorBuilder.Create(AddAssign, AST.AddAssign.Create), BinaryOperatorBuilder.Create(SubAssign, AST.SubAssign.Create), BinaryOperatorBuilder.Create(LeftShiftAssign, LShiftAssign.Create), BinaryOperatorBuilder.Create(RightShiftAssign, RShiftAssign.Create), BinaryOperatorBuilder.Create(BitwiseAndAssign, AST.BitwiseAndAssign.Create), BinaryOperatorBuilder.Create(XorAssign, AST.XorAssign.Create), BinaryOperatorBuilder.Create(BitwiseOrAssign, AST.BitwiseOrAssign.Create) ) ).Or( ConditionalExpression ) ); // postfix-expression // : primary-expression [ // '[' expression ']' # Get element from array // | '(' [argument-expression-list]? ')' # Function call // | '.' identifier # Get member from struct/union // | '->' identifier # Get member from struct/union // | '++' # Increment // | '--' # Decrement // ]* PostfixExpression.Is( PrimaryExpression .Then( Either( Given <Expr>() .Then(LeftBracket) .Then(Expression) .Then(RightBracket) .Then((array, index) => Dereference.Create(AST.Add.Create(array, index))) ).Or( Given <Expr>() .Then(LeftParen) .Then(ArgumentExpressionList.Optional(ImmutableList <Expr> .Empty)) .Then(RightParen) .Then(FuncCall.Create) ).Or( Given <Expr>() .Then(Period) .Then(Identifier) .Then(Attribute.Create) ).Or( Given <Expr>() .Then(RightArrow) .Then(Identifier) .Then((expr, member) => Attribute.Create(Dereference.Create(expr), member)) ).Or( Given <Expr>() .Then(Increment) .Then(PostIncrement.Create) ).Or( Given <Expr>() .Then(Decrement) .Then(PostDecrement.Create) ).ZeroOrMore() ) ); // argument-expression-list // : assignment-expression [ ',' assignment-expression ]* ArgumentExpressionList.Is( AssignmentExpression.OneOrMore(Comma) ); // unary-expression // : postfix-expression # first-set = { id, const, string } // | '++' unary-expression # first-set = { '++' } // | '--' unary-expression # first-set = { '--' } // | unary-operator cast-expression # first-set = { '&', '*', '+', '-', '~', '!' } // | 'sizeof' unary-expression # first-set = { 'sizeof' } // | 'sizeof' '(' Type-name ')' # first-set = { 'sizeof' } // // Notes: // 1. unary-operator can be '&', '*', '+', '-', '~', '!'. // 2. The last two rules are ambiguous: you can't figure out whether the x in sizeof(x) is a typedef of a variable. // I have a parser hack for this: add a parser environment to track all the typedefs. // 3. first_set = first_set(postfix-expression) + { '++', '--', '&', '*', '+', '-', '~', '!', 'sizeof' } // = first_set(primary-expression) + { '++', '--', '&', '*', '+', '-', '~', '!', 'sizeof' } // = { id, const, string, '++', '--', '&', '*', '+', '-', '~', '!', 'sizeof' } UnaryExpression.Is( Either( PostfixExpression ).Or( (Increment).Then(UnaryExpression).Then(PreIncrement.Create) ).Or( (Decrement).Then(UnaryExpression).Then(PreDecrement.Create) ).Or( (BitwiseAnd).Then(CastExpression).Then(Reference.Create) ).Or( (Mult).Then(CastExpression).Then(Dereference.Create) ).Or( (Add).Then(CastExpression).Then(Positive.Create) ).Or( (Sub).Then(CastExpression).Then(Negative.Create) ).Or( (BitwiseNot).Then(CastExpression).Then(AST.BitwiseNot.Create) ).Or( (LogicalNot).Then(CastExpression).Then(AST.LogicalNot.Create) ).Or( (SizeOf).Then(UnaryExpression).Then(SizeofExpr.Create) ).Or( (SizeOf).Then(LeftParen).Then(TypeName).Then(RightParen).Then(SizeofType.Create) ) ); // cast-expression // : unary-expression # first-set = { id, const, string, '++', '--', '&', '*', '+', '-', '~', '!', 'sizeof' } // | '(' type_name ')' cast-expression # first-set = '(' CastExpression.Is( Either( UnaryExpression ).Or( (LeftParen).Then(TypeName).Then(RightParen).Then(CastExpression) .Then(TypeCast.Create) ) ); // multiplicative-expression // : cast-expression [ [ '*' | '/' | '%' ] cast-expression ]* MultiplicativeExpression.Is( BinaryOperator( CastExpression, BinaryOperatorBuilder.Create(Mult, Multiply.Create), BinaryOperatorBuilder.Create(Div, Divide.Create), BinaryOperatorBuilder.Create(Mod, Modulo.Create) ) ); // additive-expression // : multiplicative-expression [ [ '+' | '-' ] multiplicative-expression ]* AdditiveExpression.Is( BinaryOperator( MultiplicativeExpression, BinaryOperatorBuilder.Create(Add, AST.Add.Create), BinaryOperatorBuilder.Create(Sub, AST.Sub.Create) ) ); // shift-expression // : additive-expression [ [ '<<' | '>>' ] additive-expression ]* ShiftExpression.Is( BinaryOperator( AdditiveExpression, BinaryOperatorBuilder.Create(LeftShift, LShift.Create), BinaryOperatorBuilder.Create(RightShift, RShift.Create) ) ); // relational-expression // : shift-expression [ [ '<' | '>' | '<=' | '>=' ] shift-expression ]* RelationalExpression.Is( BinaryOperator( ShiftExpression, BinaryOperatorBuilder.Create(Less, AST.Less.Create), BinaryOperatorBuilder.Create(Greater, AST.Greater.Create), BinaryOperatorBuilder.Create(LessEqual, LEqual.Create), BinaryOperatorBuilder.Create(GreaterEqual, GEqual.Create) ) ); // equality-expression // : relational-expression [ [ '==' | '!=' ] relational-expression ]* EqualityExpression.Is( BinaryOperator( RelationalExpression, BinaryOperatorBuilder.Create(Equal, AST.Equal.Create), BinaryOperatorBuilder.Create(NotEqual, AST.NotEqual.Create) ) ); // and-expression // : equality-expression [ '&' equality-expression ]* AndExpression.Is( BinaryOperator( EqualityExpression, BinaryOperatorBuilder.Create(BitwiseAnd, AST.BitwiseAnd.Create) ) ); // exclusive-or-expression // : and-expression [ '^' and-expression ]* ExclusiveOrExpression.Is( BinaryOperator( AndExpression, BinaryOperatorBuilder.Create(Xor, AST.Xor.Create) ) ); // inclusive-or-expression // : exclusive-or-expression [ '|' exclusive-or-expression ]* InclusiveOrExpression.Is( BinaryOperator( ExclusiveOrExpression, BinaryOperatorBuilder.Create(BitwiseOr, AST.BitwiseOr.Create) ) ); // logical-and-expression // : inclusive-or-expression [ '&&' inclusive-or-expression ]* LogicalAndExpression.Is( BinaryOperator( InclusiveOrExpression, BinaryOperatorBuilder.Create(LogicalAnd, AST.LogicalAnd.Create) ) ); // logical-or-expression // :logical-and-expression [ '||' logical-and-expression ]* LogicalOrExpression.Is( BinaryOperator( LogicalAndExpression, BinaryOperatorBuilder.Create(LogicalOr, AST.LogicalOr.Create) ) ); }
public virtual object Walk(MultiplicativeExpression node) { if (Enter(node)) { node.LeftExpression.Accept(this); if (node.RightExpression != null) node.RightExpression.Accept(this); } Exit(node); return null; }
public override bool Enter(MultiplicativeExpression node) { Print("MultiplicativeExpression ''{0}''", node.Operator); level++; return true; }
public override object Walk(MultiplicativeExpression node) { var lv = node.LeftExpression.Accept(this); var rv = node.RightExpression.Accept(this); switch (node.Operator) { case TokenType.Multiply: return OpMultiply(lv, rv); case TokenType.Divide: return OpDivide(lv, rv); case TokenType.Modulus: return Modulus(lv, rv); default: throw ErrorFactory.CreateInvalidProgramError("Invalid multiplicative operator"); } }
public ExprNode ParseMultiplicativeExpression() { var exp = new MultiplicativeExpression { Token = Next(), LeftExpression = ParseUnaryExpression() }; if (Next().IsNot(TokenType.Multiply) && Next().IsNot(TokenType.Divide) && Next().IsNot(TokenType.Modulus)) return exp.LeftExpression; exp.Operator = Next().Type; Consume(); exp.RightExpression = ParseMultiplicativeExpression(); return exp; }
public void SetUp(List <string> args) { if (verbose) { Console.WriteLine("import path:"); foreach (string directory in pathResolver.Directories) { Console.WriteLine(" " + directory); } } AppDomain domain = Thread.GetDomain(); rootModule = new Module(null, null); foreach (Assembly assembly in domain.GetAssemblies()) { AssemblyLoaded(assembly); } domain.AssemblyLoad += OnDomainAssemblyLoad; rootModule.SetName("null", null); rootModule.SetName("true", true); rootModule.SetName("false", false); rootModule.SetName("args", args); DefaultWhitespace.SetUp(rootModule, grammar); LineComment.SetUp(rootModule, grammar); BlockComment.SetUp(rootModule, grammar); Whitespace.SetUp(rootModule, grammar); Name.SetUp(rootModule, grammar); Name.SetUp(rootModule, grammar); Number.SetUp(rootModule, grammar); Base.String.SetUp(rootModule, grammar); Expression.SetUp(rootModule, grammar); ValueExpression.SetUp(rootModule, grammar); NameExpression.SetUp(rootModule, grammar); ParenExpression.SetUp(rootModule, grammar); MemberExpression.SetUp(rootModule, grammar); CallExpression.SetUp(rootModule, grammar); CallInParentScopeExpression.SetUp(rootModule, grammar); NewExpression.SetUp(rootModule, grammar); TypeExpression.SetUp(rootModule, grammar); IsExpression.SetUp(rootModule, grammar); AsExpression.SetUp(rootModule, grammar); UnaryExpression.SetUp(rootModule, grammar); NotExpression.SetUp(rootModule, grammar); MultiplicativeExpression.SetUp(rootModule, grammar); MultiplyExpression.SetUp(rootModule, grammar); DivideExpression.SetUp(rootModule, grammar); AdditiveExpression.SetUp(rootModule, grammar); AddExpression.SetUp(rootModule, grammar); SubtractExpression.SetUp(rootModule, grammar); ComparisonExpression.SetUp(rootModule, grammar); LessExpression.SetUp(rootModule, grammar); LessOrEqualExpression.SetUp(rootModule, grammar); EqualityExpression.SetUp(rootModule, grammar); InequalityExpression.SetUp(rootModule, grammar); GreaterExpression.SetUp(rootModule, grammar); GreaterOrEqualExpression.SetUp(rootModule, grammar); JunctionExpression.SetUp(rootModule, grammar); AndExpression.SetUp(rootModule, grammar); AssignmentExpression.SetUp(rootModule, grammar); AssignExpression.SetUp(rootModule, grammar); /* * NameExpression = ValueExpression * ParenExpression = ValueExpression * * CallExpression < ValueExpression * CallInParentScopeExpression = CallExpression * MemberExpression = CallExpression * * NewExpression < CallExpression * TypeExpression < NewExpression * UnaryExpression < TypeExpression * MultiplicativeExpression < UnaryExpression * AdditiveExpression < MultiplicativeExpression * ComparisonExpression < AdditiveExpression * JunctionExpression < ComparisonExpression * AssignmentExpression < JunctionExpression */ Precedence.SetPrecedence(NameExpression.pattern.Precedence, ValueExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(ParenExpression.pattern.Precedence, ValueExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(CallExpression.pattern.Precedence, ValueExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(CallInParentScopeExpression.pattern.Precedence, CallExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(MemberExpression.pattern.Precedence, CallExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(NewExpression.pattern.Precedence, CallExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(TypeExpression.pattern.Precedence, NewExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(UnaryExpression.pattern.Precedence, TypeExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(MultiplicativeExpression.pattern.Precedence, UnaryExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(AdditiveExpression.pattern.Precedence, MultiplicativeExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(ComparisonExpression.pattern.Precedence, AdditiveExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(JunctionExpression.pattern.Precedence, ComparisonExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(AssignmentExpression.pattern.Precedence, JunctionExpression.pattern.Precedence, Relation.Lower); Grammar.PatternChanged(ValueExpression.pattern, NameExpression.pattern, ParenExpression.pattern, MemberExpression.pattern, CallExpression.pattern, NewExpression.pattern, TypeExpression.pattern, UnaryExpression.pattern, MultiplicativeExpression.pattern, AdditiveExpression.pattern, ComparisonExpression.pattern, JunctionExpression.pattern, AssignmentExpression.pattern); PatternExpression.SetUp(rootModule, grammar); ReferencePatternExpression.SetUp(rootModule, grammar); AnyPatternExpression.SetUp(rootModule, grammar); TextPatternExpression.SetUp(rootModule, grammar); Option.SetUp(rootModule, grammar); BlockPatternExpression.SetUp(rootModule, grammar); ParenPatternExpression.SetUp(rootModule, grammar); TokenPatternExpression.SetUp(rootModule, grammar); RangePatternExpression.SetUp(rootModule, grammar); RepeatPatternExpression.SetUp(rootModule, grammar); AndPatternExpression.SetUp(rootModule, grammar); NotPatternExpression.SetUp(rootModule, grammar); LabelPatternExpression.SetUp(rootModule, grammar); SequencePatternExpression.SetUp(rootModule, grammar); AltPatternExpression.SetUp(rootModule, grammar); /* * EndPatternExpression = ReferencePatternExpression * AnyPatternExpression = ReferencePatternExpression * TextPatternExpression = ReferencePatternExpression * BlockPatternExpression = ReferencePatternExpression * ParenPatternExpression = ReferencePatternExpression * TokenPatternExpression = ReferencePatternExpression * * RangePatternExpression < ReferencePatternExpression * * AndPatternExpression < RangePatternExpression * NotPatternExpression = AndPatternExpression * RepeatPatternExpression = AndPatternExpression * * LabelPatternExpression < AndPatternExpression * SequencePatternExpression < LabelPatternExpression * AltPatternExpression < SequencePatternExpression */ Precedence.SetPrecedence(AnyPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(TextPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(BlockPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(ParenPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(TokenPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(RangePatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(AndPatternExpression.pattern.Precedence, RangePatternExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(NotPatternExpression.pattern.Precedence, AndPatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(RepeatPatternExpression.pattern.Precedence, AndPatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(LabelPatternExpression.pattern.Precedence, AndPatternExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(SequencePatternExpression.pattern.Precedence, LabelPatternExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(AltPatternExpression.pattern.Precedence, SequencePatternExpression.pattern.Precedence, Relation.Lower); Grammar.PatternChanged(ReferencePatternExpression.pattern, AnyPatternExpression.pattern, TextPatternExpression.pattern, BlockPatternExpression.pattern, ParenPatternExpression.pattern, TokenPatternExpression.pattern, RangePatternExpression.pattern, RepeatPatternExpression.pattern, AndPatternExpression.pattern, NotPatternExpression.pattern, LabelPatternExpression.pattern, SequencePatternExpression.pattern, AltPatternExpression.pattern); Statement.SetUp(rootModule, grammar); ExpressionStatement.SetUp(rootModule, grammar); CompoundStatement.SetUp(rootModule, grammar); PrintStatement.SetUp(rootModule, grammar); IfStatement.SetUp(rootModule, grammar); WhileStatement.SetUp(rootModule, grammar); ReturnStatement.SetUp(rootModule, grammar); ThrowStatement.SetUp(rootModule, grammar); TryStatement.SetUp(rootModule, grammar); ModuleStatement.SetUp(rootModule, grammar); FunctionStatement.SetUp(rootModule, grammar); Member.SetUp(rootModule, grammar); PatternMember.SetUp(rootModule, grammar); FieldMember.SetUp(rootModule, grammar); ConstructorMember.SetUp(rootModule, grammar); MethodMember.SetUp(rootModule, grammar); ClassStatement.SetUp(rootModule, grammar); SetPrecedenceStatement.SetUp(rootModule, grammar); UsingStatement.SetUp(rootModule, grammar); ImportStatement.SetUp(rootModule, grammar); TopLevelStatement.SetUp(rootModule, grammar); Program.SetUp(rootModule, grammar); Grammar.PatternChanged(Member.pattern, Statement.pattern); grammar.RootPattern = Program.pattern; hasBeenSetUp = true; }
public virtual bool Enter(MultiplicativeExpression node) { return true; }
public override bool Enter(MultiplicativeExpression node) { Print("MultiplicativeExpression ''{0}''", node.Operator); level++; return(true); }
public override void Exit(MultiplicativeExpression node) { level--; }