@lcap/nasl-parser/generated/toAST/to-nasl-definition.js

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

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.toNaslVarInit = exports.toNaslEnumItem = exports.pCtorToProperty = exports.toNaslStructureProperty = exports.toNaslStructure = exports.toNaslLogic = exports.toNaslLogicSig = exports.toNaslVarsAndStmts = void 0;
exports.toNaslEnum = toNaslEnum;
exports.toNaslUsingNamespace = toNaslUsingNamespace;
exports.toNaslLogicDeclare = toNaslLogicDeclare;
exports.toNaslCstAnn = toNaslCstAnn;
exports.toNaslCstAnnArg = toNaslCstAnnArg;
exports.toNaslNamespace = toNaslNamespace;
exports.toNaslEntity = toNaslEntity;
const nasl = __importStar(require("@lcap/nasl"));
const asserts_1 = require("@lcap/nasl-concepts/asserts");
const decorated_nasl_ast_1 = require("./decorated-nasl-ast");
const common_util_1 = require("./common-util");
const to_nasl_type_1 = require("./to-nasl-type");
const toNaslVarsAndStmts = ([vars, stmts]) => {
    return { nasl: { vars: vars.nasl, stmts: stmts.nasl },
        cst: { vars: vars.cst, stmts: stmts.cst } };
};
exports.toNaslVarsAndStmts = toNaslVarsAndStmts;
const toNaslLogicSig = (name, tyVars, params, _ret, anns) => {
    tyVars = tyVars ?? [];
    const ret = _ret ? new nasl.Return({
        name: _ret.nasl.name,
        typeAnnotation: _ret.nasl.typeAnnotation,
        defaultValue: _ret.nasl.defaultValue
    }) : null;
    return (0, common_util_1.PackNaslAndCst)({ name,
        tyVars: tyVars.nasl,
        params: params.nasl,
        ret,
        anns: anns?.map(common_util_1.getNasl) }, (0, common_util_1.TYPE)('LogicSig', { name,
        tyVars: tyVars.cst,
        params: params.cst,
        ret: _ret?.cst,
        anns: anns?.map(common_util_1.getCst) }));
};
exports.toNaslLogicSig = toNaslLogicSig;
const toNaslLogic = ([_sig, _body]) => {
    const sig = _sig.nasl;
    const body = _body.nasl;
    const nl = new nasl.Logic();
    nl.name = sig.name;
    nl.typeParams = sig.tyVars; // null 与 IDE 兼容，绝妙！=> 3.11 又不兼容了 又要改成 undefined
    nl.params = sig.params ?? []; // [] 与 IDE 兼容，绝妙！
    nl.returns = sig.ret ? [sig.ret] : [];
    nl.annotations = sig.annotations;
    nl.body = [new nasl.Start({ label: '开始' }), ...body.stmts]; // 不写 label 还真就不加了，🐂
    if (!(0, asserts_1.isEnd)((0, common_util_1.last)(nl.body))) {
        nl.body.push(new nasl.End({ label: '结束' })); // 不写 label 还真就不加了，🐂
    }
    nl.variables = body.vars; // 无法自由创建局部变量，都在逻辑开头处
    nl.annotations = sig.anns;
    return (0, common_util_1.PackNaslAndCst)(nl, (0, common_util_1.TYPE)('Logic', { sig: _sig.cst, body: _body.cst }));
};
exports.toNaslLogic = toNaslLogic;
// transform type variables introduced in <·> to type parameters
// not to be confused with types used <·> at the use site
const toNaslTypeParam = (n) => new nasl.TypeParam({
    name: n
});
const toNaslStructure = (tyIntro, pCtor, supTy, body, anns) => {
    const ns = new nasl.Structure({
        name: tyIntro.tyCon,
        // description: ,
        // origin: 'CallQueryComponent'; ???
        typeParams: tyIntro.tyVars.map(toNaslTypeParam),
        properties: pCtor?.nasl ? pCtor.nasl.concat(body?.nasl.props) : body?.nasl.props,
    });
    ns.annotations = anns?.map(common_util_1.getNasl);
    const cst = (0, common_util_1.TYPE)("Struct", { anns: anns?.map(common_util_1.getCst), ty: tyIntro, props: body.cst.props, logics: body.cst.logics, ctors: body.cst.ctors });
    return (0, common_util_1.PackNaslAndCst)(ns, cst);
};
exports.toNaslStructure = toNaslStructure;
const toNaslStructureProperty = (vd, anns) => {
    const nsp = new nasl.StructureProperty({
        // sp.nasl : nasl.Variable
        name: vd.nasl.name,
        typeAnnotation: vd.nasl.typeAnnotation,
        defaultValue: vd.nasl.defaultValue,
        // label: TODO
        // jsonName: TODO
        // description: TODO
        // required 看起来废弃了
    });
    nsp.annotations = anns?.map(common_util_1.getNasl);
    return (0, common_util_1.PackNaslAndCst)(nsp, (0, common_util_1.TYPE)("StructProperty", { prop: vd.cst, anns: anns?.map(common_util_1.getCst) }));
};
exports.toNaslStructureProperty = toNaslStructureProperty;
const pCtorToProperty = ([vds]) => {
    if ((0, common_util_1.isEmpty)(vds)) {
        return (0, common_util_1.PackNaslAndCst)([], []);
    }
    return (0, common_util_1.PackNaslAndCstSeq)(vds?.nasl?.map(exports.toNaslStructureProperty));
};
exports.pCtorToProperty = pCtorToProperty;
function toNaslEnum(name, defs, anns) {
    const body = (0, common_util_1.PackNaslAndCstSeq)(defs);
    const isInt = /^\d+$/.test(body.nasl[0].value);
    const ne = new nasl.Enum({
        name,
        enumItems: body.nasl,
        valueType: (0, to_nasl_type_1.createNaslPrimitiveType)(isInt ? 'Long' : 'String'),
        // ne.label = e.label; 似乎是废弃属性
    });
    ne.annotations = anns?.map(common_util_1.getNasl);
    return (0, common_util_1.PackNaslAndCst)(ne, (0, common_util_1.TYPE)("Enum", { name, body: body.cst, anns: anns?.map(common_util_1.getCst) }));
}
const toNaslEnumItem = (prop, anns) => {
    if (typeof prop !== 'string') {
        // @ts-ignore
        prop = prop.nasl.value;
    }
    const nei = new nasl.EnumItem({
        // @ts-ignore
        value: prop,
        // label: title, 后续 ProcessAnnotation 流程统一处理
    });
    nei.annotations = anns?.map(common_util_1.getNasl);
    return (0, common_util_1.PackNaslAndCst)(nei, (0, common_util_1.TYPE)("EnumItem", { value: prop, anns: anns?.map(common_util_1.getCst) }));
};
exports.toNaslEnumItem = toNaslEnumItem;
const toNaslVarInit = ([name, ty, val]) => {
    const nv = new nasl.Variable({
        name: name,
        typeAnnotation: ty?.nasl,
        defaultValue: val?.nasl ? new nasl.DefaultValue({ expression: val?.nasl }) : undefined,
    });
    return (0, common_util_1.PackNaslAndCst)(nv, (0, common_util_1.TYPE)("VarInit", { name, ty: ty?.cst, val: val?.cst }));
};
exports.toNaslVarInit = toNaslVarInit;
function toNaslUsingNamespace(_qName) {
    const nsp = _qName.namespace.concat(_qName.name);
    return (0, common_util_1.PackNaslAndCst)(new decorated_nasl_ast_1.UsingNamespace(nsp), (0, common_util_1.TYPE)("UsingNamespace", { namespace: nsp }));
}
function toNaslLogicDeclare(_sig) {
    const decl = new nasl.LogicDeclaration({
        name: _sig.nasl.name,
        typeParams: _sig.nasl.tyVars,
        params: _sig.nasl.params,
        returns: _sig.nasl.ret,
    });
    return (0, common_util_1.PackNaslAndCst)(decl, (0, common_util_1.TYPE)('LogicDeclare', _sig.cst));
}
function toNaslCstAnn(type, name, args) {
    const cAnn = new decorated_nasl_ast_1.CstAnnotation(type, name, args.nasl);
    return (0, common_util_1.PackNaslAndCst)(cAnn, (0, common_util_1.TYPE)('Annotation', { type, name, args: args.cst }));
}
function toNaslCstAnnArg(name, val) {
    const cAArg = new decorated_nasl_ast_1.CstAnnotationArg(name, val?.nasl);
    return (0, common_util_1.PackNaslAndCst)(cAArg, (0, common_util_1.TYPE)('AnnotationArg', { name: name, val: val?.cst }));
}
function toNaslNamespace(name, defs) {
    const packed = (0, common_util_1.PackNaslAndCstSeq)(defs);
    const nsp = new decorated_nasl_ast_1.CstNamespace(name, packed.nasl);
    return (0, common_util_1.PackNaslAndCst)(nsp, (0, common_util_1.TYPE)('Namespace', { defs: packed.cst }));
}
// pctor: primary constructor
function toNaslEntity(tyIntro, pctor, props, anns) {
    const ne = new nasl.Entity({
        name: tyIntro.tyCon,
        properties: props.nasl,
        annotations: anns?.map(common_util_1.getNasl)
    });
    const cst = (0, common_util_1.TYPE)('Entity', {
        ty: tyIntro,
        pctor: null, // 暂不支持
        props: props.cst,
        anns: anns?.map(common_util_1.getCst)
    });
    return (0, common_util_1.PackNaslAndCst)(ne, cst);
}
//# sourceMappingURL=to-nasl-definition.js.map