[libimdb-commit] CVS: libimdb/java JLog.swig,NONE,1.1 JLog_jni.c,NONE,1.1 JLog_jni.h,NONE,1.1 Makefile,NONE,1.1 Parser.swig,NONE,1.1 Parser_jni.c,NONE,1.1 Parser_jni.h,NONE,1.1 bytetypemaps.i,NONE,1.1 inttypemaps.i,NONE,1.1 javahead.c,NONE,1.1 longtypemaps.i,NONE,1.1 mytypemaps.i,NONE,1.1

[Jerry V. <jve...@us...>]

Update of /cvsroot/libimdb/libimdb/java
In directory sc8-pr-cvs1:/tmp/cvs-serv11812/java

Added Files:
	JLog.swig JLog_jni.c JLog_jni.h Makefile Parser.swig 
	Parser_jni.c Parser_jni.h bytetypemaps.i inttypemaps.i 
	javahead.c longtypemaps.i mytypemaps.i 
Log Message:
initial checkin

--- NEW FILE: JLog.swig ---
%{
#define _USE_STDIO
#define _USE_STDLIB
#define _USE_STDARG
#define _USE_TYPES
#define _USE_STRINGS
#define _USE_ASSERT

#include "sysincludes.h"
#include "jlog/jlog.h"
#include "JLog_jni.h"
%}

%include "typemaps.i"

%include "mytypemaps.i"

#ifdef SWIGJAVA
%typemap(in, numinputs=0) (JNIEnv *env)  %{ $1=jenv; %}
%typemap(in, numinputs=0) (jclass clazz) %{ $1=jcls; %}
#endif

%typemap(jni)    JLog_t * "jlong"
%typemap(jtype)  JLog_t * "long"
%typemap(jstype) JLog_t * "org.libimdb.swig.JLog"

%typemap(javain) JLog_t * "org.libimdb.swig.JLog.getCPtr($javainput)"
%typemap(javaout) JLog_t * {return new org.libimdb.swig.JLog($jnicall);}

%include "JLog_jni.h"

--- NEW FILE: JLog_jni.c ---
/**
 * @file
 *
 * The functions here are provide a wrapper for jlogHandle functions.
 *
 * @verbatim $Id: JLog_jni.c,v 1.1 2003/06/16 04:18:38 jveldhuis Exp $ @endverbatim 
 */

static char rcs_id[] = "$Id: JLog_jni.c,v 1.1 2003/06/16 04:18:38 jveldhuis Exp $";

#define _USE_STDIO
#define _USE_STDLIB
#define _USE_ASSERT
#define _USE_MALLOC

#include "sysincludes.h"
#include "jlog/jlog.h"
#include <jni.h>
#include "JLog_jni.h"

struct JLog_s {
    JNIEnv *env;
    jmethodID jmethod_jcb;

    jobject jobj;
    jlogHandle_t *logh;
    jlogCallbackHandle_t *jlog_cb;
};

static void
jlog_eventCallback(jlogHandle_t *logh, const char *srcfile, const char *srcfunc,
		   int srcline, jlogModule_e module, jlogReportLevel_e jlogReportLevel,
		   int messageNumber, const char *messageText, void *cb_userdata)
{
    JLog_t *jl=cb_userdata;

    (*(jl->env))->CallIntMethod(jl->env, jl->jobj, jl->jmethod_jcb,
				(*(jl->env))->NewStringUTF(jl->env, srcfile),
				(*(jl->env))->NewStringUTF(jl->env, srcfunc),
				srcline, (int)module,(int)jlogReportLevel,
				messageNumber,
				(*(jl->env))->NewStringUTF(jl->env, messageText));
}

JLog_t *
JLog_create(void)
{
    JLog_t *jl;

    jl=malloc(sizeof(struct JLog_s));
    if ( jl == NULL ) {
	return(NULL);
    }
    jl->env=NULL;
    jl->jmethod_jcb=0;
    jl->jobj=NULL;

    jl->logh=jlog_openNew();

    jl->jlog_cb=jlogCallback_create(jlog_eventCallback, jl);
    if ( jl->jlog_cb == NULL ) {
	jlog_close(jl->logh);
	free(jl);
	return(NULL);
    }

    return(jl);
}

static int
JLog_init(JNIEnv *env,
	  JLog_t *jl,
	  jobject jobj)
{
    jclass class;

    /* may fail in malloc call */
    if ( jlog_registerEventCallback(jl->logh, jl->jlog_cb) == -1 ) {
	return(-1);
    }

    class=(*env)->GetObjectClass(env, jobj);
 
    jl->env=env;
    jl->jobj=jobj;

    jl->jmethod_jcb=(*env)->GetMethodID(env, class,
					"JLogMessage_cb",
					"(Ljava/lang/String;Ljava/lang/String;IIIILjava/lang/String;)I");

    if ( jl->jmethod_jcb == 0 ) {
	return(-1);
    }

    /* testing
       jlog_eventCallback(jl->logh, __FILE__, __FUNC__,
		       __LINE__, MOD_ALL, JLOGT_CRITICAL,
		       1, "This is the test", jl);*/
    return(0);
}

int
JLog_uninitialize(JLog_t *jl)
{
    if ( jl->jmethod_jcb != 0 ) {
	if ( jlog_unregisterEventCallback(jl->logh, jl->jlog_cb) != 0 ) {
	    abort();
	}
	jl->env=NULL;
	jl->jobj=NULL;
	jl->jmethod_jcb=0;
    }
    return(0);
}

jlogHandle_t *
JLog_jlog(JLog_t *j)
{
    assert(j!=NULL);
    return(j->logh);
}

