antlr4ng
Version:
Alternative JavaScript/TypeScript runtime for ANTLR4
244 lines (238 loc) • 6.83 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/atn/ArrayPredictionContext.ts
var ArrayPredictionContext_exports = {};
__export(ArrayPredictionContext_exports, {
ArrayPredictionContext: () => ArrayPredictionContext
});
module.exports = __toCommonJS(ArrayPredictionContext_exports);
// src/utils/MurmurHash.ts
var c1 = 3432918353;
var c2 = 461845907;
var r1 = 15;
var r2 = 13;
var m = 5;
var n = 3864292196;
var MurmurHash = class _MurmurHash {
static {
__name(this, "MurmurHash");
}
static defaultSeed = 701;
constructor() {
}
/**
* Initialize the hash using the specified {@code seed}.
*
* @param seed the seed
*
* @returns the intermediate hash value
*/
static initialize(seed = _MurmurHash.defaultSeed) {
return seed;
}
static updateFromComparable(hash, value) {
return this.update(hash, value?.hashCode() ?? 0);
}
/**
* Update the intermediate hash value for the next input {@code value}.
*
* @param hash The intermediate hash value.
* @param value the value to add to the current hash.
*
* @returns the updated intermediate hash value
*/
static update(hash, value) {
value = Math.imul(value, c1);
value = value << r1 | value >>> 32 - r1;
value = Math.imul(value, c2);
hash = hash ^ value;
hash = hash << r2 | hash >>> 32 - r2;
hash = Math.imul(hash, m) + n;
return hash;
}
/**
* Apply the final computation steps to the intermediate value {@code hash}
* to form the final result of the MurmurHash 3 hash function.
*
* @param hash The intermediate hash value.
* @param entryCount The number of values added to the hash.
*
* @returns the final hash result
*/
static finish(hash, entryCount) {
hash ^= entryCount * 4;
hash ^= hash >>> 16;
hash = Math.imul(hash, 2246822507);
hash ^= hash >>> 13;
hash = Math.imul(hash, 3266489909);
hash ^= hash >>> 16;
return hash;
}
/**
* An all-in-one convenience method to compute a hash for a single value.
*
* @param value The value to hash.
* @param seed The seed for the hash value.
*
* @returns The computed hash.
*/
static hashCode(value, seed) {
return _MurmurHash.finish(_MurmurHash.update(seed ?? _MurmurHash.defaultSeed, value), 1);
}
};
// src/atn/PredictionContext.ts
var PredictionContext = class _PredictionContext {
static {
__name(this, "PredictionContext");
}
/**
* Represents `$` in an array in full context mode, when `$`
* doesn't mean wildcard: `$ + x = [$,x]`. Here,
* `$` = {@link EMPTY_RETURN_STATE}.
*/
static EMPTY_RETURN_STATE = 2147483647;
static traceATNSimulator = false;
cachedHashCode;
constructor(cachedHashCode) {
this.cachedHashCode = cachedHashCode;
}
static calculateEmptyHashCode() {
let hash = MurmurHash.initialize(31);
hash = MurmurHash.finish(hash, 0);
return hash;
}
static calculateHashCodeSingle(parent, returnState) {
let hash = MurmurHash.initialize(31);
hash = MurmurHash.updateFromComparable(hash, parent);
hash = MurmurHash.update(hash, returnState);
hash = MurmurHash.finish(hash, 2);
return hash;
}
static calculateHashCodeList(parents, returnStates) {
let hash = MurmurHash.initialize(31);
for (const parent of parents) {
hash = MurmurHash.updateFromComparable(hash, parent);
}
for (const returnState of returnStates) {
hash = MurmurHash.update(hash, returnState);
}
hash = MurmurHash.finish(hash, 2 * parents.length);
return hash;
}
isEmpty() {
return false;
}
hasEmptyPath() {
return this.getReturnState(this.length - 1) === _PredictionContext.EMPTY_RETURN_STATE;
}
hashCode() {
return this.cachedHashCode;
}
toString(_recog) {
return "";
}
};
// src/utils/helpers.ts
var equalArrays = /* @__PURE__ */ __name((a, b) => {
if (a === b) {
return true;
}
if (a.length !== b.length) {
return false;
}
for (let i = 0; i < a.length; i++) {
const left = a[i];
const right = b[i];
if (left === right) {
continue;
}
if (!left || !left.equals(right)) {
return false;
}
}
return true;
}, "equalArrays");
var equalNumberArrays = /* @__PURE__ */ __name((a, b) => {
if (a === b) {
return true;
}
if (a.length !== b.length) {
return false;
}
for (let i = 0; i < a.length; i++) {
if (a[i] !== b[i]) {
return false;
}
}
return true;
}, "equalNumberArrays");
// src/atn/ArrayPredictionContext.ts
var ArrayPredictionContext = class _ArrayPredictionContext extends PredictionContext {
static {
__name(this, "ArrayPredictionContext");
}
parents = [];
returnStates = [];
constructor(parents, returnStates) {
super(PredictionContext.calculateHashCodeList(parents, returnStates));
this.parents = parents;
this.returnStates = returnStates;
return this;
}
isEmpty() {
return this.returnStates[0] === PredictionContext.EMPTY_RETURN_STATE;
}
get length() {
return this.returnStates.length;
}
getParent(index) {
return this.parents[index];
}
getReturnState(index) {
return this.returnStates[index];
}
equals(other) {
if (this === other) {
return true;
}
if (!(other instanceof _ArrayPredictionContext) || this.hashCode() !== other.hashCode()) {
return false;
}
return equalNumberArrays(this.returnStates, other.returnStates) && equalArrays(this.parents, other.parents);
}
toString() {
if (this.isEmpty()) {
return "[]";
}
const entries = [];
for (let i = 0; i < this.returnStates.length; i++) {
if (this.returnStates[i] === PredictionContext.EMPTY_RETURN_STATE) {
entries.push("$");
continue;
}
entries.push(this.returnStates[i].toString());
if (this.parents[i]) {
entries.push(this.parents[i].toString());
} else {
entries.push("null");
}
}
return `[${entries.join(", ")}]`;
}
};