feat: support static string and add generate support.

Author: andycall

bridge/CMakeLists.txt

@@ -283,6 +283,8 @@ if ($ENV{KRAKEN_JS_ENGINE} MATCHES "quickjs")
     core/dom/events/event_target.cc
     core/dom/events/event_target_impl.cc
     core/dom/events/event_target_impl.h
+    core/dom/events/error_event.cc
+    core/dom/events/error_event.h
 #    core/dom/character_data.cc
 #    core/dom/character_data.h
 #    core/dom/comment.cc
@@ -311,6 +313,8 @@ if ($ENV{KRAKEN_JS_ENGINE} MATCHES "quickjs")
     out/qjs_event.h
     out/qjs_event_target.cc
     out/qjs_event_target.h
+    out/event_type_names.h
+    out/event_type_names.cc
     )
 
   # Quickjs use __builtin_frame_address() to get stack pointer, we should add follow options to get it work with -O2

bridge/scripts/code_generator/bin/code_generator.js

@@ -5,8 +5,11 @@ const packageJSON = require('../package.json');
 const path = require('path');
 const glob = require('glob');
 const fs = require('fs');
-const { Blob } = require('../dist/blob');
-const { analyzer } = require('../dist/analyzer');
+const { IDLBlob } = require('../dist/idl/IDLBlob');
+const { JSONBlob } = require('../dist/json/JSONBlob');
+const { Template } = require('../dist/json/template');
+const { analyzer } = require('../dist/idl/analyzer');
+const { generateJSONTemplate } = require('../dist/json/generator');
 
 program
   .version(packageJSON.version)
@@ -25,27 +28,70 @@ if (!path.isAbsolute(dist)) {
   dist = path.join(process.cwd(), dist);
 }
 
