trunk2/openisis/openjsis.c

/*
        openisis - an open implementation of the CDS/ISIS database
        Version 0.8.x (patchlevel see file Version)
        Copyright (C) 2001-2003 by Erik Grziwotz, erik@openisis.org

        This library is free software; you can redistribute it and/or
        modify it under the terms of the GNU Lesser General Public
        License as published by the Free Software Foundation; either
        version 2.1 of the License, or (at your option) any later version.

        This library 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
        Lesser General Public License for more details.

        You should have received a copy of the GNU Lesser General Public
        License along with this library; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

        see README for more information
EOH */

/*
        $Id: openjsis.c,v 1.17 2003/04/08 00:20:53 kripke Exp $
        main file of openjsis java native lib.
*/

#include <stdlib.h> /* free */
#include <memory.h> /* memcpy */

#include "openisis.h"
#define index stupidgcc
/*
java/jdk1.3/include/jni.h:607: warning: declaration of `index' shadows global declaration
        jobject (JNICALL *GetObjectArrayElement)
                (JNIEnv *env, jobjectArray array, jsize index);
*/
#include "org/openisis/NativeDb.h"
#undef index


/* ************************************************************
        private types
*/
/* ************************************************************
        private data
*/
/* ************************************************************
        private functions
*/
static jobjectArray rec2bytes (JNIEnv* env, OpenIsisRec *r )
{
        jobjectArray jarr = 0;
        jintArray ia;
        jint ji;
        jbyteArray ba;
        int i;

        if ( ! r )
                return 0;

        jarr = (*env)->NewObjectArray( env, 1+r->len,
                (*env)->FindClass( env, "java/lang/Object" ), 0 );
        if ( ! jarr )
                return 0;

        ia = (*env)->NewIntArray( env, 1+r->len );
        (*env)->SetObjectArrayElement( env, jarr, 0, ia );

        ji = r->rowid;
        (*env)->SetIntArrayRegion( env, ia, 0, 1, &ji );

        for ( i=0; i<r->len; i++ ) {
                OpenIsisField *f = &r->field[i];
                ba = (*env)->NewByteArray( env, f->len );
                if ( ! ba )
                        break;
                ji = f->tag;
                (*env)->SetIntArrayRegion( env, ia, i+1, 1, &ji );
                (*env)->SetByteArrayRegion( env, ba, 0, f->len, (jbyte*)f->val );
                (*env)->SetObjectArrayElement( env, jarr, i+1, ba );
        }
        return jarr;
}       /* rec2bytes */

static OpenIsisRec* bytes2rec ( JNIEnv* env, jobjectArray arr ) {
        jsize len;
        jsize alen;
        jintArray ia;
        jbyteArray ba;
        OpenIsisRec* rec;
        int i;
        jint ji;
        jint* tags;
        char *txt;

        /* initialize record */
        rec = 0;
        OPENISIS_RSPACE( rec, 8*1024, -1 );
        
        len = (*env)->GetArrayLength( env, arr );
        if ( 1 > len )
                return 0;

        ia = (*env)->GetObjectArrayElement( env, arr, 0 );
        if ( ! ia )
                return 0;

        (*env)->GetIntArrayRegion( env, ia, 0, 1, &ji );
        rec->rowid = ji;
        
        /* strip rowid / type description from length */
        --len;
        tags = malloc( len * sizeof( jint ) );
        (*env)->GetIntArrayRegion( env, ia, 1, len, tags );

        for ( i = 0; i < len; i++ ) {
                ba = (*env)->GetObjectArrayElement( env, arr, i + 1 );
                alen = (*env)->GetArrayLength( env, ba );
                txt = malloc( alen );
                memset( txt, 0, alen );
                (*env)->GetByteArrayRegion( env, ba, 0, alen, (jbyte*)txt );
                OPENISIS_RADD( rec, tags[ i ], txt, alen, 0 );
                if ( txt )
                        free( txt );
        }
        if ( tags )
                free( tags );
        return rec;
} /* bytes2rec */


