@bitloops/bl-transpiler/lib/cjs/src/Transpiler.js

The one and only Bitloops Language transpiler

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const index_js_1 = require("./ast/core/guards/index.js");
const index_js_2 = require("./parser/core/guards/index.js");
const index_js_3 = require("./target/typescript-nest/guards/index.js");
const IntermediateASTValidator_js_1 = require("./semantic-analysis/IntermediateASTValidator.js");
class Transpiler {
    parser;
    originalLanguageASTToIntermediateModelTransformer;
    intermediateASTModelToTargetLanguageGenerator;
    constructor(parser, originalLanguageASTToIntermediateModelTransformer, intermediateASTModelToTargetLanguageGenerator) {
        this.parser = parser;
        this.originalLanguageASTToIntermediateModelTransformer = originalLanguageASTToIntermediateModelTransformer;
        this.intermediateASTModelToTargetLanguageGenerator = intermediateASTModelToTargetLanguageGenerator;
    }
    transpile(transpileInputData, options) {
        const intermediateModel = this.bitloopsCodeToIntermediateModel(transpileInputData);
        if ((0, index_js_1.isOriginalParserOrIntermediateASTError)(intermediateModel)) {
            return intermediateModel;
        }
        const completedIntermediateModel = this.completeIntermediateModel(intermediateModel);
        const targetCode = this.intermediateASTModelToTargetLanguage(completedIntermediateModel, options);
        return targetCode;
    }
    bitloopsCodeToIntermediateModel(transpileInputData) {
        const originalAST = this.bitloopsCodeToOriginalAST(transpileInputData);
        if ((0, index_js_2.isParserErrors)(originalAST)) {
            return originalAST;
        }
        const intermediateModel = this.originalASTToIntermediateModel(originalAST);
        const validatedIntermediateModel = this.validateIntermediateModel(intermediateModel);
        return validatedIntermediateModel;
    }
    getSymbolTable(inputData) {
        const originalAST = this.bitloopsCodeToOriginalAST(inputData);
        if ((0, index_js_2.isParserErrors)(originalAST)) {
            return originalAST;
        }
        const ast = this.originalASTToIntermediateModel(originalAST);
        const validator = new IntermediateASTValidator_js_1.SemanticAnalyzer();
        return validator.getSymbolTable(ast);
    }
    bitloopsCodeToOriginalAST(parseInputData) {
        return this.parser.parse(parseInputData);
    }
    originalASTToIntermediateModel(originalLanguageAST) {
        return this.originalLanguageASTToIntermediateModelTransformer.parse(originalLanguageAST);
    }
    intermediateASTModelToTargetLanguage(ASTModel, options) {
        return this.intermediateASTModelToTargetLanguageGenerator.generate(ASTModel, options);
    }
    validateIntermediateModel(intermediateModel) {
        const validator = new IntermediateASTValidator_js_1.SemanticAnalyzer();
        const validationResult = validator.validate(intermediateModel);
        if ((0, index_js_1.isIntermediateASTValidationErrors)(validationResult)) {
            return validationResult;
        }
        return intermediateModel;
    }
    completeIntermediateModel(intermediateModel) {
        return this.originalLanguageASTToIntermediateModelTransformer.complete(intermediateModel);
    }
    // TODO: remove duplication of transpile errors
    static isTranspileError(value) {
        if (!(0, index_js_2.isParserErrors)(value) &&
            !(0, index_js_1.isIntermediateASTValidationErrors)(value) &&
            !(0, index_js_3.isTargetGeneratorError)(value)) {
            return false;
        }
        return true;
    }
    static isTranspilerError(value) {
        return Array.isArray(value) && value.every((v) => v instanceof Error);
    }
}
exports.default = Transpiler;
//# sourceMappingURL=Transpiler.js.map