@lcap/nasl 3.4.0-beta.5 → 3.4.0-beta.6

package/src/concepts/NewMap__.ts

@@ -1,4 +1,14 @@
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach, runGeneratorSync as runSync } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 import ForEachStatement from './ForEachStatement__';
 import Logic from './Logic__';
@@ -633,65 +643,63 @@ export class NewMap extends LogicItem {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     const indent0 = indent(state?.tabSize || 0);
     const indent1 = indent((state?.tabSize || 0) + 1);
     const indent2 = indent((state?.tabSize || 0) + 2);
-
-    const typeCode = (codestr: string) => {
+    const typeCode = function* typeCode(codestr: string) {
       codestr += `nasl.util.New<`;
-      codestr += `${this.typeAnnotation.toEmbeddedTS(shiftState(state, codestr, { inline: true }))}`;
+      codestr += `${yield * self.typeAnnotation.toEmbeddedTS(shiftState(state, codestr, { inline: true }))}`;
       codestr += `>()`;
       return codestr;
     };
-
     let code = '';
-    if (this.typeAnnotation) {
+    if (self.typeAnnotation) {
       code += `${indent0}(() => { \n`;
       // 方便ts报错检查
       code += `${indent1}function __newMap() {\n`;
-      this.keys.forEach((item, index) => {
+      yield* wrapForEach(self.keys, function* warpForEachGenerator(item, index) {
         const key = item;
         code += `${indent2}nasl.util.MapPut(`;
-        code = `${typeCode(code)}, `;
-        code += `${key ? key.toEmbeddedTS(shiftState(state, code, { inline: true })) : null}`;
+        code = `${yield* typeCode(code)}, `;
+        code += `${key ? yield* key.toEmbeddedTS(shiftState(state, code, { inline: true })) : null}`;
         code += ', null)\n';
       });
-      this.values.forEach((item, index) => {
-        const value = this.values[index];
+      yield* wrapForEach(self.values, function* warpForEachGenerator(item, index) {
+        const value = self.values[index];
         code += `${indent2}nasl.util.MapPut(`;
-        code = `${typeCode(code)}, null, `;
-        code += `${value ? value.toEmbeddedTS(shiftState(state, code, { inline: true })) : null}`;
+        code = `${yield* typeCode(code)}, null, `;
+        code += `${value ? yield* value.toEmbeddedTS(shiftState(state, code, { inline: true })) : null}`;
         code += ')';
         code += '\n';
       });
       code += `${indent2}return `;
-      code = `${typeCode(code)};\n`;
+      code = `${yield* typeCode(code)};\n`;
       code += `${indent1}};\n`;
-
       code += `${indent1}return __newMap();\n`;
       code += `${indent0}})()`;
-    } else if (this.keys.some((key) => key) || this.values.some((value) => value)) {
+    } else if (self.keys.some((key) => key) || self.values.some((value) => value)) {
       code += `${indent0}(() => { \n`;
       const valueTsArr: any = [];
       let keyTs = 'null';
       let valueTs = false;
       let keyIndex = -1;
-      this.keys.forEach((key, index) => {
+      yield* wrapForEach(self.keys, function* warpForEachGenerator(key, index) {
         if (key) {
-          const ts = key.toEmbeddedTS(shiftState(state, code, { inline: true }));
+          const ts = yield* key.toEmbeddedTS(shiftState(state, code, { inline: true }));
           if (keyIndex === -1 && !['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
             keyIndex = index;
             keyTs = ts;
           }
         }
       });
-      this.values.length && (code += indent1);
-      this.values.forEach((item, index) => {
+      self.values.length && (code += indent1);
+      yield* wrapForEach(self.values, function* warpForEachGenerator(item, index) {
         if (item) valueTs = true;
         code += `nasl.core.ensureVoid(`;
-        const ts = item ? item.toEmbeddedTS(shiftState(state, code, { inline: true })) : null;
+        const ts = item ? yield* item.toEmbeddedTS(shiftState(state, code, { inline: true })) : null;
         valueTsArr.push(ts);
         code += valueTsArr[index];
         code += '); ';
@@ -702,26 +710,24 @@ export class NewMap extends LogicItem {
       }
       // 方便ts报错检查
       code += `${indent1}function __newMap() {\n`;
-      this.keys.forEach((key: any) => {
+      yield* wrapForEach(self.keys, function* warpForEachGenerator(key: any) {
         if (!key) return;
         code += `${indent2}nasl.core.compareNew(${keyTs}, `;
-        code += key.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += yield* key.toEmbeddedTS(shiftState(state, code, { inline: true }));
         code += ');\n';
       });
       if (keyIndex !== -1) {
         code += `${indent2}nasl.util.ValidMapKey(`;
-        code += `${this.keys[keyIndex].toEmbeddedTS(shiftState(state, code, { inline: true }))});\n`;
+        code += `${yield* self.keys[keyIndex].toEmbeddedTS(shiftState(state, code, { inline: true }))});\n`;
       }
       code += `${indent2}return nasl.util.NewMap(`;
       code += `${keyIndex === -1 ? 'null' : keyTs}, ...[`;
-      valueTsArr.forEach((ts: any, index: number) => {
+      yield* wrapForEach(valueTsArr, function* warpForEachGenerator(ts: any, index: number) {
         code += ['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts) ? null : ts;
-        if (index + 1 < this.values.length) code += ', ';
+        if (index + 1 < self.values.length) code += ', ';
       });
       code += ']);\n';
-
       code += `${indent1}};\n`;
-
       code += `${indent1}return __newMap();\n`;
       code += `${indent0}})()`;
     } else {
@@ -730,7 +736,6 @@ export class NewMap extends LogicItem {
       code += `${indent1}function __newMap() {\n`;
       code += `${indent2}return nasl.util.NewMap(${null}, ${null});\n`;
       code += `${indent1}};\n`;
-
       code += `${indent1}return __newMap();\n`;
       code += `${indent0}})()`;
     }
@@ -755,28 +760,30 @@ export class NewMap extends LogicItem {
     return code;
   }
 
-  getInitCode(state?: TranslatorState): string {
+  *getInitCode(state?: TranslatorState) {
+    const self = this;
     let code = '';
     if (this.keys.some((key) => key) || this.values.some((value) => value)) {
       let keyBol = false;
       code += `nasl.util.NewMap(`;
-      this.keys.forEach((key) => {
+      for (const key of this.keys) {
         if (key && !keyBol) {
-          let ts = key.toEmbeddedTS(shiftState(state, code, { inline: true }));
-          ts = this.getForeachCode(ts);
+          let ts = yield* key.toEmbeddedTS(shiftState(state, code, { inline: true }));
+          ts = yield* this.getForeachCode(ts);
           if (!['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
             keyBol = true;
             code += ts;
           }
         }
-      });
+      };
       if (!keyBol) code += 'null';
       code += `, ...[`;
-      this.values.forEach((item, index) => {
-        let ts = item ? item.toEmbeddedTS(shiftState(state, code, { inline: true })) : null;
-        ts = this.getForeachCode(ts);
+
+      yield* wrapForEach(this.values, function* wrapForEach(item, index) {
+        let ts = item ? yield* item.toEmbeddedTS(shiftState(state, code, { inline: true })) : null;
+        ts = yield* self.getForeachCode(ts);
         code += ['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts) ? null : ts;
-        if (index + 1 < this.values.length) code += ', ';
+        if (index + 1 < self.values.length) code += ', ';
       });
       code += '])';
     } else {
@@ -785,12 +792,12 @@ export class NewMap extends LogicItem {
     return code;
   }
 
-  getForeachCode(code: string): string {
+  *getForeachCode(code: string) {
     // ForEachStatement 内部变量需要替换处理，如 item、index
     const forEachStatement = this.getAncestor('ForEachStatement') as ForEachStatement;
     if (forEachStatement && code) {
       code = code.replaceAll('\n', ' ');
-      code = new Logic().handleForEachCode(code, forEachStatement);
+      code = yield* new Logic().handleForEachCode(code, forEachStatement);
     }
     return code;
   }

package/src/concepts/New__.ts

@@ -1,4 +1,13 @@
-import { TranslatorState, shiftState, withSourceMap, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -53,8 +62,9 @@ export class New extends LogicItem {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     const code = '__IDENTIFIER__';
     return code;
   }

package/src/concepts/NullLiteral__.ts

@@ -1,4 +1,12 @@
-import { TranslatorState, withSourceMap, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 
 //================================================================================
@@ -66,8 +74,8 @@ export class NullLiteral extends LogicItem {
     return 'null';
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()) {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
     return 'null';
   }
 

package/src/concepts/NumericLiteral__.ts

@@ -1,4 +1,12 @@
-import { TranslatorState, withSourceMap, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 
 //================================================================================
@@ -135,7 +143,7 @@ export class NumericLiteral extends LogicItem {
   }
 
   toJS(): string {
-    const code = this.value ? `"${String(this.value)}"` : '';
+    const code = this.value ? String(this.value) : '';
     return code;
   }
 
@@ -143,10 +151,11 @@ export class NumericLiteral extends LogicItem {
     return `${this.value}`;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    const type = `${this.typeAnnotation.typeNamespace}.${this.typeAnnotation.typeName}`;
-    const code = this.value ? `new ${type}(${this.value})` : '__IDENTIFIER__';
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    const type = `${self.typeAnnotation.typeNamespace}.${self.typeAnnotation.typeName}`;
+    const code = self.value ? `new ${type}(${self.value})` : '__IDENTIFIER__';
     return code;
   }
 

package/src/concepts/OqlQueryComponent__.ts

@@ -1,4 +1,14 @@
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 import StructureProperty from './StructureProperty__';
 import Structure from './Structure__';
@@ -250,29 +260,29 @@ export class OqlQueryComponent extends LogicItem {
     return sqlTypeBan;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code: string;
-    const { typeAnnotation } = this;
+    const { typeAnnotation } = self;
     if (typeAnnotation) {
-      code = `(function(): ${typeAnnotation.toEmbeddedTS()} {\n`;
+      code = `(function(): ${yield* typeAnnotation.toEmbeddedTS()} {\n`;
     } else {
-      code = `(function __oqlQueryFn${String(this.id).slice(0, 8)} () {\n`;
+      code = `(function __oqlQueryFn${String(self.id).slice(0, 8)} () {\n`;
     }
-
     const indent1 = indent((state?.tabSize || 0) + 1);
     // this.dataSource: 'app.dataSources.defaultDS';
-    if (this.dataSource) {
+    if (self.dataSource) {
       code += indent1;
-      code += `const dataSource = ${this.dataSource || 'app.dataSources.defaultDS'};\n`;
+      code += `const dataSource = ${self.dataSource || 'app.dataSources.defaultDS'};\n`;
     }
-    const hasSyntaxErrors = !!this.codeSourceMap?.oqlSyntaxError?.syntaxErrors?.length;
+    const hasSyntaxErrors = !!self.codeSourceMap?.oqlSyntaxError?.syntaxErrors?.length;
     // 生成内部的ts内容
-    if (!this.code) {
+    if (!self.code) {
       // SQL 为空
       code += `${indent1}__OQL_EMPTY_ERROR__;\n`;
     } else if (hasSyntaxErrors) {
-      const syntaxErrors = this.codeSourceMap?.oqlSyntaxError?.syntaxErrors || [];
+      const syntaxErrors = self.codeSourceMap?.oqlSyntaxError?.syntaxErrors || [];
       const warningList = syntaxErrors.filter((err: any) => err.errorMsg.includes('别名不符合规范'));
       if (warningList.length === syntaxErrors.length) {
         // SQL 别名警告
@@ -287,21 +297,19 @@ export class OqlQueryComponent extends LogicItem {
       }
     }
     // insert typescript code
-    const typescript = this.codeSourceMap?.typescript;
+    const typescript = self.codeSourceMap?.typescript;
     if (typescript) {
       code += `${indent1}const __oqlQueryResult = ${typescript};`;
     }
-
     // 临时方案拼接字符串
-    this.getTextVariables();
+    self.getTextVariables();
     // 翻译字段
     code += '\n';
-    this._TsVariables.forEach((variable) => {
-      code += variable.toEmbeddedTS(shiftState(state, code));
+    yield* wrapForEach(self._TsVariables, function* warpForEachGenerator(variable) {
+      code += yield* variable.toEmbeddedTS(shiftState(state, code));
       code += ';\n';
     });
     code += '\n';
-
     if (typescript && !typeAnnotation) {
       code += `${indent1}return __oqlQueryResult;\n`;
     } else {