@calculemus/jaco/lib/parser-util.js

"use strict";
/**
 * Consumes (and documents) the messy output produced by the parser, and turns it into parsedsyntax.ts types. This file could easily produce garbage output if there's a mismatch between the documented types and the types that the parser produces. This file should only throw errors to document invariants of the parser; user errors should be thrown in restrictsyntax.ts.
 *
 * The structure of this file should match parsedsyntax.ts as much as practical.
 */
Object.defineProperty(exports, "__esModule", { value: true });
function Identifier([{ value, text, offset, lineBreaks, line, col }]) {
    return {
        tag: "Identifier",
        name: text
    };
}
exports.Identifier = Identifier;
function IntType([tok]) {
    return {
        tag: "IntType"
    };
}
exports.IntType = IntType;
function BoolType([tok]) {
    return {
        tag: "BoolType"
    };
}
exports.BoolType = BoolType;
function StringType([tok]) {
    return {
        tag: "StringType"
    };
}
exports.StringType = StringType;
function CharType([tok]) {
    return {
        tag: "CharType"
    };
}
exports.CharType = CharType;
function VoidType([tok]) {
    return {
        tag: "VoidType"
    };
}
exports.VoidType = VoidType;
function PointerType([tp, s, tok]) {
    return {
        tag: "PointerType",
        argument: tp
    };
}
exports.PointerType = PointerType;
function ArrayType([tp, s1, l, s2, r]) {
    return {
        tag: "ArrayType",
        argument: tp
    };
}
exports.ArrayType = ArrayType;
function StructType([str, s, id]) {
    return {
        tag: "StructType",
        id: id
    };
}
exports.StructType = StructType;
function IntLiteral([{ value, text, offset, lineBreaks, line, col }]) {
    return {
        tag: "IntLiteral",
        raw: text
    };
}
exports.IntLiteral = IntLiteral;
function CharLiteral([[start, [tok], end]]) {
    return {
        tag: "CharLiteral",
        raw: tok.value
    };
}
exports.CharLiteral = CharLiteral;
function StringLiteral([[start, toks, end]]) {
    return {
        tag: "StringLiteral",
        raw: toks.map(x => x[0].value)
    };
}
exports.StringLiteral = StringLiteral;
function BoolLiteral([t]) {
    return {
        tag: "BoolLiteral",
        value: t.value === "true"
    };
}
exports.BoolLiteral = BoolLiteral;
function NullLiteral() {
    return {
        tag: "NullLiteral"
    };
}
exports.NullLiteral = NullLiteral;
function ArrayMemberExpression([object, s1, l, s2, index, s3, r]) {
    return {
        tag: "ArrayMemberExpression",
        object: object,
        index: index
    };
}
exports.ArrayMemberExpression = ArrayMemberExpression;
function Arguments([l, s1, args, r]) {
    if (args === null)
        return [];
    return [args[0]].concat(args[2].map(x => x[2]));
}
exports.Arguments = Arguments;
function StructMemberExpression([object, s1, deref, s2, field]) {
    return {
        tag: "StructMemberExpression",
        deref: deref instanceof Array,
        object: object,
        field: field
    };
}
exports.StructMemberExpression = StructMemberExpression;
function CallExpression([f, ws, args]) {
    return {
        tag: "CallExpression",
        callee: f,
        arguments: Arguments(args)
    };
}
exports.CallExpression = CallExpression;
function IndirectCallExpression([l, s1, s, s2, f, s3, r, s4, args]) {
    return {
        tag: "IndirectCallExpression",
        callee: f,
        arguments: Arguments(args)
    };
}
exports.IndirectCallExpression = IndirectCallExpression;
function UnaryExpression([operator, s, argument]) {
    if (operator.length == 1) {
        switch (operator[0].value) {
            case "&":
            case "!":
            case "~":
            case "-":
            case "*":
                return {
                    tag: "UnaryExpression",
                    operator: operator[0].value,
                    argument: argument
                };
            default:
                throw new Error(operator[0].value);
        }
    }
    else {
        return {
            tag: "CastExpression",
            kind: operator[2],
            argument: argument
        };
    }
}
exports.UnaryExpression = UnaryExpression;
function BinaryExpression([left, s1, opertoks, s2, right]) {
    const operator = opertoks.map((tok) => tok.text).join("");
    switch (operator) {
        case "*":
        case "/":
        case "%":
        case "+":
        case "-":
        case "<<":
        case ">>":
        case "<":
        case "<=":
        case ">=":
        case ">":
        case "==":
        case "!=":
        case "&":
        case "^":
        case "|":
            return {
                tag: "BinaryExpression",
                operator: operator,
                left: left,
                right: right
            };
        case "&&":
        case "||":
            return {
                tag: "LogicalExpression",
                operator: operator,
                left: left,
                right: right
            };
        case "=":
        case "+=":
        case "-=":
        case "*=":
        case "/=":
        case "%=":
        case "&=":
        case "^=":
        case "|=":
        case "<<=":
        case ">>=":
            return {
                tag: "AssignmentExpression",
                operator: operator,
                left: left,
                right: right
            };
        default:
            throw new Error(operator);
    }
}
exports.BinaryExpression = BinaryExpression;
function ConditionalExpression([test, s1, op1, s2, consequent, s3, op2, s4, alternate]) {
    return {
        tag: "ConditionalExpression",
        test: test,
        consequent: consequent,
        alternate: alternate
    };
}
exports.ConditionalExpression = ConditionalExpression;
function AllocExpression([alloc, s1, l, s2, typ, s3, r]) {
    return {
        tag: "AllocExpression",
        kind: typ
    };
}
exports.AllocExpression = AllocExpression;
function AllocArrayExpression([alloc, s1, l, s2, typ, s3, c, s4, size, sp, r]) {
    return {
        tag: "AllocArrayExpression",
        kind: typ,
        size: size
    };
}
exports.AllocArrayExpression = AllocArrayExpression;
function ResultExpression([b, res]) {
    return {
        tag: "ResultExpression"
    };
}
exports.ResultExpression = ResultExpression;
function LengthExpression([b, length, s1, l, s2, argument, s3, r]) {
    return {
        tag: "LengthExpression",
        argument: argument
    };
}
exports.LengthExpression = LengthExpression;
function HasTagExpression([b, hastag, s1, l, s2, typ, s3, c, s4, argument, s5, r]) {
    return {
        tag: "HasTagExpression",
        kind: typ,
        argument: argument
    };
}
exports.HasTagExpression = HasTagExpression;
function UpdateExpression([argument, s1, op1, op2]) {
    return {
        tag: "UpdateExpression",
        argument: argument,
        operator: op1.value === "+" ? "++" : "--"
    };
}
exports.UpdateExpression = UpdateExpression;
function AssertExpression([assert, s1, l, s2, test, s3, r]) {
    return {
        tag: "AssertExpression",
        test: test
    };
}
exports.AssertExpression = AssertExpression;
function ErrorExpression([error, s1, l, s2, argument, s3, r]) {
    return {
        tag: "ErrorExpression",
        argument: argument
    };
}
exports.ErrorExpression = ErrorExpression;
function SimpleStatement([stm, s1, semi]) {
    if (stm instanceof Array) {
        const init = stm[3];
        return {
            tag: "VariableDeclaration",
            kind: stm[0],
            id: stm[2],
            init: init === null ? null : init[3]
        };
    }
    else {
        return {
            tag: "ExpressionStatement",
            expression: stm
        };
    }
}
exports.SimpleStatement = SimpleStatement;
function IfStatement([i, s1, l, s2, test, s3, r, s4, [annos, consequent]]) {
    return {
        tag: "IfStatement",
        test: test,
        consequent: [annos, consequent]
    };
}
exports.IfStatement = IfStatement;
function IfElseStatement([i, s1, l1, s2, test, s3, r, annos1, s4, consequent, s5, e, annos2, s6, alternate]) {
    return {
        tag: "IfStatement",
        test: test,
        consequent: [annos1, consequent],
        alternate: [annos2, alternate]
    };
}
exports.IfElseStatement = IfElseStatement;
function WhileStatement([w, s1, l, s2, test, s3, r, annos, s4, body]) {
    return {
        tag: "WhileStatement",
        test: test,
        annos: annos,
        body: body
    };
}
exports.WhileStatement = WhileStatement;
function ForStatement([f, s1, l, init, s2, semi1, s3, test, s4, semi2, update, s5, r, annos, s6, body]) {
    return {
        tag: "ForStatement",
        init: init === null ? null : SimpleStatement([init[1], s2, semi1]),
        test: test,
        update: update === null ? null : update[1],
        annos: annos,
        body: body
    };
}
exports.ForStatement = ForStatement;
function ReturnStatement([r, argument, s1, semi]) {
    return {
        tag: "ReturnStatement",
        argument: argument === null ? null : argument[1]
    };
}
exports.ReturnStatement = ReturnStatement;
function BlockStatement([l, stms, annos, s, r]) {
    const stms1 = stms.map(x => x[1][0].map((y) => ({ tag: "AnnoStatement", anno: y })).concat([x[1][1]]));
    const stms2 = annos.map((x) => ({
        tag: "AnnoStatement",
        anno: x[1][0]
    }));
    const stmsAll = stms1
        .concat([stms2])
        .reduce((collect, stms) => collect.concat(stms), []);
    return {
        tag: "BlockStatement",
        body: stmsAll
    };
}
exports.BlockStatement = BlockStatement;
function BreakStatement([stm, s1, semi]) {
    return { tag: "BreakStatement" };
}
exports.BreakStatement = BreakStatement;
function ContinueStatement([stm, s1, semi]) {
    return { tag: "ContinueStatement" };
}
exports.ContinueStatement = ContinueStatement;
function Anno1(annos) {
    const start = annos[0];
    const end = annos[6] ? annos[6] : annos[4];
    if (start.type === "anno_line_start" && start.line !== end.line)
        throw new Error(`Single-line annotations cannot be extended onto multiple lines with multiline comments.`);
    return annos[2];
}
exports.Anno1 = Anno1;
function FunctionDeclarationArgs([l, s1, params, r]) {
    if (params === null)
        return [];
    const first = {
        tag: "VariableDeclaration",
        kind: params[0],
        id: params[2]
    };
    return [first].concat(params[4].map(x => ({
        tag: "VariableDeclaration",
        kind: x[2],
        id: x[4]
    })));
}
exports.FunctionDeclarationArgs = FunctionDeclarationArgs;
function FunctionDeclaration([ty, s1, f, s2, args, annos, s3, def]) {
    return {
        tag: "FunctionDeclaration",
        returns: ty,
        id: f,
        params: args,
        annos: annos,
        body: def
    };
}
exports.FunctionDeclaration = FunctionDeclaration;
//# sourceMappingURL=parser-util.js.map