/* ************************************************************
        package functions
*/
/* ************************************************************
        public functions
*/
JNIEXPORT jshort JNICALL Java_org_openisis_NativeDb_nopen
  (JNIEnv* env, jclass cls, jstring jdbname, jobjectArray jargs)
{
        int db;
        const char *dbname = 0;
        const char **argv = 0;
        int argc = 0;
        jsize i;

        (void)cls;
        dbname = ! jdbname ? 0 :
                (*env)->GetStringUTFChars( env, jdbname, 0 );
        if ( jargs ) {
                argc = (*env)->GetArrayLength( env, jargs );
                argv = malloc( argc * sizeof(*argv) );
                if ( argv )
                        for ( i=0; i<argc; i++ )
                                argv[i] = (*env)->GetStringUTFChars( env,
                                        (*env)->GetObjectArrayElement( env, jargs, i ), 0 );
        }
        db = openIsisOpen( dbname, argv, argc );
        if ( dbname )
                (*env)->ReleaseStringUTFChars( env, jdbname, dbname );
        if ( argv )
                for ( i=0; i<argc; i++ )
                        if ( argv[i] )
                                (*env)->ReleaseStringUTFChars( env,
                                        (*env)->GetObjectArrayElement( env, jargs, i ), argv[i] );
        return db;
}       /* Java_org_openisis_Db_open */


JNIEXPORT jobjectArray JNICALL Java_org_openisis_NativeDb_nreadRow
  (JNIEnv* env, jclass cls, jshort db, jint rowid, jint tag, jbyteArray txt )
{
        OpenIsisRec *r;
        jobjectArray jarr = 0;
        (void)cls;
        if ( ! txt )
                r = openIsisReadRow( db, rowid );
        else {
                jsize l = (*env)->GetArrayLength( env, txt );
                char *search = malloc( l+1 );
                (*env)->GetByteArrayRegion( env, txt, 0, l, (jbyte*)search );
                search[l] = 0;
                r = openIsisScan( db, rowid, tag, search );
                free( search );
        }
        jarr = rec2bytes( env, r );
        if ( r ) free( r );
#ifndef NDEBUG
        fflush( stderr );
#endif
        return jarr;
}       /* Java_org_openisis_Db_readRow */

/*
 * please leave me in for debugging ;)
 * static int print ( OpenIsisRec *r )
{
        int i;
        if ( r ) {
                for ( i=0; i<r->len; i++ ) {
                        if ( ! r->field[i].val ) {
                                openIsisSMsg( 1, "%d.?=%d\n", r->rowid, r->field[i].len );
                                continue;
                        }
                        openIsisSMsg( 1, "%d.%d=%.*s\n", r->rowid, r->field[i].tag,
                                (int)r->field[i].len, r->field[i].val );
                        if ( r->field[i].len && '^' == *r->field[i].val ) {
                                OpenIsisRec *rf = openIsisReadField( 0, r->field+i );
                                if ( rf ) {
                                        int j;
                                        for ( j=0; j<rf->len; j++ )
                                                openIsisSMsg( 1, "%d.%d.%c=%.*s\n",
                                                        r->rowid, r->field[i].tag,
                                                        (0x60 & (int)rf->field[j].tag ) ?
                                                                (int)rf->field[j].tag : ' ',
                                                        (int)rf->field[j].len, rf->field[j].val );
                                        free( rf );
                                }
                        }
                }
        }
        return ! r ? -1 : r->rowid;
}       */

JNIEXPORT jshort JNICALL Java_org_openisis_NativeDb_nwriteRow
  (JNIEnv* env, jclass cls, jshort db, jobjectArray arr )
{
        OpenIsisRec *r;
        jint result;
        /* no warning */
        (void) cls;
        if ( ! arr )
                return -1;
        r = bytes2rec( env, arr );
        if ( ! r )
                return -1;
        result = openIsisWrite( db, r );
        if ( r )
                free( r );
        return result;
}

JNIEXPORT jshort JNICALL Java_org_openisis_NativeDb_nwriteXRow
  (JNIEnv* env, jclass cls, jshort db, jobjectArray arr, jobjectArray idx )
{
        OpenIsisRec *r;
        OpenIsisRec *i;
        jint result;
        /* no warning */
        (void) cls;
        if ( ! arr || ! idx )
                return -1;
        r = bytes2rec( env, arr );
        i = bytes2rec( env, idx );
        if ( ! r || ! i )
                return -1;
        result = openIsisWritex( db, r, i );
        if ( r )
                free( r );
        if ( i )
                free( i );
        return result;
}