JLog_t *
JLog_initialize(JNIEnv *env,
		jobject jobj)
{
    jmethodID jcb;
    jclass class;
    jlong r;
    JLog_t *jl;

    class=(*env)->GetObjectClass(env, jobj);

    jcb=(*env)->GetStaticMethodID(env, class,
				  "getCPtr",
				  "(Lorg/libimdb/swig/JLog;)J");
    if ( jcb == 0 ) {
	/*PAR_FAILURE(NULL, jlogHandle_t *, NULL); */
	return(NULL);
    }
    
    r=(*env)->CallStaticLongMethod(env, class, jcb, jobj, 0);
    if ( r == 0 ) {
	/*PAR_FAILURE(NULL, jlogHandle_t *, NULL); */
	return(NULL);
    }
    jl=*(JLog_t **)&r;

    if ( JLog_init(env, jl, jobj) != 0 ) {
	return(NULL);
    }

    return(jl);
}

int
JLog_destroy(JLog_t *jl)
{
    if ( jl == NULL ) {
	return(-1);
    }
    if ( jl->jmethod_jcb != 0 ) {
	JLog_uninitialize(jl);
    }
    jlogCallback_destroy(jl->jlog_cb);

    if ( jlog_close(jl->logh) != 0 ) {
	abort();
    }
    free(jl);
    return(0);
}

int
JLog_setNotificationLevel(JLog_t *jl,
			  JLogReportLevel_e level)
{
    jlogReportLevel_e jlogRL=-1;

    switch(level) {
    case JLOG_DEBUG:
	jlogRL=JLOGT_DEBUG;
	break;
    case JLOG_ERROR:
	jlogRL=JLOGT_ERROR;
	break;
    case JLOG_CRITICAL:
	jlogRL=JLOGT_CRITICAL;
	break;
    }

    if ( jlogRL == -1 ) {
	abort();
    }
    return(jlogCallback_setNotificationLevel(jl->jlog_cb, MOD_ALL, jlogRL));
}

--- NEW FILE: JLog_jni.h ---
/**
   @file
   
   Shared include with both JLog.swig and JLog_jni.c
   (ensures consistancy)

   @verbatim $Id: JLog_jni.h,v 1.1 2003/06/16 04:18:38 jveldhuis Exp $ @endverbatim 
*/

#ifdef SWIGJAVA

%typemap(jni)     (jobject jobj) "/*jni*/jobject"
%typemap(jtype)   (jobject jobj) "/*jtype*/Object"
%typemap(jstype)  (jobject jobj) "/*jstype*/Object"
%typemap(javain)  (jobject jobj) %{/*javain*/$javainput%}
%typemap(in)      (jobject jobj) %{ $1=jarg2; %}

%typemap(freearg) (jobject jobj) %{%}

%apply (jobject jobj) {(jobject jobj)};

#endif /* SWIGJAVA */


#ifndef SWIG
typedef struct JLog_s JLog_t;
#endif

JLog_t *
JLog_create(void);

#ifndef SWIG
JLog_t *
JLog_initialize(JNIEnv *env,
		jobject jobj);

jlogHandle_t *
JLog_jlog(JLog_t *j);

int
JLog_uninitialize(JLog_t *jl);
#endif

int
JLog_destroy(JLog_t *jl);

#ifndef SWIG
/* look out of date
jlogHandle_t *
JLog_jlogHandle(JLog_t *jl);
*/
#endif

typedef enum  {
    JLOG_DEBUG=2,		/**< debug message */
    JLOG_ERROR=1,		/**< error message */
    JLOG_CRITICAL=0,		/**< critical error message */
} JLogReportLevel_e;

int
JLog_setNotificationLevel(JLog_t *jl,
			  JLogReportLevel_e level);

--- NEW FILE: Makefile ---
#
# $Id: Makefile,v 1.1 2003/06/16 04:18:38 jveldhuis Exp $
#
include ../config.mk
include ../constants.mk

LIB_BASE := imdbParser_java
LIB_VERSION :=1.0

LDFLAGS +=-L../libjlog/$(BUILD_CFG) -L../parser/$(BUILD_CFG) 
LIBS     =-limdbParser -ljlog

CFLAGS_DROP =-Wmissing-prototypes
CCFLAGS_DROP=-Wmissing-prototypes

CPPFLAGS += -DSWIG_NOINCLUDE -I. -I../include 

GENERATED_FILES=gen_$(BUILD_OS)/JLog_swig.c gen_$(BUILD_OS)/Parser_swig.c

build: $(GENERATED_FILES)
	$(MAKE) $(MYDYNAMIC) DYNAMIC=$(MYDYNAMIC) SRCS="$(SRCS) $(GENERATED_FILES)"
	mkdir -p $(BUILD_CFG)
	$(JAVAC) -d $(BUILD_CFG) $(JAVAC_FLAGS) -sourcepath org -classpath org `find org -name \*.java`

gen_$(BUILD_OS)/JLog_swig.c:
	mkdir -p org/libimdb/swig/gen
	swig -java -module JLog -Wall -I. -I../include \
		-package org.libimdb.swig.gen \
		-o org/libimdb/swig/gen/JLog_swig.c JLog.swig
	mkdir -p gen_$(BUILD_OS)
	mv org/libimdb/swig/gen/JLog_swig.c gen_$(BUILD_OS)/JLog_swig.c

gen_$(BUILD_OS)/Parser_swig.c:
	mkdir -p org/libimdb/swig/gen
	swig -java -module Parser -Wall -I. -I../include \
		-package org.libimdb.swig.gen \
		-o org/libimdb/swig/gen/Parser_swig.c Parser.swig
	mkdir -p gen_$(BUILD_OS)
	mv org/libimdb/swig/gen/Parser_swig.c gen_$(BUILD_OS)/Parser_swig.c

