diff --git a/src/gen/analyze/namespace.js b/src/gen/analyze/namespace.js
index 2fec59a83baa89f469acce066488beadd15f3b77..0c99a7509bfda3d702318889d77efa509933bcf3 100644
--- a/src/gen/analyze/namespace.js
+++ b/src/gen/analyze/namespace.js
@@ -13,22 +13,20 @@
 * limitations under the License. 
 */
 const re = require("../tools/re");
-const { print, removeExplains, removeEmptyLine, checkOutBody } = require("../tools/tool");
-const { FuncType, NumberIncrease } = require("../tools/common");
-
+const { removeEmptyLine, checkOutBody } = require("../tools/tool");
 const { analyzeFunction } = require("./function");
 const { analyzeInterface } = require("./interface");
+const { analyzeClass } = require("./class");
+const { NapiLog } = require("../tools/NapiLog");
 
 /**namespace解析 */
 function analyzeNamespace(data) {
     let result = {
         exports: [],
-
         enum: [],
         const: [],
         type: [],
         function: [],
-
         interface: [],
         class: [],
         namespace: [],
@@ -36,44 +34,37 @@ function analyzeNamespace(data) {
     while (data != '\n') {
         let oldData = data
         data = removeEmptyLine(data)
-        let tt = re.match(" *\n*", data)
-        if (tt && tt.regs[0][1] == data.length) break//只剩下空格和回车时，解析完成
-
-        let parseEnumResult = parseEnum(tt, data, result)
+        let matchs = re.match(" *\n*", data)
+        //只剩下空格和回车时，解析完成
+        if (matchs && matchs.regs[0][1] == data.length) break
+        let parseEnumResult = parseEnum(matchs, data, result)
         if (parseEnumResult != null) {
             data = parseEnumResult
         }
-
-        let parseInterResult = parseInterface(tt, data, result)
+        let parseInterResult = parseInterface(matchs, data, result)
         if (parseInterResult != null) {
             data = parseInterResult
         }
-
-        let parseFunctionResult = parseFunction(tt, data, result)
+        let parseFunctionResult = parseFunction(matchs, data, result)
         if (parseFunctionResult != null) {
             data = parseFunctionResult
         }
-
-        let parseTypeResult = parseType(tt, data, result)
+        let parseTypeResult = parseType(matchs, data, result)
         if (parseTypeResult != null) {
             data = parseTypeResult
         }
-
-        let parseClassResult = parseClass(tt, data, result)
+        let parseClassResult = parseClass(matchs, data, result)
         if (parseClassResult != null) {
             data = parseClassResult
         }
-
-        let parseNamespaceResult = parseNamespace(tt, data, result)
+        let parseNamespaceResult = parseNamespace(matchs, data, result)
         if (parseNamespaceResult != null) {
             data = parseNamespaceResult
         }
-
-        data = removeReg(tt, data, result)
+        data = removeReg(matchs, data, result)
         if (oldData == data) {
-            print("\nvvv 解析Namespace失败 vvv")
-            print("[", data.substring(0, data.length > 128 ? 128 : data.length), "]")
-            print("^^^ 解析Namespace失败 ^^^\n")
+            NapiLog.logError("解析Namespace失败");
+            NapiLog.logError("[", data.substring(0, data.length > 128 ? 128 : data.length), "]");
             break;
         }
     }
@@ -97,96 +88,102 @@ function parseNamespace(tt, data, result) {
     return data
 }
 
-function parseClass(tt, data, result) {
-    tt = re.match("(export )*class ([a-zA-Z]+) (extends [a-zA-Z]+ )*(implements [a-zA-Z]+ )*({)", data)
-    if (tt) {
-        let className = re.getReg(data, tt.regs[2])
-        let classBody = checkOutBody(data, tt.regs[5][0], null, true)
+function parseClass(matchs, data, result) {
+    matchs = re.match("(export )*class ([a-zA-Z]+) (extends [a-zA-Z]+ )*(implements [a-zA-Z]+ )*({)", data)
+    if (matchs) {
+        let className = re.getReg(data, matchs.regs[2])
+        let classBody = checkOutBody(data, matchs.regs[5][0], null, true)
         result.class.push({
             name: className,
-            body: classBody
+            body: analyzeClass(classBody.substring(1, classBody.length - 1)),
+            functiontType: classBody.indexOf('static') > 0 ? 'static' : ''
         })
-        data = data.substring(tt.regs[5][0] + classBody.length + 2, data.length)
-        if (tt.regs[1][0] != -1) {
+        data = data.substring(matchs.regs[5][0] + classBody.length + 2, data.length)
+        if (matchs.regs[1][0] != -1) {
             result.exports.push(className)
         }
     }
     return data
 }
 
-function parseEnum(tt, data, result) {
-    tt = re.match("(export )*enum *([A-Za-z]+) *({)", data)
-    if (tt != null) {
-        let enumName = re.getReg(data, tt.regs[2]);
-        let enumBody = checkOutBody(data, tt.regs[3][0], null, null)
+function parseEnum(matchs, data, result) {
+    matchs = re.match("(export )*enum *([A-Za-z]+) *({)", data)
+    if (matchs != null) {
+        let enumName = re.getReg(data, matchs.regs[2]);
+        let enumBody = checkOutBody(data, matchs.regs[3][0], null, null)
         result.enum.push({
             name: enumName,
-            body: enumBody.substring(1, -1)
         })
-        data = data.substring(tt.regs[3][0] + enumBody.length)
-        if (tt.regs[1][0] != -1) {
+        data = data.substring(matchs.regs[3][0] + enumBody.length)
+        if (matchs.regs[1][0] != -1) {
             result.exports.push(enumName)
         }
     }
 
-    tt = re.match("(export )*const ([a-zA-Z_]+) *[:=]{1} ([a-zA-Z0-9]+);", data)
-    if (tt) {
-        let constName = re.getReg(data, tt.regs[1])
+    matchs = re.match("(export )*const ([a-zA-Z_]+) *[:=]{1} ([a-zA-Z0-9]+);", data)
+    if (matchs) {
+        let constName = re.getReg(data, matchs.regs[1])
         result.const.push({
             name: constName,
-            body: re.getReg(data, tt.regs[2])
+            body: re.getReg(data, matchs.regs[2])
         })
-        data = re.removeReg(data, tt.regs[0])
-        if (tt.regs[1][0] != -1) {
+        data = re.removeReg(data, matchs.regs[0])
+        if (matchs.regs[1][0] != -1) {
             result.exports.push(constName)
         }
     }
     return data
 }
 
-function parseType(tt, data, result) {
-    tt = re.match("(export )*type ([a-zA-Z]+) = *([\\(\\):=a-zA-Z<> |\n']+);", data)
-    if (tt) {
-        let typeName = re.getReg(data, tt.regs[2]);
+function parseType(matchs, data, result) {
+    matchs = re.match("(export )*type ([a-zA-Z]+) = *([\\(\\):=a-zA-Z<> |\n']+);", data)
+    if (matchs) {
+        let typeName = re.getReg(data, matchs.regs[2]);
         result.type.push({
             name: typeName,
-            body: re.getReg(data, tt.regs[3])
+            body: re.getReg(data, matchs.regs[3])
         })
-        data = re.removeReg(data, tt.regs[0])
-        if (tt.regs[1][0] != -1) {
+        data = re.removeReg(data, matchs.regs[0])
+        if (matchs.regs[1][0] != -1) {
             result.exports.push(typeName)
         }
     }
 
-    tt = re.match("(export )*type ([a-zA-Z]+) = ({)", data)
-    if (tt) {
-        let typeName = re.getReg(data, tt.regs[2]);
-        let typeBody = checkOutBody(data, tt.regs[3][0], null, true)
+    matchs = re.match("(export )*type ([a-zA-Z]+) = ({)", data)
+    if (matchs) {
+        let typeName = re.getReg(data, matchs.regs[2]);
+        let typeBody = checkOutBody(data, matchs.regs[3][0], null, true)
         result.type.push({
             name: typeName,
             body: typeBody
         })
-        data = data.substring(tt.regs[3][0] + typeBody.length + 2, data.length)
-        if (tt.regs[1][0] != -1) {
+        data = data.substring(matchs.regs[3][0] + typeBody.length + 2, data.length)
+        if (matchs.regs[1][0] != -1) {
             result.exports.push(typeName)
         }
     }
     return data
 }
 
-function parseFunction(tt, data, result) {
-    tt = re.match("(export )*function ([A-Za-z0-9_]+) *(\\()", data)
-    if (tt) {
-        let funcName = re.getReg(data, tt.regs[2])
-        let funcValue = checkOutBody(data, tt.regs[3][0], ["(", ")"], null)
-        let funcRet = checkOutBody(data.substring(tt.regs[3][0] + funcValue.length), 0, ["", "\n"], null)
-
-        data = data.substring(tt.regs[3][0] + funcValue.length + funcRet.length)
-        let tt2 = re.match(" *: *([A-Za-z0-9_<>{}:, .=]+);*", funcRet)
-        if (tt2) {
-            funcRet = re.getReg(funcRet, tt2.regs[1])
-        }
-        else {//maybe error
+function parseFunction(matchs, data, result) {
+    matchs = re.match("(export )*function (\\$*[A-Za-z0-9_]+) *(\\()", data)
+    if (null == matchs) {
+        matchs = re.match("(export )*function (static )*(\\$*[A-Za-z0-9_]+) *(\\()", data)
+    }
+    if (matchs) {
+        let funcName = re.getReg(data,
+            matchs.regs.length == 5 ? [matchs.regs[2][0], matchs.regs[3][1]] : matchs.regs[2])
+        let funcValue = checkOutBody(data,
+            matchs.regs.length == 5 ? matchs.regs[4][0] : matchs.regs[3][0], ["(", ")"], null)
+        let funcRet = checkOutBody(data.substring(matchs.regs.length == 5 ?
+            matchs.regs[4][0] : matchs.regs[3][0] + funcValue.length), 0, ["", "\n"], null)
+        data = data.substring(matchs.regs.length == 5 ?
+            matchs.regs[4][0] : matchs.regs[3][0] + funcValue.length + funcRet.length)
+        let matchFunc = re.match(" *: *([A-Za-z0-9_<>{}:, .=]+);*", funcRet)
+        if (matchFunc) {
+            funcRet = re.getReg(funcRet, matchFunc.regs[1])
+        }
+        else {
             funcRet = "void"
         }
 
@@ -194,46 +191,46 @@ function parseFunction(tt, data, result) {
         if (funcDetail != null)
             result.function.push(funcDetail)
 
-        if (tt.regs[1][0] != -1) {
+        if (matchs.regs[1][0] != -1) {
             result.exports.push(funcName)
         }
     }
     return data
 }
 
-function parseInterface(tt, data, result) {
-    tt = re.match("(export )*interface ([A-Za-z_0-9]+)(<T>)* (extends [a-zA-Z]+ )*({)", data)
-    if (tt) {
-        let interfaceName = re.getReg(data, tt.regs[2])
-        let interfaceBody = checkOutBody(data, tt.regs[5][0], null, null)
+function parseInterface(matchs, data, result) {
+    matchs = re.match("(export )*interface ([A-Za-z_0-9]+)(<T>)* (extends [a-zA-Z]+ )*({)", data)
+    if (matchs) {
+        let interfaceName = re.getReg(data, matchs.regs[2])
+        let interfaceBody = checkOutBody(data, matchs.regs[5][0], null, null)
         result.interface.push({
             name: interfaceName,
             body: analyzeInterface(interfaceBody.substring(1, interfaceBody.length - 1))
         })
-        data = data.substring(tt.regs[5][0] + interfaceBody.length, data.length)
-        if (tt.regs[1][0] != -1) {
+        data = data.substring(matchs.regs[5][0] + interfaceBody.length, data.length)
+        if (matchs.regs[1][0] != -1) {
             result.exports.push(interfaceName)
         }
     }
     return data
 }
 
-function removeReg(tt, data, result) {
-    tt = re.match("export { ([a-zA-Z]+) };", data)
-    if (tt) {
-        let exportName = re.getReg(data, tt.regs[1])
+function removeReg(matchs, data, result) {
+    matchs = re.match("export { ([a-zA-Z]+) };", data)
+    if (matchs) {
+        let exportName = re.getReg(data, matchs.regs[1])
         result.exports.push(exportName)
-        data = re.removeReg(data, tt.regs[0])
+        data = re.removeReg(data, matchs.regs[0])
     }
 
-    tt = re.match("export import [a-zA-Z]+ = [a-zA-Z\\.]+;", data)
-    if (tt) {
-        data = re.removeReg(data, tt.regs[0])
+    matchs = re.match("export import [a-zA-Z]+ = [a-zA-Z\\.]+;", data)
+    if (matchs) {
+        data = re.removeReg(data, matchs.regs[0])
     }
 
-    tt = re.match("readonly [a-zA-Z]+: [a-z\\[\\]]+;*", data)
-    if (tt) {
-        data = re.removeReg(data, tt.regs[0])
+    matchs = re.match("readonly [a-zA-Z]+: [a-z\\[\\]]+;*", data)
+    if (matchs) {
+        data = re.removeReg(data, matchs.regs[0])
     }
 
     return data
diff --git a/src/gen/generate/function_async.js b/src/gen/generate/function_async.js
index 77385f22bae9ba98b6f58c6e74c3add1d7633e23..0cf5dc98d03af761d4095b8b9badbb9a31801b94 100644
--- a/src/gen/generate/function_async.js
+++ b/src/gen/generate/function_async.js
@@ -12,7 +12,7 @@
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */
-const { replaceAll, print } = require("../tools/tool");
+const { replaceAll } = require("../tools/tool");
 const { paramGenerate } = require("./param_generate");
 const { returnGenerate } = require("./return_generate");
 
@@ -69,7 +69,7 @@ struct [funcName]_value_struct {[valueIn]
     return result;
 }`
 
-function generateFunctionAsync(func, className) {
+function generateFunctionAsync(func, data, className) {
     let middleFunc = replaceAll(funcAsyncTemplete, "[funcName]", func.name)
     if (className == null) {
         middleFunc = middleFunc.replaceAll("[static_define]", "")
@@ -95,10 +95,10 @@ function generateFunctionAsync(func, className) {
 
     for (let i in func.value) {
         let v = func.value[i]
-        paramGenerate(i, v.name, v.type, param)
+        paramGenerate(i, v.name, v.type, param, data)
     }
 
-    returnGenerate(param.callback.type, param)
+    returnGenerate(param.callback.type, param, data)
 
     middleFunc = replaceAll(middleFunc, "[valueIn]", param.valueIn)//  # 输入参数定义
     middleFunc = replaceAll(middleFunc, "[valueOut]", param.valueOut)//  # 输出参数定义
diff --git a/src/gen/generate/function_direct.js b/src/gen/generate/function_direct.js
index 375ea2d3b16cad89aad951c28e451c5a249150a9..171139885047cb7b661d7d54c5e5d6213e740fcb 100644
--- a/src/gen/generate/function_direct.js
+++ b/src/gen/generate/function_direct.js
@@ -12,7 +12,7 @@
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */
-const { replaceAll, print } = require("../tools/tool");
+const { replaceAll } = require("../tools/tool");
 const { paramGenerate } = require("./param_generate");
 const { returnGenerate } = require("./return_generate");
 
@@ -51,7 +51,7 @@ struct [funcName]_value_struct {[valueIn]
     return result;
 }`
 
-function generateFunctionDirect(func, className) {
+function generateFunctionDirect(func, data, className) {
     let middleFunc = replaceAll(funcDirectTemplete, "[funcName]", func.name)
     if (className == null) {
         middleFunc = middleFunc.replaceAll("[static_define]", "")
@@ -65,7 +65,6 @@ function generateFunctionDirect(func, className) {
     let param = {
         valueIn: "",//定义输入
         valueOut: "",//定义输出
-
         valueCheckout: "",//解析
         valueFill: "",//填充到函数内
         valuePackage: "",//输出参数打包
@@ -74,10 +73,10 @@ function generateFunctionDirect(func, className) {
 
     for (let i in func.value) {
         let v = func.value[i]
-        paramGenerate(i, v.name, v.type, param)
+        paramGenerate(i, v.name, v.type, param, data)
     }
 
-    returnGenerate(func.ret, param)
+    returnGenerate(func.ret, param, data)
 
     middleFunc = replaceAll(middleFunc, "[valueIn]", param.valueIn)//  # 输入参数定义
     middleFunc = replaceAll(middleFunc, "[valueOut]", param.valueOut)//  # 输出参数定义
diff --git a/src/gen/generate/function_sync.js b/src/gen/generate/function_sync.js
index a03b72a72e498f33dfe90c3a371d6c578fede3fa..f1c4074909c186777358727375ad28307f259436 100644
--- a/src/gen/generate/function_sync.js
+++ b/src/gen/generate/function_sync.js
@@ -12,7 +12,7 @@
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */
-const { replaceAll, print } = require("../tools/tool");
+const { replaceAll } = require("../tools/tool");
 const { paramGenerate } = require("./param_generate");
 const { returnGenerate } = require("./return_generate");
 
@@ -57,7 +57,7 @@ struct [funcName]_value_struct {[valueIn]
     return result;
 }`
 
-function generateFunctionSync(func, className) {
+function generateFunctionSync(func, data, className) {
     let middleFunc = replaceAll(funcSyncTemplete, "[funcName]", func.name)
     if (className == null) {
         middleFunc = middleFunc.replaceAll("[static_define]", "")
@@ -80,7 +80,7 @@ function generateFunctionSync(func, className) {
 
     for (let i in func.value) {
         let v = func.value[i]
-        paramGenerate(i, v.name, v.type, param)
+        paramGenerate(i, v.name, v.type, param, data)
     }
 
     returnGenerate(param.callback.type, param)
diff --git a/src/gen/generate/namespace.js b/src/gen/generate/namespace.js
index 17f16114d0639fe021e4e03f1da256016eafcf95..cc91fe2c62a3f1d33c34d73289f95ac76af0ca8f 100644
--- a/src/gen/generate/namespace.js
+++ b/src/gen/generate/namespace.js
@@ -12,15 +12,14 @@
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */
-const { print } = require("../tools/tool");
 const { generateFunctionDirect } = require("./function_direct");
 const { generateFunctionSync } = require("./function_sync");
 const { generateFunctionAsync } = require("./function_async");
 const { generateInterface } = require("./interface");
 const { FuncType, InterfaceList } = require("../tools/common");
 
+//生成module_middle.cpp、module.h、module.cpp
 function generateNamespace(name, data, inNamespace = "") {
-    //生成module_middle.cpp、module.h、module.cpp
     let implH = ""
     let implCpp = ""
     let middleFunc = ""
@@ -37,7 +36,7 @@ function generateNamespace(name, data, inNamespace = "") {
     }
     for (let i in data.function) {
         let func = data.function[i]
-        let tmp = generateFunction(func)
+        let tmp = generateFunction(func, data)
         middleFunc += tmp[0]
         implH += tmp[1]
         implCpp += tmp[2]
@@ -56,27 +55,31 @@ function generateNamespace(name, data, inNamespace = "") {
     if (inNamespace.length > 0) {
         middleInit += "}"
     }
+    return generateResult(name, implH, implCpp, middleFunc, middleInit)
+}
+
+function generateResult(name, implH, implCpp, middleFunc, middleInit) {
     let result = {
         implH: `namespace %s {%s\n}`.format(name, implH),
         implCpp: `namespace %s {%s}`.format(name, implCpp),
         middleBody: `namespace %s {%s}`.format(name, middleFunc),
         middleInit: middleInit
     }
-    return result
+    return result;
 }
 
-function generateFunction(func) {
+function generateFunction(func, data) {
     let tmp;
     switch (func.type) {
         case FuncType.DIRECT:
-            tmp = generateFunctionDirect(func)
+            tmp = generateFunctionDirect(func, data)
             break;
         case FuncType.SYNC:
-            tmp = generateFunctionSync(func)
+            tmp = generateFunctionSync(func, data)
             break
         case FuncType.ASYNC:
         case FuncType.PROMISE:
-            tmp = generateFunctionAsync(func)
+            tmp = generateFunctionAsync(func, data)
             break
         default:
             return