1 /* 2 * Copyright (c) 2025 Shenzhen Kaihong Digital. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 package gen; 17 18 import grammar.*; 19 import utils.FileUtils; 20 import utils.StringUtils; 21 22 import java.io.File; 23 import java.util.List; 24 import java.util.Locale; 25 import java.util.Map; 26 27 /** 28 * <h3>类名：该类用于xxx</h3> 29 * description ${description} 30 * 31 * @author ${USER} 32 * date 2025-02-28 33 * @since 2025-02-28 34 * @version 1.0 35 */ 36 public class GenNapiCppFile extends GeneratorBase { 37 private static final String NAPI_ENUM_TOKEN = "enum"; 38 private static final String NAPI_CLASS_TOKEN = "class"; 39 private static final String NAPI_STRUCT_TOKEN = "struct"; 40 private static final String NAPI_UNION_TOKEN = "union"; 41 private static final String NAPI_TEMPLATE_TOKEN = "template"; 42 private static final String NAPI_TYPE_NAME_TOKEN = "typename"; 43 private static final String NAPI_STAR_TOKEN = "*"; 44 private static final String NAPI_CHAR_START_TOKEN = "char*"; 45 private static final String NAPI_AUTO_TOKEN = "auto"; 46 private static final String NAPI_EXPORT_TOKEN = "export"; 47 private static final String NAPI_IMPLEMENNAPI_TOKEN = "implements"; 48 private static final String NAPI_EXTENDS_TOKEN = "extends"; 49 private static final String NAPI_CONST_TOKEN = "const"; 50 private static final String NAPI_PRIVATE_TOKEN = "private"; 51 private static final String NAPI_PUBLIC_TOKEN = "public"; 52 private static final String NAPI_INTERFACE_TOKEN = "interface"; 53 private static final String NAPI_PROTECTED_TOKEN = "protected"; 54 private static final String NAPI_STATIC_TOKEN = "static"; 55 private static final String NAPI_ANY_TOKEN = "any"; 56 private static final String NAPI_VOID_TOKEN = "void"; 57 private static final String NAPI_NUMBER_TOKEN = "number"; 58 private static final String NAPI_NEVER_TOKEN = "never"; 59 private static final String NAPI_BOOLEAN_TOKEN = "boolean"; 60 private static final String NAPI_STRING_TOKEN = "string"; 61 private static final String NAPI_UNIQUE_TOKEN = "unique"; 62 private static final String NAPI_SYMBOL_TOKEN = "symbol"; 63 private static final String NAPI_UNDEFINED_TOKEN = "undefined"; 64 private static final String NAPI_OBJECT_TOKEN = "object"; 65 private static final String NAPI_OF_TOKEN = "of"; 66 private static final String NAPI_KEYOF_TOKEN = "keyof"; 67 private static final String NAPI_TYPE_TOKEN = "type"; 68 private static final String NAPI_CONSTRUCTOR_TOKEN = "constructor"; 69 private static final String NAPI_NAMESPACE_TOKEN = "namespace"; 70 private static final String NAPI_REQUIRE_TOKEN = "require"; 71 private static final String NAPI_MODULE_TOKEN = "module"; 72 private static final String NAPI_DECLARE_TOKEN = "declare"; 73 private static final String NAPI_ABSTRACT_TOKEN = "abstract"; 74 private static final String NAPI_DEBUGGER_TOKEN = "debugger"; 75 private static final String NAPI_FUNCTION_TOKEN = "function"; 76 private static final String NAPI_THIS_TOKEN = "this"; 77 private static final String NAPI_WITH_TOKEN = "with"; 78 private static final String NAPI_DEFAULT_TOKEN = "default"; 79 private static final String NAPI_READONLY_TOKEN = "readonly"; 80 private static final String NAPI_ASYNC_TOKEN = "async"; 81 private static final String NAPI_AWAIT_TOKEN = "await"; 82 private static final String NAPI_YIELD_TOKEN = "yield"; 83 private static final String NAPI_NEW_LINE = "\n"; 84 private static final String NAPI_TAB_SPACE = "\t"; 85 private static final String NAPI_BLANK_SPACE = " "; 86 private static final String NAPI_SPLIT = " | "; 87 private static final String NAPI_EQUAL = " = "; 88 private static final String NAPI_COMMA = ","; 89 private static final String NAPI_DOUBLE_QUOTATION = "\""; 90 private static final String NAPI_UNDER_LINE = "_"; 91 private static final String NAPI_SEMICOLON = ";"; 92 private static final String NAPI_COLON = ":"; 93 private static final String NAPI_ELLIPSIS = "..."; 94 private static final String NAPI_DOT = "."; 95 private static final String NAPI_LEFT_BRACE = "{"; 96 private static final String NAPI_RIGHT_BRACE = "}"; 97 private static final String NAPI_LEFT_PARENTHESES = "("; 98 private static final String NAPI_RIGHT_PARENTHESES = ")"; 99 private static final String NAPI_LEFT_SQUARE_BRACKET = "["; 100 private static final String NAPI_RIGHT_SQUARE_BRACKET = "]"; 101 private static final String NAPI_LEFT_ANGLE_BRACKET = "<"; 102 private static final String NAPI_RIGHT_ANGLE_BRACKET = ">"; 103 104 private static final String NAPI_STD_STRING = "std::string"; 105 private static final String NAPI_STD_VECTOR = "std::vector"; 106 private static final String NAPI_STD_LIST = "std::list"; 107 private static final String NAPI_STD_ARRAY = "std::array"; 108 private static final String NAPI_STD_STACK = "std::stack"; 109 private static final String NAPI_STD_QUEUE = "std::queue"; 110 private static final String NAPI_STD_PAIR = "std::pair"; 111 private static final String NAPI_STD_MAP = "std::map"; 112 private static final String NAPI_STD_SET = "std::set"; 113 private static final String NAPI_STD_DEQUE = "std::deque"; 114 private static final String NAPI_STD_MULTIMAP = "std::multimap"; 115 private static final String NAPI_STD_MULTISET = "std::multiset"; 116 117 private static final String NAPI_ASYNC_SUFFIX = "Async"; 118 private static final String NAPI_PROMISE_SUFFIX = "Promise"; 119 private static final String NAPI_STR_SUFFIX = "STR"; 120 private static final String NAPI_FILE_PREFIX = "ag_"; 121 private static final String NAPI_FILE_H_SUFFIX = ".h"; 122 private static final String NAPI_FILE_NAPI_SUFFIX = ".cpp"; 123 private static final String NAPI_FILE_C_SUFFIX = ".c"; 124 private static final String NAPI_STRUCT_SUFFIX = "ST"; 125 126 private static final String NAPI_ENUM_NAME = "NAPI_ENUM_NAME"; 127 private static final String NAPI_ENUM_MEM_LIST = "NAPI_ENUM_MEM_LIST"; 128 private static final String NAPI_ENUM_VAL_LIST = "NAPI_ENUM_VAL_LIST"; 129 private static final String NAPI_ENUM_CNT = "NAPI_ENUM_CNT"; 130 private static final String NAPI_ENUM_ITEM_VALUE = "NAPI_ENUM_ITEM_VALUE"; 131 private static final String NAPI_ENUM_VALUE_INDEX = "i"; 132 private static final String NAPI_ENUM_VALUE_ITER = "values[i]"; 133 private static final String NAPI_CREATE_ENUM_DECLARE = "\n// 创建枚举对象\n" + 134 "napi_value CreateNAPI_ENUM_NAMEEnum(napi_env env) {\n" + 135 "\tnapi_value enum_obj;\n" + 136 "\tnapi_create_object(env, &enum_obj);\n" + 137 "\n" + 138 "\t// 添加枚举成员\n" + 139 "\tconst char* members[] = {NAPI_ENUM_MEM_LIST};\n" + 140 "\tconst int values[] = {NAPI_ENUM_VAL_LIST};\n" + 141 "\tfor (int32_t i = 0; i < NAPI_ENUM_CNT; ++i) {\n" + 142 "\t\tnapi_value value;\n" + 143 "\t\tnapi_create_int32(env, NAPI_ENUM_ITEM_VALUE, &value);\n" + 144 "\t\tnapi_set_named_property(env, enum_obj, members[i], value);\n" + 145 "\t}\n" + 146 "\n" + 147 "\treturn enum_obj;\n" + 148 "}\n"; 149 150 private static final String NAPI_EXPORT_ENUM = "\t// 创建并绑定枚举\n" + 151 "\tnapi_value NAPI_ENUM_NAME_enum = CreateNAPI_ENUM_NAMEEnum(env);\n" + 152 "\tnapi_set_named_property(env, exports, \"NAPI_ENUM_NAME\", NAPI_ENUM_NAME_enum);\n"; 153 154 private static final String NAPI_CLASS_NAME = "NAPI_CLASS_NAME"; 155 private static final String NAPI_CLASS_METHOD_NAME = "NAPI_CLASS_METHOD_NAME"; 156 private static final String NAPI_CLASS_ATTRIBUTE_NAME = "NAPI_CLASS_ATTRIBUTE_NAME"; 157 private static final String NAPI_CONSTRUCTOR_EXPRESSION = "NAPI_CONSTRUCTOR_EXPRESSION"; 158 private static final String NAPI_CONSTRUCTOR_DECLARE = "\n\tJSBIND_CONSTRUCTOR<NAPI_CONSTRUCTOR_PARAMS>();"; 159 private static final String NAPI_CONSTRUCTOR_PARAMS = "NAPI_CONSTRUCTOR_PARAMS"; 160 private static final String NAPI_METHOD_DECLARE = "\n\tJSBIND_METHOD(NAPI_METHOD_NAME, \"NAPI_METHOD_NAME\");" + 161 "\n\tJSBIND_PMETHOD(NAPI_METHOD_NAME, \"NAPI_METHOD_NAMEPromise\");"; 162 private static final String NAPI_METHOD_EXPRESSION = "NAPI_METHOD_EXPRESSION"; 163 private static final String NAPI_METHOD_NAME = "NAPI_METHOD_NAME"; 164 private static final String NAPI_PMETHOD_DECLARE = "\n\tJSBIND_PMETHOD(NAPI_PMETHOD_NAME);"; 165 private static final String NAPI_PMETHOD_EXPRESSION = "NAPI_PMETHOD_EXPRESSION"; 166 private static final String NAPI_PMETHOD_NAME = "NAPI_PMETHOD_NAME"; 167 private static final String NAPI_PROPERTY_DECLARE = "\n\tJSBIND_PROPERTY(NAPI_PROPERTY_NAME);"; 168 private static final String NAPI_PROPERTY_EXPRESSION = "NAPI_PROPERTY_EXPRESSION"; 169 private static final String NAPI_PROPERTY_NAME = "NAPI_PROPERTY_NAME"; 170 171 172 private static final String NAPI_CLASS_CONSTRUCTURE = 173 "\nnapi_value ConstructorNAPI_CLASS_NAME(napi_env env, napi_callback_info info)\n" + 174 "{\n" + 175 "\tnapi_value undefineVar = nullptr, thisVar = nullptr;\n" + 176 "\tnapi_get_undefined(env, &undefineVar);\n" + 177 "\n" + 178 "\tif (napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr) == napi_ok &&" + 179 " thisVar != nullptr) {\n" + 180 "\t\tNAPI_CLASS_NAME *reference = new NAPI_CLASS_NAME();\n" + 181 "\t\tif (napi_wrap(env, thisVar,\n" + 182 "\t\t\treinterpret_cast<void *>(reference), DestructorNAPI_CLASS_NAME, nullptr, nullptr) == napi_ok) {\n" + 183 "\t\t\treturn thisVar;\n" + 184 "\t\t}\n" + 185 "\t\treturn thisVar;\n" + 186 "\t}\n" + 187 "\treturn undefineVar;\n" + 188 "};\n"; 189 private static final String NAPI_CLASS_DESTRUCTURE = 190 "\nvoid DestructorNAPI_CLASS_NAME(napi_env env, void *nativeObject, void *finalize)\n" + 191 "{\n" + 192 "\tdelete reinterpret_cast<NAPI_CLASS_NAME *>(nativeObject);\n" + 193 "};\n"; 194 private static final String NAPI_CLASS_GET_ATTRIBUTE_DECLARE = 195 "\nnapi_value GetNAPI_CLASS_ATTRIBUTE_NAMENAPI_CLASS_NAME(napi_env env, napi_callback_info info)\n" + 196 "{\n" + 197 "\tnapi_value result = nullptr;\n" + 198 "\tnapi_value jsthis;\n" + 199 "\tnapi_status status;\n" + 200 "\tnapi_get_undefined(env, &result);\n" + 201 "\tif (napi_get_cb_info(env, info, nullptr, nullptr, &jsthis, nullptr) != napi_ok) {\n" + 202 "\t\treturn result;\n" + 203 "\t}\n" + 204 "\tNAPI_CLASS_NAME *obj;\n" + 205 "\tstatus = napi_unwrap(env, jsthis, (void **)&obj);\n" + 206 "\n" + 207 "\t// 创建返回对象\n" + 208 "\tNAPI_CLASS_RETURN_VALUE_DECLARE\n" + 209 "\n" + 210 "\treturn result;\n" + 211 "};\n"; 212 private static final String NAPI_CLASS_SET_ATTRIBUTE_DECLARE = 213 "\nnapi_value SetNAPI_CLASS_ATTRIBUTE_NAMENAPI_CLASS_NAME(napi_env env, napi_callback_info info)\n" + 214 "{\n" + 215 "\tnapi_value result = nullptr;\n" + 216 "\tnapi_get_undefined(env, &result);\n" + 217 "\tchar msg[128] = {0};\n" + 218 "\tnapi_value jsthis;\n" + 219 "\tnapi_value msgvalue;\n" + 220 "\tnapi_status status;\n" + 221 "\tsize_t argc = 1, size = 0;\n" + 222 "\tif (napi_get_cb_info(env, info, &argc, &msgvalue, &jsthis, nullptr) != napi_ok) {\n" + 223 "\t\treturn result;\n" + 224 "\t}\n" + 225 "\tNAPI_CLASS_NAME *obj;\n" + 226 "\tstatus = napi_unwrap(env, jsthis, (void **)&obj);\n" + 227 "\t// 获取参数\n" + 228 "\tNAPI_GET_ARGUMENTS_DECLARE\n" + 229 "\tobj->NAPI_CLASS_ATTRIBUTE_NAME = msg;\n" + 230 "\treturn nullptr;\n" + 231 "};\n"; 232 private static final String NAPI_CLASS_METHOD_DECLARE = 233 "\nnapi_value NAPI_CLASS_METHOD_NAMENAPI_CLASS_NAME(napi_env env, napi_callback_info info)\n" + 234 "{\n" + 235 "\tnapi_value result = nullptr;\n" + 236 "\tnapi_value jsthis;\n" + 237 "\tnapi_status status;\n" + 238 "\tnapi_get_undefined(env, &result);\n" + 239 "\t// 获取napi对象\n" + 240 "\tif (napi_get_cb_info(env, info, nullptr, nullptr, &jsthis, nullptr) != napi_ok) {\n" + 241 "\t\treturn result;\n" + 242 "\t}\n" + 243 "\tNAPI_CLASS_NAME *obj;\n" + 244 "\tstatus = napi_unwrap(env, jsthis, (void **)&obj);\n" + 245 "\t\n" + 246 "\t// 获取参数\n" + 247 "\tNAPI_GET_ARGUMENTS_DECLARE" + 248 "\t// 调用原始类方法\n" + 249 "\tNAPI_CLASS_CALL_METHOD_DECLARE\n" + 250 "\t// 创建返回参数\n" + 251 "\tNAPI_CLASS_RETURN_VALUE_DECLARE\n" + 252 "\t}\n" + 253 "\treturn result;\n" + 254 "};\n"; 255 private static final String NAPI_CLASS_METHOD_PROPERTY = "NAPI_CLASS_METHOD_PROPERTY"; 256 private static final String NAPI_CLASS_ATTRIBUTE_PROPERTY = "NAPI_CLASS_ATTRIBUTE_PROPERTY"; 257 private static final String NAPI_CLASS_METHOD_PROPERTY_DECLARE = 258 "\t{\"NAPI_CLASS_METHOD_NAME\", nullptr, NAPI_CLASS_METHOD_NAMENAPI_CLASS_NAME, " + 259 "nullptr, nullptr, nullptr, napi_default, nullptr},\n"; 260 private static final String NAPI_CLASS_ATTRIBUTE_PROPERTY_DECLARE = 261 "\t{\"NAPI_CLASS_ATTRIBUTE_NAME\", nullptr, nullptr, GetNAPI_CLASS_ATTRIBUTE_NAMENAPI_CLASS_NAME, " + 262 "SetNAPI_CLASS_ATTRIBUTE_NAMENAPI_CLASS_NAME, nullptr, napi_default, nullptr},\n"; 263 private static final String NAPI_CLASS_PROPERTY_DECLARE = 264 "\nnapi_property_descriptor NAPI_CLASS_NAMEProps[] = {\n" + 265 "NAPI_CLASS_METHOD_PROPERTY" + 266 "NAPI_CLASS_ATTRIBUTE_PROPERTY" + 267 "};\n"; 268 private static final String NAPI_CLASS_INIT = "\nnapi_value NAPI_CLASS_NAMEIns = nullptr;\n" + 269 "\tif (napi_define_class(env, \"NAPI_CLASS_NAME\", NAPI_AUTO_LENGTH, " + 270 "ConstructorNAPI_CLASS_NAME, nullptr, sizeof(NAPI_CLASS_NAMEProps) / " + 271 "sizeof(NAPI_CLASS_NAMEProps[0]), NAPI_CLASS_NAMEProps, " + 272 "&NAPI_CLASS_NAMEIns) != napi_ok) {\n" + 273 "\t\treturn nullptr;\n" + 274 "\t}\n" + 275 "\tif (napi_set_named_property(env, exports, \"NAPI_CLASS_NAME\", NAPI_CLASS_NAMEIns) != napi_ok) {\n" + 276 "\t\treturn nullptr;\n" + 277 "\t}"; 278 279 private static final String NAPI_FUNCTION_NAME = "NAPI_FUNCTION_NAME"; 280 private static final String NAPI_FUNCTION_DESC_PROPERTY = "NAPI_FUNCTION_DESC_DECLARE"; 281 private static final String NAPI_PARAM_NAME = "NAPI_PARAM_NAME"; 282 private static final String NAPI_PARAM_TYPE = "NAPI_PARAM_TYPE"; 283 private static final String NAPI_PARAM_EXPRESSION = "NAPI_PARAM_EXPRESSION"; 284 private static final String NAPI_GET_ARGUMENTS_DECLARE = "NAPI_GET_ARGUMENTS_DECLARE"; 285 private static final String NAPI_CLASS_CALL_METHOD_DECLARE = "NAPI_CLASS_CALL_METHOD_DECLARE"; 286 private static final String NAPI_CLASS_RETURN_VALUE_DECLARE = "NAPI_CLASS_RETURN_VALUE_DECLARE"; 287 288 private static final String NAPI_FUNCTION_CALL_EXPRESSION = "NAPI_FUNCTION_NAME(NAPI_PARAM_EXPRESSION);"; 289 290 private static final String NAPI_PARAM_CNT = "NAPI_PARAM_CNT"; 291 private static final String NAPI_PARAM_CHECK = 292 "size_t argc = NAPI_PARAM_CNT;" + 293 "\n\tnapi_value args[NAPI_PARAM_CNT] = {nullptr};" + 294 "\n\tnapi_value this_arg;" + 295 "\n\tnapi_get_cb_info(env, info, &argc, args, &this_arg, nullptr);" + 296 "\n\t// 参数校验" + 297 "\n\tif (argc < NAPI_PARAM_CNT) {" + 298 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"argc < NAPI_PARAM_CNT error\");" + 299 "\n\t\tnapi_throw_error(env, \"EINVAL\", \"需要NAPI_PARAM_CNT个参数\");" + 300 "\n\t\treturn nullptr;" + 301 "\n\t};\n\n"; 302 303 private static final String NAPI_FUNCTION_DECLARE = 304 "\nnapi_value NAPI_FUNCTION_NAMENapi(napi_env env, napi_callback_info info)\n" + 305 "{\n" + 306 "\tnapi_value result = nullptr;\n" + 307 "\tnapi_value jsthis;\n" + 308 "\tnapi_status status;\n" + 309 "\tnapi_get_undefined(env, &result);\n" + 310 "\t// 获取参数\n" + 311 "\tNAPI_GET_ARGUMENTS_DECLARE" + 312 "\t// 调用原始类方法\n" + 313 "\tNAPI_CLASS_CALL_METHOD_DECLARE\n" + 314 "\t// 创建返回参数\n" + 315 "\tNAPI_CLASS_RETURN_VALUE_DECLARE\n" + 316 "\treturn result;\n" + 317 "};\n"; 318 319 private static final String NAPI_FUNCTION_DESC_DECLARE = 320 "\t{ \"NAPI_FUNCTION_NAME\", nullptr, NAPI_FUNCTION_NAMENapi, nullptr, " + 321 "nullptr, nullptr, napi_default, nullptr },\n"; 322 323 private static final String NAPI_FUNCTION_INIT = "napi_property_descriptor funcDesc[] = {\n" + 324 "NAPI_FUNCTION_DESC_DECLARE" + 325 "};\n" + 326 "napi_define_properties(env, exports, sizeof(funcDesc) / sizeof(funcDesc[0]), funcDesc);\n"; 327 328 private static final String NAPI_VAL_GET_DECLARE = 329 "\nnapi_value GetNAPI_CLASS_ATTRIBUTE_NAMENAPI_CLASS_NAME(napi_env env, napi_callback_info info)\n" + 330 "{\n" + 331 "\tnapi_value result = nullptr;\n" + 332 "\tnapi_value jsthis;\n" + 333 "\tnapi_status status;\n" + 334 "\tnapi_get_undefined(env, &result);\n" + 335 "\tif (napi_get_cb_info(env, info, nullptr, nullptr, nullptr, nullptr) != napi_ok) {\n" + 336 "\t\treturn result;\n" + 337 "\t}\n" + 338 "\n" + 339 "\t// 创建返回对象\n" + 340 "\tNAPI_CLASS_RETURN_VALUE_DECLARE\n" + 341 "\n" + 342 "\treturn result;\n" + 343 "};\n"; 344 private static final String NAPI_VAL_SET_DECLARE = 345 "\nnapi_value SetNAPI_CLASS_ATTRIBUTE_NAMENAPI_CLASS_NAME(napi_env env, napi_callback_info info)\n" + 346 "{\n" + 347 "\tnapi_value result = nullptr;\n" + 348 "\tnapi_get_undefined(env, &result);\n" + 349 "\tchar msg[128] = {0};\n" + 350 "\tnapi_value jsthis;\n" + 351 "\tnapi_value msgvalue;\n" + 352 "\tnapi_status status;\n" + 353 "\tsize_t argc = 1, size = 0;\n" + 354 "\tif (napi_get_cb_info(env, info, &argc, &msgvalue, nullptr, nullptr) != napi_ok) {\n" + 355 "\t\treturn result;\n" + 356 "\t}\n" + 357 "\t// 获取参数\n" + 358 "\tNAPI_GET_ARGUMENTS_DECLARE\n" + 359 "\tNAPI_CLASS_ATTRIBUTE_NAME = msg;\n" + 360 "\treturn nullptr;\n" + 361 "};\n"; 362 363 private static final String NAPI_ASYNC_DATA_PARAM = "NAPI_ASYNC_DATA_PARAM"; 364 365 private static final String NAPI_RET_TYPE = "NAPI_RET_TYPE"; 366 367 private static final String NAPI_CREATE_RET_TYPE = "NAPI_CREATE_RET_TYPE"; 368 369 private static final String NAPI_ASYNC_DATA = "\nstruct NAPI_FUNCTION_NAMEData {\n" + 370 "\tnapi_async_work work;\t\t\t// 异步工作句柄\n" + 371 "\tnapi_deferred deferred;\t\t\t// Promise句柄（如果使用Promise）\n" + 372 "\tnapi_ref callback_ref;\t\t\t// JS回调引用\n" + 373 "NAPI_ASYNC_DATA_PARAM" + 374 "\tNAPI_RET_TYPE result;\t\t\t// 返回值\n" + 375 "\tnapi_status status;\t\t\t// 执行状态\n" + 376 "};\n"; 377 378 private static final String NAPI_EXECUTE_WORK = "\n// 实际执行计算的线程池任务\n" + 379 "void NAPI_FUNCTION_NAMEExecuteWork(napi_env env, void* data) {\n" + 380 "\tNAPI_FUNCTION_NAMEData* async_data = static_cast<NAPI_FUNCTION_NAMEData*>(data);\n" + 381 "\t// 调用原始类方法\n" + 382 "\tNAPI_CLASS_CALL_METHOD_DECLARE\n" + 383 "\tasync_data->result = res; // 实际计算\n" + 384 "}\n"; 385 386 private static final String NAPI_PROMISE_COMPLETE_WORK = "\n// 计算结果返回给JS事件循环\n" + 387 "void NAPI_FUNCTION_NAMECompleteWork(napi_env env, napi_status status, void* data) {\n" + 388 "\tNAPI_FUNCTION_NAMEData* async_data = static_cast<NAPI_FUNCTION_NAMEData*>(data);\n" + 389 "\n" + 390 "\t// 准备回调参数\n" + 391 "\tnapi_value argv[2] = { nullptr };\n" + 392 "\tif (async_data->status == napi_ok) {\n" + 393 "\t\tNAPI_CREATE_RET_TYPE\n" + 394 "\t\tnapi_get_null(env, &argv[0]);\n" + 395 "\t} else {\n" + 396 "\t\tnapi_value error_msg;\n" + 397 "\t\tnapi_create_string_utf8(env, \"NAPI_FUNCTION_NAME failed\", NAPI_AUTO_LENGTH, &error_msg);\n" + 398 "\t\tnapi_create_error(env, NULL, error_msg, &argv[1]);\n" + 399 "\t\tnapi_get_null(env, &argv[0]);\n" + 400 "\t}\n" + 401 "\n" + 402 "\t// 获取JS回调函数\n" + 403 "\tif (async_data->deferred) {\n" + 404 "\t\tif (status == napi_ok) {\n" + 405 "\t\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"resolve promise\");" + 406 "\t\t\tnapi_resolve_deferred(env, async_data->deferred, argv);\n" + 407 "\t\t} else {\n" + 408 "\t\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"reject promise\");" + 409 "\t\t\tnapi_reject_deferred(env, async_data->deferred, argv);\n" + 410 "\t\t}\n" + 411 "\t}\n" + 412 "\n" + 413 "\t// 清理资源\n" + 414 "\tnapi_delete_async_work(env, async_data->work);\n" + 415 "\tnapi_delete_reference(env, async_data->callback_ref);\n" + 416 "\tdelete async_data;\n" + 417 "};\n"; 418 419 private static final String NAPI_ASYNC_COMPLETE_WORK = "\n// 计算结果返回给JS事件循环\n" + 420 "void NAPI_FUNCTION_NAMECompleteWork(napi_env env, napi_status status, void* data) {\n" + 421 "\tNAPI_FUNCTION_NAMEData* async_data = static_cast<NAPI_FUNCTION_NAMEData*>(data);\n" + 422 "\n" + 423 "\t// 准备回调参数\n" + 424 "\tnapi_value argv[2] = { nullptr };\n" + 425 "\tif (async_data->status == napi_ok) {\n" + 426 "\t\tNAPI_CREATE_RET_TYPE\n" + 427 "\t\tnapi_get_null(env, &argv[0]);\n" + 428 "\t} else {\n" + 429 "\t\tnapi_value error_msg;\n" + 430 "\t\tnapi_create_string_utf8(env, \"NAPI_FUNCTION_NAME failed\", NAPI_AUTO_LENGTH, &error_msg);\n" + 431 "\t\tnapi_create_error(env, NULL, error_msg, &argv[1]);\n" + 432 "\t\tnapi_get_null(env, &argv[0]);\n" + 433 "\t}\n" + 434 "\n" + 435 "\t// 获取JS回调函数\n" + 436 "\tnapi_value callback;\n" + 437 "\tnapi_get_reference_value(env, async_data->callback_ref, &callback);\n" + 438 "\n" + 439 "\t// 调用回调\n" + 440 "\tnapi_value global;\n" + 441 "\tnapi_get_global(env, &global);\n" + 442 "\tnapi_call_function(env, global, callback, 2, argv, nullptr);\n" + 443 "\n" + 444 "\t// 清理资源\n" + 445 "\tnapi_delete_async_work(env, async_data->work);\n" + 446 "\tnapi_delete_reference(env, async_data->callback_ref);\n" + 447 "\tdelete async_data;\n" + 448 "};\n"; 449 450 private String interfaceContent = ""; 451 private String enumContent = ""; 452 private String classContent = ""; 453 private String funcContent = ""; 454 private String structContent = ""; 455 private String typeContent = ""; 456 private String unionContent = ""; 457 private String constContent = ""; 458 459 private final Map<String, String> ts2cppMap = Map.ofEntries( 460 Map.entry("any", "auto"), 461 Map.entry("boolean", "bool"), 462 Map.entry("string", "std::string"), 463 Map.entry("number", "int"), 464 Map.entry("void", "void"), 465 Map.entry("[]", "*") 466 ); 467 468 private final Map<String, String> tsTokenMap = Map.ofEntries( 469 Map.entry("\"", ""), 470 Map.entry("*", ""), 471 Map.entry("&", ""), 472 Map.entry("(", ""), 473 Map.entry(")", "") 474 ); 475 476 private final Map<String, String> getArguMap = Map.ofEntries( 477 Map.entry("bool", "\tnapi_valuetype valuetypeNAPI_PARAM_CNT;" + 478 "\n\tif (napi_typeof(env, args[NAPI_PARAM_CNT], &valuetypeNAPI_PARAM_CNT) != napi_ok) {" + 479 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_typeof error\");" + 480 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error value type\");" + 481 "\n\t\treturn result;" + 482 "\n\t};" + 483 "\n\tif (type != napi_boolean) {" + 484 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_boolean error\");" + 485 "\n\t\tapi_throw_type_error(env, \"ERR_INVALID_ARG_TYPE\", " + 486 "\"第valuetypeNAPI_PARAM_CNT个参数必须是布尔\");" + 487 "\n\t\treturn result;" + 488 "\n\t}" + 489 "\n" + 490 "\n\tbool valueNAPI_PARAM_CNT;\n" + 491 "\n\tif (napi_get_value_bool(env, args[NAPI_PARAM_CNT], &valueNAPI_PARAM_CNT) != napi_ok) {" + 492 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_get_value_double error\");" + 493 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error get value\");" + 494 "\n\t\treturn result;" + 495 "\n\t};\n\n"), 496 Map.entry("string", "\tnapi_valuetype valuetypeNAPI_PARAM_CNT;" + 497 "\n\tif (napi_typeof(env, args[NAPI_PARAM_CNT], &valuetypeNAPI_PARAM_CNT) != napi_ok) {" + 498 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_typeof error\");" + 499 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error value type\");" + 500 "\n\t\treturn result;" + 501 "\n\t};" + 502 "\n\tif (type != napi_string) {" + 503 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_string error\");" + 504 "\n\t\tapi_throw_type_error(env, \"ERR_INVALID_ARG_TYPE\", " + 505 "\"第NAPI_PARAM_CNT个参数必须是字符串\");" + 506 "\n\t\treturn result;" + 507 "\n\t}" + 508 "\n" + 509 "\n\tchar* valueNAPI_PARAM_CNT[MAX_BUFFER_SIZE];" + 510 "\n\tsize_t bufferSize = MAX_BUFFER_SIZE;" + 511 "\n\tsize_t realSize = 0;" + 512 "\n\tif (napi_get_value_string_utf8(env, args[NAPI_PARAM_CNT], " + 513 "&valueNAPI_PARAM_CNT, bufferSize, &realSize) != napi_ok) {" + 514 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", " + 515 "\"napi_get_value_string_utf8 error\");" + 516 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error get value\");" + 517 "\n\t\treturn result;" + 518 "\n\t};\n\n"), 519 Map.entry("number", "\tnapi_valuetype valuetypeNAPI_PARAM_CNT;" + 520 "\n\tif (napi_typeof(env, args[NAPI_PARAM_CNT], &valuetypeNAPI_PARAM_CNT) != napi_ok) {" + 521 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_typeof error\");" + 522 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error value type\");" + 523 "\n\t\treturn result;" + 524 "\n\t};" + 525 "\n\tif (type != napi_number) {" + 526 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_number error\");" + 527 "\n\t\tapi_throw_type_error(env, \"ERR_INVALID_ARG_TYPE\", " + 528 "\"第valuetypeNAPI_PARAM_CNT个参数必须是数字\");" + 529 "\n\t\treturn result;" + 530 "\n\t}" + 531 "\n" + 532 "\n\tint valueNAPI_PARAM_CNT = 0;\n" + 533 "\n\tsize_t bufferSize = MAX_BUFFER_SIZE;" + 534 "\n\tsize_t realSize = 0;" + 535 "\n\tif (napi_get_value_int32(env, args[NAPI_PARAM_CNT], " + 536 "&valueNAPI_PARAM_CNT) != napi_ok) {" + 537 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", " + 538 "\"napi_get_value_int32 error\");" + 539 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error get value\");" + 540 "\n\t\treturn result;" + 541 "\n\t};\n\n"), 542 Map.entry("double", "\tnapi_valuetype valuetypeNAPI_PARAM_CNT;" + 543 "\n\tif (napi_typeof(env, args[NAPI_PARAM_CNT], &valuetypeNAPI_PARAM_CNT) != napi_ok) {" + 544 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_typeof error\");" + 545 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error value type\");" + 546 "\n\t\treturn result;" + 547 "\n\t};" + 548 "\n\tif (type != napi_number) {" + 549 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_number error\");" + 550 "\n\t\tapi_throw_type_error(env, \"ERR_INVALID_ARG_TYPE\", " + 551 "\"第valuetypeNAPI_PARAM_CNT个参数必须是数字\");" + 552 "\n\t\treturn result;" + 553 "\n\t}" + 554 "\n" + 555 "\n\tdouble valueNAPI_PARAM_CNT = 0;\n" + 556 "\n\tsize_t bufferSize = MAX_BUFFER_SIZE;" + 557 "\n\tsize_t realSize = 0;" + 558 "\n\tif (napi_get_value_double(env, args[NAPI_PARAM_CNT], " + 559 "&valueNAPI_PARAM_CNT) != napi_ok) {" + 560 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", " + 561 "\"napi_get_value_double error\");" + 562 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error get value\");" + 563 "\n\t\treturn result;" + 564 "\n\t};\n\n"), 565 Map.entry("object", "\tnapi_valuetype valuetypeNAPI_PARAM_CNT;" + 566 "\n\tif (napi_typeof(env, args[NAPI_PARAM_CNT], &valuetypeNAPI_PARAM_CNT) != napi_ok) {" + 567 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_typeof error\");" + 568 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error value type\");" + 569 "\n\t\treturn result;" + 570 "\n\t};" + 571 "\n\tif (type != napi_object) {" + 572 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_object error\");" + 573 "\n\t\tapi_throw_type_error(env, \"ERR_INVALID_ARG_TYPE\", " + 574 "\"第valuetypeNAPI_PARAM_CNT个参数必须是对象\");" + 575 "\n\t\treturn result;" + 576 "\n\t}" + 577 "\n" + 578 "\n\tobject valueNAPI_PARAM_CNT = 0;\n" + 579 "\n\tif (napi_unwrap(env, jsthis, (void **)&valueNAPI_PARAM_CNT) != napi_ok) {" + 580 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", " + 581 "\"napi_unwrap error\");" + 582 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error get value\");" + 583 "\n\t\treturn result;" + 584 "\n\t};\n\n") 585 ); 586 587 private final Map<String, String> setArguMap = Map.ofEntries( 588 Map.entry("void", ""), 589 Map.entry("bool", 590 "napi_value valueRetNAPI_PARAM_CNT;" + 591 "\n\tif (napi_create_uint32(env, args[NAPI_PARAM_CNT], &valueNAPI_PARAM_CNT) != napi_ok) {" + 592 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_get_value_double error\");" + 593 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error get value\");" + 594 "\n\t\treturn result;" + 595 "\n\t};" + 596 "\n\treturn valueRetNAPI_PARAM_CNT;\n"), 597 Map.entry("string", 598 "napi_value valueRetNAPI_PARAM_CNT;" + 599 "\n\tif (napi_create_string_utf8(env, args[NAPI_PARAM_CNT], " + 600 "realSize, &valueRetNAPI_PARAM_CNT) != napi_ok) {" + 601 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", " + 602 "\"napi_create_string_utf8 error\");" + 603 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error get value\");" + 604 "\n\t\treturn result;" + 605 "\n\t};" + 606 "\n\treturn valueRetNAPI_PARAM_CNT;\n"), 607 Map.entry("number", 608 "napi_value valueRetNAPI_PARAM_CNT;" + 609 "\n\tif (napi_create_int32(env, args[NAPI_PARAM_CNT], " + 610 "&valueRetNAPI_PARAM_CNT) != napi_ok) {" + 611 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", " + 612 "\"napi_create_int32 error\");" + 613 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error get value\");" + 614 "\n\t\treturn result;" + 615 "\n\t};" + 616 "\n\treturn valueRetNAPI_PARAM_CNT;\n"), 617 Map.entry("double", 618 "napi_value valueRetNAPI_PARAM_CNT;" + 619 "\n\tif (napi_create_double(env, args[NAPI_PARAM_CNT], " + 620 "&valueRetNAPI_PARAM_CNT) != napi_ok) {" + 621 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", " + 622 "\"napi_create_double error\");" + 623 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error get value\");" + 624 "\n\t\treturn result;" + 625 "\n\t};" + 626 "\n\treturn valueRetNAPI_PARAM_CNT;\n"), 627 Map.entry("object", 628 "NAPI_PARAM_TYPE *reference = new NAPI_PARAM_TYPE();" + 629 "\n\tif (napi_wrap(env, thisVar, reinterpret_cast<void *>(reference), " + 630 "DesNAPI_PARAM_TYPENAPI_FUNCTION_NAMENAPI_PARAM_CNT, nullptr, " + 631 "nullptr) != napi_ok) {" + 632 "\n\t\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", " + 633 "\"napi_wrap error\");" + 634 "\n\t\tnapi_throw_error(env, \"EINTYPE\", \"error wrap value\");" + 635 "\n\t\treturn result;" + 636 "\n\t};" + 637 "\n\treturn thisVar;\n") 638 ); 639 640 private final Map<String, String> createTypeMap = Map.ofEntries( 641 Map.entry("void", ""), 642 Map.entry("bool", "if (napi_create_uint32(env, async_data->result, &argv[1]) != napi_ok) {\n" + 643 "\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_create_uint32 error\");\n" + 644 "\tnapi_throw_error(env, \"EINTYPE\", \"error napi_create_uint32\");\n" + 645 "\treturn;\n" + 646 "};\n" + 647 "\n" + 648 "if (napi_get_null(env, &argv[0]) != napi_ok) {\n" + 649 "\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_get_null error\");\n" + 650 "\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_get_null error\");\n" + 651 "\tnapi_throw_error(env, \"EINTYPE\", \"error napi_get_null\");\n" + 652 "\treturn;\n" + 653 "};"), 654 Map.entry("string", "if (napi_create_string_utf8(env, async_data->result, &argv[1]) != napi_ok) {\n" + 655 "\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_create_string_utf8 error\");\n" + 656 "\tnapi_throw_error(env, \"EINTYPE\", \"error napi_create_string_utf8\");\n" + 657 "\treturn;\n" + 658 "};\n" + 659 "\n" + 660 "if (napi_get_null(env, &argv[0]) != napi_ok) {\n" + 661 "\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_get_null error\");\n" + 662 "\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_get_null error\");\n" + 663 "\tnapi_throw_error(env, \"EINTYPE\", \"error napi_get_null\");\n" + 664 "\treturn;\n" + 665 "};"), 666 Map.entry("number", "if (napi_create_int32(env, async_data->result, &argv[1]) != napi_ok) {\n" + 667 "\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_create_int32 error\");\n" + 668 "\tnapi_throw_error(env, \"EINTYPE\", \"error napi_create_int32\");\n" + 669 "\treturn;\n" + 670 "};\n" + 671 "\n" + 672 "if (napi_get_null(env, &argv[0]) != napi_ok) {\n" + 673 "\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_get_null error\");\n" + 674 "\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_get_null error\");\n" + 675 "\tnapi_throw_error(env, \"EINTYPE\", \"error napi_get_null\");\n" + 676 "\treturn;\n" + 677 "};"), 678 Map.entry("double", "if (napi_create_double(env, async_data->result, &argv[1]) != napi_ok) {\n" + 679 "\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_create_double error\");\n" + 680 "\tnapi_throw_error(env, \"EINTYPE\", \"error napi_create_double\");\n" + 681 "\treturn;\n" + 682 "};\n" + 683 "\n" + 684 "if (napi_get_null(env, &argv[0]) != napi_ok) {\n" + 685 "\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_get_null error\");\n" + 686 "\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_get_null error\");\n" + 687 "\tnapi_throw_error(env, \"EINTYPE\", \"error napi_get_null\");\n" + 688 "\treturn;\n" + 689 "};"), 690 Map.entry("object", "if (napi_create_object(env, &argv[1]) != napi_ok) {\n" + 691 "\tOH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, \"Log\", \"napi_create_object error\");\n" + 692 "\tnapi_throw_error(env, \"EINTYPE\", \"error napi_create_object\");\n" + 693 "\treturn;\n" + 694 "} else {\n" + 695 "\t// 设置对象的属性\n" + 696 "\tnapi_value name = nullptr;\n" + 697 "\t// 设置属性名为\"name\"\n" + 698 "\tnapi_create_string_utf8(env, \"tag\", NAPI_AUTO_LENGTH, &name);\n" + 699 "\tnapi_value value = nullptr;\n" + 700 "\t// 设置属性值为\"Hello from Node-API!\"\n" + 701 "\tnapi_create_int32(env, async_data->result, &value);\n" + 702 "\t// 将属性设置到对象上\n" + 703 "\tnapi_set_property(env, argv[1], name, value);\n" + 704 "}\n") 705 ); 706 707 /** 708 * 构造函数 709 */ GenNapiCppFile()710 GenNapiCppFile() { 711 712 } 713 714 /** 715 * 将 cpp key 转换成 ts key 716 * 717 * @param cppKey 枚举对象列表 718 * @return ts key 719 */ ts2CppKey(String cppKey)720 private String ts2CppKey(String cppKey) { 721 if (cppKey == null) { 722 return ""; 723 } 724 String retKey = cppKey; 725 for (Map.Entry<String, String> entry : ts2cppMap.entrySet()) { 726 String key = entry.getKey(); 727 String value = entry.getValue(); 728 int ret = cppKey.indexOf(key); 729 if (ret >= 0 && value.contains(NAPI_STAR_TOKEN)) { 730 return cppKey.substring(0, ret) + value; 731 } else if (ret >= 0) { 732 return value; 733 } 734 } 735 return retKey; 736 } 737 738 /** 739 * 将cpp token 替换成对应的dts token 740 * 741 * @param cppKey 语言关键字 742 * @return 替换后字符串 743 */ replaceTsToken(String cppKey)744 private String replaceTsToken(String cppKey) { 745 String retKey = cppKey; 746 for (Map.Entry<String, String> entry : tsTokenMap.entrySet()) { 747 String key = entry.getKey(); 748 String value = entry.getValue(); 749 int ret = retKey.indexOf(key); 750 if (ret >= 0) { 751 retKey = retKey.replace(key, value); 752 } 753 } 754 return retKey; 755 } 756 757 /** 758 * 获得接口内容 759 * 760 * @return 接口内容 761 */ getInterfaceContent()762 public String getInterfaceContent() { 763 return interfaceContent; 764 } 765 766 /** 767 * 获得枚举内容 768 * 769 * @return 枚举内容 770 */ getEnumContent()771 public String getEnumContent() { 772 return enumContent; 773 } 774 775 /** 776 * 获得类内容 777 * 778 * @return 类内容 779 */ getClassContent()780 public String getClassContent() { 781 return classContent; 782 } 783 784 /** 785 * 获得方法内容 786 * 787 * @return 方法内容 788 */ getFuncContent()789 public String getFuncContent() { 790 return funcContent; 791 } 792 793 /** 794 * 获得结构体内容 795 * 796 * @return 结构体内容 797 */ getStructContent()798 public String getStructContent() { 799 return structContent; 800 } 801 802 /** 803 * 获得type内容 804 * 805 * @return type内容 806 */ getTypeContent()807 public String getTypeContent() { 808 return typeContent; 809 } 810 811 /** 812 * 获得联合体内容 813 * 814 * @return 联合体内容 815 */ getUnionContent()816 public String getUnionContent() { 817 return unionContent; 818 } 819 820 /** 821 * 获得常量内容 822 * 823 * @return 常量内容 824 */ getConstContent()825 public String getConstContent() { 826 return constContent; 827 } 828 829 /** 830 * 生成输出内容 831 * 832 * @param po 解析类 833 */ 834 @Override genContent(ParseObj po)835 public void genContent(ParseObj po) { 836 genInterfaceList(po.getInterfaceList()); 837 genEnumList(po.getEnumList()); 838 genClassList(po.getClassList()); 839 genFuncList(po.getFuncList()); 840 genStructList(po.getStructList()); 841 genTypeList(po.getTypeList()); 842 genUnionList(po.getUnionList()); 843 genVarList(po.getVarList()); 844 } 845 846 /** 847 * 生成文件 848 * 849 * @param fileName 文件名 850 * @param filePath 文件路径 851 */ 852 @Override genFile(String filePath, String fileName)853 public void genFile(String filePath, String fileName) { 854 System.out.println("genFile : " + filePath + fileName); 855 String outFileName = filePath + File.separator + NAPI_FILE_PREFIX + 856 fileName.replace(".", "_") + NAPI_FILE_H_SUFFIX; 857 System.out.println("outFileName : " + outFileName); 858 859 FileUtils.createFile(outFileName); 860 861 FileUtils.appendText(outFileName, this.genFileHeader(filePath + File.separator + fileName)); 862 FileUtils.appendText(outFileName, this.constContent); 863 FileUtils.appendText(outFileName, this.enumContent); 864 FileUtils.appendText(outFileName, this.typeContent); 865 FileUtils.appendText(outFileName, this.interfaceContent); 866 FileUtils.appendText(outFileName, this.unionContent); 867 FileUtils.appendText(outFileName, this.funcContent); 868 FileUtils.appendText(outFileName, this.structContent); 869 FileUtils.appendText(outFileName, this.classContent); 870 871 } 872 873 /** 874 * 生成输出内容 875 * 876 * @param iol 接口列表 877 */ 878 @Override genInterfaceList(List<InterfaceObject> iol)879 public void genInterfaceList(List<InterfaceObject> iol) { 880 System.out.println("genInterfaceList" + iol.toString()); 881 }; 882 genCppEnumContent(EnumObj eo)883 private String genCppEnumContent(EnumObj eo) { 884 String enumName = eo.getName(); 885 enumName = !enumName.isEmpty() ? enumName : eo.getAlias(); 886 List<String> memList = eo.getMemberList(); 887 List<String> vaList = eo.getValueList(); 888 int i = 0; 889 String resContent = ""; 890 resContent += NAPI_NEW_LINE + NAPI_ENUM_TOKEN + 891 NAPI_BLANK_SPACE + enumName + NAPI_BLANK_SPACE + NAPI_LEFT_BRACE; 892 for (String memItem : memList) { 893 resContent += NAPI_NEW_LINE + NAPI_TAB_SPACE + memItem; 894 if (vaList.size() > i && !vaList.get(i).isEmpty()) { 895 resContent += NAPI_EQUAL + replaceTsToken(vaList.get(i)) + NAPI_COMMA; 896 } else { 897 resContent += NAPI_COMMA; 898 } 899 i++; 900 } 901 902 resContent = StringUtils.removeLastSpace(resContent); 903 resContent += NAPI_NEW_LINE + NAPI_RIGHT_BRACE + NAPI_SEMICOLON + NAPI_NEW_LINE; 904 905 i = 0; 906 if (vaList.size() > i && !vaList.get(i).isEmpty() && 907 vaList.get(i).contains("\"")) { 908 resContent += NAPI_NEW_LINE + NAPI_CHAR_START_TOKEN + NAPI_BLANK_SPACE + 909 enumName.toLowerCase(Locale.ROOT) + NAPI_UNDER_LINE + NAPI_STR_SUFFIX + 910 NAPI_LEFT_SQUARE_BRACKET + NAPI_RIGHT_SQUARE_BRACKET + NAPI_EQUAL + NAPI_LEFT_BRACE; 911 for (String val : vaList) { 912 resContent += NAPI_NEW_LINE + NAPI_TAB_SPACE + NAPI_LEFT_SQUARE_BRACKET + 913 memList.get(i) + NAPI_RIGHT_SQUARE_BRACKET + NAPI_EQUAL + val + NAPI_COMMA; 914 i++; 915 } 916 resContent = StringUtils.removeLastCharacter(resContent, 1); 917 resContent += NAPI_NEW_LINE + NAPI_RIGHT_BRACE + NAPI_SEMICOLON + NAPI_NEW_LINE; 918 } 919 return resContent; 920 } 921 genNapiEnumContent(EnumObj eo)922 private String genNapiEnumContent(EnumObj eo) { 923 String enumName = eo.getName(); 924 enumName = !enumName.isEmpty() ? enumName : eo.getAlias(); 925 List<String> memList = eo.getMemberList(); 926 String enumNameList = ""; 927 for (String memItem : memList) { 928 enumNameList += NAPI_DOUBLE_QUOTATION + memItem + NAPI_DOUBLE_QUOTATION + NAPI_COMMA + NAPI_BLANK_SPACE; 929 } 930 enumNameList = StringUtils.removeLastCharacter(enumNameList, 2); 931 932 String enumValueList = ""; 933 List<String> valueList = eo.getValueList(); 934 for (String valItem : valueList) { 935 enumValueList += valItem + NAPI_COMMA + NAPI_BLANK_SPACE; 936 } 937 enumValueList = StringUtils.removeLastCharacter(enumValueList, 2); 938 939 String enumDeclare = NAPI_CREATE_ENUM_DECLARE.replace(NAPI_ENUM_NAME, enumName); 940 enumDeclare = enumDeclare.replace(NAPI_ENUM_MEM_LIST, enumNameList); 941 enumDeclare = enumDeclare.replace(NAPI_ENUM_VAL_LIST, enumValueList); 942 enumDeclare = enumDeclare.replace(NAPI_ENUM_ITEM_VALUE, valueList.isEmpty() ? 943 NAPI_ENUM_VALUE_INDEX : NAPI_ENUM_VALUE_ITER); 944 enumDeclare = enumDeclare.replace(NAPI_ENUM_CNT, Integer.toString(memList.size())); 945 String resContent = ""; 946 resContent = enumDeclare + NAPI_EXPORT_ENUM.replace(NAPI_ENUM_NAME, enumName); 947 return resContent; 948 } 949 950 /** 951 * 生成输出内容 952 * 953 * @param eol 枚举列表 954 */ 955 @Override genEnumList(List<EnumObj> eol)956 public void genEnumList(List<EnumObj> eol) { 957 System.out.println("genEnumList" + eol.toString()); 958 959 String resContent = ""; 960 for (EnumObj eo : eol) { 961 resContent += genCppEnumContent(eo); 962 resContent += genNapiEnumContent(eo); 963 } 964 965 this.enumContent = resContent; 966 }; 967 setClassFunc(List<FuncObj> funcList, String content)968 private String setClassFunc(List<FuncObj> funcList, String content) { 969 String tempResContent = content; 970 for (FuncObj funcItem : funcList) { 971 String retValue = funcItem.getRetValue(); 972 retValue = retValue.isEmpty() ? "" : ts2CppKey(retValue) + NAPI_BLANK_SPACE; 973 tempResContent += NAPI_NEW_LINE + NAPI_TAB_SPACE + retValue + 974 replaceTsToken(funcItem.getName()) + NAPI_LEFT_PARENTHESES; 975 List<ParamObj> pol = funcItem.getParamList(); 976 for (ParamObj poItem : pol) { 977 String retType = ts2CppKey(poItem.getType()).isEmpty() ? 978 NAPI_AUTO_TOKEN : ts2CppKey(poItem.getType()); 979 tempResContent += (poItem.getName() == null) ? retType + NAPI_COMMA + NAPI_BLANK_SPACE : 980 retType + NAPI_BLANK_SPACE + replaceTsToken(poItem.getName()) + NAPI_COMMA + NAPI_BLANK_SPACE; 981 } 982 if (!pol.isEmpty()) { 983 tempResContent = StringUtils.removeLastCharacter(tempResContent, 2); 984 } 985 tempResContent += NAPI_RIGHT_PARENTHESES + NAPI_SEMICOLON; 986 } 987 return tempResContent; 988 } 989 genCppClassContent(ClassObj co)990 private String genCppClassContent(ClassObj co) { 991 String className = co.getName(); 992 className = !className.isEmpty() ? className : co.getAlias(); 993 994 String templateStr = !co.getTempList().isEmpty() ? 995 NAPI_TEMPLATE_TOKEN + NAPI_BLANK_SPACE + NAPI_LEFT_ANGLE_BRACKET : ""; 996 for (String teStr : co.getTempList()) { 997 templateStr += NAPI_TYPE_NAME_TOKEN + NAPI_BLANK_SPACE + teStr + NAPI_COMMA + NAPI_BLANK_SPACE; 998 } 999 templateStr = templateStr.length() > 1 ? 1000 StringUtils.removeLastCharacter(templateStr, 2) + NAPI_RIGHT_ANGLE_BRACKET + NAPI_BLANK_SPACE : ""; 1001 1002 List<String> hnList = co.getHeritageNameList(); 1003 String htStr = hnList.size() > 0 ? NAPI_BLANK_SPACE + NAPI_COLON + NAPI_BLANK_SPACE : ""; 1004 for (String hName : hnList) { 1005 htStr += NAPI_PUBLIC_TOKEN + NAPI_BLANK_SPACE + hName + NAPI_COMMA + NAPI_BLANK_SPACE; 1006 } 1007 htStr = htStr.length() > 1 ? StringUtils.removeLastCharacter(htStr, 2) : htStr; 1008 1009 List<String> htempList = co.getHeritageTemplateList(); 1010 String htempStr = htempList.size() > 0 ? NAPI_LEFT_ANGLE_BRACKET : ""; 1011 for (String tempStr : htempList) { 1012 htempStr += tempStr + NAPI_COMMA + NAPI_BLANK_SPACE; 1013 } 1014 htempStr = htempList.size() > 0 ? 1015 StringUtils.removeLastCharacter(htempStr, 2) + NAPI_RIGHT_ANGLE_BRACKET : ""; 1016 String resContent = ""; 1017 resContent += NAPI_NEW_LINE + templateStr + NAPI_CLASS_TOKEN + 1018 NAPI_BLANK_SPACE + className + htStr + htempStr + NAPI_BLANK_SPACE + NAPI_LEFT_BRACE; 1019 List<ParamObj> paList = co.getParamList(); 1020 for (ParamObj paItem : paList) { 1021 String paType = paItem.getType(); 1022 String qualifyStr = paItem.getQualifier() == null || paItem.getQualifier().isEmpty() ? 1023 "" : paItem.getQualifier() + NAPI_BLANK_SPACE; 1024 resContent += NAPI_NEW_LINE + NAPI_TAB_SPACE + qualifyStr + ts2CppKey(paType) + 1025 NAPI_BLANK_SPACE + replaceTsToken(paItem.getName()); 1026 List<String> initVList = paItem.getvList(); 1027 if (!initVList.isEmpty()) { 1028 resContent += NAPI_EQUAL + initVList.get(0) + NAPI_SEMICOLON; 1029 } else { 1030 resContent += NAPI_SEMICOLON; 1031 } 1032 } 1033 1034 resContent = setClassFunc(co.getFuncList(), resContent); 1035 1036 resContent += NAPI_NEW_LINE + NAPI_RIGHT_BRACE + NAPI_SEMICOLON + NAPI_NEW_LINE; 1037 return resContent; 1038 } 1039 genNapiClassContent(ClassObj co)1040 private String genNapiClassContent(ClassObj co) { 1041 String className = co.getName(); 1042 className = !className.isEmpty() ? className : co.getAlias(); 1043 List<FuncObj> funcList = co.getFuncList(); 1044 String classNameList = ""; 1045 String classMethodContent = ""; 1046 String classMethodProperty = ""; 1047 for (FuncObj funcItem : funcList) { 1048 String classMethodStr = NAPI_CLASS_METHOD_DECLARE.replace( 1049 NAPI_CLASS_NAME, className); 1050 classMethodStr = classMethodStr.replace( 1051 NAPI_CLASS_METHOD_NAME, funcItem.getName()); 1052 1053 classMethodStr = genNapiFuncConvert(funcItem, classMethodStr); 1054 classMethodContent += classMethodStr; 1055 1056 String classMethodPropertyStr = NAPI_CLASS_METHOD_PROPERTY_DECLARE.replace( 1057 NAPI_CLASS_METHOD_NAME, funcItem.getName()); 1058 classMethodPropertyStr = classMethodPropertyStr.replace(NAPI_CLASS_NAME, className); 1059 classMethodProperty += classMethodPropertyStr; 1060 } 1061 1062 String classAttributeContent = ""; 1063 String classAttributeProperty = ""; 1064 List<ParamObj> paList = co.getParamList(); 1065 for (ParamObj paItem : paList) { 1066 String getAttributeContent = NAPI_CLASS_GET_ATTRIBUTE_DECLARE.replace( 1067 NAPI_CLASS_ATTRIBUTE_NAME, paItem.getName()); 1068 getAttributeContent = getAttributeContent.replace(NAPI_CLASS_NAME, className); 1069 String setAttributeContent = NAPI_CLASS_SET_ATTRIBUTE_DECLARE.replace( 1070 NAPI_CLASS_ATTRIBUTE_NAME, paItem.getName()); 1071 setAttributeContent = setAttributeContent.replace(NAPI_CLASS_NAME, className); 1072 classAttributeContent += getAttributeContent + setAttributeContent; 1073 1074 String classAttributeStr = NAPI_CLASS_ATTRIBUTE_PROPERTY_DECLARE.replace( 1075 NAPI_CLASS_ATTRIBUTE_NAME, paItem.getName()); 1076 classAttributeStr = classAttributeStr.replace(NAPI_CLASS_NAME, className); 1077 classAttributeProperty += classAttributeStr; 1078 } 1079 1080 1081 String classDeclare = NAPI_CLASS_CONSTRUCTURE.replace(NAPI_CLASS_NAME, className); 1082 classDeclare += NAPI_CLASS_DESTRUCTURE.replace(NAPI_CLASS_NAME, className); 1083 classDeclare += classMethodContent + classAttributeContent; 1084 1085 String classPropertyStr = NAPI_CLASS_PROPERTY_DECLARE.replace(NAPI_CLASS_NAME, className); 1086 classPropertyStr = classPropertyStr.replace(NAPI_CLASS_METHOD_PROPERTY, classMethodProperty); 1087 classPropertyStr = classPropertyStr.replace(NAPI_CLASS_ATTRIBUTE_PROPERTY, classAttributeProperty); 1088 classDeclare += classPropertyStr; 1089 1090 String classInitStr = NAPI_CLASS_INIT.replace(NAPI_CLASS_NAME, className); 1091 classDeclare += classInitStr; 1092 1093 String resContent = ""; 1094 resContent = classDeclare; 1095 return resContent; 1096 } 1097 1098 /** 1099 * 生成输出内容 1100 * 1101 * @param col 类列表 1102 */ 1103 @Override genClassList(List<ClassObj> col)1104 public void genClassList(List<ClassObj> col) { 1105 System.out.println("genClassList" + col.toString()); 1106 1107 String resContent = ""; 1108 for (ClassObj co : col) { 1109 resContent += genCppClassContent(co); 1110 resContent += genNapiClassContent(co); 1111 } 1112 this.classContent = resContent; 1113 }; 1114 genCppFunctionContent(FuncObj fo)1115 private String genCppFunctionContent(FuncObj fo) { 1116 String funcName = fo.getName(); 1117 funcName = !funcName.isEmpty() ? funcName : fo.getAlias(); 1118 List<String> tempList = fo.getTempList(); 1119 String tempStr = tempList.isEmpty() ? "" : NAPI_TEMPLATE_TOKEN + NAPI_LEFT_ANGLE_BRACKET; 1120 for (String teStr : tempList) { 1121 tempStr += NAPI_TYPE_NAME_TOKEN + NAPI_BLANK_SPACE + teStr + NAPI_COMMA + NAPI_BLANK_SPACE; 1122 } 1123 tempStr = tempList.isEmpty() ? "" : 1124 StringUtils.removeLastCharacter(tempStr, 2) + NAPI_RIGHT_ANGLE_BRACKET + NAPI_BLANK_SPACE; 1125 List<ParamObj> paList = fo.getParamList(); 1126 String retValue = ts2CppKey(fo.getRetValue()).isEmpty() ? 1127 "" : ts2CppKey(fo.getRetValue()) + NAPI_BLANK_SPACE; 1128 String resContent = ""; 1129 resContent += NAPI_NEW_LINE + tempStr + retValue + 1130 replaceTsToken(funcName) + NAPI_LEFT_PARENTHESES; 1131 1132 for (ParamObj poItem : paList) { 1133 String paType = ts2CppKey(poItem.getType()).isEmpty() ? 1134 NAPI_AUTO_TOKEN + NAPI_BLANK_SPACE : ts2CppKey(poItem.getType()) + NAPI_BLANK_SPACE; 1135 String paName = poItem.getName(); 1136 String defaultVal = poItem.getStrValue(0); 1137 defaultVal = defaultVal.isEmpty() ? "" : NAPI_EQUAL + defaultVal; 1138 resContent += !paName.isEmpty() ? paType + replaceTsToken(paName) + 1139 defaultVal + NAPI_COMMA + NAPI_BLANK_SPACE : 1140 paType + NAPI_COMMA + NAPI_BLANK_SPACE; 1141 } 1142 if (!paList.isEmpty()) { 1143 resContent = StringUtils.removeLastCharacter(resContent, 2); 1144 } 1145 resContent += NAPI_RIGHT_PARENTHESES + NAPI_SEMICOLON; 1146 return resContent; 1147 } 1148 genGetParam(ParamObj pa, int off)1149 private String genGetParam(ParamObj pa, int off) { 1150 System.out.println("genGetParam : " + pa.getType()); 1151 if (pa.getType() == null) { 1152 return ""; 1153 } 1154 String resContent = getArguMap.get(pa.getType()); 1155 resContent = resContent == null ? "" : resContent; 1156 resContent = resContent.replace(NAPI_PARAM_CNT, Integer.toString(off)); 1157 resContent = resContent.replace(NAPI_PARAM_TYPE, pa.getType()); 1158 return resContent; 1159 }; 1160 genDataParam(ParamObj pa, int off)1161 private String genDataParam(ParamObj pa, int off) { 1162 String name = pa.getName().isEmpty() ? "value" + Integer.toString(off) : pa.getName(); 1163 String type = pa.getType() == null ? NAPI_AUTO_TOKEN : pa.getType(); 1164 return NAPI_TAB_SPACE + type + NAPI_BLANK_SPACE + name + NAPI_SEMICOLON + NAPI_NEW_LINE; 1165 } 1166 genFuncCall(FuncObj fo)1167 private String genFuncCall(FuncObj fo) { 1168 System.out.println("genFuncCall : " + fo.getName()); 1169 return NAPI_FUNCTION_CALL_EXPRESSION.replace(NAPI_FUNCTION_NAME, fo.getName()); 1170 }; 1171 genFuncRet(String retType)1172 private String genFuncRet(String retType) { 1173 System.out.println("genFuncRet : " + retType); 1174 if (retType.isEmpty()) { 1175 return ""; 1176 } 1177 String resContent = setArguMap.get(retType); 1178 if (resContent == null) { 1179 return ""; 1180 } 1181 resContent = resContent.replace(NAPI_PARAM_CNT, Integer.toString(0)); 1182 resContent = resContent.replace(NAPI_PARAM_TYPE, retType); 1183 return resContent; 1184 }; 1185 genNapiFunctionContent(FuncObj fo)1186 private String genNapiFunctionContent(FuncObj fo) { 1187 String funcName = fo.getName(); 1188 funcName = funcName.isEmpty() ? fo.getAlias() : funcName; 1189 funcName = StringUtils.unCapitalFirst(funcName); 1190 1191 String funcGetParamStr = ""; 1192 String funcCallStr = ""; 1193 String funcRetStr = ""; 1194 int i = 0; 1195 for (ParamObj pa : fo.getParamList()) { 1196 funcGetParamStr += genGetParam(pa, i); 1197 i++; 1198 } 1199 funcCallStr += genFuncCall(fo); 1200 funcRetStr += genFuncRet(fo.getRetValue()); 1201 String paCheckStr = NAPI_PARAM_CHECK.replace(NAPI_PARAM_CNT, Integer.toString(fo.getParamList().size())); 1202 String funcDeclareStr = NAPI_FUNCTION_DECLARE.replace(NAPI_FUNCTION_NAME, funcName); 1203 funcDeclareStr = funcDeclareStr.replace(NAPI_GET_ARGUMENTS_DECLARE, paCheckStr + funcGetParamStr); 1204 funcDeclareStr = funcDeclareStr.replace(NAPI_CLASS_CALL_METHOD_DECLARE, funcCallStr); 1205 funcDeclareStr = funcDeclareStr.replace(NAPI_CLASS_RETURN_VALUE_DECLARE, funcRetStr); 1206 1207 String funcPropertyStr = NAPI_FUNCTION_DESC_DECLARE.replace(NAPI_FUNCTION_NAME, 1208 funcName); 1209 String funcInitStr = NAPI_FUNCTION_INIT.replace(NAPI_FUNCTION_DESC_PROPERTY, 1210 funcPropertyStr); 1211 String resContent = ""; 1212 resContent += funcDeclareStr + funcInitStr; 1213 return resContent; 1214 } 1215 genNapiAsyncFunctionContent(FuncObj fo)1216 private String genNapiAsyncFunctionContent(FuncObj fo) { 1217 String funcName = fo.getName(); 1218 funcName = funcName.isEmpty() ? fo.getAlias() : funcName; 1219 funcName = StringUtils.unCapitalFirst(funcName) + NAPI_ASYNC_SUFFIX; 1220 1221 String funcGetParamStr = ""; 1222 String funcCallStr = ""; 1223 String funcRetStr = ""; 1224 String dataParamStr = ""; 1225 String paramListStr = ""; 1226 int i = 0; 1227 for (ParamObj pa : fo.getParamList()) { 1228 funcGetParamStr += genGetParam(pa, i); 1229 dataParamStr += genDataParam(pa, i); 1230 paramListStr += pa.getName() + NAPI_COMMA + NAPI_BLANK_SPACE; 1231 i++; 1232 } 1233 paramListStr = StringUtils.removeLastCharacter(paramListStr, 2); 1234 // create async function template 1235 funcCallStr += genFuncCall(fo); 1236 funcRetStr += genFuncRet(fo.getRetValue()); 1237 1238 // create async data 1239 String retType = fo.getType().isEmpty() ? NAPI_VOID_TOKEN : fo.getType(); 1240 String asyncDataStr = NAPI_ASYNC_DATA.replace(NAPI_FUNCTION_NAME, funcName); 1241 asyncDataStr = asyncDataStr.replace(NAPI_ASYNC_DATA_PARAM, dataParamStr); 1242 asyncDataStr = asyncDataStr.replace(NAPI_RET_TYPE, retType); 1243 1244 // create execute work 1245 String exeWorkStr = NAPI_EXECUTE_WORK.replace(NAPI_FUNCTION_NAME, funcName); 1246 exeWorkStr = exeWorkStr.replace(NAPI_CLASS_CALL_METHOD_DECLARE, funcCallStr); 1247 exeWorkStr = exeWorkStr.replace(NAPI_PARAM_EXPRESSION, paramListStr); 1248 1249 // create complete work 1250 String completeWorkStr = NAPI_ASYNC_COMPLETE_WORK.replace(NAPI_FUNCTION_NAME, funcName); 1251 completeWorkStr = completeWorkStr.replace(NAPI_CREATE_RET_TYPE, funcRetStr); 1252 1253 String paCheckStr = NAPI_PARAM_CHECK.replace(NAPI_PARAM_CNT, Integer.toString(fo.getParamList().size())); 1254 String funcDeclareStr = NAPI_FUNCTION_DECLARE.replace(NAPI_FUNCTION_NAME, funcName); 1255 funcDeclareStr = funcDeclareStr.replace(NAPI_GET_ARGUMENTS_DECLARE, paCheckStr + funcGetParamStr); 1256 funcDeclareStr = funcDeclareStr.replace(NAPI_CLASS_CALL_METHOD_DECLARE, funcCallStr); 1257 funcDeclareStr = funcDeclareStr.replace(NAPI_CLASS_RETURN_VALUE_DECLARE, funcRetStr); 1258 1259 String funcPropertyStr = NAPI_FUNCTION_DESC_DECLARE.replace(NAPI_FUNCTION_NAME, 1260 funcName); 1261 String funcInitStr = NAPI_FUNCTION_INIT.replace(NAPI_FUNCTION_DESC_PROPERTY, 1262 funcPropertyStr); 1263 String resContent = ""; 1264 resContent += asyncDataStr + exeWorkStr + completeWorkStr + funcDeclareStr + funcInitStr; 1265 return resContent; 1266 } 1267 genNapiPromiseFunctionContent(FuncObj fo)1268 private String genNapiPromiseFunctionContent(FuncObj fo) { 1269 String funcName = fo.getName(); 1270 funcName = funcName.isEmpty() ? fo.getAlias() : funcName; 1271 funcName = StringUtils.unCapitalFirst(funcName) + NAPI_PROMISE_SUFFIX; 1272 1273 String funcGetParamStr = ""; 1274 String funcCallStr = ""; 1275 String funcRetStr = ""; 1276 String dataParamStr = ""; 1277 String paramListStr = ""; 1278 int i = 0; 1279 for (ParamObj pa : fo.getParamList()) { 1280 funcGetParamStr += genGetParam(pa, i); 1281 dataParamStr += genDataParam(pa, i); 1282 paramListStr += pa.getName() + NAPI_COMMA + NAPI_BLANK_SPACE; 1283 i++; 1284 } 1285 paramListStr = StringUtils.removeLastCharacter(paramListStr, 2); 1286 // create async function template 1287 funcCallStr += genFuncCall(fo); 1288 funcRetStr += genFuncRet(fo.getRetValue()); 1289 1290 // create async data 1291 String retType = fo.getType().isEmpty() ? NAPI_VOID_TOKEN : fo.getType(); 1292 String asyncDataStr = NAPI_ASYNC_DATA.replace(NAPI_FUNCTION_NAME, funcName); 1293 asyncDataStr = asyncDataStr.replace(NAPI_ASYNC_DATA_PARAM, dataParamStr); 1294 asyncDataStr = asyncDataStr.replace(NAPI_RET_TYPE, retType); 1295 1296 // create execute work 1297 String exeWorkStr = NAPI_EXECUTE_WORK.replace(NAPI_FUNCTION_NAME, funcName); 1298 exeWorkStr = exeWorkStr.replace(NAPI_CLASS_CALL_METHOD_DECLARE, funcCallStr); 1299 exeWorkStr = exeWorkStr.replace(NAPI_PARAM_EXPRESSION, paramListStr); 1300 1301 // create complete work 1302 String completeWorkStr = NAPI_PROMISE_COMPLETE_WORK.replace(NAPI_FUNCTION_NAME, funcName); 1303 completeWorkStr = completeWorkStr.replace(NAPI_CREATE_RET_TYPE, funcRetStr); 1304 1305 String paCheckStr = NAPI_PARAM_CHECK.replace(NAPI_PARAM_CNT, Integer.toString(fo.getParamList().size())); 1306 String funcDeclareStr = NAPI_FUNCTION_DECLARE.replace(NAPI_FUNCTION_NAME, funcName); 1307 funcDeclareStr = funcDeclareStr.replace(NAPI_GET_ARGUMENTS_DECLARE, paCheckStr + funcGetParamStr); 1308 funcDeclareStr = funcDeclareStr.replace(NAPI_CLASS_CALL_METHOD_DECLARE, funcCallStr); 1309 funcDeclareStr = funcDeclareStr.replace(NAPI_CLASS_RETURN_VALUE_DECLARE, funcRetStr); 1310 1311 String funcPropertyStr = NAPI_FUNCTION_DESC_DECLARE.replace(NAPI_FUNCTION_NAME, 1312 funcName); 1313 String funcInitStr = NAPI_FUNCTION_INIT.replace(NAPI_FUNCTION_DESC_PROPERTY, 1314 funcPropertyStr); 1315 String resContent = ""; 1316 resContent += funcDeclareStr + funcInitStr; 1317 return resContent; 1318 } 1319 1320 /** 1321 * 生成输出内容 1322 * 1323 * @param fol 方法列表 1324 */ 1325 @Override genFuncList(List<FuncObj> fol)1326 public void genFuncList(List<FuncObj> fol) { 1327 System.out.println("genFuncList : " + fol.toString()); 1328 String resContent = ""; 1329 for (FuncObj fo : fol) { 1330 resContent += genCppFunctionContent(fo); 1331 resContent += genNapiFunctionContent(fo); 1332 resContent += genNapiAsyncFunctionContent(fo); 1333 resContent += genNapiPromiseFunctionContent(fo); 1334 } 1335 this.funcContent = resContent; 1336 System.out.println("genFuncList : " + resContent); 1337 }; 1338 genCppStructContent(StructObj so)1339 private String genCppStructContent(StructObj so) { 1340 String structName = so.getName(); 1341 structName = !structName.isEmpty() ? structName : so.getAlias(); 1342 1343 String templateStr = !so.getTemplateList().isEmpty() ? 1344 NAPI_TEMPLATE_TOKEN + NAPI_BLANK_SPACE + NAPI_LEFT_ANGLE_BRACKET : ""; 1345 for (String teStr : so.getTemplateList()) { 1346 templateStr += NAPI_TYPE_NAME_TOKEN + NAPI_BLANK_SPACE + teStr + NAPI_COMMA + NAPI_BLANK_SPACE; 1347 } 1348 templateStr = templateStr.length() > 1 ? 1349 StringUtils.removeLastCharacter(templateStr, 2) + 1350 NAPI_RIGHT_ANGLE_BRACKET + NAPI_BLANK_SPACE : ""; 1351 1352 List<ParamObj> paList = so.getMemberList(); 1353 String resContent = ""; 1354 resContent += NAPI_NEW_LINE + templateStr + NAPI_STRUCT_TOKEN + 1355 NAPI_BLANK_SPACE + structName + NAPI_BLANK_SPACE + NAPI_LEFT_BRACE; 1356 1357 for (ParamObj paItem : paList) { 1358 String paType = paItem.getType().isEmpty() ? NAPI_AUTO_TOKEN : paItem.getType(); 1359 resContent += NAPI_NEW_LINE + NAPI_TAB_SPACE + ts2CppKey(paType) + 1360 NAPI_BLANK_SPACE + paItem.getName(); 1361 ; 1362 List<String> initVList = paItem.getvList(); 1363 if (initVList.size() > 0) { 1364 resContent += NAPI_EQUAL + initVList.get(0) + NAPI_SEMICOLON; 1365 } else { 1366 resContent += NAPI_SEMICOLON; 1367 } 1368 } 1369 1370 List<FuncObj> funcList = so.getFuncList(); 1371 for (FuncObj funcItem : funcList) { 1372 String retValue = ts2CppKey(funcItem.getRetValue()).isEmpty() ? "" : 1373 ts2CppKey(funcItem.getRetValue()) + NAPI_BLANK_SPACE; 1374 resContent += NAPI_NEW_LINE + NAPI_TAB_SPACE + retValue + 1375 replaceTsToken(funcItem.getName()) + NAPI_LEFT_PARENTHESES; 1376 List<ParamObj> pol = funcItem.getParamList(); 1377 for (ParamObj poItem : pol) { 1378 String retType = ts2CppKey(poItem.getType()).isEmpty() ? 1379 NAPI_AUTO_TOKEN : ts2CppKey(poItem.getType()); 1380 resContent += retType + NAPI_BLANK_SPACE + replaceTsToken(poItem.getName()) + 1381 NAPI_COMMA + NAPI_BLANK_SPACE; 1382 } 1383 resContent = !pol.isEmpty() ? StringUtils.removeLastCharacter(resContent, 2) : resContent; 1384 resContent += NAPI_RIGHT_PARENTHESES + NAPI_SEMICOLON; 1385 } 1386 1387 resContent = StringUtils.removeLastSpace(resContent); 1388 resContent += NAPI_NEW_LINE + NAPI_RIGHT_BRACE + NAPI_SEMICOLON + NAPI_NEW_LINE; 1389 return resContent; 1390 } 1391 genNapiFuncConvert(FuncObj funcItem, String structMethodStr)1392 private String genNapiFuncConvert(FuncObj funcItem, String structMethodStr) { 1393 String funcName = funcItem.getName(); 1394 funcName = funcName.isEmpty() ? funcItem.getAlias() : funcName; 1395 funcName = StringUtils.unCapitalFirst(funcName); 1396 1397 String funcGetParamStr = ""; 1398 String funcCallStr = ""; 1399 String funcRetStr = ""; 1400 int i = 0; 1401 for (ParamObj pa : funcItem.getParamList()) { 1402 funcGetParamStr += genGetParam(pa, i); 1403 i++; 1404 } 1405 funcCallStr += genFuncCall(funcItem); 1406 funcRetStr += genFuncRet(funcItem.getRetValue()); 1407 String paCheckStr = NAPI_PARAM_CHECK.replace(NAPI_PARAM_CNT, 1408 Integer.toString(funcItem.getParamList().size())); 1409 String tempStr = structMethodStr; 1410 tempStr = tempStr.replace(NAPI_GET_ARGUMENTS_DECLARE, paCheckStr + funcGetParamStr); 1411 tempStr = tempStr.replace(NAPI_CLASS_CALL_METHOD_DECLARE, funcCallStr); 1412 tempStr = tempStr.replace(NAPI_CLASS_RETURN_VALUE_DECLARE, funcRetStr); 1413 return tempStr; 1414 } 1415 genNapiStructContent(StructObj so)1416 private String genNapiStructContent(StructObj so) { 1417 String structName = so.getName(); 1418 structName = !structName.isEmpty() ? structName : so.getAlias(); 1419 List<FuncObj> funcList = so.getFuncList(); 1420 String structNameList = ""; 1421 String structMethodContent = ""; 1422 String structMethodProperty = ""; 1423 for (FuncObj funcItem : funcList) { 1424 String structMethodStr = NAPI_CLASS_METHOD_DECLARE.replace( 1425 NAPI_CLASS_NAME, structName); 1426 structMethodStr = structMethodStr.replace( 1427 NAPI_CLASS_METHOD_NAME, funcItem.getName()); 1428 1429 structMethodStr = genNapiFuncConvert(funcItem, structMethodStr); 1430 structMethodContent += structMethodStr; 1431 1432 String structMethodPropertyStr = NAPI_CLASS_METHOD_PROPERTY_DECLARE.replace( 1433 NAPI_CLASS_METHOD_NAME, funcItem.getName()); 1434 structMethodPropertyStr = structMethodPropertyStr.replace(NAPI_CLASS_NAME, structName); 1435 structMethodProperty += structMethodPropertyStr; 1436 } 1437 1438 String classAttributeContent = ""; 1439 String classAttributeProperty = ""; 1440 List<ParamObj> paList = so.getMemberList(); 1441 for (ParamObj paItem : paList) { 1442 String getAttributeContent = NAPI_CLASS_GET_ATTRIBUTE_DECLARE.replace( 1443 NAPI_CLASS_ATTRIBUTE_NAME, paItem.getName()); 1444 getAttributeContent = getAttributeContent.replace(NAPI_CLASS_NAME, structName); 1445 String setAttributeContent = NAPI_CLASS_SET_ATTRIBUTE_DECLARE.replace( 1446 NAPI_CLASS_ATTRIBUTE_NAME, paItem.getName()); 1447 setAttributeContent = setAttributeContent.replace(NAPI_CLASS_NAME, structName); 1448 classAttributeContent += getAttributeContent + setAttributeContent; 1449 1450 String classAttributeStr = NAPI_CLASS_ATTRIBUTE_PROPERTY_DECLARE.replace( 1451 NAPI_CLASS_ATTRIBUTE_NAME, paItem.getName()); 1452 classAttributeStr = classAttributeStr.replace(NAPI_CLASS_NAME, structName); 1453 classAttributeProperty += classAttributeStr; 1454 } 1455 1456 String classDeclare = NAPI_CLASS_CONSTRUCTURE.replace(NAPI_CLASS_NAME, structName); 1457 classDeclare += NAPI_CLASS_DESTRUCTURE.replace(NAPI_CLASS_NAME, structName); 1458 classDeclare += structMethodContent + classAttributeContent; 1459 1460 String classPropertyStr = NAPI_CLASS_PROPERTY_DECLARE.replace(NAPI_CLASS_NAME, structName); 1461 classPropertyStr = classPropertyStr.replace(NAPI_CLASS_METHOD_PROPERTY, structMethodProperty); 1462 classPropertyStr = classPropertyStr.replace(NAPI_CLASS_ATTRIBUTE_PROPERTY, classAttributeProperty); 1463 classDeclare += classPropertyStr; 1464 1465 String classInitStr = NAPI_CLASS_INIT.replace(NAPI_CLASS_NAME, structName); 1466 classDeclare += classInitStr; 1467 1468 String resContent = ""; 1469 resContent = classDeclare; 1470 return resContent; 1471 } 1472 1473 /** 1474 * 生成输出内容 1475 * 1476 * @param sol 结构体列表 1477 */ 1478 @Override genStructList(List<StructObj> sol)1479 public void genStructList(List<StructObj> sol) { 1480 System.out.println("genStructList" + sol.toString()); 1481 1482 String resContent = ""; 1483 for (StructObj so : sol) { 1484 resContent += genCppStructContent(so); 1485 resContent += genNapiStructContent(so); 1486 } 1487 this.structContent = resContent; 1488 }; 1489 1490 /** 1491 * 生成输出内容 1492 * 1493 * @param tol 类型列表 1494 */ 1495 @Override genTypeList(List<TypeObj> tol)1496 public void genTypeList(List<TypeObj> tol) { 1497 System.out.println("genTypeList : " + tol.toString()); 1498 }; 1499 1500 /** 1501 * 生成输出内容 1502 * 1503 * @param uol 联合体列表 1504 */ 1505 @Override genUnionList(List<UnionObj> uol)1506 public void genUnionList(List<UnionObj> uol) { 1507 System.out.println("genUnionList : " + uol.toString()); 1508 1509 String resContent = ""; 1510 for (UnionObj uo : uol) { 1511 String unionName = uo.getName(); 1512 unionName = !unionName.isEmpty() ? unionName : uo.getAlias(); 1513 1514 String templateStr = !uo.getTemplateList().isEmpty() ? 1515 NAPI_TEMPLATE_TOKEN + NAPI_BLANK_SPACE + NAPI_LEFT_ANGLE_BRACKET : ""; 1516 for (String teStr : uo.getTemplateList()) { 1517 templateStr += NAPI_TYPE_NAME_TOKEN + NAPI_BLANK_SPACE + teStr + NAPI_COMMA + NAPI_BLANK_SPACE; 1518 } 1519 templateStr = templateStr.length() > 1 ? 1520 StringUtils.removeLastCharacter(templateStr, 2) + 1521 NAPI_RIGHT_ANGLE_BRACKET + NAPI_BLANK_SPACE : ""; 1522 1523 resContent += NAPI_NEW_LINE + templateStr + NAPI_UNION_TOKEN + 1524 NAPI_BLANK_SPACE + unionName + NAPI_LEFT_BRACE; 1525 1526 List<ParamObj> paList = uo.getMemList(); 1527 for (ParamObj paItem : paList) { 1528 String paType = paItem.getType(); 1529 String paName = paItem.getName(); 1530 resContent += NAPI_NEW_LINE + NAPI_TAB_SPACE + ts2CppKey(paType) 1531 + NAPI_BLANK_SPACE + paName + NAPI_SEMICOLON; 1532 } 1533 resContent += NAPI_NEW_LINE + NAPI_RIGHT_BRACE; 1534 resContent += NAPI_SEMICOLON + NAPI_NEW_LINE; 1535 } 1536 this.unionContent = resContent; 1537 }; 1538 genVarArrayList(String tmpContent, String paName, List<ParamObj> paList)1539 private String genVarArrayList(String tmpContent, String paName, List<ParamObj> paList) { 1540 String resContent = tmpContent; 1541 resContent += NAPI_NEW_LINE + NAPI_STRUCT_TOKEN + NAPI_BLANK_SPACE + paName + 1542 NAPI_STRUCT_SUFFIX + NAPI_BLANK_SPACE + NAPI_LEFT_BRACE; 1543 List<ParamObj> paramList = paList.get(0).getPaList(); 1544 for (ParamObj paItem : paramList) { 1545 String paStr = paItem.getName(); 1546 String paVal = paItem.getStrValue(0); 1547 String typeStr = StringUtils.isAllDigits(paVal) ? 1548 NAPI_NUMBER_TOKEN : NAPI_STD_STRING; 1549 typeStr = StringUtils.isBoolean(paVal) ? NAPI_BOOLEAN_TOKEN : typeStr; 1550 resContent += NAPI_NEW_LINE + NAPI_TAB_SPACE + typeStr + NAPI_BLANK_SPACE + paStr + NAPI_SEMICOLON; 1551 } 1552 resContent += NAPI_NEW_LINE + NAPI_RIGHT_BRACE + NAPI_SEMICOLON + NAPI_NEW_LINE; 1553 1554 resContent += NAPI_NEW_LINE + NAPI_CONST_TOKEN + NAPI_BLANK_SPACE + NAPI_STD_VECTOR + 1555 NAPI_LEFT_ANGLE_BRACKET + paName + NAPI_STRUCT_SUFFIX + NAPI_RIGHT_ANGLE_BRACKET + 1556 NAPI_BLANK_SPACE + paName + NAPI_EQUAL + NAPI_LEFT_BRACE; 1557 for (ParamObj paramListItem : paList) { 1558 List<ParamObj> subParamList = paramListItem.getPaList(); 1559 resContent += NAPI_NEW_LINE + NAPI_TAB_SPACE + NAPI_LEFT_BRACE; 1560 for (ParamObj paItem : subParamList) { 1561 String paVal = paItem.getStrValue(0); 1562 resContent += paVal + NAPI_COMMA + NAPI_BLANK_SPACE; 1563 } 1564 resContent = StringUtils.removeLastCharacter(resContent, 2); 1565 resContent += NAPI_RIGHT_BRACE + NAPI_COMMA; 1566 } 1567 resContent += NAPI_NEW_LINE + NAPI_RIGHT_BRACE + NAPI_SEMICOLON + NAPI_NEW_LINE; 1568 return resContent; 1569 }; 1570 genCppValContent(ParamObj po)1571 private String genCppValContent(ParamObj po) { 1572 String paName = po.getName(); 1573 String paType = ts2CppKey(po.getType()).isEmpty() ? NAPI_AUTO_TOKEN : ts2CppKey(po.getType()); 1574 String paValue = po.getStrValue(0); 1575 List<ParamObj> paList = po.getPaList(); 1576 String resContent = ""; 1577 if (paList.isEmpty()) { 1578 resContent += NAPI_NEW_LINE + NAPI_EXTENDS_TOKEN + NAPI_BLANK_SPACE + NAPI_CONST_TOKEN + 1579 NAPI_BLANK_SPACE + paType + NAPI_BLANK_SPACE + paName + NAPI_EQUAL + paValue; 1580 1581 resContent += NAPI_SEMICOLON + NAPI_NEW_LINE; 1582 } else if (paList.get(0).getPaList().isEmpty()) { 1583 String valType = StringUtils.isAllDigits(paList.get(0).getStrValue(0)) ? 1584 NAPI_NUMBER_TOKEN : NAPI_STD_STRING; 1585 resContent += NAPI_NEW_LINE + NAPI_EXTENDS_TOKEN + NAPI_BLANK_SPACE + NAPI_CONST_TOKEN + 1586 NAPI_BLANK_SPACE + NAPI_STD_MAP + NAPI_LEFT_ANGLE_BRACKET + NAPI_STD_STRING + 1587 NAPI_COMMA + NAPI_BLANK_SPACE + valType + NAPI_RIGHT_BRACE + NAPI_BLANK_SPACE + 1588 paName + NAPI_EQUAL + NAPI_LEFT_BRACE; 1589 for (ParamObj paItem : paList) { 1590 String pName = paItem.getName(); 1591 String pVal = paItem.getStrValue(0); 1592 resContent += NAPI_NEW_LINE + NAPI_TAB_SPACE + NAPI_LEFT_BRACE + NAPI_DOUBLE_QUOTATION + 1593 pName + NAPI_DOUBLE_QUOTATION + NAPI_COMMA + NAPI_BLANK_SPACE + pVal + 1594 NAPI_RIGHT_BRACE + NAPI_COMMA; 1595 } 1596 resContent = StringUtils.removeLastCharacter(resContent, 1); 1597 resContent += NAPI_NEW_LINE + NAPI_RIGHT_BRACE + NAPI_SEMICOLON + NAPI_NEW_LINE; 1598 } else if (!(paList.get(0).getPaList().isEmpty())) { 1599 resContent = genVarArrayList(resContent, paName, paList); 1600 } 1601 return resContent; 1602 }; 1603 genNapiValContent(ParamObj po)1604 private String genNapiValContent(ParamObj po) { 1605 String paramAttributeContent = ""; 1606 String paramAttributeProperty = ""; 1607 String structName = "GNAPI"; 1608 { 1609 String getAttributeContent = NAPI_VAL_GET_DECLARE.replace( 1610 NAPI_CLASS_ATTRIBUTE_NAME, po.getName()); 1611 getAttributeContent = getAttributeContent.replace(NAPI_CLASS_NAME, structName); 1612 String setAttributeContent = NAPI_VAL_SET_DECLARE.replace( 1613 NAPI_CLASS_ATTRIBUTE_NAME, po.getName()); 1614 setAttributeContent = setAttributeContent.replace(NAPI_CLASS_NAME, structName); 1615 paramAttributeContent += getAttributeContent + setAttributeContent; 1616 1617 String classAttributeStr = NAPI_CLASS_ATTRIBUTE_PROPERTY_DECLARE.replace( 1618 NAPI_CLASS_ATTRIBUTE_NAME, po.getName()); 1619 classAttributeStr = classAttributeStr.replace(NAPI_CLASS_NAME, structName); 1620 paramAttributeProperty += classAttributeStr; 1621 } 1622 1623 String classDeclare = ""; 1624 classDeclare += paramAttributeContent; 1625 1626 String classPropertyStr = NAPI_CLASS_PROPERTY_DECLARE.replace(NAPI_CLASS_NAME, structName); 1627 classPropertyStr = classPropertyStr.replace(NAPI_CLASS_ATTRIBUTE_PROPERTY, paramAttributeProperty); 1628 classPropertyStr = classPropertyStr.replace(NAPI_CLASS_METHOD_PROPERTY, ""); 1629 classDeclare += classPropertyStr; 1630 1631 return classDeclare; 1632 } 1633 1634 /** 1635 * 生成输出内容 1636 * 1637 * @param pol 常量列表 1638 */ 1639 @Override genVarList(List<ParamObj> pol)1640 public void genVarList(List<ParamObj> pol) { 1641 System.out.println("genVarList : " + pol.toString()); 1642 1643 String resContent = ""; 1644 for (ParamObj po : pol) { 1645 resContent += genCppValContent(po); 1646 resContent += genNapiValContent(po); 1647 } 1648 this.constContent = resContent; 1649 System.out.println("genVarList : " + resContent); 1650 } 1651 } 1652