clobber::
	$(RM) -rf $(BUILD_CFG) gen_$(OS)
	$(RM) -rf org/libimdb/swig/gen

run:
	LD_LIBRARY_PATH=$(BUILD_CFG):../parser/$(BUILD_CFG):../libjlog/$(BUILD_CFG):/usr/local/lib \
	       $(JAVA) -classpath $(BUILD_CFG) org.libimdb.swig.Parser

include ../rules.mk

--- NEW FILE: Parser.swig ---
%{
#define _USE_STDIO
#define _USE_STDLIB
#define _USE_TYPES
#define _USE_STRINGS
#define _USE_ASSERT

#include "sysincludes.h"
#include "jlog/parerr.h"
#include "libimdb/parser.h"
#include "JLog_jni.h"
#include "Parser_jni.h"
%}

%pragma(java) jniclassclassmodifiers="public"

%include "typemaps.i"

%include "mytypemaps.i"
%include "inttypemaps.i"
%include "longtypemaps.i"
%include "bytetypemaps.i"

#ifdef SWIGJAVA
%typemap(in, numinputs=0) (JNIEnv *env) %{ $1=jenv; %}
%typemap(in, numinputs=0) (jclass clazz) %{ $1=jcls; %}
#endif

%typemap(jni)    JLog_t * "jlong"
%typemap(jtype)  JLog_t * "long"
%typemap(jstype) JLog_t * "org.libimdb.swig.JLog"

%typemap(javain) JLog_t * "org.libimdb.swig.JLog.getCPtr($javainput)"
%typemap(javaout) JLog_t * {return new org.libimdb.swig.JLog($jnicall);}

%typemap(jni)    imdbParser_t * "jlong"
%typemap(jtype)  imdbParser_t * "long"
%typemap(jstype) imdbParser_t * "org.libimdb.swig.Parser"

%typemap(javain) imdbParser_t * "org.libimdb.swig.Parser.getCPtr($javainput)"
%typemap(javaout) imdbParser_t * {return new org.libimdb.swig.Parser($jnicall);}


%include "Parser_jni.h"

--- NEW FILE: Parser_jni.c ---
/**
 * @file
 * The functions here are provide a wrapper for libimdb functions.
 * They try and simplify the swig interface, provide jni callbacks
 * into java for libimdb callbacks.
 *
 * @verbatim $Id: Parser_jni.c,v 1.1 2003/06/16 04:18:38 jveldhuis Exp $ @endverbatim 
 */

static char rcs_id[] = "$Id: Parser_jni.c,v 1.1 2003/06/16 04:18:38 jveldhuis Exp $";

#define _USE_STDIO
#define _USE_STDLIB
#define _USE_ERRNO
#define _USE_IO
#define _USE_ASSERT
#define _USE_STDARG
#define _USE_STRINGS
#define _USE_TYPES
#define _USE_CTYPE
#define _USE_MALLOC
#define _USE_LIMITS
#define _USE_TIME

#include "sysincludes.h"
#include "jlog/parerr.h"
#include "libimdb/parser.h"
#include <jni.h>
#include "JLog_jni.h"
#include "Parser_jni.h"

struct jniData_s {
    JNIEnv *env;
    jobject jparserobject;
    jmethodID movieListEntry_jcb;
    jmethodID directorListEntry_jcb;
    jmethodID actorListEntry_jcb;
    jmethodID actressListEntry_jcb;
    jobject jprogressobject;
    jmethodID progressStarting_jcb;
    jmethodID progressUpdate_jcb;
    jmethodID progressFinished_jcb;
};

static int
listentry_cb(jlogHandle_t *logh,
	     imdbParser_t *imdbh,
	     const ListFile_e lf,
	     const void *entry)
{
    int r=-1;
    struct jniData_s *jniData=imdbParser_getUserHandle(logh, imdbh);

    switch(lf) {
    case LIST_MOVIES:
	{
	    const struct MovieInList_s *data=entry;
	    r=(*(jniData->env))->CallIntMethod(jniData->env, 
						 jniData->jparserobject,
						 jniData->movieListEntry_jcb,
						 data->lineNumber,
						 data->number,
						 data->type,
						 (*(jniData->env))->NewStringUTF(jniData->env, data->title),
						 data->year);
	}
	break;
    case LIST_DIRECTORS:
	{
	    const struct DirectorInList_s *data=entry;
	    
	    r=(*(jniData->env))->CallIntMethod(jniData->env, 
						 jniData->jparserobject,
						 jniData->directorListEntry_jcb,
						 data->lineNumber,
						 data->number,
						 (*(jniData->env))->NewStringUTF(jniData->env, data->name),
						 (*(jniData->env))->NewStringUTF(jniData->env, data->movieLabel));
	}
	break;
    case LIST_ACTORS:
	{
	    const struct ActorInList_s *data=entry;

	    r=(*(jniData->env))->CallIntMethod(jniData->env, 
						 jniData->jparserobject,
						 jniData->actorListEntry_jcb,
						 data->lineNumber,
						 data->number,
						 (*(jniData->env))->NewStringUTF(jniData->env, data->name),
						 data->billing,
						 data->isNarrator,
						 (*(jniData->env))->NewStringUTF(jniData->env, data->characterName),
						 (*(jniData->env))->NewStringUTF(jniData->env, data->characterNameAka),
						 (*(jniData->env))->NewStringUTF(jniData->env, data->movieLabel));
	}
	break;
    case LIST_ACTRESSES:
	{
	    const struct ActorInList_s *data=entry;

	    r=(*(jniData->env))->CallIntMethod(jniData->env, 
						 jniData->jparserobject,
						 jniData->actressListEntry_jcb,
						 data->lineNumber,
						 data->number,
						 (*(jniData->env))->NewStringUTF(jniData->env, data->name),
						 data->billing,
						 data->isNarrator,
						 (*(jniData->env))->NewStringUTF(jniData->env, data->characterName),
						 (*(jniData->env))->NewStringUTF(jniData->env, data->characterNameAka),
						 (*(jniData->env))->NewStringUTF(jniData->env, data->movieLabel));
	}
	break;
    }
    return(r);
}

