4 |
5 | This database contains information regarding CVE(s) that affect smart contracts. We currently store version information corresponding to respective modules as understood by select sources.
6 |
7 | |Language|Environments|Metadata|
8 | |--------|-------------|--------|
9 | |Solidity|Ethereum|`name`, `address`|
10 |
11 | This project is inspired by the great work done by the people at [RubySec](http://rubysec.github.io/) and [Victims](https://blog.victi.ms/).
12 |
13 | ### Notes on CVE(s)
14 | If you already have a CVE assigned to your project and would like us to create an entry for it with the correct coordinates, you can send us a [pull request](https://help.github.com/articles/using-pull-requests) or create an issue [here](https://github.com/soohoio/sooho/issues) with CVE details and affected components.
15 |
--------------------------------------------------------------------------------
/packages/sooho-advisory-db/ethereum/solidity/cve/2018-12056.yml:
--------------------------------------------------------------------------------
1 | id: CVE-2018-12056
2 | title: "Breking PRNG in All For One"
3 | description: >
4 | The maxRandom function of a smart contract implementation for All For One, an Ethereum gambling game, generates a random value with publicly readable variables because the _seed value can be retrieved with a getStorageAt call. Therefore, it allows attackers to always win and get rewards.
5 | references:
6 | - https://medium.com/coinmonks/to-be-a-winner-of-ethereum-gambling-game-all-for-one-by-breaking-prng-1ab011163d40
7 | - https://nvd.nist.gov/vuln/detail/CVE-2018-12056
8 | credits: "Jonghyuk Song"
9 | vulnerability_type:
10 | cwe: "CWE-338"
11 | swc: "SWC-120"
12 | severity: 7.5
13 | affected:
14 | contractName: "Lottery"
15 | address: "0x9c16cbb9f9bd827f6cbee556c7801073fbac2250"
16 | signature: "a9e7573645bdfd6e95d63117c6dab3ab"
17 |
--------------------------------------------------------------------------------
/packages/sooho-advisory-db/ethereum/solidity/cve/2018-12511.yml:
--------------------------------------------------------------------------------
1 | id: CVE-2018-12511
2 | title: "Integer overflow"
3 | description: >
4 | In the mintToken function of a smart contract implementation for Substratum (SUB), an Ethereum ERC20 token, the administrator can control mintedAmount, leverage an integer overflow, and modify a user account's balance arbitrarily.
5 | references:
6 | - https://github.com/n0pn0pn0p/smart_contract_-vulnerability/blob/master/PolyAi.md
7 | credits: "n0pn0pn0p"
8 | vulnerability_type:
9 | cwe: "CWE-190"
10 | swc: "SWC-101"
11 | severity: 7.5
12 | affected:
13 | contractName: "MyAdvancedToken"
14 | address: "0x12480e24eb5bec1a9d4369cab6a80cad3c0a377a"
15 | signature: "f2dea3f6ecb1397e9005efbd42dc90aa"
16 |
--------------------------------------------------------------------------------
/packages/sooho-advisory-db/ethereum/solidity/cve/2018-13158.yml:
--------------------------------------------------------------------------------
1 | id: CVE-2018-12056
2 | title: "Integer overflow"
3 | description: >
4 | The mintToken function of a smart contract implementation for AssetToken, an Ethereum token, has an integer overflow that allows the owner of the contract to set the balance of an arbitrary user to any value.
5 | references:
6 | - https://github.com/BlockChainsSecurity/EtherTokens/blob/master/GEMCHAIN/mint%20integer%20overflow.md
7 | - https://github.com/BlockChainsSecurity/EtherTokens/tree/master/AssetToken
8 | credits: "BlockChainsSecurity"
9 | vulnerability_type:
10 | cwe: "CWE-190"
11 | swc: "SWC-101"
12 | severity: 7.5
13 | affected:
14 | contractName: "AssetToken"
15 | address: "0x0bdbc0748ba09fbe9e9ed5938532e41446c2f033"
16 | signature: "8bc5f574da5fabf0b30bc2c9cb454231"
17 |
--------------------------------------------------------------------------------
/packages/sooho-advisory-db/ethereum/solidity/cve/2018-14001.yml:
--------------------------------------------------------------------------------
1 | id: CVE-2018-14001
2 | title: "Integer overflow"
3 | description: >
4 | An integer overflow vulnerability exists in the function batchTransfer of SHARKTECH (SKT), an Ethereum token smart contract. An attacker could use it to set any user's balance.
5 | references:
6 | - https://github.com/VenusADLab/EtherTokens/blob/master/SHARKTECH/SHARKTECH.md
7 | credits: "VenusADLab"
8 | vulnerability_type:
9 | cwe: "CWE-190"
10 | swc: "SWC-101"
11 | severity: 7.5
12 | affected:
13 | contractName: "Shark"
14 | address: "0xf4ac238121585456DeE1096fED287F4d8906D519"
15 | signature: "6796f60784392dd620c85d43ba4f734d"
16 |
--------------------------------------------------------------------------------
/packages/sooho-advisory-db/ethereum/solidity/cve/2018-14002.yml:
--------------------------------------------------------------------------------
1 | id: CVE-2018-14002
2 | title: "Integer overflow"
3 | description: >
4 | An integer overflow vulnerability exists in the function distribute of MP3 Coin (MP3), an Ethereum token smart contract. An attacker could use it to set any user's balance.
5 | references:
6 | - https://github.com/VenusADLab/EtherTokens/blob/master/SHARKTECH/SHARKTECH.md
7 | credits: "VenusADLab"
8 | vulnerability_type:
9 | cwe: "CWE-190"
10 | swc: "SWC-101"
11 | severity: 7.5
12 | affected:
13 | contractName: "MP3Coin"
14 | address: "0x5ad6dc0a267693c8a14ac9ff2a29c7d63a3d96c2"
15 | signature: "21c275adb76b36bcb05d19966466931d"
16 |
--------------------------------------------------------------------------------
/packages/sooho-advisory-db/ethereum/solidity/cve/2018-15552.yml:
--------------------------------------------------------------------------------
1 | id: CVE-2018-15552
2 | title: "Breking PRNG in Ethereum Lottery"
3 | description: >
4 | The "PayWinner" function of a simplelottery smart contract implementation for The Ethereum Lottery, an Ethereum gambling game, generates a random value with publicly readable variable "maxTickets" (which is private, yet predictable and readable by the eth.getStorageAt function). Therefore, it allows attackers to always win and get rewards.
5 | references:
6 | - https://github.com/TEAM-C4B/CVE-LIST/tree/master/CVE-2018-15552
7 | credits: "TEAM-C4B"
8 | vulnerability_type:
9 | cwe: "CWE-338"
10 | swc: "SWC-120"
11 | severity: 7.5
12 | affected:
13 | contractName: "LottoCount"
14 | address: "0x1e217adc6a6adc16e248af109ab7efa4d1bb252d"
15 | signature: "a4aa4756cc71cf9dcf673654010fc5f2"
16 |
--------------------------------------------------------------------------------
/packages/sooho-advisory-db/ethereum/solidity/cve/2018-17050.yml:
--------------------------------------------------------------------------------
1 | id: CVE-2018-17050
2 | title: "Integer overflow"
3 | description: >
4 | The mintToken function of a smart contract implementation for PolyAi (AI), an Ethereum token, has an integer overflow that allows the owner of the contract to set the balance of an arbitrary user to any value.
5 | references:
6 | - https://github.com/n0pn0pn0p/smart_contract_-vulnerability/blob/master/PolyAi.md
7 | credits: "n0pn0pn0p"
8 | vulnerability_type:
9 | cwe: "CWE-190"
10 | swc: "SWC-101"
11 | severity: 7.5
12 | affected:
13 | contractName: "PolyAi"
14 | address: "0x5121e348e897daef1eef23959ab290e5557cf274"
15 | signature: "ba41c713dfeca7d69147f8ebcc09f699"
16 |
--------------------------------------------------------------------------------
/packages/sooho-advisory-db/ethereum/solidity/cve/2018-17071.yml:
--------------------------------------------------------------------------------
1 | id: CVE-2018-17071
2 | title: "Breking PRNG in Lucky9io"
3 | description: >
4 | The fallback function of a simple lottery smart contract implementation for Lucky9io, an Ethereum gambling game, generates a random value with the publicly readable variable entry_number. This variable is private, yet it is readable by eth.getStorageAt function. Also, attackers can purchase a ticket at a low price by directly calling the fallback function with small msg.value, because the developer set the currency unit incorrectly. Therefore, it allows attackers to always win and get rewards.
5 | references:
6 | - https://github.com/TEAM-C4B/CVE-LIST/tree/master/CVE-2018-17071
7 | credits: "TEAM-C4B"
8 | vulnerability_type:
9 | cwe: "CWE-338"
10 | swc: "SWC-120"
11 | severity: 7.5
12 | affected:
13 | contractName: "lucky9io"
14 | address: "0x94f5a9cecb397a8fb837edb809bc1cd6a66ffed2"
15 | signature: "ac00ddfd6670573c81b30089ed6e4380"
16 |
--------------------------------------------------------------------------------
/packages/sooho-advisory-db/ethereum/solidity/cve/2018-17877.yml:
--------------------------------------------------------------------------------
1 | id: CVE-2018-17877
2 | title: "Breking PRNG in Greedy 599"
3 | description: >
4 | A lottery smart contract implementation for Greedy 599, an Ethereum gambling game, generates a random value that is predictable via an external contract call. The developer used the extcodesize() function to prevent a malicious contract from being called, but the attacker can bypass it by writing the core code in the constructor of their exploit code. Therefore, it allows attackers to always win and get rewards.
5 | references:
6 | - https://github.com/TEAM-C4B/CVE-LIST/tree/master/CVE-2018-17877
7 | credits: "TEAM-C4B"
8 | vulnerability_type:
9 | cwe: "CWE-338"
10 | swc: "SWC-120"
11 | severity: 7.5
12 | affected:
13 | contractName: "Greedy"
14 | address: "0x3bb5e74f7ff56e0b64d326f8ec07236aa4a07260"
15 | signature: "79c073187783d3569f266d7dc0cdc08c"
16 |
--------------------------------------------------------------------------------
/packages/sooho-advisory-db/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const yaml = require('js-yaml');
3 | const fs = require('fs');
4 | const path = require('path');
5 |
6 | const appDirectory = fs.realpathSync(process.cwd());
7 | const cveDirectory = 'ethereum/solidity/cve'
8 | const resolveOwn = relativePath => path.resolve(__dirname, relativePath);
9 |
10 | function getAdvisoryDB() {
11 | let data = [];
12 | try {
13 | const cveDir = resolveOwn(cveDirectory)
14 | fs.readdirSync(cveDir)
15 | .map(item => resolveOwn(`${cveDirectory}/${item}`))
16 | .forEach(filePath => data.push(yaml.safeLoad(
17 | fs.readFileSync(filePath, 'utf8')
18 | )));
19 | return data;
20 | } catch (e) {
21 | throw new Error(e);
22 | }
23 | }
24 |
25 | module.exports = { getAdvisoryDB };
26 |
--------------------------------------------------------------------------------
/packages/sooho-advisory-db/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "@sooho/advisory-db",
3 | "version": "0.3.4",
4 | "description": "A community-driven vulnerability database of smart contract",
5 | "repository": {
6 | "type": "git",
7 | "url": "https://github.com/soohoio/sooho"
8 | },
9 | "license": "CC BY-NC-SA-4.0",
10 | "author": "Jisu Park 32 | // The default value is {@code false} to avoid the performance and memory 33 | // overhead of copying text for every token unless explicitly requested.
34 | // 35 | this.copyText = copyText===undefined ? false : copyText; 36 | return this; 37 | } 38 | 39 | CommonTokenFactory.prototype = Object.create(TokenFactory.prototype); 40 | CommonTokenFactory.prototype.constructor = CommonTokenFactory; 41 | 42 | // 43 | // The default {@link CommonTokenFactory} instance. 44 | // 45 | //46 | // This token factory does not explicitly copy token text when constructing 47 | // tokens.
48 | // 49 | CommonTokenFactory.DEFAULT = new CommonTokenFactory(); 50 | 51 | CommonTokenFactory.prototype.create = function(source, type, text, channel, start, stop, line, column) { 52 | var t = new CommonToken(source, type, channel, start, stop); 53 | t.line = line; 54 | t.column = column; 55 | if (text !==null) { 56 | t.text = text; 57 | } else if (this.copyText && source[1] !==null) { 58 | t.text = source[1].getText(start,stop); 59 | } 60 | return t; 61 | }; 62 | 63 | CommonTokenFactory.prototype.createThin = function(type, text) { 64 | var t = new CommonToken(null, type); 65 | t.text = text; 66 | return t; 67 | }; 68 | 69 | exports.CommonTokenFactory = CommonTokenFactory; 70 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/CommonTokenStream.js: -------------------------------------------------------------------------------- 1 | // 2 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 3 | * Use of this file is governed by the BSD 3-clause license that 4 | * can be found in the LICENSE.txt file in the project root. 5 | */ 6 | /// 7 | 8 | // 9 | // This class extends {@link BufferedTokenStream} with functionality to filter 10 | // token streams to tokens on a particular channel (tokens where 11 | // {@link Token//getChannel} returns a particular value). 12 | // 13 | //14 | // This token stream provides access to all tokens by index or when calling 15 | // methods like {@link //getText}. The channel filtering is only used for code 16 | // accessing tokens via the lookahead methods {@link //LA}, {@link //LT}, and 17 | // {@link //LB}.
18 | // 19 | //20 | // By default, tokens are placed on the default channel 21 | // ({@link Token//DEFAULT_CHANNEL}), but may be reassigned by using the 22 | // {@code ->channel(HIDDEN)} lexer command, or by using an embedded action to 23 | // call {@link Lexer//setChannel}. 24 | //
25 | // 26 | //27 | // Note: lexer rules which use the {@code ->skip} lexer command or call 28 | // {@link Lexer//skip} do not produce tokens at all, so input text matched by 29 | // such a rule will not be available as part of the token stream, regardless of 30 | // channel.
31 | /// 32 | 33 | var Token = require('./Token').Token; 34 | var BufferedTokenStream = require('./BufferedTokenStream').BufferedTokenStream; 35 | 36 | function CommonTokenStream(lexer, channel) { 37 | BufferedTokenStream.call(this, lexer); 38 | this.channel = channel===undefined ? Token.DEFAULT_CHANNEL : channel; 39 | return this; 40 | } 41 | 42 | CommonTokenStream.prototype = Object.create(BufferedTokenStream.prototype); 43 | CommonTokenStream.prototype.constructor = CommonTokenStream; 44 | 45 | CommonTokenStream.prototype.adjustSeekIndex = function(i) { 46 | return this.nextTokenOnChannel(i, this.channel); 47 | }; 48 | 49 | CommonTokenStream.prototype.LB = function(k) { 50 | if (k===0 || this.index-k<0) { 51 | return null; 52 | } 53 | var i = this.index; 54 | var n = 1; 55 | // find k good tokens looking backwards 56 | while (n <= k) { 57 | // skip off-channel tokens 58 | i = this.previousTokenOnChannel(i - 1, this.channel); 59 | n += 1; 60 | } 61 | if (i < 0) { 62 | return null; 63 | } 64 | return this.tokens[i]; 65 | }; 66 | 67 | CommonTokenStream.prototype.LT = function(k) { 68 | this.lazyInit(); 69 | if (k === 0) { 70 | return null; 71 | } 72 | if (k < 0) { 73 | return this.LB(-k); 74 | } 75 | var i = this.index; 76 | var n = 1; // we know tokens[pos] is a good one 77 | // find k good tokens 78 | while (n < k) { 79 | // skip off-channel tokens, but make sure to not look past EOF 80 | if (this.sync(i + 1)) { 81 | i = this.nextTokenOnChannel(i + 1, this.channel); 82 | } 83 | n += 1; 84 | } 85 | return this.tokens[i]; 86 | }; 87 | 88 | // Count EOF just once./// 89 | CommonTokenStream.prototype.getNumberOfOnChannelTokens = function() { 90 | var n = 0; 91 | this.fill(); 92 | for (var i =0; i< this.tokens.length;i++) { 93 | var t = this.tokens[i]; 94 | if( t.channel===this.channel) { 95 | n += 1; 96 | } 97 | if( t.type===Token.EOF) { 98 | break; 99 | } 100 | } 101 | return n; 102 | }; 103 | 104 | exports.CommonTokenStream = CommonTokenStream; -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/FileStream.js: -------------------------------------------------------------------------------- 1 | // 2 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 3 | * Use of this file is governed by the BSD 3-clause license that 4 | * can be found in the LICENSE.txt file in the project root. 5 | */ 6 | // 7 | 8 | // 9 | // This is an InputStream that is loaded from a file all at once 10 | // when you construct the object. 11 | // 12 | var InputStream = require('./InputStream').InputStream; 13 | var isNodeJs = typeof window === 'undefined' && typeof importScripts === 'undefined'; 14 | var fs = isNodeJs ? require("fs") : null; 15 | 16 | function FileStream(fileName, decodeToUnicodeCodePoints) { 17 | var data = fs.readFileSync(fileName, "utf8"); 18 | InputStream.call(this, data, decodeToUnicodeCodePoints); 19 | this.fileName = fileName; 20 | return this; 21 | } 22 | 23 | FileStream.prototype = Object.create(InputStream.prototype); 24 | FileStream.prototype.constructor = FileStream; 25 | 26 | exports.FileStream = FileStream; 27 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/InputStream.js: -------------------------------------------------------------------------------- 1 | // 2 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 3 | * Use of this file is governed by the BSD 3-clause license that 4 | * can be found in the LICENSE.txt file in the project root. 5 | */ 6 | // 7 | 8 | var Token = require('./Token').Token; 9 | require('./polyfills/codepointat'); 10 | require('./polyfills/fromcodepoint'); 11 | 12 | // Vacuum all input from a string and then treat it like a buffer. 13 | 14 | function _loadString(stream, decodeToUnicodeCodePoints) { 15 | stream._index = 0; 16 | stream.data = []; 17 | if (stream.decodeToUnicodeCodePoints) { 18 | for (var i = 0; i < stream.strdata.length; ) { 19 | var codePoint = stream.strdata.codePointAt(i); 20 | stream.data.push(codePoint); 21 | i += codePoint <= 0xFFFF ? 1 : 2; 22 | } 23 | } else { 24 | for (var i = 0; i < stream.strdata.length; i++) { 25 | var codeUnit = stream.strdata.charCodeAt(i); 26 | stream.data.push(codeUnit); 27 | } 28 | } 29 | stream._size = stream.data.length; 30 | } 31 | 32 | // If decodeToUnicodeCodePoints is true, the input is treated 33 | // as a series of Unicode code points. 34 | // 35 | // Otherwise, the input is treated as a series of 16-bit UTF-16 code 36 | // units. 37 | function InputStream(data, decodeToUnicodeCodePoints) { 38 | this.name = "If {@code ctx} is {@code null} and the end of the rule containing 71 | // {@code s} is reached, {@link Token//EPSILON} is added to the result set. 72 | // If {@code ctx} is not {@code null} and the end of the outermost rule is 73 | // reached, {@link Token//EOF} is added to the result set.
74 | // 75 | // @param s the ATN state 76 | // @param stopState the ATN state to stop at. This can be a 77 | // {@link BlockEndState} to detect epsilon paths through a closure. 78 | // @param ctx the complete parser context, or {@code null} if the context 79 | // should be ignored 80 | // 81 | // @return The set of tokens that can follow {@code s} in the ATN in the 82 | // specified {@code ctx}. 83 | /// 84 | LL1Analyzer.prototype.LOOK = function(s, stopState, ctx) { 85 | var r = new IntervalSet(); 86 | var seeThruPreds = true; // ignore preds; get all lookahead 87 | ctx = ctx || null; 88 | var lookContext = ctx!==null ? predictionContextFromRuleContext(s.atn, ctx) : null; 89 | this._LOOK(s, stopState, lookContext, r, new Set(), new BitSet(), seeThruPreds, true); 90 | return r; 91 | }; 92 | 93 | //* 94 | // Compute set of tokens that can follow {@code s} in the ATN in the 95 | // specified {@code ctx}. 96 | // 97 | //If {@code ctx} is {@code null} and {@code stopState} or the end of the 98 | // rule containing {@code s} is reached, {@link Token//EPSILON} is added to 99 | // the result set. If {@code ctx} is not {@code null} and {@code addEOF} is 100 | // {@code true} and {@code stopState} or the end of the outermost rule is 101 | // reached, {@link Token//EOF} is added to the result set.
102 | // 103 | // @param s the ATN state. 104 | // @param stopState the ATN state to stop at. This can be a 105 | // {@link BlockEndState} to detect epsilon paths through a closure. 106 | // @param ctx The outer context, or {@code null} if the outer context should 107 | // not be used. 108 | // @param look The result lookahead set. 109 | // @param lookBusy A set used for preventing epsilon closures in the ATN 110 | // from causing a stack overflow. Outside code should pass 111 | // {@code new Set79 | // Since tokens on hidden channels (e.g. whitespace or comments) are not 80 | // added to the parse trees, they will not appear in the output of this 81 | // method. 82 | // / 83 | RuleContext.prototype.getText = function() { 84 | if (this.getChildCount() === 0) { 85 | return ""; 86 | } else { 87 | return this.children.map(function(child) { 88 | return child.getText(); 89 | }).join(" "); 90 | } 91 | }; 92 | 93 | // For rule associated with this parse tree internal node, return 94 | // the outer alternative number used to match the input. Default 95 | // implementation does not compute nor store this alt num. Create 96 | // a subclass of ParserRuleContext with backing field and set 97 | // option contextSuperClass. 98 | // to set it. 99 | RuleContext.prototype.getAltNumber = function() { return INVALID_ALT_NUMBER; } 100 | 101 | // Set the outer alternative number for this context node. Default 102 | // implementation does nothing to avoid backing field overhead for 103 | // trees that don't need it. Create 104 | // a subclass of ParserRuleContext with backing field and set 105 | // option contextSuperClass. 106 | RuleContext.prototype.setAltNumber = function(altNumber) { } 107 | 108 | RuleContext.prototype.getChild = function(i) { 109 | return null; 110 | }; 111 | 112 | RuleContext.prototype.getChildCount = function() { 113 | return 0; 114 | }; 115 | 116 | RuleContext.prototype.accept = function(visitor) { 117 | return visitor.visitChildren(this); 118 | }; 119 | 120 | //need to manage circular dependencies, so export now 121 | exports.RuleContext = RuleContext; 122 | var Trees = require('./tree/Trees').Trees; 123 | 124 | 125 | // Print out a whole tree, not just a node, in LISP format 126 | // (root child1 .. childN). Print just a node if this is a leaf. 127 | // 128 | 129 | RuleContext.prototype.toStringTree = function(ruleNames, recog) { 130 | return Trees.toStringTree(this, ruleNames, recog); 131 | }; 132 | 133 | RuleContext.prototype.toString = function(ruleNames, stop) { 134 | ruleNames = ruleNames || null; 135 | stop = stop || null; 136 | var p = this; 137 | var s = "["; 138 | while (p !== null && p !== stop) { 139 | if (ruleNames === null) { 140 | if (!p.isEmpty()) { 141 | s += p.invokingState; 142 | } 143 | } else { 144 | var ri = p.ruleIndex; 145 | var ruleName = (ri >= 0 && ri < ruleNames.length) ? ruleNames[ri] 146 | : "" + ri; 147 | s += ruleName; 148 | } 149 | if (p.parentCtx !== null && (ruleNames !== null || !p.parentCtx.isEmpty())) { 150 | s += " "; 151 | } 152 | p = p.parentCtx; 153 | } 154 | s += "]"; 155 | return s; 156 | }; 157 | 158 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/Token.js: -------------------------------------------------------------------------------- 1 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 2 | * Use of this file is governed by the BSD 3-clause license that 3 | * can be found in the LICENSE.txt file in the project root. 4 | */ 5 | // 6 | 7 | // A token has properties: text, type, line, character position in the line 8 | // (so we can ignore tabs), token channel, index, and source from which 9 | // we obtained this token. 10 | 11 | function Token() { 12 | this.source = null; 13 | this.type = null; // token type of the token 14 | this.channel = null; // The parser ignores everything not on DEFAULT_CHANNEL 15 | this.start = null; // optional; return -1 if not implemented. 16 | this.stop = null; // optional; return -1 if not implemented. 17 | this.tokenIndex = null; // from 0..n-1 of the token object in the input stream 18 | this.line = null; // line=1..n of the 1st character 19 | this.column = null; // beginning of the line at which it occurs, 0..n-1 20 | this._text = null; // text of the token. 21 | return this; 22 | } 23 | 24 | Token.INVALID_TYPE = 0; 25 | 26 | // During lookahead operations, this "token" signifies we hit rule end ATN state 27 | // and did not follow it despite needing to. 28 | Token.EPSILON = -2; 29 | 30 | Token.MIN_USER_TOKEN_TYPE = 1; 31 | 32 | Token.EOF = -1; 33 | 34 | // All tokens go to the parser (unless skip() is called in that rule) 35 | // on a particular "channel". The parser tunes to a particular channel 36 | // so that whitespace etc... can go to the parser on a "hidden" channel. 37 | 38 | Token.DEFAULT_CHANNEL = 0; 39 | 40 | // Anything on different channel than DEFAULT_CHANNEL is not parsed 41 | // by parser. 42 | 43 | Token.HIDDEN_CHANNEL = 1; 44 | 45 | // Explicitly set the text for this token. If {code text} is not 46 | // {@code null}, then {@link //getText} will return this value rather than 47 | // extracting the text from the input. 48 | // 49 | // @param text The explicit text of the token, or {@code null} if the text 50 | // should be obtained from the input along with the start and stop indexes 51 | // of the token. 52 | 53 | Object.defineProperty(Token.prototype, "text", { 54 | get : function() { 55 | return this._text; 56 | }, 57 | set : function(text) { 58 | this._text = text; 59 | } 60 | }); 61 | 62 | Token.prototype.getTokenSource = function() { 63 | return this.source[0]; 64 | }; 65 | 66 | Token.prototype.getInputStream = function() { 67 | return this.source[1]; 68 | }; 69 | 70 | function CommonToken(source, type, channel, start, stop) { 71 | Token.call(this); 72 | this.source = source !== undefined ? source : CommonToken.EMPTY_SOURCE; 73 | this.type = type !== undefined ? type : null; 74 | this.channel = channel !== undefined ? channel : Token.DEFAULT_CHANNEL; 75 | this.start = start !== undefined ? start : -1; 76 | this.stop = stop !== undefined ? stop : -1; 77 | this.tokenIndex = -1; 78 | if (this.source[0] !== null) { 79 | this.line = source[0].line; 80 | this.column = source[0].column; 81 | } else { 82 | this.column = -1; 83 | } 84 | return this; 85 | } 86 | 87 | CommonToken.prototype = Object.create(Token.prototype); 88 | CommonToken.prototype.constructor = CommonToken; 89 | 90 | // An empty {@link Pair} which is used as the default value of 91 | // {@link //source} for tokens that do not have a source. 92 | CommonToken.EMPTY_SOURCE = [ null, null ]; 93 | 94 | // Constructs a new {@link CommonToken} as a copy of another {@link Token}. 95 | // 96 | //
97 | // If {@code oldToken} is also a {@link CommonToken} instance, the newly 98 | // constructed token will share a reference to the {@link //text} field and 99 | // the {@link Pair} stored in {@link //source}. Otherwise, {@link //text} will 100 | // be assigned the result of calling {@link //getText}, and {@link //source} 101 | // will be constructed from the result of {@link Token//getTokenSource} and 102 | // {@link Token//getInputStream}.
103 | // 104 | // @param oldToken The token to copy. 105 | // 106 | CommonToken.prototype.clone = function() { 107 | var t = new CommonToken(this.source, this.type, this.channel, this.start, 108 | this.stop); 109 | t.tokenIndex = this.tokenIndex; 110 | t.line = this.line; 111 | t.column = this.column; 112 | t.text = this.text; 113 | return t; 114 | }; 115 | 116 | Object.defineProperty(CommonToken.prototype, "text", { 117 | get : function() { 118 | if (this._text !== null) { 119 | return this._text; 120 | } 121 | var input = this.getInputStream(); 122 | if (input === null) { 123 | return null; 124 | } 125 | var n = input.size; 126 | if (this.start < n && this.stop < n) { 127 | return input.getText(this.start, this.stop); 128 | } else { 129 | return "If {@code context} is {@code null}, it is treated as 104 | // {@link ParserRuleContext//EMPTY}.
105 | // 106 | // @param stateNumber the ATN state number 107 | // @param context the full parse context 108 | // @return The set of potentially valid input symbols which could follow the 109 | // specified state in the specified context. 110 | // @throws IllegalArgumentException if the ATN does not contain a state with 111 | // number {@code stateNumber} 112 | var Token = require('./../Token').Token; 113 | 114 | ATN.prototype.getExpectedTokens = function( stateNumber, ctx ) { 115 | if ( stateNumber < 0 || stateNumber >= this.states.length ) { 116 | throw("Invalid state number."); 117 | } 118 | var s = this.states[stateNumber]; 119 | var following = this.nextTokens(s); 120 | if (!following.contains(Token.EPSILON)) { 121 | return following; 122 | } 123 | var expected = new IntervalSet(); 124 | expected.addSet(following); 125 | expected.removeOne(Token.EPSILON); 126 | while (ctx !== null && ctx.invokingState >= 0 && following.contains(Token.EPSILON)) { 127 | var invokingState = this.states[ctx.invokingState]; 128 | var rt = invokingState.transitions[0]; 129 | following = this.nextTokens(rt.followState); 130 | expected.addSet(following); 131 | expected.removeOne(Token.EPSILON); 132 | ctx = ctx.parentCtx; 133 | } 134 | if (following.contains(Token.EPSILON)) { 135 | expected.addOne(Token.EOF); 136 | } 137 | return expected; 138 | }; 139 | 140 | ATN.INVALID_ALT_NUMBER = 0; 141 | 142 | exports.ATN = ATN; -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/atn/ATNConfig.js: -------------------------------------------------------------------------------- 1 | // 2 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 3 | * Use of this file is governed by the BSD 3-clause license that 4 | * can be found in the LICENSE.txt file in the project root. 5 | */ 6 | /// 7 | 8 | // A tuple: (ATN state, predicted alt, syntactic, semantic context). 9 | // The syntactic context is a graph-structured stack node whose 10 | // path(s) to the root is the rule invocation(s) 11 | // chain used to arrive at the state. The semantic context is 12 | // the tree of semantic predicates encountered before reaching 13 | // an ATN state. 14 | /// 15 | 16 | var DecisionState = require('./ATNState').DecisionState; 17 | var SemanticContext = require('./SemanticContext').SemanticContext; 18 | var Hash = require("../Utils").Hash; 19 | 20 | 21 | function checkParams(params, isCfg) { 22 | if(params===null) { 23 | var result = { state:null, alt:null, context:null, semanticContext:null }; 24 | if(isCfg) { 25 | result.reachesIntoOuterContext = 0; 26 | } 27 | return result; 28 | } else { 29 | var props = {}; 30 | props.state = params.state || null; 31 | props.alt = (params.alt === undefined) ? null : params.alt; 32 | props.context = params.context || null; 33 | props.semanticContext = params.semanticContext || null; 34 | if(isCfg) { 35 | props.reachesIntoOuterContext = params.reachesIntoOuterContext || 0; 36 | props.precedenceFilterSuppressed = params.precedenceFilterSuppressed || false; 37 | } 38 | return props; 39 | } 40 | } 41 | 42 | function ATNConfig(params, config) { 43 | this.checkContext(params, config); 44 | params = checkParams(params); 45 | config = checkParams(config, true); 46 | // The ATN state associated with this configuration/// 47 | this.state = params.state!==null ? params.state : config.state; 48 | // What alt (or lexer rule) is predicted by this configuration/// 49 | this.alt = params.alt!==null ? params.alt : config.alt; 50 | // The stack of invoking states leading to the rule/states associated 51 | // with this config. We track only those contexts pushed during 52 | // execution of the ATN simulator. 53 | this.context = params.context!==null ? params.context : config.context; 54 | this.semanticContext = params.semanticContext!==null ? params.semanticContext : 55 | (config.semanticContext!==null ? config.semanticContext : SemanticContext.NONE); 56 | // We cannot execute predicates dependent upon local context unless 57 | // we know for sure we are in the correct context. Because there is 58 | // no way to do this efficiently, we simply cannot evaluate 59 | // dependent predicates unless we are in the rule that initially 60 | // invokes the ATN simulator. 61 | // 62 | // closure() tracks the depth of how far we dip into the 63 | // outer context: depth > 0. Note that it may not be totally 64 | // accurate depth since I don't ever decrement. TODO: make it a boolean then 65 | this.reachesIntoOuterContext = config.reachesIntoOuterContext; 66 | this.precedenceFilterSuppressed = config.precedenceFilterSuppressed; 67 | return this; 68 | } 69 | 70 | ATNConfig.prototype.checkContext = function(params, config) { 71 | if((params.context===null || params.context===undefined) && 72 | (config===null || config.context===null || config.context===undefined)) { 73 | this.context = null; 74 | } 75 | }; 76 | 77 | 78 | ATNConfig.prototype.hashCode = function() { 79 | var hash = new Hash(); 80 | this.updateHashCode(hash); 81 | return hash.finish(); 82 | }; 83 | 84 | 85 | ATNConfig.prototype.updateHashCode = function(hash) { 86 | hash.update(this.state.stateNumber, this.alt, this.context, this.semanticContext); 87 | }; 88 | 89 | // An ATN configuration is equal to another if both have 90 | // the same state, they predict the same alternative, and 91 | // syntactic/semantic contexts are the same. 92 | 93 | ATNConfig.prototype.equals = function(other) { 94 | if (this === other) { 95 | return true; 96 | } else if (! (other instanceof ATNConfig)) { 97 | return false; 98 | } else { 99 | return this.state.stateNumber===other.state.stateNumber && 100 | this.alt===other.alt && 101 | (this.context===null ? other.context===null : this.context.equals(other.context)) && 102 | this.semanticContext.equals(other.semanticContext) && 103 | this.precedenceFilterSuppressed===other.precedenceFilterSuppressed; 104 | } 105 | }; 106 | 107 | 108 | ATNConfig.prototype.hashCodeForConfigSet = function() { 109 | var hash = new Hash(); 110 | hash.update(this.state.stateNumber, this.alt, this.semanticContext); 111 | return hash.finish(); 112 | }; 113 | 114 | 115 | ATNConfig.prototype.equalsForConfigSet = function(other) { 116 | if (this === other) { 117 | return true; 118 | } else if (! (other instanceof ATNConfig)) { 119 | return false; 120 | } else { 121 | return this.state.stateNumber===other.state.stateNumber && 122 | this.alt===other.alt && 123 | this.semanticContext.equals(other.semanticContext); 124 | } 125 | }; 126 | 127 | 128 | ATNConfig.prototype.toString = function() { 129 | return "(" + this.state + "," + this.alt + 130 | (this.context!==null ? ",[" + this.context.toString() + "]" : "") + 131 | (this.semanticContext !== SemanticContext.NONE ? 132 | ("," + this.semanticContext.toString()) 133 | : "") + 134 | (this.reachesIntoOuterContext>0 ? 135 | (",up=" + this.reachesIntoOuterContext) 136 | : "") + ")"; 137 | }; 138 | 139 | 140 | function LexerATNConfig(params, config) { 141 | ATNConfig.call(this, params, config); 142 | 143 | // This is the backing field for {@link //getLexerActionExecutor}. 144 | var lexerActionExecutor = params.lexerActionExecutor || null; 145 | this.lexerActionExecutor = lexerActionExecutor || (config!==null ? config.lexerActionExecutor : null); 146 | this.passedThroughNonGreedyDecision = config!==null ? this.checkNonGreedyDecision(config, this.state) : false; 147 | return this; 148 | } 149 | 150 | LexerATNConfig.prototype = Object.create(ATNConfig.prototype); 151 | LexerATNConfig.prototype.constructor = LexerATNConfig; 152 | 153 | LexerATNConfig.prototype.updateHashCode = function(hash) { 154 | hash.update(this.state.stateNumber, this.alt, this.context, this.semanticContext, this.passedThroughNonGreedyDecision, this.lexerActionExecutor); 155 | }; 156 | 157 | LexerATNConfig.prototype.equals = function(other) { 158 | return this === other || 159 | (other instanceof LexerATNConfig && 160 | this.passedThroughNonGreedyDecision == other.passedThroughNonGreedyDecision && 161 | (this.lexerActionExecutor ? this.lexerActionExecutor.equals(other.lexerActionExecutor) : !other.lexerActionExecutor) && 162 | ATNConfig.prototype.equals.call(this, other)); 163 | }; 164 | 165 | LexerATNConfig.prototype.hashCodeForConfigSet = LexerATNConfig.prototype.hashCode; 166 | 167 | LexerATNConfig.prototype.equalsForConfigSet = LexerATNConfig.prototype.equals; 168 | 169 | 170 | LexerATNConfig.prototype.checkNonGreedyDecision = function(source, target) { 171 | return source.passedThroughNonGreedyDecision || 172 | (target instanceof DecisionState) && target.nonGreedy; 173 | }; 174 | 175 | exports.ATNConfig = ATNConfig; 176 | exports.LexerATNConfig = LexerATNConfig; -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/atn/ATNDeserializationOptions.js: -------------------------------------------------------------------------------- 1 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 2 | * Use of this file is governed by the BSD 3-clause license that 3 | * can be found in the LICENSE.txt file in the project root. 4 | */ 5 | 6 | function ATNDeserializationOptions(copyFrom) { 7 | if(copyFrom===undefined) { 8 | copyFrom = null; 9 | } 10 | this.readOnly = false; 11 | this.verifyATN = copyFrom===null ? true : copyFrom.verifyATN; 12 | this.generateRuleBypassTransitions = copyFrom===null ? false : copyFrom.generateRuleBypassTransitions; 13 | 14 | return this; 15 | } 16 | 17 | ATNDeserializationOptions.defaultOptions = new ATNDeserializationOptions(); 18 | ATNDeserializationOptions.defaultOptions.readOnly = true; 19 | 20 | // def __setattr__(self, key, value): 21 | // if key!="readOnly" and self.readOnly: 22 | // raise Exception("The object is read only.") 23 | // super(type(self), self).__setattr__(key,value) 24 | 25 | exports.ATNDeserializationOptions = ATNDeserializationOptions; 26 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/atn/ATNSimulator.js: -------------------------------------------------------------------------------- 1 | // 2 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 3 | * Use of this file is governed by the BSD 3-clause license that 4 | * can be found in the LICENSE.txt file in the project root. 5 | */ 6 | /// 7 | 8 | var DFAState = require('./../dfa/DFAState').DFAState; 9 | var ATNConfigSet = require('./ATNConfigSet').ATNConfigSet; 10 | var getCachedPredictionContext = require('./../PredictionContext').getCachedPredictionContext; 11 | 12 | function ATNSimulator(atn, sharedContextCache) { 13 | 14 | // The context cache maps all PredictionContext objects that are == 15 | // to a single cached copy. This cache is shared across all contexts 16 | // in all ATNConfigs in all DFA states. We rebuild each ATNConfigSet 17 | // to use only cached nodes/graphs in addDFAState(). We don't want to 18 | // fill this during closure() since there are lots of contexts that 19 | // pop up but are not used ever again. It also greatly slows down closure(). 20 | // 21 | //This cache makes a huge difference in memory and a little bit in speed. 22 | // For the Java grammar on java.*, it dropped the memory requirements 23 | // at the end from 25M to 16M. We don't store any of the full context 24 | // graphs in the DFA because they are limited to local context only, 25 | // but apparently there's a lot of repetition there as well. We optimize 26 | // the config contexts before storing the config set in the DFA states 27 | // by literally rebuilding them with cached subgraphs only.
28 | // 29 | //I tried a cache for use during closure operations, that was 30 | // whacked after each adaptivePredict(). It cost a little bit 31 | // more time I think and doesn't save on the overall footprint 32 | // so it's not worth the complexity.
33 | /// 34 | this.atn = atn; 35 | this.sharedContextCache = sharedContextCache; 36 | return this; 37 | } 38 | 39 | // Must distinguish between missing edge and edge we know leads nowhere/// 40 | ATNSimulator.ERROR = new DFAState(0x7FFFFFFF, new ATNConfigSet()); 41 | 42 | 43 | ATNSimulator.prototype.getCachedContext = function(context) { 44 | if (this.sharedContextCache ===null) { 45 | return context; 46 | } 47 | var visited = {}; 48 | return getCachedPredictionContext(context, this.sharedContextCache, visited); 49 | }; 50 | 51 | exports.ATNSimulator = ATNSimulator; 52 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/atn/ATNType.js: -------------------------------------------------------------------------------- 1 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 2 | * Use of this file is governed by the BSD 3-clause license that 3 | * can be found in the LICENSE.txt file in the project root. 4 | */ 5 | /// 6 | 7 | // Represents the type of recognizer an ATN applies to. 8 | 9 | function ATNType() { 10 | 11 | } 12 | 13 | ATNType.LEXER = 0; 14 | ATNType.PARSER = 1; 15 | 16 | exports.ATNType = ATNType; 17 | 18 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/atn/LexerActionExecutor.js: -------------------------------------------------------------------------------- 1 | // 2 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 3 | * Use of this file is governed by the BSD 3-clause license that 4 | * can be found in the LICENSE.txt file in the project root. 5 | */ 6 | /// 7 | 8 | // Represents an executor for a sequence of lexer actions which traversed during 9 | // the matching operation of a lexer rule (token). 10 | // 11 | //The executor tracks position information for position-dependent lexer actions 12 | // efficiently, ensuring that actions appearing only at the end of the rule do 13 | // not cause bloating of the {@link DFA} created for the lexer.
14 | 15 | var hashStuff = require("../Utils").hashStuff; 16 | var LexerIndexedCustomAction = require('./LexerAction').LexerIndexedCustomAction; 17 | 18 | function LexerActionExecutor(lexerActions) { 19 | this.lexerActions = lexerActions === null ? [] : lexerActions; 20 | // Caches the result of {@link //hashCode} since the hash code is an element 21 | // of the performance-critical {@link LexerATNConfig//hashCode} operation. 22 | this.cachedHashCode = hashStuff(lexerActions); // "".join([str(la) for la in 23 | // lexerActions])) 24 | return this; 25 | } 26 | 27 | // Creates a {@link LexerActionExecutor} which executes the actions for 28 | // the input {@code lexerActionExecutor} followed by a specified 29 | // {@code lexerAction}. 30 | // 31 | // @param lexerActionExecutor The executor for actions already traversed by 32 | // the lexer while matching a token within a particular 33 | // {@link LexerATNConfig}. If this is {@code null}, the method behaves as 34 | // though it were an empty executor. 35 | // @param lexerAction The lexer action to execute after the actions 36 | // specified in {@code lexerActionExecutor}. 37 | // 38 | // @return A {@link LexerActionExecutor} for executing the combine actions 39 | // of {@code lexerActionExecutor} and {@code lexerAction}. 40 | LexerActionExecutor.append = function(lexerActionExecutor, lexerAction) { 41 | if (lexerActionExecutor === null) { 42 | return new LexerActionExecutor([ lexerAction ]); 43 | } 44 | var lexerActions = lexerActionExecutor.lexerActions.concat([ lexerAction ]); 45 | return new LexerActionExecutor(lexerActions); 46 | }; 47 | 48 | // Creates a {@link LexerActionExecutor} which encodes the current offset 49 | // for position-dependent lexer actions. 50 | // 51 | //Normally, when the executor encounters lexer actions where 52 | // {@link LexerAction//isPositionDependent} returns {@code true}, it calls 53 | // {@link IntStream//seek} on the input {@link CharStream} to set the input 54 | // position to the end of the current token. This behavior provides 55 | // for efficient DFA representation of lexer actions which appear at the end 56 | // of a lexer rule, even when the lexer rule matches a variable number of 57 | // characters.
58 | // 59 | //Prior to traversing a match transition in the ATN, the current offset 60 | // from the token start index is assigned to all position-dependent lexer 61 | // actions which have not already been assigned a fixed offset. By storing 62 | // the offsets relative to the token start index, the DFA representation of 63 | // lexer actions which appear in the middle of tokens remains efficient due 64 | // to sharing among tokens of the same length, regardless of their absolute 65 | // position in the input stream.
66 | // 67 | //If the current executor already has offsets assigned to all 68 | // position-dependent lexer actions, the method returns {@code this}.
69 | // 70 | // @param offset The current offset to assign to all position-dependent 71 | // lexer actions which do not already have offsets assigned. 72 | // 73 | // @return A {@link LexerActionExecutor} which stores input stream offsets 74 | // for all position-dependent lexer actions. 75 | // / 76 | LexerActionExecutor.prototype.fixOffsetBeforeMatch = function(offset) { 77 | var updatedLexerActions = null; 78 | for (var i = 0; i < this.lexerActions.length; i++) { 79 | if (this.lexerActions[i].isPositionDependent && 80 | !(this.lexerActions[i] instanceof LexerIndexedCustomAction)) { 81 | if (updatedLexerActions === null) { 82 | updatedLexerActions = this.lexerActions.concat([]); 83 | } 84 | updatedLexerActions[i] = new LexerIndexedCustomAction(offset, 85 | this.lexerActions[i]); 86 | } 87 | } 88 | if (updatedLexerActions === null) { 89 | return this; 90 | } else { 91 | return new LexerActionExecutor(updatedLexerActions); 92 | } 93 | }; 94 | 95 | // Execute the actions encapsulated by this executor within the context of a 96 | // particular {@link Lexer}. 97 | // 98 | //This method calls {@link IntStream//seek} to set the position of the 99 | // {@code input} {@link CharStream} prior to calling 100 | // {@link LexerAction//execute} on a position-dependent action. Before the 101 | // method returns, the input position will be restored to the same position 102 | // it was in when the method was invoked.
103 | // 104 | // @param lexer The lexer instance. 105 | // @param input The input stream which is the source for the current token. 106 | // When this method is called, the current {@link IntStream//index} for 107 | // {@code input} should be the start of the following token, i.e. 1 108 | // character past the end of the current token. 109 | // @param startIndex The token start index. This value may be passed to 110 | // {@link IntStream//seek} to set the {@code input} position to the beginning 111 | // of the token. 112 | // / 113 | LexerActionExecutor.prototype.execute = function(lexer, input, startIndex) { 114 | var requiresSeek = false; 115 | var stopIndex = input.index; 116 | try { 117 | for (var i = 0; i < this.lexerActions.length; i++) { 118 | var lexerAction = this.lexerActions[i]; 119 | if (lexerAction instanceof LexerIndexedCustomAction) { 120 | var offset = lexerAction.offset; 121 | input.seek(startIndex + offset); 122 | lexerAction = lexerAction.action; 123 | requiresSeek = (startIndex + offset) !== stopIndex; 124 | } else if (lexerAction.isPositionDependent) { 125 | input.seek(stopIndex); 126 | requiresSeek = false; 127 | } 128 | lexerAction.execute(lexer); 129 | } 130 | } finally { 131 | if (requiresSeek) { 132 | input.seek(stopIndex); 133 | } 134 | } 135 | }; 136 | 137 | LexerActionExecutor.prototype.hashCode = function() { 138 | return this.cachedHashCode; 139 | }; 140 | 141 | LexerActionExecutor.prototype.updateHashCode = function(hash) { 142 | hash.update(this.cachedHashCode); 143 | }; 144 | 145 | 146 | LexerActionExecutor.prototype.equals = function(other) { 147 | if (this === other) { 148 | return true; 149 | } else if (!(other instanceof LexerActionExecutor)) { 150 | return false; 151 | } else if (this.cachedHashCode != other.cachedHashCode) { 152 | return false; 153 | } else if (this.lexerActions.length != other.lexerActions.length) { 154 | return false; 155 | } else { 156 | var numActions = this.lexerActions.length 157 | for (var idx = 0; idx < numActions; ++idx) { 158 | if (!this.lexerActions[idx].equals(other.lexerActions[idx])) { 159 | return false; 160 | } 161 | } 162 | return true; 163 | } 164 | }; 165 | 166 | exports.LexerActionExecutor = LexerActionExecutor; 167 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/atn/index.js: -------------------------------------------------------------------------------- 1 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 2 | * Use of this file is governed by the BSD 3-clause license that 3 | * can be found in the LICENSE.txt file in the project root. 4 | */ 5 | 6 | exports.ATN = require('./ATN').ATN; 7 | exports.ATNDeserializer = require('./ATNDeserializer').ATNDeserializer; 8 | exports.LexerATNSimulator = require('./LexerATNSimulator').LexerATNSimulator; 9 | exports.ParserATNSimulator = require('./ParserATNSimulator').ParserATNSimulator; 10 | exports.PredictionMode = require('./PredictionMode').PredictionMode; 11 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/dfa/DFA.js: -------------------------------------------------------------------------------- 1 | // 2 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 3 | * Use of this file is governed by the BSD 3-clause license that 4 | * can be found in the LICENSE.txt file in the project root. 5 | */ 6 | 7 | var Set = require("../Utils").Set; 8 | var DFAState = require('./DFAState').DFAState; 9 | var StarLoopEntryState = require('../atn/ATNState').StarLoopEntryState; 10 | var ATNConfigSet = require('./../atn/ATNConfigSet').ATNConfigSet; 11 | var DFASerializer = require('./DFASerializer').DFASerializer; 12 | var LexerDFASerializer = require('./DFASerializer').LexerDFASerializer; 13 | 14 | 15 | 16 | function DFA(atnStartState, decision) { 17 | if (decision === undefined) { 18 | decision = 0; 19 | } 20 | // From which ATN state did we create this DFA? 21 | this.atnStartState = atnStartState; 22 | this.decision = decision; 23 | // A set of all DFA states. Use {@link Map} so we can get old state back 24 | // ({@link Set} only allows you to see if it's there). 25 | this._states = new Set(); 26 | this.s0 = null; 27 | // {@code true} if this DFA is for a precedence decision; otherwise, 28 | // {@code false}. This is the backing field for {@link //isPrecedenceDfa}, 29 | // {@link //setPrecedenceDfa}. 30 | this.precedenceDfa = false; 31 | if (atnStartState instanceof StarLoopEntryState) 32 | { 33 | if (atnStartState.isPrecedenceDecision) { 34 | this.precedenceDfa = true; 35 | var precedenceState = new DFAState(null, new ATNConfigSet()); 36 | precedenceState.edges = []; 37 | precedenceState.isAcceptState = false; 38 | precedenceState.requiresFullContext = false; 39 | this.s0 = precedenceState; 40 | } 41 | } 42 | return this; 43 | } 44 | 45 | // Get the start state for a specific precedence value. 46 | // 47 | // @param precedence The current precedence. 48 | // @return The start state corresponding to the specified precedence, or 49 | // {@code null} if no start state exists for the specified precedence. 50 | // 51 | // @throws IllegalStateException if this is not a precedence DFA. 52 | // @see //isPrecedenceDfa() 53 | 54 | DFA.prototype.getPrecedenceStartState = function(precedence) { 55 | if (!(this.precedenceDfa)) { 56 | throw ("Only precedence DFAs may contain a precedence start state."); 57 | } 58 | // s0.edges is never null for a precedence DFA 59 | if (precedence < 0 || precedence >= this.s0.edges.length) { 60 | return null; 61 | } 62 | return this.s0.edges[precedence] || null; 63 | }; 64 | 65 | // Set the start state for a specific precedence value. 66 | // 67 | // @param precedence The current precedence. 68 | // @param startState The start state corresponding to the specified 69 | // precedence. 70 | // 71 | // @throws IllegalStateException if this is not a precedence DFA. 72 | // @see //isPrecedenceDfa() 73 | // 74 | DFA.prototype.setPrecedenceStartState = function(precedence, startState) { 75 | if (!(this.precedenceDfa)) { 76 | throw ("Only precedence DFAs may contain a precedence start state."); 77 | } 78 | if (precedence < 0) { 79 | return; 80 | } 81 | 82 | // synchronization on s0 here is ok. when the DFA is turned into a 83 | // precedence DFA, s0 will be initialized once and not updated again 84 | // s0.edges is never null for a precedence DFA 85 | this.s0.edges[precedence] = startState; 86 | }; 87 | 88 | // 89 | // Sets whether this is a precedence DFA. If the specified value differs 90 | // from the current DFA configuration, the following actions are taken; 91 | // otherwise no changes are made to the current DFA. 92 | // 93 | //-
94 | //
- The {@link //states} map is cleared 95 | //
- If {@code precedenceDfa} is {@code false}, the initial state 96 | // {@link //s0} is set to {@code null}; otherwise, it is initialized to a new 97 | // {@link DFAState} with an empty outgoing {@link DFAState//edges} array to 98 | // store the start states for individual precedence values. 99 | //
- The {@link //precedenceDfa} field is updated 100 | //
I use a set of ATNConfig objects not simple states. An ATNConfig 42 | // is both a state (ala normal conversion) and a RuleContext describing 43 | // the chain of rules (if any) followed to arrive at that state.
44 | // 45 | //A DFA state may have multiple references to a particular state, 46 | // but with different ATN contexts (with same or different alts) 47 | // meaning that state was reached via a different set of rule invocations.
48 | // / 49 | 50 | function DFAState(stateNumber, configs) { 51 | if (stateNumber === null) { 52 | stateNumber = -1; 53 | } 54 | if (configs === null) { 55 | configs = new ATNConfigSet(); 56 | } 57 | this.stateNumber = stateNumber; 58 | this.configs = configs; 59 | // {@code edges[symbol]} points to target of symbol. Shift up by 1 so (-1) 60 | // {@link Token//EOF} maps to {@code edges[0]}. 61 | this.edges = null; 62 | this.isAcceptState = false; 63 | // if accept state, what ttype do we match or alt do we predict? 64 | // This is set to {@link ATN//INVALID_ALT_NUMBER} when {@link 65 | // //predicates}{@code !=null} or 66 | // {@link //requiresFullContext}. 67 | this.prediction = 0; 68 | this.lexerActionExecutor = null; 69 | // Indicates that this state was created during SLL prediction that 70 | // discovered a conflict between the configurations in the state. Future 71 | // {@link ParserATNSimulator//execATN} invocations immediately jumped doing 72 | // full context prediction if this field is true. 73 | this.requiresFullContext = false; 74 | // During SLL parsing, this is a list of predicates associated with the 75 | // ATN configurations of the DFA state. When we have predicates, 76 | // {@link //requiresFullContext} is {@code false} since full context 77 | // prediction evaluates predicates 78 | // on-the-fly. If this is not null, then {@link //prediction} is 79 | // {@link ATN//INVALID_ALT_NUMBER}. 80 | // 81 | //We only use these for non-{@link //requiresFullContext} but 82 | // conflicting states. That 83 | // means we know from the context (it's $ or we don't dip into outer 84 | // context) that it's an ambiguity not a conflict.
85 | // 86 | //This list is computed by {@link 87 | // ParserATNSimulator//predicateDFAState}.
88 | this.predicates = null; 89 | return this; 90 | } 91 | 92 | // Get the set of all alts mentioned by all ATN configurations in this 93 | // DFA state. 94 | DFAState.prototype.getAltSet = function() { 95 | var alts = new Set(); 96 | if (this.configs !== null) { 97 | for (var i = 0; i < this.configs.length; i++) { 98 | var c = this.configs[i]; 99 | alts.add(c.alt); 100 | } 101 | } 102 | if (alts.length === 0) { 103 | return null; 104 | } else { 105 | return alts; 106 | } 107 | }; 108 | 109 | // Two {@link DFAState} instances are equal if their ATN configuration sets 110 | // are the same. This method is used to see if a state already exists. 111 | // 112 | //Because the number of alternatives and number of ATN configurations are 113 | // finite, there is a finite number of DFA states that can be processed. 114 | // This is necessary to show that the algorithm terminates.
115 | // 116 | //Cannot test the DFA state numbers here because in 117 | // {@link ParserATNSimulator//addDFAState} we need to know if any other state 118 | // exists that has this exact set of ATN configurations. The 119 | // {@link //stateNumber} is irrelevant.
120 | DFAState.prototype.equals = function(other) { 121 | // compare set of ATN configurations in this set with other 122 | return this === other || 123 | (other instanceof DFAState && 124 | this.configs.equals(other.configs)); 125 | }; 126 | 127 | DFAState.prototype.toString = function() { 128 | var s = "" + this.stateNumber + ":" + this.configs; 129 | if(this.isAcceptState) { 130 | s = s + "=>"; 131 | if (this.predicates !== null) 132 | s = s + this.predicates; 133 | else 134 | s = s + this.prediction; 135 | } 136 | return s; 137 | }; 138 | 139 | DFAState.prototype.hashCode = function() { 140 | var hash = new Hash(); 141 | hash.update(this.configs); 142 | if(this.isAcceptState) { 143 | if (this.predicates !== null) 144 | hash.update(this.predicates); 145 | else 146 | hash.update(this.prediction); 147 | } 148 | return hash.finish(); 149 | }; 150 | 151 | exports.DFAState = DFAState; 152 | exports.PredPrediction = PredPrediction; 153 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/dfa/index.js: -------------------------------------------------------------------------------- 1 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 2 | * Use of this file is governed by the BSD 3-clause license that 3 | * can be found in the LICENSE.txt file in the project root. 4 | */ 5 | 6 | exports.DFA = require('./DFA').DFA; 7 | exports.DFASerializer = require('./DFASerializer').DFASerializer; 8 | exports.LexerDFASerializer = require('./DFASerializer').LexerDFASerializer; 9 | exports.PredPrediction = require('./DFAState').PredPrediction; 10 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/error/DiagnosticErrorListener.js: -------------------------------------------------------------------------------- 1 | // 2 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 3 | * Use of this file is governed by the BSD 3-clause license that 4 | * can be found in the LICENSE.txt file in the project root. 5 | */ 6 | // 7 | 8 | // 9 | // This implementation of {@link ANTLRErrorListener} can be used to identify 10 | // certain potential correctness and performance problems in grammars. "Reports" 11 | // are made by calling {@link Parser//notifyErrorListeners} with the appropriate 12 | // message. 13 | // 14 | //-
15 | //
- Ambiguities: These are cases where more than one path through the 16 | // grammar can match the input. 17 | //
- Weak context sensitivity: These are cases where full-context 18 | // prediction resolved an SLL conflict to a unique alternative which equaled the 19 | // minimum alternative of the SLL conflict. 20 | //
- Strong (forced) context sensitivity: These are cases where the 21 | // full-context prediction resolved an SLL conflict to a unique alternative, 22 | // and the minimum alternative of the SLL conflict was found to not be 23 | // a truly viable alternative. Two-stage parsing cannot be used for inputs where 24 | // this situation occurs. 25 | //
44 | // This implementation prints messages to {@link System//err} containing the 45 | // values of {@code line}, {@code charPositionInLine}, and {@code msg} using 46 | // the following format.
47 | // 48 | //49 | // line line:charPositionInLine msg 50 | //51 | // 52 | ConsoleErrorListener.prototype.syntaxError = function(recognizer, offendingSymbol, line, column, msg, e) { 53 | console.error("line " + line + ":" + column + " " + msg); 54 | }; 55 | 56 | function ProxyErrorListener(delegates) { 57 | ErrorListener.call(this); 58 | if (delegates===null) { 59 | throw "delegates"; 60 | } 61 | this.delegates = delegates; 62 | return this; 63 | } 64 | 65 | ProxyErrorListener.prototype = Object.create(ErrorListener.prototype); 66 | ProxyErrorListener.prototype.constructor = ProxyErrorListener; 67 | 68 | ProxyErrorListener.prototype.syntaxError = function(recognizer, offendingSymbol, line, column, msg, e) { 69 | this.delegates.map(function(d) { d.syntaxError(recognizer, offendingSymbol, line, column, msg, e); }); 70 | }; 71 | 72 | ProxyErrorListener.prototype.reportAmbiguity = function(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) { 73 | this.delegates.map(function(d) { d.reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs); }); 74 | }; 75 | 76 | ProxyErrorListener.prototype.reportAttemptingFullContext = function(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) { 77 | this.delegates.map(function(d) { d.reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs); }); 78 | }; 79 | 80 | ProxyErrorListener.prototype.reportContextSensitivity = function(recognizer, dfa, startIndex, stopIndex, prediction, configs) { 81 | this.delegates.map(function(d) { d.reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs); }); 82 | }; 83 | 84 | exports.ErrorListener = ErrorListener; 85 | exports.ConsoleErrorListener = ConsoleErrorListener; 86 | exports.ProxyErrorListener = ProxyErrorListener; 87 | 88 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/error/Errors.js: -------------------------------------------------------------------------------- 1 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 2 | * Use of this file is governed by the BSD 3-clause license that 3 | * can be found in the LICENSE.txt file in the project root. 4 | */ 5 | 6 | // The root of the ANTLR exception hierarchy. In general, ANTLR tracks just 7 | // 3 kinds of errors: prediction errors, failed predicate errors, and 8 | // mismatched input errors. In each case, the parser knows where it is 9 | // in the input, where it is in the ATN, the rule invocation stack, 10 | // and what kind of problem occurred. 11 | 12 | var PredicateTransition = require('./../atn/Transition').PredicateTransition; 13 | 14 | function RecognitionException(params) { 15 | Error.call(this); 16 | if (!!Error.captureStackTrace) { 17 | Error.captureStackTrace(this, RecognitionException); 18 | } else { 19 | var stack = new Error().stack; 20 | } 21 | this.message = params.message; 22 | this.recognizer = params.recognizer; 23 | this.input = params.input; 24 | this.ctx = params.ctx; 25 | // The current {@link Token} when an error occurred. Since not all streams 26 | // support accessing symbols by index, we have to track the {@link Token} 27 | // instance itself. 28 | this.offendingToken = null; 29 | // Get the ATN state number the parser was in at the time the error 30 | // occurred. For {@link NoViableAltException} and 31 | // {@link LexerNoViableAltException} exceptions, this is the 32 | // {@link DecisionState} number. For others, it is the state whose outgoing 33 | // edge we couldn't match. 34 | this.offendingState = -1; 35 | if (this.recognizer!==null) { 36 | this.offendingState = this.recognizer.state; 37 | } 38 | return this; 39 | } 40 | 41 | RecognitionException.prototype = Object.create(Error.prototype); 42 | RecognitionException.prototype.constructor = RecognitionException; 43 | 44 | //
If the state number is not known, this method returns -1.
45 | 46 | // 47 | // Gets the set of input symbols which could potentially follow the 48 | // previously matched symbol at the time this exception was thrown. 49 | // 50 | //If the set of expected tokens is not known and could not be computed, 51 | // this method returns {@code null}.
52 | // 53 | // @return The set of token types that could potentially follow the current 54 | // state in the ATN, or {@code null} if the information is not available. 55 | // / 56 | RecognitionException.prototype.getExpectedTokens = function() { 57 | if (this.recognizer!==null) { 58 | return this.recognizer.atn.getExpectedTokens(this.offendingState, this.ctx); 59 | } else { 60 | return null; 61 | } 62 | }; 63 | 64 | RecognitionException.prototype.toString = function() { 65 | return this.message; 66 | }; 67 | 68 | function LexerNoViableAltException(lexer, input, startIndex, deadEndConfigs) { 69 | RecognitionException.call(this, {message:"", recognizer:lexer, input:input, ctx:null}); 70 | this.startIndex = startIndex; 71 | this.deadEndConfigs = deadEndConfigs; 72 | return this; 73 | } 74 | 75 | LexerNoViableAltException.prototype = Object.create(RecognitionException.prototype); 76 | LexerNoViableAltException.prototype.constructor = LexerNoViableAltException; 77 | 78 | LexerNoViableAltException.prototype.toString = function() { 79 | var symbol = ""; 80 | if (this.startIndex >= 0 && this.startIndex < this.input.size) { 81 | symbol = this.input.getText((this.startIndex,this.startIndex)); 82 | } 83 | return "LexerNoViableAltException" + symbol; 84 | }; 85 | 86 | // Indicates that the parser could not decide which of two or more paths 87 | // to take based upon the remaining input. It tracks the starting token 88 | // of the offending input and also knows where the parser was 89 | // in the various paths when the error. Reported by reportNoViableAlternative() 90 | // 91 | function NoViableAltException(recognizer, input, startToken, offendingToken, deadEndConfigs, ctx) { 92 | ctx = ctx || recognizer._ctx; 93 | offendingToken = offendingToken || recognizer.getCurrentToken(); 94 | startToken = startToken || recognizer.getCurrentToken(); 95 | input = input || recognizer.getInputStream(); 96 | RecognitionException.call(this, {message:"", recognizer:recognizer, input:input, ctx:ctx}); 97 | // Which configurations did we try at input.index() that couldn't match 98 | // input.LT(1)?// 99 | this.deadEndConfigs = deadEndConfigs; 100 | // The token object at the start index; the input stream might 101 | // not be buffering tokens so get a reference to it. (At the 102 | // time the error occurred, of course the stream needs to keep a 103 | // buffer all of the tokens but later we might not have access to those.) 104 | this.startToken = startToken; 105 | this.offendingToken = offendingToken; 106 | } 107 | 108 | NoViableAltException.prototype = Object.create(RecognitionException.prototype); 109 | NoViableAltException.prototype.constructor = NoViableAltException; 110 | 111 | // This signifies any kind of mismatched input exceptions such as 112 | // when the current input does not match the expected token. 113 | // 114 | function InputMismatchException(recognizer) { 115 | RecognitionException.call(this, {message:"", recognizer:recognizer, input:recognizer.getInputStream(), ctx:recognizer._ctx}); 116 | this.offendingToken = recognizer.getCurrentToken(); 117 | } 118 | 119 | InputMismatchException.prototype = Object.create(RecognitionException.prototype); 120 | InputMismatchException.prototype.constructor = InputMismatchException; 121 | 122 | // A semantic predicate failed during validation. Validation of predicates 123 | // occurs when normally parsing the alternative just like matching a token. 124 | // Disambiguating predicate evaluation occurs when we test a predicate during 125 | // prediction. 126 | 127 | function FailedPredicateException(recognizer, predicate, message) { 128 | RecognitionException.call(this, {message:this.formatMessage(predicate,message || null), recognizer:recognizer, 129 | input:recognizer.getInputStream(), ctx:recognizer._ctx}); 130 | var s = recognizer._interp.atn.states[recognizer.state]; 131 | var trans = s.transitions[0]; 132 | if (trans instanceof PredicateTransition) { 133 | this.ruleIndex = trans.ruleIndex; 134 | this.predicateIndex = trans.predIndex; 135 | } else { 136 | this.ruleIndex = 0; 137 | this.predicateIndex = 0; 138 | } 139 | this.predicate = predicate; 140 | this.offendingToken = recognizer.getCurrentToken(); 141 | return this; 142 | } 143 | 144 | FailedPredicateException.prototype = Object.create(RecognitionException.prototype); 145 | FailedPredicateException.prototype.constructor = FailedPredicateException; 146 | 147 | FailedPredicateException.prototype.formatMessage = function(predicate, message) { 148 | if (message !==null) { 149 | return message; 150 | } else { 151 | return "failed predicate: {" + predicate + "}?"; 152 | } 153 | }; 154 | 155 | function ParseCancellationException() { 156 | Error.call(this); 157 | Error.captureStackTrace(this, ParseCancellationException); 158 | return this; 159 | } 160 | 161 | ParseCancellationException.prototype = Object.create(Error.prototype); 162 | ParseCancellationException.prototype.constructor = ParseCancellationException; 163 | 164 | exports.RecognitionException = RecognitionException; 165 | exports.NoViableAltException = NoViableAltException; 166 | exports.LexerNoViableAltException = LexerNoViableAltException; 167 | exports.InputMismatchException = InputMismatchException; 168 | exports.FailedPredicateException = FailedPredicateException; 169 | exports.ParseCancellationException = ParseCancellationException; 170 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/error/index.js: -------------------------------------------------------------------------------- 1 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 2 | * Use of this file is governed by the BSD 3-clause license that 3 | * can be found in the LICENSE.txt file in the project root. 4 | */ 5 | 6 | exports.RecognitionException = require('./Errors').RecognitionException; 7 | exports.NoViableAltException = require('./Errors').NoViableAltException; 8 | exports.LexerNoViableAltException = require('./Errors').LexerNoViableAltException; 9 | exports.InputMismatchException = require('./Errors').InputMismatchException; 10 | exports.FailedPredicateException = require('./Errors').FailedPredicateException; 11 | exports.DiagnosticErrorListener = require('./DiagnosticErrorListener').DiagnosticErrorListener; 12 | exports.BailErrorStrategy = require('./ErrorStrategy').BailErrorStrategy; 13 | exports.ErrorListener = require('./ErrorListener').ErrorListener; 14 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/index.js: -------------------------------------------------------------------------------- 1 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 2 | * Use of this file is governed by the BSD 3-clause license that 3 | * can be found in the LICENSE.txt file in the project root. 4 | */ 5 | exports.atn = require('./atn/index'); 6 | exports.codepointat = require('./polyfills/codepointat'); 7 | exports.dfa = require('./dfa/index'); 8 | exports.fromcodepoint = require('./polyfills/fromcodepoint'); 9 | exports.tree = require('./tree/index'); 10 | exports.error = require('./error/index'); 11 | exports.Token = require('./Token').Token; 12 | exports.CharStreams = require('./CharStreams').CharStreams; 13 | exports.CommonToken = require('./Token').CommonToken; 14 | exports.InputStream = require('./InputStream').InputStream; 15 | exports.FileStream = require('./FileStream').FileStream; 16 | exports.CommonTokenStream = require('./CommonTokenStream').CommonTokenStream; 17 | exports.Lexer = require('./Lexer').Lexer; 18 | exports.Parser = require('./Parser').Parser; 19 | var pc = require('./PredictionContext'); 20 | exports.PredictionContextCache = pc.PredictionContextCache; 21 | exports.ParserRuleContext = require('./ParserRuleContext').ParserRuleContext; 22 | exports.Interval = require('./IntervalSet').Interval; 23 | exports.Utils = require('./Utils'); 24 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "antlr4", 3 | "version": "4.7.0", 4 | "description": "JavaScript runtime for ANTLR4", 5 | "main": "src/antlr4/index.js", 6 | "repository": "antlr/antlr4.git", 7 | "keywords": [ 8 | "lexer", 9 | "parser", 10 | "antlr", 11 | "antlr4", 12 | "grammar" 13 | ], 14 | "license": "BSD", 15 | "bugs": { 16 | "url": "https://github.com/antlr/antlr4/issues" 17 | }, 18 | "homepage": "https://github.com/antlr/antlr4" 19 | } 20 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/polyfills/codepointat.js: -------------------------------------------------------------------------------- 1 | /*! https://mths.be/codepointat v0.2.0 by @mathias */ 2 | if (!String.prototype.codePointAt) { 3 | (function() { 4 | 'use strict'; // needed to support `apply`/`call` with `undefined`/`null` 5 | var defineProperty = (function() { 6 | // IE 8 only supports `Object.defineProperty` on DOM elements 7 | try { 8 | var object = {}; 9 | var $defineProperty = Object.defineProperty; 10 | var result = $defineProperty(object, object, object) && $defineProperty; 11 | } catch(error) {} 12 | return result; 13 | }()); 14 | var codePointAt = function(position) { 15 | if (this == null) { 16 | throw TypeError(); 17 | } 18 | var string = String(this); 19 | var size = string.length; 20 | // `ToInteger` 21 | var index = position ? Number(position) : 0; 22 | if (index != index) { // better `isNaN` 23 | index = 0; 24 | } 25 | // Account for out-of-bounds indices: 26 | if (index < 0 || index >= size) { 27 | return undefined; 28 | } 29 | // Get the first code unit 30 | var first = string.charCodeAt(index); 31 | var second; 32 | if ( // check if it’s the start of a surrogate pair 33 | first >= 0xD800 && first <= 0xDBFF && // high surrogate 34 | size > index + 1 // there is a next code unit 35 | ) { 36 | second = string.charCodeAt(index + 1); 37 | if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate 38 | // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae 39 | return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; 40 | } 41 | } 42 | return first; 43 | }; 44 | if (defineProperty) { 45 | defineProperty(String.prototype, 'codePointAt', { 46 | 'value': codePointAt, 47 | 'configurable': true, 48 | 'writable': true 49 | }); 50 | } else { 51 | String.prototype.codePointAt = codePointAt; 52 | } 53 | }()); 54 | } 55 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/polyfills/fromcodepoint.js: -------------------------------------------------------------------------------- 1 | /*! https://mths.be/fromcodepoint v0.2.1 by @mathias */ 2 | if (!String.fromCodePoint) { 3 | (function() { 4 | var defineProperty = (function() { 5 | // IE 8 only supports `Object.defineProperty` on DOM elements 6 | try { 7 | var object = {}; 8 | var $defineProperty = Object.defineProperty; 9 | var result = $defineProperty(object, object, object) && $defineProperty; 10 | } catch(error) {} 11 | return result; 12 | }()); 13 | var stringFromCharCode = String.fromCharCode; 14 | var floor = Math.floor; 15 | var fromCodePoint = function(_) { 16 | var MAX_SIZE = 0x4000; 17 | var codeUnits = []; 18 | var highSurrogate; 19 | var lowSurrogate; 20 | var index = -1; 21 | var length = arguments.length; 22 | if (!length) { 23 | return ''; 24 | } 25 | var result = ''; 26 | while (++index < length) { 27 | var codePoint = Number(arguments[index]); 28 | if ( 29 | !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity` 30 | codePoint < 0 || // not a valid Unicode code point 31 | codePoint > 0x10FFFF || // not a valid Unicode code point 32 | floor(codePoint) != codePoint // not an integer 33 | ) { 34 | throw RangeError('Invalid code point: ' + codePoint); 35 | } 36 | if (codePoint <= 0xFFFF) { // BMP code point 37 | codeUnits.push(codePoint); 38 | } else { // Astral code point; split in surrogate halves 39 | // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae 40 | codePoint -= 0x10000; 41 | highSurrogate = (codePoint >> 10) + 0xD800; 42 | lowSurrogate = (codePoint % 0x400) + 0xDC00; 43 | codeUnits.push(highSurrogate, lowSurrogate); 44 | } 45 | if (index + 1 == length || codeUnits.length > MAX_SIZE) { 46 | result += stringFromCharCode.apply(null, codeUnits); 47 | codeUnits.length = 0; 48 | } 49 | } 50 | return result; 51 | }; 52 | if (defineProperty) { 53 | defineProperty(String, 'fromCodePoint', { 54 | 'value': fromCodePoint, 55 | 'configurable': true, 56 | 'writable': true 57 | }); 58 | } else { 59 | String.fromCodePoint = fromCodePoint; 60 | } 61 | }()); 62 | } 63 | -------------------------------------------------------------------------------- /packages/sooho-parser/src/antlr4/tree/Tree.js: -------------------------------------------------------------------------------- 1 | /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. 2 | * Use of this file is governed by the BSD 3-clause license that 3 | * can be found in the LICENSE.txt file in the project root. 4 | */ 5 | /// 6 | 7 | // The basic notion of a tree has a parent, a payload, and a list of children. 8 | // It is the most abstract interface for all the trees used by ANTLR. 9 | /// 10 | 11 | var Token = require('./../Token').Token; 12 | var Interval = require('./../IntervalSet').Interval; 13 | var INVALID_INTERVAL = new Interval(-1, -2); 14 | var Utils = require('../Utils.js'); 15 | 16 | 17 | function Tree() { 18 | return this; 19 | } 20 | 21 | function SyntaxTree() { 22 | Tree.call(this); 23 | return this; 24 | } 25 | 26 | SyntaxTree.prototype = Object.create(Tree.prototype); 27 | SyntaxTree.prototype.constructor = SyntaxTree; 28 | 29 | function ParseTree() { 30 | SyntaxTree.call(this); 31 | return this; 32 | } 33 | 34 | ParseTree.prototype = Object.create(SyntaxTree.prototype); 35 | ParseTree.prototype.constructor = ParseTree; 36 | 37 | function RuleNode() { 38 | ParseTree.call(this); 39 | return this; 40 | } 41 | 42 | RuleNode.prototype = Object.create(ParseTree.prototype); 43 | RuleNode.prototype.constructor = RuleNode; 44 | 45 | function TerminalNode() { 46 | ParseTree.call(this); 47 | return this; 48 | } 49 | 50 | TerminalNode.prototype = Object.create(ParseTree.prototype); 51 | TerminalNode.prototype.constructor = TerminalNode; 52 | 53 | function ErrorNode() { 54 | TerminalNode.call(this); 55 | return this; 56 | } 57 | 58 | ErrorNode.prototype = Object.create(TerminalNode.prototype); 59 | ErrorNode.prototype.constructor = ErrorNode; 60 | 61 | function ParseTreeVisitor() { 62 | return this; 63 | } 64 | 65 | ParseTreeVisitor.prototype.visit = function(ctx) { 66 | if (Array.isArray(ctx)) { 67 | return ctx.map(function(child) { 68 | return child.accept(this); 69 | }, this); 70 | } else { 71 | return ctx.accept(this); 72 | } 73 | }; 74 | 75 | ParseTreeVisitor.prototype.visitChildren = function(ctx) { 76 | return this.visit(ctx.children); 77 | } 78 | 79 | ParseTreeVisitor.prototype.visitTerminal = function(node) { 80 | }; 81 | 82 | ParseTreeVisitor.prototype.visitErrorNode = function(node) { 83 | }; 84 | 85 | 86 | function ParseTreeListener() { 87 | return this; 88 | } 89 | 90 | ParseTreeListener.prototype.visitTerminal = function(node) { 91 | }; 92 | 93 | ParseTreeListener.prototype.visitErrorNode = function(node) { 94 | }; 95 | 96 | ParseTreeListener.prototype.enterEveryRule = function(node) { 97 | }; 98 | 99 | ParseTreeListener.prototype.exitEveryRule = function(node) { 100 | }; 101 | 102 | function TerminalNodeImpl(symbol) { 103 | TerminalNode.call(this); 104 | this.parentCtx = null; 105 | this.symbol = symbol; 106 | return this; 107 | } 108 | 109 | TerminalNodeImpl.prototype = Object.create(TerminalNode.prototype); 110 | TerminalNodeImpl.prototype.constructor = TerminalNodeImpl; 111 | 112 | TerminalNodeImpl.prototype.getChild = function(i) { 113 | return null; 114 | }; 115 | 116 | TerminalNodeImpl.prototype.getSymbol = function() { 117 | return this.symbol; 118 | }; 119 | 120 | TerminalNodeImpl.prototype.getParent = function() { 121 | return this.parentCtx; 122 | }; 123 | 124 | TerminalNodeImpl.prototype.getPayload = function() { 125 | return this.symbol; 126 | }; 127 | 128 | TerminalNodeImpl.prototype.getSourceInterval = function() { 129 | if (this.symbol === null) { 130 | return INVALID_INTERVAL; 131 | } 132 | var tokenIndex = this.symbol.tokenIndex; 133 | return new Interval(tokenIndex, tokenIndex); 134 | }; 135 | 136 | TerminalNodeImpl.prototype.getChildCount = function() { 137 | return 0; 138 | }; 139 | 140 | TerminalNodeImpl.prototype.accept = function(visitor) { 141 | return visitor.visitTerminal(this); 142 | }; 143 | 144 | TerminalNodeImpl.prototype.getText = function() { 145 | return this.symbol.text; 146 | }; 147 | 148 | TerminalNodeImpl.prototype.toString = function() { 149 | if (this.symbol.type === Token.EOF) { 150 | return "