diff --git a/ExprLexer.g4 b/ExprLexer.g4 index 5777926..b734a93 100644 --- a/ExprLexer.g4 +++ b/ExprLexer.g4 @@ -96,7 +96,7 @@ Volatile: 'volatile'; While: 'while'; // LITERALS ------------------------------------------------------------------------------------------------------------------- -IntigerLiteral: DecimalIntegerLiteral | HexIntegerLiteral | OctalIntegerLiteral; +IntegerLiteral: DecimalIntegerLiteral | HexIntegerLiteral | OctalIntegerLiteral; fragment DecimalIntegerLiteral: DecimalNumeral IntegerTypeSuffix?; @@ -214,7 +214,7 @@ ConditionalOR: '||'; Increment: '++'; Decrement: '--'; Addition: '+'; -Subtaction: '-'; +Subtraction: '-'; Multiplication: '*'; Division: '/'; BitwiseAND: '&'; diff --git a/ExprSyntactic.g4 b/ExprSyntactic.g4 index ba6f46e..8a086fc 100644 --- a/ExprSyntactic.g4 +++ b/ExprSyntactic.g4 @@ -37,21 +37,21 @@ statementExpression: expression; constantExpression: expression; -expression1: expression2 (expression1Rest)*; +expression1: expression2 (expression1Rest)?; -expression1Rest: (Question expression Colon expression1)?; +expression1Rest: Question expression Colon expression1; -expression2: expression3 (expression2Rest)?; +expression2: expression3 expression2Rest?; -expression2Rest: (infixop expression3)* - | expression3 INSTANCEOF type; +expression2Rest: (infixop expression3)+ + | InstanceOf type; infixop: ConditionalOR | ConditionalAND | BitwiseOR | BitwiseXOR | BitwiseAND - | EqualTO + | EqualTo | NotEqualTO | LessThan | GreterThan @@ -67,8 +67,8 @@ infixop: ConditionalOR | Remainder; expression3: prefixOp expression3 // Recursion - | (expr | type) expression3 - | primary (selector)* (postfixOP)*; + | (expression | type) expression3 + | primary (selector)* (postfixOp)*; primary: (expression) | This (arguments)? @@ -79,6 +79,25 @@ primary: (expression) | basicType bracketsOpt Dot Class | Void Dot Class; +////TEST +//primary: primaryAtom primarySuffix* +// | New creator ; +// +//primaryAtom: ParenthesesLeft expression ParenthesesRight +// | This +// | literal +// | qualifiedIdentifier +// | qualifiedIdentifier Dot This +// | basicType bracketsOpt Dot Class +// | Void Dot Class +// | Super; +// +//// All selectors / postfix pieces (no recursion back to primary) +//primarySuffix: Dot Identifier arguments? +// | SquareBracketLeft expression SquareBracketRight +// | Dot Class; +////END test + identifierSuffix: SquareBracketLeft SquareBracketRight bracketsOpt Dot Class //Case []...'.'class |SquareBracketLeft expression SquareBracketRight //arr[5] |arguments @@ -101,7 +120,7 @@ selector: Dot identifier (arguments)? superSuffix: arguments | Dot identifier (arguments)?; - +//primitives basicType: Byte | Short | Char @@ -113,7 +132,7 @@ basicType: Byte //TODO: REVIEW ANYTHING BEFORE THIS POINT FOR POTENTIAL CONFUSSION ON TERMINAL SYMBOLS AND GRAMMAR argumentsOpt: (arguments)?; -arguments: ParenthesesLeft (expression (',' expression)*)? ParenthesesRight; +arguments: ParenthesesLeft (expression (Comma expression)*)? ParenthesesRight; bracketsOpt: (SquareBracketLeft SquareBracketRight)*; @@ -138,17 +157,17 @@ blockStatements: (blockStatement)*; blockStatement: localVariableDeclarationStatement |classOrInterfaceDeclaration - |(identifier Colon)?; + |(identifier Colon)? statement; localVariableDeclarationStatement: (Final)? type variableDeclarators; statement: block | If parExpression statement (Else statement)? - | For ParenthesesLeft forInitOp Semicolon (expression)? Semicolon forUpdateOpt ParenthesesRight statement + | For ParenthesesLeft forInit? Semicolon (expression)? Semicolon forUpdate? ParenthesesRight statement | While parExpression statement | Do statement While parExpression Semicolon | Try block (catches | (catches)? Finally block) - | Switch parExpression CurlyBracketLeft switchBlockStatementsGroups? CurlyBracketRight + | Switch parExpression CurlyBracketLeft switchBlockStatementGroups? CurlyBracketRight | Synchronized parExpression block | Return (expression)? Semicolon | Throw expression Semicolon @@ -162,7 +181,7 @@ catches: catchClause (catchClause)*; catchClause: Catch ParenthesesLeft formalParameter ParanthesesRight block; -switchBlockStatementGroups: (switchBlockStatementGroups)*; +switchBlockStatementGroups: (switchBlockStatementGroup)*; switchBlockStatementGroup: switchLabel blockStatements; @@ -189,14 +208,225 @@ modifier: Public | Volatile | Strictfp; -variableDeclarators: variableDeclarators (Comma variableDeclarator)*; +variableDeclarators: variableDeclarator (Comma variableDeclarator)*; -variableDeclaratorsRest: variableDeclaratorsRest (Comma variableDeclarator)*; +variableDeclaratorsRest: variableDeclaratorRest (Comma variableDeclarator)*; -constantDeclaratorRest: constantDeclaratorRest (Comma constantDeclarator)*; +constantDeclaratorsRest: constantDeclaratorRest (Comma constantDeclarator)*; variableDeclarator: identifier variableDeclaratorsRest; constantDeclarator: identifier constantDeclaratorRest; -//Little git test +variableDeclaratorRest: bracketsOpt (Assignment variableInitializer)?; + +constantDeclaratorRest: bracketsOpt Assignment variableInitializer; + +variableDeclaratorId: identifier bracketsOpt; + +compilationUnit: (Package qualifiedIdentifier Semicolon)? (importDeclaration)*; + +importDeclaration: Import identifier (Dot identifier)*(importDeclaration Multiplication)? Semicolon; + +typeDeclaration: classOrInterfaceDeclaration Semicolon; + +classOrInterfaceDeclaration: modifiersOpt (classDeclaration | interfaceDeclaration); + +classDeclaration: Class identifier (Extends type)? (Implements typeList)? classBody; + +interfaceDeclaration: Interface identifier (Extends typeList)? interfaceBody; + +typeList: type (Semicolon type)*; + +classBody: CurlyBracketLeft (classBodyDeclaration)* CurlyBracketRight; + +interfaceBody: CurlyBracketLeft (interfaceBodyDeclaration)* CurlyBracketRight; + +classBodyDeclaration: Semicolon + | (Static)? block + | modifiersOpt memberDecl; +memberDecl: methodOrFieldDecl + | Void identifier methodDeclaratorRest + | identifier constructorDeclaratorRest + | classOrInterfaceDeclaration; + +methodOrFieldDecl: type identifier methodOrFieldRest; + +methodOrFieldRest: variableDeclaratorRest + |methodDeclaratorRest; + +interfaceBodyDeclaration: Semicolon + | modifiersOpt interfaceMemberDecl; + +interfaceMemberDecl: interfaceMethodOrFieldDecl + | Void identifier voidInterfaceMethodDeclaratorRest + | classOrInterfaceDeclaration; + +interfaceMethodOrFieldDecl: type identifier interfaceMethodOrFieldRest; + +interfaceMethodOrFieldRest: constantDeclaratorRest Semicolon + | interfaceMethodDeclaratorRest; + +methodDeclaratorRest: formalParameters bracketsOpt (Throws qualifiedIdentifierList)?(methodBody | Semicolon); + +voidMethodDeclaratorRest: formalParameters (Throws qualifiedIdentifierList)? (methodBody | Semicolon); + +interfaceMethodDeclaratorRest: formalParameters bracketsOpt (Throws qualifiedIdentifierList)? Semicolon; + +voidInterfaceMethodDeclaratorRest: formalParameters (Throws qualifiedIdentifierList)?; + +constructorDeclaratorRest: formalParameters (Throws qualifiedIdentifierList)? methodBody; + +qualifiedIdentifierList: qualifiedIdentifier (Semicolon qualifiedIdentifier)*; + +formalParameters:ParenthesesLeft (formalParameters(Semicolon formalParameter))? ParanthesesRight; + +formalParameter: (Final)? type variableDeclaratorId; + +methodBody: block; + +//Things not defined within the final chapter of JSL2 +expressionStatement: statementExpression Semicolon; + +asssignmentExpression: conditionalExpression + | assignment; +assignment: leftHandSide assignmentOperator assignmentExpression; + +leftHandSide: expressionName + | fieldAccess + | arrayAccess; + +conditionalExpression: conditionalOrExpression + | conditionalOrExpression Question expression Colon conditionalExpression; + + conditionalOrExpression: + conditionalAndExpression + |conditionalOrExpression ConditionalOr conditionalAndExpression; + //Conditional And (&&) + conditionalAndExpression: + inclusiveOrExpression + |conditionalAndExpression ConditionalAnd inclusiveOrExpression; + inclusiveOrExpression: + exclusiveOrExpression + inclusiveOrExpression BitwiseOR exclusiveOrExpression; +//Assignment operators +assignmentExpression:conditionalExpression + |assignment; + + relationalExpression: + shiftExpression + |relationalExpression LessThan shiftExpression + |relationalExpression GreaterThan shiftExpression + |relationalExpression LessOrEqual shiftExpression + |relationalExpression GreaterOrEqual shiftExpression + |relationalExpression InstanceOf referenceType; + +//ShiftExpression: +shiftExpression: additiveExpression + |shiftExpression LeftShift additiveExpression + |shiftExpression SignedRightShift additiveExpression + |shiftExpression UnsignedRightShift additiveExpression; +//Additive Operators +additiveExpression: multiplicativeExpression + | additiveExpression Addition multiplicativeExpression + | additiveExpression Subtraction multiplicativeExpression; + +//Multiplicative Operators +multiplicativeExpression: unaryExpression + | multiplicativeExpression Multiplication unaryExpression + | multiplicativeExpression Division unaryExpression + | multiplicativeExpression Remainder unaryExpression; +//Unary Operators +unaryExpression: preIncrementExpression + |preDecrementExpression + |Addition unaryExpression + |Subtraction unaryExpression + |unaryExpressionNotPlusMinus; + +preIncrementExpression: Increment unaryExpression; +preDecrementExpression: Decrement unaryExpression; +unaryExpressionNotPlusMinus: postfixExpression + |BitwiseComplement unaryExpression + |LogicalComplement unaryExpression + | castExpression; +castExpression: ParenthesesLeft primitiveType ParanthesesRight unaryExpression + | ParenthesesLeft referenceType ParanthesesRight unaryExpressionNotPlusMinus; +//Primitive types +primitiveType: numericType + | Boolean; +referenceType: classOrInterfaceType + | arrayType; +classOrInterfaceType: classType + | interfaceType; +classType: typeName; +interfaceType: typeName; +//Determining meaning of Name +typeName: identifier + | packageOrTypeName Dot Identifier; +packageOrTypeName: Identifier + | packageOrTypeName Dot identifier; +arrayType: type SquareBracketLeft SquareBracketRight; +numericType: integralType + | floatingPointType; +integralType: Byte | Short | Int | Long | Char; +floatingPointType: Float | Double; +//postfix expressions +//postfixExpression: primary +// | expressionName +// | postIncrementExpression +// | postDecrementExpression; +postfixBase: primary | expressionName ; +postfixExpression : postfixBase (Increment | Decrement)* ; +postIncrementExpression: postfixExpression Increment; +postDecrementExpression: postfixExpression Decrement; + + //Equality Operators + equalityExpression: + relationalExpression + |equalityExpression EqualEqual relationalExpression + |equalityExpression NotEqualTo relationalExpression; + + //Bitwise and Logical Operators + andExpression: + equalityExpression + |andExpression BitwiseAND andExpression; + exclusiveOrExpression: + andExpression + |exclusiveOrExpression BitwiseXOR andExpression; +expressionName: Identifier (Dot Identifier)*; +fieldAccess + : primary Dot Identifier + | Super Dot Identifier + | typeName Dot Super Dot Identifier + ; + +primaryNoNewArray: literal + | type Dot Class + |Void Dot Class + |This + |qualifiedIdentifier Dot This + |ParenthesesLeft expression ParanthesesRight + |classInstanceCreationExpression + |fieldAccess + |methodInvocation + |arrayAccess; + +classInstanceCreationExpression: New classOrInterfaceType ParenthesesLeft argumentsOpt ParanthesesRight classBody + | primary New identifier ParenthesesLeft argumentsOpt ParanthesesRight classBody; + +methodInvocation: methodName arguments + | primary Dot Identifier arguments + | Super Dot Identifier arguments + | typeName Dot Super Dot Identifier arguments; +methodName + : Identifier (Dot Identifier)*; + +//arguments: ParenthesesLeft argumentList? ParanthesesRight; + +argumentList: expression (Comma expression)*; + + + + + +