LcConfigC_jv.c

Go to the documentation of this file.

 
/* LABEL-START */
#define META_FILE_NAME "LcConfigC_jv.c"
 
#include "jni_h/jvlcconfig_LcConfigC.h"
#include "LibLcConfig_private_jv.h"
 
 
jobject NS(LcConfigC_ObjNew) (MK_RT_ARGS JNIEnv *env, LC_CFG hdl) {
  static MkThreadLocal jobject NS_NULL = NULL;
  return (hdl ? MK(AtomObjNew)(MK_RT_CALL env, LcConfigC_X2obj(hdl)) : MK_GET__NS_NULL(LcConfigC));
}
 
MK_UNUSED
static jobject NS(LcConfigC_ObjCreate) (MK_RT_ARGS JNIEnv *env, LC_CFG hdl) {
  return MK(AtomObjCreate)(MK_RT_CALL env, LcConfigC_X2obj(hdl));
}
 
static MK_PTR NS(LcConfigC_selfCreate) (MK_RT_ARGS MK_OBJ obj, MK_PTR envP) {
  JNIEnv *env = (JNIEnv*) envP;
  return (*env)->NewObject(env, NS(Class_LcConfigC), NS(MID_LcConfigC_INIT), (jlong) obj, JNI_TRUE);
}
 
#define ClassInit \
 
//  printTxt("init: LcConfigC");
 
/* LABEL-END */
 
// BEGIN-LcConfigC - created by 'jv_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
 
// doc-key: LcConfigC,LcConfigC-Class-Export,sc_
 