imdbParser_t *
imdbParser_create(JNIEnv *env,
		  jobject jlogobject,
		  char *dbsDir)
{
    imdbParser_t *parser;
    JLog_t *jl;
    struct jniData_s *jniData;
    
    jniData=malloc(sizeof(struct jniData_s));
    if ( jniData == NULL ) {
	return(NULL);
    }

    jl=JLog_initialize(env, jlogobject);
    if ( jl == NULL ) {
	free(jniData);
	return(NULL);
    }
    
    parser=imdbParser_open(JLog_jlog(jl), dbsDir, listentry_cb);
    imdbParser_setUserHandle(JLog_jlog(jl), parser, jniData);

    JLog_uninitialize(jl);

    return(parser);
}

static imdbParser_t *
getParserFromObject(JLog_t *jl,
		    JNIEnv *env,
		    jobject jparserobject)
{
    jmethodID jcb;
    jlong r;

    jclass class=(*env)->GetObjectClass(env, jparserobject);

    if ( (jcb=(*env)->GetStaticMethodID(env, class,
					"getCPtr",
					"(Lorg/libimdb/swig/Parser;)J"))==0 ) {
	PARE_JNI_INVALID_OBJECT_FAILURE(JLog_jlog(jl), "org/libimdb/swig/Parser",
					"static method \"getCPtr\" missing",
					imdbParser_t *, NULL);
    }

    if ( (r=(*env)->CallStaticLongMethod(env, class, jcb, jparserobject, 0)) == 0 ) {
	PARE_JNI_INVALID_OBJECT_FAILURE(JLog_jlog(jl), "org/libimdb/swig/Parser",
					"static method call to \"getCPtr\" returned NULL(0)",
					imdbParser_t *, NULL);
    }

    if ( r == 0 ) {
	PAR_FAILURE(JLog_jlog(jl), imdbParser_t *, NULL);
    }
    else {
	PAR_SUCCESS(JLog_jlog(jl), imdbParser_t *, *(imdbParser_t **)&r);
    }
}

static void
progressStarting_cb(jlogHandle_t *logh,
		    imdbParser_t *parser,
		    const char *shortDescription,
		    int itemEstimate)
{
    struct jniData_s *jniData=imdbParser_getUserHandle(logh, parser);

    (*(jniData->env))->CallVoidMethod(jniData->env,
			     jniData->jprogressobject,
			     jniData->progressStarting_jcb, 
			     (*(jniData->env))->NewStringUTF(jniData->env, shortDescription),
			     itemEstimate);
}

/* returns number of next item progrssUpdate
   needs to be called for */
static int 
progressUpdate_cb(jlogHandle_t *logh,
		  imdbParser_t *parser,
		  int itemCount,
		  int itemEstimate)
{
    struct jniData_s *jniData=imdbParser_getUserHandle(logh, parser);

    return((*(jniData->env))->CallIntMethod(jniData->env,
					      jniData->jprogressobject,
					      jniData->progressUpdate_jcb, 
					      itemCount, itemEstimate));
}

static void
progressFinished_cb(jlogHandle_t *logh,
		    imdbParser_t *parser,
		    int itemCount,
		    int abortCode)
{
    struct jniData_s *jniData=imdbParser_getUserHandle(logh, parser);

    (*(jniData->env))->CallVoidMethod(jniData->env,
					jniData->jprogressobject,
					jniData->progressFinished_jcb, 
					itemCount, abortCode);
}

static int
setupProgressListener(JNIEnv *env,
		      JLog_t *jl,
		      imdbParser_t *parser,
		      jobject jprogressobject)
{
    jclass class;
    struct jniData_s *jniData=imdbParser_getUserHandle(JLog_jlog(jl), parser);

    if ( jprogressobject == NULL ) {
	return(imdbParser_disableProgressCallbacks(JLog_jlog(jl), parser));
    }

    class=(*env)->GetObjectClass(env, jprogressobject);

    if ( (jniData->progressStarting_jcb=(*env)->GetMethodID(env, class,
						   "progressStarting_cb",
						   "(Ljava/lang/String;I)V"))==0 ) {
	PARE_JNI_INVALID_OBJECT_FAILURE(JLog_jlog(jl), "org/libimdb/swig/ProgressListener",
					"static method \"progressStarting_cb\" missing",
					int, -1);
    }
    if ( (jniData->progressUpdate_jcb=(*env)->GetMethodID(env, class,
						 "progressUpdate_cb",
						 "(II)I"))==0 ) {
	PARE_JNI_INVALID_OBJECT_FAILURE(JLog_jlog(jl), "org/libimdb/swig/ProgressListener",
					"static method \"progressUpdate_cb\" missing",
					int, -1);
    }
    if ( (jniData->progressFinished_jcb=(*env)->GetMethodID(env, class,
						   "progressFinished_cb",
						   "(II)V"))==0 ) {
	PARE_JNI_INVALID_OBJECT_FAILURE(JLog_jlog(jl), "org/libimdb/swig/ProgressListener",
					"static method \"progressFinished_cb\" missing",
					int, -1);
    }
    jniData->jprogressobject=jprogressobject;
    
    return(imdbParser_setProgressCallbacks(JLog_jlog(jl), parser,
					   progressStarting_cb,
					   progressUpdate_cb,
					   progressFinished_cb));
}

