add hw2

node_modules/chevrotain-allstar/lib/atn.js

@@ -0,0 +1,404 @@
+/******************************************************************************
+ * Copyright 2022 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+import map from "lodash-es/map.js";
+import filter from "lodash-es/filter.js";
+import { Alternation, NonTerminal, Option, RepetitionMandatory, Repetition, Terminal, RepetitionWithSeparator, RepetitionMandatoryWithSeparator } from "chevrotain";
+export function buildATNKey(rule, type, occurrence) {
+    return `${rule.name}_${type}_${occurrence}`;
+}
+export const ATN_INVALID_TYPE = 0;
+export const ATN_BASIC = 1;
+export const ATN_RULE_START = 2;
+export const ATN_PLUS_BLOCK_START = 4;
+export const ATN_STAR_BLOCK_START = 5;
+// Currently unused as the ATN is not used for lexing
+export const ATN_TOKEN_START = 6;
+export const ATN_RULE_STOP = 7;
+export const ATN_BLOCK_END = 8;
+export const ATN_STAR_LOOP_BACK = 9;
+export const ATN_STAR_LOOP_ENTRY = 10;
+export const ATN_PLUS_LOOP_BACK = 11;
+export const ATN_LOOP_END = 12;
+export class AbstractTransition {
+    constructor(target) {
+        this.target = target;
+    }
+    isEpsilon() {
+        return false;
+    }
+}
+export class AtomTransition extends AbstractTransition {
+    constructor(target, tokenType) {
+        super(target);
+        this.tokenType = tokenType;
+    }
+}
+export class EpsilonTransition extends AbstractTransition {
+    constructor(target) {
+        super(target);
+    }
+    isEpsilon() {
+        return true;
+    }
+}
+export class RuleTransition extends AbstractTransition {
+    constructor(ruleStart, rule, followState) {
+        super(ruleStart);
+        this.rule = rule;
+        this.followState = followState;
+    }
+    isEpsilon() {
+        return true;
+    }
+}
+export function createATN(rules) {
+    const atn = {
+        decisionMap: {},
+        decisionStates: [],
+        ruleToStartState: new Map(),
+        ruleToStopState: new Map(),
+        states: []
+    };
+    createRuleStartAndStopATNStates(atn, rules);
+    const ruleLength = rules.length;
+    for (let i = 0; i < ruleLength; i++) {
+        const rule = rules[i];
+        const ruleBlock = block(atn, rule, rule);
+        if (ruleBlock === undefined) {
+            continue;
+        }
+        buildRuleHandle(atn, rule, ruleBlock);
+    }
+    return atn;
+}
+function createRuleStartAndStopATNStates(atn, rules) {
+    const ruleLength = rules.length;
+    for (let i = 0; i < ruleLength; i++) {
+        const rule = rules[i];
+        const start = newState(atn, rule, undefined, {
+            type: ATN_RULE_START
+        });
+        const stop = newState(atn, rule, undefined, {
+            type: ATN_RULE_STOP
+        });
+        start.stop = stop;
+        atn.ruleToStartState.set(rule, start);
+        atn.ruleToStopState.set(rule, stop);
+    }
+}
+function atom(atn, rule, production) {
+    if (production instanceof Terminal) {
+        return tokenRef(atn, rule, production.terminalType, production);
+    }
+    else if (production instanceof NonTerminal) {
+        return ruleRef(atn, rule, production);
+    }
+    else if (production instanceof Alternation) {
+        return alternation(atn, rule, production);
+    }
+    else if (production instanceof Option) {
+        return option(atn, rule, production);
+    }
+    else if (production instanceof Repetition) {
+        return repetition(atn, rule, production);
+    }
+    else if (production instanceof RepetitionWithSeparator) {
+        return repetitionSep(atn, rule, production);
+    }
+    else if (production instanceof RepetitionMandatory) {
+        return repetitionMandatory(atn, rule, production);
+    }
+    else if (production instanceof RepetitionMandatoryWithSeparator) {
+        return repetitionMandatorySep(atn, rule, production);
+    }
+    else {
+        return block(atn, rule, production);
+    }
+}
+function repetition(atn, rule, repetition) {
+    const starState = newState(atn, rule, repetition, {
+        type: ATN_STAR_BLOCK_START
+    });
+    defineDecisionState(atn, starState);
+    const handle = makeAlts(atn, rule, starState, repetition, block(atn, rule, repetition));
+    return star(atn, rule, repetition, handle);
+}
+function repetitionSep(atn, rule, repetition) {
+    const starState = newState(atn, rule, repetition, {
+        type: ATN_STAR_BLOCK_START
+    });
+    defineDecisionState(atn, starState);
+    const handle = makeAlts(atn, rule, starState, repetition, block(atn, rule, repetition));
+    const sep = tokenRef(atn, rule, repetition.separator, repetition);
+    return star(atn, rule, repetition, handle, sep);
+}
+function repetitionMandatory(atn, rule, repetition) {
+    const plusState = newState(atn, rule, repetition, {
+        type: ATN_PLUS_BLOCK_START
+    });
+    defineDecisionState(atn, plusState);
+    const handle = makeAlts(atn, rule, plusState, repetition, block(atn, rule, repetition));
+    return plus(atn, rule, repetition, handle);
+}
+function repetitionMandatorySep(atn, rule, repetition) {
+    const plusState = newState(atn, rule, repetition, {
+        type: ATN_PLUS_BLOCK_START
+    });
+    defineDecisionState(atn, plusState);
+    const handle = makeAlts(atn, rule, plusState, repetition, block(atn, rule, repetition));
+    const sep = tokenRef(atn, rule, repetition.separator, repetition);
+    return plus(atn, rule, repetition, handle, sep);
+}
+function alternation(atn, rule, alternation) {
+    const start = newState(atn, rule, alternation, {
+        type: ATN_BASIC
+    });
+    defineDecisionState(atn, start);
+    const alts = map(alternation.definition, (e) => atom(atn, rule, e));
+    const handle = makeAlts(atn, rule, start, alternation, ...alts);
+    return handle;
+}
+function option(atn, rule, option) {
+    const start = newState(atn, rule, option, {
+        type: ATN_BASIC
+    });
+    defineDecisionState(atn, start);
+    const handle = makeAlts(atn, rule, start, option, block(atn, rule, option));
+    return optional(atn, rule, option, handle);
+}
+function block(atn, rule, block) {
+    const handles = filter(map(block.definition, (e) => atom(atn, rule, e)), (e) => e !== undefined);
+    if (handles.length === 1) {
+        return handles[0];
+    }
+    else if (handles.length === 0) {
+        return undefined;
+    }
+    else {
+        return makeBlock(atn, handles);
+    }
+}
+function plus(atn, rule, plus, handle, sep) {
+    const blkStart = handle.left;
+    const blkEnd = handle.right;
+    const loop = newState(atn, rule, plus, {
+        type: ATN_PLUS_LOOP_BACK
+    });
+    defineDecisionState(atn, loop);
+    const end = newState(atn, rule, plus, {
+        type: ATN_LOOP_END
+    });
+    blkStart.loopback = loop;
+    end.loopback = loop;
+    atn.decisionMap[buildATNKey(rule, sep ? 'RepetitionMandatoryWithSeparator' : 'RepetitionMandatory', plus.idx)] = loop;
+    epsilon(blkEnd, loop); // block can see loop back
+    // Depending on whether we have a separator we put the exit transition at index 1 or 0
+    // This influences the chosen option in the lookahead DFA
+    if (sep === undefined) {
+        epsilon(loop, blkStart); // loop back to start
+        epsilon(loop, end); // exit
+    }
+    else {
+        epsilon(loop, end); // exit
+        // loop back to start with separator
+        epsilon(loop, sep.left);
+        epsilon(sep.right, blkStart);
+    }
+    return {
+        left: blkStart,
+        right: end
+    };
+}
+function star(atn, rule, star, handle, sep) {
+    const start = handle.left;
+    const end = handle.right;
+    const entry = newState(atn, rule, star, {
+        type: ATN_STAR_LOOP_ENTRY
+    });
+    defineDecisionState(atn, entry);
+    const loopEnd = newState(atn, rule, star, {
+        type: ATN_LOOP_END
+    });
+    const loop = newState(atn, rule, star, {
+        type: ATN_STAR_LOOP_BACK
+    });
+    entry.loopback = loop;
+    loopEnd.loopback = loop;
+    epsilon(entry, start); // loop enter edge (alt 2)
+    epsilon(entry, loopEnd); // bypass loop edge (alt 1)
+    epsilon(end, loop); // block end hits loop back
+    if (sep !== undefined) {
+        epsilon(loop, loopEnd); // end loop
+        // loop back to start of handle using separator
+        epsilon(loop, sep.left);
+        epsilon(sep.right, start);
+    }
+    else {
+        epsilon(loop, entry); // loop back to entry/exit decision
+    }
+    atn.decisionMap[buildATNKey(rule, sep ? 'RepetitionWithSeparator' : 'Repetition', star.idx)] = entry;
+    return {
+        left: entry,
+        right: loopEnd
+    };
+}
+function optional(atn, rule, optional, handle) {
+    const start = handle.left;
+    const end = handle.right;
+    epsilon(start, end);
+    atn.decisionMap[buildATNKey(rule, 'Option', optional.idx)] = start;
+    return handle;
+}
+function defineDecisionState(atn, state) {
+    atn.decisionStates.push(state);
+    state.decision = atn.decisionStates.length - 1;
+    return state.decision;
+}
+function makeAlts(atn, rule, start, production, ...alts) {
+    const end = newState(atn, rule, production, {
+        type: ATN_BLOCK_END,
+        start
+    });
+    start.end = end;
+    for (const alt of alts) {
+        if (alt !== undefined) {
+            // hook alts up to decision block
+            epsilon(start, alt.left);
+            epsilon(alt.right, end);
+        }
+        else {
+            epsilon(start, end);
+        }
+    }
+    const handle = {
+        left: start,
+        right: end
+    };
+    atn.decisionMap[buildATNKey(rule, getProdType(production), production.idx)] = start;
+    return handle;
+}
+function getProdType(production) {
+    if (production instanceof Alternation) {
+        return 'Alternation';
+    }
+    else if (production instanceof Option) {
+        return 'Option';
+    }
+    else if (production instanceof Repetition) {
+        return 'Repetition';
+    }
+    else if (production instanceof RepetitionWithSeparator) {
+        return 'RepetitionWithSeparator';
+    }
+    else if (production instanceof RepetitionMandatory) {
+        return 'RepetitionMandatory';
+    }
+    else if (production instanceof RepetitionMandatoryWithSeparator) {
+        return 'RepetitionMandatoryWithSeparator';
+    }
+    else {
+        throw new Error('Invalid production type encountered');
+    }
+}
+function makeBlock(atn, alts) {
+    const altsLength = alts.length;
+    for (let i = 0; i < altsLength - 1; i++) {
+        const handle = alts[i];
+        let transition;
+        if (handle.left.transitions.length === 1) {
+            transition = handle.left.transitions[0];
+        }
+        const isRuleTransition = transition instanceof RuleTransition;
+        const ruleTransition = transition;
+        const next = alts[i + 1].left;
+        if (handle.left.type === ATN_BASIC &&
+            handle.right.type === ATN_BASIC &&
+            transition !== undefined &&
+            ((isRuleTransition && ruleTransition.followState === handle.right) ||
+                transition.target === handle.right)) {
+            // we can avoid epsilon edge to next element
+            if (isRuleTransition) {
+                ruleTransition.followState = next;
+            }
+            else {
+                transition.target = next;
+            }
+            removeState(atn, handle.right); // we skipped over this state
+        }
+        else {
+            // need epsilon if previous block's right end node is complex
+            epsilon(handle.right, next);
+        }
+    }
+    const first = alts[0];
+    const last = alts[altsLength - 1];
+    return {
+        left: first.left,
+        right: last.right
+    };
+}
+function tokenRef(atn, rule, tokenType, production) {
+    const left = newState(atn, rule, production, {
+        type: ATN_BASIC
+    });
+    const right = newState(atn, rule, production, {
+        type: ATN_BASIC
+    });
+    addTransition(left, new AtomTransition(right, tokenType));
+    return {
+        left,
+        right
+    };
+}
+function ruleRef(atn, currentRule, nonTerminal) {
+    const rule = nonTerminal.referencedRule;
+    const start = atn.ruleToStartState.get(rule);
+    const left = newState(atn, currentRule, nonTerminal, {
+        type: ATN_BASIC
+    });
+    const right = newState(atn, currentRule, nonTerminal, {
+        type: ATN_BASIC
+    });
+    const call = new RuleTransition(start, rule, right);
+    addTransition(left, call);
+    return {
+        left,
+        right
+    };
+}
+function buildRuleHandle(atn, rule, block) {
+    const start = atn.ruleToStartState.get(rule);
+    epsilon(start, block.left);
+    const stop = atn.ruleToStopState.get(rule);
+    epsilon(block.right, stop);
+    const handle = {
+        left: start,
+        right: stop
+    };
+    return handle;
+}
+function epsilon(a, b) {
+    const transition = new EpsilonTransition(b);
+    addTransition(a, transition);
+}
+function newState(atn, rule, production, partial) {
+    const t = Object.assign({ atn,
+        production, epsilonOnlyTransitions: false, rule, transitions: [], nextTokenWithinRule: [], stateNumber: atn.states.length }, partial);
+    atn.states.push(t);
+    return t;
+}
+function addTransition(state, transition) {
+    // A single ATN state can only contain epsilon transitions or non-epsilon transitions
+    // Because they are never mixed, only setting the property for the first transition is fine
+    if (state.transitions.length === 0) {
+        state.epsilonOnlyTransitions = transition.isEpsilon();
+    }
+    state.transitions.push(transition);
+}
+function removeState(atn, state) {
+    atn.states.splice(atn.states.indexOf(state), 1);
+}
+//# sourceMappingURL=atn.js.map