diff --git a/.gitignore b/.gitignore index a1c2a23..0384afc 100644 --- a/.gitignore +++ b/.gitignore @@ -1,23 +1,2 @@ -# Compiled class file -*.class - -# Log file -*.log - -# BlueJ files -*.ctxt - -# Mobile Tools for Java (J2ME) -.mtj.tmp/ - -# Package Files # -*.jar -*.war -*.nar -*.ear -*.zip -*.tar.gz -*.rar - -# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml -hs_err_pid* +/gen/ +/input/JavaScriptLexer.tokens \ No newline at end of file diff --git a/build.gradle b/build.gradle new file mode 100644 index 0000000..5ed0b48 --- /dev/null +++ b/build.gradle @@ -0,0 +1,32 @@ +plugins { + id 'java' + id 'java-library' +} + +sourceSets { + main { + java { + srcDir 'src/main/entry' + } + resources { + srcDir 'src/main/resources' + } + } + test { + java { + srcDir 'src/test/java' + } + resources { + srcDir 'src/test/resources' + } + } +} + +dependencies { + api 'log4j:log4j:1.2.17' + api 'org.antlr:antlr4:4.9.2' + api 'org.apache.logging.log4j:log4j-core:2.14.1' + api 'org.apache.logging.log4j:log4j-api:2.14.1' + + testImplementation 'junit:junit:4.13.2' +} \ No newline at end of file diff --git a/input/ExprParser.g4 b/input/ExprParser.g4 new file mode 100644 index 0000000..22c81c9 --- /dev/null +++ b/input/ExprParser.g4 @@ -0,0 +1,10 @@ +parser grammar ExprParser; + +options { + tokenVocab=JavaScriptLexer; + superClass=JavaScriptBaseParser; +} + +program + :Contract Identifier '{' '}' + ; \ No newline at end of file diff --git a/input/JavaScriptBaseLexer.java b/input/JavaScriptBaseLexer.java new file mode 100644 index 0000000..ffb38cb --- /dev/null +++ b/input/JavaScriptBaseLexer.java @@ -0,0 +1,119 @@ +package org.bdware.sc.parser; +import org.antlr.v4.runtime.*; +import java.util.Stack; +public abstract class JavaScriptBaseLexer extends Lexer +{ + /** + * Stores values of nested modes. By default mode is strict or + * defined externally (useStrictDefault) + */ + private Stack scopeStrictModes = new Stack(); + + private Token lastToken = null; + /** + * Default value of strict mode + * Can be defined externally by setUseStrictDefault + */ + private boolean useStrictDefault = false; + /** + * Current value of strict mode + * Can be defined during parsing, see StringFunctions.js and StringGlobal.js samples + */ + private boolean useStrictCurrent = false; + + public JavaScriptBaseLexer(CharStream input) { + super(input); + } + + public boolean getStrictDefault() { + return useStrictDefault; + } + + public void setUseStrictDefault(boolean value) { + useStrictDefault = value; + useStrictCurrent = value; + } + + public boolean IsStrictMode() { + return useStrictCurrent; + } + + /** + * Return the next token from the character stream and records this last + * token in case it resides on the default channel. This recorded token + * is used to determine when the lexer could possibly match a regex + * literal. Also changes scopeStrictModes stack if tokenize special + * string 'use strict'; + * + * @return the next token from the character stream. + */ + @Override + public Token nextToken() { + Token next = super.nextToken(); + + if (next.getChannel() == Token.DEFAULT_CHANNEL) { + // Keep track of the last token on the default channel. + this.lastToken = next; + } + + return next; + } + + protected void ProcessOpenBrace() + { + useStrictCurrent = scopeStrictModes.size() > 0 && scopeStrictModes.peek() ? true : useStrictDefault; + scopeStrictModes.push(useStrictCurrent); + } + + protected void ProcessCloseBrace() + { + useStrictCurrent = scopeStrictModes.size() > 0 ? scopeStrictModes.pop() : useStrictDefault; + } + + protected void ProcessStringLiteral() + { + if (lastToken == null || lastToken.getType() == JavaScriptLexer.OpenBrace) + { + String text = getText(); + if (text.equals("\"use strict\"") || text.equals("'use strict'")) + { + if (scopeStrictModes.size() > 0) + scopeStrictModes.pop(); + useStrictCurrent = true; + scopeStrictModes.push(useStrictCurrent); + } + } + } + + /** + * Returns {@code true} if the lexer can match a regex literal. + */ + protected boolean IsRegexPossible() { + + if (this.lastToken == null) { + // No token has been produced yet: at the start of the input, + // no division is possible, so a regex literal _is_ possible. + return true; + } + + switch (this.lastToken.getType()) { + case JavaScriptLexer.Identifier: + case JavaScriptLexer.NullLiteral: + case JavaScriptLexer.BooleanLiteral: + case JavaScriptLexer.This: + case JavaScriptLexer.CloseBracket: + case JavaScriptLexer.CloseParen: + case JavaScriptLexer.OctalIntegerLiteral: + case JavaScriptLexer.DecimalLiteral: + case JavaScriptLexer.HexIntegerLiteral: + case JavaScriptLexer.StringLiteral: + case JavaScriptLexer.PlusPlus: + case JavaScriptLexer.MinusMinus: + // After any of the tokens above, no regex literal can follow. + return false; + default: + // In all other cases, a regex literal _is_ possible. + return true; + } + } +} \ No newline at end of file diff --git a/input/JavaScriptBaseParser.java b/input/JavaScriptBaseParser.java new file mode 100644 index 0000000..2c41620 --- /dev/null +++ b/input/JavaScriptBaseParser.java @@ -0,0 +1,114 @@ +package org.bdware.sc.parser; + +import org.antlr.v4.runtime.*; + +/** + * All parser methods that used in grammar (p, prev, notLineTerminator, etc.) + * should start with lower case char similar to parser rules. + */ +public abstract class JavaScriptBaseParser extends Parser { + public JavaScriptBaseParser(TokenStream input) { + super(input); + } + + /** + * Short form for prev(String str) + */ + protected boolean p(String str) { + return prev(str); + } + + /** + * Whether the previous token value equals to @param str + */ + protected boolean prev(String str) { + return _input.LT(-1).getText().equals(str); + } + + /** + * Short form for next(String str) + */ + protected boolean n(String str) { + return next(str); + } + + /** + * Whether the next token value equals to @param str + */ + protected boolean next(String str) { + return _input.LT(1).getText().equals(str); + } + + protected boolean notLineTerminator() { + return !here(YJSParser.LineTerminator); + } + + protected boolean notOpenBraceAndNotFunction() { + int nextTokenType = _input.LT(1).getType(); + return nextTokenType != YJSParser.OpenBrace && nextTokenType != YJSParser.Function; + } + + protected boolean closeBrace() { + return _input.LT(1).getType() == YJSParser.CloseBrace; + } + + /** + * Returns {@code true} iff on the current index of the parser's token stream a + * token of the given {@code type} exists on the {@code HIDDEN} channel. + * + * @param type the type of the token on the {@code HIDDEN} channel to check. + * @return {@code true} iff on the current index of the parser's token stream a + * token of the given {@code type} exists on the {@code HIDDEN} channel. + */ + private boolean here(final int type) { + + // Get the token ahead of the current index. + int possibleIndexEosToken = this.getCurrentToken().getTokenIndex() - 1; + Token ahead = _input.get(possibleIndexEosToken); + + // Check if the token resides on the HIDDEN channel and if it's of the + // provided type. + return (ahead.getChannel() == Lexer.HIDDEN) && (ahead.getType() == type); + } + + /** + * Returns {@code true} iff on the current index of the parser's token stream a + * token exists on the {@code HIDDEN} channel which either is a line terminator, + * or is a multi line comment that contains a line terminator. + * + * @return {@code true} iff on the current index of the parser's token stream a + * token exists on the {@code HIDDEN} channel which either is a line + * terminator, or is a multi line comment that contains a line + * terminator. + */ + protected boolean lineTerminatorAhead() { + + // Get the token ahead of the current index. + int possibleIndexEosToken = this.getCurrentToken().getTokenIndex() - 1; + Token ahead = _input.get(possibleIndexEosToken); + + if (ahead.getChannel() != Lexer.HIDDEN) { + // We're only interested in tokens on the HIDDEN channel. + return false; + } + + if (ahead.getType() == YJSParser.LineTerminator) { + // There is definitely a line terminator ahead. + return true; + } + + if (ahead.getType() == YJSParser.WhiteSpaces) { + // Get the token ahead of the current whitespaces. + possibleIndexEosToken = this.getCurrentToken().getTokenIndex() - 2; + ahead = _input.get(possibleIndexEosToken); + } + + // Get the token's text and type. + String text = ahead.getText(); + int type = ahead.getType(); + + // Check if the token is, or contains a line terminator. + return (type == YJSParser.MultiLineComment && (text.contains("\r") || text.contains("\n"))) + || (type == YJSParser.LineTerminator); + } +} \ No newline at end of file diff --git a/input/JavaScriptLexer.g4 b/input/JavaScriptLexer.g4 new file mode 100644 index 0000000..ad92354 --- /dev/null +++ b/input/JavaScriptLexer.g4 @@ -0,0 +1,695 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2014 by Bart Kiers (original author) and Alexandre Vitorelli (contributor -> ported to CSharp) + * Copyright (c) 2017 by Ivan Kochurkin (Positive Technologies): + added ECMAScript 6 support, cleared and transformed to the universal grammar. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + */ +lexer grammar JavaScriptLexer; + +channels { ERROR } + +options { superClass=JavaScriptBaseLexer; } + +MultiLineComment: '/*' .*? '*/' -> channel(HIDDEN); +SingleLineComment: '//' ~[\r\n\u2028\u2029]* -> channel(HIDDEN); +RegularExpressionLiteral: '/' RegularExpressionChar+ {IsRegexPossible()}? '/' IdentifierPart*; + +OpenBracket: '['; +CloseBracket: ']'; +OpenParen: '('; +CloseParen: ')'; +OpenBrace: '{' {ProcessOpenBrace();}; +CloseBrace: '}' {ProcessCloseBrace();}; +SemiColon: ';'; +Comma: ','; +Assign: '='; +QuestionMark: '?'; +Colon: ':'; +Ellipsis: '...'; +Dot: '.'; +PlusPlus: '++'; +MinusMinus: '--'; +Plus: '+'; +Minus: '-'; +BitNot: '~'; +Not: '!'; +Multiply: '*'; +Divide: '/'; +Modulus: '%'; +RightShiftArithmetic: '>>'; +LeftShiftArithmetic: '<<'; +RightShiftLogical: '>>>'; +LessThan: '<'; +MoreThan: '>'; +LessThanEquals: '<='; +GreaterThanEquals: '>='; +Equals_: '=='; +NotEquals: '!='; +IdentityEquals: '==='; +IdentityNotEquals: '!=='; +BitAnd: '&'; +BitXOr: '^'; +BitOr: '|'; +And: '&&'; +Or: '||'; +MultiplyAssign: '*='; +DivideAssign: '/='; +ModulusAssign: '%='; +PlusAssign: '+='; +MinusAssign: '-='; +LeftShiftArithmeticAssign: '<<='; +RightShiftArithmeticAssign: '>>='; +RightShiftLogicalAssign: '>>>='; +BitAndAssign: '&='; +BitXorAssign: '^='; +BitOrAssign: '|='; +ARROW: '=>'; + +/// Null Literals + +NullLiteral: 'null'; + +/// Boolean Literals + +BooleanLiteral: 'true' + | 'false'; + +/// Numeric Literals + +DecimalLiteral: DecimalIntegerLiteral '.' [0-9]* ExponentPart? + | '.' [0-9]+ ExponentPart? + | DecimalIntegerLiteral ExponentPart? + ; + +/// Numeric Literals + +HexIntegerLiteral: '0' [xX] HexDigit+; +OctalIntegerLiteral: '0' [0-7]+ {!IsStrictMode()}?; +OctalIntegerLiteral2: '0' [oO] [0-7]+; +BinaryIntegerLiteral: '0' [bB] [01]+; + +/// Keywords + +Break: 'break'; +Do: 'do'; +Instanceof: 'instanceof'; +Typeof: 'typeof'; +Case: 'case'; +Else: 'else'; +New: 'new'; +Var: 'var'; +Catch: 'catch'; +Finally: 'finally'; +Return: 'return'; +Void: 'void'; +Continue: 'continue'; +For: 'for'; +Switch: 'switch'; +While: 'while'; +Debugger: 'debugger'; +Function: 'function'; +This: 'this'; +With: 'with'; +Default: 'default'; +If: 'if'; +Throw: 'throw'; +Delete: 'delete'; +In: 'in'; +Try: 'try'; +Event: 'event'; +AtToken: '@'; + +/// Event Semantics + +AtLeastOnce: 'AT_LEAST_ONCE'; +AtMostOnce: 'AT_MOST_ONCE'; +OnlyOnce: 'ONLY_ONCE'; + +/// Future Reserved Words + +Class: 'class'; +Enum: 'enum'; +Extends: 'extends'; +Super: 'super'; +Const: 'const'; +Export: 'export'; +Import: 'import'; +Contract: 'contract'; +Module: 'module'; +Oracle: 'oracle'; +/// The following tokens are also considered to be FutureReservedWords +/// when parsing strict mode + +Implements: 'implements' {IsStrictMode()}?; +Let: 'let' {IsStrictMode()}?; +Private: 'private' {IsStrictMode()}?; +Public: 'public' {IsStrictMode()}?; +Interface: 'interface' {IsStrictMode()}?; +Package: 'package' {IsStrictMode()}?; +Protected: 'protected' {IsStrictMode()}?; +Static: 'static' {IsStrictMode()}?; +Yield: 'yield' {IsStrictMode()}?; + +/// Identifier Names and Identifiers + +Identifier: IdentifierStart IdentifierPart*; + +/// String Literals +StringLiteral: ('"' DoubleStringCharacter* '"' + | '\'' SingleStringCharacter* '\'') {ProcessStringLiteral();} + ; + +TemplateStringLiteral: '`' ('\\`' | ~'`')* '`'; + +WhiteSpaces: [\t\u000B\u000C\u0020\u00A0]+ -> channel(HIDDEN); + +LineTerminator: [\r\n\u2028\u2029] -> channel(HIDDEN); + +/// Comments + + +HtmlComment: '' -> channel(HIDDEN); +CDataComment: '' -> channel(HIDDEN); +UnexpectedCharacter: . -> channel(ERROR); + +// Fragment rules + +fragment DoubleStringCharacter + : ~["\\\r\n] + | '\\' EscapeSequence + | LineContinuation + ; + +fragment SingleStringCharacter + : ~['\\\r\n] + | '\\' EscapeSequence + | LineContinuation + ; + +fragment EscapeSequence + : CharacterEscapeSequence + | '0' // no digit ahead! TODO + | HexEscapeSequence + | UnicodeEscapeSequence + | ExtendedUnicodeEscapeSequence + ; + +fragment CharacterEscapeSequence + : SingleEscapeCharacter + | NonEscapeCharacter + ; + +fragment HexEscapeSequence + : 'x' HexDigit HexDigit + ; + +fragment UnicodeEscapeSequence + : 'u' HexDigit HexDigit HexDigit HexDigit + ; + +fragment ExtendedUnicodeEscapeSequence + : 'u' '{' HexDigit+ '}' + ; + +fragment SingleEscapeCharacter + : ['"\\bfnrtv] + ; + +fragment NonEscapeCharacter + : ~['"\\bfnrtv0-9xu\r\n] + ; + +fragment EscapeCharacter + : SingleEscapeCharacter + | [0-9] + | [xu] + ; + +fragment LineContinuation + : '\\' [\r\n\u2028\u2029] + ; + +fragment HexDigit + : [0-9a-fA-F] + ; + +fragment DecimalIntegerLiteral + : '0' + | [1-9] [0-9]* + ; + +fragment ExponentPart + : [eE] [+-]? [0-9]+ + ; + +fragment IdentifierPart + : IdentifierStart + | UnicodeCombiningMark + | UnicodeDigit + | UnicodeConnectorPunctuation + | '\u200C' + | '\u200D' + ; + +fragment IdentifierStart + : UnicodeLetter + | [$_] + | '\\' UnicodeEscapeSequence + ; + +fragment UnicodeLetter + : [\u0041-\u005A] + | [\u0061-\u007A] + | [\u00AA] + | [\u00B5] + | [\u00BA] + | [\u00C0-\u00D6] + | [\u00D8-\u00F6] + | [\u00F8-\u021F] + | [\u0222-\u0233] + | [\u0250-\u02AD] + | [\u02B0-\u02B8] + | [\u02BB-\u02C1] + | [\u02D0-\u02D1] + | [\u02E0-\u02E4] + | [\u02EE] + | [\u037A] + | [\u0386] + | [\u0388-\u038A] + | [\u038C] + | [\u038E-\u03A1] + | [\u03A3-\u03CE] + | [\u03D0-\u03D7] + | [\u03DA-\u03F3] + | [\u0400-\u0481] + | [\u048C-\u04C4] + | [\u04C7-\u04C8] + | [\u04CB-\u04CC] + | [\u04D0-\u04F5] + | [\u04F8-\u04F9] + | [\u0531-\u0556] + | [\u0559] + | [\u0561-\u0587] + | [\u05D0-\u05EA] + | [\u05F0-\u05F2] + | [\u0621-\u063A] + | [\u0640-\u064A] + | [\u0671-\u06D3] + | [\u06D5] + | [\u06E5-\u06E6] + | [\u06FA-\u06FC] + | [\u0710] + | [\u0712-\u072C] + | [\u0780-\u07A5] + | [\u0905-\u0939] + | [\u093D] + | [\u0950] + | [\u0958-\u0961] + | [\u0985-\u098C] + | [\u098F-\u0990] + | [\u0993-\u09A8] + | [\u09AA-\u09B0] + | [\u09B2] + | [\u09B6-\u09B9] + | [\u09DC-\u09DD] + | [\u09DF-\u09E1] + | [\u09F0-\u09F1] + | [\u0A05-\u0A0A] + | [\u0A0F-\u0A10] + | [\u0A13-\u0A28] + | [\u0A2A-\u0A30] + | [\u0A32-\u0A33] + | [\u0A35-\u0A36] + | [\u0A38-\u0A39] + | [\u0A59-\u0A5C] + | [\u0A5E] + | [\u0A72-\u0A74] + | [\u0A85-\u0A8B] + | [\u0A8D] + | [\u0A8F-\u0A91] + | [\u0A93-\u0AA8] + | [\u0AAA-\u0AB0] + | [\u0AB2-\u0AB3] + | [\u0AB5-\u0AB9] + | [\u0ABD] + | [\u0AD0] + | [\u0AE0] + | [\u0B05-\u0B0C] + | [\u0B0F-\u0B10] + | [\u0B13-\u0B28] + | [\u0B2A-\u0B30] + | [\u0B32-\u0B33] + | [\u0B36-\u0B39] + | [\u0B3D] + | [\u0B5C-\u0B5D] + | [\u0B5F-\u0B61] + | [\u0B85-\u0B8A] + | [\u0B8E-\u0B90] + | [\u0B92-\u0B95] + | [\u0B99-\u0B9A] + | [\u0B9C] + | [\u0B9E-\u0B9F] + | [\u0BA3-\u0BA4] + | [\u0BA8-\u0BAA] + | [\u0BAE-\u0BB5] + | [\u0BB7-\u0BB9] + | [\u0C05-\u0C0C] + | [\u0C0E-\u0C10] + | [\u0C12-\u0C28] + | [\u0C2A-\u0C33] + | [\u0C35-\u0C39] + | [\u0C60-\u0C61] + | [\u0C85-\u0C8C] + | [\u0C8E-\u0C90] + | [\u0C92-\u0CA8] + | [\u0CAA-\u0CB3] + | [\u0CB5-\u0CB9] + | [\u0CDE] + | [\u0CE0-\u0CE1] + | [\u0D05-\u0D0C] + | [\u0D0E-\u0D10] + | [\u0D12-\u0D28] + | [\u0D2A-\u0D39] + | [\u0D60-\u0D61] + | [\u0D85-\u0D96] + | [\u0D9A-\u0DB1] + | [\u0DB3-\u0DBB] + | [\u0DBD] + | [\u0DC0-\u0DC6] + | [\u0E01-\u0E30] + | [\u0E32-\u0E33] + | [\u0E40-\u0E46] + | [\u0E81-\u0E82] + | [\u0E84] + | [\u0E87-\u0E88] + | [\u0E8A] + | [\u0E8D] + | [\u0E94-\u0E97] + | [\u0E99-\u0E9F] + | [\u0EA1-\u0EA3] + | [\u0EA5] + | [\u0EA7] + | [\u0EAA-\u0EAB] + | [\u0EAD-\u0EB0] + | [\u0EB2-\u0EB3] + | [\u0EBD-\u0EC4] + | [\u0EC6] + | [\u0EDC-\u0EDD] + | [\u0F00] + | [\u0F40-\u0F6A] + | [\u0F88-\u0F8B] + | [\u1000-\u1021] + | [\u1023-\u1027] + | [\u1029-\u102A] + | [\u1050-\u1055] + | [\u10A0-\u10C5] + | [\u10D0-\u10F6] + | [\u1100-\u1159] + | [\u115F-\u11A2] + | [\u11A8-\u11F9] + | [\u1200-\u1206] + | [\u1208-\u1246] + | [\u1248] + | [\u124A-\u124D] + | [\u1250-\u1256] + | [\u1258] + | [\u125A-\u125D] + | [\u1260-\u1286] + | [\u1288] + | [\u128A-\u128D] + | [\u1290-\u12AE] + | [\u12B0] + | [\u12B2-\u12B5] + | [\u12B8-\u12BE] + | [\u12C0] + | [\u12C2-\u12C5] + | [\u12C8-\u12CE] + | [\u12D0-\u12D6] + | [\u12D8-\u12EE] + | [\u12F0-\u130E] + | [\u1310] + | [\u1312-\u1315] + | [\u1318-\u131E] + | [\u1320-\u1346] + | [\u1348-\u135A] + | [\u13A0-\u13B0] + | [\u13B1-\u13F4] + | [\u1401-\u1676] + | [\u1681-\u169A] + | [\u16A0-\u16EA] + | [\u1780-\u17B3] + | [\u1820-\u1877] + | [\u1880-\u18A8] + | [\u1E00-\u1E9B] + | [\u1EA0-\u1EE0] + | [\u1EE1-\u1EF9] + | [\u1F00-\u1F15] + | [\u1F18-\u1F1D] + | [\u1F20-\u1F39] + | [\u1F3A-\u1F45] + | [\u1F48-\u1F4D] + | [\u1F50-\u1F57] + | [\u1F59] + | [\u1F5B] + | [\u1F5D] + | [\u1F5F-\u1F7D] + | [\u1F80-\u1FB4] + | [\u1FB6-\u1FBC] + | [\u1FBE] + | [\u1FC2-\u1FC4] + | [\u1FC6-\u1FCC] + | [\u1FD0-\u1FD3] + | [\u1FD6-\u1FDB] + | [\u1FE0-\u1FEC] + | [\u1FF2-\u1FF4] + | [\u1FF6-\u1FFC] + | [\u207F] + | [\u2102] + | [\u2107] + | [\u210A-\u2113] + | [\u2115] + | [\u2119-\u211D] + | [\u2124] + | [\u2126] + | [\u2128] + | [\u212A-\u212D] + | [\u212F-\u2131] + | [\u2133-\u2139] + | [\u2160-\u2183] + | [\u3005-\u3007] + | [\u3021-\u3029] + | [\u3031-\u3035] + | [\u3038-\u303A] + | [\u3041-\u3094] + | [\u309D-\u309E] + | [\u30A1-\u30FA] + | [\u30FC-\u30FE] + | [\u3105-\u312C] + | [\u3131-\u318E] + | [\u31A0-\u31B7] + | [\u3400] + | [\u4DB5] + | [\u4E00] + | [\u9FA5] + | [\uA000-\uA48C] + | [\uAC00] + | [\uD7A3] + | [\uF900-\uFA2D] + | [\uFB00-\uFB06] + | [\uFB13-\uFB17] + | [\uFB1D] + | [\uFB1F-\uFB28] + | [\uFB2A-\uFB36] + | [\uFB38-\uFB3C] + | [\uFB3E] + | [\uFB40-\uFB41] + | [\uFB43-\uFB44] + | [\uFB46-\uFBB1] + | [\uFBD3-\uFD3D] + | [\uFD50-\uFD8F] + | [\uFD92-\uFDC7] + | [\uFDF0-\uFDFB] + | [\uFE70-\uFE72] + | [\uFE74] + | [\uFE76-\uFEFC] + | [\uFF21-\uFF3A] + | [\uFF41-\uFF5A] + | [\uFF66-\uFFBE] + | [\uFFC2-\uFFC7] + | [\uFFCA-\uFFCF] + | [\uFFD2-\uFFD7] + | [\uFFDA-\uFFDC] + ; + +fragment UnicodeCombiningMark + : [\u0300-\u034E] + | [\u0360-\u0362] + | [\u0483-\u0486] + | [\u0591-\u05A1] + | [\u05A3-\u05B9] + | [\u05BB-\u05BD] + | [\u05BF] + | [\u05C1-\u05C2] + | [\u05C4] + | [\u064B-\u0655] + | [\u0670] + | [\u06D6-\u06DC] + | [\u06DF-\u06E4] + | [\u06E7-\u06E8] + | [\u06EA-\u06ED] + | [\u0711] + | [\u0730-\u074A] + | [\u07A6-\u07B0] + | [\u0901-\u0903] + | [\u093C] + | [\u093E-\u094D] + | [\u0951-\u0954] + | [\u0962-\u0963] + | [\u0981-\u0983] + | [\u09BC-\u09C4] + | [\u09C7-\u09C8] + | [\u09CB-\u09CD] + | [\u09D7] + | [\u09E2-\u09E3] + | [\u0A02] + | [\u0A3C] + | [\u0A3E-\u0A42] + | [\u0A47-\u0A48] + | [\u0A4B-\u0A4D] + | [\u0A70-\u0A71] + | [\u0A81-\u0A83] + | [\u0ABC] + | [\u0ABE-\u0AC5] + | [\u0AC7-\u0AC9] + | [\u0ACB-\u0ACD] + | [\u0B01-\u0B03] + | [\u0B3C] + | [\u0B3E-\u0B43] + | [\u0B47-\u0B48] + | [\u0B4B-\u0B4D] + | [\u0B56-\u0B57] + | [\u0B82-\u0B83] + | [\u0BBE-\u0BC2] + | [\u0BC6-\u0BC8] + | [\u0BCA-\u0BCD] + | [\u0BD7] + | [\u0C01-\u0C03] + | [\u0C3E-\u0C44] + | [\u0C46-\u0C48] + | [\u0C4A-\u0C4D] + | [\u0C55-\u0C56] + | [\u0C82-\u0C83] + | [\u0CBE-\u0CC4] + | [\u0CC6-\u0CC8] + | [\u0CCA-\u0CCD] + | [\u0CD5-\u0CD6] + | [\u0D02-\u0D03] + | [\u0D3E-\u0D43] + | [\u0D46-\u0D48] + | [\u0D4A-\u0D4D] + | [\u0D57] + | [\u0D82-\u0D83] + | [\u0DCA] + | [\u0DCF-\u0DD4] + | [\u0DD6] + | [\u0DD8-\u0DDF] + | [\u0DF2-\u0DF3] + | [\u0E31] + | [\u0E34-\u0E3A] + | [\u0E47-\u0E4E] + | [\u0EB1] + | [\u0EB4-\u0EB9] + | [\u0EBB-\u0EBC] + | [\u0EC8-\u0ECD] + | [\u0F18-\u0F19] + | [\u0F35] + | [\u0F37] + | [\u0F39] + | [\u0F3E-\u0F3F] + | [\u0F71-\u0F84] + | [\u0F86-\u0F87] + | [\u0F90-\u0F97] + | [\u0F99-\u0FBC] + | [\u0FC6] + | [\u102C-\u1032] + | [\u1036-\u1039] + | [\u1056-\u1059] + | [\u17B4-\u17D3] + | [\u18A9] + | [\u20D0-\u20DC] + | [\u20E1] + | [\u302A-\u302F] + | [\u3099-\u309A] + | [\uFB1E] + | [\uFE20-\uFE23] + ; + +fragment UnicodeDigit + : [\u0030-\u0039] + | [\u0660-\u0669] + | [\u06F0-\u06F9] + | [\u0966-\u096F] + | [\u09E6-\u09EF] + | [\u0A66-\u0A6F] + | [\u0AE6-\u0AEF] + | [\u0B66-\u0B6F] + | [\u0BE7-\u0BEF] + | [\u0C66-\u0C6F] + | [\u0CE6-\u0CEF] + | [\u0D66-\u0D6F] + | [\u0E50-\u0E59] + | [\u0ED0-\u0ED9] + | [\u0F20-\u0F29] + | [\u1040-\u1049] + | [\u1369-\u1371] + | [\u17E0-\u17E9] + | [\u1810-\u1819] + | [\uFF10-\uFF19] + ; + +fragment UnicodeConnectorPunctuation + : [\u005F] + | [\u203F-\u2040] + | [\u30FB] + | [\uFE33-\uFE34] + | [\uFE4D-\uFE4F] + | [\uFF3F] + | [\uFF65] + ; + +fragment RegularExpressionChar + : ~[\r\n\u2028\u2029\\/[] + | RegularExpressionBackslashSequence + | '[' RegularExpressionClassChar* ']' + ; + +fragment RegularExpressionClassChar + : ~[\r\n\u2028\u2029\]\\] + | RegularExpressionBackslashSequence + ; + +fragment RegularExpressionBackslashSequence + : '\\' ~[\r\n\u2028\u2029] + ; \ No newline at end of file diff --git a/input/JavaScriptParser.g4 b/input/JavaScriptParser.g4 new file mode 100644 index 0000000..9cfd73c --- /dev/null +++ b/input/JavaScriptParser.g4 @@ -0,0 +1,431 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2014 by Bart Kiers (original author) and Alexandre Vitorelli (contributor -> ported to CSharp) + * Copyright (c) 2017 by Ivan Kochurkin (Positive Technologies): + added ECMAScript 6 support, cleared and transformed to the universal grammar. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + */ +parser grammar JavaScriptParser; + +options { + tokenVocab=JavaScriptLexer; + superClass=JavaScriptBaseParser; +} + +program + : sourceElements? EOF + ; + +sourceElement + : exportStmt? statement + ; + +exportStmt + : Export StringLiteral versionName + ; + +versionName: NumberVersionLiteral ('.' NumberVersionLiteral)* ; + +statement + : block + | variableStatement + | emptyStatement + | expressionStatement + | ifStatement + | iterationStatement + | continueStatement + | breakStatement + | returnStatement + | withStatement + | labelledStatement + | switchStatement + | throwStatement + | tryStatement + | debuggerStatement + | functionDeclaration + | classDeclaration + ; + +block + : '{' statementList? '}' + ; + +statementList + : statement+ + ; + +variableStatement + : varModifier variableDeclarationList eos + ; + +variableDeclarationList + : variableDeclaration (',' variableDeclaration)* + ; + +variableDeclaration + : (Identifier | arrayLiteral | objectLiteral) ('=' singleExpression)? // ECMAScript 6: Array & Object Matching + ; + +emptyStatement + : SemiColon + ; + +expressionStatement + : {notOpenBraceAndNotFunction()}? expressionSequence eos + ; + +ifStatement + : If '(' expressionSequence ')' statement (Else statement)? + ; + + +iterationStatement + : Do statement While '(' expressionSequence ')' eos # DoStatement + | While '(' expressionSequence ')' statement # WhileStatement + | For '(' expressionSequence? ';' expressionSequence? ';' expressionSequence? ')' statement # ForStatement + | For '(' varModifier variableDeclarationList ';' expressionSequence? ';' expressionSequence? ')' + statement # ForVarStatement + | For '(' singleExpression (In | Identifier{p("of")}?) expressionSequence ')' statement # ForInStatement + | For '(' varModifier variableDeclaration (In | Identifier{p("of")}?) expressionSequence ')' statement # ForVarInStatement + ; + +varModifier // let, const - ECMAScript 6 + : Var + | Let + | Const + ; + +continueStatement + : Continue ({notLineTerminator()}? Identifier)? eos + ; + +breakStatement + : Break ({notLineTerminator()}? Identifier)? eos + ; + +returnStatement + : Return ({notLineTerminator()}? expressionSequence)? eos + ; + +withStatement + : With '(' expressionSequence ')' statement + ; + +switchStatement + : Switch '(' expressionSequence ')' caseBlock + ; + +caseBlock + : '{' caseClauses? (defaultClause caseClauses?)? '}' + ; + +caseClauses + : caseClause+ + ; + +caseClause + : Case expressionSequence ':' statementList? + ; + +defaultClause + : Default ':' statementList? + ; + +labelledStatement + : Identifier ':' statement + ; + +throwStatement + : Throw {notLineTerminator()}? expressionSequence eos + ; + +tryStatement + : Try block (catchProduction finallyProduction? | finallyProduction) + ; + +catchProduction + : Catch '(' Identifier ')' block + ; + +finallyProduction + : Finally block + ; + +debuggerStatement + : Debugger eos + ; + +functionDeclaration + : Function Identifier '(' formalParameterList? ')' '{' functionBody '}' + ; + +classDeclaration + : Class Identifier classTail + ; + +classTail + : (Extends singleExpression)? '{' classElement* '}' + ; + +classElement + : Static? methodDefinition + ; + +methodDefinition + : propertyName '(' formalParameterList? ')' '{' functionBody '}' + | getter '(' ')' '{' functionBody '}' + | setter '(' formalParameterList? ')' '{' functionBody '}' + | generatorMethod + ; + +generatorMethod + : '*'? Identifier '(' formalParameterList? ')' '{' functionBody '}' + ; + +formalParameterList + : formalParameterArg (',' formalParameterArg)* (',' lastFormalParameterArg)? + | lastFormalParameterArg + | arrayLiteral // ECMAScript 6: Parameter Context Matching + | objectLiteral // ECMAScript 6: Parameter Context Matching + ; + +formalParameterArg + : Identifier ('=' singleExpression)? // ECMAScript 6: Initialization + ; + +lastFormalParameterArg // ECMAScript 6: Rest Parameter + : Ellipsis Identifier + ; + +functionBody + : sourceElements? + ; + +sourceElements + : sourceElement+ + ; + +arrayLiteral + : '[' ','* elementList? ','* ']' + ; + +elementList + : singleExpression (','+ singleExpression)* (','+ lastElement)? + | lastElement + ; + +lastElement // ECMAScript 6: Spread Operator + : Ellipsis Identifier + ; + +objectLiteral + : '{' (propertyAssignment (',' propertyAssignment)*)? ','? '}' + ; + +propertyAssignment + : propertyName (':' |'=') singleExpression # PropertyExpressionAssignment + | '[' singleExpression ']' ':' singleExpression # ComputedPropertyExpressionAssignment + | getter '(' ')' '{' functionBody '}' # PropertyGetter + | setter '(' Identifier ')' '{' functionBody '}' # PropertySetter + | generatorMethod # MethodProperty + | Identifier # PropertyShorthand + ; + +propertyName + : identifierName + | StringLiteral + | numericLiteral + ; + +arguments + : '('( + singleExpression (',' singleExpression)* (',' lastArgument)? | + lastArgument + )?')' + ; + +lastArgument // ECMAScript 6: Spread Operator + : Ellipsis Identifier + ; + +expressionSequence + : singleExpression (',' singleExpression)* + ; + +singleExpression + : Function Identifier? '(' formalParameterList? ')' '{' functionBody '}' # FunctionExpression + | Class Identifier? classTail # ClassExpression + | singleExpression '[' expressionSequence ']' # MemberIndexExpression + | singleExpression '.' identifierName # MemberDotExpression + | singleExpression arguments # ArgumentsExpression + | New singleExpression arguments? # NewExpression + | singleExpression {notLineTerminator()}? '++' # PostIncrementExpression + | singleExpression {notLineTerminator()}? '--' # PostDecreaseExpression + | Delete singleExpression # DeleteExpression + | Void singleExpression # VoidExpression + | Typeof singleExpression # TypeofExpression + | '++' singleExpression # PreIncrementExpression + | '--' singleExpression # PreDecreaseExpression + | '+' singleExpression # UnaryPlusExpression + | '-' singleExpression # UnaryMinusExpression + | '~' singleExpression # BitNotExpression + | '!' singleExpression # NotExpression + | singleExpression ('*' | '/' | '%') singleExpression # MultiplicativeExpression + | singleExpression ('+' | '-') singleExpression # AdditiveExpression + | singleExpression ('<<' | '>>' | '>>>') singleExpression # BitShiftExpression + | singleExpression ('<' | '>' | '<=' | '>=') singleExpression # RelationalExpression + | singleExpression Instanceof singleExpression # InstanceofExpression + | singleExpression In singleExpression # InExpression + | singleExpression ('==' | '!=' | '===' | '!==') singleExpression # EqualityExpression + | singleExpression '&' singleExpression # BitAndExpression + | singleExpression '^' singleExpression # BitXOrExpression + | singleExpression '|' singleExpression # BitOrExpression + | singleExpression '&&' singleExpression # LogicalAndExpression + | singleExpression '||' singleExpression # LogicalOrExpression + | singleExpression '?' singleExpression ':' singleExpression # TernaryExpression + | singleExpression '=' singleExpression # AssignmentExpression + | singleExpression assignmentOperator singleExpression # AssignmentOperatorExpression + | singleExpression TemplateStringLiteral # TemplateStringExpression // ECMAScript 6 + | This # ThisExpression + | Identifier # IdentifierExpression + | Super # SuperExpression + | literal # LiteralExpression + | arrayLiteral # ArrayLiteralExpression + | objectLiteral # ObjectLiteralExpression + | '(' expressionSequence ')' # ParenthesizedExpression + | arrowFunctionParameters '=>' arrowFunctionBody # ArrowFunctionExpression // ECMAScript 6 + ; + +arrowFunctionParameters + : Identifier + | '(' formalParameterList? ')' + ; + +arrowFunctionBody + : singleExpression + | '{' functionBody '}' + ; + +assignmentOperator + : '*=' + | '/=' + | '%=' + | '+=' + | '-=' + | '<<=' + | '>>=' + | '>>>=' + | '&=' + | '^=' + | '|=' + ; + +literal + : NullLiteral + | BooleanLiteral + | StringLiteral + | TemplateStringLiteral + | RegularExpressionLiteral + | numericLiteral + ; + +numericLiteral + : DecimalLiteral + | HexIntegerLiteral + | OctalIntegerLiteral + | OctalIntegerLiteral2 + | BinaryIntegerLiteral + ; + +identifierName + : Identifier + | reservedWord + ; + +reservedWord + : keyword + | NullLiteral + | BooleanLiteral + ; + +keyword + : Break + | Do + | Instanceof + | Typeof + | Case + | Else + | New + | Var + | Catch + | Finally + | Return + | Void + | Continue + | For + | Switch + | While + | Debugger + | Function + | This + | With + | Default + | If + | Throw + | Delete + | In + | Try + + | Class + | Enum + | Extends + | Super + | Const + | Export + | Import + | Implements + | Let + | Private + | Public + | Interface + | Package + | Protected + | Static + | Yield + ; + +getter + : Identifier{p("get")}? propertyName + ; + +setter + : Identifier{p("set")}? propertyName + ; + +eos + : SemiColon + | EOF + | {lineTerminatorAhead()}? + | {closeBrace()}? + ; \ No newline at end of file diff --git a/input/YJSParser.g4 b/input/YJSParser.g4 new file mode 100644 index 0000000..03f29f1 --- /dev/null +++ b/input/YJSParser.g4 @@ -0,0 +1,441 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2014 by Bart Kiers (original author) and Alexandre Vitorelli (contributor -> ported to CSharp) + * Copyright (c) 2017 by Ivan Kochurkin (Positive Technologies): + added ECMAScript 6 support, cleared and transformed to the universal grammar. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + */ +parser grammar YJSParser; + +options { + tokenVocab=JavaScriptLexer; + superClass=JavaScriptBaseParser; +} + +program + : importStmts? contractDeclar + ; + +contractDeclar + : annotations? (Contract|Module|Oracle) Identifier '{' clzOrFunctionDeclaration+ '}' + ; + +annotations + : annotation+ + ; + +annotation + : AtToken Identifier '(' annotationArgs? ')' + ; + +annotationArgs + : annotationLiteral (',' annotationLiteral)* + ; +annotationLiteral + :numericLiteral + |StringLiteral + |objectLiteral + ; + +clzOrFunctionDeclaration + :classDeclaration + |functionDeclaration + |eventDeclaration + ; +eventSemantics + :AtLeastOnce + |AtMostOnce + |OnlyOnce + ; +eventDeclaration + :Event eventSemantics? Identifier SemiColon +// |Event eventSemantics? Identifier '(' annotationArgs? ')' SemiColon + ; +sourceElement + : statement + ; + +importStmts + : importStmt+ + ; + +importStmt + : Import StringLiteral SemiColon + ; + +exportStmt + : Export Identifier versionName SemiColon + ; + +versionName: DecimalLiteral ('.' DecimalLiteral)* ; + +statement + : block + | variableStatement + | emptyStatement + | expressionStatement + | ifStatement + | iterationStatement + | continueStatement + | breakStatement + | returnStatement + | switchStatement + ; + +block + : '{' statementList? '}' + ; + +statementList + : statement+ + ; + +variableStatement + : varModifier variableDeclarationList eos + ; + +variableDeclarationList + : variableDeclaration (',' variableDeclaration)* + ; + +variableDeclaration + : (Identifier) ('=' singleExpression)? // ECMAScript 6: Array & Object Matching + ; + +emptyStatement + : SemiColon + ; + +expressionStatement + : {notOpenBraceAndNotFunction()}? expressionSequence eos + ; + +ifStatement + : If '(' expressionSequence ')' statement (Else statement)? + ; + + +iterationStatement + : Do statement While '(' expressionSequence ')' eos # DoStatement + | While '(' expressionSequence ')' statement # WhileStatement + | For '(' expressionSequence? ';' expressionSequence? ';' expressionSequence? ')' statement # ForStatement + | For '(' varModifier variableDeclarationList ';' expressionSequence? ';' expressionSequence? ')' + statement # ForVarStatement + | For '(' singleExpression (In | Identifier{p("of")}?) expressionSequence ')' statement # ForInStatement + | For '(' varModifier variableDeclaration (In | Identifier{p("of")}?) expressionSequence ')' statement # ForVarInStatement + ; + +varModifier // let, const - ECMAScript 6 + : Var + ; + +continueStatement + : Continue ({notLineTerminator()}? Identifier)? eos + ; + +breakStatement + : Break ({notLineTerminator()}? Identifier)? eos + ; + +returnStatement + : Return ({notLineTerminator()}? expressionSequence)? eos + ; + +withStatement + : With '(' expressionSequence ')' statement + ; + +switchStatement + : Switch '(' expressionSequence ')' caseBlock + ; + +caseBlock + : '{' caseClauses? (defaultClause caseClauses?)? '}' + ; + +caseClauses + : caseClause+ + ; + +caseClause + : Case expressionSequence ':' statementList? + ; + +defaultClause + : Default ':' statementList? + ; + + + +throwStatement + : Throw {notLineTerminator()}? expressionSequence eos + ; + +tryStatement + : Try block (catchProduction finallyProduction? | finallyProduction) + ; + +catchProduction + : Catch '(' Identifier ')' block + ; + +finallyProduction + : Finally block + ; + +debuggerStatement + : Debugger eos + ; + +functionDeclaration + : annotations? Export? Function Identifier '(' formalParameterList? ')' '{' functionBody '}' + ; + +classDeclaration + : Class Identifier classTail + ; + +classTail + : (Extends singleExpression)? '{' classElement* '}' + ; + +classElement + : Static? methodDefinition + ; + +methodDefinition + : propertyName '(' formalParameterList? ')' '{' functionBody '}' + ; + +formalParameterList + : formalParameterArg (',' formalParameterArg)* (',' lastFormalParameterArg)? + | lastFormalParameterArg + | arrayLiteral // ECMAScript 6: Parameter Context Matching + | objectLiteral // ECMAScript 6: Parameter Context Matching + ; + +formalParameterArg + : Identifier ('=' singleExpression)? // ECMAScript 6: Initialization + ; + +lastFormalParameterArg // ECMAScript 6: Rest Parameter + : Ellipsis Identifier + ; + +functionBody + : sourceElements? + ; + +sourceElements + : sourceElement+ + ; + +arrayLiteral + : '[' ','* elementList? ','* ']' + ; + +elementList + : singleExpression (','+ singleExpression)* (','+ lastElement)? + | lastElement + ; + +lastElement // ECMAScript 6: Spread Operator + : Ellipsis Identifier + ; + +objectLiteral + : '{' (propertyAssignment (',' propertyAssignment)*)? ','? '}' + ; + +propertyAssignment + : propertyName (':' |'=') singleExpression # PropertyExpressionAssignment + | '[' singleExpression ']' ':' singleExpression # ComputedPropertyExpressionAssignment + | Identifier # PropertyShorthand + ; + +propertyName + : identifierName + | StringLiteral + | numericLiteral + ; + +arguments + : '('( + singleExpression (',' singleExpression)* (',' lastArgument)? | + lastArgument + )?')' + ; + +lastArgument // ECMAScript 6: Spread Operator + : Ellipsis Identifier + ; + +expressionSequence + : singleExpression (',' singleExpression)* + ; + +singleExpression + : singleExpression '[' expressionSequence ']' # MemberIndexExpression + | singleExpression '.' identifierName # MemberDotExpression + | singleExpression arguments # ArgumentsExpression + | New singleExpression arguments? # NewExpression + | singleExpression {notLineTerminator()}? '++' # PostIncrementExpression + | singleExpression {notLineTerminator()}? '--' # PostDecreaseExpression + | Typeof singleExpression # TypeofExpression + | '++' singleExpression # PreIncrementExpression + | '--' singleExpression # PreDecreaseExpression + | '+' singleExpression # UnaryPlusExpression + | '-' singleExpression # UnaryMinusExpression + | '~' singleExpression # BitNotExpression + | '!' singleExpression # NotExpression + | singleExpression ('*' | '/' | '%') singleExpression # MultiplicativeExpression + | singleExpression ('+' | '-') singleExpression # AdditiveExpression + | singleExpression ('<<' | '>>' | '>>>') singleExpression # BitShiftExpression + | singleExpression ('<' | '>' | '<=' | '>=') singleExpression # RelationalExpression + | singleExpression Instanceof singleExpression # InstanceofExpression + | singleExpression In singleExpression # InExpression + | singleExpression ('==' | '!=' | '===' | '!==') singleExpression # EqualityExpression + | singleExpression '&' singleExpression # BitAndExpression + | singleExpression '^' singleExpression # BitXOrExpression + | singleExpression '|' singleExpression # BitOrExpression + | singleExpression '&&' singleExpression # LogicalAndExpression + | singleExpression '||' singleExpression # LogicalOrExpression + | singleExpression '?' singleExpression ':' singleExpression # TernaryExpression + | singleExpression '=' singleExpression # AssignmentExpression + | singleExpression assignmentOperator singleExpression # AssignmentOperatorExpression + | singleExpression TemplateStringLiteral # TemplateStringExpression // ECMAScript 6 + | This # ThisExpression + | Identifier # IdentifierExpression + | Super # SuperExpression + | literal # LiteralExpression + | arrayLiteral # ArrayLiteralExpression + | objectLiteral # ObjectLiteralExpression + | '(' expressionSequence ')' # ParenthesizedExpression + | arrowFunctionParameters '=>' arrowFunctionBody # ArrowFunctionExpression // ECMAScript 6 + ; + +arrowFunctionParameters + : Identifier + | '(' formalParameterList? ')' + ; + +arrowFunctionBody + : singleExpression + | '{' functionBody '}' + ; + +assignmentOperator + : '*=' + | '/=' + | '%=' + | '+=' + | '-=' + | '<<=' + | '>>=' + | '>>>=' + | '&=' + | '^=' + | '|=' + ; + +literal + : NullLiteral + | BooleanLiteral + | StringLiteral + | TemplateStringLiteral + | RegularExpressionLiteral + | numericLiteral + ; + +numericLiteral + : DecimalLiteral + | HexIntegerLiteral + | OctalIntegerLiteral + | OctalIntegerLiteral2 + | BinaryIntegerLiteral + ; + +identifierName + : Identifier + | reservedWord + ; + +reservedWord + : keyword + | NullLiteral + | BooleanLiteral + ; + +keyword + : Break + | Do + | Instanceof + | Typeof + | Case + | Else + | New + | Var + | Catch + | Finally + | Return + | Void + | Continue + | For + | Switch + | While + | Debugger + | Function + | This + | With + | Default + | If + | Throw + | Delete + | In + | Try + + | Class + | Enum + | Extends + | Super + | Const + | Export + | Import + | Implements + | Let + | Private + | Public + | Interface + | Package + | Protected + | Static + | Yield + ; + +eos + : SemiColon + | EOF + | {lineTerminatorAhead()}? + | {closeBrace()}? + ; \ No newline at end of file diff --git a/input/hello.g4 b/input/hello.g4 new file mode 100644 index 0000000..77235a8 --- /dev/null +++ b/input/hello.g4 @@ -0,0 +1,4 @@ +grammar hello; +r : 'hello' ID ; +ID: [a-z]+ ; +WS: [ \t\r\n]+ -> skip; \ No newline at end of file diff --git a/input/init.sh b/input/init.sh new file mode 100755 index 0000000..58f0aa8 --- /dev/null +++ b/input/init.sh @@ -0,0 +1,7 @@ +#!/bin/bash +curl 'http://localhost:8080/SCIDE/NodeCenter?action=register&pubKey=a&wsUrl=ws%3A%2F%2F39.106.6.6%3A8080%2FSCIDE%2FSCExecutor' +echo "" +curl 'http://localhost:8080/SCIDE/NodeCenter?action=register&pubKey=b&wsUrl=ws%3A%2F%2F47.106.38.23%3A8080%2FSCIDE%2FSCExecutor' +echo "" +curl 'http://localhost:8080/SCIDE/NodeCenter?action=register&pubKey=c&wsUrl=ws%3A%2F%2F222.29.159.166%3A3436%2FSCIDE%2FSCExecutor' +echo "" diff --git a/input/opinfo.txt b/input/opinfo.txt new file mode 100644 index 0000000..358d9e4 --- /dev/null +++ b/input/opinfo.txt @@ -0,0 +1,202 @@ +int NOP = 0 ; // visitInsn + int ACONST_NULL = 1 ; // - + int ICONST_M1 = 2 ; // - + int ICONST_0 = 3 ; // - + int ICONST_1 = 4 ; // - + int ICONST_2 = 5 ; // - + int ICONST_3 = 6 ; // - + int ICONST_4 = 7 ; // - + int ICONST_5 = 8 ; // - + int LCONST_0 = 9 ; // - + int LCONST_1 = 10 ; // - + int FCONST_0 = 11 ; // - + int FCONST_1 = 12 ; // - + int FCONST_2 = 13 ; // - + int DCONST_0 = 14 ; // - + int DCONST_1 = 15 ; // - + int BIPUSH = 16 ; // visitIntInsn + int SIPUSH = 17 ; // - + int LDC = 18 ; // visitLdcInsn + int LDC_W = 19 ; // - + int LDC2_W = 20 ; // - + int ILOAD = 21 ; // visitVarInsn + int LLOAD = 22 ; // - + int FLOAD = 23 ; // - + int DLOAD = 24 ; // - + int ALOAD = 25 ; // - + int ILOAD_0 = 26 ; // - + int ILOAD_1 = 27 ; // - + int ILOAD_2 = 28 ; // - + int ILOAD_3 = 29 ; // - + int LLOAD_0 = 30 ; // - + int LLOAD_1 = 31 ; // - + int LLOAD_2 = 32 ; // - + int LLOAD_3 = 33 ; // - + int FLOAD_0 = 34 ; // - + int FLOAD_1 = 35 ; // - + int FLOAD_2 = 36 ; // - + int FLOAD_3 = 37 ; // - + int DLOAD_0 = 38 ; // - + int DLOAD_1 = 39 ; // - + int DLOAD_2 = 40 ; // - + int DLOAD_3 = 41 ; // - + int ALOAD_0 = 42 ; // - + int ALOAD_1 = 43 ; // - + int ALOAD_2 = 44 ; // - + int ALOAD_3 = 45 ; // - + int IALOAD = 46 ; // visitInsn + int LALOAD = 47 ; // - + int FALOAD = 48 ; // - + int DALOAD = 49 ; // - + int AALOAD = 50 ; // - + int BALOAD = 51 ; // - + int CALOAD = 52 ; // - + int SALOAD = 53 ; // - + int ISTORE = 54 ; // visitVarInsn + int LSTORE = 55 ; // - + int FSTORE = 56 ; // - + int DSTORE = 57 ; // - + int ASTORE = 58 ; // - + int ISTORE_0 = 59 ; // - + int ISTORE_1 = 60 ; // - + int ISTORE_2 = 61 ; // - + int ISTORE_3 = 62 ; // - + int LSTORE_0 = 63 ; // - + int LSTORE_1 = 64 ; // - + int LSTORE_2 = 65 ; // - + int LSTORE_3 = 66 ; // - + int FSTORE_0 = 67 ; // - + int FSTORE_1 = 68 ; // - + int FSTORE_2 = 69 ; // - + int FSTORE_3 = 70 ; // - + int DSTORE_0 = 71 ; // - + int DSTORE_1 = 72 ; // - + int DSTORE_2 = 73 ; // - + int DSTORE_3 = 74 ; // - + int ASTORE_0 = 75 ; // - + int ASTORE_1 = 76 ; // - + int ASTORE_2 = 77 ; // - + int ASTORE_3 = 78 ; // - + int IASTORE = 79 ; // visitInsn + int LASTORE = 80 ; // - + int FASTORE = 81 ; // - + int DASTORE = 82 ; // - + int AASTORE = 83 ; // - + int BASTORE = 84 ; // - + int CASTORE = 85 ; // - + int SASTORE = 86 ; // - + int POP = 87 ; // - + int POP2 = 88 ; // - + int DUP = 89 ; // - + int DUP_X1 = 90 ; // - + int DUP_X2 = 91 ; // - + int DUP2 = 92 ; // - + int DUP2_X1 = 93 ; // - + int DUP2_X2 = 94 ; // - + int SWAP = 95 ; // - + int IADD = 96 ; // - + int LADD = 97 ; // - + int FADD = 98 ; // - + int DADD = 99 ; // - + int ISUB = 100 ; // - + int LSUB = 101 ; // - + int FSUB = 102 ; // - + int DSUB = 103 ; // - + int IMUL = 104 ; // - + int LMUL = 105 ; // - + int FMUL = 106 ; // - + int DMUL = 107 ; // - + int IDIV = 108 ; // - + int LDIV = 109 ; // - + int FDIV = 110 ; // - + int DDIV = 111 ; // - + int IREM = 112 ; // - + int LREM = 113 ; // - + int FREM = 114 ; // - + int DREM = 115 ; // - + int INEG = 116 ; // - + int LNEG = 117 ; // - + int FNEG = 118 ; // - + int DNEG = 119 ; // - + int ISHL = 120 ; // - + int LSHL = 121 ; // - + int ISHR = 122 ; // - + int LSHR = 123 ; // - + int IUSHR = 124 ; // - + int LUSHR = 125 ; // - + int IAND = 126 ; // - + int LAND = 127 ; // - + int IOR = 128 ; // - + int LOR = 129 ; // - + int IXOR = 130 ; // - + int LXOR = 131 ; // - + int IINC = 132 ; // visitIincInsn + int I2L = 133 ; // visitInsn + int I2F = 134 ; // - + int I2D = 135 ; // - + int L2I = 136 ; // - + int L2F = 137 ; // - + int L2D = 138 ; // - + int F2I = 139 ; // - + int F2L = 140 ; // - + int F2D = 141 ; // - + int D2I = 142 ; // - + int D2L = 143 ; // - + int D2F = 144 ; // - + int I2B = 145 ; // - + int I2C = 146 ; // - + int I2S = 147 ; // - + int LCMP = 148 ; // - + int FCMPL = 149 ; // - + int FCMPG = 150 ; // - + int DCMPL = 151 ; // - + int DCMPG = 152 ; // - + int IFEQ = 153 ; // visitJumpInsn + int IFNE = 154 ; // - + int IFLT = 155 ; // - + int IFGE = 156 ; // - + int IFGT = 157 ; // - + int IFLE = 158 ; // - + int IF_ICMPEQ = 159 ; // - + int IF_ICMPNE = 160 ; // - + int IF_ICMPLT = 161 ; // - + int IF_ICMPGE = 162 ; // - + int IF_ICMPGT = 163 ; // - + int IF_ICMPLE = 164 ; // - + int IF_ACMPEQ = 165 ; // - + int IF_ACMPNE = 166 ; // - + int GOTO = 167 ; // - + int JSR = 168 ; // - + int RET = 169 ; // visitVarInsn + int TABLESWITCH = 170 ; // visiTableSwitchInsn + int LOOKUPSWITCH = 171 ; // visitLookupSwitch + int IRETURN = 172 ; // visitInsn + int LRETURN = 173 ; // - + int FRETURN = 174 ; // - + int DRETURN = 175 ; // - + int ARETURN = 176 ; // - + int RETURN = 177 ; // - + int GETSTATIC = 178 ; // visitFieldInsn + int PUTSTATIC = 179 ; // - + int GETFIELD = 180 ; // - + int PUTFIELD = 181 ; // - + int INVOKEVIRTUAL = 182 ; // visitMethodInsn + int INVOKESPECIAL = 183 ; // - + int INVOKESTATIC = 184 ; // - + int INVOKEINTERFACE = 185 ; // - + int INVOKEDYNAMIC = 186 ; // visitInvokeDynamicInsn + int NEW = 187 ; // visitTypeInsn + int NEWARRAY = 188 ; // visitIntInsn + int ANEWARRAY = 189 ; // visitTypeInsn + int ARRAYLENGTH = 190 ; // visitInsn + int ATHROW = 191 ; // - + int CHECKCAST = 192 ; // visitTypeInsn + int INSTANCEOF = 193 ; // - + int MONITORENTER = 194 ; // visitInsn + int MONITOREXIT = 195 ; // - + int WIDE = 196 ; // NOT VISITED + int MULTIANEWARRAY = 197 ; // visitMultiANewArrayInsn + int IFNULL = 198 ; // visitJumpInsn + int IFNONNULL = 199 ; // - + int GOTO_W = 200 ; // - + int JSR_W = 201 ; // - \ No newline at end of file diff --git a/src/main/entry/AntlrTest.java b/src/main/entry/AntlrTest.java new file mode 100644 index 0000000..754d7a0 --- /dev/null +++ b/src/main/entry/AntlrTest.java @@ -0,0 +1,8 @@ +import org.antlr.v4.gui.TestRig; + +public class AntlrTest { + @SuppressWarnings("deprecation") + public static void main(String[] args) throws Exception { + TestRig.main(new String[] {}); + } +} diff --git a/src/main/entry/AntlrTool.java b/src/main/entry/AntlrTool.java new file mode 100644 index 0000000..526ceeb --- /dev/null +++ b/src/main/entry/AntlrTool.java @@ -0,0 +1,60 @@ +import org.antlr.v4.Tool; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; + +public class AntlrTool { + public static void main(String[] args) throws IOException { + + processLexer(); + // processParser(); + + + } + + private static void processParser() { + String g4 = "YJSParser.g4"; + String pkg; + + // g4 = "ExprParser.g4"; + if (g4.equals("YJSParser.g4")) + pkg = "org.bdware.sc.parser"; + else + pkg = "org.bdware.sc.parser.test"; + System.out.println("GenerateAt:" + "./common/src/main/gen/" + pkg.replaceAll("\\.", "/")); + File from = new File("./genparser/input/" + g4); + + File out = new File(g4); + out.delete(); + try { + Files.copy(from.toPath(), out.toPath()); + } catch (Exception e) { + e.printStackTrace(); + } + // Tool.main(new String[] {}); + Tool.main(new String[]{g4, "-package", pkg, "-o", "./common/src/main/gen/" + pkg.replaceAll("\\.", "/"), "-visitor"}); + // Tool.main(new String[] { g5, "-package", pkg, "-o", "./gen/" + + // pkg.replaceAll("\\.", "/"), "-visitor" }); + + System.out.println("DeleteFiles!"); + out.delete(); + } + + private static void processLexer() { + String g5 = "JavaScriptLexer.g4"; + String pkg = "org.bdware.sc.parser"; + + File from = new File("./genparser/input/" + g5); + File out = new File(g5); + out.delete(); + try { + Files.copy(from.toPath(), out.toPath()); + Tool.main(new String[]{g5, "-package", pkg, "-o", "./common/src/main/gen/" + + pkg.replaceAll("\\.", "/"), "-visitor"}); + new File(g5).delete(); + } catch (Exception e) { + e.printStackTrace(); + } + } +}