int
imdbParser_destroy(JNIEnv *env,
		   jobject jlogobject,
		   jobject jparserobject)
{
    int ret;
    JLog_t *jl;
    imdbParser_t *parser;
    struct jniData_s *jniData;

    jl=JLog_initialize(env, jlogobject);
    if ( jl == NULL ) {
	return(-1);
    }
    parser=getParserFromObject(jl, env, jparserobject);
    if ( parser == NULL ) {
	JLog_uninitialize(jl);
	return(-2);
    }

    jniData=imdbParser_setUserHandle(JLog_jlog(jl), parser, NULL);
    free(jniData);

    ret=imdbParser_close(JLog_jlog(jl), parser);
    JLog_uninitialize(jl);
    return(ret);
}

int
imdbParser_dumpMovies(JNIEnv *env,
		      jobject jlogobject,
		      jobject jparserobject,
		      jobject jprogressobject)
{
    jclass class;
    int ret;
    JLog_t *jl;
    imdbParser_t *parser;
    struct jniData_s *jniData;

    jl=JLog_initialize(env, jlogobject);
    if ( jl == NULL ) {
	return(-1);
    }

    parser=getParserFromObject(jl, env, jparserobject);
    if ( parser == NULL ) {
	JLog_uninitialize(jl); 
	return(-2);
    }
    jniData=imdbParser_getUserHandle(JLog_jlog(jl), parser);

    jniData->env=env;
    jniData->jparserobject=jparserobject;

    if ( setupProgressListener(env, jl, parser, jprogressobject) != 0 ) {
	JLog_uninitialize(jl); 
	return(-3);
    }

    class=(*env)->GetObjectClass(env, jparserobject);

    /* javap -s -classpath bdir-LINUX org.libimdb.swig.Parser */
    jniData->movieListEntry_jcb=(*env)->GetMethodID(env, class,
						    "movieListEntry_cb",
						    "(IIILjava/lang/String;I)I");
    if ( jniData->movieListEntry_jcb == 0 ) {
	JLog_uninitialize(jl); 
	return(-4);
    }
    ret=imdbParser_moviesParse(JLog_jlog(jl), parser);
    JLog_uninitialize(jl);
    return(ret);
}


int
imdbParser_dumpDirectors(JNIEnv *env,
			 jobject jlogobject,
			 jobject jparserobject,
			 jobject jprogressobject)
{
    jclass class;
    int ret;
    JLog_t *jl;
    imdbParser_t *parser;
    struct jniData_s *jniData;

    jl=JLog_initialize(env, jlogobject);
    if ( jl == NULL ) {
	return(-1);
    }

    parser=getParserFromObject(jl, env, jparserobject);
    if ( parser == NULL ) {
	JLog_uninitialize(jl); 
	return(-2);
    }
    jniData=imdbParser_getUserHandle(JLog_jlog(jl), parser);

    if ( setupProgressListener(env, jl, parser, jprogressobject) != 0 ) {
	JLog_uninitialize(jl); 
	return(-3);
    }
    jniData->env=env;
    jniData->jparserobject=jparserobject;

    class=(*env)->GetObjectClass(env, jparserobject);

    /* javap -s -classpath bdir-LINUX org.libimdb.swig.Parser */
    jniData->directorListEntry_jcb=(*env)->GetMethodID(env, class,
						    "directorListEntry_cb",
						    "(IILjava/lang/String;Ljava/lang/String;)I");
    if ( jniData->directorListEntry_jcb == 0 ) {
	JLog_uninitialize(jl); 
	return(-4);
    }

    ret=imdbParser_directorsParse(JLog_jlog(jl), parser);
    JLog_uninitialize(jl);
    return(ret);
}

int
imdbParser_dumpActors(JNIEnv *env,
		      jobject jlogobject,
		      jobject jparserobject,
		      jobject jprogressobject)
{
    jclass class;
    int ret;
    JLog_t *jl;
    imdbParser_t *parser;
    struct jniData_s *jniData;

    jl=JLog_initialize(env, jlogobject);
    if ( jl == NULL ) {
	return(-1);
    }

    parser=getParserFromObject(jl, env, jparserobject);
    if ( parser == NULL ) {
	JLog_uninitialize(jl); 
	return(-2);
    }
    jniData=imdbParser_getUserHandle(JLog_jlog(jl), parser);

    if ( setupProgressListener(env, jl, parser, jprogressobject) != 0 ) {
	JLog_uninitialize(jl); 
	return(-3);
    }
    jniData->env=env;
    jniData->jparserobject=jparserobject;

    class=(*env)->GetObjectClass(env, jparserobject);

    /* javap -s -classpath bdir-LINUX org.libimdb.swig.Parser */
    jniData->actorListEntry_jcb=(*env)->GetMethodID(env, class,
						    "actorListEntry_cb",
						    "(IILjava/lang/String;IILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)I");
    if ( jniData->actorListEntry_jcb == 0 ) {
	JLog_uninitialize(jl); 
	return(-4);
    }

    ret=imdbParser_actorsParse(JLog_jlog(jl), parser);
    JLog_uninitialize(jl);
    return(ret);
}