-let files = glob.sync("**/*.d.ts", {
-  cwd: source,
-});
+function genCodeFromTypeDefine() {
+  // Generate code from type defines.
+  let files = glob.sync("**/*.d.ts", {
+    cwd: source,
+  });
 
-let blobs = files.map(file => {
-  let filename = 'qjs_' + file.split('/').slice(-1)[0].replace('.d.ts', '');
-  let implement = file.replace(path.join(__dirname, '../../')).replace('.d.ts', '');
-  return new Blob(path.join(source, file), dist, filename, implement);
-});
+  let blobs = files.map(file => {
+    let filename = 'qjs_' + file.split('/').slice(-1)[0].replace('.d.ts', '');
+    let implement = file.replace(path.join(__dirname, '../../')).replace('.d.ts', '');
+    return new IDLBlob(path.join(source, file), dist, filename, implement);
+  });
 
-for (let i = 0; i < blobs.length; i ++) {
-  let b = blobs[i];
-  let result = analyzer(b);
+  for (let i = 0; i < blobs.length; i ++) {
+    let b = blobs[i];
+    let result = analyzer(b);
 
-  if (!fs.existsSync(b.dist)) {
-    fs.mkdirSync(b.dist, {recursive: true});
+    if (!fs.existsSync(b.dist)) {
+      fs.mkdirSync(b.dist, {recursive: true});
+    }
+
+    let genFilePath = path.join(b.dist, b.filename);
+
+    fs.writeFileSync(genFilePath + '.h', result.header);
+    fs.writeFileSync(genFilePath + '.cc', result.source);
   }
+}
+
+// Generate code from json data.
+function genCodeFromJSONData() {
+  let jsonFiles = glob.sync('**/*.json', {
+    cwd: source
+  });
+  let templateFiles = glob.sync('**/*.tpl', {
+    cwd: path.join(__dirname, '../static')
+  });
 
-  let genFilePath = path.join(b.dist, b.filename);
+  let blobs = jsonFiles.map(file => {
+    let filename = file.split('/').slice(-1)[0].replace('.json', '');
+    return new JSONBlob(path.join(source, file), dist, filename);
+  });
 
-  fs.writeFileSync(genFilePath + '.h', result.header);
-  fs.writeFileSync(genFilePath + '.cc', result.source);
+  let templates = templateFiles.map(template => {
+    let filename = template.split('/').slice(-1)[0].replace('.tpl', '');
+    return new Template(path.join(path.join(__dirname, '../static'), template), filename);
+  });
+
+  for (let i = 0; i < blobs.length; i ++) {
+    let blob = blobs[i];
+    blob.json.metadata.templates.forEach((targetTemplate) => {
+      let targetTemplateHeaderData = templates.find(t => t.filename === targetTemplate + '.h');
+      let targetTemplateBodyData = templates.find(t => t.filename === targetTemplate + '.h');
+      let result = generateJSONTemplate(blobs[i], targetTemplateHeaderData, targetTemplateBodyData);
+      let dist = blob.dist;
+
+      if (targetTemplate === 'qjs_atom') {
+        dist = path.join(__dirname, '../../../third_party/quickjs')
+      }
+
+      let genFilePath = path.join(dist, blob.filename);
+      fs.writeFileSync(genFilePath + '.h', result.header);
+      result.source && fs.writeFileSync(genFilePath + '.cc', result.source);
+    });
+  }
 }
 
+// genCodeFromTypeDefine();
+genCodeFromJSONData();

bridge/scripts/code_generator/src/generator.ts

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import {ClassObject, FunctionObject} from "./declaration";
 
-export class Blob {
+export class IDLBlob {
   raw: string;
   dist: string;
   source: string;

bridge/scripts/code_generator/src/blob.ts renamed to bridge/scripts/code_generator/src/idl/IDLBlob.ts

@@ -1,5 +1,5 @@
 import ts, {HeritageClause, ScriptTarget, VariableStatement} from 'typescript';
-import {Blob} from './blob';
+import {IDLBlob} from './IDLBlob';
 import {
   ClassObject,
   FunctionArguments,
@@ -10,7 +10,7 @@ import {
 } from './declaration';
 import {generatorSource} from './generator';
 
-export function analyzer(blob: Blob) {
+export function analyzer(blob: IDLBlob) {
   let code = blob.raw;
   const sourceFile = ts.createSourceFile(blob.source, blob.raw, ScriptTarget.ES2020);
   blob.objects = sourceFile.statements.map(statement => walkProgram(statement)).filter(o => {

bridge/scripts/code_generator/src/analyzer.ts renamed to bridge/scripts/code_generator/src/idl/analyzer.ts

@@ -1,9 +1,9 @@
 import {ClassObject, FunctionObject, PropsDeclaration} from "./declaration";
 import {uniqBy, snakeCase} from "lodash";
-import {Blob} from "./blob";
+import {IDLBlob} from "./IDLBlob";
 import {addIndent, getClassName} from "./utils";
 
-function generateInterfaceAdditionalHeader(blob: Blob, object: any): [string, string, string] {
+function generateInterfaceAdditionalHeader(blob: IDLBlob, object: any): [string, string, string] {
   if (!(object instanceof ClassObject)) {
     return ['', '', ''];
   }
@@ -27,7 +27,7 @@ function generateInterfaceAdditionalHeader(blob: Blob, object: any): [string, st
   ];
 }
 
-export function generateCppHeader(blob: Blob) {
+export function generateCppHeader(blob: IDLBlob) {
   let classObject = blob.objects.find(object => object instanceof ClassObject);
   let interfaceDefines = generateInterfaceAdditionalHeader(blob, classObject);
   let haveInterfaceBase = !!classObject;

bridge/scripts/code_generator/src/declaration.ts renamed to bridge/scripts/code_generator/src/idl/declaration.ts

@@ -1,4 +1,4 @@
-import {Blob} from "./blob";
+import {IDLBlob} from "./IDLBlob";
 import {
   ClassObject,
   FunctionArguments,
@@ -85,7 +85,7 @@ function generateCallMethodName(name: string) {
   return name;
 }
 
-function generateOptionalInitBody(blob: Blob, declare: FunctionDeclaration, argument: FunctionArguments, argsIndex: number, previousArguments: string[], options: GenFunctionBodyOptions) {
+function generateOptionalInitBody(blob: IDLBlob, declare: FunctionDeclaration, argument: FunctionArguments, argsIndex: number, previousArguments: string[], options: GenFunctionBodyOptions) {
   let call = '';
   let returnValueAssignment = '';
   if (declare.returnType[0] != FunctionArgumentType.void) {
@@ -110,7 +110,7 @@ if (argc <= ${argsIndex + 1}) {
 }`;
 }
 
-function generateFunctionCallBody(blob: Blob, declaration: FunctionDeclaration, options: GenFunctionBodyOptions = {isConstructor: false, isInstanceMethod: false}) {
+function generateFunctionCallBody(blob: IDLBlob, declaration: FunctionDeclaration, options: GenFunctionBodyOptions = {isConstructor: false, isInstanceMethod: false}) {
   let minimalRequiredArgc = 0;
   declaration.args.forEach(m => {
     if (m.required) minimalRequiredArgc++;
@@ -157,14 +157,14 @@ ${optionalArgumentsInit.join('\n')}
 `;
 }
 
-function generateGlobalFunctionSource(blob: Blob, object: FunctionObject) {
+function generateGlobalFunctionSource(blob: IDLBlob, object: FunctionObject) {
   let body = generateFunctionBody(blob, object.declare);
   return `static JSValue ${object.declare.name}(JSContext* ctx, JSValueConst this_val, int argc, JSValueConst* argv) {
 ${body}
 }`;
 }
 
-function generateReturnValueInit(blob: Blob, type: ParameterType[], options: GenFunctionBodyOptions = {isConstructor: false, isInstanceMethod: false}) {
+function generateReturnValueInit(blob: IDLBlob, type: ParameterType[], options: GenFunctionBodyOptions = {isConstructor: false, isInstanceMethod: false}) {
   if (type[0] == FunctionArgumentType.void) return '';
 
   if (options.isConstructor) {
@@ -180,7 +180,7 @@ function generateReturnValueInit(blob: Blob, type: ParameterType[], options: Gen
   return `Converter<${generateTypeConverter(type)}>::ImplType return_value;`;
 }
 
-function generateReturnValueResult(blob: Blob, type: ParameterType[], options: GenFunctionBodyOptions = {isConstructor: false, isInstanceMethod: false}): string {
+function generateReturnValueResult(blob: IDLBlob, type: ParameterType[], options: GenFunctionBodyOptions = {isConstructor: false, isInstanceMethod: false}): string {
   if (type[0] == FunctionArgumentType.void) return 'JS_NULL';
   if (options.isConstructor) {
     return `return_value->ToQuickJS()`;
@@ -199,7 +199,7 @@ function generateReturnValueResult(blob: Blob, type: ParameterType[], options: G
 
 type GenFunctionBodyOptions = {isConstructor?: boolean, isInstanceMethod?: boolean};
 
-function generateFunctionBody(blob: Blob, declare: FunctionDeclaration, options: GenFunctionBodyOptions = {isConstructor: false, isInstanceMethod : false}) {
+function generateFunctionBody(blob: IDLBlob, declare: FunctionDeclaration, options: GenFunctionBodyOptions = {isConstructor: false, isInstanceMethod : false}) {
   let paramCheck = generateMethodArgumentsCheck(declare);
   let callBody = generateFunctionCallBody(blob, declare, options);
   let returnValueInit = generateReturnValueInit(blob, declare.returnType, options);
@@ -222,22 +222,22 @@ ${addIndent(callBody, 4)}
 `;
 }
 
-function generateClassConstructorCallback(blob: Blob, declare: FunctionDeclaration) {
+function generateClassConstructorCallback(blob: IDLBlob, declare: FunctionDeclaration) {
   return `JSValue QJS${getClassName(blob)}::ConstructorCallback(JSContext* ctx, JSValue func_obj, JSValue this_val, int argc, JSValue* argv, int flags) {
 ${generateFunctionBody(blob, declare, {isConstructor: true})}
 }
 `;
 }
 
-function generatePropertyGetterCallback(blob: Blob, prop: PropsDeclaration) {
+function generatePropertyGetterCallback(blob: IDLBlob, prop: PropsDeclaration) {
   return `static JSValue ${prop.name}AttributeGetCallback(JSContext* ctx, JSValueConst this_val, int argc, JSValueConst* argv) {
   auto* ${blob.filename} = toScriptWrappable<${getClassName(blob)}>(this_val);
   assert(${blob.filename} != nullptr);
   return Converter<${generateTypeConverter(prop.type)}>::ToValue(ctx, ${blob.filename}->${prop.name}());
 }`;
 }
 
-function generatePropertySetterCallback(blob: Blob, prop: PropsDeclaration) {
+function generatePropertySetterCallback(blob: IDLBlob, prop: PropsDeclaration) {
   return `static JSValue ${prop.name}AttributeSetCallback(JSContext* ctx, JSValueConst this_val, int argc, JSValueConst* argv) {
   auto* ${blob.filename} = toScriptWrappable<${getClassName(blob)}>(this_val);
   ExceptionState exception_state;
@@ -249,15 +249,15 @@ function generatePropertySetterCallback(blob: Blob, prop: PropsDeclaration) {
 }`;
 }
 
-function generateMethodCallback(blob: Blob, methods: FunctionDeclaration[]): string[] {
+function generateMethodCallback(blob: IDLBlob, methods: FunctionDeclaration[]): string[] {
   return methods.map(method => {
     return `static JSValue ${method.name}(JSContext* ctx, JSValueConst this_val, int argc, JSValueConst* argv) {
     ${ generateFunctionBody(blob, method, {isInstanceMethod: true}) }
 }`;
   });
 }
 
-function generateClassSource(blob: Blob, object: ClassObject) {
+function generateClassSource(blob: IDLBlob, object: ClassObject) {
   let constructorCallback = '';
   if (object.construct) {
     constructorCallback = generateClassConstructorCallback(blob, object.construct);
@@ -281,7 +281,7 @@ function generateClassSource(blob: Blob, object: ClassObject) {
   ].join('\n');
 }
 
-function generateInstallGlobalFunctions(blob: Blob, installList: string[]) {
+function generateInstallGlobalFunctions(blob: IDLBlob, installList: string[]) {
   return `void QJS${getClassName(blob)}::InstallGlobalFunctions(ExecutingContext* context) {
   std::initializer_list<MemberInstaller::FunctionConfig> functionConfig {
     ${installList.join(',\n')}
@@ -291,7 +291,7 @@ function generateInstallGlobalFunctions(blob: Blob, installList: string[]) {
 }`;
 }
 
-function generateConstructorInstaller(blob: Blob) {
+function generateConstructorInstaller(blob: IDLBlob) {
   return `void QJS${getClassName(blob)}::InstallConstructor(ExecutingContext* context) {
   const WrapperTypeInfo* wrapperTypeInfo = GetWrapperTypeInfo();
   JSValue constructor = context->contextData()->constructorForType(wrapperTypeInfo);
@@ -303,7 +303,7 @@ function generateConstructorInstaller(blob: Blob) {
 }`;
 }
 
-function generatePrototypeMethodsInstaller(blob: Blob, installList: string[]) {
+function generatePrototypeMethodsInstaller(blob: IDLBlob, installList: string[]) {
   return `void QJS${getClassName(blob)}::InstallPrototypeMethods(ExecutingContext* context) {
   const WrapperTypeInfo* wrapperTypeInfo = GetWrapperTypeInfo();
   JSValue prototype = context->contextData()->prototypeForType(wrapperTypeInfo);
@@ -317,7 +317,7 @@ function generatePrototypeMethodsInstaller(blob: Blob, installList: string[]) {
 `;
 }
 
-function generatePrototypePropsInstaller(blob: Blob, installList: string[]) {
+function generatePrototypePropsInstaller(blob: IDLBlob, installList: string[]) {
   return `void QJS${getClassName(blob)}::InstallPrototypeProperties(ExecutingContext* context) {
   const WrapperTypeInfo* wrapperTypeInfo = GetWrapperTypeInfo();
   JSValue prototype = context->contextData()->prototypeForType(wrapperTypeInfo);
@@ -331,7 +331,7 @@ function generatePrototypePropsInstaller(blob: Blob, installList: string[]) {
 `;
 }
 
-export function generateCppSource(blob: Blob) {
+export function generateCppSource(blob: IDLBlob) {
   let functionInstallList: string[] = [];
   let classMethodsInstallList: string[] = [];
   let classPropsInstallList: string[] = [];

bridge/scripts/code_generator/src/generate_header.ts renamed to bridge/scripts/code_generator/src/idl/generateHeader.ts

@@ -0,0 +1,12 @@
+import {IDLBlob} from './IDLBlob';
+import {generateCppHeader} from "./generateHeader";
+import {generateCppSource} from "./generateSource";
+
+export function generatorSource(blob: IDLBlob) {
+  let header = generateCppHeader(blob);
+  let source = generateCppSource(blob);
+  return {
+    header,
+    source
+  };
+}

bridge/scripts/code_generator/src/genereate_source.ts renamed to bridge/scripts/code_generator/src/idl/generateSource.ts

@@ -1,4 +1,4 @@
-import {Blob} from './blob';
+import {IDLBlob} from './IDLBlob';
 import {camelCase} from 'lodash';
 
 export function addIndent(str: String, space: number) {
@@ -12,7 +12,7 @@ export function addIndent(str: String, space: number) {
   return lines.join('\n');
 }
 
-export function getClassName(blob: Blob) {
+export function getClassName(blob: IDLBlob) {
   let raw = camelCase(blob.filename[4].toUpperCase() + blob.filename.slice(5));
 
   return `${raw[0].toUpperCase() + raw.slice(1)}`;

bridge/scripts/code_generator/src/idl/generator.ts

@@ -0,0 +1,18 @@
+import {ClassObject, FunctionObject} from "../idl/declaration";
+import fs from "fs";
+
+export class JSONBlob {
+  raw: string;
+  dist: string;
+  source: string;
+  filename: string;
+  json: any;
+
+  constructor(source: string, dist: string, filename: string) {
+    this.source = source;
+    this.raw = fs.readFileSync(source, {encoding: 'utf-8'});
+    this.dist = dist;
+    this.filename = filename;
+    this.json = JSON.parse(this.raw);
+  }
+}