@parser-generator/grammar-interpreter/lib/cjs/__tests__/arithmetic/lexer.js

A Parser Generator that supports LL,SLR,LR1,LALR

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const definition_1 = require("@parser-generator/definition");
var Tag;
(function (Tag) {
    Tag["EOF"] = "EOF";
    Tag["NUM"] = "NUM";
    Tag["SINGLE"] = "SINGLE";
    Tag["SPACE"] = "SPACE";
})(Tag || (Tag = {}));
class Token {
    toString() {
        return this.value().toString();
    }
}
exports.Token = Token;
let DIGIT;
class Single extends Token {
    constructor(lexeme) {
        super();
        this.lexeme = lexeme;
    }
    value() {
        return this.lexeme;
    }
    key() {
        return this.lexeme;
    }
}
exports.Single = Single;
class Num extends Token {
    constructor(lexeme) {
        super();
        this.lexeme = lexeme;
    }
    key() {
        return DIGIT;
    }
    value() {
        return this.lexeme;
    }
}
exports.Num = Num;
class ArithmeticLexer extends definition_1.AbstractRegexpLexer {
    constructor(text) {
        super(text, [
            { regexp: /(?<space>\s+)/y, type: Tag.SPACE },
            { regexp: /(?<num>(0(?![0-9]))|([1-9]\d*(?!\.)))/y, type: Tag.NUM },
            { regexp: /(?<real>([1-9]\d*\.\d+)|(0\.\d+))/y, type: Tag.NUM },
            { regexp: /(?<single>.)/y, type: Tag.SINGLE }
        ]);
    }
    createToken(lexeme, type, match) {
        switch (type) {
            case Tag.SPACE:
                return undefined; /* it means ignoring the match */
            case Tag.NUM:
                return new Num(parseFloat(lexeme));
            case Tag.SINGLE:
                return new Single(lexeme);
        }
    }
    getEOF() {
        return definition_1.EOF;
    }
}
function getLexer(text, digit) {
    DIGIT = digit;
    return new ArithmeticLexer(text);
}
exports.getLexer = getLexer;
//# sourceMappingURL=lexer.js.map