int
imdbParser_dumpActresses(JNIEnv *env,
			 jobject jlogobject,
			 jobject jparserobject,
			 jobject jprogressobject)
{
    jclass class;
    int ret;
    JLog_t *jl;
    imdbParser_t *parser;
    struct jniData_s *jniData;

    jl=JLog_initialize(env, jlogobject);
    if ( jl == NULL ) {
	return(-1);
    }

    parser=getParserFromObject(jl, env, jparserobject);
    if ( parser == NULL ) {
	JLog_uninitialize(jl); 
	return(-2);
    }
    jniData=imdbParser_getUserHandle(JLog_jlog(jl), parser);

    if ( setupProgressListener(env, jl, parser, jprogressobject) != 0 ) {
	JLog_uninitialize(jl); 
	return(-3);
    }
    jniData->env=env;
    jniData->jparserobject=jparserobject;

    class=(*env)->GetObjectClass(env, jparserobject);

    /* javap -s -classpath bdir-LINUX org.libimdb.swig.Parser */
    jniData->actressListEntry_jcb=(*env)->GetMethodID(env, class,
						      "actressListEntry_cb",
						      "(IILjava/lang/String;IILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)I");
    if ( jniData->actressListEntry_jcb == 0 ) {
	JLog_uninitialize(jl); 
	return(-4);
    }

    ret=imdbParser_actressesParse(JLog_jlog(jl), parser);
    JLog_uninitialize(jl);
    return(ret);
}



--- NEW FILE: Parser_jni.h ---
/**
   @file
   
   Shared include with both Parser.swig and Parser_jni.c
   (ensures consistancy)

   @verbatim $Id: Parser_jni.h,v 1.1 2003/06/16 04:18:38 jveldhuis Exp $ @endverbatim 
*/

#ifdef SWIGJAVA

%typemap(jni)     (jobject jlog) "/*jni*/jobject"
%typemap(jtype)   (jobject jlog) "/*jtype*/org.libimdb.swig.JLog"
%typemap(jstype)  (jobject jlog) "/*jstype*/org.libimdb.swig.JLog"
%typemap(javain)  (jobject jlog) %{/*javain*/$javainput%}
%typemap(in)      (jobject jlog) %{ $1=jarg$argnum;%}
%typemap(freearg) (jobject jlog) %{%}

%apply (jobject jlog) {(jobject jlogobject)};

#endif /* SWIGJAVA */

imdbParser_t *
imdbParser_create(JNIEnv *env,
		  jobject jlogobject,
		  char *dbsDir);

int
imdbParser_destroy(JNIEnv *env,
		   jobject jlogobject,
		   jobject jparserobject);

#ifdef SWIGJAVA

%typemap(jni)     (jobject jprog) "/*jni*/jobject"
%typemap(jtype)   (jobject jprog) "/*jtype*/org.libimdb.swig.ProgressListener"
%typemap(jstype)  (jobject jprog) "/*jstype*/org.libimdb.swig.ProgressListener"
%typemap(javain)  (jobject jprog) %{/*javain*/$javainput%}
%typemap(in)      (jobject jprog) %{ $1=jarg$argnum;%}
%typemap(freearg) (jobject jprog) %{%}

%apply (jobject jprog) {(jobject jprogressobject)};

#endif

#ifdef SWIGJAVA

%typemap(jni)     (jobject jparser) "/*jni*/jobject"
%typemap(jtype)   (jobject jparser) "/*jtype*/org.libimdb.swig.Parser"
%typemap(jstype)  (jobject jparser) "/*jstype*/org.libimdb.swig.Parser"
%typemap(javain)  (jobject jparser) %{/*javain*/$javainput%}
%typemap(in)      (jobject jparser) %{ $1=jarg$argnum;%}
%typemap(freearg) (jobject jparser) %{%}

%apply (jobject jparser) {(jobject jparserobject)};

#endif

int
imdbParser_dumpMovies(JNIEnv *env,
		      jobject jlogobject,
		      jobject jparserobject,
		      jobject jprogressobject);

int
imdbParser_dumpDirectors(JNIEnv *env,
			 jobject jlogobject,
			 jobject jparserobject,
			 jobject jprogressobject);

int
imdbParser_dumpActors(JNIEnv *env,
		      jobject jlogobject,
		      jobject jparserobject,
		      jobject jprogressobject);

int
imdbParser_dumpActresses(JNIEnv *env,
			 jobject jlogobject,
			 jobject jparserobject,
			 jobject jprogressobject);

--- NEW FILE: bytetypemaps.i ---

#ifdef SWIG
%typemap(jni) (int LIST_SIZE, uint8_t *BYTE_ARRAY_IN) "/*jni*/jbyteArray"
%typemap(jtype) (int LIST_SIZE, uint8_t *BYTE_ARRAY_IN) "/*jtype*/byte[]"
%typemap(jstype) (int LIST_SIZE, uint8_t *BYTE_ARRAY_IN) "/*jstype*/byte[]"
%typemap(javain) (int LIST_SIZE, uint8_t *BYTE_ARRAY_IN) %{/*javain*/$javainput%}
#if IF_JAVAOUT_DID_SOMETHING
%typemap(javaout) (int LIST_SIZE, uint8_t *BYTE_ARRAY_IN) %{/*javaout*/&$jnicall%}
#endif
%typemap(in) (int LIST_SIZE, uint8_t *BYTE_ARRAY_IN)(jboolean isCopy) {
    $1=JCALL1(GetArrayLength, jenv, $input);
    $2=JCALL2(GetByteArrayElements, jenv, $input, &isCopy); 
}
%typemap(argout) (int LIST_SIZE, uint8_t *BYTE_ARRAY_IN) {
    /*argout*/
    JCALL3(ReleaseByteArrayElements, jenv, $input, $2, JNI_ABORT); 
}    
%typemap(freearg) (int LIST_SIZE, uint8_t *BYTE_ARRAY_IN) {/* freearg */}
#endif


