@lcap/nasl 3.6.0-beta.1 → 3.7.0-beta.1

package/src/concepts/JSBlock__.ts

@@ -28,6 +28,13 @@ import LogicItem from './LogicItem__';
 export class JSBlock extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'JSBlock';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/JavaLogic__.ts

@@ -28,6 +28,13 @@ import LogicItem from './LogicItem__';
 export class JavaLogic extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'JavaLogic';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/LogicDeclaration__.ts

@@ -0,0 +1,657 @@
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
+
+import * as utils from '../utils';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
+import { v4 as uuidv4 } from 'uuid';
+import BaseNode from '../common/BaseNode';
+import TypeParam from './TypeParam__';
+import Param from './Param__';
+import Return from './Return__';
+
+/**
+ * 逻辑声明
+ */
+@concept('逻辑声明')
+export class LogicDeclaration extends BaseNode {
+  /** 类名 */
+  static readonly ConceptName: string = 'LogicDeclaration';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
+
+  /**
+   * 产品概念
+   */
+  @property('concept')
+  // @ts-ignore
+  readonly concept!: 'LogicDeclaration';
+  /**
+   * 逻辑名称
+   */
+  @property({
+    objectRef: '',
+  })
+  name: string = '';
+
+  /**
+   * 逻辑标题
+   */
+  @property({
+    objectRef: '',
+  })
+  title: string;
+
+  /**
+   * 逻辑描述
+   */
+  @property({
+    objectRef: '',
+  })
+  description: string;
+
+  /**
+   * 类型参数列表
+   */
+  @property({
+    objectRef: 'TypeParam',
+    isArray: true,
+    defaultValue: null,
+  })
+  typeParams?: Array<TypeParam> = null;
+
+  /**
+   * 输入参数列表
+   */
+  @property({
+    objectRef: 'Param',
+    isArray: true,
+    defaultValue: [],
+  })
+  params: Array<Param> = [];
+
+  /**
+   * 输出参数列表
+   */
+  @property({
+    objectRef: 'Return',
+    isArray: true,
+    defaultValue: [],
+  })
+  returns: Array<Return> = [];
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<LogicDeclaration>) {
+    source = Object.assign({}, LogicDeclaration.getDefaultOptions(), source);
+    super(source);
+    super.subConstructor(source);
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): LogicDeclaration {
+    return super.from(source, parentNode, parentKey) as LogicDeclaration;
+  }
+
+  getTypeParamExistingNames(excludedList: Array<TypeParam> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.typeParams as TypeParam[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+  getTypeParamUniqueName(name = 'typeParam1') {
+    return utils.unique(name, this.getTypeParamExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入类型参数
+   * @internal
+   * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+   */
+  _insertTypeParamAt(name: string, index: number): TypeParam;
+
+  /**
+   * 插入类型参数
+   * @internal
+   * @param typeParamOptions 类型参数参数
+   */
+  _insertTypeParamAt(typeParamOptions: Partial<TypeParam>, index: number): TypeParam;
+
+  /**
+   * 插入类型参数
+   * @internal
+   * @param typeParam 已有的类型参数实例
+   */
+  _insertTypeParamAt(typeParam: TypeParam, index: number): TypeParam;
+
+  _insertTypeParamAt(options: string | Partial<TypeParam> | TypeParam, index: number) {
+    const typeParamOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'typeParams' };
+    const TypeParam = getConceptConstructor('TypeParam');
+    let typeParam: TypeParam;
+    if (!options) {
+      typeParam = TypeParam.from(
+        {
+          ...typeParamOptions,
+          name: this.getTypeParamUniqueName(),
+        },
+        this,
+        'typeParams',
+      );
+    } else if (typeof options === 'string') {
+      typeParam = TypeParam.from(
+        {
+          ...typeParamOptions,
+          name: options,
+        },
+        this,
+        'typeParams',
+      );
+    } else if (asserts.isTypeParam(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      typeParam = options;
+      Object.assign(typeParam, relationOptions);
+    } else {
+      typeParam = TypeParam.from(
+        {
+          ...typeParamOptions,
+          ...options,
+        },
+        this,
+        'typeParams',
+      );
+    }
+    this.typeParams.splice(index, 0, typeParam);
+    return typeParam;
+  }
+
+  /**
+   * 插入类型参数
+   * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+   */
+  insertTypeParamAt(name: string, index: number): TypeParam;
+
+  /**
+   * 插入类型参数
+   * @param typeParamOptions 类型参数参数
+   */
+  insertTypeParamAt(typeParamOptions: Partial<TypeParam>, index: number): TypeParam;
+
+  /**
+   * 插入类型参数
+   * @param typeParam 已有的类型参数实例
+   */
+  insertTypeParamAt(typeParam: TypeParam, index: number): TypeParam;
+
+  insertTypeParamAt(options: string | Partial<TypeParam> | TypeParam, index: number) {
+    const node = this._insertTypeParamAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'typeParams',
+    });
+    return node;
+  }
+
+  /**
+   * 添加类型参数
+   * @internal
+   * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+   */
+  _addTypeParam(name?: string): TypeParam;
+
+  /**
+   * 添加类型参数
+   * @internal
+   * @param typeParamOptions 类型参数参数
+   */
+  _addTypeParam(typeParamOptions: Partial<TypeParam>): TypeParam;
+
+  /**
+   * 添加类型参数
+   * @internal
+   * @param typeParam 已有的类型参数实例
+   */
+  _addTypeParam(typeParam: TypeParam): TypeParam;
+
+  _addTypeParam(options?: string | Partial<TypeParam> | TypeParam) {
+    const index = this.typeParams.length;
+    return this._insertTypeParamAt(options as any, index);
+  }
+
+  /**
+   * 添加类型参数
+   * @internal
+   * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+   */
+  addTypeParam(name?: string): TypeParam;
+
+  /**
+   * 添加类型参数
+   * @param typeParamOptions 类型参数参数
+   */
+  addTypeParam(typeParamOptions: Partial<TypeParam>): TypeParam;
+
+  /**
+   * 添加类型参数
+   * @param typeParam 已有的类型参数实例
+   */
+  addTypeParam(typeParam: TypeParam): TypeParam;
+
+  addTypeParam(options?: string | Partial<TypeParam> | TypeParam) {
+    const node = this._addTypeParam(options as any);
+    const index = this.typeParams.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'typeParams',
+    });
+    return node;
+  }
+
+  getParamExistingNames(excludedList: Array<Param> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.params as Param[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+  getParamUniqueName(name = 'param1') {
+    return utils.unique(name, this.getParamExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入输入参数
+   * @internal
+   * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+   */
+  _insertParamAt(name: string, index: number): Param;
+
+  /**
+   * 插入输入参数
+   * @internal
+   * @param paramOptions 输入参数参数
+   */
+  _insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+
+  /**
+   * 插入输入参数
+   * @internal
+   * @param param 已有的输入参数实例
+   */
+  _insertParamAt(param: Param, index: number): Param;
+
+  _insertParamAt(options: string | Partial<Param> | Param, index: number) {
+    const paramOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'params' };
+    const Param = getConceptConstructor('Param');
+    let param: Param;
+    if (!options) {
+      param = Param.from(
+        {
+          ...paramOptions,
+          name: this.getParamUniqueName(),
+        },
+        this,
+        'params',
+      );
+    } else if (typeof options === 'string') {
+      param = Param.from(
+        {
+          ...paramOptions,
+          name: options,
+        },
+        this,
+        'params',
+      );
+    } else if (asserts.isParam(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      param = options;
+      Object.assign(param, relationOptions);
+    } else {
+      param = Param.from(
+        {
+          ...paramOptions,
+          ...options,
+        },
+        this,
+        'params',
+      );
+    }
+    this.params.splice(index, 0, param);
+    return param;
+  }
+
+  /**
+   * 插入输入参数
+   * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+   */
+  insertParamAt(name: string, index: number): Param;
+
+  /**
+   * 插入输入参数
+   * @param paramOptions 输入参数参数
+   */
+  insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+
+  /**
+   * 插入输入参数
+   * @param param 已有的输入参数实例
+   */
+  insertParamAt(param: Param, index: number): Param;
+
+  insertParamAt(options: string | Partial<Param> | Param, index: number) {
+    const node = this._insertParamAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'params',
+    });
+    return node;
+  }
+
+  /**
+   * 添加输入参数
+   * @internal
+   * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+   */
+  _addParam(name?: string): Param;
+
+  /**
+   * 添加输入参数
+   * @internal
+   * @param paramOptions 输入参数参数
+   */
+  _addParam(paramOptions: Partial<Param>): Param;
+
+  /**
+   * 添加输入参数
+   * @internal
+   * @param param 已有的输入参数实例
+   */
+  _addParam(param: Param): Param;
+
+  _addParam(options?: string | Partial<Param> | Param) {
+    const index = this.params.length;
+    return this._insertParamAt(options as any, index);
+  }
+
+  /**
+   * 添加输入参数
+   * @internal
+   * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+   */
+  addParam(name?: string): Param;
+
+  /**
+   * 添加输入参数
+   * @param paramOptions 输入参数参数
+   */
+  addParam(paramOptions: Partial<Param>): Param;
+
+  /**
+   * 添加输入参数
+   * @param param 已有的输入参数实例
+   */
+  addParam(param: Param): Param;
+
+  addParam(options?: string | Partial<Param> | Param) {
+    const node = this._addParam(options as any);
+    const index = this.params.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'params',
+    });
+    return node;
+  }
+
+  getReturnExistingNames(excludedList: Array<Return> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.returns as Return[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+  getReturnUniqueName(name = 'ret1') {
+    return utils.unique(name, this.getReturnExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入输出参数
+   * @internal
+   * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+   */
+  _insertReturnAt(name: string, index: number): Return;
+
+  /**
+   * 插入输出参数
+   * @internal
+   * @param retOptions 输出参数参数
+   */
+  _insertReturnAt(retOptions: Partial<Return>, index: number): Return;
+
+  /**
+   * 插入输出参数
+   * @internal
+   * @param ret 已有的输出参数实例
+   */
+  _insertReturnAt(ret: Return, index: number): Return;
+
+  _insertReturnAt(options: string | Partial<Return> | Return, index: number) {
+    const retOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'returns' };
+    const Return = getConceptConstructor('Return');
+    let ret: Return;
+    if (!options) {
+      ret = Return.from(
+        {
+          ...retOptions,
+          name: this.getReturnUniqueName(),
+        },
+        this,
+        'returns',
+      );
+    } else if (typeof options === 'string') {
+      ret = Return.from(
+        {
+          ...retOptions,
+          name: options,
+        },
+        this,
+        'returns',
+      );
+    } else if (asserts.isReturn(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      ret = options;
+      Object.assign(ret, relationOptions);
+    } else {
+      ret = Return.from(
+        {
+          ...retOptions,
+          ...options,
+        },
+        this,
+        'returns',
+      );
+    }
+    this.returns.splice(index, 0, ret);
+    return ret;
+  }
+
+  /**
+   * 插入输出参数
+   * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+   */
+  insertReturnAt(name: string, index: number): Return;
+
+  /**
+   * 插入输出参数
+   * @param retOptions 输出参数参数
+   */
+  insertReturnAt(retOptions: Partial<Return>, index: number): Return;
+
+  /**
+   * 插入输出参数
+   * @param ret 已有的输出参数实例
+   */
+  insertReturnAt(ret: Return, index: number): Return;
+
+  insertReturnAt(options: string | Partial<Return> | Return, index: number) {
+    const node = this._insertReturnAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'returns',
+    });
+    return node;
+  }
+
+  /**
+   * 添加输出参数
+   * @internal
+   * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+   */
+  _addReturn(name?: string): Return;
+
+  /**
+   * 添加输出参数
+   * @internal
+   * @param retOptions 输出参数参数
+   */
+  _addReturn(retOptions: Partial<Return>): Return;
+
+  /**
+   * 添加输出参数
+   * @internal
+   * @param ret 已有的输出参数实例
+   */
+  _addReturn(ret: Return): Return;
+
+  _addReturn(options?: string | Partial<Return> | Return) {
+    const index = this.returns.length;
+    return this._insertReturnAt(options as any, index);
+  }
+
+  /**
+   * 添加输出参数
+   * @internal
+   * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+   */
+  addReturn(name?: string): Return;
+
+  /**
+   * 添加输出参数
+   * @param retOptions 输出参数参数
+   */
+  addReturn(retOptions: Partial<Return>): Return;
+
+  /**
+   * 添加输出参数
+   * @param ret 已有的输出参数实例
+   */
+  addReturn(ret: Return): Return;
+
+  addReturn(options?: string | Partial<Return> | Return) {
+    const node = this._addReturn(options as any);
+    const index = this.returns.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'returns',
+    });
+    return node;
+  }
+
+  /**
+   * 删除类型参数
+   * @param name 类型参数名称
+   */
+  removeTypeParam(name: string): void;
+
+  /**
+   * 删除类型参数
+   * @param typeParam 已有的类型参数实例
+   */
+  removeTypeParam(typeParam: TypeParam): void;
+
+  removeTypeParam(options: string | TypeParam) {
+    let typeParam: TypeParam;
+    if (typeof options === 'string') {
+      typeParam = (this.typeParams as TypeParam[]).find((item) => item.name === options);
+      if (!typeParam) {
+        throw new Error('找不到类型参数 ' + options);
+      }
+    } else {
+      typeParam = options;
+    }
+    return typeParam.delete();
+  }
+
+  /**
+   * 删除输入参数
+   * @param name 输入参数名称
+   */
+  removeParam(name: string): void;
+
+  /**
+   * 删除输入参数
+   * @param param 已有的输入参数实例
+   */
+  removeParam(param: Param): void;
+
+  removeParam(options: string | Param) {
+    let param: Param;
+    if (typeof options === 'string') {
+      param = (this.params as Param[]).find((item) => item.name === options);
+      if (!param) {
+        throw new Error('找不到输入参数 ' + options);
+      }
+    } else {
+      param = options;
+    }
+    return param.delete();
+  }
+
+  /**
+   * 删除输出参数
+   * @param name 输出参数名称
+   */
+  removeReturn(name: string): void;
+
+  /**
+   * 删除输出参数
+   * @param ret 已有的输出参数实例
+   */
+  removeReturn(ret: Return): void;
+
+  removeReturn(options: string | Return) {
+    let ret: Return;
+    if (typeof options === 'string') {
+      ret = (this.returns as Return[]).find((item) => item.name === options);
+      if (!ret) {
+        throw new Error('找不到输出参数 ' + options);
+      }
+    } else {
+      ret = options;
+    }
+    return ret.delete();
+  }
+
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
+
+  //================================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //================================================================================
+}
+
+export default LogicDeclaration;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================

package/src/concepts/LogicItem__.ts

@@ -40,6 +40,13 @@ import BaseNode from '../common/BaseNode';
 export abstract class LogicItem extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'LogicItem';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = true;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念