diff --git a/.clang-format b/.clang-format index ab8b4bc1ca83d4076e318a8208215b6405aed50b..2563ec259abfc482ce9d46c3e89aa7a1e45b265a 100644 --- a/.clang-format +++ b/.clang-format @@ -43,8 +43,7 @@ BreakConstructorInitializers: BeforeColon BreakInheritanceList: BeforeColon BreakStringLiterals: true BreakAfterJavaFieldAnnotations: true -# ColumnLimit: 120 -ColumnLimit: 0 +ColumnLimit: 120 # CommentPragmas: '^ IWYU pragma:' QualifierAlignment: Leave ReflowComments: true diff --git a/gn/command/npm_util.py b/gn/command/npm_util.py index 2dec5865c778fd5a376d737f6e35a1173c73329b..eebddb8a84ac969349d9977b0ec24e5e2c0a477c 100755 --- a/gn/command/npm_util.py +++ b/gn/command/npm_util.py @@ -53,17 +53,17 @@ if args.stdlib_path: os.environ["PANDA_SDK_PATH"] = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../ui2abc/build/sdk") -def run(args, dir = None): +def run(args_list, dir = None): os.chdir(dir or project_path) if os.environ.get("KOALA_LOG_STDOUT"): - subprocess.run(["npm"] + args, env=os.environ, text=True, check=True, stderr=subprocess.STDOUT) + subprocess.run(["npm"] + args_list, env=os.environ, text=True, check=True, stderr=subprocess.STDOUT) return - result = subprocess.run(["npm"] + args, capture_output=True, env=os.environ, text=True) + result = subprocess.run(["npm"] + args_list, capture_output=True, env=os.environ, text=True) with open(koala_log, "a+") as f: - f.write(f"npm args: {args}; project: {project_path}:\n" + result.stdout) + f.write(f"npm args: {args_list}; project: {project_path}:\n" + result.stdout) if result.returncode != 0: - f.write(f"npm args: {args}; project: {project_path}:\n" + result.stderr) + f.write(f"npm args: {args_list}; project: {project_path}:\n" + result.stderr) print(open(koala_log, "r").read()) raise Exception("npm failed") f.close() diff --git a/gn/script/npm.py b/gn/script/npm.py index 7bcc018a3e54b554c3b1d6ac18a092217ad1f932..147c61aed412a2d64e9f6315fd671cb639939dee 100755 --- a/gn/script/npm.py +++ b/gn/script/npm.py @@ -54,19 +54,19 @@ if args.stdlib_path: os.environ["ETS_STDLIB_PATH"] = args.stdlib_path if args.panda_sdk_path: os.environ["PANDA_SDK_PATH"] = args.panda_sdk_path -# os.environ["PANDA_SDK_PATH"] = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../ui2abc/build/sdk") +# Note: os.environ["PANDA_SDK_PATH"] = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../ui2abc/build/sdk") -def run(args, dir = None): +def run(args_list, dir = None): os.chdir(dir or project_path) if os.environ.get("KOALA_LOG_STDOUT"): - subprocess.run(["npm"] + args, env=os.environ, text=True, check=True, stderr=subprocess.STDOUT) + subprocess.run(["npm"] + args_list, env=os.environ, text=True, check=True, stderr=subprocess.STDOUT) return - result = subprocess.run(["npm"] + args, capture_output=True, env=os.environ, text=True) + result = subprocess.run(["npm"] + args_list, capture_output=True, env=os.environ, text=True) with open(koala_log, "a+") as f: - f.write(f"npm args: {args}; project: {project_path}:\n" + result.stdout) + f.write(f"npm args: {args_list}; project: {project_path}:\n" + result.stdout) if result.returncode != 0: - f.write(f"npm args: {args}; project: {project_path}:\n" + result.stderr) + f.write(f"npm args: {args_list}; project: {project_path}:\n" + result.stderr) print(open(koala_log, "r").read()) raise Exception("npm failed") f.close() diff --git a/incremental/compat/src/arkts/observable.ts b/incremental/compat/src/arkts/observable.ts index f28ece65d700d7e0b74824e5963b0a5c598100e6..547066388d9617a248e3a292dfa6804a45a39ae6 100644 --- a/incremental/compat/src/arkts/observable.ts +++ b/incremental/compat/src/arkts/observable.ts @@ -1263,19 +1263,21 @@ export class ClassMetadata implements TrackableProperties { } static findClassMetadata(type: Type): ClassMetadata | undefined { - if (type instanceof ClassType) { - const fieldsNum = type.getFieldsNum() - for (let i = 0; i < fieldsNum; i++) { - const field = type.getField(i) - if (field.isStatic() && field.getName() == ClassMetadata.metadataPropName) { - const meta = field.getStaticValue() - if (meta != undefined && meta instanceof ClassMetadata) { - return meta - } - break + if (!(type instanceof ClassType)) { + return undefined + } + const fieldsNum = type.getFieldsNum() + for (let i = 0; i < fieldsNum; i++) { + const field = type.getField(i) + if (field.isStatic() && field.getName() == ClassMetadata.metadataPropName) { + const meta = field.getStaticValue() + if (meta != undefined && meta instanceof ClassMetadata) { + return meta } + break } } + return undefined } } diff --git a/interop/src/cpp/DeserializerBase.h b/interop/src/cpp/DeserializerBase.h index 360ccaea66a4eb1b6ef232aff4db9d73e279b777..16c8df852f0800b38444c13497b00d7bea5138fe 100644 --- a/interop/src/cpp/DeserializerBase.h +++ b/interop/src/cpp/DeserializerBase.h @@ -531,17 +531,18 @@ inline void WriteToString(std::string* result, InteropUInt32 value) { result->append(std::to_string(value)); } +const int BUFFER_FLOAT_NUMBER = 20; template<> inline void WriteToString(std::string* result, InteropFloat32 value) { #if (defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && (__MAC_OS_X_VERSION_MAX_ALLOWED < 130300L)) // to_chars() is not available on older macOS. - char buf[20]; + char buf[BUFFER_FLOAT_NUMBER]; interop_snprintf(buf, sizeof buf, "%f", value); result->append(buf); #else std::string storage; - storage.resize(20); + storage.resize(BUFFER_FLOAT_NUMBER); // We use to_chars() to avoid locale issues. auto rc = std::to_chars(storage.data(), storage.data() + storage.size(), value); storage.resize(rc.ptr - storage.data()); @@ -553,12 +554,12 @@ inline void WriteToString(std::string* result, InteropFloat64 value) { #if (defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && (__MAC_OS_X_VERSION_MAX_ALLOWED < 130300L)) // to_chars() is not available on older macOS. - char buf[20]; + char buf[BUFFER_FLOAT_NUMBER]; interop_snprintf(buf, sizeof buf, "%f", value); result->append(buf); #else std::string storage; - storage.resize(20); + storage.resize(BUFFER_FLOAT_NUMBER); // We use to_chars() to avoid locale issues. auto rc = std::to_chars(storage.data(), storage.data() + storage.size(), value); storage.resize(rc.ptr - storage.data()); diff --git a/interop/src/cpp/SerializerBase.h b/interop/src/cpp/SerializerBase.h index 2b9e484e1314561e65d6ae3acd9f4228fa64a8ec..df814919259d36ff21523d12d01eeb284348ee04 100644 --- a/interop/src/cpp/SerializerBase.h +++ b/interop/src/cpp/SerializerBase.h @@ -54,6 +54,8 @@ inline InteropRuntimeType runtimeType(const InteropObject& value) return INTEROP_RUNTIME_OBJECT; } +const uint32_t INITIAL_SERIALIZER_DATA_LENGTH = 256; + class SerializerBase { private: uint8_t* data; @@ -79,7 +81,7 @@ public: SerializerBase(CallbackResourceHolder* resourceHolder = nullptr) : position(0), ownData(true), resourceHolder(resourceHolder) { - this->dataLength = 256; + this->dataLength = INITIAL_SERIALIZER_DATA_LENGTH; this->data = reinterpret_cast(malloc(this->dataLength)); if (!this->data) { INTEROP_FATAL("Cannot allocate memory"); diff --git a/interop/src/cpp/ani/convertors-ani.cc b/interop/src/cpp/ani/convertors-ani.cc index c9ece6e17547d5ac743f74475f3464a94a4a4680..f4065c3aea8be7537bccd64daf2a441882489b53 100644 --- a/interop/src/cpp/ani/convertors-ani.cc +++ b/interop/src/cpp/ani/convertors-ani.cc @@ -15,7 +15,11 @@ #include "convertors-ani.h" #include +#ifdef __cplusplus +#include +#else #include +#endif #include "interop-types.h" #include "signatures.h" diff --git a/interop/src/cpp/ani/convertors-ani.h b/interop/src/cpp/ani/convertors-ani.h index cc46d7998bfe4ee0e2758d5411fd97681c02a40b..1c1b046c485d406946ad87ec3ef6844f76f2fd7d 100644 --- a/interop/src/cpp/ani/convertors-ani.h +++ b/interop/src/cpp/ani/convertors-ani.h @@ -476,18 +476,18 @@ public: } \ } __Init_##name##_v; \ } -#define KOALA_ANI_INTEROP_MODULE_CLASSPATH(module, classpath) \ - static void __init_classpath_##module() \ - { \ - AniExports::getInstance()->setClasspath(KOALA_QUOTE(module), classpath); \ - } \ - namespace { \ - struct __Init_classpath_##module { \ - __Init_classpath_##module() \ - { \ - __init_classpath_##module(); \ - } \ - } __Init_classpath_##module##_v; \ +#define KOALA_ANI_INTEROP_MODULE_CLASSPATH(module, classpath) \ + static void __init_classpath_##module() \ + { \ + AniExports::getInstance()->setClasspath(KOALA_QUOTE(module), classpath); \ + } \ + namespace { \ + struct __Init_classpath_##module { \ + __Init_classpath_##module() \ + { \ + __init_classpath_##module(); \ + } \ + } __Init_classpath_##module##_v; \ } #else #define MAKE_ANI_EXPORT(module, name, type, flag) \ @@ -496,10 +496,10 @@ public: AniExports::getInstance()->addMethod( \ KOALA_QUOTE(module), "_" #name, type, reinterpret_cast(Ani_##name), flag); \ } -#define KOALA_ANI_INTEROP_MODULE_CLASSPATH(module, classpath) \ - __attribute__((constructor)) static void __init_ani_classpath_##module() \ - { \ - AniExports::getInstance()->setClasspath(KOALA_QUOTE(module), classpath); \ +#define KOALA_ANI_INTEROP_MODULE_CLASSPATH(module, classpath) \ + __attribute__((constructor)) static void __init_ani_classpath_##module() \ + { \ + AniExports::getInstance()->setClasspath(KOALA_QUOTE(module), classpath); \ } #endif diff --git a/interop/src/cpp/common-interop.cc b/interop/src/cpp/common-interop.cc index b367d4f6d16214e17b9884e42f0af573b7d4a649..0379dd4ed94a26b832826eda534840fcce480c89 100644 --- a/interop/src/cpp/common-interop.cc +++ b/interop/src/cpp/common-interop.cc @@ -89,7 +89,7 @@ bool setKoalaEtsNapiCallbackDispatcher( { g_koalaEtsNapiCallbackDispatcher.clazz = clazz; etsEnv->NewGlobalRef(clazz); - ets_method method = etsEnv->GetStaticp_method(clazz, dispatcherMethodName, dispactherMethodSig); + ets_method method = etsEnv->GetStaticMethod(clazz, dispatcherMethodName, dispactherMethodSig); if (method == nullptr) { return false; } @@ -302,10 +302,12 @@ KInt impl_LoadVirtualMachine(KVMContext vmContext, KInt vmKind, const KStringPtr const char* nativeLibPath = envClassPath ? envClassPath : libraryPath.c_str(); static LoadVirtualMachine_t impl = nullptr; - if (!impl) + if (!impl) { impl = reinterpret_cast(getImpl(nativeLibPath, "LoadVirtualMachine")); - if (!impl) + } + if (!impl) { KOALA_INTEROP_THROW_STRING(vmContext, "Cannot load VM", -1); + } const ForeignVMContext foreignVM = { vmContext, &callCallback }; return impl(vmKind, bootFilesPath, userFiles.c_str(), nativeLibPath, &foreignVM); } @@ -314,8 +316,9 @@ KOALA_INTEROP_CTX_4(LoadVirtualMachine, KInt, KInt, KStringPtr, KStringPtr, KStr KNativePointer impl_StartApplication(const KStringPtr& appUrl, const KStringPtr& appParams, KInt loopIterations) { static StartApplication_t impl = nullptr; - if (!impl) + if (!impl) { impl = reinterpret_cast(getImpl(nullptr, "StartApplication")); + } return impl(appUrl.c_str(), appParams.c_str(), loopIterations); } KOALA_INTEROP_3(StartApplication, KNativePointer, KStringPtr, KStringPtr, KInt) @@ -323,8 +326,9 @@ KOALA_INTEROP_3(StartApplication, KNativePointer, KStringPtr, KStringPtr, KInt) KBoolean impl_RunApplication(const KInt arg0, const KInt arg1) { static RunApplication_t impl = nullptr; - if (!impl) + if (!impl) { impl = reinterpret_cast(getImpl(nullptr, "RunApplication")); + } return impl(arg0, arg1); } KOALA_INTEROP_2(RunApplication, KBoolean, KInt, KInt) @@ -332,8 +336,9 @@ KOALA_INTEROP_2(RunApplication, KBoolean, KInt, KInt) KStringPtr impl_EmitEvent(KVMContext vmContext, KInt type, KInt target, KInt arg0, KInt arg1) { static EmitEvent_t impl = nullptr; - if (!impl) + if (!impl) { impl = reinterpret_cast(getImpl(nullptr, "EmitEvent")); + } const char* out = impl(type, target, arg0, arg1); auto size = std::string(out).size(); KStringPtr result(out, size, true); @@ -344,8 +349,9 @@ KOALA_INTEROP_CTX_4(EmitEvent, KStringPtr, KInt, KInt, KInt, KInt) void impl_RestartWith(const KStringPtr& page) { static RestartWith_t impl = nullptr; - if (!impl) + if (!impl) { impl = reinterpret_cast(getImpl(nullptr, "RestartWith")); + } impl(page.c_str()); } KOALA_INTEROP_V1(RestartWith, KStringPtr) @@ -354,8 +360,9 @@ KOALA_INTEROP_V1(RestartWith, KStringPtr) KStringPtr impl_LoadView(const KStringPtr& className, const KStringPtr& params) { static LoadView_t impl = nullptr; - if (!impl) + if (!impl) { impl = reinterpret_cast(getImpl(nullptr, "LoadView")); + } const char* result = impl(className.c_str(), params.c_str()); return KStringPtr(result, interop_strlen(result), true); } diff --git a/interop/src/cpp/ets/convertors-ets.h b/interop/src/cpp/ets/convertors-ets.h index 8a28df7b105cdbc7ca2ab7d4f541650dabc03133..74d8dee743333419a5f96ada9acaff833381ad5a 100644 --- a/interop/src/cpp/ets/convertors-ets.h +++ b/interop/src/cpp/ets/convertors-ets.h @@ -806,9 +806,7 @@ public: return rv; \ } \ MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, \ - #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 \ - "|" #P12, \ - 0) + #Ret"|"#P0"|"#P1"|"#P2"|"#P3"|"#P4"|"#P5"|"#P6"|"#P7"|"#P8"|"#P9"|"#P10"|"#P11"|"#P12, 0) #define KOALA_INTEROP_14(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ InteropTypeConverter::InteropType Ark_##name(EtsEnv* env, ets_class clazz, \ @@ -853,9 +851,7 @@ public: return rv; \ } \ MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, \ - #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 \ - "|" #P12 "|" #P13, \ - 0) + #Ret"|"#P0"|"#P1"|"#P2"|"#P3"|"#P4"|"#P5"|"#P6"|"#P7"|"#P8"|"#P9"|"#P10"|"#P11"|"#P12"|"#P13, 0) #define KOALA_INTEROP_V0(name) \ void Ark_##name(EtsEnv* env) \ diff --git a/interop/src/cpp/ets/etsapi.h b/interop/src/cpp/ets/etsapi.h index 144d600906379d829d61858bdfc32d0f2765beed..380b43f2e616d8eedd42318d22962f1d53d59419 100644 --- a/interop/src/cpp/ets/etsapi.h +++ b/interop/src/cpp/ets/etsapi.h @@ -182,12 +182,12 @@ struct ETS_NativeInterface { #ifdef ETS_NAPI_DESIGN_FINISHED ets_method (*FromReflectedMethod)(EtsEnv *env, ets_object method); ets_field (*FromReflectedField)(EtsEnv *env, ets_object field); - ets_object (*ToReflectedMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ets_boolean isStatic); + ets_object (*ToReflectedMethod)(EtsEnv *env, ets_class cls, ets_method method, ets_boolean isStatic); #endif ets_class (*GetSuperclass)(EtsEnv *env, ets_class cls); ets_boolean (*IsAssignableFrom)(EtsEnv *env, ets_class cls1, ets_class cls2); #ifdef ETS_NAPI_DESIGN_FINISHED - ets_object (*ToReflectedField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_boolean isStatic); + ets_object (*ToReflectedField)(EtsEnv *env, ets_class cls, ets_field field, ets_boolean isStatic); #endif ets_int (*ThrowError)(EtsEnv *env, ets_error obj); ets_int (*ThrowErrorNew)(EtsEnv *env, ets_class cls, const char *message); @@ -204,161 +204,161 @@ struct ETS_NativeInterface { ets_object (*NewLocalRef)(EtsEnv *env, ets_object ref); ets_int (*EnsureLocalCapacity)(EtsEnv *env, ets_int capacity); ets_object (*AllocObject)(EtsEnv *env, ets_class cls); - ets_object (*NewObject)(EtsEnv *env, ets_class cls, ets_method p_method, ...); - ets_object (*NewObjectList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); - ets_object (*NewObjectArray)(EtsEnv *env, ets_class cls, ets_method p_method, const ets_value *args); + ets_object (*NewObject)(EtsEnv *env, ets_class cls, ets_method method, ...); + ets_object (*NewObjectList)(EtsEnv *env, ets_class cls, ets_method method, va_list args); + ets_object (*NewObjectArray)(EtsEnv *env, ets_class cls, ets_method method, const ets_value *args); ets_class (*GetObjectClass)(EtsEnv *env, ets_object obj); ets_boolean (*IsInstanceOf)(EtsEnv *env, ets_object obj, ets_class cls); - ets_method (*Getp_method)(EtsEnv *env, ets_class cls, const char *name, const char *sig); - ets_object (*CallObjectMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); - ets_object (*CallObjectMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); - ets_object (*CallObjectMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); - ets_boolean (*CallBooleanMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); - ets_boolean (*CallBooleanMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); - ets_boolean (*CallBooleanMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); - ets_byte (*CallByteMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); - ets_byte (*CallByteMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); - ets_byte (*CallByteMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); - ets_char (*CallCharMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); - ets_char (*CallCharMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); - ets_char (*CallCharMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); - ets_short (*CallShortMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); - ets_short (*CallShortMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); - ets_short (*CallShortMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); - ets_int (*CallIntMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); - ets_int (*CallIntMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); - ets_int (*CallIntMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); - ets_long (*CallLongMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); - ets_long (*CallLongMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); - ets_long (*CallLongMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); - ets_float (*CallFloatMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); - ets_float (*CallFloatMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); - ets_float (*CallFloatMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); - ets_double (*CallDoubleMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); - ets_double (*CallDoubleMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); - ets_double (*CallDoubleMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); - void (*CallVoidMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); - void (*CallVoidMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); - void (*CallVoidMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); + ets_method (*GetMethod)(EtsEnv *env, ets_class cls, const char *name, const char *sig); + ets_object (*CallObjectMethod)(EtsEnv *env, ets_object obj, ets_method method, ...); + ets_object (*CallObjectMethodList)(EtsEnv *env, ets_object obj, ets_method method, va_list args); + ets_object (*CallObjectMethodArray)(EtsEnv *env, ets_object obj, ets_method method, const ets_value *args); + ets_boolean (*CallBooleanMethod)(EtsEnv *env, ets_object obj, ets_method method, ...); + ets_boolean (*CallBooleanMethodList)(EtsEnv *env, ets_object obj, ets_method method, va_list args); + ets_boolean (*CallBooleanMethodArray)(EtsEnv *env, ets_object obj, ets_method method, const ets_value *args); + ets_byte (*CallByteMethod)(EtsEnv *env, ets_object obj, ets_method method, ...); + ets_byte (*CallByteMethodList)(EtsEnv *env, ets_object obj, ets_method method, va_list args); + ets_byte (*CallByteMethodArray)(EtsEnv *env, ets_object obj, ets_method method, const ets_value *args); + ets_char (*CallCharMethod)(EtsEnv *env, ets_object obj, ets_method method, ...); + ets_char (*CallCharMethodList)(EtsEnv *env, ets_object obj, ets_method method, va_list args); + ets_char (*CallCharMethodArray)(EtsEnv *env, ets_object obj, ets_method method, const ets_value *args); + ets_short (*CallShortMethod)(EtsEnv *env, ets_object obj, ets_method method, ...); + ets_short (*CallShortMethodList)(EtsEnv *env, ets_object obj, ets_method method, va_list args); + ets_short (*CallShortMethodArray)(EtsEnv *env, ets_object obj, ets_method method, const ets_value *args); + ets_int (*CallIntMethod)(EtsEnv *env, ets_object obj, ets_method method, ...); + ets_int (*CallIntMethodList)(EtsEnv *env, ets_object obj, ets_method method, va_list args); + ets_int (*CallIntMethodArray)(EtsEnv *env, ets_object obj, ets_method method, const ets_value *args); + ets_long (*CallLongMethod)(EtsEnv *env, ets_object obj, ets_method method, ...); + ets_long (*CallLongMethodList)(EtsEnv *env, ets_object obj, ets_method method, va_list args); + ets_long (*CallLongMethodArray)(EtsEnv *env, ets_object obj, ets_method method, const ets_value *args); + ets_float (*CallFloatMethod)(EtsEnv *env, ets_object obj, ets_method method, ...); + ets_float (*CallFloatMethodList)(EtsEnv *env, ets_object obj, ets_method method, va_list args); + ets_float (*CallFloatMethodArray)(EtsEnv *env, ets_object obj, ets_method method, const ets_value *args); + ets_double (*CallDoubleMethod)(EtsEnv *env, ets_object obj, ets_method method, ...); + ets_double (*CallDoubleMethodList)(EtsEnv *env, ets_object obj, ets_method method, va_list args); + ets_double (*CallDoubleMethodArray)(EtsEnv *env, ets_object obj, ets_method method, const ets_value *args); + void (*CallVoidMethod)(EtsEnv *env, ets_object obj, ets_method method, ...); + void (*CallVoidMethodList)(EtsEnv *env, ets_object obj, ets_method method, va_list args); + void (*CallVoidMethodArray)(EtsEnv *env, ets_object obj, ets_method method, const ets_value *args); - ets_object (*CallNonvirtualObjectMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); - ets_object (*CallNonvirtualObjectMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_object (*CallNonvirtualObjectMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, ...); + ets_object (*CallNonvirtualObjectMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, va_list args); - ets_object (*CallNonvirtualObjectMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_object (*CallNonvirtualObjectMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, const ets_value *args); - ets_boolean (*CallNonvirtualBooleanMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); - ets_boolean (*CallNonvirtualBooleanMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_boolean (*CallNonvirtualBooleanMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, ...); + ets_boolean (*CallNonvirtualBooleanMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, va_list args); - ets_boolean (*CallNonvirtualBooleanMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_boolean (*CallNonvirtualBooleanMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, const ets_value *args); - ets_byte (*CallNonvirtualByteMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); - ets_byte (*CallNonvirtualByteMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_byte (*CallNonvirtualByteMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, ...); + ets_byte (*CallNonvirtualByteMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, va_list args); - ets_byte (*CallNonvirtualByteMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_byte (*CallNonvirtualByteMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, const ets_value *args); - ets_char (*CallNonvirtualCharMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); - ets_char (*CallNonvirtualCharMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_char (*CallNonvirtualCharMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, ...); + ets_char (*CallNonvirtualCharMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, va_list args); - ets_char (*CallNonvirtualCharMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_char (*CallNonvirtualCharMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, const ets_value *args); - ets_short (*CallNonvirtualShortMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); - ets_short (*CallNonvirtualShortMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_short (*CallNonvirtualShortMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, ...); + ets_short (*CallNonvirtualShortMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, va_list args); - ets_short (*CallNonvirtualShortMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_short (*CallNonvirtualShortMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, const ets_value *args); - ets_int (*CallNonvirtualIntMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); - ets_int (*CallNonvirtualIntMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_int (*CallNonvirtualIntMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, ...); + ets_int (*CallNonvirtualIntMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, va_list args); - ets_int (*CallNonvirtualIntMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_int (*CallNonvirtualIntMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, const ets_value *args); - ets_long (*CallNonvirtualLongMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); - ets_long (*CallNonvirtualLongMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_long (*CallNonvirtualLongMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, ...); + ets_long (*CallNonvirtualLongMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, va_list args); - ets_long (*CallNonvirtualLongMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_long (*CallNonvirtualLongMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, const ets_value *args); - ets_float (*CallNonvirtualFloatMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); - ets_float (*CallNonvirtualFloatMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_float (*CallNonvirtualFloatMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, ...); + ets_float (*CallNonvirtualFloatMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, va_list args); - ets_float (*CallNonvirtualFloatMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_float (*CallNonvirtualFloatMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, const ets_value *args); - ets_double (*CallNonvirtualDoubleMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); - ets_double (*CallNonvirtualDoubleMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_double (*CallNonvirtualDoubleMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, ...); + ets_double (*CallNonvirtualDoubleMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, va_list args); - ets_double (*CallNonvirtualDoubleMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + ets_double (*CallNonvirtualDoubleMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, const ets_value *args); - void (*CallNonvirtualVoidMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); - void (*CallNonvirtualVoidMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, va_list args); - void (*CallNonvirtualVoidMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + void (*CallNonvirtualVoidMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, ...); + void (*CallNonvirtualVoidMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, va_list args); + void (*CallNonvirtualVoidMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method method, const ets_value *args); ets_field (*Getp_field)(EtsEnv *env, ets_class cls, const char *name, const char *sig); - ets_object (*GetObjectField)(EtsEnv *env, ets_object obj, ets_field p_field); - ets_boolean (*GetBooleanField)(EtsEnv *env, ets_object obj, ets_field p_field); - ets_byte (*GetByteField)(EtsEnv *env, ets_object obj, ets_field p_field); - ets_char (*GetCharField)(EtsEnv *env, ets_object obj, ets_field p_field); - ets_short (*GetShortField)(EtsEnv *env, ets_object obj, ets_field p_field); - ets_int (*GetIntField)(EtsEnv *env, ets_object obj, ets_field p_field); - ets_long (*GetLongField)(EtsEnv *env, ets_object obj, ets_field p_field); - ets_float (*GetFloatField)(EtsEnv *env, ets_object obj, ets_field p_field); - ets_double (*GetDoubleField)(EtsEnv *env, ets_object obj, ets_field p_field); - void (*SetObjectField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_object value); - void (*SetBooleanField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_boolean value); - void (*SetByteField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_byte value); - void (*SetCharField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_char value); - void (*SetShortField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_short value); - void (*SetIntField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_int value); - void (*SetLongField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_long value); - void (*SetFloatField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_float value); - void (*SetDoubleField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_double value); - ets_method (*GetStaticp_method)(EtsEnv *env, ets_class cls, const char *name, const char *sig); - ets_object (*CallStaticObjectMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); - ets_object (*CallStaticObjectMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); - ets_object (*CallStaticObjectMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); - ets_boolean (*CallStaticBooleanMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); - ets_boolean (*CallStaticBooleanMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); - ets_boolean (*CallStaticBooleanMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); - ets_byte (*CallStaticByteMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); - ets_byte (*CallStaticByteMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); - ets_byte (*CallStaticByteMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); - ets_char (*CallStaticCharMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); - ets_char (*CallStaticCharMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); - ets_char (*CallStaticCharMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); - ets_short (*CallStaticShortMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); - ets_short (*CallStaticShortMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); - ets_short (*CallStaticShortMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); - ets_int (*CallStaticIntMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); - ets_int (*CallStaticIntMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); - ets_int (*CallStaticIntMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); - ets_long (*CallStaticLongMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); - ets_long (*CallStaticLongMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); - ets_long (*CallStaticLongMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); - ets_float (*CallStaticFloatMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); - ets_float (*CallStaticFloatMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); - ets_float (*CallStaticFloatMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); - ets_double (*CallStaticDoubleMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); - ets_double (*CallStaticDoubleMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); - ets_double (*CallStaticDoubleMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); - void (*CallStaticVoidMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); - void (*CallStaticVoidMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); - void (*CallStaticVoidMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); + ets_object (*GetObjectField)(EtsEnv *env, ets_object obj, ets_field field); + ets_boolean (*GetBooleanField)(EtsEnv *env, ets_object obj, ets_field field); + ets_byte (*GetByteField)(EtsEnv *env, ets_object obj, ets_field field); + ets_char (*GetCharField)(EtsEnv *env, ets_object obj, ets_field field); + ets_short (*GetShortField)(EtsEnv *env, ets_object obj, ets_field field); + ets_int (*GetIntField)(EtsEnv *env, ets_object obj, ets_field field); + ets_long (*GetLongField)(EtsEnv *env, ets_object obj, ets_field field); + ets_float (*GetFloatField)(EtsEnv *env, ets_object obj, ets_field field); + ets_double (*GetDoubleField)(EtsEnv *env, ets_object obj, ets_field field); + void (*SetObjectField)(EtsEnv *env, ets_object obj, ets_field field, ets_object value); + void (*SetBooleanField)(EtsEnv *env, ets_object obj, ets_field field, ets_boolean value); + void (*SetByteField)(EtsEnv *env, ets_object obj, ets_field field, ets_byte value); + void (*SetCharField)(EtsEnv *env, ets_object obj, ets_field field, ets_char value); + void (*SetShortField)(EtsEnv *env, ets_object obj, ets_field field, ets_short value); + void (*SetIntField)(EtsEnv *env, ets_object obj, ets_field field, ets_int value); + void (*SetLongField)(EtsEnv *env, ets_object obj, ets_field field, ets_long value); + void (*SetFloatField)(EtsEnv *env, ets_object obj, ets_field field, ets_float value); + void (*SetDoubleField)(EtsEnv *env, ets_object obj, ets_field field, ets_double value); + ets_method (*GetStaticMethod)(EtsEnv *env, ets_class cls, const char *name, const char *sig); + ets_object (*CallStaticObjectMethod)(EtsEnv *env, ets_class cls, ets_method method, ...); + ets_object (*CallStaticObjectMethodList)(EtsEnv *env, ets_class cls, ets_method method, va_list args); + ets_object (*CallStaticObjectMethodArray)(EtsEnv *env, ets_class cls, ets_method method, ets_value *args); + ets_boolean (*CallStaticBooleanMethod)(EtsEnv *env, ets_class cls, ets_method method, ...); + ets_boolean (*CallStaticBooleanMethodList)(EtsEnv *env, ets_class cls, ets_method method, va_list args); + ets_boolean (*CallStaticBooleanMethodArray)(EtsEnv *env, ets_class cls, ets_method method, ets_value *args); + ets_byte (*CallStaticByteMethod)(EtsEnv *env, ets_class cls, ets_method method, ...); + ets_byte (*CallStaticByteMethodList)(EtsEnv *env, ets_class cls, ets_method method, va_list args); + ets_byte (*CallStaticByteMethodArray)(EtsEnv *env, ets_class cls, ets_method method, ets_value *args); + ets_char (*CallStaticCharMethod)(EtsEnv *env, ets_class cls, ets_method method, ...); + ets_char (*CallStaticCharMethodList)(EtsEnv *env, ets_class cls, ets_method method, va_list args); + ets_char (*CallStaticCharMethodArray)(EtsEnv *env, ets_class cls, ets_method method, ets_value *args); + ets_short (*CallStaticShortMethod)(EtsEnv *env, ets_class cls, ets_method method, ...); + ets_short (*CallStaticShortMethodList)(EtsEnv *env, ets_class cls, ets_method method, va_list args); + ets_short (*CallStaticShortMethodArray)(EtsEnv *env, ets_class cls, ets_method method, ets_value *args); + ets_int (*CallStaticIntMethod)(EtsEnv *env, ets_class cls, ets_method method, ...); + ets_int (*CallStaticIntMethodList)(EtsEnv *env, ets_class cls, ets_method method, va_list args); + ets_int (*CallStaticIntMethodArray)(EtsEnv *env, ets_class cls, ets_method method, ets_value *args); + ets_long (*CallStaticLongMethod)(EtsEnv *env, ets_class cls, ets_method method, ...); + ets_long (*CallStaticLongMethodList)(EtsEnv *env, ets_class cls, ets_method method, va_list args); + ets_long (*CallStaticLongMethodArray)(EtsEnv *env, ets_class cls, ets_method method, ets_value *args); + ets_float (*CallStaticFloatMethod)(EtsEnv *env, ets_class cls, ets_method method, ...); + ets_float (*CallStaticFloatMethodList)(EtsEnv *env, ets_class cls, ets_method method, va_list args); + ets_float (*CallStaticFloatMethodArray)(EtsEnv *env, ets_class cls, ets_method method, ets_value *args); + ets_double (*CallStaticDoubleMethod)(EtsEnv *env, ets_class cls, ets_method method, ...); + ets_double (*CallStaticDoubleMethodList)(EtsEnv *env, ets_class cls, ets_method method, va_list args); + ets_double (*CallStaticDoubleMethodArray)(EtsEnv *env, ets_class cls, ets_method method, ets_value *args); + void (*CallStaticVoidMethod)(EtsEnv *env, ets_class cls, ets_method method, ...); + void (*CallStaticVoidMethodList)(EtsEnv *env, ets_class cls, ets_method method, va_list args); + void (*CallStaticVoidMethodArray)(EtsEnv *env, ets_class cls, ets_method method, ets_value *args); ets_field (*GetStaticp_field)(EtsEnv *env, ets_class cls, const char *name, const char *sig); - ets_object (*GetStaticObjectField)(EtsEnv *env, ets_class cls, ets_field p_field); - ets_boolean (*GetStaticBooleanField)(EtsEnv *env, ets_class cls, ets_field p_field); - ets_byte (*GetStaticByteField)(EtsEnv *env, ets_class cls, ets_field p_field); - ets_char (*GetStaticCharField)(EtsEnv *env, ets_class cls, ets_field p_field); - ets_short (*GetStaticShortField)(EtsEnv *env, ets_class cls, ets_field p_field); - ets_int (*GetStaticIntField)(EtsEnv *env, ets_class cls, ets_field p_field); - ets_long (*GetStaticLongField)(EtsEnv *env, ets_class cls, ets_field p_field); - ets_float (*GetStaticFloatField)(EtsEnv *env, ets_class cls, ets_field p_field); - ets_double (*GetStaticDoubleField)(EtsEnv *env, ets_class cls, ets_field p_field); - void (*SetStaticObjectField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_object value); - void (*SetStaticBooleanField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_boolean value); - void (*SetStaticByteField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_byte value); - void (*SetStaticCharField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_char value); - void (*SetStaticShortField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_short value); - void (*SetStaticIntField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_int value); - void (*SetStaticLongField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_long value); - void (*SetStaticFloatField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_float value); - void (*SetStaticDoubleField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_double value); + ets_object (*GetStaticObjectField)(EtsEnv *env, ets_class cls, ets_field field); + ets_boolean (*GetStaticBooleanField)(EtsEnv *env, ets_class cls, ets_field field); + ets_byte (*GetStaticByteField)(EtsEnv *env, ets_class cls, ets_field field); + ets_char (*GetStaticCharField)(EtsEnv *env, ets_class cls, ets_field field); + ets_short (*GetStaticShortField)(EtsEnv *env, ets_class cls, ets_field field); + ets_int (*GetStaticIntField)(EtsEnv *env, ets_class cls, ets_field field); + ets_long (*GetStaticLongField)(EtsEnv *env, ets_class cls, ets_field field); + ets_float (*GetStaticFloatField)(EtsEnv *env, ets_class cls, ets_field field); + ets_double (*GetStaticDoubleField)(EtsEnv *env, ets_class cls, ets_field field); + void (*SetStaticObjectField)(EtsEnv *env, ets_class cls, ets_field field, ets_object value); + void (*SetStaticBooleanField)(EtsEnv *env, ets_class cls, ets_field field, ets_boolean value); + void (*SetStaticByteField)(EtsEnv *env, ets_class cls, ets_field field, ets_byte value); + void (*SetStaticCharField)(EtsEnv *env, ets_class cls, ets_field field, ets_char value); + void (*SetStaticShortField)(EtsEnv *env, ets_class cls, ets_field field, ets_short value); + void (*SetStaticIntField)(EtsEnv *env, ets_class cls, ets_field field, ets_int value); + void (*SetStaticLongField)(EtsEnv *env, ets_class cls, ets_field field, ets_long value); + void (*SetStaticFloatField)(EtsEnv *env, ets_class cls, ets_field field, ets_float value); + void (*SetStaticDoubleField)(EtsEnv *env, ets_class cls, ets_field field, ets_double value); ets_string (*NewString)(EtsEnv *env, const ets_char *unicodeChars, ets_size len); ets_size (*GetStringLength)(EtsEnv *env, ets_string string); const ets_char *(*GetStringChars)(EtsEnv *env, ets_string string, ets_boolean *isCopy); @@ -368,8 +368,8 @@ struct ETS_NativeInterface { const char *(*GetStringUTFChars)(EtsEnv *env, ets_string string, ets_boolean *isCopy); void (*ReleaseStringUTFChars)(EtsEnv *env, ets_string string, const char *utf); ets_size (*GetArrayLength)(EtsEnv *env, ets_array array); - ets_objectArray (*NewObjectsArray)(EtsEnv *env, ets_size length, ets_class element_class, - ets_object initial_element); + ets_objectArray (*NewObjectsArray)(EtsEnv *env, ets_size length, ets_class elementClass, + ets_object initialElement); ets_object (*GetObjectArrayElement)(EtsEnv *env, ets_objectArray array, ets_size index); void (*SetObjectArrayElement)(EtsEnv *env, ets_objectArray array, ets_size index, ets_object value); ets_booleanArray (*NewBooleanArray)(EtsEnv *env, ets_size length); @@ -524,1018 +524,1018 @@ struct __EtsVM { struct __EtsEnv { // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) - const struct ETS_NativeInterface* native_interface; + const struct ETS_NativeInterface* nativeInterface; #ifdef __cplusplus ets_int GetVersion() { - return native_interface->GetVersion(this); + return nativeInterface->GetVersion(this); } // DefineClass, ets_class FindClass(const char* name) { - return native_interface->FindClass(this, name); + return nativeInterface->FindClass(this, name); } // FromReflectedMethod, // FromReflectedField, // ToReflectedMethod, ets_class GetSuperclass(ets_class cls) { - return native_interface->GetSuperclass(this, cls); + return nativeInterface->GetSuperclass(this, cls); } ets_boolean IsAssignableFrom(ets_class cls1, ets_class cls2) { - return native_interface->IsAssignableFrom(this, cls1, cls2); + return nativeInterface->IsAssignableFrom(this, cls1, cls2); } // ToReflectedField, ets_int ThrowError(ets_error obj) { - return native_interface->ThrowError(this, obj); + return nativeInterface->ThrowError(this, obj); } ets_int ThrowErrorNew(ets_class cls, const char* message) { - return native_interface->ThrowErrorNew(this, cls, message); + return nativeInterface->ThrowErrorNew(this, cls, message); } ets_error ErrorOccurred() { - return native_interface->ErrorOccurred(this); + return nativeInterface->ErrorOccurred(this); } void ErrorDescribe() { - native_interface->ErrorDescribe(this); + nativeInterface->ErrorDescribe(this); } void ErrorClear() { - native_interface->ErrorClear(this); + nativeInterface->ErrorClear(this); } void FatalError(const char* message) { - native_interface->FatalError(this, message); + nativeInterface->FatalError(this, message); } ets_int PushLocalFrame(ets_int capacity) { - return native_interface->PushLocalFrame(this, capacity); + return nativeInterface->PushLocalFrame(this, capacity); } ets_object PopLocalFrame(ets_object result) { - return native_interface->PopLocalFrame(this, result); + return nativeInterface->PopLocalFrame(this, result); } ets_object NewGlobalRef(ets_object obj) { - return native_interface->NewGlobalRef(this, obj); + return nativeInterface->NewGlobalRef(this, obj); } void DeleteGlobalRef(ets_object globalRef) { - native_interface->DeleteGlobalRef(this, globalRef); + nativeInterface->DeleteGlobalRef(this, globalRef); } void DeleteLocalRef(ets_object localRef) { - native_interface->DeleteLocalRef(this, localRef); + nativeInterface->DeleteLocalRef(this, localRef); } ets_boolean IsSameObject(ets_object ref1, ets_object ref2) { - return native_interface->IsSameObject(this, ref1, ref2); + return nativeInterface->IsSameObject(this, ref1, ref2); } ets_object NewLocalRef(ets_object ref) { - return native_interface->NewLocalRef(this, ref); + return nativeInterface->NewLocalRef(this, ref); } ets_int EnsureLocalCapacity(ets_int capacity) { - return native_interface->EnsureLocalCapacity(this, capacity); + return nativeInterface->EnsureLocalCapacity(this, capacity); } ets_object AllocObject(ets_class cls) { - return native_interface->AllocObject(this, cls); + return nativeInterface->AllocObject(this, cls); } - ets_object NewObject(ets_class cls, ets_method p_method, ...) + ets_object NewObject(ets_class cls, ets_method method, ...) { va_list args; - va_start(args, p_method); - ets_object ret = native_interface->NewObjectList(this, cls, p_method, args); + va_start(args, method); + ets_object ret = nativeInterface->NewObjectList(this, cls, method, args); va_end(args); return ret; } - ets_object NewObjectList(ets_class cls, ets_method p_method, va_list args) + ets_object NewObjectList(ets_class cls, ets_method method, va_list args) { - return native_interface->NewObjectList(this, cls, p_method, args); + return nativeInterface->NewObjectList(this, cls, method, args); } - ets_object NewObjectArray(ets_class cls, ets_method p_method, const ets_value* args) + ets_object NewObjectArray(ets_class cls, ets_method method, const ets_value* args) { - return native_interface->NewObjectArray(this, cls, p_method, args); + return nativeInterface->NewObjectArray(this, cls, method, args); } ets_class GetObjectClass(ets_object obj) { - return native_interface->GetObjectClass(this, obj); + return nativeInterface->GetObjectClass(this, obj); } ets_boolean IsInstanceOf(ets_object obj, ets_class cls) { - return native_interface->IsInstanceOf(this, obj, cls); + return nativeInterface->IsInstanceOf(this, obj, cls); } - ets_method Getp_method(ets_class cls, const char* name, const char* sig) + ets_method GetMethod(ets_class cls, const char* name, const char* sig) { - return native_interface->Getp_method(this, cls, name, sig); + return nativeInterface->GetMethod(this, cls, name, sig); } - ets_object CallObjectMethod(ets_object obj, ets_method method_id, ...) + ets_object CallObjectMethod(ets_object obj, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_object res = native_interface->CallObjectMethodList(this, obj, method_id, args); + va_start(args, methodId); + ets_object res = nativeInterface->CallObjectMethodList(this, obj, methodId, args); va_end(args); return res; } - ets_object CallObjectMethodList(ets_object obj, ets_method method_id, va_list args) + ets_object CallObjectMethodList(ets_object obj, ets_method methodId, va_list args) { - return native_interface->CallObjectMethodList(this, obj, method_id, args); + return nativeInterface->CallObjectMethodList(this, obj, methodId, args); } - ets_object CallObjectMethodArray(ets_object obj, ets_method method_id, const ets_value* args) + ets_object CallObjectMethodArray(ets_object obj, ets_method methodId, const ets_value* args) { - return native_interface->CallObjectMethodArray(this, obj, method_id, args); + return nativeInterface->CallObjectMethodArray(this, obj, methodId, args); } - ets_boolean CallBooleanMethod(ets_object obj, ets_method method_id, ...) + ets_boolean CallBooleanMethod(ets_object obj, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_boolean res = native_interface->CallBooleanMethodList(this, obj, method_id, args); + va_start(args, methodId); + ets_boolean res = nativeInterface->CallBooleanMethodList(this, obj, methodId, args); va_end(args); return res; } - ets_boolean CallBooleanMethodList(ets_object obj, ets_method method_id, va_list args) + ets_boolean CallBooleanMethodList(ets_object obj, ets_method methodId, va_list args) { - return native_interface->CallBooleanMethodList(this, obj, method_id, args); + return nativeInterface->CallBooleanMethodList(this, obj, methodId, args); } - ets_boolean CallBooleanMethodArray(ets_object obj, ets_method method_id, const ets_value* args) + ets_boolean CallBooleanMethodArray(ets_object obj, ets_method methodId, const ets_value* args) { - return native_interface->CallBooleanMethodArray(this, obj, method_id, args); + return nativeInterface->CallBooleanMethodArray(this, obj, methodId, args); } - ets_byte CallByteMethod(ets_object obj, ets_method method_id, ...) + ets_byte CallByteMethod(ets_object obj, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_byte res = native_interface->CallByteMethodList(this, obj, method_id, args); + va_start(args, methodId); + ets_byte res = nativeInterface->CallByteMethodList(this, obj, methodId, args); va_end(args); return res; } - ets_byte CallByteMethodList(ets_object obj, ets_method method_id, va_list args) + ets_byte CallByteMethodList(ets_object obj, ets_method methodId, va_list args) { - return native_interface->CallByteMethodList(this, obj, method_id, args); + return nativeInterface->CallByteMethodList(this, obj, methodId, args); } - ets_byte CallByteMethodArray(ets_object obj, ets_method method_id, const ets_value* args) + ets_byte CallByteMethodArray(ets_object obj, ets_method methodId, const ets_value* args) { - return native_interface->CallByteMethodArray(this, obj, method_id, args); + return nativeInterface->CallByteMethodArray(this, obj, methodId, args); } - ets_char CallCharMethod(ets_object obj, ets_method method_id, ...) + ets_char CallCharMethod(ets_object obj, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_char res = native_interface->CallCharMethodList(this, obj, method_id, args); + va_start(args, methodId); + ets_char res = nativeInterface->CallCharMethodList(this, obj, methodId, args); va_end(args); return res; } - ets_char CallCharMethodList(ets_object obj, ets_method method_id, va_list args) + ets_char CallCharMethodList(ets_object obj, ets_method methodId, va_list args) { - return native_interface->CallCharMethodList(this, obj, method_id, args); + return nativeInterface->CallCharMethodList(this, obj, methodId, args); } - ets_char CallCharMethodArray(ets_object obj, ets_method method_id, const ets_value* args) + ets_char CallCharMethodArray(ets_object obj, ets_method methodId, const ets_value* args) { - return native_interface->CallCharMethodArray(this, obj, method_id, args); + return nativeInterface->CallCharMethodArray(this, obj, methodId, args); } - ets_short CallShortMethod(ets_object obj, ets_method method_id, ...) + ets_short CallShortMethod(ets_object obj, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_short res = native_interface->CallShortMethodList(this, obj, method_id, args); + va_start(args, methodId); + ets_short res = nativeInterface->CallShortMethodList(this, obj, methodId, args); va_end(args); return res; } - ets_short CallShortMethodList(ets_object obj, ets_method method_id, va_list args) + ets_short CallShortMethodList(ets_object obj, ets_method methodId, va_list args) { - return native_interface->CallShortMethodList(this, obj, method_id, args); + return nativeInterface->CallShortMethodList(this, obj, methodId, args); } - ets_short CallShortMethodArray(ets_object obj, ets_method method_id, const ets_value* args) + ets_short CallShortMethodArray(ets_object obj, ets_method methodId, const ets_value* args) { - return native_interface->CallShortMethodArray(this, obj, method_id, args); + return nativeInterface->CallShortMethodArray(this, obj, methodId, args); } - ets_int CallIntMethod(ets_object obj, ets_method method_id, ...) + ets_int CallIntMethod(ets_object obj, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_int res = native_interface->CallIntMethodList(this, obj, method_id, args); + va_start(args, methodId); + ets_int res = nativeInterface->CallIntMethodList(this, obj, methodId, args); va_end(args); return res; } - ets_int CallIntMethodList(ets_object obj, ets_method method_id, va_list args) + ets_int CallIntMethodList(ets_object obj, ets_method methodId, va_list args) { - return native_interface->CallIntMethodList(this, obj, method_id, args); + return nativeInterface->CallIntMethodList(this, obj, methodId, args); } - ets_int CallIntMethodArray(ets_object obj, ets_method method_id, const ets_value* args) + ets_int CallIntMethodArray(ets_object obj, ets_method methodId, const ets_value* args) { - return native_interface->CallIntMethodArray(this, obj, method_id, args); + return nativeInterface->CallIntMethodArray(this, obj, methodId, args); } - ets_long CallLongMethod(ets_object obj, ets_method method_id, ...) + ets_long CallLongMethod(ets_object obj, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_long res = native_interface->CallLongMethodList(this, obj, method_id, args); + va_start(args, methodId); + ets_long res = nativeInterface->CallLongMethodList(this, obj, methodId, args); va_end(args); return res; } - ets_long CallLongMethodList(ets_object obj, ets_method method_id, va_list args) + ets_long CallLongMethodList(ets_object obj, ets_method methodId, va_list args) { - return native_interface->CallLongMethodList(this, obj, method_id, args); + return nativeInterface->CallLongMethodList(this, obj, methodId, args); } - ets_long CallLongMethodArray(ets_object obj, ets_method method_id, const ets_value* args) + ets_long CallLongMethodArray(ets_object obj, ets_method methodId, const ets_value* args) { - return native_interface->CallLongMethodArray(this, obj, method_id, args); + return nativeInterface->CallLongMethodArray(this, obj, methodId, args); } - ets_float CallFloatMethod(ets_object obj, ets_method method_id, ...) + ets_float CallFloatMethod(ets_object obj, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_float res = native_interface->CallFloatMethodList(this, obj, method_id, args); + va_start(args, methodId); + ets_float res = nativeInterface->CallFloatMethodList(this, obj, methodId, args); va_end(args); return res; } - ets_float CallFloatMethodList(ets_object obj, ets_method method_id, va_list args) + ets_float CallFloatMethodList(ets_object obj, ets_method methodId, va_list args) { - return native_interface->CallFloatMethodList(this, obj, method_id, args); + return nativeInterface->CallFloatMethodList(this, obj, methodId, args); } - ets_float CallFloatMethodArray(ets_object obj, ets_method method_id, const ets_value* args) + ets_float CallFloatMethodArray(ets_object obj, ets_method methodId, const ets_value* args) { - return native_interface->CallFloatMethodArray(this, obj, method_id, args); + return nativeInterface->CallFloatMethodArray(this, obj, methodId, args); } - ets_double CallDoubleMethod(ets_object obj, ets_method method_id, ...) + ets_double CallDoubleMethod(ets_object obj, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_double res = native_interface->CallDoubleMethodList(this, obj, method_id, args); + va_start(args, methodId); + ets_double res = nativeInterface->CallDoubleMethodList(this, obj, methodId, args); va_end(args); return res; } - ets_double CallDoubleMethodList(ets_object obj, ets_method method_id, va_list args) + ets_double CallDoubleMethodList(ets_object obj, ets_method methodId, va_list args) { - return native_interface->CallDoubleMethodList(this, obj, method_id, args); + return nativeInterface->CallDoubleMethodList(this, obj, methodId, args); } - ets_double CallDoubleMethodArray(ets_object obj, ets_method method_id, const ets_value* args) + ets_double CallDoubleMethodArray(ets_object obj, ets_method methodId, const ets_value* args) { - return native_interface->CallDoubleMethodArray(this, obj, method_id, args); + return nativeInterface->CallDoubleMethodArray(this, obj, methodId, args); } - void CallVoidMethod(ets_object obj, ets_method method_id, ...) + void CallVoidMethod(ets_object obj, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - native_interface->CallVoidMethodList(this, obj, method_id, args); + va_start(args, methodId); + nativeInterface->CallVoidMethodList(this, obj, methodId, args); va_end(args); } - void CallVoidMethodList(ets_object obj, ets_method method_id, va_list args) + void CallVoidMethodList(ets_object obj, ets_method methodId, va_list args) { - native_interface->CallVoidMethodList(this, obj, method_id, args); + nativeInterface->CallVoidMethodList(this, obj, methodId, args); } - void CallVoidMethodArray(ets_object obj, ets_method method_id, const ets_value* args) + void CallVoidMethodArray(ets_object obj, ets_method methodId, const ets_value* args) { - native_interface->CallVoidMethodArray(this, obj, method_id, args); + nativeInterface->CallVoidMethodArray(this, obj, methodId, args); } - ets_object CallNonvirtualObjectMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + ets_object CallNonvirtualObjectMethod(ets_object obj, ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_object res = native_interface->CallNonvirtualObjectMethodList(this, obj, cls, method_id, args); + va_start(args, methodId); + ets_object res = nativeInterface->CallNonvirtualObjectMethodList(this, obj, cls, methodId, args); va_end(args); return res; } - ets_object CallNonvirtualObjectMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + ets_object CallNonvirtualObjectMethodList(ets_object obj, ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallNonvirtualObjectMethodList(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualObjectMethodList(this, obj, cls, methodId, args); } ets_object CallNonvirtualObjectMethodArray( - ets_object obj, ets_class cls, ets_method method_id, const ets_value* args) + ets_object obj, ets_class cls, ets_method methodId, const ets_value* args) { - return native_interface->CallNonvirtualObjectMethodArray(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualObjectMethodArray(this, obj, cls, methodId, args); } - ets_boolean CallNonvirtualBooleanMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + ets_boolean CallNonvirtualBooleanMethod(ets_object obj, ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_boolean res = native_interface->CallNonvirtualBooleanMethodList(this, obj, cls, method_id, args); + va_start(args, methodId); + ets_boolean res = nativeInterface->CallNonvirtualBooleanMethodList(this, obj, cls, methodId, args); va_end(args); return res; } - ets_boolean CallNonvirtualBooleanMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + ets_boolean CallNonvirtualBooleanMethodList(ets_object obj, ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallNonvirtualBooleanMethodList(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualBooleanMethodList(this, obj, cls, methodId, args); } ets_boolean CallNonvirtualBooleanMethodArray( - ets_object obj, ets_class cls, ets_method method_id, const ets_value* args) + ets_object obj, ets_class cls, ets_method methodId, const ets_value* args) { - return native_interface->CallNonvirtualBooleanMethodArray(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualBooleanMethodArray(this, obj, cls, methodId, args); } - ets_byte CallNonvirtualByteMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + ets_byte CallNonvirtualByteMethod(ets_object obj, ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_byte res = native_interface->CallNonvirtualByteMethodList(this, obj, cls, method_id, args); + va_start(args, methodId); + ets_byte res = nativeInterface->CallNonvirtualByteMethodList(this, obj, cls, methodId, args); va_end(args); return res; } - ets_byte CallNonvirtualByteMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + ets_byte CallNonvirtualByteMethodList(ets_object obj, ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallNonvirtualByteMethodList(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualByteMethodList(this, obj, cls, methodId, args); } - ets_byte CallNonvirtualByteMethodArray(ets_object obj, ets_class cls, ets_method method_id, const ets_value* args) + ets_byte CallNonvirtualByteMethodArray(ets_object obj, ets_class cls, ets_method methodId, const ets_value* args) { - return native_interface->CallNonvirtualByteMethodArray(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualByteMethodArray(this, obj, cls, methodId, args); } - ets_char CallNonvirtualCharMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + ets_char CallNonvirtualCharMethod(ets_object obj, ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_char res = native_interface->CallNonvirtualCharMethodList(this, obj, cls, method_id, args); + va_start(args, methodId); + ets_char res = nativeInterface->CallNonvirtualCharMethodList(this, obj, cls, methodId, args); va_end(args); return res; } - ets_char CallNonvirtualCharMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + ets_char CallNonvirtualCharMethodList(ets_object obj, ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallNonvirtualCharMethodList(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualCharMethodList(this, obj, cls, methodId, args); } - ets_char CallNonvirtualCharMethodArray(ets_object obj, ets_class cls, ets_method method_id, const ets_value* args) + ets_char CallNonvirtualCharMethodArray(ets_object obj, ets_class cls, ets_method methodId, const ets_value* args) { - return native_interface->CallNonvirtualCharMethodArray(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualCharMethodArray(this, obj, cls, methodId, args); } - ets_short CallNonvirtualShortMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + ets_short CallNonvirtualShortMethod(ets_object obj, ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_short res = native_interface->CallNonvirtualShortMethodList(this, obj, cls, method_id, args); + va_start(args, methodId); + ets_short res = nativeInterface->CallNonvirtualShortMethodList(this, obj, cls, methodId, args); va_end(args); return res; } - ets_short CallNonvirtualShortMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + ets_short CallNonvirtualShortMethodList(ets_object obj, ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallNonvirtualShortMethodList(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualShortMethodList(this, obj, cls, methodId, args); } - ets_short CallNonvirtualShortMethodArray(ets_object obj, ets_class cls, ets_method method_id, const ets_value* args) + ets_short CallNonvirtualShortMethodArray(ets_object obj, ets_class cls, ets_method methodId, const ets_value* args) { - return native_interface->CallNonvirtualShortMethodArray(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualShortMethodArray(this, obj, cls, methodId, args); } - ets_int CallNonvirtualIntMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + ets_int CallNonvirtualIntMethod(ets_object obj, ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_int res = native_interface->CallNonvirtualIntMethodList(this, obj, cls, method_id, args); + va_start(args, methodId); + ets_int res = nativeInterface->CallNonvirtualIntMethodList(this, obj, cls, methodId, args); va_end(args); return res; } - ets_int CallNonvirtualIntMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + ets_int CallNonvirtualIntMethodList(ets_object obj, ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallNonvirtualIntMethodList(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualIntMethodList(this, obj, cls, methodId, args); } - ets_int CallNonvirtualIntMethodArray(ets_object obj, ets_class cls, ets_method method_id, const ets_value* args) + ets_int CallNonvirtualIntMethodArray(ets_object obj, ets_class cls, ets_method methodId, const ets_value* args) { - return native_interface->CallNonvirtualIntMethodArray(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualIntMethodArray(this, obj, cls, methodId, args); } - ets_long CallNonvirtualLongMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + ets_long CallNonvirtualLongMethod(ets_object obj, ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_long res = native_interface->CallNonvirtualLongMethodList(this, obj, cls, method_id, args); + va_start(args, methodId); + ets_long res = nativeInterface->CallNonvirtualLongMethodList(this, obj, cls, methodId, args); va_end(args); return res; } - ets_long CallNonvirtualLongMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + ets_long CallNonvirtualLongMethodList(ets_object obj, ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallNonvirtualLongMethodList(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualLongMethodList(this, obj, cls, methodId, args); } - ets_long CallNonvirtualLongMethodArray(ets_object obj, ets_class cls, ets_method method_id, const ets_value* args) + ets_long CallNonvirtualLongMethodArray(ets_object obj, ets_class cls, ets_method methodId, const ets_value* args) { - return native_interface->CallNonvirtualLongMethodArray(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualLongMethodArray(this, obj, cls, methodId, args); } - ets_float CallNonvirtualFloatMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + ets_float CallNonvirtualFloatMethod(ets_object obj, ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_float res = native_interface->CallNonvirtualFloatMethodList(this, obj, cls, method_id, args); + va_start(args, methodId); + ets_float res = nativeInterface->CallNonvirtualFloatMethodList(this, obj, cls, methodId, args); va_end(args); return res; } - ets_float CallNonvirtualFloatMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + ets_float CallNonvirtualFloatMethodList(ets_object obj, ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallNonvirtualFloatMethodList(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualFloatMethodList(this, obj, cls, methodId, args); } - ets_float CallNonvirtualFloatMethodArray(ets_object obj, ets_class cls, ets_method method_id, const ets_value* args) + ets_float CallNonvirtualFloatMethodArray(ets_object obj, ets_class cls, ets_method methodId, const ets_value* args) { - return native_interface->CallNonvirtualFloatMethodArray(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualFloatMethodArray(this, obj, cls, methodId, args); } - ets_double CallNonvirtualDoubleMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + ets_double CallNonvirtualDoubleMethod(ets_object obj, ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_double res = native_interface->CallNonvirtualDoubleMethodList(this, obj, cls, method_id, args); + va_start(args, methodId); + ets_double res = nativeInterface->CallNonvirtualDoubleMethodList(this, obj, cls, methodId, args); va_end(args); return res; } - ets_double CallNonvirtualDoubleMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + ets_double CallNonvirtualDoubleMethodList(ets_object obj, ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallNonvirtualDoubleMethodList(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualDoubleMethodList(this, obj, cls, methodId, args); } ets_double CallNonvirtualDoubleMethodArray( - ets_object obj, ets_class cls, ets_method method_id, const ets_value* args) + ets_object obj, ets_class cls, ets_method methodId, const ets_value* args) { - return native_interface->CallNonvirtualDoubleMethodArray(this, obj, cls, method_id, args); + return nativeInterface->CallNonvirtualDoubleMethodArray(this, obj, cls, methodId, args); } - void CallNonvirtualVoidMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + void CallNonvirtualVoidMethod(ets_object obj, ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - native_interface->CallNonvirtualVoidMethodList(this, obj, cls, method_id, args); + va_start(args, methodId); + nativeInterface->CallNonvirtualVoidMethodList(this, obj, cls, methodId, args); va_end(args); } - void CallNonvirtualVoidMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + void CallNonvirtualVoidMethodList(ets_object obj, ets_class cls, ets_method methodId, va_list args) { - native_interface->CallNonvirtualVoidMethodList(this, obj, cls, method_id, args); + nativeInterface->CallNonvirtualVoidMethodList(this, obj, cls, methodId, args); } - void CallNonvirtualVoidMethodArray(ets_object obj, ets_class cls, ets_method method_id, const ets_value* args) + void CallNonvirtualVoidMethodArray(ets_object obj, ets_class cls, ets_method methodId, const ets_value* args) { - native_interface->CallNonvirtualVoidMethodArray(this, obj, cls, method_id, args); + nativeInterface->CallNonvirtualVoidMethodArray(this, obj, cls, methodId, args); } ets_field Getp_field(ets_class cls, const char* name, const char* sig) { - return native_interface->Getp_field(this, cls, name, sig); + return nativeInterface->Getp_field(this, cls, name, sig); } - ets_object GetObjectField(ets_object obj, ets_field p_field) + ets_object GetObjectField(ets_object obj, ets_field field) { - return native_interface->GetObjectField(this, obj, p_field); + return nativeInterface->GetObjectField(this, obj, field); } - ets_boolean GetBooleanField(ets_object obj, ets_field p_field) + ets_boolean GetBooleanField(ets_object obj, ets_field field) { - return native_interface->GetBooleanField(this, obj, p_field); + return nativeInterface->GetBooleanField(this, obj, field); } - ets_byte GetByteField(ets_object obj, ets_field p_field) + ets_byte GetByteField(ets_object obj, ets_field field) { - return native_interface->GetByteField(this, obj, p_field); + return nativeInterface->GetByteField(this, obj, field); } - ets_char GetCharField(ets_object obj, ets_field p_field) + ets_char GetCharField(ets_object obj, ets_field field) { - return native_interface->GetCharField(this, obj, p_field); + return nativeInterface->GetCharField(this, obj, field); } - ets_short GetShortField(ets_object obj, ets_field p_field) + ets_short GetShortField(ets_object obj, ets_field field) { - return native_interface->GetShortField(this, obj, p_field); + return nativeInterface->GetShortField(this, obj, field); } - ets_int GetIntField(ets_object obj, ets_field p_field) + ets_int GetIntField(ets_object obj, ets_field field) { - return native_interface->GetIntField(this, obj, p_field); + return nativeInterface->GetIntField(this, obj, field); } - ets_long GetLongField(ets_object obj, ets_field p_field) + ets_long GetLongField(ets_object obj, ets_field field) { - return native_interface->GetLongField(this, obj, p_field); + return nativeInterface->GetLongField(this, obj, field); } - ets_float GetFloatField(ets_object obj, ets_field p_field) + ets_float GetFloatField(ets_object obj, ets_field field) { - return native_interface->GetFloatField(this, obj, p_field); + return nativeInterface->GetFloatField(this, obj, field); } - ets_double GetDoubleField(ets_object obj, ets_field p_field) + ets_double GetDoubleField(ets_object obj, ets_field field) { - return native_interface->GetDoubleField(this, obj, p_field); + return nativeInterface->GetDoubleField(this, obj, field); } - void SetObjectField(ets_object obj, ets_field p_field, ets_object value) + void SetObjectField(ets_object obj, ets_field field, ets_object value) { - return native_interface->SetObjectField(this, obj, p_field, value); + return nativeInterface->SetObjectField(this, obj, field, value); } - void SetBooleanField(ets_object obj, ets_field p_field, ets_boolean value) + void SetBooleanField(ets_object obj, ets_field field, ets_boolean value) { - return native_interface->SetBooleanField(this, obj, p_field, value); + return nativeInterface->SetBooleanField(this, obj, field, value); } - void SetByteField(ets_object obj, ets_field p_field, ets_byte value) + void SetByteField(ets_object obj, ets_field field, ets_byte value) { - return native_interface->SetByteField(this, obj, p_field, value); + return nativeInterface->SetByteField(this, obj, field, value); } - void SetCharField(ets_object obj, ets_field p_field, ets_char value) + void SetCharField(ets_object obj, ets_field field, ets_char value) { - return native_interface->SetCharField(this, obj, p_field, value); + return nativeInterface->SetCharField(this, obj, field, value); } - void SetShortField(ets_object obj, ets_field p_field, ets_short value) + void SetShortField(ets_object obj, ets_field field, ets_short value) { - return native_interface->SetShortField(this, obj, p_field, value); + return nativeInterface->SetShortField(this, obj, field, value); } - void SetIntField(ets_object obj, ets_field p_field, ets_int value) + void SetIntField(ets_object obj, ets_field field, ets_int value) { - return native_interface->SetIntField(this, obj, p_field, value); + return nativeInterface->SetIntField(this, obj, field, value); } - void SetLongField(ets_object obj, ets_field p_field, ets_long value) + void SetLongField(ets_object obj, ets_field field, ets_long value) { - return native_interface->SetLongField(this, obj, p_field, value); + return nativeInterface->SetLongField(this, obj, field, value); } - void SetFloatField(ets_object obj, ets_field p_field, ets_float value) + void SetFloatField(ets_object obj, ets_field field, ets_float value) { - return native_interface->SetFloatField(this, obj, p_field, value); + return nativeInterface->SetFloatField(this, obj, field, value); } - void SetDoubleField(ets_object obj, ets_field p_field, ets_double value) + void SetDoubleField(ets_object obj, ets_field field, ets_double value) { - return native_interface->SetDoubleField(this, obj, p_field, value); + return nativeInterface->SetDoubleField(this, obj, field, value); } - ets_method GetStaticp_method(ets_class cls, const char* name, const char* sig) + ets_method GetStaticMethod(ets_class cls, const char* name, const char* sig) { - return native_interface->GetStaticp_method(this, cls, name, sig); + return nativeInterface->GetStaticMethod(this, cls, name, sig); } - ets_object CallStaticObjectMethod(ets_class cls, ets_method method_id, ...) + ets_object CallStaticObjectMethod(ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_object res = native_interface->CallStaticObjectMethodList(this, cls, method_id, args); + va_start(args, methodId); + ets_object res = nativeInterface->CallStaticObjectMethodList(this, cls, methodId, args); va_end(args); return res; } - ets_object CallStaticObjectMethodList(ets_class cls, ets_method method_id, va_list args) + ets_object CallStaticObjectMethodList(ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallStaticObjectMethodList(this, cls, method_id, args); + return nativeInterface->CallStaticObjectMethodList(this, cls, methodId, args); } - ets_object CallStaticObjectMethodArray(ets_class cls, ets_method method_id, ets_value* args) + ets_object CallStaticObjectMethodArray(ets_class cls, ets_method methodId, ets_value* args) { - return native_interface->CallStaticObjectMethodArray(this, cls, method_id, args); + return nativeInterface->CallStaticObjectMethodArray(this, cls, methodId, args); } - ets_boolean CallStaticBooleanMethod(ets_class cls, ets_method method_id, ...) + ets_boolean CallStaticBooleanMethod(ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_boolean res = native_interface->CallStaticBooleanMethodList(this, cls, method_id, args); + va_start(args, methodId); + ets_boolean res = nativeInterface->CallStaticBooleanMethodList(this, cls, methodId, args); va_end(args); return res; } - ets_boolean CallStaticBooleanMethodList(ets_class cls, ets_method method_id, va_list args) + ets_boolean CallStaticBooleanMethodList(ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallStaticBooleanMethodList(this, cls, method_id, args); + return nativeInterface->CallStaticBooleanMethodList(this, cls, methodId, args); } - ets_boolean CallStaticBooleanMethodArray(ets_class cls, ets_method method_id, ets_value* args) + ets_boolean CallStaticBooleanMethodArray(ets_class cls, ets_method methodId, ets_value* args) { - return native_interface->CallStaticBooleanMethodArray(this, cls, method_id, args); + return nativeInterface->CallStaticBooleanMethodArray(this, cls, methodId, args); } - ets_byte CallStaticByteMethod(ets_class cls, ets_method method_id, ...) + ets_byte CallStaticByteMethod(ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_byte res = native_interface->CallStaticByteMethodList(this, cls, method_id, args); + va_start(args, methodId); + ets_byte res = nativeInterface->CallStaticByteMethodList(this, cls, methodId, args); va_end(args); return res; } - ets_byte CallStaticByteMethodList(ets_class cls, ets_method method_id, va_list args) + ets_byte CallStaticByteMethodList(ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallStaticByteMethodList(this, cls, method_id, args); + return nativeInterface->CallStaticByteMethodList(this, cls, methodId, args); } - ets_byte CallStaticByteMethodArray(ets_class cls, ets_method method_id, ets_value* args) + ets_byte CallStaticByteMethodArray(ets_class cls, ets_method methodId, ets_value* args) { - return native_interface->CallStaticByteMethodArray(this, cls, method_id, args); + return nativeInterface->CallStaticByteMethodArray(this, cls, methodId, args); } - ets_char CallStaticCharMethod(ets_class cls, ets_method method_id, ...) + ets_char CallStaticCharMethod(ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_char res = native_interface->CallStaticCharMethodList(this, cls, method_id, args); + va_start(args, methodId); + ets_char res = nativeInterface->CallStaticCharMethodList(this, cls, methodId, args); va_end(args); return res; } - ets_char CallStaticCharMethodList(ets_class cls, ets_method method_id, va_list args) + ets_char CallStaticCharMethodList(ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallStaticCharMethodList(this, cls, method_id, args); + return nativeInterface->CallStaticCharMethodList(this, cls, methodId, args); } - ets_char CallStaticCharMethodArray(ets_class cls, ets_method method_id, ets_value* args) + ets_char CallStaticCharMethodArray(ets_class cls, ets_method methodId, ets_value* args) { - return native_interface->CallStaticCharMethodArray(this, cls, method_id, args); + return nativeInterface->CallStaticCharMethodArray(this, cls, methodId, args); } - ets_short CallStaticShortMethod(ets_class cls, ets_method method_id, ...) + ets_short CallStaticShortMethod(ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_short res = native_interface->CallStaticShortMethodList(this, cls, method_id, args); + va_start(args, methodId); + ets_short res = nativeInterface->CallStaticShortMethodList(this, cls, methodId, args); va_end(args); return res; } - ets_short CallStaticShortMethodList(ets_class cls, ets_method method_id, va_list args) + ets_short CallStaticShortMethodList(ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallStaticShortMethodList(this, cls, method_id, args); + return nativeInterface->CallStaticShortMethodList(this, cls, methodId, args); } - ets_short CallStaticShortMethodArray(ets_class cls, ets_method method_id, ets_value* args) + ets_short CallStaticShortMethodArray(ets_class cls, ets_method methodId, ets_value* args) { - return native_interface->CallStaticShortMethodArray(this, cls, method_id, args); + return nativeInterface->CallStaticShortMethodArray(this, cls, methodId, args); } - ets_int CallStaticIntMethod(ets_class cls, ets_method method_id, ...) + ets_int CallStaticIntMethod(ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_int res = native_interface->CallStaticIntMethodList(this, cls, method_id, args); + va_start(args, methodId); + ets_int res = nativeInterface->CallStaticIntMethodList(this, cls, methodId, args); va_end(args); return res; } - ets_int CallStaticIntMethodList(ets_class cls, ets_method method_id, va_list args) + ets_int CallStaticIntMethodList(ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallStaticIntMethodList(this, cls, method_id, args); + return nativeInterface->CallStaticIntMethodList(this, cls, methodId, args); } - ets_int CallStaticIntMethodArray(ets_class cls, ets_method method_id, ets_value* args) + ets_int CallStaticIntMethodArray(ets_class cls, ets_method methodId, ets_value* args) { - return native_interface->CallStaticIntMethodArray(this, cls, method_id, args); + return nativeInterface->CallStaticIntMethodArray(this, cls, methodId, args); } - ets_long CallStaticLongMethod(ets_class cls, ets_method method_id, ...) + ets_long CallStaticLongMethod(ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_long res = native_interface->CallStaticLongMethodList(this, cls, method_id, args); + va_start(args, methodId); + ets_long res = nativeInterface->CallStaticLongMethodList(this, cls, methodId, args); va_end(args); return res; } - ets_long CallStaticLongMethodList(ets_class cls, ets_method method_id, va_list args) + ets_long CallStaticLongMethodList(ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallStaticLongMethodList(this, cls, method_id, args); + return nativeInterface->CallStaticLongMethodList(this, cls, methodId, args); } - ets_long CallStaticLongMethodArray(ets_class cls, ets_method method_id, ets_value* args) + ets_long CallStaticLongMethodArray(ets_class cls, ets_method methodId, ets_value* args) { - return native_interface->CallStaticLongMethodArray(this, cls, method_id, args); + return nativeInterface->CallStaticLongMethodArray(this, cls, methodId, args); } - ets_float CallStaticFloatMethod(ets_class cls, ets_method method_id, ...) + ets_float CallStaticFloatMethod(ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_float res = native_interface->CallStaticFloatMethodList(this, cls, method_id, args); + va_start(args, methodId); + ets_float res = nativeInterface->CallStaticFloatMethodList(this, cls, methodId, args); va_end(args); return res; } - ets_float CallStaticFloatMethodList(ets_class cls, ets_method method_id, va_list args) + ets_float CallStaticFloatMethodList(ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallStaticFloatMethodList(this, cls, method_id, args); + return nativeInterface->CallStaticFloatMethodList(this, cls, methodId, args); } - ets_float CallStaticFloatMethodArray(ets_class cls, ets_method method_id, ets_value* args) + ets_float CallStaticFloatMethodArray(ets_class cls, ets_method methodId, ets_value* args) { - return native_interface->CallStaticFloatMethodArray(this, cls, method_id, args); + return nativeInterface->CallStaticFloatMethodArray(this, cls, methodId, args); } - ets_double CallStaticDoubleMethod(ets_class cls, ets_method method_id, ...) + ets_double CallStaticDoubleMethod(ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - ets_double res = native_interface->CallStaticDoubleMethodList(this, cls, method_id, args); + va_start(args, methodId); + ets_double res = nativeInterface->CallStaticDoubleMethodList(this, cls, methodId, args); va_end(args); return res; } - ets_double CallStaticDoubleMethodList(ets_class cls, ets_method method_id, va_list args) + ets_double CallStaticDoubleMethodList(ets_class cls, ets_method methodId, va_list args) { - return native_interface->CallStaticDoubleMethodList(this, cls, method_id, args); + return nativeInterface->CallStaticDoubleMethodList(this, cls, methodId, args); } - ets_double CallStaticDoubleMethodArray(ets_class cls, ets_method method_id, ets_value* args) + ets_double CallStaticDoubleMethodArray(ets_class cls, ets_method methodId, ets_value* args) { - return native_interface->CallStaticDoubleMethodArray(this, cls, method_id, args); + return nativeInterface->CallStaticDoubleMethodArray(this, cls, methodId, args); } - void CallStaticVoidMethod(ets_class cls, ets_method method_id, ...) + void CallStaticVoidMethod(ets_class cls, ets_method methodId, ...) { va_list args; - va_start(args, method_id); - native_interface->CallStaticVoidMethodList(this, cls, method_id, args); + va_start(args, methodId); + nativeInterface->CallStaticVoidMethodList(this, cls, methodId, args); va_end(args); } - void CallStaticVoidMethodList(ets_class cls, ets_method method_id, va_list args) + void CallStaticVoidMethodList(ets_class cls, ets_method methodId, va_list args) { - native_interface->CallStaticVoidMethodList(this, cls, method_id, args); + nativeInterface->CallStaticVoidMethodList(this, cls, methodId, args); } - void CallStaticVoidMethodArray(ets_class cls, ets_method method_id, ets_value* args) + void CallStaticVoidMethodArray(ets_class cls, ets_method methodId, ets_value* args) { - native_interface->CallStaticVoidMethodArray(this, cls, method_id, args); + nativeInterface->CallStaticVoidMethodArray(this, cls, methodId, args); } ets_field GetStaticp_field(ets_class cls, const char* name, const char* sig) { - return native_interface->GetStaticp_field(this, cls, name, sig); + return nativeInterface->GetStaticp_field(this, cls, name, sig); } - ets_object GetStaticObjectField(ets_class cls, ets_field p_field) + ets_object GetStaticObjectField(ets_class cls, ets_field field) { - return native_interface->GetStaticObjectField(this, cls, p_field); + return nativeInterface->GetStaticObjectField(this, cls, field); } - ets_boolean GetStaticBooleanField(ets_class cls, ets_field p_field) + ets_boolean GetStaticBooleanField(ets_class cls, ets_field field) { - return native_interface->GetStaticBooleanField(this, cls, p_field); + return nativeInterface->GetStaticBooleanField(this, cls, field); } - ets_byte GetStaticByteField(ets_class cls, ets_field p_field) + ets_byte GetStaticByteField(ets_class cls, ets_field field) { - return native_interface->GetStaticByteField(this, cls, p_field); + return nativeInterface->GetStaticByteField(this, cls, field); } - ets_char GetStaticCharField(ets_class cls, ets_field p_field) + ets_char GetStaticCharField(ets_class cls, ets_field field) { - return native_interface->GetStaticCharField(this, cls, p_field); + return nativeInterface->GetStaticCharField(this, cls, field); } - ets_short GetStaticShortField(ets_class cls, ets_field p_field) + ets_short GetStaticShortField(ets_class cls, ets_field field) { - return native_interface->GetStaticShortField(this, cls, p_field); + return nativeInterface->GetStaticShortField(this, cls, field); } - ets_int GetStaticIntField(ets_class cls, ets_field p_field) + ets_int GetStaticIntField(ets_class cls, ets_field field) { - return native_interface->GetStaticIntField(this, cls, p_field); + return nativeInterface->GetStaticIntField(this, cls, field); } - ets_long GetStaticLongField(ets_class cls, ets_field p_field) + ets_long GetStaticLongField(ets_class cls, ets_field field) { - return native_interface->GetStaticLongField(this, cls, p_field); + return nativeInterface->GetStaticLongField(this, cls, field); } - ets_float GetStaticFloatField(ets_class cls, ets_field p_field) + ets_float GetStaticFloatField(ets_class cls, ets_field field) { - return native_interface->GetStaticFloatField(this, cls, p_field); + return nativeInterface->GetStaticFloatField(this, cls, field); } - ets_double GetStaticDoubleField(ets_class cls, ets_field p_field) + ets_double GetStaticDoubleField(ets_class cls, ets_field field) { - return native_interface->GetStaticDoubleField(this, cls, p_field); + return nativeInterface->GetStaticDoubleField(this, cls, field); } - void SetStaticObjectField(ets_class cls, ets_field p_field, ets_object value) + void SetStaticObjectField(ets_class cls, ets_field field, ets_object value) { - return native_interface->SetStaticObjectField(this, cls, p_field, value); + return nativeInterface->SetStaticObjectField(this, cls, field, value); } - void SetStaticBooleanField(ets_class cls, ets_field p_field, ets_boolean value) + void SetStaticBooleanField(ets_class cls, ets_field field, ets_boolean value) { - return native_interface->SetStaticBooleanField(this, cls, p_field, value); + return nativeInterface->SetStaticBooleanField(this, cls, field, value); } - void SetStaticByteField(ets_class cls, ets_field p_field, ets_byte value) + void SetStaticByteField(ets_class cls, ets_field field, ets_byte value) { - return native_interface->SetStaticByteField(this, cls, p_field, value); + return nativeInterface->SetStaticByteField(this, cls, field, value); } - void SetStaticCharField(ets_class cls, ets_field p_field, ets_char value) + void SetStaticCharField(ets_class cls, ets_field field, ets_char value) { - return native_interface->SetStaticCharField(this, cls, p_field, value); + return nativeInterface->SetStaticCharField(this, cls, field, value); } - void SetStaticShortField(ets_class cls, ets_field p_field, ets_short value) + void SetStaticShortField(ets_class cls, ets_field field, ets_short value) { - return native_interface->SetStaticShortField(this, cls, p_field, value); + return nativeInterface->SetStaticShortField(this, cls, field, value); } - void SetStaticIntField(ets_class cls, ets_field p_field, ets_int value) + void SetStaticIntField(ets_class cls, ets_field field, ets_int value) { - return native_interface->SetStaticIntField(this, cls, p_field, value); + return nativeInterface->SetStaticIntField(this, cls, field, value); } - void SetStaticLongField(ets_class cls, ets_field p_field, ets_long value) + void SetStaticLongField(ets_class cls, ets_field field, ets_long value) { - return native_interface->SetStaticLongField(this, cls, p_field, value); + return nativeInterface->SetStaticLongField(this, cls, field, value); } - void SetStaticFloatField(ets_class cls, ets_field p_field, ets_float value) + void SetStaticFloatField(ets_class cls, ets_field field, ets_float value) { - return native_interface->SetStaticFloatField(this, cls, p_field, value); + return nativeInterface->SetStaticFloatField(this, cls, field, value); } - void SetStaticDoubleField(ets_class cls, ets_field p_field, ets_double value) + void SetStaticDoubleField(ets_class cls, ets_field field, ets_double value) { - return native_interface->SetStaticDoubleField(this, cls, p_field, value); + return nativeInterface->SetStaticDoubleField(this, cls, field, value); } ets_string NewString(const ets_char* unicode_chars, ets_size len) { - return native_interface->NewString(this, unicode_chars, len); + return nativeInterface->NewString(this, unicode_chars, len); } ets_size GetStringLength(ets_string string) { - return native_interface->GetStringLength(this, string); + return nativeInterface->GetStringLength(this, string); } const ets_char* GetStringChars(ets_string string, ets_boolean* is_copy) { - return native_interface->GetStringChars(this, string, is_copy); + return nativeInterface->GetStringChars(this, string, is_copy); } void ReleaseStringChars(ets_string string, const ets_char* chars) { - native_interface->ReleaseStringChars(this, string, chars); + nativeInterface->ReleaseStringChars(this, string, chars); } ets_string NewStringUTF(const char* bytes) { - return native_interface->NewStringUTF(this, bytes); + return nativeInterface->NewStringUTF(this, bytes); } ets_size GetStringUTFLength(ets_string string) { - return native_interface->GetStringUTFLength(this, string); + return nativeInterface->GetStringUTFLength(this, string); } const char* GetStringUTFChars(ets_string string, ets_boolean* is_copy) { - return native_interface->GetStringUTFChars(this, string, is_copy); + return nativeInterface->GetStringUTFChars(this, string, is_copy); } void ReleaseStringUTFChars(ets_string string, const char* chars) { - native_interface->ReleaseStringUTFChars(this, string, chars); + nativeInterface->ReleaseStringUTFChars(this, string, chars); } ets_size GetArrayLength(ets_array array) { - return native_interface->GetArrayLength(this, array); + return nativeInterface->GetArrayLength(this, array); } - ets_objectArray NewObjectsArray(ets_size length, ets_class element_class, ets_object initial_element) + ets_objectArray NewObjectsArray(ets_size length, ets_class elementClass, ets_object initialElement) { - return native_interface->NewObjectsArray(this, length, element_class, initial_element); + return nativeInterface->NewObjectsArray(this, length, elementClass, initialElement); } ets_object GetObjectArrayElement(ets_objectArray array, ets_size index) { - return native_interface->GetObjectArrayElement(this, array, index); + return nativeInterface->GetObjectArrayElement(this, array, index); } void SetObjectArrayElement(ets_objectArray array, ets_size index, ets_object value) { - native_interface->SetObjectArrayElement(this, array, index, value); + nativeInterface->SetObjectArrayElement(this, array, index, value); } // SetObjectArrayElement, ets_booleanArray NewBooleanArray(ets_size length) { - return native_interface->NewBooleanArray(this, length); + return nativeInterface->NewBooleanArray(this, length); } ets_byteArray NewByteArray(ets_size length) { - return native_interface->NewByteArray(this, length); + return nativeInterface->NewByteArray(this, length); } ets_charArray NewCharArray(ets_size length) { - return native_interface->NewCharArray(this, length); + return nativeInterface->NewCharArray(this, length); } ets_shortArray NewShortArray(ets_size length) { - return native_interface->NewShortArray(this, length); + return nativeInterface->NewShortArray(this, length); } ets_intArray NewIntArray(ets_size length) { - return native_interface->NewIntArray(this, length); + return nativeInterface->NewIntArray(this, length); } ets_longArray NewLongArray(ets_size length) { - return native_interface->NewLongArray(this, length); + return nativeInterface->NewLongArray(this, length); } ets_floatArray NewFloatArray(ets_size length) { - return native_interface->NewFloatArray(this, length); + return nativeInterface->NewFloatArray(this, length); } ets_doubleArray NewDoubleArray(ets_size length) { - return native_interface->NewDoubleArray(this, length); + return nativeInterface->NewDoubleArray(this, length); } ets_boolean* PinBooleanArray(ets_booleanArray array) { - return native_interface->PinBooleanArray(this, array); + return nativeInterface->PinBooleanArray(this, array); } ets_byte* PinByteArray(ets_byteArray array) { - return native_interface->PinByteArray(this, array); + return nativeInterface->PinByteArray(this, array); } ets_char* PinCharArray(ets_charArray array) { - return native_interface->PinCharArray(this, array); + return nativeInterface->PinCharArray(this, array); } ets_short* PinShortArray(ets_shortArray array) { - return native_interface->PinShortArray(this, array); + return nativeInterface->PinShortArray(this, array); } ets_int* PinIntArray(ets_intArray array) { - return native_interface->PinIntArray(this, array); + return nativeInterface->PinIntArray(this, array); } ets_long* PinLongArray(ets_longArray array) { - return native_interface->PinLongArray(this, array); + return nativeInterface->PinLongArray(this, array); } ets_float* PinFloatArray(ets_floatArray array) { - return native_interface->PinFloatArray(this, array); + return nativeInterface->PinFloatArray(this, array); } ets_double* PinDoubleArray(ets_doubleArray array) { - return native_interface->PinDoubleArray(this, array); + return nativeInterface->PinDoubleArray(this, array); } void UnpinBooleanArray(ets_booleanArray array) { - return native_interface->UnpinBooleanArray(this, array); + return nativeInterface->UnpinBooleanArray(this, array); } void UnpinByteArray(ets_byteArray array) { - return native_interface->UnpinByteArray(this, array); + return nativeInterface->UnpinByteArray(this, array); } void UnpinCharArray(ets_charArray array) { - return native_interface->UnpinCharArray(this, array); + return nativeInterface->UnpinCharArray(this, array); } void UnpinShortArray(ets_shortArray array) { - return native_interface->UnpinShortArray(this, array); + return nativeInterface->UnpinShortArray(this, array); } void UnpinIntArray(ets_intArray array) { - return native_interface->UnpinIntArray(this, array); + return nativeInterface->UnpinIntArray(this, array); } void UnpinLongArray(ets_longArray array) { - return native_interface->UnpinLongArray(this, array); + return nativeInterface->UnpinLongArray(this, array); } void UnpinFloatArray(ets_floatArray array) { - return native_interface->UnpinFloatArray(this, array); + return nativeInterface->UnpinFloatArray(this, array); } void UnpinDoubleArray(ets_doubleArray array) { - return native_interface->UnpinDoubleArray(this, array); + return nativeInterface->UnpinDoubleArray(this, array); } void GetBooleanArrayRegion(ets_booleanArray array, ets_size start, ets_size len, ets_boolean* buf) { - return native_interface->GetBooleanArrayRegion(this, array, start, len, buf); + return nativeInterface->GetBooleanArrayRegion(this, array, start, len, buf); } void GetByteArrayRegion(ets_byteArray array, ets_size start, ets_size len, ets_byte* buf) { - return native_interface->GetByteArrayRegion(this, array, start, len, buf); + return nativeInterface->GetByteArrayRegion(this, array, start, len, buf); } void GetCharArrayRegion(ets_charArray array, ets_size start, ets_size len, ets_char* buf) { - return native_interface->GetCharArrayRegion(this, array, start, len, buf); + return nativeInterface->GetCharArrayRegion(this, array, start, len, buf); } void GetShortArrayRegion(ets_shortArray array, ets_size start, ets_size len, ets_short* buf) { - return native_interface->GetShortArrayRegion(this, array, start, len, buf); + return nativeInterface->GetShortArrayRegion(this, array, start, len, buf); } void GetIntArrayRegion(ets_intArray array, ets_size start, ets_size len, ets_int* buf) { - return native_interface->GetIntArrayRegion(this, array, start, len, buf); + return nativeInterface->GetIntArrayRegion(this, array, start, len, buf); } void GetLongArrayRegion(ets_longArray array, ets_size start, ets_size len, ets_long* buf) { - return native_interface->GetLongArrayRegion(this, array, start, len, buf); + return nativeInterface->GetLongArrayRegion(this, array, start, len, buf); } void GetFloatArrayRegion(ets_floatArray array, ets_size start, ets_size len, ets_float* buf) { - return native_interface->GetFloatArrayRegion(this, array, start, len, buf); + return nativeInterface->GetFloatArrayRegion(this, array, start, len, buf); } void GetDoubleArrayRegion(ets_doubleArray array, ets_size start, ets_size len, ets_double* buf) { - return native_interface->GetDoubleArrayRegion(this, array, start, len, buf); + return nativeInterface->GetDoubleArrayRegion(this, array, start, len, buf); } void SetBooleanArrayRegion(ets_booleanArray array, ets_size start, ets_size length, const ets_boolean* buf) { - native_interface->SetBooleanArrayRegion(this, array, start, length, buf); + nativeInterface->SetBooleanArrayRegion(this, array, start, length, buf); } void SetByteArrayRegion(ets_byteArray array, ets_size start, ets_size length, const ets_byte* buf) { - native_interface->SetByteArrayRegion(this, array, start, length, buf); + nativeInterface->SetByteArrayRegion(this, array, start, length, buf); } void SetCharArrayRegion(ets_charArray array, ets_size start, ets_size length, const ets_char* buf) { - native_interface->SetCharArrayRegion(this, array, start, length, buf); + nativeInterface->SetCharArrayRegion(this, array, start, length, buf); } void SetShortArrayRegion(ets_shortArray array, ets_size start, ets_size length, const ets_short* buf) { - native_interface->SetShortArrayRegion(this, array, start, length, buf); + nativeInterface->SetShortArrayRegion(this, array, start, length, buf); } void SetIntArrayRegion(ets_intArray array, ets_size start, ets_size length, const ets_int* buf) { - native_interface->SetIntArrayRegion(this, array, start, length, buf); + nativeInterface->SetIntArrayRegion(this, array, start, length, buf); } void SetLongArrayRegion(ets_longArray array, ets_size start, ets_size length, const ets_long* buf) { - native_interface->SetLongArrayRegion(this, array, start, length, buf); + nativeInterface->SetLongArrayRegion(this, array, start, length, buf); } void SetFloatArrayRegion(ets_floatArray array, ets_size start, ets_size length, const ets_float* buf) { - native_interface->SetFloatArrayRegion(this, array, start, length, buf); + nativeInterface->SetFloatArrayRegion(this, array, start, length, buf); } void SetDoubleArrayRegion(ets_doubleArray array, ets_size start, ets_size length, const ets_double* buf) { - native_interface->SetDoubleArrayRegion(this, array, start, length, buf); + nativeInterface->SetDoubleArrayRegion(this, array, start, length, buf); } ets_int RegisterNatives(ets_class cls, const EtsNativeMethod* methods, ets_int nMethods) { - return native_interface->RegisterNatives(this, cls, methods, nMethods); + return nativeInterface->RegisterNatives(this, cls, methods, nMethods); } ets_int UnregisterNatives(ets_class cls) { - return native_interface->UnregisterNatives(this, cls); + return nativeInterface->UnregisterNatives(this, cls); } ets_int GetEtsVM(EtsVM** vm) { - return native_interface->GetEtsVM(this, vm); + return nativeInterface->GetEtsVM(this, vm); } void GetStringRegion(ets_string str, ets_size start, ets_size len, ets_char* buf) { - native_interface->GetStringRegion(this, str, start, len, buf); + nativeInterface->GetStringRegion(this, str, start, len, buf); } void GetStringUTFRegion(ets_string str, ets_size start, ets_size len, char* buf) { - native_interface->GetStringUTFRegion(this, str, start, len, buf); + nativeInterface->GetStringUTFRegion(this, str, start, len, buf); } ets_weak NewWeakGlobalRef(ets_object obj) { - return native_interface->NewWeakGlobalRef(this, obj); + return nativeInterface->NewWeakGlobalRef(this, obj); } void DeleteWeakGlobalRef(ets_weak obj) { - native_interface->DeleteWeakGlobalRef(this, obj); + nativeInterface->DeleteWeakGlobalRef(this, obj); } ets_boolean ErrorCheck() { - return native_interface->ErrorCheck(this); + return nativeInterface->ErrorCheck(this); } // NewDirectByteBuffer, // GetDirectBufferAddress, // GetDirectBufferCapacity, ets_objectRefType GetObjectRefType(ets_object obj) { - return native_interface->GetObjectRefType(this, obj); + return nativeInterface->GetObjectRefType(this, obj); } // Promise ets_status PromiseCreate(ets_deferred* deferred, ets_object* promise) { - return native_interface->PromiseCreate(this, deferred, promise); + return nativeInterface->PromiseCreate(this, deferred, promise); } ets_status DeferredResolve(ets_deferred deferred, ets_object resolution) { - return native_interface->DeferredResolve(this, deferred, resolution); + return nativeInterface->DeferredResolve(this, deferred, resolution); } ets_status DeferredReject(ets_deferred deferred, ets_object rejection) { - return native_interface->DeferredReject(this, deferred, rejection); + return nativeInterface->DeferredReject(this, deferred, rejection); } #endif }; diff --git a/interop/src/cpp/interop-logging.cc b/interop/src/cpp/interop-logging.cc index 4fb30b9383082a61cce7df5d747774aa5f3e463e..801901d51eda6ce1ad2073ae4bd72745af153e3c 100644 --- a/interop/src/cpp/interop-logging.cc +++ b/interop/src/cpp/interop-logging.cc @@ -14,7 +14,12 @@ */ #include "interop-logging.h" +#ifdef __cplusplus +#include +#else #include +#endif + #include #include @@ -34,8 +39,9 @@ void startGroupedLog(int index) if (index >= static_cast(groupedLogs.size())) { groupedLogs.resize(index + 1); for (int i = 0; i <= index; i++) { - if (!groupedLogs[i]) + if (!groupedLogs[i]) { groupedLogs[i] = new Log(); + } } } groupedLogs[index]->isActive = true; diff --git a/interop/src/cpp/jni/convertors-jni.cc b/interop/src/cpp/jni/convertors-jni.cc index 7918b9721dc6f5ce3cc167bb9446d98d35b63e1e..1c16a4ebd184ec0a408d801f5c7e9360e924af65 100644 --- a/interop/src/cpp/jni/convertors-jni.cc +++ b/interop/src/cpp/jni/convertors-jni.cc @@ -26,6 +26,9 @@ static const char* callCallbackFromNative = "callCallbackFromNative"; static const char* callCallbackFromNativeSig = "(I[BI)I"; const bool registerByOne = true; +const size_t METHOD_NAME_IDX = 0; +const size_t METHOD_SIGNATURE_IDX = 1; +const size_t METHOD_FN_PTR_IDX = 2; static bool registerNatives( JNIEnv* env, jclass clazz, const std::vector> impls) @@ -34,9 +37,9 @@ static bool registerNatives( JNINativeMethod* methods = new JNINativeMethod[numMethods]; bool result = true; for (size_t i = 0; i < numMethods; i++) { - methods[i].name = (char*)std::get<0>(impls[i]).c_str(); - methods[i].signature = (char*)std::get<1>(impls[i]).c_str(); - methods[i].fnPtr = std::get<2>(impls[i]); + methods[i].name = (char*)std::get(impls[i]).c_str(); + methods[i].signature = (char*)std::get(impls[i]).c_str(); + methods[i].fnPtr = std::get(impls[i]); if (registerByOne) { result &= (env->RegisterNatives(clazz, methods + i, 1) >= 0); if (env->ExceptionCheck()) { diff --git a/interop/src/cpp/jsc/convertors-jsc.cc b/interop/src/cpp/jsc/convertors-jsc.cc index 98d3a994efe28f2916d9e90fc4cc01e3ea17ddab..86a87195c58c1a923bb92f9d35d65f7fb07ce68f 100644 --- a/interop/src/cpp/jsc/convertors-jsc.cc +++ b/interop/src/cpp/jsc/convertors-jsc.cc @@ -152,11 +152,12 @@ static JSValueRef u64ToBigInt(JSContextRef context, uint64_t value) #ifdef KOALA_JSC_USE_CALLBACK_CAST // Improve: benchmark this JSObjectRef bigIntFromParts = getBigIntFromParts(context); - JSValueRef parts[2] = { + const int partsSize = 2; + JSValueRef parts[partsSize] = { JSValueMakeNumber(context, (double)(value >> 32)), JSValueMakeNumber(context, (double)(value & 0xFFFFFFFF)), }; - bigint = JSObjectCallAsFunction(context, bigIntFromParts, nullptr, 2, parts, nullptr); + bigint = JSObjectCallAsFunction(context, bigIntFromParts, nullptr, partsSize, parts, nullptr); #else char buffer[128] = { 0 }; interop_snprintf(buffer, sizeof(buffer) - 1, "%zun", static_cast(value)); diff --git a/interop/src/cpp/kotlin/convertors-kotlin.h b/interop/src/cpp/kotlin/convertors-kotlin.h index 05df3438179c7ca3a5c68b80897dc73606d9797b..c8d4d65ecac866a15acb7aae77ad2a9fb5b1f356 100644 --- a/interop/src/cpp/kotlin/convertors-kotlin.h +++ b/interop/src/cpp/kotlin/convertors-kotlin.h @@ -21,7 +21,11 @@ #include #include #include +#ifdef __cplusplus +#include +#else #include +#endif #include "interop-logging.h" #include "interop-utils.h" diff --git a/interop/src/cpp/napi/convertors-napi.cc b/interop/src/cpp/napi/convertors-napi.cc index 63d27e5738a7e6c1d13e3c14e29fc17cccd929b1..e3d9e36268810e1594321217fab336a620252490 100644 --- a/interop/src/cpp/napi/convertors-napi.cc +++ b/interop/src/cpp/napi/convertors-napi.cc @@ -195,8 +195,7 @@ KULong getUInt64(napi_env env, napi_value value) napi_value makeString(napi_env env, const KStringPtr& value) { napi_value result; - napi_status status; - status = napi_create_string_utf8(env, value.isNull() ? "" : value.data(), value.length(), &result); + napi_status status = napi_create_string_utf8(env, value.isNull() ? "" : value.data(), value.length(), &result); KOALA_NAPI_THROW_IF_FAILED(env, status, result); return result; } @@ -204,8 +203,7 @@ napi_value makeString(napi_env env, const KStringPtr& value) napi_value makeString(napi_env env, const std::string& value) { napi_value result; - napi_status status; - status = napi_create_string_utf8(env, value.c_str(), value.length(), &result); + napi_status status = napi_create_string_utf8(env, value.c_str(), value.length(), &result); KOALA_NAPI_THROW_IF_FAILED(env, status, result); return result; } @@ -213,8 +211,7 @@ napi_value makeString(napi_env env, const std::string& value) napi_value makeBoolean(napi_env env, int8_t value) { napi_value result; - napi_status status; - status = napi_get_boolean(env, value != 0, &result); + napi_status status = napi_get_boolean(env, value != 0, &result); KOALA_NAPI_THROW_IF_FAILED(env, status, result); return result; } @@ -222,8 +219,7 @@ napi_value makeBoolean(napi_env env, int8_t value) napi_value makeInt32(napi_env env, int32_t value) { napi_value result; - napi_status status; - status = napi_create_int32(env, value, &result); + napi_status status = napi_create_int32(env, value, &result); KOALA_NAPI_THROW_IF_FAILED(env, status, result); return result; } @@ -231,8 +227,7 @@ napi_value makeInt32(napi_env env, int32_t value) napi_value makeUInt32(napi_env env, uint32_t value) { napi_value result; - napi_status status; - status = napi_create_uint32(env, value, &result); + napi_status status = napi_create_uint32(env, value, &result); KOALA_NAPI_THROW_IF_FAILED(env, status, result); return result; } @@ -240,8 +235,7 @@ napi_value makeUInt32(napi_env env, uint32_t value) napi_value makeInt64(napi_env env, int64_t value) { napi_value result; - napi_status status; - status = napi_create_bigint_int64(env, value, &result); + napi_status status = napi_create_bigint_int64(env, value, &result); KOALA_NAPI_THROW_IF_FAILED(env, status, result); return result; } @@ -249,8 +243,7 @@ napi_value makeInt64(napi_env env, int64_t value) napi_value makeUInt64(napi_env env, uint64_t value) { napi_value result; - napi_status status; - status = napi_create_bigint_uint64(env, value, &result); + napi_status status = napi_create_bigint_uint64(env, value, &result); KOALA_NAPI_THROW_IF_FAILED(env, status, result); return result; } @@ -258,8 +251,7 @@ napi_value makeUInt64(napi_env env, uint64_t value) napi_value makeFloat32(napi_env env, float value) { napi_value result; - napi_status status; - status = napi_create_double(env, value, &result); + napi_status status = napi_create_double(env, value, &result); KOALA_NAPI_THROW_IF_FAILED(env, status, result); return result; } @@ -267,8 +259,7 @@ napi_value makeFloat32(napi_env env, float value) napi_value makeFloat64(napi_env env, double value) { napi_value result; - napi_status status; - status = napi_create_double(env, value, &result); + napi_status status = napi_create_double(env, value, &result); KOALA_NAPI_THROW_IF_FAILED(env, status, result); return result; } @@ -276,8 +267,8 @@ napi_value makeFloat64(napi_env env, double value) napi_value makePointer(napi_env env, void* value) { napi_value result; - napi_status status; - status = napi_create_bigint_uint64(env, static_cast(reinterpret_cast(value)), &result); + napi_status status = + napi_create_bigint_uint64(env, static_cast(reinterpret_cast(value)), &result); KOALA_NAPI_THROW_IF_FAILED(env, status, result); return result; } @@ -285,8 +276,7 @@ napi_value makePointer(napi_env env, void* value) napi_value makeVoid(napi_env env) { napi_value result; - napi_status status; - status = napi_get_undefined(env, &result); + napi_status status = napi_get_undefined(env, &result); KOALA_NAPI_THROW_IF_FAILED(env, status, result); return result; } @@ -294,8 +284,7 @@ napi_value makeVoid(napi_env env) napi_value makeObject(napi_env env, napi_value object) { napi_value result; - napi_status status; - status = napi_create_object(env, &result); + napi_status status = napi_create_object(env, &result); KOALA_NAPI_THROW_IF_FAILED(env, status, result); return result; } diff --git a/interop/src/cpp/napi/convertors-napi.h b/interop/src/cpp/napi/convertors-napi.h index 4b86ca1eb085bbc8742f2628135a49eff21def6f..5a930c1b0e384183742dc2704e9b97fce9a0acf0 100644 --- a/interop/src/cpp/napi/convertors-napi.h +++ b/interop/src/cpp/napi/convertors-napi.h @@ -203,16 +203,21 @@ struct InteropTypeConverter { static inline void release(napi_env env, InteropType value, KVMObjectHandle converted) {} }; +const KInt UINT8_ARRAY_SIZE = 1; +const KInt UINT16_ARRAY_SIZE = 2; +const KInt UINT32_ARRAY_SIZE = 4; +const KInt BIGUINT64_ARRAY_SIZE = 8; + inline napi_typedarray_type getNapiType(KInt size) { switch (size) { - case 1: + case UINT8_ARRAY_SIZE: return napi_uint8_array; - case 2: + case UINT16_ARRAY_SIZE: return napi_uint16_array; - case 4: + case UINT32_ARRAY_SIZE: return napi_uint32_array; - case 8: + case BIGUINT64_ARRAY_SIZE: return napi_biguint64_array; default: break; diff --git a/interop/src/cpp/ohos/hilog/log.h b/interop/src/cpp/ohos/hilog/log.h index 058d09e265b8b20b68b8cb7977dd2690baad4ae2..c1beac5b6db96443474c74d0795908aabfa80625 100644 --- a/interop/src/cpp/ohos/hilog/log.h +++ b/interop/src/cpp/ohos/hilog/log.h @@ -58,8 +58,12 @@ * * @since 8 */ +#ifdef __cplusplus +#include +#else #include #include +#endif #ifdef __cplusplus extern "C" { diff --git a/interop/src/cpp/ohos/oh_sk_log.cc b/interop/src/cpp/ohos/oh_sk_log.cc index 77da3d2d6642ccafb0df44d9bfc40ea9f9944a52..8ae46236d1bf59786420fef870f5480bb107eb63 100644 --- a/interop/src/cpp/ohos/oh_sk_log.cc +++ b/interop/src/cpp/ohos/oh_sk_log.cc @@ -26,6 +26,7 @@ #include "interop-utils.h" static const char* KOALAUI_OHOS_LOG_ROOT = "/data/storage/el2/base/files/logs"; +const int RATIO = 1000; #define APPLY_LOG_FILE_PATTERN(buf, bufLen, t, ms, pid) \ interop_sprintf(buf, bufLen, "%s/%d_%d_%d_%ld.pid%d.log", KOALAUI_OHOS_LOG_ROOT, (t).tm_year + 1900, \ @@ -63,11 +64,12 @@ void oh_sk_file_log(oh_sk_log_type type, const char* msg, ...) } std::unique_ptr file(fopen(path, "a"), fclose); - if (!file) + if (!file) { return; + } fprintf(file.get(), "%02d-%02d %02d:%02d:%02d.%03ld %s koala: ", lt.tm_mon + 1, lt.tm_mday, lt.tm_hour, lt.tm_min, - lt.tm_sec, ms.tv_usec / 1000, oh_sk_log_type_str(type)); + lt.tm_sec, ms.tv_usec / RATIO, oh_sk_log_type_str(type)); va_list args; va_start(args, msg); diff --git a/interop/src/cpp/types/koala-types.h b/interop/src/cpp/types/koala-types.h index d9856c2a848f8e29f4eb62b1ef46bfa0a4dea9b8..14d916cb317dd54162021cbd7fdc71027d2f1383 100644 --- a/interop/src/cpp/types/koala-types.h +++ b/interop/src/cpp/types/koala-types.h @@ -20,9 +20,14 @@ #include #include #include -#include #include +#ifdef __cplusplus +#include +#else +#include +#endif + #include "interop-types.h" #include "interop-utils.h" diff --git a/interop/src/cpp/vmloader.cc b/interop/src/cpp/vmloader.cc index e9f002aa1b4ee11695393986572b6869347a72d2..b42fa70a1dee722e36ef3e75d93d4c3f73971f26 100644 --- a/interop/src/cpp/vmloader.cc +++ b/interop/src/cpp/vmloader.cc @@ -96,37 +96,34 @@ const VMLibInfo pandaVMLib = { // sdkPath #if defined(KOALA_OHOS) #ifdef KOALA_OHOS_ARM32 - "/system/lib" + "/system/lib", #elif KOALA_OHOS_ARM64 - "/system/lib64" + "/system/lib64", #else - OHOS_USER_LIBS + OHOS_USER_LIBS, #endif #else - getenv("PANDA_HOME") + getenv("PANDA_HOME"), #endif - , // platform #ifdef KOALA_LINUX #ifdef KOALA_LINUX_ARM64 - "linux_arm64_host_tools/lib" + "linux_arm64_host_tools/lib", #else - "linux_host_tools/lib" + "linux_host_tools/lib", #endif #elif KOALA_MACOS - "macos_host_tools/lib" + "macos_host_tools/lib", #elif KOALA_WINDOWS - "_host_tools/lib" + "_host_tools/lib", #elif KOALA_OHOS_ARM64 - "arm64" + "arm64", #elif KOALA_OHOS_ARM32 - "arm" + "arm", #else #error "Unknown platform" #endif - , - // lib "arkruntime" }; @@ -188,6 +185,17 @@ int loadES2Panda(const char* appClassPath, const char* appLibPath) } #ifdef KOALA_ETS_NAPI +static bool ResetErrorIfExists(EtsEnv* etsEnv, const char* message = "") +{ + if (etsEnv->ErrorCheck()) { + LOGE("%s", message); + etsEnv->ErrorDescribe(); + etsEnv->ErrorClear(); + return true; + } + return false; +} + namespace { enum PandaLog2MobileLog : int { @@ -681,19 +689,13 @@ extern "C" DLL_EXPORT KNativePointer StartApplication(const char* appUrl, const ets_class appClass = etsEnv->FindClass(appInfo->className); if (!appClass) { LOGE("Cannot load main class %" LOG_PUBLIC "s\n", appInfo->className); - if (etsEnv->ErrorCheck()) { - etsEnv->ErrorDescribe(); - etsEnv->ErrorClear(); - } + ResetErrorIfExists(etsEnv); return nullptr; } - ets_method create = etsEnv->GetStaticp_method(appClass, appInfo->createMethodName, appInfo->createMethodSig); + ets_method create = etsEnv->GetStaticMethod(appClass, appInfo->createMethodName, appInfo->createMethodSig); if (!create) { LOGE("Cannot find create method %" LOG_PUBLIC "s\n", appInfo->createMethodName); - if (etsEnv->ErrorCheck()) { - etsEnv->ErrorDescribe(); - etsEnv->ErrorClear(); - } + ResetErrorIfExists(etsEnv); return nullptr; } auto useNativeLog = false; @@ -701,49 +703,34 @@ extern "C" DLL_EXPORT KNativePointer StartApplication(const char* appUrl, const etsEnv->NewStringUTF(appParams), useNativeLog, g_vmEntry.vmKind)); if (!app) { LOGE("createApplication returned null"); - if (etsEnv->ErrorCheck()) { - etsEnv->ErrorDescribe(); - etsEnv->ErrorClear(); - return nullptr; - } + ResetErrorIfExists(etsEnv); return nullptr; } g_vmEntry.app = (void*)app; - auto start = etsEnv->Getp_method(appClass, appInfo->startMethodName, appInfo->startMethodSig); + auto start = etsEnv->GetMethod(appClass, appInfo->startMethodName, appInfo->startMethodSig); g_vmEntry.enter = - (void*)(etsEnv->Getp_method(appClass, appInfo->enterMethodName, nullptr /*appInfo->enterMethodSig */)); + (void*)(etsEnv->GetMethod(appClass, appInfo->enterMethodName, nullptr /*appInfo->enterMethodSig */)); if (!g_vmEntry.enter) { LOGE("Cannot find enter method %" LOG_PUBLIC "s", appInfo->enterMethodName); - if (etsEnv->ErrorCheck()) { - etsEnv->ErrorDescribe(); - etsEnv->ErrorClear(); - } + ResetErrorIfExists(etsEnv); return nullptr; } - if (etsEnv->ErrorCheck()) { - etsEnv->ErrorDescribe(); - etsEnv->ErrorClear(); + if (ResetErrorIfExists(etsEnv)) { return nullptr; } g_vmEntry.emitEvent = - (void*)(etsEnv->Getp_method(appClass, appInfo->emitEventMethodName, appInfo->emitEventMethodSig)); + (void*)(etsEnv->GetMethod(appClass, appInfo->emitEventMethodName, appInfo->emitEventMethodSig)); if (!g_vmEntry.emitEvent) { LOGE("Cannot find enter emitEvent %" LOG_PUBLIC "s", appInfo->emitEventMethodSig); - if (etsEnv->ErrorCheck()) { - etsEnv->ErrorDescribe(); - etsEnv->ErrorClear(); - } + ResetErrorIfExists(etsEnv); return nullptr; } if (isTestEnv) { g_vmEntry.restartWith = - (void*)(etsEnv->Getp_method(appClass, appInfo->restartWithMethodName, appInfo->restartWithMethodSig)); + (void*)(etsEnv->GetMethod(appClass, appInfo->restartWithMethodName, appInfo->restartWithMethodSig)); if (!g_vmEntry.restartWith) { LOGE("Cannot find enter restartWith %" LOG_PUBLIC "s", appInfo->restartWithMethodSig); - if (etsEnv->ErrorCheck()) { - etsEnv->ErrorDescribe(); - etsEnv->ErrorClear(); - } + ResetErrorIfExists(etsEnv); return nullptr; } } @@ -907,11 +894,7 @@ extern "C" DLL_EXPORT KBoolean RunApplication(const KInt arg0, const KInt arg1) } auto result = etsEnv->CallBooleanMethod((ets_object)(g_vmEntry.app), (ets_method)(g_vmEntry.enter), (ets_int)arg0, (ets_int)arg1, (int64_t)(intptr_t)(&g_vmEntry.foreignVMContext)); - if (etsEnv->ErrorCheck()) { - LOGE("Calling enter() method gave an error"); - etsEnv->ErrorDescribe(); - etsEnv->ErrorClear(); - } + ResetErrorIfExists(etsEnv, "Calling enter() method gave an error"); return result; } #endif @@ -974,11 +957,7 @@ extern "C" DLL_EXPORT const char* EmitEvent(const KInt type, const KInt target, } auto rv = (ets_string)etsEnv->CallObjectMethod((ets_object)(g_vmEntry.app), (ets_method)(g_vmEntry.emitEvent), (ets_int)type, (ets_int)target, (ets_int)arg0, (ets_int)arg1); - if (etsEnv->ErrorCheck()) { - LOGE("Calling emitEvent() method gave an error"); - etsEnv->ErrorDescribe(); - etsEnv->ErrorClear(); - } + ResetErrorIfExists(etsEnv, "Calling emitEvent() method gave an error"); const char* result = etsEnv->GetStringUTFChars(rv, 0); return result; } @@ -1063,11 +1042,7 @@ extern "C" DLL_EXPORT void RestartWith(const char* page) } etsEnv->CallVoidMethod( (ets_object)(g_vmEntry.app), (ets_method)(g_vmEntry.restartWith), etsEnv->NewStringUTF(page)); - if (etsEnv->ErrorCheck()) { - LOGE("Calling restartWith() method gave an error"); - etsEnv->ErrorDescribe(); - etsEnv->ErrorClear(); - } + ResetErrorIfExists(etsEnv, "Calling restartWith() method gave an error"); } #endif #if defined(KOALA_ANI) diff --git a/interop/src/interop/SerializerBase.ts b/interop/src/interop/SerializerBase.ts index 8361d723a5dc8a042b68625af477f428a52b6a16..18d8aaca3cf17920c84640cdee88b0b39fed7699 100644 --- a/interop/src/interop/SerializerBase.ts +++ b/interop/src/interop/SerializerBase.ts @@ -131,7 +131,7 @@ export class SerializerBase { SerializerBase.customSerializers = serializer; } else { let current = SerializerBase.customSerializers; - while (current.next != undefined) { + while (current.next) { current = current.next; } current.next = serializer; @@ -207,7 +207,7 @@ export class SerializerBase { let resourceId: ResourceId = 0; const promise = new Promise((resolve, reject) => { const callback = (err: string[] | undefined) => { - if (err !== undefined) reject(err); + if (err) reject(err); else resolve(); }; resourceId = this.holdAndWriteCallback(callback, hold, release, call, callSync); @@ -222,7 +222,7 @@ export class SerializerBase { let resourceId: ResourceId = 0; const promise = new Promise((resolve, reject) => { const callback = (value: T | undefined, err: string[] | undefined) => { - if (err !== undefined) reject(err); + if (err) reject(err); else resolve(value!); }; resourceId = this.holdAndWriteCallback(callback, hold, release, call); @@ -261,7 +261,7 @@ export class SerializerBase { } writeNumber(value: number | undefined) { this.checkCapacity(5); - if (value == undefined) { + if (value === undefined || value === null) { this.view.setInt8(this.position, Tags.UNDEFINED); this.position++; return; diff --git a/interop/src/interop/Wrapper.ts b/interop/src/interop/Wrapper.ts index 2b0b51c51009f9b81f14dc50ed513fedba3c8932..98bc15175dca9a0aff05f2352e90b5696608a296 100644 --- a/interop/src/interop/Wrapper.ts +++ b/interop/src/interop/Wrapper.ts @@ -39,6 +39,6 @@ export function getPtr(value: Wrapper | undefined): KPointer { export function ptrEqual(a: Wrapper | undefined, b: Wrapper | undefined): boolean { if (a === b) return true; - if (a == undefined || b == undefined) return false; + if (a === undefined || b === undefined || a === null || b === null) return false; return isSamePtr(a.ptr, b.ptr); } diff --git a/ui2abc/gn/command/gen_sdk.py b/ui2abc/gn/command/gen_sdk.py index f9bb97ea23a044fa88d0540bf98f23e02d1c05fb..1a08504a78050fb72e7ba03a33f5b7ee785e0041 100755 --- a/ui2abc/gn/command/gen_sdk.py +++ b/ui2abc/gn/command/gen_sdk.py @@ -23,8 +23,8 @@ def load_config(config_file): config = json.load(f) return config -def get_compiler_type(os, cpu): - if (os == 'mingw' and cpu == 'x86_64'): +def get_compiler_type(os_name, cpu): + if (os_name == 'mingw' and cpu == 'x86_64'): return 'mingw_x86_64' return 'clang_x64' diff --git a/ui2abc/libarkts/gn/command/copy.py b/ui2abc/libarkts/gn/command/copy.py index c42c37f146341132e1fa9e03e7720576f675a232..70cd12dcba46c0e8de53ea16330373e76a66537b 100755 --- a/ui2abc/libarkts/gn/command/copy.py +++ b/ui2abc/libarkts/gn/command/copy.py @@ -19,8 +19,8 @@ import shutil import subprocess import sys -def library_ext(os, cpu): - if (os == 'mingw' and cpu == 'x86_64'): +def library_ext(os_name, cpu): + if (os_name == 'mingw' and cpu == 'x86_64'): return 'dll' return 'node' diff --git a/ui2abc/libarkts/native/src/common.cc b/ui2abc/libarkts/native/src/common.cc index 87fa3b0b0e9ada55799a214bb0642317e151345c..f89613c6863e141b179dabe2129d39427f0dc939 100644 --- a/ui2abc/libarkts/native/src/common.cc +++ b/ui2abc/libarkts/native/src/common.cc @@ -136,14 +136,14 @@ void impl_SetUpSoPath(KStringPtr& soPath) } KOALA_INTEROP_V1(SetUpSoPath, KStringPtr); -void* TryLibrary(const char* name) +void* TryLibrary(const char* name) { void* res = nullptr; std::vector pathArray; // find by SetUpSoPath if (!ES2PANDA_LIB_PATH.empty()) { - pathArray = {ES2PANDA_LIB_PATH, LIB_DIR, name}; + pathArray = { ES2PANDA_LIB_PATH, LIB_DIR, name }; res = loadLibrary(joinPath(pathArray)); if (res) { return res; @@ -153,7 +153,7 @@ void* TryLibrary(const char* name) // find by set PANDA_SDK_PATH char* envValue = getenv("PANDA_SDK_PATH"); if (envValue) { - pathArray = {envValue, PLUGIN_DIR, LIB_DIR, name}; + pathArray = { envValue, PLUGIN_DIR, LIB_DIR, name }; res = loadLibrary(joinPath(pathArray)); if (res) { return res; @@ -161,14 +161,14 @@ void* TryLibrary(const char* name) } // find by set LD_LIBRARY_PATH - pathArray = {name}; + pathArray = { name }; res = loadLibrary(joinPath(pathArray)); if (res) { return res; } // find by DEFAULT_SDK_PATH - pathArray = {DEFAULT_SDK_PATH, PLUGIN_DIR, LIB_DIR, name}; + pathArray = { DEFAULT_SDK_PATH, PLUGIN_DIR, LIB_DIR, name }; res = loadLibrary(joinPath(pathArray)); if (res) { return res; @@ -178,8 +178,9 @@ void* TryLibrary(const char* name) } // TODO: @panda/sdk will be changed to match ohos-sdk -void* FindLibrary() { - void *res = nullptr; +void* FindLibrary() +{ + void* res = nullptr; res = TryLibrary(LIB_ES2PANDA_PUBLIC); if (res) { diff --git a/ui2abc/libarkts/native/src/memoryTracker.cc b/ui2abc/libarkts/native/src/memoryTracker.cc index 024a056c664ae7dee00227b8ff6815ced07b4d31..9ada27f59352ea3e5f2f20623ef67dd1ffb2fe49 100644 --- a/ui2abc/libarkts/native/src/memoryTracker.cc +++ b/ui2abc/libarkts/native/src/memoryTracker.cc @@ -153,12 +153,15 @@ void MemoryTracker::Report(MemoryStats stats) const double mb = kb * BYTES_PER_KB; const double gb = mb * BYTES_PER_KB; - if (bytes > gb) + if (bytes > gb) { return std::to_string(bytes / gb) + " GB"; - if (bytes > mb) + } + if (bytes > mb) { return std::to_string(bytes / mb) + " MB"; - if (bytes > kb) + } + if (bytes > kb) { return std::to_string(bytes / kb) + " KB"; + } return std::to_string(bytes) + " B"; }; diff --git a/ui2abc/libarkts/src/arkts-api/peers/AstNode.ts b/ui2abc/libarkts/src/arkts-api/peers/AstNode.ts index 350d9b51e5d4ff3f28461df703117794174e2a6d..2fcc7783d0498976cb5771f128f65cd3bd4da260 100644 --- a/ui2abc/libarkts/src/arkts-api/peers/AstNode.ts +++ b/ui2abc/libarkts/src/arkts-api/peers/AstNode.ts @@ -97,22 +97,6 @@ export abstract class AstNode extends ArktsObject { return unpackString(global.es2panda._AstNodeDumpModifiers(global.context, this.peer)); } - // public clone(): this { - // return unpackNonNullableNode(global.generatedEs2panda._AstNodeClone(global.context, this.peer, this.parent.peer)); - // } - - // public get parent(): AstNode { - // const parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer) - // if (parent === nullptr) { - // throwError(`no parent`) - // } - // return unpackNonNullableNode(parent) - // } - - // public set parent(node: AstNode) { - // global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, node.peer) - // } - public clone(): this { const clonedNode = unpackNonNullableNode( global.generatedEs2panda._AstNodeClone(global.context, this.peer, this.parent?.peer ?? nullptr) diff --git a/ui2abc/libarkts/src/arkts-api/utilities/private.ts b/ui2abc/libarkts/src/arkts-api/utilities/private.ts index 95fe0ce9e783415a149de4dc1684f24d0ccbf612..2005b38b9c84948aea99616d06041f46849fc641 100644 --- a/ui2abc/libarkts/src/arkts-api/utilities/private.ts +++ b/ui2abc/libarkts/src/arkts-api/utilities/private.ts @@ -17,7 +17,6 @@ import { global } from '../static/global'; import { isNumber, throwError } from '../../utils'; import { KInt, KNativePointer as KPtr, KNativePointer, nullptr, withString, withStringArray } from '@koalaui/interop'; import { NativePtrDecoder } from './nativePtrDecoder'; -//import { OptimizedNativePtrDecoder as NativePtrDecoder } from "./nativePtrDecoder" import { Es2pandaAstNodeType, Es2pandaModifierFlags, @@ -71,13 +70,9 @@ export function acceptNativeObjectArrayResult( arrayObject: KNativePointer, factory: (instance: KNativePointer) => T ): T[] { - // For OptimizedNativePtrDecoder - //const decoded = new NativePtrDecoder().decode(arrayObject) - //return decoded.reduce((prev, curr) => { - // prev.push(factory(curr)) - // return prev - //}, [] as T[]) - return new NativePtrDecoder().decode(arrayObject).map(factory); + // OptimizedNativePtrDecoder:return decoded.reduce((prev, curr)=>{prev.push(factory(curr));return prev},[] as T[]) + const decoded = new NativePtrDecoder().decode(arrayObject) + return decoded.map(factory); } export function unpackNonNullableNode(peer: KNativePointer, typeHint?: Es2pandaAstNodeType): T { diff --git a/ui2abc/libarkts/src/tracer.ts b/ui2abc/libarkts/src/tracer.ts index 6a1d56ece5022e1cdad22c7657ec0563bb30e308..955e15533eda4fe78f7d4870f140ef6b83c19096 100644 --- a/ui2abc/libarkts/src/tracer.ts +++ b/ui2abc/libarkts/src/tracer.ts @@ -41,7 +41,7 @@ export class Tracer { return; } const programPath = program.absoluteName; - if (programPath == '') { + if (!programPath.length) { return; } const suggestedTracer = Tracer.Tracers.get(programPath); diff --git a/ui2abc/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts b/ui2abc/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts index 2982ad6eaa21113e6345af17cd86d0977e908e49..4a4d57cb0e45298e052bf088baa77567ae69f959 100644 --- a/ui2abc/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts +++ b/ui2abc/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts @@ -19,17 +19,6 @@ import * as ts from "../../../../src/ts-api" suite.skip(util.basename(__filename), () => { // full memo rewrite test("memo-function-with-lambda-memo-param", function() { - // function foo( - // __memo_context: __memo_context_type, - // __memo_id: __memo_id_type, - // content: (__memo_context: __memo_context_type, __memo_id: __memo_id_type) => void - // ) { - // if (__memo_scope.unchanged) - // return __memo_scope.cached - // content(__memo_context, __memo_id + "key_id_main.ts") - // return __memo_scope.recache() - // } - const sample_in = ` function foo( diff --git a/ui2abc/libarkts/test/ts-api/general/import.test.ts b/ui2abc/libarkts/test/ts-api/general/import.test.ts index 8f649094a1aa83dc9f4d14a26a8b66b984e9ce68..3bb81b2e1b56d8e5ec3db5fcf12763b498b33709 100644 --- a/ui2abc/libarkts/test/ts-api/general/import.test.ts +++ b/ui2abc/libarkts/test/ts-api/general/import.test.ts @@ -24,10 +24,6 @@ suite.skip(util.basename(__filename), () => { import { TEST } from "./export" console.log(TEST) ` - - // util.getDefaultSetup(sample_in) - - // util.generateBinAndRun() }) test("sample-2", function() { @@ -36,41 +32,5 @@ suite.skip(util.basename(__filename), () => { import { power as F } from "std/math" console.log(F(2, 10)) ` - - // util.getDefaultSetup(sample_in) - - // arkts.proceedToState(arkts.ContextState.ES2PANDA_STATE_CHECKED) - - // const classDecl = arkts.nodeByPeer(util.getStatement(1)) - // util.assert(arkts.isClassDeclaration(classDecl)) - - // const method = classDecl.members[1] - // util.assert(arkts.isMethodDeclaration(method)) - - // const body = method.body! - // util.assert(arkts.isBlock(body)) - - // const exprStatement = body.statements[0] - // util.assert(arkts.isExpressionStatement(exprStatement)) - - // const callExpr = exprStatement.expression - // util.assert(arkts.isCallExpression(callExpr)) - - // const F = callExpr.arguments[0] - // util.assert(arkts.isCallExpression(F)) - - // const ident = F.expression - // util.assert(arkts.isIdentifier(ident)) - - // console.log(arkts.dumpJsonNode(ident)) - - // const decl = arkts.getDecl(ident) - // if (decl !== undefined) { - // console.log(arkts.dumpJsonNode(decl)) - // } else { - // console.log(decl) - // } - - // util.generateBinAndRun() }) }) diff --git a/ui2abc/libarkts/test/ts-api/visitors-and-transformers/builder-lambda-rewrite.test.ts b/ui2abc/libarkts/test/ts-api/visitors-and-transformers/builder-lambda-rewrite.test.ts deleted file mode 100644 index 45c1407fb1516d38c04f2159a28f09c7fe7f5b45..0000000000000000000000000000000000000000 --- a/ui2abc/libarkts/test/ts-api/visitors-and-transformers/builder-lambda-rewrite.test.ts +++ /dev/null @@ -1,120 +0,0 @@ -/* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -// import * as util from "../../test-util" -// import * as ts from "../../../src/ts-api" -// import { factory } from "../../../src/ts-api" -// import { BuilderLambdaTransformer } from "../../../plugins/src/builder-lambda-transformer" -// -// suite.skip(util.getSuiteTitle(__filename), () => { -// test("builder-lambda-transformer-sample-1", function() { -// // foo((instance: string) => { -// // return instance; -// // }, "label"); -// -// const sample_in = -// ` -// _BuilderLambdaCall_foo("label") -// ` -// -// let sourceFile = factory.createSourceFile(sample_in) -// util.assert(ts.isSourceFile(sourceFile)) -// -// const builderLambdaTransformer = new BuilderLambdaTransformer() -// -// const result = builderLambdaTransformer.visitor(sourceFile) -// util.assert(ts.isSourceFile(result)) -// -// util.TS_TEST_ASSERTION( -// result, -// ` -// foo(((instance: string) => { -// return instance; -// }), "label") -// `, -// ts.ContextState.ES2PANDA_STATE_PARSED, -// ) -// }) -// -// test("builder-lambda-transformer-sample-2", function() { -// // foo((instance: string) => { -// // return instance.bar().qux(); -// // }, "label1", "label2"); -// -// const sample_in = -// ` -// _BuilderLambdaCall_foo("label1", "label2").bar().qux() -// ` -// -// let sourceFile = factory.createSourceFile(sample_in) -// util.assert(ts.isSourceFile(sourceFile)) -// -// const builderLambdaTransformer = new BuilderLambdaTransformer() -// -// const result = builderLambdaTransformer.visitor(sourceFile) -// util.assert(ts.isSourceFile(result)) -// -// util.TS_TEST_ASSERTION( -// result, -// ` -// foo(((instance: string) => { -// return instance.bar().qux(); -// }), "label1", "label2") -// `, -// ts.ContextState.ES2PANDA_STATE_PARSED, -// ) -// }) -// -// // Improve: update nodes properly (now failing to generate bin) -// test("builder-lambda-transformer-sample-3", function() { -// // function Foo(builder: (instance: string) => string, arg1: string): void { -// // console.log(arg1 + builder("ABC")) -// // } -// // Foo((instance: string) => { -// // return instance.charAt(1) -// // }, "> second_char_of_ABC: ") -// -// const sample_in = -// ` -// function Foo(builder: (instance: string) => string, arg1: string): void { -// console.log(arg1 + builder("ABC")) -// } -// -// _BuilderLambdaCall_Foo("> second_char_of_ABC: ").charAt(1) -// ` -// -// let sourceFile = factory.createSourceFile(sample_in) -// util.assert(ts.isSourceFile(sourceFile)) -// -// const builderLambdaTransformer = new BuilderLambdaTransformer() -// -// const result = builderLambdaTransformer.visitor(sourceFile) -// util.assert(ts.isSourceFile(result)) -// -// util.TS_TEST_ASSERTION( -// result, -// ` -// function Foo(builder: ((instance: string)=> string), arg1: string): void { -// console.log(((arg1) + (builder("ABC")))); -// } -// -// Foo(((instance: string) => { -// return instance.charAt(1); -// }), "> second_char_of_ABC: ") -// `, -// ts.ContextState.ES2PANDA_STATE_PARSED, -// ) -// }) -// })