--- NEW FILE: inttypemaps.i ---
/* int32_t *INTEGER_ARRAY_IN
   - to use:
   %apply (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_IN) {(int size, int32_t *list)};
   extern int printInts(int size, int32_t *list);
   %clear (int size, int32_t *list);
*/
%typemap(jni) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_IN) "/*jni*/jintArray"
%typemap(jtype) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_IN) "/*jtype*/int[]"
%typemap(jstype) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_IN) "/*jstype*/int[]"
%typemap(javain) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_IN) %{/*javain*/$javainput%}
#if IF_JAVAOUT_DID_SOMETHING
%typemap(javaout) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_IN) %{/*javaout*/&$jnicall%}
#endif
%typemap(in) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_IN)(jboolean isCopy) {
    $1=JCALL1(GetArrayLength, jenv, $input);
    $2=JCALL2(GetIntArrayElements, jenv, $input, &isCopy); 
}
%typemap(argout) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_IN) {
    /*argout*/
    JCALL3(ReleaseIntArrayElements, jenv, $input, $2, JNI_ABORT); 
}    
%typemap(freearg) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_IN) {/* freearg */}

/* int32_t *INTEGER_ARRAY_INOUT
  - array must stay the same size :)
  - to use:
  %apply (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_INOUT) {(int size, int32_t *list)};
  extern int reverseInts(int size, int32_t *list);
  %clear (int size, int32_t *list);
*/
%typemap(jni) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_INOUT) "/*jni*/jintArray"
%typemap(jtype) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_INOUT) "/*jtype*/int[]"
%typemap(jstype) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_INOUT) "/*jstype*/int[]"
%typemap(javain) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_INOUT) %{/*javain*/$javainput%}
#if IF_JAVAOUT_DID_SOMETHING
%typemap(javaout) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_INOUT) %{/*javaout*/&$jnicall%}
#endif
%typemap(in) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_INOUT)(jboolean isCopy) {
    $1=JCALL1(GetArrayLength, jenv, $input);
    $2=JCALL2(GetIntArrayElements, jenv, $input, &isCopy); 
}
%typemap(argout) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_INOUT) {
    JCALL3(ReleaseIntArrayElements, jenv, $input, $2, 0/*copy back and free prev arg*/); 
    $2=NULL;
}
%typemap(freearg) (int32_t LIST_SIZE, int32_t *INTEGER_ARRAY_INOUT) {/* freearg */}


--- NEW FILE: javahead.c ---
/* my copy of javahead.swg - jwv
 */

#if defined(__GNUC__)
    typedef long long __int64; /*For gcc on Windows */
#endif
#include <jni.h>
#include <stdlib.h>
#include <string.h>


/* Support for throwing Java exceptions */
typedef enum {
  SWIG_JavaOutOfMemoryError = 1, 
  SWIG_JavaIOException, 
  SWIG_JavaRuntimeException, 
  SWIG_JavaIndexOutOfBoundsException,
  SWIG_JavaArithmeticException,
  SWIG_JavaIllegalArgumentException,
  SWIG_JavaNullPointerException,
  SWIG_JavaUnknownError
} SWIG_JavaExceptionCodes;

typedef struct {
  SWIG_JavaExceptionCodes code;
  const char *java_exception;
} SWIG_JavaExceptions_t;

void SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
  jclass excep;
  static const SWIG_JavaExceptions_t java_exceptions[] = {
    { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
    { SWIG_JavaIOException, "java/io/IOException" },
    { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
    { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
    { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
    { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
    { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
    { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
    { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" } };
  const SWIG_JavaExceptions_t *except_ptr = java_exceptions;

  while (except_ptr->code != code && except_ptr->code)
    except_ptr++;

  (*jenv)->ExceptionClear(jenv);
  excep = (*jenv)->FindClass(jenv, except_ptr->java_exception);
  if (excep)
    (*jenv)->ThrowNew(jenv, excep, msg);
}

--- NEW FILE: longtypemaps.i ---

/* int64_t *LONG_ARRAY_IN 
   - to use:
   %apply (int32_t LIST_SIZE, int64_t *LONG_ARRAY_IN) {(int size, int64_t *list)};
   extern int printLongs(int size, int64_t *list);
   %clear (int size, int64_t *list);
 */
%typemap(jni) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_IN) "/*jni*/jlongArray"
%typemap(jtype) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_IN) "/*jtype*/long[]"
%typemap(jstype) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_IN) "/*jstype*/long[]"
%typemap(javain) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_IN) %{/*javain*/$javainput%}
#if IF_JAVAOUT_DID_SOMETHING
%typemap(javaout) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_IN) %{/*javaout*/&$jnicall%}
#endif
%typemap(in) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_IN)(jboolean isCopy) {
    $1=JCALL1(GetArrayLength, jenv, $input);
    $2=JCALL2(GetLongArrayElements, jenv, $input, &isCopy); 
}
%typemap(argout) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_IN) {
    /*argout*/
    JCALL3(ReleaseLongArrayElements, jenv, $input, $2, JNI_ABORT); 
}
%typemap(freearg) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_IN)  { /* freearg */ }