JNIEXPORT jobjectArray JNICALL Java_org_openisis_NativeDb_nTerms
  (JNIEnv* env, jclass cls, jshort db, jbyteArray term, jbyteArray start )
{
        OpenIsisRec *r;
        jobjectArray jarr = 0;
        jsize lterm = (*env)->GetArrayLength( env, term );
        char *cterm = malloc( lterm+1 );
        union { OpenIsisRec r; char buf[4096]; } x;
        x.r.len   = 0;
        x.r.bytes = sizeof(x);
        (void)cls;
        (*env)->GetByteArrayRegion( env, term, 0, lterm, (jbyte*)cterm );
        cterm[lterm] = 0;
        if ( start ) {
                char *cstart;
                jsize lstart = (*env)->GetArrayLength( env, start );
                if ( 128 < lstart )
                        lstart = 128;
                cstart = x.buf + sizeof(x.r);
                (*env)->GetByteArrayRegion( env, start, 0, lstart, (jbyte*)cstart );
                x.r.field[0].val = cstart;
                x.r.field[0].len = lstart;
                x.r.len = 1;
        }
        r = openIsisTerm( &x.r, db, cterm );
        free( cterm );
        jarr = rec2bytes( env, r );
#ifndef NDEBUG
        fflush( stderr );
#endif
        return jarr;
}       /* Java_org_openisis_Db_Terms */