JNIEXPORT jobject JNICALL Java_jvlcconfig_LcConfigC_HandleResolve (JNIEnv *env, jclass class, jint netHdl)  {
  MkRtSetup_NULL;
  LC_CFG __retVal__L = LcConfigHandleResolve(netHdl);
  jobject __retVal__S = LC(LcConfigC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// doc-key: LcConfigC,LcConfigC-Class-Export,om_
 
// skip class-overload: HandleGet = LcConfigHandleGet → MkObjectHandleGet
 
// LcConfigC_Class_JV_API
 
 
// doc-key: LcConfigC,LcConfigC-Class-Introspection,oc_
 
JNIEXPORT jobject JNICALL Java_jvlcconfig_LcConfigC_Next (JNIEnv *env, jobject self)  {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  LC_CFG __retVal__L = LcConfigNext(hdl);
  jobject __retVal__S = LC(LcConfigC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvlcconfig_LcConfigC_Prev (JNIEnv *env, jobject self)  {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  LC_CFG __retVal__L = LcConfigPrev(hdl);
  jobject __retVal__S = LC(LcConfigC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: LcConfigC,LcConfigC-Class-Introspection,sc_
 
JNIEXPORT jobject JNICALL Java_jvlcconfig_LcConfigC_Instances (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  LC_CFG __retVal__L = LcConfigInstances();
  jobject __retVal__S = LC(LcConfigC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// LcConfigC_Class_JV_API
 
 
// doc-key: LcConfigC,LcConfigC-Class-Misc,sc_
 
JNIEXPORT jobject JNICALL Java_jvlcconfig_LcConfigC_GetNull (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  LC_CFG __retVal__L = LcConfigGetNull();
  jobject __retVal__S = LC(LcConfigC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// LcConfigC_Class_JV_API
 
 
// doc-key: LcConfigC,LcConfigC-Error,om_
 
JNIEXPORT jobject JNICALL Java_jvlcconfig_LcConfigC_ErrorType (JNIEnv *env, jobject self)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum LcErrorTypeE __retVal__L = LcConfigErrorType(hdl);
  jobject __retVal__S = MK(pGetEnumFromString)(env,LC(Class_LcErrorTypeE),"Ljvlcconfig/LcErrorTypeE;",LcErrorTypeE_ToString(__retVal__L));
  return __retVal__S;
error:
  return 0;
}
 
// LcConfigC_Error_JV_API
 
 
// doc-key: LcConfigC,LcConfigC-Get,om_
 
JNIEXPORT jobject JNICALL Java_jvlcconfig_LcConfigC_GetDefaultFormat (JNIEnv *env, jobject self)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum LcConfigFormatE __retVal__L = LcConfigGetDefaultFormat(hdl);
  jobject __retVal__S = MK(pGetEnumFromString)(env,LC(Class_LcConfigFormatE),"Ljvlcconfig/LcConfigFormatE;",LcConfigFormatE_ToString(__retVal__L));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jshort JNICALL Java_jvlcconfig_LcConfigC_GetFloatPrecision (JNIEnv *env, jobject self)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I16 __retVal__L = LcConfigGetFloatPrecision(hdl);
  jshort __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvlcconfig_LcConfigC_GetIncludeDir (JNIEnv *env, jobject self)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = LcConfigGetIncludeDir(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jboolean JNICALL Java_jvlcconfig_LcConfigC_GetOption (JNIEnv *env, jobject self, jobject option)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum LcConfigOptionsEF option_e = MK(pGetEnumFromObj)(env, NS(Class_LcConfigOptionsEF), option);
  JavaErrorCheck;
  MK_BOOL __retVal__L = LcConfigGetOption(hdl, option_e);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvlcconfig_LcConfigC_GetOptions (JNIEnv *env, jobject self)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum LcConfigOptionsEF __retVal__L = LcConfigGetOptions(hdl);
  jobject __retVal__S = MK(pGetEnumFlagFromInt)(env,LC(Class_LcConfigOptionsEF),__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jshort JNICALL Java_jvlcconfig_LcConfigC_GetTabWidth (JNIEnv *env, jobject self)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I16 __retVal__L = LcConfigGetTabWidth(hdl);
  jshort __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
// LcConfigC_Get_JV_API
 
 
// doc-key: LcConfigC,LcConfigC-Lookup,oc_
 
JNIEXPORT jobject JNICALL Java_jvlcconfig_LcConfigC_Lookup (JNIEnv *env, jobject self, jstring path)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN path_ptr = (path?(*env)->GetStringUTFChars(env,path,NULL):NULL);
  JavaErrorCheck;
  LC_CFS __retVal__L = LcConfigLookup(hdl, path_ptr);
  jobject __retVal__S = LC(LcSettingC_ObjNew)(MK_RT_CALL env,__retVal__L);
  if (path_ptr) (*env)->ReleaseStringUTFChars(env,path,path_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: LcConfigC,LcConfigC-Lookup,omo
 
JNIEXPORT jboolean JNICALL Java_jvlcconfig_LcConfigC_LookupBool (JNIEnv *env, jobject self, jstring path)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOOL value_out;
  MK_STRN path_ptr = (path?(*env)->GetStringUTFChars(env,path,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = LcConfigLookupBool(hdl, path_ptr, &value_out);
  MkErrorC_Check(hdl, errVal)
  jboolean __retVal__S = value_out;
  if (path_ptr) (*env)->ReleaseStringUTFChars(env,path,path_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jdouble JNICALL Java_jvlcconfig_LcConfigC_LookupFloat (JNIEnv *env, jobject self, jstring path)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_DBL value_out;
  MK_STRN path_ptr = (path?(*env)->GetStringUTFChars(env,path,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = LcConfigLookupFloat(hdl, path_ptr, &value_out);
  MkErrorC_Check(hdl, errVal)
  jdouble __retVal__S = value_out;
  if (path_ptr) (*env)->ReleaseStringUTFChars(env,path,path_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvlcconfig_LcConfigC_LookupInt (JNIEnv *env, jobject self, jstring path)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I32 value_out;
  MK_STRN path_ptr = (path?(*env)->GetStringUTFChars(env,path,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = LcConfigLookupInt(hdl, path_ptr, &value_out);
  MkErrorC_Check(hdl, errVal)
  jint __retVal__S = value_out;
  if (path_ptr) (*env)->ReleaseStringUTFChars(env,path,path_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jlong JNICALL Java_jvlcconfig_LcConfigC_LookupInt64 (JNIEnv *env, jobject self, jstring path)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I64 value_out;
  MK_STRN path_ptr = (path?(*env)->GetStringUTFChars(env,path,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = LcConfigLookupInt64(hdl, path_ptr, &value_out);
  MkErrorC_Check(hdl, errVal)
  jlong __retVal__S = value_out;
  if (path_ptr) (*env)->ReleaseStringUTFChars(env,path,path_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvlcconfig_LcConfigC_LookupString (JNIEnv *env, jobject self, jstring path)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN value_out;
  MK_STRN path_ptr = (path?(*env)->GetStringUTFChars(env,path,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = LcConfigLookupString(hdl, path_ptr, &value_out);
  MkErrorC_Check(hdl, errVal)
  jstring __retVal__S = JC2O(env,value_out);
  if (path_ptr) (*env)->ReleaseStringUTFChars(env,path,path_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// LcConfigC_Lookup_JV_API
 
 
// doc-key: LcConfigC,LcConfigC-Misc,oc_
 
JNIEXPORT jobject JNICALL Java_jvlcconfig_LcConfigC_RootSetting (JNIEnv *env, jobject self)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  LC_CFS __retVal__L = LcConfigRootSetting(hdl);
  jobject __retVal__S = LC(LcSettingC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: LcConfigC,LcConfigC-Misc,om_
 
JNIEXPORT void JNICALL Java_jvlcconfig_LcConfigC_Clear (JNIEnv *env, jobject self)  {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  LcConfigClear(hdl);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvlcconfig_LcConfigC_Log (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_OBJN fmtobj_hdl = (MK_OBJN)pObj2Hdl__null_allow(env,fmtobj);
  JavaErrorCheck;
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  if (debug > (jint)(MkRuntimeDebugGet())) {return;}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  LcConfigLog(hdl, fmtobj_hdl, debug, callfunc_ptr, lvl);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvlcconfig_LcConfigC_ReadFile (JNIEnv *env, jobject self, jstring filename)  {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN filename_ptr = (filename?(*env)->GetStringUTFChars(env,filename,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = LcConfigReadFile(hdl, filename_ptr);
  MkErrorC_Check(hdl, errVal)
  if (filename_ptr) (*env)->ReleaseStringUTFChars(env,filename,filename_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvlcconfig_LcConfigC_ReadString (JNIEnv *env, jobject self, jstring str)  {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN str_ptr = (str?(*env)->GetStringUTFChars(env,str,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = LcConfigReadString(hdl, str_ptr);
  MkErrorC_Check(hdl, errVal)
  if (str_ptr) (*env)->ReleaseStringUTFChars(env,str,str_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvlcconfig_LcConfigC_WriteFile (JNIEnv *env, jobject self, jstring filename)  {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN filename_ptr = (filename?(*env)->GetStringUTFChars(env,filename,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = LcConfigWriteFile(hdl, filename_ptr);
  MkErrorC_Check(hdl, errVal)
  if (filename_ptr) (*env)->ReleaseStringUTFChars(env,filename,filename_ptr);
error:
  return;
}
 
// doc-key: LcConfigC,LcConfigC-Misc,omo
 
JNIEXPORT jstring JNICALL Java_jvlcconfig_LcConfigC_WriteString (JNIEnv *env, jobject self)  {
  LC_CFGN hdl = (LC_CFGN)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN val_out;
  enum MkErrorE errVal = LcConfigWriteString(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jstring __retVal__S = JC2O(env,val_out);
  return __retVal__S;
error:
  return 0;
}
 
// LcConfigC_Misc_JV_API
 
 
// doc-key: LcConfigC,LcConfigC-Set,om_
 
JNIEXPORT void JNICALL Java_jvlcconfig_LcConfigC_SetDefaultFormat (JNIEnv *env, jobject self, jobject format)  {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum LcConfigFormatE format_e = MK(pGetEnumFromObj)(env, NS(Class_LcConfigFormatE), format);
  JavaErrorCheck;
  LcConfigSetDefaultFormat(hdl, format_e);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvlcconfig_LcConfigC_SetFloatPrecision (JNIEnv *env, jobject self, jshort digits)  {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  LcConfigSetFloatPrecision(hdl, digits);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvlcconfig_LcConfigC_SetIncludeDir (JNIEnv *env, jobject self, jstring include_dir)  {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN include_dir_ptr = (include_dir?(*env)->GetStringUTFChars(env,include_dir,NULL):NULL);
  JavaErrorCheck;
  LcConfigSetIncludeDir(hdl, include_dir_ptr);
  if (include_dir_ptr) (*env)->ReleaseStringUTFChars(env,include_dir,include_dir_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvlcconfig_LcConfigC_SetIncludeFunc (JNIEnv *env, jobject self, jobject fConfigIncludeData)  {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  LcConfigIncludeCallF fConfigIncludeCall = NS(ConfigIncludeCall);
  LC_CBP fConfigIncludeData_ptr = MK(ProcCreate)(MK_RT_CALL env, fConfigIncludeData, NULL, NS(MID_fConfigIncludeData), true);
  JavaErrorCheck;
  if (fConfigIncludeData_ptr == NULL) fConfigIncludeCall = NULL;
  enum MkErrorE errVal = LcConfigSetIncludeFunc(hdl, fConfigIncludeCall, fConfigIncludeData_ptr, NS(ConfigIncludeFree));
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvlcconfig_LcConfigC_SetOption (JNIEnv *env, jobject self, jobject option, jboolean flag)  {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum LcConfigOptionsEF option_e = MK(pGetEnumFromObj)(env, NS(Class_LcConfigOptionsEF), option);
  JavaErrorCheck;
  LcConfigSetOption(hdl, option_e, flag);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvlcconfig_LcConfigC_SetOptions (JNIEnv *env, jobject self, jobject options)  {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum LcConfigOptionsEF options_e = MK(pGetEnumFromObj)(env, NS(Class_LcConfigOptionsEF), options);
  JavaErrorCheck;
  LcConfigSetOptions(hdl, options_e);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvlcconfig_LcConfigC_SetSettingDeleteFunc (JNIEnv *env, jobject self, jobject fSettingDeleteData)  {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  LcSettingDeleteCallF fSettingDeleteCall = NS(SettingDeleteCall);
  LC_CBP fSettingDeleteData_ptr = MK(ProcCreate)(MK_RT_CALL env, fSettingDeleteData, NULL, NS(MID_fSettingDeleteData), true);
  JavaErrorCheck;
  if (fSettingDeleteData_ptr == NULL) fSettingDeleteCall = NULL;
  enum MkErrorE errVal = LcConfigSetSettingDeleteFunc(hdl, fSettingDeleteCall, fSettingDeleteData_ptr, NS(SettingDeleteFree));
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvlcconfig_LcConfigC_SetTabWidth (JNIEnv *env, jobject self, jshort width)  {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  LcConfigSetTabWidth(hdl, width);
error:
  return;
}
 
// LcConfigC_Set_JV_API
 
 
// doc-key: LcConfigC,LcConfigC-TOR,sCc
 
JNIEXPORT jlong JNICALL Java_jvlcconfig_LcConfigC_CTOR (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  LC_CFG __retVal__L = LcConfigCreate(NULL, NULL);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "LcConfigC.CTOR");
    goto error;
  }
  jlong __retVal__S = (jlong)__retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvlcconfig_LcConfigC_Create (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  LC_CFG __retVal__L = LcConfigCreate(NULL, NULL);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "LcConfigC.Create");
    goto error;
  }
  jobject __retVal__S = LC(LcConfigC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// LcConfigC_TOR_JV_API
 
// END-LcConfigC - created by 'jv_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
void NS(LcConfigC_Init)(LC_RT_ARGS_ONLY) {
  ClassInit
 
  LcConfigC_TT->selfCreate        =  NS(LcConfigC_selfCreate)      ;
  LcConfigC_TT->selfUnlink        =  MK(AtomSelfUnlink)  ;
}
 
// ====================================================================================================
// OVERLOAD
 
JNIEXPORT void JNICALL Java_jvlcconfig_LcConfigC_SetIncludeFunc__Ljava_C_langlass_2Ljava_lang_String_2 (
  JNIEnv    *env, 
  jobject   self, 
  jclass    searchClass, 
  jstring   fConfigIncludeDataString
) {
  LC_CFG hdl = (LC_CFG)pObj2Hdl(env,"LcConfigC",self);
  JavaErrorCheck;
  MkRtSetup_XN(hdl);
  jmethodID meth = (*env)->GetStaticMethodID(env,MK(Class_MkKernel),"resolveCallback",
                      "(Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Class;");
  JavaErrorCheck;
  jclass fConfigIncludeData = (*env)->CallStaticObjectMethod(env, MK(Class_MkKernel), meth, searchClass, 
                                                    LC(Class_LcConfigIncludeIF), fConfigIncludeDataString);
  JavaErrorCheck;
  LC_CBP fConfigIncludeData_ptr = MK(ProcCreate)(MK_RT_CALL_NULL env, fConfigIncludeData, NULL, NS(MID_fConfigIncludeData), true);
  JavaErrorCheck;
  enum MkErrorE errVal = LcConfigSetIncludeFunc(hdl, NS(ConfigIncludeCall), fConfigIncludeData_ptr, NS(ConfigIncludeFree));
  MkErrorC_Check(hdl, errVal)
error:
  return;
}