/* int64_t *LONG_ARRAY_INOUT 
  - array must stay the same size :)
   - to use:
   %apply (int32_t LIST_SIZE, int64_t *LONG_ARRAY_INOUT) {(int size, int64_t *list)};
   extern int reverseLongs(int size, int64_t *list);
   %clear (int size, int64_t *list);
*/
%typemap(jni) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_INOUT) "/*jni*/jlongArray"
%typemap(jtype) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_INOUT) "/*jtype*/long[]"
%typemap(jstype) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_INOUT) "/*jstype*/long[]"
%typemap(javain) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_INOUT) %{/*javain*/$javainput%}
#if IF_JAVAOUT_DID_SOMETHING
%typemap(javaout) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_INOUT) %{/*javaout*/&$jnicall%}
#endif
%typemap(in) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_INOUT)(jboolean isCopy) {
    $1=JCALL1(GetArrayLength, jenv, $input);
    $2=JCALL2(GetLongArrayElements, jenv, $input, &isCopy); 
}
%typemap(argout) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_INOUT) {
    JCALL3(ReleaseLongArrayElements, jenv, $input, $2, 0/*copy back and free prev arg*/); 
    $2=NULL;
}
%typemap(freearg) (int32_t LIST_SIZE, int64_t *LONG_ARRAY_INOUT)  { /* freearg */ }


--- NEW FILE: mytypemaps.i ---

/* char **MYSTATIC_STRING_OUT_ARG - result must be a null terminated string */
%typemap(jni) char **MYSTATIC_STRING_OUT_ARG "jobjectArray"
%typemap(jtype) char **MYSTATIC_STRING_OUT_ARG "String[]"
%typemap(jstype) char **MYSTATIC_STRING_OUT_ARG "String[]"
%typemap(in) char **MYSTATIC_STRING_OUT_ARG (char *s) %{ $1 = &s; %}
%typemap(argout) char **MYSTATIC_STRING_OUT_ARG {
  if($1) {
     JCALL3(SetObjectArrayElement, jenv, $input, 0, JCALL1(NewStringUTF, jenv, *$1)); 
  }
}

%typemap(javain) char **MYSTATIC_STRING_OUT_ARG "$javainput"
%typemap(javaout) char **MYSTATIC_STRING_OUT_ARG "&$jnicall"

/* char **MYALLOCTED_STRING_OUT
 */
%typemap(jni) char **MYALLOCTED_STRING_OUT_ARG "jobjectArray"
%typemap(jtype) char **MYALLOCTED_STRING_OUT_ARG "String[]"
%typemap(jstype) char **MYALLOCTED_STRING_OUT_ARG "String[]"
%typemap(in) char **MYALLOCTED_STRING_OUT_ARG (char *s) %{ $1 = &s; %}
%typemap(argout) char **MYALLOCTED_STRING_OUT_ARG {
  if($1) {
     JCALL3(SetObjectArrayElement, jenv, $input, 0, JCALL1(NewStringUTF, jenv, *$1)); 
     free($1); $1=NULL;
  }
}

%typemap(javain) char **MYALLOCTED_STRING_OUT_ARG "$javainput"
%typemap(javaout) char **MYALLOCTED_STRING_OUT_ARG "&$jnicall"

/* char **MYSTATIC_STRING_ARRAY_RETURN
  for use for functions that return a NULL terminated array
 of strings (that the function does the memory management on) */
%typemap(jni) char **MYSTATIC_STRING_ARRAY_RET "jarray"
%typemap(jtype) char **MYSTATIC_STRING_ARRAY_RET "String[]"
%typemap(jstype) char **MYSTATIC_STRING_ARRAY_RET "String[]"
%typemap(out) char **MYSTATIC_STRING_ARRAY_RET {
  if($1 != NULL) {
    char **p = $1;
    jsize size = 0;
    int i = 0;
    jclass strClass;
    
    while (*p++) size++; /* determine size */
    strClass = JCALL1(FindClass, jenv, "java/lang/String");
    $result = JCALL3(NewObjectArray, jenv, size, strClass, NULL);
    p = $1;
    while (*p) {
      jstring js = JCALL1(NewStringUTF, jenv, *p);
      JCALL3(SetObjectArrayElement, jenv, $result, i++, js);
      p++;
    }
  } 
}

%typemap(javain) char **MYSTATIC_STRING_ARRAY_RET "$javainput"
%typemap(javaout) char **MYSTATIC_STRING_ARRAY_RET "{return($jnicall);}"

/* char **MYALLOCTED_STRING_ARRAY_RET
   same as MYSTATIC_STRING_ARRAY_RET except returned array
   is freed after its been returned (each element, then the
   array itself */
%typemap(jni) char **MYALLOCTED_STRING_ARRAY_RET "jarray"
%typemap(jtype) char **MYALLOCTED_STRING_ARRAY_RET "String[]"
%typemap(jstype) char **MYALLOCTED_STRING_ARRAY_RET "String[]"
%typemap(out) char **MYALLOCTED_STRING_ARRAY_RET {
  if($1 != NULL) {
    char **p = $1;
    jsize size = 0;
    int i = 0;
    jclass strClass;
    
    while (*p++) size++; /* determine size */
    strClass = JCALL1(FindClass, jenv, "java/lang/String");
    $result = JCALL3(NewObjectArray, jenv, size, strClass, NULL);
    p = $1;
    while (*p) {
      jstring js = JCALL1(NewStringUTF, jenv, *p);
      JCALL3(SetObjectArrayElement, jenv, $result, i++, js);
      free(*p);
      *p=NULL;
      p++;
    }
    free($1);
    $1=NULL;
  } 
}

%typemap(javain) char **MYALLOCTED_STRING_ARRAY_RET "$javainput"
%typemap(javaout) char **MYALLOCTED_STRING_ARRAY_RET "{return($jnicall);}"