JNIEXPORT jintArray JNICALL Java_org_openisis_NativeDb_nsearch
  (JNIEnv * env, jclass cls, jshort db, jbyteArray key, jint mode)
{
        jsize l;
        char *search;
        OpenIsisSet set;
        jintArray ia;
        (void)cls;
        if ( ! key )
                return 0;
        l = (*env)->GetArrayLength( env, key );
        search = malloc( l+1 );
        (*env)->GetByteArrayRegion( env, key, 0, l, (jbyte*)search );
        search[l] = 0;
        set.len = 0;
        openIsisQuery( &set, db, search, mode, 0 );
        free( search );
        if ( 0 >= set.len )
                return 0;
        ia = (*env)->NewIntArray( env, set.len );
        (*env)->SetIntArrayRegion( env, ia, 0, set.len, (jint*)set.id );
        return ia;
}       /* Java_org_openisis_Db_search */
1	dpavlin	237	/*
2			openisis - an open implementation of the CDS/ISIS database
3			Version 0.8.x (patchlevel see file Version)
4			Copyright (C) 2001-2003 by Erik Grziwotz, erik@openisis.org
5
6			This library is free software; you can redistribute it and/or
7			modify it under the terms of the GNU Lesser General Public
8			License as published by the Free Software Foundation; either
9			version 2.1 of the License, or (at your option) any later version.
10
11			This library is distributed in the hope that it will be useful,
12			but WITHOUT ANY WARRANTY; without even the implied warranty of
13			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			Lesser General Public License for more details.
15
16			You should have received a copy of the GNU Lesser General Public
17			License along with this library; if not, write to the Free Software
18			Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
20			see README for more information
21			EOH */
22
23			/*
24			$Id: openjsis.c,v 1.17 2003/04/08 00:20:53 kripke Exp $
25			main file of openjsis java native lib.
26			*/
27
28			#include <stdlib.h> /* free */
29			#include <memory.h> /* memcpy */
30
31			#include "openisis.h"
32			#define index stupidgcc
33			/*
34			java/jdk1.3/include/jni.h:607: warning: declaration of `index' shadows global declaration
35			jobject (JNICALL *GetObjectArrayElement)
36			(JNIEnv *env, jobjectArray array, jsize index);
37			*/
38			#include "org/openisis/NativeDb.h"
39			#undef index
40
41
42
43			/* ************************************************************
44			private types
45			*/
46			/* ************************************************************
47			private data
48			*/
49			/* ************************************************************
50			private functions
51			*/
52			static jobjectArray rec2bytes (JNIEnv* env, OpenIsisRec *r )
53			{
54			jobjectArray jarr = 0;
55			jintArray ia;
56			jint ji;
57			jbyteArray ba;
58			int i;
59
60			if ( ! r )
61			return 0;
62
63			jarr = (*env)->NewObjectArray( env, 1+r->len,
64			(*env)->FindClass( env, "java/lang/Object" ), 0 );
65			if ( ! jarr )
66			return 0;
67
68			ia = (*env)->NewIntArray( env, 1+r->len );
69			(*env)->SetObjectArrayElement( env, jarr, 0, ia );
70
71			ji = r->rowid;
72			(*env)->SetIntArrayRegion( env, ia, 0, 1, &ji );
73
74			for ( i=0; i<r->len; i++ ) {
75			OpenIsisField *f = &r->field[i];
76			ba = (*env)->NewByteArray( env, f->len );
77			if ( ! ba )
78			break;
79			ji = f->tag;
80			(*env)->SetIntArrayRegion( env, ia, i+1, 1, &ji );
81			(env)->SetByteArrayRegion( env, ba, 0, f->len, (jbyte)f->val );
82			(*env)->SetObjectArrayElement( env, jarr, i+1, ba );
83			}
84			return jarr;
85			} /* rec2bytes */
86
87			static OpenIsisRec* bytes2rec ( JNIEnv* env, jobjectArray arr ) {
88			jsize len;
89			jsize alen;
90			jintArray ia;
91			jbyteArray ba;
92			OpenIsisRec* rec;
93			int i;
94			jint ji;
95			jint* tags;
96			char *txt;
97
98			/* initialize record */
99			rec = 0;
100			OPENISIS_RSPACE( rec, 8*1024, -1 );
101
102			len = (*env)->GetArrayLength( env, arr );
103			if ( 1 > len )
104			return 0;
105
106			ia = (*env)->GetObjectArrayElement( env, arr, 0 );
107			if ( ! ia )
108			return 0;
109
110			(*env)->GetIntArrayRegion( env, ia, 0, 1, &ji );
111			rec->rowid = ji;
112
113			/* strip rowid / type description from length */
114			--len;
115			tags = malloc( len * sizeof( jint ) );
116			(*env)->GetIntArrayRegion( env, ia, 1, len, tags );
117
118			for ( i = 0; i < len; i++ ) {
119			ba = (*env)->GetObjectArrayElement( env, arr, i + 1 );
120			alen = (*env)->GetArrayLength( env, ba );
121			txt = malloc( alen );
122			memset( txt, 0, alen );
123			(env)->GetByteArrayRegion( env, ba, 0, alen, (jbyte)txt );
124			OPENISIS_RADD( rec, tags[ i ], txt, alen, 0 );
125			if ( txt )
126			free( txt );
127			}
128			if ( tags )
129			free( tags );
130			return rec;
131			} /* bytes2rec */
132
133
134			/* ************************************************************
135			package functions
136			*/
137			/* ************************************************************
138			public functions
139			*/
140			JNIEXPORT jshort JNICALL Java_org_openisis_NativeDb_nopen
141			(JNIEnv* env, jclass cls, jstring jdbname, jobjectArray jargs)
142			{
143			int db;
144			const char *dbname = 0;
145			const char **argv = 0;
146			int argc = 0;
147			jsize i;
148
149			(void)cls;
150			dbname = ! jdbname ? 0 :
151			(*env)->GetStringUTFChars( env, jdbname, 0 );
152			if ( jargs ) {
153			argc = (*env)->GetArrayLength( env, jargs );
154			argv = malloc( argc * sizeof(*argv) );
155			if ( argv )
156			for ( i=0; i<argc; i++ )
157			argv[i] = (*env)->GetStringUTFChars( env,
158			(*env)->GetObjectArrayElement( env, jargs, i ), 0 );
159			}
160			db = openIsisOpen( dbname, argv, argc );
161			if ( dbname )
162			(*env)->ReleaseStringUTFChars( env, jdbname, dbname );
163			if ( argv )
164			for ( i=0; i<argc; i++ )
165			if ( argv[i] )
166			(*env)->ReleaseStringUTFChars( env,
167			(*env)->GetObjectArrayElement( env, jargs, i ), argv[i] );
168			return db;
169			} /* Java_org_openisis_Db_open */
170
171
172			JNIEXPORT jobjectArray JNICALL Java_org_openisis_NativeDb_nreadRow
173			(JNIEnv* env, jclass cls, jshort db, jint rowid, jint tag, jbyteArray txt )
174			{
175			OpenIsisRec *r;
176			jobjectArray jarr = 0;
177			(void)cls;
178			if ( ! txt )
179			r = openIsisReadRow( db, rowid );
180			else {
181			jsize l = (*env)->GetArrayLength( env, txt );
182			char *search = malloc( l+1 );
183			(env)->GetByteArrayRegion( env, txt, 0, l, (jbyte)search );
184			search[l] = 0;
185			r = openIsisScan( db, rowid, tag, search );
186			free( search );
187			}
188			jarr = rec2bytes( env, r );
189			if ( r ) free( r );
190			#ifndef NDEBUG
191			fflush( stderr );
192			#endif
193			return jarr;
194			} /* Java_org_openisis_Db_readRow */
195
196			/*
197			* please leave me in for debugging ;)
198			* static int print ( OpenIsisRec *r )
199			{
200			int i;
201			if ( r ) {
202			for ( i=0; i<r->len; i++ ) {
203			if ( ! r->field[i].val ) {
204			openIsisSMsg( 1, "%d.?=%d\n", r->rowid, r->field[i].len );
205			continue;
206			}
207			openIsisSMsg( 1, "%d.%d=%.*s\n", r->rowid, r->field[i].tag,
208			(int)r->field[i].len, r->field[i].val );
209			if ( r->field[i].len && '^' == *r->field[i].val ) {
210			OpenIsisRec *rf = openIsisReadField( 0, r->field+i );
211			if ( rf ) {
212			int j;
213			for ( j=0; j<rf->len; j++ )
214			openIsisSMsg( 1, "%d.%d.%c=%.*s\n",
215			r->rowid, r->field[i].tag,
216			(0x60 & (int)rf->field[j].tag ) ?
217			(int)rf->field[j].tag : ' ',
218			(int)rf->field[j].len, rf->field[j].val );
219			free( rf );
220			}
221			}
222			}
223			}
224			return ! r ? -1 : r->rowid;
225			} */
226
227			JNIEXPORT jshort JNICALL Java_org_openisis_NativeDb_nwriteRow
228			(JNIEnv* env, jclass cls, jshort db, jobjectArray arr )
229			{
230			OpenIsisRec *r;
231			jint result;
232			/* no warning */
233			(void) cls;
234			if ( ! arr )
235			return -1;
236			r = bytes2rec( env, arr );
237			if ( ! r )
238			return -1;
239			result = openIsisWrite( db, r );
240			if ( r )
241			free( r );
242			return result;
243			}
244
245			JNIEXPORT jshort JNICALL Java_org_openisis_NativeDb_nwriteXRow
246			(JNIEnv* env, jclass cls, jshort db, jobjectArray arr, jobjectArray idx )
247			{
248			OpenIsisRec *r;
249			OpenIsisRec *i;
250			jint result;
251			/* no warning */
252			(void) cls;
253			if ( ! arr \|\| ! idx )
254			return -1;
255			r = bytes2rec( env, arr );
256			i = bytes2rec( env, idx );
257			if ( ! r \|\| ! i )
258			return -1;
259			result = openIsisWritex( db, r, i );
260			if ( r )
261			free( r );
262			if ( i )
263			free( i );
264			return result;
265			}
266
267			JNIEXPORT jobjectArray JNICALL Java_org_openisis_NativeDb_nTerms
268			(JNIEnv* env, jclass cls, jshort db, jbyteArray term, jbyteArray start )
269			{
270			OpenIsisRec *r;
271			jobjectArray jarr = 0;
272			jsize lterm = (*env)->GetArrayLength( env, term );
273			char *cterm = malloc( lterm+1 );
274			union { OpenIsisRec r; char buf[4096]; } x;
275			x.r.len = 0;
276			x.r.bytes = sizeof(x);
277			(void)cls;
278			(env)->GetByteArrayRegion( env, term, 0, lterm, (jbyte)cterm );
279			cterm[lterm] = 0;
280			if ( start ) {
281			char *cstart;
282			jsize lstart = (*env)->GetArrayLength( env, start );
283			if ( 128 < lstart )
284			lstart = 128;
285			cstart = x.buf + sizeof(x.r);
286			(env)->GetByteArrayRegion( env, start, 0, lstart, (jbyte)cstart );
287			x.r.field[0].val = cstart;
288			x.r.field[0].len = lstart;
289			x.r.len = 1;
290			}
291			r = openIsisTerm( &x.r, db, cterm );
292			free( cterm );
293			jarr = rec2bytes( env, r );
294			#ifndef NDEBUG
295			fflush( stderr );
296			#endif
297			return jarr;
298			} /* Java_org_openisis_Db_Terms */
299
300
301
302			JNIEXPORT jintArray JNICALL Java_org_openisis_NativeDb_nsearch
303			(JNIEnv * env, jclass cls, jshort db, jbyteArray key, jint mode)
304			{
305			jsize l;
306			char *search;
307			OpenIsisSet set;
308			jintArray ia;
309			(void)cls;
310			if ( ! key )
311			return 0;
312			l = (*env)->GetArrayLength( env, key );
313			search = malloc( l+1 );
314			(env)->GetByteArrayRegion( env, key, 0, l, (jbyte)search );
315			search[l] = 0;
316			set.len = 0;
317			openIsisQuery( &set, db, search, mode, 0 );
318			free( search );
319			if ( 0 >= set.len )
320			return 0;
321			ia = (*env)->NewIntArray( env, set.len );
322			(env)->SetIntArrayRegion( env, ia, 0, set.len, (jint)set.id );
323			return ia;
324			} /* Java_org_openisis_Db_search */