@calculemus/jaco/lib/parse.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const immutable_1 = require("immutable");
const lex_1 = require("./lex");
const nearley_1 = require("nearley");
const restrictsyntax_1 = require("./restrictsyntax");
const expressionRules = require("../lib/expression-rules");
//const statementRules = require("../lib/statement-rules");
const programRules = require("../lib/program-rules");
function parseExpression(str, options) {
    const opt = options ? options : {};
    const parser = new nearley_1.Parser(nearley_1.Grammar.fromCompiled(expressionRules));
    parser.lexer = new lex_1.TypeLexer(opt.types);
    parser.feed(str);
    const parsed = parser.finish();
    if (parsed.length > 1) {
        throw new Error("Ambiguous parse!");
    }
    else if (parsed.length === 0) {
        throw new Error("Incomplete parse");
    }
    else {
        return restrictsyntax_1.restrictExpression(opt.lang || "C1", parsed[0]);
    }
}
exports.parseExpression = parseExpression;
function parseStatement(str, options) {
    programRules.lexer = new lex_1.TypeLexer(options ? options.types : undefined);
    const parser = new nearley_1.Parser(nearley_1.Grammar.fromCompiled(programRules));
    parser.feed(str);
    return restrictsyntax_1.restrictStatement;
}
exports.parseStatement = parseStatement;
function parseProgramRaw(str) {
    const parser = new nearley_1.Parser(nearley_1.Grammar.fromCompiled(programRules));
    const lexer = (parser.lexer = new lex_1.TypeLexer());
    const segments = str.split(";");
    let decls = immutable_1.List();
    segments.forEach((segment, index) => {
        parser.feed(segment);
        const parsed = parser.finish();
        if (parsed.length > 1) {
            console.log(JSON.stringify(parsed[0]));
            console.log(JSON.stringify(parsed[parsed.length - 1]));
            throw new Error(`Parse ambiguous (${parsed.length} parses)`);
        }
        else if (parsed.length === 0) {
            if (index === segments.length - 1) {
                throw new Error("Incomplete parse at the end of the file");
            }
            else {
                //console.log(` -- continuing to parse`);
                parser.feed(";");
            }
        }
        else {
            // parsed.length === 1
            if (index === segments.length - 1) {
                //console.log(` -- end`);
                decls = decls.concat(parsed[0]);
            }
            else {
                const parsedGlobalDecls = parsed[0];
                decls = decls.concat(parsedGlobalDecls);
                const possibleTypedef = parsedGlobalDecls[parsedGlobalDecls.length - 1];
                // TODO: check that it's a typedef
                //console.log(` -- typedef ${possibleTypedef[1]}`);
                const typeIdentifier = possibleTypedef[1];
                lexer.addIdentifier(typeIdentifier);
                parser.feed(" ");
            }
        }
    });
    return decls;
}
exports.parseProgramRaw = parseProgramRaw;
function parseProgram(lang, str) {
    return parseProgramRaw(str).map(decl => {
        if (typeof decl === "string")
            return decl;
        if (decl instanceof Array)
            return decl[0];
        return restrictsyntax_1.restrictDeclaration(lang, decl);
    });
}
exports.parseProgram = parseProgram;
//# sourceMappingURL=parse.js.map