@lcap/nasl-parser/ts/toAST/to-nasl-match.ts

Take Nasl text to Nasl AST with the help of generalized parsing.

import { isEmpty, PackNaslAndCst, TYPE } from './common-util';

import * as nasl from '@lcap/nasl';
import { inspect } from 'util';

export const toNaslMatchStmt = (expr, cases) => {
    const nm = new nasl.Match({
        expression: expr.nasl,
        cases: cases.nasl.norm?.concat(cases.nasl.dft)
    });
    return PackNaslAndCst(nm, TYPE('MatchStmt', { expr: expr.cst, cases: cases.cst.norm?.concat(cases.cst.dft) }));
}

export const toNaslMatchExpr = (expr, cases) => {
    const nme = new nasl.Match({
        expression: expr.nasl,
        isExpression: true,
        cases: cases.nasl});
    return PackNaslAndCst(nme, TYPE('MatchExpr', { expr: expr.cst, cases: cases.cst }));
}

export const toNaslMatchCase = (body, pats?) => {
    const nmc = new nasl.MatchCase({
        patterns: pats?.nasl,
        body: body.nasl
    });
    return PackNaslAndCst(nmc, TYPE('MatchCase', { pats: pats?.cst, body: body.cst }));
}

// export const toNaslMatchCases = ([normal, def]) => {
//     const naslCases = normal.map(c => c.nasl).concat(def.nasl);
//     const cstCases =  normal.map(c => c.cst).concat(def.cst);
//     return PackNaslAndCst(naslCases, cstCases);
// }

// export const toNaslMatchNormalCase = (pats, expr) => {
//     const nmc = new nasl.MatchCase({
//         patterns: pats.nasl,
//         body: expr.nasl
//     })
//     return PackNaslAndCst(nmc, TYPE('MatchNormalCase', { pats: pats.cst, expr: expr.cst }));
// }

// export const toNaslMatchDefaultCase = (expr) => {
//     const nmc = new nasl.MatchCase({
//         patterns: [],
//         body: expr.nasl
//     })
//     return PackNaslAndCst(nmc, TYPE('MatchDefaultCase', { expr: expr.cst }));
// }