From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- .../native/jni/gconf-peer/GConfNativePeer.c | 617 +++++++++++++++++++++ 1 file changed, 617 insertions(+) create mode 100644 libjava/classpath/native/jni/gconf-peer/GConfNativePeer.c (limited to 'libjava/classpath/native/jni/gconf-peer/GConfNativePeer.c') diff --git a/libjava/classpath/native/jni/gconf-peer/GConfNativePeer.c b/libjava/classpath/native/jni/gconf-peer/GConfNativePeer.c new file mode 100644 index 000000000..3564f9b69 --- /dev/null +++ b/libjava/classpath/native/jni/gconf-peer/GConfNativePeer.c @@ -0,0 +1,617 @@ +/* GConfNativePeer.c -- Implements native methods for class GConfNativePeer + Copyright (C) 2003, 2004 Free Software Foundation, Inc. + + This file is part of GNU Classpath. + + GNU Classpath is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + GNU Classpath is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GNU Classpath; see the file COPYING. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301 USA. + + Linking this library statically or dynamically with other modules is + making a combined work based on this library. Thus, the terms and + conditions of the GNU General Public License cover the whole + combination. + + As a special exception, the copyright holders of this library give you + permission to link this library with independent modules to produce an + executable, regardless of the license terms of these independent + modules, and to copy and distribute the resulting executable under + terms of your choice, provided that you also meet, for each linked + independent module, the terms and conditions of the license of that + module. An independent module is a module which is not derived from + or based on this library. If you modify this library, you may extend + this exception to your version of the library, but you are not + obligated to do so. If you do not wish to do so, delete this + exception statement from your version. */ + +#include +#include + +#include + +#include +#include +#include + +#include "jcl.h" + +#include "gnu_java_util_prefs_gconf_GConfNativePeer.h" + +/* + * Cached id, methods and objects + */ + +/** Reference count */ +static int reference_count = 0; + +/** GConfEngine backend */ +static GConfEngine *engine = NULL; + +/** java.util.ArrayList class */ +static jclass jlist_class = NULL; + +/** java.util.ArrayList constructor id */ +static jmethodID jlist_init_id = NULL; + +/** ava.util.ArrayList add id */ +static jmethodID jlist_add_id = NULL; + +/* ***** PRIVATE FUNCTIONS DELCARATION ***** */ + +/** + * Gets the reference of the default GConfEngine.. + * The client reference should be released with g_object_unref after use. + */ +static void init_gconf (void); + +/** + * Throws a new runtime exception after a failure, with the given message. + */ +static void throw_exception (JNIEnv * env, const char *msg); + +/** + * Throws the given exception after a failure, with the given message. + */ +static void +throw_exception_by_name (JNIEnv * env, const char *name, const char *msg); + +/** + * Return a reference to a java.util.ArrayList class. + */ +static gboolean set_jlist_class (JNIEnv * env); + +/** + * Builds a new reference to a new java.util.ArrayList instace. + * The instance should be freed by the caller after use. + */ +static jclass get_jlist_reference (JNIEnv * env, jclass jlist_class); + +/* ***** END: PRIVATE FUNCTIONS DELCARATION ***** */ + +/* ***** NATIVE FUNCTIONS ***** */ + +/* + * Class: gnu_java_util_prefs_gconf_GConfNativePeer + * Method: init_class + * Signature: ()V + */ +JNIEXPORT void JNICALL +Java_gnu_java_util_prefs_gconf_GConfNativePeer_init_1class + (JNIEnv *env, jclass clazz) +{ + if (reference_count == 0) + { + Java_gnu_java_util_prefs_gconf_GConfNativePeer_init_1id_1cache + (env, clazz); + return; + } + + reference_count++; +} + +/* + * Class: gnu_java_util_prefs_gconf_GConfNativePeer + * Method: init_id_chache + * Signature: ()V + */ +JNIEXPORT void JNICALL +Java_gnu_java_util_prefs_gconf_GConfNativePeer_init_1id_1cache + (JNIEnv *env, jclass clazz __attribute__ ((unused))) +{ + reference_count++; + + init_gconf (); + + /* if engine is null, there is probably an out of memory */ + if (engine == NULL) + { + /* release the string and throw a runtime exception */ + throw_exception (env, + "Unable to initialize GConfEngine in native code\n"); + return; + } + + /* ***** java.util.ArrayList ***** */ + if (set_jlist_class (env) == FALSE) + { + throw_exception (env, + "Unable to get valid reference to java.util.List in native code\n"); + return; + } +} + +/* + * Class: gnu_java_util_prefs_gconf_GConfNativePeer + * Method: gconf_all_keys + * Signature: (Ljava/lang/String;)Ljava/util/List; + */ +JNIEXPORT jobject JNICALL +Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1all_1keys + (JNIEnv *env, jclass clazz __attribute__ ((unused)), jstring node) +{ + /* TODO: check all the calls to gdk_threads_enter/leave */ + + const char *dir = NULL; + const char *_val = NULL; + const char *_val_unescaped = NULL; + + GError *err = NULL; + GSList *entries = NULL; + GSList *tmp; + + /* java.util.ArrayList */ + jobject jlist = NULL; + + dir = JCL_jstring_to_cstring (env, node); + if (dir == NULL) + { + return NULL; + } + + entries = gconf_engine_all_entries (engine, dir, &err); + if (err != NULL) + { + throw_exception_by_name (env, "java/util/prefs/BackingStoreException", + err->message); + g_error_free (err); + err = NULL; + + JCL_free_cstring (env, node, dir); + return NULL; + } + + jlist = get_jlist_reference (env, jlist_class); + if (jlist == NULL) + { + throw_exception_by_name (env, "java/util/prefs/BackingStoreException", + "Unable to get java.util.List reference in native code\n"); + JCL_free_cstring (env, node, dir); + g_slist_foreach (entries, (GFunc) gconf_entry_free, NULL); + g_slist_free (entries); + return NULL; + } + + tmp = entries; + while (tmp != NULL) + { + _val = gconf_entry_get_key (tmp->data); + _val = strrchr (_val, '/'); + ++_val; + + _val_unescaped = gconf_unescape_key (_val, strlen (_val)); + + (*env)->CallBooleanMethod (env, jlist, jlist_add_id, + (*env)->NewStringUTF (env, _val_unescaped)); + + tmp = g_slist_next (tmp); + + g_free ((gpointer) _val_unescaped); + } + + /* clean up things */ + JCL_free_cstring (env, node, dir); + g_slist_foreach (entries, (GFunc) gconf_entry_free, NULL); + g_slist_free (entries); + + return jlist; +} + +/* + * Class: gnu_java_util_prefs_gconf_GConfNativePeer + * Method: gconf_all_nodes + * Signature: (Ljava/lang/String;)Ljava/util/List; + */ +JNIEXPORT jobject JNICALL +Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1all_1nodes + (JNIEnv *env, jclass clazz __attribute__ ((unused)), jstring node) +{ + const char *dir = NULL; + const char *_val = NULL; + const char *_val_unescaped = NULL; + + GError *err = NULL; + GSList *entries = NULL; + GSList *tmp; + + /* java.util.ArrayList */ + jobject jlist = NULL; + + dir = JCL_jstring_to_cstring (env, node); + if (dir == NULL) + { + return NULL; + } + + entries = gconf_engine_all_dirs (engine, dir, &err); + if (err != NULL) + { + throw_exception_by_name (env, "java/util/prefs/BackingStoreException", + err->message); + g_error_free (err); + err = NULL; + JCL_free_cstring (env, node, dir); + return NULL; + } + + jlist = get_jlist_reference (env, jlist_class); + if (jlist == NULL) + { + throw_exception_by_name (env, "java/util/prefs/BackingStoreException", + "Unable to get java.util.List reference in native code\n"); + JCL_free_cstring (env, node, dir); + g_slist_foreach (entries, (GFunc) gconf_entry_free, NULL); + g_slist_free (entries); + return NULL; + } + + tmp = entries; + while (tmp != NULL) + { + _val = tmp->data; + + _val = strrchr (_val, '/'); + ++_val; + + _val_unescaped = gconf_unescape_key (_val, strlen (_val)); + + (*env)->CallBooleanMethod (env, jlist, jlist_add_id, + (*env)->NewStringUTF (env, _val_unescaped)); + + tmp = g_slist_next (tmp); + + g_free ((gpointer) _val_unescaped); + } + + /* clean up things */ + JCL_free_cstring (env, node, dir); + g_slist_foreach (entries, (GFunc) gconf_entry_free, NULL); + g_slist_free (entries); + + return jlist; +} + +/* + * Class: gnu_java_util_prefs_gconf_GConfNativePeer + * Method: gconf_suggest_sync + * Signature: ()V + */ +JNIEXPORT void JNICALL +Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1suggest_1sync + (JNIEnv *env, jclass clazz __attribute__ ((unused))) +{ + GError *err = NULL; + + gconf_engine_suggest_sync (engine, &err); + if (err != NULL) + { + throw_exception_by_name (env, "java/util/prefs/BackingStoreException", + err->message); + g_error_free (err); + err = NULL; + } +} + +/* + * Class: gnu_java_util_prefs_gconf_GConfNativePeer + * Method: gconf_unset + * Signature: (Ljava/lang/String;)Z + */ +JNIEXPORT jboolean JNICALL +Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1unset + (JNIEnv *env, jclass clazz __attribute__ ((unused)), jstring key) +{ + const char *_key = NULL; + gboolean result = JNI_FALSE; + GError *err = NULL; + + _key = JCL_jstring_to_cstring (env, key); + if (_key == NULL) + { + return JNI_FALSE; + } + + result = gconf_engine_unset (engine, _key, &err); + if (err != NULL) + { + result = JNI_FALSE; + g_error_free (err); + err = NULL; + } + + JCL_free_cstring (env, key, _key); + + return result; +} + +/* + * Class: gnu_java_util_prefs_gconf_GConfNativePeer + * Method: gconf_get_string + * Signature: (Ljava/lang/String;)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL +Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1get_1string + (JNIEnv *env, jclass clazz __attribute__ ((unused)), jstring key) +{ + const char *_key = NULL; + const char *_value = NULL; + GError *err = NULL; + jstring result = NULL; + + _key = JCL_jstring_to_cstring (env, key); + if (_key == NULL) + { + return NULL; + } + + _value = gconf_engine_get_string (engine, _key, &err); + JCL_free_cstring (env, key, _key); + if (err != NULL) + { + /* just in case */ + if (_value != NULL) g_free ((gpointer) _value); + g_error_free (err); + err = NULL; + + return NULL; + } + + /* Even if Gconf reported no error it is possible that NULL was returned */ + /* and it should be prevented to create a Java string from that value. */ + if (_value != NULL) + { + result = (*env)->NewStringUTF (env, _value); + g_free ((gpointer) _value); + } + + gconf_engine_suggest_sync (engine, NULL); + + return result; +} + +/* + * Class: gnu_java_util_prefs_gconf_GConfNativePeer + * Method: gconf_set_string + * Signature: (Ljava/lang/String;Ljava/lang/String;)Z + */ +JNIEXPORT jboolean JNICALL +Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1set_1string + (JNIEnv *env, jclass clazz __attribute__ ((unused)), + jstring key, jstring value) +{ + const char *_key = NULL; + const char *_value = NULL; + GError *err = NULL; + + gboolean result = JNI_FALSE; + + /* load an UTF string from the virtual machine. */ + _key = JCL_jstring_to_cstring (env, key); + _value = JCL_jstring_to_cstring (env, value); + if (_key == NULL || _value == NULL) + { + return JNI_FALSE; + } + + result = gconf_engine_set_string (engine, _key, _value, &err); + if (err != NULL) + { + g_error_free (err); + err = NULL; + result = JNI_FALSE; + } + + JCL_free_cstring (env, key, _key); + JCL_free_cstring (env, value, _value); + + return (jboolean) result; +} + +/* + * Class: gnu_java_util_prefs_gconf_GConfNativePeer + * Method: gconf_dir_exists + * Signature: (Ljava/lang/String;)Z + */ +JNIEXPORT jboolean JNICALL +Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1dir_1exists + (JNIEnv *env, jclass clazz __attribute__ ((unused)), jstring node) +{ + const char *dir = NULL; + GError *err = NULL; + jboolean value = JNI_FALSE; + + dir = JCL_jstring_to_cstring (env, node); + if (dir == NULL) + return value; + + /* on error return false */ + value = gconf_engine_dir_exists (engine, dir, &err); + if (err != NULL) + value = JNI_FALSE; + + JCL_free_cstring (env, node, dir); + + return value; +} + +/* + * Class: gnu_java_util_prefs_gconf_GConfNativePeer + * Method: finalize_class + * Signature: ()V + */ +JNIEXPORT void JNICALL +Java_gnu_java_util_prefs_gconf_GConfNativePeer_finalize_1class + (JNIEnv *env, jclass clazz __attribute__ ((unused))) +{ + if (reference_count == 0) + { + /* last reference, free all resources and return */ + g_object_unref (G_OBJECT (engine)); + + (*env)->DeleteGlobalRef (env, jlist_class); + + jlist_class = NULL; + jlist_init_id = NULL; + jlist_add_id = NULL; + + return; + } + + reference_count--; +} + +/* + * Class: gnu_java_util_prefs_gconf_GConfNativePeer + * Method: Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1escape_1key + * Signature: (Ljava/lang/String;)Z + */ +JNIEXPORT jstring JNICALL +Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1escape_1key + (JNIEnv *env, jclass clazz __attribute__ ((unused)), jstring plain) +{ + const char *escaped = NULL; + const char *_plain = NULL; + jstring result = NULL; + + _plain = JCL_jstring_to_cstring (env, plain); + if (_plain == NULL) + { + return NULL; + } + + escaped = gconf_escape_key (_plain, strlen (_plain)); + + JCL_free_cstring (env, plain, _plain); + /* check for NULL, if so prevent string creation */ + if (escaped != NULL) + { + result = (*env)->NewStringUTF (env, escaped); + g_free ((gpointer) escaped); + } + + return result; +} + +/* + * Class: gnu_java_util_prefs_gconf_GConfNativePeer + * Method: Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1unescape_1key + * Signature: (Ljava/lang/String;)Z + */ +JNIEXPORT jstring JNICALL +Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1unescape_1key + (JNIEnv *env, jclass clazz __attribute__ ((unused)), jstring escaped) +{ + const char *plain = NULL; + const char *_escaped = NULL; + jstring result = NULL; + + _escaped = JCL_jstring_to_cstring (env, escaped); + if (_escaped == NULL) + { + return NULL; + } + + plain = gconf_unescape_key (_escaped, strlen (_escaped)); + + JCL_free_cstring (env, escaped, _escaped); + /* check for NULL, if so prevent string creation */ + if (plain != NULL) + { + result = (*env)->NewStringUTF (env, plain); + g_free ((gpointer) plain); + } + + return result; +} + +/* ***** END: NATIVE FUNCTIONS ***** */ + +/* ***** PRIVATE FUNCTIONS IMPLEMENTATION ***** */ + +static void throw_exception (JNIEnv *env, const char *msg) +{ + throw_exception_by_name (env, "java/lang/RuntimeException", msg); +} + +static void +throw_exception_by_name (JNIEnv *env, const char *name, const char *msg) +{ + JCL_ThrowException (env, name, msg); +} + +static void init_gconf (void) +{ + engine = gconf_engine_get_default (); +} + +static gboolean set_jlist_class (JNIEnv *env) +{ + jclass local_jlist_class = NULL; + + /* gets a reference to the ArrayList class */ + local_jlist_class = JCL_FindClass (env, "java/util/ArrayList"); + if (local_jlist_class == NULL) + { + return FALSE; + } + + jlist_class = (*env)->NewGlobalRef (env, local_jlist_class); + (*env)->DeleteLocalRef (env, local_jlist_class); + if (jlist_class == NULL) + { + return FALSE; + } + + /* and initialize it */ + jlist_init_id = (*env)->GetMethodID (env, jlist_class, "", "()V"); + if (jlist_init_id == NULL) + { + return FALSE; + } + + jlist_add_id = (*env)->GetMethodID (env, jlist_class, "add", + "(Ljava/lang/Object;)Z"); + if (jlist_add_id == NULL) + { + return FALSE; + } + + return TRUE; +} + +static jobject get_jlist_reference (JNIEnv *env, jclass jlist_class) +{ + return (*env)->NewObject (env, jlist_class, jlist_init_id); +} + +/* ***** END: PRIVATE FUNCTIONS IMPLEMENTATION ***** */ -- cgit v1.2.3