23 #if defined (HAVE_CONFIG_H)
32 #if defined (HAVE_WINDOWS_H)
56 #if defined (HAVE_JAVA)
60 #if defined (HAVE_JAVA)
62 #define TO_JOBJECT(obj) reinterpret_cast<jobject> (obj)
63 #define TO_JCLASS(obj) reinterpret_cast<jclass> (obj)
65 #define TO_JNIENV(env) reinterpret_cast<JNIEnv *> (env)
67 typedef jint (JNICALL *JNI_CreateJavaVM_t) (JavaVM **pvm, JNIEnv **
penv,
70 typedef jint (JNICALL *JNI_GetCreatedJavaVMs_t) (JavaVM **pvm, jsize
bufLen,
97 operator T () {
return jobj; }
138 box (JNIEnv* jni_env,
void *jobj,
void *jcls_arg = 0);
141 box_more (JNIEnv* jni_env,
void *jobj_arg,
void *jcls_arg = 0);
153 JNIEXPORT jboolean JNICALL
157 JNIEXPORT
void JNICALL
160 JNIEXPORT
void JNICALL
163 JNIEXPORT
void JNICALL
166 JNIEXPORT jboolean JNICALL
193 vm_args.version = JNI_VERSION_1_2;
196 vm_args.ignoreUnrecognized =
false;
217 std::ifstream js (filename.c_str ());
219 if (! js.bad () && ! js.fail ())
223 while (! js.eof () && ! js.fail ())
225 std::getline (js, line);
227 if (line.find (
"-") == 0)
230 std::cerr <<
"invalid JVM option, skipping: " << line << std::endl;
242 delete []
vm_args.options[
i].optionString;
262 for (std::list<std::string>::const_iterator it =
java_opts.begin ();
266 std::cout << *it << std::endl;
282 #if defined (OCTAVE_USE_WINDOWS_API)
292 if (! RegOpenKeyEx (HKEY_LOCAL_MACHINE, key.c_str (), 0, KEY_READ, &hkey))
294 if (! RegQueryValueEx (hkey, value.c_str (), 0, 0, 0, &len))
297 if (RegQueryValueEx (hkey, value.c_str (), 0, 0,
298 (LPBYTE)&retval[0], &len))
300 else if (retval[len-1] ==
'\0')
310 get_module_filename (HMODULE hMod)
318 int status = GetModuleFileName (hMod, &
retval[0], n);
333 return (found ?
retval :
"");
343 if (java_dir.empty ())
347 if (java_dir.empty ())
370 std::ifstream
fs (filepath.c_str ());
378 std::getline (
fs, line);
380 if (line.length () > 0)
382 if (line[0] ==
'#' || line[0] ==
'%')
390 int last = line.find_last_not_of (
" \t\f\v\r\n");
409 if (! retval.empty ())
413 std::string jar_file = java_dir + sep +
"octave.jar";
433 std::string cp_list[] = {
"javaclasspath.txt",
"classpath.txt"};
435 for (
int i=0;
i<2;
i++)
448 retval.append (classpath);
462 retval.append (classpath);
470 cp_file = java_dir + sep +
filename;
476 retval.append (classpath);
482 error (
"octave.jar does not exist: %s", jar_file.c_str ());
485 error (
"initial java dir is empty");
498 const char *static_locale = setlocale (LC_ALL, 0);
501 #if defined (OCTAVE_USE_WINDOWS_API)
503 HMODULE hMod = GetModuleHandle (
"jvm.dll");
510 jvm_lib_path = get_module_filename (hMod);
512 if (jvm_lib_path.empty ())
513 error (
"unable to find Java Runtime Environment");
521 key =
"software\\javasoft\\java runtime environment";
526 value =
"Currentversion";
527 std::string regval = read_registry_string (key,value);
530 error (
"unable to find Java Runtime Environment: %s::%s",
531 key.c_str (), value.c_str ());
536 key = key +
"\\" +
value;
537 value =
"RuntimeLib";
538 jvm_lib_path = read_registry_string (key, value);
540 if (jvm_lib_path.empty ())
541 error (
"unable to find Java Runtime Environment: %s::%s",
542 key.c_str (), value.c_str ());
548 # if defined (__APPLE__)
551 std::string jvm_lib_path = JAVA_LDPATH +
std::string (
"/libjvm.so");
558 #if ! defined (__APPLE__) && ! defined (__MACH__)
563 error (
"unable to load Java Runtime Environment from %s",
564 jvm_lib_path.c_str ());
566 JNI_CreateJavaVM_t create_vm =
567 reinterpret_cast<JNI_CreateJavaVM_t
> (lib.
search (
"JNI_CreateJavaVM"));
568 JNI_GetCreatedJavaVMs_t get_vm =
569 reinterpret_cast<JNI_GetCreatedJavaVMs_t
> (lib.
search (
"JNI_GetCreatedJavaVMs"));
572 error (
"unable to find JNI_CreateJavaVM in %s", jvm_lib_path.c_str ());
575 error (
"unable to find JNI_GetCreatedJavaVMs in %s", jvm_lib_path.c_str ());
577 if (get_vm (&
jvm, 1, &nVMs) == 0 && nVMs > 0)
585 if (JNI_GetCreatedJavaVMs (&
jvm, 1, &nVMs) == 0 && nVMs > 0)
592 switch (
jvm->GetEnv (reinterpret_cast<void **> (¤t_env),
597 JavaVMAttachArgs vm_args;
598 vm_args.version = JNI_VERSION_1_2;
599 vm_args.name =
const_cast<char *
> (
"octave");
601 if (
jvm->AttachCurrentThread (reinterpret_cast<void **> (¤t_env),
603 error (
"JVM internal error, unable to attach octave to existing JVM");
607 error (
"JVM internal error, the required JNI version is not supported");
625 vm_args.
add (
"-Xrs");
626 vm_args.
add (
"-Djava.system.class.loader=org.octave.OctClassLoader");
631 #if ! defined (__APPLE__) && ! defined (__MACH__)
633 if (create_vm (&
jvm, ¤t_env, vm_args.
to_args ()) != JNI_OK)
634 error (
"unable to start Java VM in %s", jvm_lib_path.c_str ());
641 if (JNI_CreateJavaVM (&
jvm, reinterpret_cast<void **> (¤t_env),
642 vm_args.to_args ()) != JNI_OK)
643 error (
"unable to start Java VM in %s", jvm_lib_path.c_str ());
649 setlocale (LC_ALL, locale.c_str ());
658 jvm->DetachCurrentThread ();
660 jvm->DestroyJavaVM ();
663 jvm_attached =
false;
679 const char *cstr = jni_env->GetStringUTFChars (s, 0);
681 jni_env->ReleaseStringUTFChars (s, cstr);
694 jclass_ref cls (jni_env, jni_env->FindClass (
"java/lang/String"));
697 if (jni_env->IsInstanceOf (obj, cls))
699 reinterpret_cast<jstring> (obj));
706 static inline JNIEnv *
712 jvm->GetEnv (reinterpret_cast<void **> (&env), JNI_VERSION_1_2);
722 #if defined (HAVE_JAVA)
728 jclass_ref cls (current_env, current_env->FindClass (
"java/lang/String"));
747 #if defined (HAVE_JAVA)
752 std::replace (cls_cpp.begin (), cls_cpp.end (),
'.',
'/');
756 jclass_ref cls (current_env, current_env->FindClass (cls_cpp.c_str ()));
757 if (current_env->ExceptionCheck ())
758 current_env->ExceptionClear ();
766 octave_unused_parameter (cls_name);
776 #if defined (HAVE_JAVA)
788 jni_env->ExceptionDescribe ();
790 jni_env->ExceptionClear ();
792 jclass_ref jcls (jni_env, jni_env->GetObjectClass (ex));
793 jmethodID mID = jni_env->GetMethodID (jcls,
"toString",
794 "()Ljava/lang/String;");
796 reinterpret_cast<jstring> (jni_env->CallObjectMethod (ex, mID)));
799 error (
"[java] %s", msg.c_str ());
811 static jclass uiClass = 0;
813 jclass jcls = jni_env->FindClass (name);
817 jni_env->ExceptionClear ();
821 if (class_loader.empty ())
824 jni_env->FindClass (
"java/lang/System"));
825 jmethodID mID = jni_env->GetStaticMethodID
828 "(Ljava/lang/String;)Ljava/lang/String;");
830 jni_env->NewStringUTF (
"octave.class.loader"));
831 js =
reinterpret_cast<jstring
> (jni_env->CallStaticObjectMethod
832 (syscls, mID, jstring (js)));
834 std::replace (class_loader.begin (), class_loader.end (),
839 jni_env->FindClass (class_loader.c_str ()));
843 jni_env->ExceptionClear ();
846 std::replace (class_loader.begin (), class_loader.end (),
849 jni_env->FindClass (
"org/openide/util/Lookup"));
850 jmethodID mID = jni_env->GetStaticMethodID
851 (jcls2,
"getDefault",
"()Lorg/openide/util/Lookup;");
853 jni_env->CallStaticObjectMethod (jcls2, mID));
854 mID = jni_env->GetMethodID (jcls2,
"lookup",
855 "(Ljava/lang/Class;)Ljava/lang/Object;");
857 jni_env->FindClass (
"java/lang/ClassLoader"));
859 jni_env->CallObjectMethod
860 (lObj, mID, jclass (cLoaderCls)));
861 mID = jni_env->GetMethodID (cLoaderCls,
"loadClass",
862 "(Ljava/lang/String;)Ljava/lang/Class;");
864 jni_env->NewStringUTF (class_loader.c_str ()));
865 uicls =
reinterpret_cast<jclass
>
866 (jni_env->CallObjectMethod (cLoader, mID, jstring (js)));
870 uiClass =
reinterpret_cast<jclass
>
871 (jni_env->NewGlobalRef (jclass (uicls)));
876 jmethodID mID = jni_env->GetStaticMethodID
877 (uiClass,
"findClass",
"(Ljava/lang/String;)Ljava/lang/Class;");
878 jstring_ref js (jni_env, jni_env->NewStringUTF (name));
879 jcls =
reinterpret_cast<jclass
>
880 (jni_env->CallStaticObjectMethod (uiClass, mID, jstring (js)));
891 jclass_ref jcls (jni_env, jni_env->GetObjectClass (obj));
892 jclass_ref ccls (jni_env, jni_env->GetObjectClass (jcls));
893 jmethodID isArray_ID = jni_env->GetMethodID (ccls,
"isArray",
"()Z");
894 jmethodID getComponentType_ID = jni_env->GetMethodID (ccls,
896 "()Ljava/lang/Class;");
902 while (jcls && jni_env->CallBooleanMethod (jcls, isArray_ID))
904 int len = (jobj ? jni_env->GetArrayLength (jobj) : 0);
905 if (idx >= dv.
ndims ())
908 jcls =
reinterpret_cast<jclass
>
909 (jni_env->CallObjectMethod (jcls, getComponentType_ID));
911 ?
reinterpret_cast<jobjectArray
> (jni_env->GetObjectArrayElement (jobj,
925 jclass_ref ocls (jni_env, jni_env->FindClass (
"[I"));
926 jobjectArray
retval = jni_env->NewObjectArray (idx.
length (), ocls, 0);
936 jint *buf = jni_env->GetIntArrayElements (i_array, 0);
944 jni_env->ReleaseIntArrayElements (i_array, buf, 0);
945 jni_env->SetObjectArrayElement (retval,
i, i_array);
969 "org/octave/ClassHelper"));
970 jmethodID mID = jni_env
971 ->GetStaticMethodID (helperClass,
"arraySubsref",
972 "(Ljava/lang/Object;[[I)Ljava/lang/Object;");
973 resObj = jni_env->CallStaticObjectMethod
974 (helperClass, mID, jobj, jobject (java_idx));
977 retval =
box (jni_env, resObj);
997 if (
unbox (jni_env, rhs, rhsObj, rhsCls))
1001 "org/octave/ClassHelper"));
1002 jmethodID mID = jni_env->GetStaticMethodID (helperClass,
"arraySubsasgn",
1003 "(Ljava/lang/Object;[[ILjava/lang/Object;)" "Ljava/lang/Object;");
1004 resObj = jni_env->CallStaticObjectMethod
1005 (helperClass, mID, jobj, jobject (java_idx), jobject (rhsObj));
1009 retval =
box (jni_env, resObj);
1023 std::list<std::string> name_list;
1027 jclass_ref cls (jni_env, jni_env->GetObjectClass (jobj));
1028 jclass_ref ccls (jni_env, jni_env->GetObjectClass (cls));
1029 jmethodID getMethods_ID = jni_env->GetMethodID
1030 (ccls,
"getMethods",
"()[Ljava/lang/reflect/Method;");
1031 jmethodID getFields_ID = jni_env->GetMethodID
1032 (ccls,
"getFields",
"()[Ljava/lang/reflect/Field;");
1034 reinterpret_cast<jobjectArray>
1035 (jni_env->CallObjectMethod (cls, getMethods_ID)));
1037 reinterpret_cast<jobjectArray>
1038 (jni_env->CallObjectMethod (cls, getFields_ID)));
1039 int mLen = jni_env->GetArrayLength (mList);
1040 int fLen = jni_env->GetArrayLength (fList);
1042 jni_env->FindClass (
"java/lang/reflect/Method"));
1044 jni_env->FindClass (
"java/lang/reflect/Field"));
1045 jmethodID m_getName_ID = jni_env->GetMethodID (mCls,
"getName",
1046 "()Ljava/lang/String;");
1047 jmethodID f_getName_ID = jni_env->GetMethodID (fCls,
"getName",
1048 "()Ljava/lang/String;");
1050 for (
int i = 0;
i < mLen;
i++)
1052 jobject_ref meth (jni_env, jni_env->GetObjectArrayElement (mList,
i));
1053 jstring_ref methName (jni_env, reinterpret_cast<jstring>
1054 (jni_env->CallObjectMethod (meth, m_getName_ID)));
1058 for (
int i = 0;
i < fLen;
i++)
1061 jni_env->GetObjectArrayElement (fList,
i));
1063 reinterpret_cast<jstring>
1064 (jni_env->CallObjectMethod
1065 (field, f_getName_ID)));
1074 return v.
sort (
true);
1082 if (jni_env && java_object)
1084 jclass_ref cls (jni_env, jni_env->FindClass (
"java/lang/String"));
1086 if (jni_env->IsInstanceOf (java_object, cls))
1090 cls = jni_env->FindClass (
"[Ljava/lang/String;");
1092 if (jni_env->IsInstanceOf (java_object, cls))
1094 jobjectArray
array =
reinterpret_cast<jobjectArray
> (java_object);
1095 int len = jni_env->GetArrayLength (array);
1098 for (
int i = 0;
i < len;
i++)
1101 reinterpret_cast<jstring>
1102 (jni_env->GetObjectArrayElement (array,
i)));
1114 cls = jni_env->FindClass (
"java/lang/Object");
1115 jmethodID mID = jni_env->GetMethodID (cls,
"toString",
1116 "()Ljava/lang/String;");
1118 reinterpret_cast<jstring>
1119 (jni_env->CallObjectMethod (java_object, mID)));
1128 error (
"unable to convert Java object to string");
1136 #define TO_JAVA(obj) dynamic_cast<octave_java*> ((obj).internal_rep ())
1152 cls = jni_env->FindClass (
"java/lang/Double");
1153 if (jni_env->IsInstanceOf (jobj, cls))
1155 cls = jni_env->FindClass (
"java/lang/Float");
1156 if (jni_env->IsInstanceOf (jobj, cls))
1158 cls = jni_env->FindClass (
"java/lang/Byte");
1159 if (jni_env->IsInstanceOf (jobj, cls))
1161 cls = jni_env->FindClass (
"java/lang/Short");
1162 if (jni_env->IsInstanceOf (jobj, cls))
1164 cls = jni_env->FindClass (
"java/lang/Integer");
1165 if (jni_env->IsInstanceOf (jobj, cls))
1167 cls = jni_env->FindClass (
"java/lang/Long");
1168 if (jni_env->IsInstanceOf (jobj, cls))
1192 box (JNIEnv *jni_env,
void *jobj_arg,
void *jcls_arg)
1209 cls = jni_env->FindClass (
"java/lang/Number");
1210 if (jni_env->IsInstanceOf (jobj, cls)
1213 jmethodID
m = jni_env->GetMethodID (cls,
"doubleValue",
"()D");
1214 retval = jni_env->CallDoubleMethod (jobj, m);
1218 cls = jni_env->FindClass (
"java/lang/Boolean");
1219 if (jni_env->IsInstanceOf (jobj, cls))
1221 jmethodID
m = jni_env->GetMethodID (cls,
"booleanValue",
"()Z");
1222 retval = (jni_env->CallBooleanMethod (jobj, m) ?
true :
false);
1226 cls = jni_env->FindClass (
"java/lang/String");
1227 if (jni_env->IsInstanceOf (jobj, cls))
1233 cls = jni_env->FindClass (
"java/lang/Character");
1234 if (jni_env->IsInstanceOf (jobj, cls))
1236 jmethodID
m = jni_env->GetMethodID (cls,
"charValue",
"()C");
1237 retval = jni_env->CallCharMethod (jobj, m);
1242 #define BOX_PRIMITIVE_ARRAY(JAVA_TYPE, JAVA_ID, JAVA_TYPE_CAP, OCTAVE_ID) \
1243 cls = jni_env->FindClass (JAVA_ID); \
1244 if (jni_env->IsInstanceOf (jobj, cls)) \
1246 const JAVA_TYPE ## Array jarr = reinterpret_cast<JAVA_TYPE ## Array> (jobj); \
1247 const jsize len = jni_env->GetArrayLength (jarr); \
1248 OCTAVE_ID ## NDArray d (dim_vector (len, 1)); \
1249 JAVA_TYPE *buffer = reinterpret_cast<JAVA_TYPE *> (d.fortran_vec ()); \
1250 jni_env->Get ## JAVA_TYPE_CAP ## ArrayRegion (jarr, 0, len, buffer); \
1264 #undef BOX_PRIMITIVE_ARRAY
1266 if (Vjava_matrix_autoconversion)
1270 if (jni_env->IsInstanceOf (jobj, cls))
1272 jmethodID mID = jni_env->GetMethodID (cls,
"getDims",
"()[I");
1274 reinterpret_cast<jintArray>
1275 (jni_env->CallObjectMethod (jobj, mID)));
1276 jint *iv_data = jni_env->GetIntArrayElements (jintArray (iv), 0);
1278 dims.
resize (jni_env->GetArrayLength (jintArray (iv)));
1280 for (
int i = 0;
i < dims.
ndims ();
i++)
1283 jni_env->ReleaseIntArrayElements (jintArray (iv), iv_data, 0);
1284 mID = jni_env->GetMethodID (cls,
"getClassName",
1285 "()Ljava/lang/String;");
1287 reinterpret_cast<jstring>
1288 (jni_env->CallObjectMethod (jobj, mID)));
1295 mID = jni_env->GetMethodID (cls,
"toDouble",
"()[D");
1297 reinterpret_cast<jdoubleArray>
1298 (jni_env->CallObjectMethod (jobj, mID)));
1299 jni_env->GetDoubleArrayRegion (dv, 0,
1305 else if (s ==
"byte")
1307 if (Vjava_unsigned_autoconversion)
1310 mID = jni_env->GetMethodID (cls,
"toByte",
"()[B");
1312 reinterpret_cast<jbyteArray>
1313 (jni_env->CallObjectMethod (jobj,
1315 jni_env->GetByteArrayRegion (dv, 0, m.
numel (),
1316 reinterpret_cast<jbyte *
>
1324 mID = jni_env->GetMethodID (cls,
"toByte",
"()[B");
1326 reinterpret_cast<jbyteArray>
1327 (jni_env->CallObjectMethod (jobj,
1329 jni_env->GetByteArrayRegion (dv, 0, m.
numel (),
1330 reinterpret_cast<jbyte *
>
1336 else if (s ==
"integer")
1338 if (Vjava_unsigned_autoconversion)
1341 mID = jni_env->GetMethodID (cls,
"toInt",
"()[I");
1342 jintArray_ref dv (jni_env, reinterpret_cast<jintArray> (jni_env->CallObjectMethod (jobj, mID)));
1350 mID = jni_env->GetMethodID (cls,
"toInt",
"()[I");
1352 reinterpret_cast<jintArray>
1353 (jni_env->CallObjectMethod (jobj,
1355 jni_env->GetIntArrayRegion (dv, 0, m.
numel (),
1356 reinterpret_cast<jint *
>
1366 if (jni_env->IsInstanceOf (jobj, cls))
1368 jmethodID mID = jni_env->GetMethodID (cls,
"getID",
"()I");
1369 int ID = jni_env->CallIntMethod (jobj, mID);
1370 std::map<int,octave_value>::iterator it = octave_ref_map.find (ID);
1372 if (it != octave_ref_map.end ())
1373 retval = it->second;
1386 box_more (JNIEnv *jni_env,
void *jobj_arg,
void *jcls_arg)
1401 cls = jni_env->FindClass (
"[D");
1403 if (jni_env->IsInstanceOf (jobj, cls))
1405 jdoubleArray jarr =
reinterpret_cast<jdoubleArray
> (jobj);
1406 int len = jni_env->GetArrayLength (jarr);
1411 jni_env->GetDoubleArrayRegion (jarr, 0, len, m.
fortran_vec ());
1421 cls = jni_env->FindClass (
"[[D");
1423 if (jni_env->IsInstanceOf (jobj, cls))
1425 jobjectArray jarr =
reinterpret_cast<jobjectArray
> (jobj);
1426 int rows = jni_env->GetArrayLength (jarr);
1433 for (
int r = 0; r < rows; r++)
1436 reinterpret_cast<jdoubleArray>
1437 (jni_env->GetObjectArrayElement
1442 cols = jni_env->GetArrayLength (row);
1445 jni_env->GetDoubleArrayRegion
1457 cls = jni_env->FindClass (
"[Ljava/lang/String;");
1459 if (jni_env->IsInstanceOf (jobj, cls))
1461 jobjectArray jarr =
reinterpret_cast<jobjectArray
> (jobj);
1462 int len = jni_env->GetArrayLength (jarr);
1465 for (
int i = 0;
i < len;
i++)
1468 reinterpret_cast<jstring>
1469 (jni_env->GetObjectArrayElement (jarr,
i)));
1497 jcls = jni_env->GetObjectClass (jobj);
1503 jobj = jni_env->NewStringUTF (s.c_str ());
1504 jcls = jni_env->GetObjectClass (jobj);
1511 jclass_ref scls (jni_env, jni_env->FindClass (
"java/lang/String"));
1512 jobjectArray
array = jni_env->NewObjectArray (n, scls, NULL);
1517 (str_arr(
i).c_str ()));
1518 jni_env->SetObjectArrayElement (array,
i, jstr);
1522 jcls = jni_env->GetObjectClass (jobj);
1529 #define UNBOX_PRIMITIVE_ARRAY(METHOD_T, OCTAVE_T, JAVA_T, JAVA_T_CAP) \
1532 const OCTAVE_T ## NDArray v = val.METHOD_T ## array_value (); \
1533 JAVA_T ## Array jarr = jni_env->New ## JAVA_T_CAP ## Array (v.numel ()); \
1534 const JAVA_T *jv = reinterpret_cast<const JAVA_T*> (v.data ()); \
1535 jni_env->Set ## JAVA_T_CAP ## ArrayRegion (jarr, 0, v.numel (), jv); \
1536 jobj = reinterpret_cast<jobject> (jarr); \
1537 jcls = jni_env->GetObjectClass (jobj); \
1567 #undef UNBOX_PRIMITIVE_ARRAY
1574 #define UNBOX_PRIMITIVE_SCALAR(OCTAVE_T, METHOD_T, JAVA_T, JAVA_CON) \
1577 const OCTAVE_T ov = val.METHOD_T ## _value (); \
1578 jclass_ref dcls (jni_env, jni_env->FindClass (JAVA_T)); \
1579 const jfieldID fid = jni_env->GetStaticFieldID (dcls, "TYPE", "Ljava/lang/Class;"); \
1580 const jmethodID mid = jni_env->GetMethodID (dcls, "<init>", JAVA_CON); \
1581 jcls = reinterpret_cast<jclass> (jni_env->GetStaticObjectField (dcls, fid)); \
1582 jobj = jni_env->NewObject (dcls, mid, ov); \
1609 #undef UNBOX_PRIMITIVE_SCALAR
1617 else if (! Vjava_matrix_autoconversion
1623 jdoubleArray
dv = jni_env->NewDoubleArray (m.
numel ());
1626 jcls = jni_env->GetObjectClass (jobj);
1628 else if (Vjava_matrix_autoconversion
1633 "org/octave/Matrix"));
1636 jint *iv_data = jni_env->GetIntArrayElements (jintArray (iv), 0);
1638 for (
int i = 0;
i < dims.
ndims ();
i++)
1641 jni_env->ReleaseIntArrayElements (jintArray (iv), iv_data, 0);
1647 jni_env->SetDoubleArrayRegion (jdoubleArray (dv), 0, m.
numel (),
1649 jmethodID mID = jni_env->GetMethodID (mcls,
"<init>",
"([D[I)V");
1650 jobj = jni_env->NewObject (jclass (mcls), mID, jdoubleArray (dv),
1652 jcls = jni_env->GetObjectClass (jobj);
1658 jni_env->SetByteArrayRegion (jbyteArray (bv), 0, m.
numel (),
1659 reinterpret_cast<jbyte *
>
1661 jmethodID mID = jni_env->GetMethodID (mcls,
"<init>",
"([B[I)V");
1662 jobj = jni_env->NewObject
1663 (jclass (mcls), mID, jbyteArray (bv), jintArray (iv));
1664 jcls = jni_env->GetObjectClass (jobj);
1670 jni_env->SetByteArrayRegion (jbyteArray (bv), 0, m.
numel (),
1671 reinterpret_cast<jbyte *
>
1673 jmethodID mID = jni_env->GetMethodID (mcls,
"<init>",
"([B[I)V");
1674 jobj = jni_env->NewObject
1675 (jclass (mcls), mID, jbyteArray (bv), jintArray (iv));
1676 jcls = jni_env->GetObjectClass (jobj);
1682 jni_env->SetIntArrayRegion (jintArray (v), 0, m.
numel (),
1683 reinterpret_cast<jint *
>
1685 jmethodID mID = jni_env->GetMethodID (mcls,
"<init>",
"([I[I)V");
1686 jobj = jni_env->NewObject
1687 (jclass (mcls), mID, jintArray (v), jintArray (iv));
1688 jcls = jni_env->GetObjectClass (jobj);
1693 error (
"cannot convert matrix of type '%s'",
1700 jmethodID mID = jni_env->GetMethodID (rcls,
"<init>",
"(I)V");
1701 int ID = octave_java_refcount++;
1703 jobj = jni_env->NewObject (rcls, mID, ID);
1705 octave_ref_map[ID] =
val;
1717 jclass_ref ocls (jni_env, jni_env->FindClass (
"java/lang/Object"));
1718 jclass_ref ccls (jni_env, jni_env->FindClass (
"java/lang/Class"));
1721 jobjs = jni_env->NewObjectArray (args.
length (), ocls, 0);
1724 jclss = jni_env->NewObjectArray (args.
length (), ccls, 0);
1726 for (
int i = 0;
i < args.
length ();
i++)
1731 found =
unbox (jni_env,
args(
i), jobj, jcls);
1735 jni_env->SetObjectArrayElement (jobjs,
i, jobj);
1736 jni_env->SetObjectArrayElement (jclss,
i, jcls);
1747 jclass_ref cls (jni_env, jni_env->FindClass (
"java/lang/Thread"));
1748 jmethodID mID = jni_env->GetStaticMethodID (cls,
"currentThread",
1749 "()Ljava/lang/Thread;");
1750 jobject_ref jthread (jni_env, jni_env->CallStaticObjectMethod (cls, mID));
1754 jclass_ref jth_cls (jni_env, jni_env->GetObjectClass (jthread));
1755 mID = jni_env->GetMethodID (jth_cls,
"getId",
"()J");
1756 long result = jni_env->CallLongMethod (jthread, mID);
1773 "org/octave/Octave"));
1774 jmethodID mID = current_env->GetStaticMethodID
1775 (cls,
"checkPendingAction",
"()V");
1776 current_env->CallStaticVoidMethod (cls, mID);
1802 error (msg.c_str ());
1809 JNIEXPORT jboolean JNICALL
1811 jobjectArray argin, jobjectArray argout)
1815 int nargout = env->GetArrayLength (argout);
1816 int nargin = env->GetArrayLength (argin);
1821 varargin(
i) =
box (env, env->GetObjectArrayElement (argin,
i), 0);
1823 varargout =
feval (fname, varargin, nargout);
1827 return unbox (env, varargout, out_objs, out_clss);
1830 JNIEXPORT
void JNICALL
1833 octave_ref_map.erase (ID);
1836 JNIEXPORT
void JNICALL
1840 std::map<int,octave_value>::iterator it = octave_ref_map.find (ID);
1842 if (it != octave_ref_map.end ())
1845 int len = env->GetArrayLength (args);
1848 for (
int i = 0;
i < len;
i++)
1850 jobject_ref jobj (env, env->GetObjectArrayElement (args,
i));
1851 oct_args(
i) =
box (env, jobj, 0);
1854 BEGIN_INTERRUPT_WITH_EXCEPTIONS;
1859 feval (fcn, oct_args);
1863 && val.
cell_value()(0).is_function_handle ())
1869 oct_args(len+
i-1) =
c(
i);
1871 feval (fcn, oct_args);
1874 error (
"trying to invoke non-invocable object");
1876 END_INTERRUPT_WITH_EXCEPTIONS;
1880 JNIEXPORT
void JNICALL
1888 JNIEXPORT jboolean JNICALL
1901 #if ! defined (HAVE_JAVA)
1911 #if defined (HAVE_JAVA)
1917 octave_unused_parameter (jobj);
1918 octave_unused_parameter (jcls);
1932 #if defined (HAVE_JAVA)
1943 #if defined (HAVE_JAVA)
1964 const std::list<octave_value_list>& idx,
int nargout)
1966 #if defined (HAVE_JAVA)
1976 if (type.length () > 1 && type[1] ==
'(')
1981 ovl(0) = (idx.front ())(0);
1982 std::list<octave_value_list>::const_iterator it = idx.begin ();
1992 ovl(1) = (idx.front ())(0);
2004 error (
"subsref: Java object cannot be indexed with %c", type[0]);
2008 if (idx.size () > 1 && type.length () > 1)
2015 octave_unused_parameter (type);
2016 octave_unused_parameter (idx);
2017 octave_unused_parameter (nargout);
2029 const std::list<octave_value_list>& idx,
2032 #if defined (HAVE_JAVA)
2041 if (type.length () == 1)
2047 ovl(1) = (idx.front ())(0);
2049 feval (
"__java_set__", ovl, 0);
2054 else if (type.length () > 2 && type[1] ==
'(')
2056 std::list<octave_value_list> new_idx;
2057 std::list<octave_value_list>::const_iterator it = idx.begin ();
2058 new_idx.push_back (*it++);
2059 new_idx.push_back (*it++);
2062 std::list<octave_value_list> next_idx (idx);
2063 next_idx.erase (next_idx.begin ());
2064 next_idx.erase (next_idx.begin ());
2065 u(0).subsasgn (type.substr (2), next_idx, rhs);
2070 else if (type[1] ==
'.')
2074 std::list<octave_value_list> next_idx (idx);
2075 next_idx.erase (next_idx.begin ());
2076 u(0).subsasgn (type.substr (1), next_idx, rhs);
2082 error (
"invalid indexing/assignment on Java object");
2097 error (
"Java object cannot be indexed with %c", type[0]);
2105 octave_unused_parameter (type);
2106 octave_unused_parameter (idx);
2107 octave_unused_parameter (rhs);
2120 #if defined (HAVE_JAVA)
2142 #if defined (HAVE_JAVA)
2153 octave_unused_parameter (force);
2154 octave_unused_parameter (type);
2183 warning (
"save: unable to save java objects, skipping");
2198 warning (
"save: unable to save java objects, skipping");
2215 warning (
"save: unable to save java objects, skipping");
2231 #if defined (HAVE_JAVA)
2235 JNIEnv *jni_env =
TO_JNIENV (jni_env_arg);
2240 if (
unbox (jni_env, args, arg_objs, arg_types))
2243 jmethodID mID = jni_env->GetStaticMethodID (helperClass,
"invokeMethod",
2244 "(Ljava/lang/Object;Ljava/lang/String;[Ljava/lang/Object;[Ljava/lang/Class;)Ljava/lang/Object;");
2245 jstring_ref methName (jni_env, jni_env->NewStringUTF (name.c_str ()));
2246 jobjectArray_ref resObj (jni_env, reinterpret_cast<jobjectArray> (jni_env->CallStaticObjectMethod (helperClass, mID,
2247 to_java (), jstring (methName), jobjectArray (arg_objs), jobjectArray (arg_types))));
2249 retval =
box (jni_env, resObj);
2261 octave_unused_parameter (jni_env_arg);
2262 octave_unused_parameter (name);
2263 octave_unused_parameter (args);
2277 #if defined (HAVE_JAVA)
2283 octave_unused_parameter (name);
2284 octave_unused_parameter (args);
2300 #if defined (HAVE_JAVA)
2304 JNIEnv *jni_env =
TO_JNIENV (jni_env_arg);
2309 if (
unbox (jni_env, args, arg_objs, arg_types))
2312 jmethodID mID = jni_env->GetStaticMethodID (helperClass,
"invokeStaticMethod",
2313 "(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;[Ljava/lang/Class;)Ljava/lang/Object;");
2314 jstring_ref methName (jni_env, jni_env->NewStringUTF (name.c_str ()));
2315 jstring_ref clsName (jni_env, jni_env->NewStringUTF (class_name.c_str ()));
2316 jobject_ref resObj (jni_env, jni_env->CallStaticObjectMethod (helperClass, mID,
2317 jstring (clsName), jstring (methName), jobjectArray (arg_objs), jobjectArray (arg_types)));
2319 retval =
box (jni_env, resObj);
2331 octave_unused_parameter (jni_env_arg);
2332 octave_unused_parameter (class_name);
2333 octave_unused_parameter (name);
2334 octave_unused_parameter (args);
2349 #if defined (HAVE_JAVA)
2355 octave_unused_parameter (class_name);
2356 octave_unused_parameter (name);
2357 octave_unused_parameter (args);
2371 #if defined (HAVE_JAVA)
2375 JNIEnv *jni_env =
TO_JNIENV (jni_env_arg);
2381 if (
unbox (jni_env, args, arg_objs, arg_types))
2384 jmethodID mID = jni_env->GetStaticMethodID (helperClass,
"invokeConstructor",
2385 "(Ljava/lang/String;[Ljava/lang/Object;[Ljava/lang/Class;)Ljava/lang/Object;");
2386 jstring_ref clsName (jni_env, jni_env->NewStringUTF (name.c_str ()));
2387 jobject_ref resObj (jni_env, jni_env->CallStaticObjectMethod (helperClass, mID,
2388 jstring (clsName), jobjectArray (arg_objs), jobjectArray (arg_types)));
2403 octave_unused_parameter (jni_env_arg);
2404 octave_unused_parameter (name);
2405 octave_unused_parameter (args);
2419 #if defined (HAVE_JAVA)
2425 octave_unused_parameter (name);
2426 octave_unused_parameter (args);
2439 #if defined (HAVE_JAVA)
2443 JNIEnv *jni_env =
TO_JNIENV (jni_env_arg);
2448 jmethodID mID = jni_env->GetStaticMethodID (helperClass,
"getField",
2449 "(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;");
2450 jstring_ref fName (jni_env, jni_env->NewStringUTF (name.c_str ()));
2451 jobject_ref resObj (jni_env, jni_env->CallStaticObjectMethod (helperClass, mID,
2452 to_java (), jstring (fName)));
2455 retval =
box (jni_env, resObj);
2466 octave_unused_parameter (jni_env_arg);
2467 octave_unused_parameter (name);
2480 #if defined (HAVE_JAVA)
2486 octave_unused_parameter (name);
2500 #if defined (HAVE_JAVA)
2504 JNIEnv *jni_env =
TO_JNIENV (jni_env_arg);
2509 jmethodID mID = jni_env->GetStaticMethodID (helperClass,
"getStaticField",
2510 "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;");
2511 jstring_ref cName (jni_env, jni_env->NewStringUTF (class_name.c_str ()));
2512 jstring_ref fName (jni_env, jni_env->NewStringUTF (name.c_str ()));
2513 jobject_ref resObj (jni_env, jni_env->CallStaticObjectMethod (helperClass, mID,
2514 jstring (cName), jstring (fName)));
2516 retval =
box (jni_env, resObj);
2527 octave_unused_parameter (jni_env_arg);
2528 octave_unused_parameter (class_name);
2529 octave_unused_parameter (name);
2543 #if defined (HAVE_JAVA)
2549 octave_unused_parameter (class_name);
2550 octave_unused_parameter (name);
2564 #if defined (HAVE_JAVA)
2568 JNIEnv *jni_env =
TO_JNIENV (jni_env_arg);
2575 if (
unbox (jni_env, val, jobj, jcls))
2578 jmethodID mID = jni_env->GetStaticMethodID (helperClass,
"setField",
2579 "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)V");
2580 jstring_ref fName (jni_env, jni_env->NewStringUTF (name.c_str ()));
2581 jni_env->CallStaticObjectMethod (helperClass, mID,
to_java (), jstring (fName), jobject (jobj));
2592 octave_unused_parameter (jni_env_arg);
2593 octave_unused_parameter (name);
2594 octave_unused_parameter (val);
2607 #if defined (HAVE_JAVA)
2613 octave_unused_parameter (name);
2614 octave_unused_parameter (val);
2628 #if defined (HAVE_JAVA)
2632 JNIEnv *jni_env =
TO_JNIENV (jni_env_arg);
2639 if (
unbox (jni_env, val, jobj, jcls))
2642 jmethodID mID = jni_env->GetStaticMethodID (helperClass,
"setStaticField",
2643 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)V");
2644 jstring_ref cName (jni_env, jni_env->NewStringUTF (class_name.c_str ()));
2645 jstring_ref fName (jni_env, jni_env->NewStringUTF (name.c_str ()));
2646 jni_env->CallStaticObjectMethod (helperClass, mID, jstring (cName), jstring (fName), jobject (jobj));
2657 octave_unused_parameter (jni_env_arg);
2658 octave_unused_parameter (class_name);
2659 octave_unused_parameter (name);
2660 octave_unused_parameter (val);
2675 #if defined (HAVE_JAVA)
2681 octave_unused_parameter (class_name);
2682 octave_unused_parameter (name);
2683 octave_unused_parameter (val);
2696 #if defined (HAVE_JAVA)
2709 java_class = current_env->NewGlobalRef (jcls);
2713 java_class = current_env->NewGlobalRef (jclass (ocls));
2719 jmethodID mID = current_env->GetMethodID (clsCls,
"getCanonicalName",
"()Ljava/lang/String;");
2727 octave_unused_parameter (jobj_arg);
2728 octave_unused_parameter (jcls_arg);
2741 #if defined (HAVE_JAVA)
2770 DEFUN (__java_init__, , ,
2778 #if defined (HAVE_JAVA)
2797 DEFUN (__java_exit__, , ,
2806 #if defined (HAVE_JAVA)
2839 #if defined (HAVE_JAVA)
2841 if (
args.length () == 0)
2844 std::string classname =
args(0).xstring_value (
"javaObject: CLASSNAME must be a string");
2851 for (
int i=1;
i<
args.length ();
i++)
2858 octave_unused_parameter (
args);
2903 #if defined (HAVE_JAVA)
2905 if (
args.length () < 2)
2908 std::string methodname =
args(0).xstring_value (
"javaMethod: METHODNAME must be a string");
2917 for (
int i=2;
i<
args.length ();
i++)
2920 if (
args(1).is_java ())
2923 retval = jobj->
do_javaMethod (current_env, methodname, tmp);
2925 else if (
args(1).is_string ())
2931 error (
"javaMethod: OBJ must be a Java object or a string");
2937 octave_unused_parameter (
args);
2976 #if defined (HAVE_JAVA)
2978 if (
args.length () != 2)
2989 if (
args(0).is_java ())
2994 else if (
args(0).is_string ())
3000 error (
"__java_get__: OBJ must be a Java object or a string");
3006 octave_unused_parameter (
args);
3036 #if defined (HAVE_JAVA)
3038 if (
args.length () != 3)
3041 std::string name =
args(1).xstring_value (
"__java_set__: NAME must be a string");
3049 if (
args(0).is_java ())
3054 else if (
args(0).is_string ())
3060 error (
"__java_set__: OBJ must be a Java object or a string");
3066 octave_unused_parameter (
args);
3079 #if defined (HAVE_JAVA)
3081 if (
args.length () != 1)
3090 if (
args(0).is_java ())
3102 octave_unused_parameter (
args);
3125 #if defined (HAVE_JAVA)
3131 octave_unused_parameter (
args);
3132 octave_unused_parameter (
nargout);
3156 #if defined (HAVE_JAVA)
3162 octave_unused_parameter (
args);
3163 octave_unused_parameter (
nargout);
3185 #if defined (HAVE_JAVA)
3191 octave_unused_parameter (
args);
3192 octave_unused_parameter (
nargout);
3210 if (
args.length () != 1)
3213 return ovl (
args(0).is_java ());
uint8NDArray uint8_array_value(void) const
static std::string dir_sep_str(void)
java_local_ref(JNIEnv *_env, T obj)
bool is_empty(void) const
bool is_range(void) const
static std::string get_current_directory(void)
Octave interface to the compression and uncompression libraries.
JNIEXPORT void JNICALL Java_org_octave_Octave_doEvalString(JNIEnv *, jclass, jstring)
static octave_value get_array_elements(JNIEnv *jni_env, jobject jobj, const octave_value_list &idx)
bool save_hdf5(octave_hdf5_id loc_id, const char *name, bool save_as_floats)
octave_idx_type length(octave_idx_type n=0) const
octave_refcount< octave_idx_type > count
bool is_real_type(void) const
octave_idx_type rows(void) const
void * search(const std::string &nm, name_mangler mangler=0) const
void octave_set_default_fpucw(void)
static octave_value do_javaObject(void *jni_env, const std::string &name, const octave_value_list &args)
void resize(octave_idx_type nr, octave_idx_type nc, double rfv=0)
int8NDArray int8_array_value(void) const
bool load_ascii(std::istream &is)
bool is_vector(void) const
#define UNBOX_PRIMITIVE_SCALAR(OCTAVE_T, METHOD_T, JAVA_T, JAVA_CON)
OCTAVE_EXPORT octave_value_list isa nd deftypefn *return ovl(args(0).is_integer_type())
bool is_uint16_type(void) const
java_local_ref< jclass > jclass_ref
OCTINTERP_API void print_usage(void)
octave_idx_type numel(void) const
Number of elements in the array.
java_local_ref< jstring > jstring_ref
OCTAVE_EXPORT octave_value_list uint16
static dim_vector compute_array_dimensions(JNIEnv *jni_env, jobject obj)
identity matrix If supplied two scalar respectively For allows like xample val
void set_pos_if_unset(octave_idx_type nd_arg, octave_idx_type dim_arg)
static octave_value set_array_elements(JNIEnv *jni_env, jobject jobj, const octave_value_list &idx, const octave_value &rhs)
octave_idx_type length(void) const
octave_value_list & append(const octave_value &val)
static char * strsave(const char *s)
java_local_ref< jbyteArray > jbyteArray_ref
void resize(int n, int fill_value=0)
octave_value do_java_set(void *jni_env, const std::string &name, const octave_value &val)
#define DEFUN(name, args_name, nargout_name, doc)
void error(const char *fmt,...)
int32NDArray int32_array_value(void) const
#define SET_INTERNAL_VARIABLE(NM)
bool is_int8_type(void) const
JNIEXPORT jboolean JNICALL Java_org_octave_Octave_call(JNIEnv *, jclass, jstring, jobjectArray, jobjectArray)
std::string Vfcn_file_dir
static void initialize_java(void)
static std::string initial_java_dir(void)
octave_value subsasgn(const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
static std::string jstring_to_string(JNIEnv *jni_env, jstring s)
octave_value resize(const dim_vector &dv, bool fill=false) const
void init(void *jobj, void *jcls)
#define BOX_PRIMITIVE_ARRAY(JAVA_TYPE, JAVA_ID, JAVA_TYPE_CAP, OCTAVE_ID)
bool is_int32_type(void) const
static std::string initial_class_path(void)
static jobject make_java_index(JNIEnv *jni_env, const octave_value_list &idx)
void newline(std::ostream &os) const
static std::string tilde_expand(const std::string &)
static void initialize_jvm(void)
void read_java_opts(const std::string &filename)
bool is_function_handle(void) const
static std::string getenv(const std::string &name)
bool load_hdf5(octave_hdf5_id loc_id, const char *name)
static string_vector get_invoke_list(JNIEnv *jni_env, void *jobj_arg)
OCTAVE_EXPORT octave_value_list search each directory of the loadpath for element of the cell array and return the first that matches If the second optional argument return a cell array containing the list of all files that have the same name in the path If no files are found
JNIEXPORT jboolean JNICALL Java_org_octave_Octave_needThreadedInvokation(JNIEnv *, jclass)
Cell cell_value(void) const
bool is_float_type(void) const
static std::map< int, octave_value > listener_map
Array< std::string > cellstr_value(void) const
static int java_event_hook(void)
octave_idx_type columns(void) const
typedef jint(JNICALL *JNI_CreateJavaVM_t)(JavaVM **pvm
bool Vjava_matrix_autoconversion
OCTAVE_EXPORT octave_value_list return the number of command line arguments passed to Octave If called with the optional argument the function xample nargout(@histc)
static void replace(QString &text, const QRegExp &re, const QString &after)
octave_value convert_to_str(bool pad=false, bool force=false, char type= '\'') const
static std::string get_home_directory(void)
octave_idx_type numel(const octave_value_list &idx)
static JNIEnv * thread_jni_env(void)
bool is_bool_type(void) const
bool is_real_scalar(void) const
std::string string_value(bool force=false) const
OCTAVE_EXPORT octave_value_list uint32
nd deftypefn *octave_map m
octave_value do_java_get(void *jni_env, const std::string &name)
bool save_ascii(std::ostream &os)
then the function must return scalars which will be concatenated into the return array(s).If code
bool is_matrix_type(void) const
static long octave_thread_ID
bool is_string(void) const
OCTAVE_EXPORT octave_value_list int16
bool is_double_type(void) const
static bool unbox(JNIEnv *jni_env, const octave_value &val, jobject_ref &jobj, jclass_ref &jcls)
octave_value do_javaMethod(void *jni_env, const std::string &name, const octave_value_list &args)
void print_raw(std::ostream &os, bool pr_as_read_syntax=false) const
bool is_int64_type(void) const
bool is_cellstr(void) const
#define panic_impossible()
Matrix transpose(void) const
OCTAVE_EXPORT octave_value_list int32
JNIEXPORT void JNICALL Java_org_octave_OctaveReference_doFinalize(JNIEnv *, jclass, jint)
string_vector & sort(bool make_uniq=false)
dim_vector dims(void) const
static octave_value check_exception(JNIEnv *jni_env)
octave_idx_type length(void) const
static int octave_java_refcount
static jclass find_octave_class(JNIEnv *jni_env, const char *name)
the sparsity preserving column transformation such that that defines the pivoting threshold can be given in which case it defines the c
static std::string read_classpath_txt(const std::string &filepath)
java_local_ref(JNIEnv *_env)
the exceeded dimensions are set to if fewer subscripts than dimensions are the exceeding dimensions are merged into the final requested dimension For consider the following dims
dim_vector dims(void) const
java_local_ref< jobjectArray > jobjectArray_ref
Matrix matrix_value(bool frc_str_conv=false) const
java_local_ref< jdoubleArray > jdoubleArray_ref
With real return the complex result
bool Vjava_unsigned_autoconversion
friend class octave_value
octave_function * function_value(bool silent=false) const
bool is_int16_type(void) const
OCTAVE_EXPORT octave_value_list int64
static octave_value convert_to_string(JNIEnv *jni_env, jobject java_object, bool force, char type)
static const std::string t_name
void warning(const char *fmt,...)
static std::string path_sep_str(void)
bool is_empty(void) const
bool is_bool_scalar(void) const
std::list< std::string > java_opts
NDArray array_value(bool frc_str_conv=false) const
JavaVMInitArgs * to_args()
void print(std::ostream &os, bool pr_as_read_syntax=false)
bool is_java_string(void) const
static bool is_auto_convertible_number(JNIEnv *jni_env, jobject jobj)
Return whether jobj shall be automatically converted to an Octave numeric value.
static void register_type(void)
octave_value convert_to_str_internal(bool pad, bool force, char type) const
static octave_value box(JNIEnv *jni_env, void *jobj, void *jcls_arg=0)
Convert the Java object pointed to by jobj_arg with class jcls_arg to an Octave value.
=val(i)}if ode{val(i)}occurs in table i
std::string java_classname
bool is_uint8_type(void) const
string_vector map_keys(void) const
static int register_type(const std::string &, const std::string &, const octave_value &)
OCTAVE_EXPORT octave_value_list or N dimensional array whose elements are all equal to the IEEE symbol zero divided by nd tex zero divided by nd ifnottex and any operation involving another NaN value(5+NaN).Note that NaN always compares not equal to NaN(NaN!
#define UNBOX_PRIMITIVE_ARRAY(METHOD_T, OCTAVE_T, JAVA_T, JAVA_T_CAP)
JNIEXPORT void JNICALL Java_org_octave_Octave_doInvoke(JNIEnv *, jclass, jint, jobjectArray)
java_local_ref< jobject > jobject_ref
octave_idx_type ndims(void) const
Number of dimensions.
std::string class_name(void) const
java_local_ref< jintArray > jintArray_ref
bool is_instance_of(const std::string &) const
bool is_undefined(void) const
bool is_uint64_type(void) const
octave::sys::file_stat fs(filename)
static long get_current_thread_ID(JNIEnv *jni_env)
octave_value_list subsref(const std::string &type, const std::list< octave_value_list > &idx, int nargout)
static void add_event_hook(event_hook_fcn f)
static std::map< int, octave_value > octave_ref_map
static octave_value box_more(JNIEnv *jni_env, void *jobj_arg, void *jcls_arg=0)
OCTINTERP_API octave_value_list eval_string(const std::string &, bool silent, int &parse_status, int nargout)
static void terminate_jvm(void)
void close(close_hook cl_hook=0)
const T * fortran_vec(void) const
void add(const std::string &opt)
bool is_uint32_type(void) const
Vector representing the dimensions (size) of an Array.
void err_disabled_feature(const std::string &fcn, const std::string &feature, const std::string &pkg)
If this string is the system will ring the terminal sometimes it is useful to be able to print the original representation of the string
static octave::dynamic_library jvm_lib
java_local_ref< jthrowable > jthrowable_ref
octave_value next_subsref(const std::string &type, const std::list< octave_value_list > &idx, size_t skip=1)
where the brackets indicate optional arguments and and character or cell array For character arrays the conversion is repeated for every row
return octave_value(v1.char_array_value().concat(v2.char_array_value(), ra_idx),((a1.is_sq_string()||a2.is_sq_string())? '\'': '"'))
bool save_binary(std::ostream &os, bool &save_as_floats)
bool is_real_matrix(void) const
void * to_java(void) const
bool load_binary(std::istream &is, bool swap, octave::mach_info::float_format fmt)