From b65898e0dd73615af12027ee41a8795c77659720 Mon Sep 17 00:00:00 2001
From: str4d <str4d@mail.i2p>
Date: Wed, 3 Apr 2013 01:39:33 +0000
Subject: [PATCH] Ticket #741 - Added limewireExe source
---
installer/c/limewireExe/LimeWire3.sln | 22 +
installer/c/limewireExe/LimeWire3.suo | Bin 0 -> 27648 bytes
installer/c/limewireExe/LimeWire3.vcproj | 331 ++++
installer/c/limewireExe/LimeWire31.rc | 113 ++
installer/c/limewireExe/errors.h | 11 +
installer/c/limewireExe/java.c | 1042 ++++++++++++
installer/c/limewireExe/java.h | 76 +
installer/c/limewireExe/java_md.c | 388 +++++
installer/c/limewireExe/java_md.h | 28 +
installer/c/limewireExe/jni.h | 1944 ++++++++++++++++++++++
installer/c/limewireExe/jni_md.h | 19 +
installer/c/limewireExe/limewire.c | 234 +++
installer/c/limewireExe/merged icon.ico | Bin 0 -> 97294 bytes
installer/c/limewireExe/resource1.h | 17 +
installer/c/limewireExe/torrent.ico | Bin 0 -> 25214 bytes
15 files changed, 4225 insertions(+)
create mode 100644 installer/c/limewireExe/LimeWire3.sln
create mode 100644 installer/c/limewireExe/LimeWire3.suo
create mode 100644 installer/c/limewireExe/LimeWire3.vcproj
create mode 100644 installer/c/limewireExe/LimeWire31.rc
create mode 100644 installer/c/limewireExe/errors.h
create mode 100644 installer/c/limewireExe/java.c
create mode 100644 installer/c/limewireExe/java.h
create mode 100644 installer/c/limewireExe/java_md.c
create mode 100644 installer/c/limewireExe/java_md.h
create mode 100644 installer/c/limewireExe/jni.h
create mode 100644 installer/c/limewireExe/jni_md.h
create mode 100644 installer/c/limewireExe/limewire.c
create mode 100644 installer/c/limewireExe/merged icon.ico
create mode 100644 installer/c/limewireExe/resource1.h
create mode 100644 installer/c/limewireExe/torrent.ico
diff --git a/installer/c/limewireExe/LimeWire3.sln b/installer/c/limewireExe/LimeWire3.sln
new file mode 100644
index 0000000000..789dc66e4f
--- /dev/null
+++ b/installer/c/limewireExe/LimeWire3.sln
@@ -0,0 +1,22 @@
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual Studio 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LimeWire3", "LimeWire3.vcproj", "{0A74F3D1-C70A-4CF0-9390-C676025ED12F}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ Release|Win32 = Release|Win32
+ Release-alpha|Win32 = Release-alpha|Win32
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {0A74F3D1-C70A-4CF0-9390-C676025ED12F}.Debug|Win32.ActiveCfg = Debug|Win32
+ {0A74F3D1-C70A-4CF0-9390-C676025ED12F}.Debug|Win32.Build.0 = Debug|Win32
+ {0A74F3D1-C70A-4CF0-9390-C676025ED12F}.Release|Win32.ActiveCfg = Release|Win32
+ {0A74F3D1-C70A-4CF0-9390-C676025ED12F}.Release|Win32.Build.0 = Release|Win32
+ {0A74F3D1-C70A-4CF0-9390-C676025ED12F}.Release-alpha|Win32.ActiveCfg = Release-alpha|Win32
+ {0A74F3D1-C70A-4CF0-9390-C676025ED12F}.Release-alpha|Win32.Build.0 = Release-alpha|Win32
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
diff --git a/installer/c/limewireExe/LimeWire3.suo b/installer/c/limewireExe/LimeWire3.suo
new file mode 100644
index 0000000000000000000000000000000000000000..0cdc68d24bac7fb30382adb642e7b21b926ab5c3
GIT binary patch
literal 27648
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
literal 0
HcmV?d00001
diff --git a/installer/c/limewireExe/LimeWire3.vcproj b/installer/c/limewireExe/LimeWire3.vcproj
new file mode 100644
index 0000000000..e66c9e10ce
--- /dev/null
+++ b/installer/c/limewireExe/LimeWire3.vcproj
@@ -0,0 +1,331 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="9.00"
+ Name="LimeWire3"
+ ProjectGUID="{0A74F3D1-C70A-4CF0-9390-C676025ED12F}"
+ RootNamespace="LimeWire3"
+ Keyword="Win32Proj"
+ TargetFrameworkVersion="131072"
+ >
+ <Platforms>
+ <Platform
+ Name="Win32"
+ />
+ </Platforms>
+ <ToolFiles>
+ </ToolFiles>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="Debug"
+ IntermediateDirectory="Debug"
+ ConfigurationType="1"
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
+ CharacterSet="2"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories=""C:\Program Files\Java\jdk1.6.0\include\win32";"C:\Program Files\Java\jdk1.6.0\include""
+ PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS"
+ MinimalRebuild="true"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="1"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="true"
+ DebugInformationFormat="4"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="Shlwapi.lib"
+ OutputFile="$(OutDir)/LimeWire.exe"
+ LinkIncremental="2"
+ GenerateDebugInformation="true"
+ ProgramDatabaseFile="$(OutDir)/LimeWire3.pdb"
+ SubSystem="2"
+ RandomizedBaseAddress="1"
+ DataExecutionPrevention="0"
+ TargetMachine="1"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCManifestTool"
+ AdditionalManifestFiles="LimeWire.exe.manifest"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCAppVerifierTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="Release"
+ IntermediateDirectory="Release"
+ ConfigurationType="1"
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
+ CharacterSet="2"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="2"
+ InlineFunctionExpansion="0"
+ AdditionalIncludeDirectories=""C:\Program Files\Java\jdk1.6.0_13\include";"C:\Program Files\Java\jdk1.6.0_13\include\win32""
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS"
+ RuntimeLibrary="0"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="true"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="shlwapi.lib"
+ OutputFile="$(OutDir)/MuWire.exe"
+ LinkIncremental="1"
+ GenerateDebugInformation="true"
+ SubSystem="2"
+ OptimizeReferences="2"
+ EnableCOMDATFolding="2"
+ RandomizedBaseAddress="1"
+ DataExecutionPrevention="0"
+ TargetMachine="1"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCManifestTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCAppVerifierTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ <Configuration
+ Name="Release-alpha|Win32"
+ OutputDirectory="$(ConfigurationName)"
+ IntermediateDirectory="$(ConfigurationName)"
+ ConfigurationType="1"
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
+ CharacterSet="2"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ AdditionalOptions="/D"ALPHA""
+ Optimization="2"
+ InlineFunctionExpansion="0"
+ AdditionalIncludeDirectories=""C:\Program Files\Java\jdk1.6.0\include";"C:\Program Files\Java\jdk1.6.0\include\win32""
+ PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS"
+ RuntimeLibrary="0"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="true"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="shlwapi.lib"
+ OutputFile="$(OutDir)/LimeWire.exe"
+ LinkIncremental="1"
+ GenerateDebugInformation="true"
+ SubSystem="2"
+ OptimizeReferences="2"
+ EnableCOMDATFolding="2"
+ RandomizedBaseAddress="1"
+ DataExecutionPrevention="0"
+ TargetMachine="1"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCManifestTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCAppVerifierTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="Source Files"
+ Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+ >
+ <File
+ RelativePath=".\java.c"
+ >
+ </File>
+ <File
+ RelativePath=".\java_md.c"
+ >
+ </File>
+ <File
+ RelativePath=".\limewire.c"
+ >
+ </File>
+ </Filter>
+ <Filter
+ Name="Header Files"
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+ >
+ <File
+ RelativePath=".\errors.h"
+ >
+ </File>
+ <File
+ RelativePath=".\java.h"
+ >
+ </File>
+ <File
+ RelativePath=".\java_md.h"
+ >
+ </File>
+ <File
+ RelativePath=".\jni.h"
+ >
+ </File>
+ <File
+ RelativePath=".\jni_md.h"
+ >
+ </File>
+ <File
+ RelativePath=".\resource1.h"
+ >
+ </File>
+ </Filter>
+ <Filter
+ Name="Resource Files"
+ Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
+ UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+ >
+ <File
+ RelativePath=".\LimeWire31.rc"
+ >
+ </File>
+ <File
+ RelativePath=".\merged icon.ico"
+ >
+ </File>
+ <File
+ RelativePath=".\torrent.ico"
+ >
+ </File>
+ </Filter>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>
diff --git a/installer/c/limewireExe/LimeWire31.rc b/installer/c/limewireExe/LimeWire31.rc
new file mode 100644
index 0000000000..386d2003b1
--- /dev/null
+++ b/installer/c/limewireExe/LimeWire31.rc
@@ -0,0 +1,113 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource1.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE
+BEGIN
+ "resource1.h\0"
+END
+
+2 TEXTINCLUDE
+BEGIN
+ "#include ""afxres.h""\r\n"
+ "\0"
+END
+
+3 TEXTINCLUDE
+BEGIN
+ "\r\n"
+ "\0"
+END
+
+#endif // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 1,0,0,2
+ PRODUCTVERSION 1,0,0,2
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x1L
+ FILESUBTYPE 0x0L
+BEGIN
+ BLOCK "StringFileInfo"
+ BEGIN
+ BLOCK "040904b0"
+ BEGIN
+ VALUE "Comments", "The easiest and safest way to get music"
+ VALUE "CompanyName", "The MuWire Project"
+ VALUE "FileDescription", "MuWire"
+ VALUE "FileVersion", "1, 0, 0, 2"
+ VALUE "InternalName", "MuWire"
+ VALUE "LegalCopyright", "GPL"
+ VALUE "OriginalFilename", "MuWire.exe"
+ VALUE "ProductName", " MuWire"
+ VALUE "ProductVersion", "1, 0, 0, 2"
+ END
+ END
+ BLOCK "VarFileInfo"
+ BEGIN
+ VALUE "Translation", 0x409, 1200
+ END
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+IDI_ICON1 ICON "merged icon.ico"
+IDI_ICON2 ICON "torrent.ico"
+#endif // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif // not APSTUDIO_INVOKED
+
diff --git a/installer/c/limewireExe/errors.h b/installer/c/limewireExe/errors.h
new file mode 100644
index 0000000000..6802181d2a
--- /dev/null
+++ b/installer/c/limewireExe/errors.h
@@ -0,0 +1,11 @@
+#ifndef _LIME_ERRORS_H
+#define _LIME_ERRORS_h
+
+
+#define ERROR_COULDNT_LOAD_JVM 6
+#define ERROR_COULDNT_PARSE_ARGUMENTS 7
+#define ERROR_COULDNT_INITIALIZE_JVM 8
+#define ERROR_STARTING_PROGRAM 9
+#define ERROR_COULDNT_FIND_JVM 10
+
+#endif /* _LIME_ERRORS_H */
\ No newline at end of file
diff --git a/installer/c/limewireExe/java.c b/installer/c/limewireExe/java.c
new file mode 100644
index 0000000000..ddc9ffb794
--- /dev/null
+++ b/installer/c/limewireExe/java.c
@@ -0,0 +1,1042 @@
+/*
+ * Derived from the shared source for the 'java' command line tool.
+ *
+ * Original comments as follows:
+ * Shared source for 'java' command line tool.
+ *
+ * If JAVA_ARGS is defined, then acts as a launcher for applications. For
+ * instance, the JDK command line tools such as javac and javadoc (see
+ * makefiles for more details) are built with this program. Any arguments
+ * prefixed with '-J' will be passed directly to the 'java' command.
+ */
+
+/*
+ * One job of the launcher is to remove command line options which the
+ * vm does not understand and will not process. These options include
+ * options which select which style of vm is run (e.g. -client and
+ * -server) as well as options which select the data model to use.
+ * Additionally, for tools which invoke an underlying vm "-J-foo"
+ * options are turned into "-foo" options to the vm. This option
+ * filtering is handled in a number of places in the launcher, some of
+ * it in machine-dependent code. In this file, the function
+ * CheckJVMType removes vm style options and TranslateDashJArgs
+ * removes "-J" prefixes. On unix platforms, the
+ * CreateExecutionEnvironment function from the unix java_md.c file
+ * processes and removes -d<n> options. However, in case
+ * CreateExecutionEnvironment does not need to exec because
+ * LD_LIBRARY_PATH is set acceptably and the data model does not need
+ * to be changed, ParseArguments will screen out the redundant -d<n>
+ * options and prevent them from being passed to the vm; this is done
+ * by using the machine-dependent call
+ * RemovableMachineDependentOption.
+ */
+
+#include "errors.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#include "jni.h"
+#include "java.h"
+
+#ifndef FULL_VERSION
+#define FULL_VERSION JDK_MAJOR_VERSION "." JDK_MINOR_VERSION
+#endif
+
+
+static jboolean printVersion = JNI_FALSE; /* print and exit */
+static jboolean showVersion = JNI_FALSE; /* print but continue */
+
+/*
+ * List of VM options to be specified when the VM is created.
+ */
+static JavaVMOption *options;
+static int numOptions, maxOptions;
+
+/*
+ * Prototypes for functions internal to launcher.
+ */
+static void AddOption(char *str, void *info);
+static void SetClassPath(char *s);
+static jboolean ParseArguments(int *pargc, char ***pargv, char **pjarfile,
+ char **pclassname, int *pret);
+static jboolean InitializeJVM(JavaVM **pvm, JNIEnv **penv,
+ InvocationFunctions *ifn);
+static jstring NewPlatformString(JNIEnv *env, char *s);
+static jobjectArray NewPlatformStringArray(JNIEnv *env, char **strv, int strc);
+static jclass LoadClass(JNIEnv *env, char *name);
+static jstring GetMainClassName(JNIEnv *env, char *jarname);
+static void SetJavaCommandLineProp(char* classname, char* jarfile, int argc, char** argv);
+
+
+static void PrintJavaVersion(JNIEnv *env);
+
+
+/* Support for options such as -hotspot, -classic etc. */
+#define INIT_MAX_KNOWN_VMS 10
+#define VM_UNKNOWN -1
+#define VM_KNOWN 0
+#define VM_ALIASED_TO 1
+#define VM_WARN 2
+#define VM_ERROR 3
+struct vmdesc {
+ char *name;
+ int flag;
+ char *alias;
+};
+static struct vmdesc *knownVMs = NULL;
+static int knownVMsCount = 0;
+static int knownVMsLimit = 0;
+
+static void GrowKnownVMs();
+static int KnownVMIndex(const char* name);
+static void FreeKnownVMs();
+
+/* flag which if set suppresses error messages from the launcher */
+static int noExitErrorMessage = 0;
+
+jboolean ServerClassMachine();
+
+/*
+ * Entry point.
+ */
+int
+launchJVM(int argc, char ** argv)
+{
+ JavaVM *vm = 0;
+ JNIEnv *env = 0;
+ char *jarfile = 0;
+ char *classname = 0;
+ char *s = 0;
+ char *main_class = NULL;
+ jstring mainClassName;
+ jclass mainClass;
+ jmethodID mainID;
+ jobjectArray mainArgs;
+ int ret;
+ InvocationFunctions ifn;
+ char jrepath[MAXPATHLEN], jvmpath[MAXPATHLEN];
+ char ** original_argv = argv;
+ int create_ret;
+
+ /*
+ * Error message to print or display; by default the message will
+ * only be displayed in a window.
+ */
+ char * message = "Fatal exception occurred. Program will exit.";
+ jboolean messageDest = JNI_FALSE;
+
+ /* copy original argv */
+ {
+ int i;
+ original_argv = (char**)MemAlloc(sizeof(char*)*(argc+1));
+ for(i = 0; i < argc+1; i++)
+ original_argv[i] = argv[i];
+ }
+
+ create_ret = CreateExecutionEnvironment(&argc, &argv,
+ jrepath, sizeof(jrepath),
+ jvmpath, sizeof(jvmpath),
+ original_argv);
+ if(create_ret != 0)
+ return ERROR_COULDNT_FIND_JVM;
+
+ ifn.CreateJavaVM = 0;
+ ifn.GetDefaultJavaVMInitArgs = 0;
+
+ if (!LoadJavaVM(jvmpath, &ifn)) {
+ return ERROR_COULDNT_LOAD_JVM;
+ }
+
+ // ignore the program name when processing arguments.
+ ++argv;
+ --argc;
+
+ /*
+ * Parse command line options; if the return value of
+ * ParseArguments is false, the program should exit.
+ */
+ if (!ParseArguments(&argc, &argv, &jarfile, &classname, &ret)) {
+ return ERROR_COULDNT_PARSE_ARGUMENTS;
+ }
+
+ /* Override class path if -jar flag was specified */
+ if (jarfile != 0) {
+ SetClassPath(jarfile);
+ }
+
+ /* set the -Dsun.java.command pseudo property */
+ SetJavaCommandLineProp(classname, jarfile, argc, argv);
+
+ /* Initialize the virtual machine */
+
+ if (!InitializeJVM(&vm, &env, &ifn)) {
+ ReportErrorMessage("Could not create the Java virtual machine.", JNI_TRUE);
+ return ERROR_COULDNT_INITIALIZE_JVM;
+ }
+
+ if (printVersion || showVersion) {
+ PrintJavaVersion(env);
+ if ((*env)->ExceptionOccurred(env)) {
+ ReportExceptionDescription(env);
+ goto leave;
+ }
+ if (printVersion) {
+ ret = 0;
+ message = NULL;
+ goto leave;
+ }
+ if (showVersion) {
+ fprintf(stderr, "\n");
+ }
+ }
+
+ /* If the user specified neither a class name nor a JAR file */
+ if (jarfile == 0 && classname == 0) {
+ message = NULL;
+ goto leave;
+ }
+
+ FreeKnownVMs(); /* after last possible PrintUsage() */
+
+
+ /* At this stage, argc/argv have the applications' arguments */
+
+ ret = 1;
+
+ /* Get the application's main class */
+ if (jarfile != 0) {
+ mainClassName = GetMainClassName(env, jarfile);
+ if ((*env)->ExceptionOccurred(env)) {
+ ReportExceptionDescription(env);
+ goto leave;
+ }
+ if (mainClassName == NULL) {
+ const char * format = "Failed to load Main-Class manifest "
+ "attribute from\n%s";
+ message = (char*)MemAlloc((strlen(format) + strlen(jarfile)) *
+ sizeof(char));
+ sprintf(message, format, jarfile);
+ messageDest = JNI_TRUE;
+ goto leave;
+ }
+ classname = (char *)(*env)->GetStringUTFChars(env, mainClassName, 0);
+ if (classname == NULL) {
+ ReportExceptionDescription(env);
+ goto leave;
+ }
+ mainClass = LoadClass(env, classname);
+ if(mainClass == NULL) { /* exception occured */
+ ReportExceptionDescription(env);
+ message = "Could not find the main class. Program will exit.";
+ goto leave;
+ }
+ (*env)->ReleaseStringUTFChars(env, mainClassName, classname);
+ } else {
+ mainClassName = NewPlatformString(env, classname);
+ if (mainClassName == NULL) {
+ const char * format = "Failed to load Main Class: %s";
+ message = (char *)MemAlloc((strlen(format) + strlen(classname)) *
+ sizeof(char) );
+ sprintf(message, format, classname);
+ messageDest = JNI_TRUE;
+ goto leave;
+ }
+ classname = (char *)(*env)->GetStringUTFChars(env, mainClassName, 0);
+ if (classname == NULL) {
+ ReportExceptionDescription(env);
+ goto leave;
+ }
+ mainClass = LoadClass(env, classname);
+ if(mainClass == NULL) { /* exception occured */
+ ReportExceptionDescription(env);
+ message = "Could not find the main class. Program will exit.";
+ goto leave;
+ }
+ (*env)->ReleaseStringUTFChars(env, mainClassName, classname);
+ }
+
+ /* Get the application's main method */
+ mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
+ "([Ljava/lang/String;)V");
+ if (mainID == NULL) {
+ if ((*env)->ExceptionOccurred(env)) {
+ ReportExceptionDescription(env);
+ } else {
+ message = "No main method found in specified class.";
+ messageDest = JNI_TRUE;
+ }
+ goto leave;
+ }
+
+ { /* Make sure the main method is public */
+ jint mods;
+ jmethodID mid;
+ jobject obj = (*env)->ToReflectedMethod(env, mainClass,
+ mainID, JNI_TRUE);
+
+ if( obj == NULL) { /* exception occurred */
+ ReportExceptionDescription(env);
+ goto leave;
+ }
+
+ mid =
+ (*env)->GetMethodID(env,
+ (*env)->GetObjectClass(env, obj),
+ "getModifiers", "()I");
+ if ((*env)->ExceptionOccurred(env)) {
+ ReportExceptionDescription(env);
+ goto leave;
+ }
+
+ mods = (*env)->CallIntMethod(env, obj, mid);
+ if ((mods & 1) == 0) { /* if (!Modifier.isPublic(mods)) ... */
+ message = "Main method not public.";
+ messageDest = JNI_TRUE;
+ goto leave;
+ }
+ }
+
+ /* Build argument array */
+ mainArgs = NewPlatformStringArray(env, argv, argc);
+ if (mainArgs == NULL) {
+ ReportExceptionDescription(env);
+ goto leave;
+ }
+
+ /* Invoke main method. */
+ (*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);
+ if ((*env)->ExceptionOccurred(env)) {
+ /*
+ * Formerly, we used to call the "uncaughtException" method of
+ * the main thread group, but this was later shown to be
+ * unnecessary since the default definition merely printed out
+ * the same exception stack trace as ExceptionDescribe and
+ * could never actually be overridden by application programs.
+ */
+ ReportExceptionDescription(env);
+ goto leave;
+ }
+
+ /*
+ * Detach the current thread so that it appears to have exited when
+ * the application's main method exits.
+ */
+ if ((*vm)->DetachCurrentThread(vm) != 0) {
+ message = "Could not detach main thread.";
+ messageDest = JNI_TRUE;
+ goto leave;
+ }
+ ret = 0;
+ message = NULL;
+
+leave:
+ (*vm)->DestroyJavaVM(vm);
+ if(message != NULL && !noExitErrorMessage)
+ ReportErrorMessage(message, messageDest);
+
+ return ERROR_STARTING_PROGRAM;
+}
+
+
+/*
+ * Checks the command line options to find which JVM type was
+ * specified. If no command line option was given for the JVM type,
+ * the default type is used. The environment variable
+ * JDK_ALTERNATE_VM and the command line option -XXaltjvm= are also
+ * checked as ways of specifying which JVM type to invoke.
+ */
+char *
+CheckJvmType(int *pargc, char ***argv, jboolean speculative) {
+ int i, argi;
+ int argc;
+ char **newArgv;
+ int newArgvIdx = 0;
+ int isVMType;
+ int jvmidx = -1;
+ char *jvmtype = getenv("JDK_ALTERNATE_VM");
+
+ argc = *pargc;
+
+ /* To make things simpler we always copy the argv array */
+ newArgv = MemAlloc((argc + 1) * sizeof(char *));
+
+ /* The program name is always present */
+ newArgv[newArgvIdx++] = (*argv)[0];
+
+ for (argi = 1; argi < argc; argi++) {
+ char *arg = (*argv)[argi];
+ isVMType = 0;
+
+ if (strcmp(arg, "-classpath") == 0 ||
+ strcmp(arg, "-cp") == 0) {
+ newArgv[newArgvIdx++] = arg;
+ argi++;
+ if (argi < argc) {
+ newArgv[newArgvIdx++] = (*argv)[argi];
+ }
+ continue;
+ }
+ if (arg[0] != '-') break;
+
+ /* Did the user pass an explicit VM type? */
+ i = KnownVMIndex(arg);
+ if (i >= 0) {
+ jvmtype = knownVMs[jvmidx = i].name + 1; /* skip the - */
+ isVMType = 1;
+ *pargc = *pargc - 1;
+ }
+
+ /* Did the user specify an "alternate" VM? */
+ else if (strncmp(arg, "-XXaltjvm=", 10) == 0 || strncmp(arg, "-J-XXaltjvm=", 12) == 0) {
+ isVMType = 1;
+ jvmtype = arg+((arg[1]=='X')? 10 : 12);
+ jvmidx = -1;
+ }
+
+ if (!isVMType) {
+ newArgv[newArgvIdx++] = arg;
+ }
+ }
+
+ /*
+ * Finish copying the arguments if we aborted the above loop.
+ * NOTE that if we aborted via "break" then we did NOT copy the
+ * last argument above, and in addition argi will be less than
+ * argc.
+ */
+ while (argi < argc) {
+ newArgv[newArgvIdx++] = (*argv)[argi];
+ argi++;
+ }
+
+ /* argv is null-terminated */
+ newArgv[newArgvIdx] = 0;
+
+ /* Copy back argv */
+ *argv = newArgv;
+ *pargc = newArgvIdx;
+
+ /* use the default VM type if not specified (no alias processing) */
+ if (jvmtype == NULL)
+ return knownVMs[0].name+1;
+
+ /* if using an alternate VM, no alias processing */
+ if (jvmidx < 0)
+ return jvmtype;
+
+ /* Resolve aliases first */
+ {
+ int loopCount = 0;
+ while (knownVMs[jvmidx].flag == VM_ALIASED_TO) {
+ int nextIdx = KnownVMIndex(knownVMs[jvmidx].alias);
+
+ if (loopCount > knownVMsCount) {
+ if (!speculative) {
+ ReportErrorMessage("Error: Corrupt jvm.cfg file; cycle in alias list.",
+ JNI_TRUE);
+ return "ERROR";
+ } else {
+ return "ERROR";
+ /* break; */
+ }
+ }
+
+ if (nextIdx < 0) {
+ if (!speculative) {
+ ReportErrorMessage2("Error: Unable to resolve VM alias %s",
+ knownVMs[jvmidx].alias, JNI_TRUE);
+ return "ERROR";
+ } else {
+ return "ERROR";
+ }
+ }
+ jvmidx = nextIdx;
+ jvmtype = knownVMs[jvmidx].name+1;
+ loopCount++;
+ }
+ }
+
+ switch (knownVMs[jvmidx].flag) {
+ case VM_WARN:
+ if (!speculative) {
+ fprintf(stderr, "Warning: %s VM not supported; %s VM will be used\n",
+ jvmtype, knownVMs[0].name + 1);
+ }
+ jvmtype = knownVMs[jvmidx=0].name + 1;
+ /* fall through */
+ case VM_KNOWN:
+ break;
+ case VM_ERROR:
+ if (!speculative) {
+ ReportErrorMessage2("Error: %s VM not supported", jvmtype, JNI_TRUE);
+ return "ERROR";
+ } else {
+ return "ERROR";
+ }
+ }
+
+ return jvmtype;
+}
+
+
+/*
+ * Adds a new VM option with the given given name and value.
+ */
+static void
+AddOption(char *str, void *info)
+{
+ /*
+ * Expand options array if needed to accommodate at least one more
+ * VM option.
+ */
+ if (numOptions >= maxOptions) {
+ if (options == 0) {
+ maxOptions = 4;
+ options = MemAlloc(maxOptions * sizeof(JavaVMOption));
+ } else {
+ JavaVMOption *tmp;
+ maxOptions *= 2;
+ tmp = MemAlloc(maxOptions * sizeof(JavaVMOption));
+ memcpy(tmp, options, numOptions * sizeof(JavaVMOption));
+ free(options);
+ options = tmp;
+ }
+ }
+ options[numOptions].optionString = str;
+ options[numOptions++].extraInfo = info;
+}
+
+static void
+SetClassPath(char *s)
+{
+ char *def = MemAlloc(strlen(s) + 40);
+ sprintf(def, "-Djava.class.path=%s", s);
+ AddOption(def, NULL);
+}
+
+/*
+ * Parses command line arguments. Returns JNI_FALSE if launcher
+ * should exit without starting vm (e.g. certain version and usage
+ * options); returns JNI_TRUE if vm needs to be started to process
+ * given options. *pret (the launcher process return value) is set to
+ * 0 for a normal exit.
+ */
+static jboolean
+ParseArguments(int *pargc, char ***pargv, char **pjarfile,
+ char **pclassname, int *pret)
+{
+ int argc = *pargc;
+ char **argv = *pargv;
+ jboolean jarflag = JNI_FALSE;
+ char *arg;
+
+ *pret = 1;
+ while ((arg = *argv) != 0 && *arg == '-') {
+ argv++; --argc;
+ if (strcmp(arg, "-classpath") == 0 || strcmp(arg, "-cp") == 0) {
+ if (argc < 1) {
+ ReportErrorMessage2("%s requires class path specification",
+ arg, JNI_TRUE);
+ return JNI_FALSE;
+ }
+ SetClassPath(*argv);
+ argv++; --argc;
+ } else if (strcmp(arg, "-jar") == 0) {
+ jarflag = JNI_TRUE;
+ } else if (strcmp(arg, "-version") == 0) {
+ printVersion = JNI_TRUE;
+ return JNI_TRUE;
+ } else if (strcmp(arg, "-showversion") == 0) {
+ showVersion = JNI_TRUE;
+ } else if (strcmp(arg, "-X") == 0) {
+ *pret = 0;
+ return JNI_FALSE;
+ /*
+ * The following case provide backward compatibility with old-style
+ * command line options.
+ */
+ } else if (strcmp(arg, "-verbosegc") == 0) {
+ AddOption("-verbose:gc", NULL);
+ } else if (strcmp(arg, "-t") == 0) {
+ AddOption("-Xt", NULL);
+ } else if (strcmp(arg, "-tm") == 0) {
+ AddOption("-Xtm", NULL);
+ } else if (strcmp(arg, "-debug") == 0) {
+ AddOption("-Xdebug", NULL);
+ } else if (strcmp(arg, "-noclassgc") == 0) {
+ AddOption("-Xnoclassgc", NULL);
+ } else if (strcmp(arg, "-Xfuture") == 0) {
+ AddOption("-Xverify:all", NULL);
+ } else if (strcmp(arg, "-verify") == 0) {
+ AddOption("-Xverify:all", NULL);
+ } else if (strcmp(arg, "-verifyremote") == 0) {
+ AddOption("-Xverify:remote", NULL);
+ } else if (strcmp(arg, "-noverify") == 0) {
+ AddOption("-Xverify:none", NULL);
+ } else if (strcmp(arg, "-XXsuppressExitMessage") == 0) {
+ noExitErrorMessage = 1;
+ } else if (strncmp(arg, "-prof", 5) == 0) {
+ char *p = arg + 5;
+ char *tmp = MemAlloc(strlen(arg) + 50);
+ if (*p) {
+ sprintf(tmp, "-Xrunhprof:cpu=old,file=%s", p + 1);
+ } else {
+ sprintf(tmp, "-Xrunhprof:cpu=old,file=java.prof");
+ }
+ AddOption(tmp, NULL);
+ } else if (strncmp(arg, "-ss", 3) == 0 ||
+ strncmp(arg, "-oss", 4) == 0 ||
+ strncmp(arg, "-ms", 3) == 0 ||
+ strncmp(arg, "-mx", 3) == 0) {
+ char *tmp = MemAlloc(strlen(arg) + 6);
+ sprintf(tmp, "-X%s", arg + 1); /* skip '-' */
+ AddOption(tmp, NULL);
+ } else if (strcmp(arg, "-checksource") == 0 ||
+ strcmp(arg, "-cs") == 0 ||
+ strcmp(arg, "-noasyncgc") == 0) {
+ /* No longer supported */
+ fprintf(stderr,
+ "Warning: %s option is no longer supported.\n",
+ arg);
+ } else if (strncmp(arg, "-version:", 9) == 0 ||
+ strcmp(arg, "-no-jre-restrict-search") == 0 ||
+ strcmp(arg, "-jre-restrict-search") == 0) {
+ ; /* Ignore machine independent options already handled */
+ } else if (RemovableMachineDependentOption(arg) ) {
+ ; /* Do not pass option to vm. */
+ }
+ else {
+ AddOption(arg, NULL);
+ }
+ }
+
+ if (--argc >= 0) {
+ if (jarflag) {
+ *pjarfile = *argv++;
+ *pclassname = 0;
+ } else {
+ *pjarfile = 0;
+ *pclassname = *argv++;
+ }
+ *pargc = argc;
+ *pargv = argv;
+ }
+
+ return JNI_TRUE;
+}
+
+/*
+ * Initializes the Java Virtual Machine. Also frees options array when
+ * finished.
+ */
+static jboolean
+InitializeJVM(JavaVM **pvm, JNIEnv **penv, InvocationFunctions *ifn)
+{
+ JavaVMInitArgs args;
+ jint r;
+
+ memset(&args, 0, sizeof(args));
+ args.version = JNI_VERSION_1_2;
+ args.nOptions = numOptions;
+ args.options = options;
+ args.ignoreUnrecognized = JNI_FALSE;
+
+ r = ifn->CreateJavaVM(pvm, (void **)penv, &args);
+ free(options);
+ return r == JNI_OK;
+}
+
+
+#define NULL_CHECK0(e) if ((e) == 0) return 0
+#define NULL_CHECK(e) if ((e) == 0) return
+
+/*
+ * Returns a pointer to a block of at least 'size' bytes of memory.
+ * Prints error message and exits if the memory could not be allocated.
+ */
+void *
+MemAlloc(size_t size)
+{
+ void *p = malloc(size);
+ if (p == 0) {
+ perror("malloc");
+ exit(1);
+ }
+ return p;
+}
+
+/*
+ * Returns a new Java string object for the specified platform string.
+ */
+static jstring
+NewPlatformString(JNIEnv *env, char *s)
+{
+ int len = (int)strlen(s);
+ jclass cls;
+ jmethodID mid;
+ jbyteArray ary;
+
+ if (s == NULL)
+ return 0;
+ NULL_CHECK0(cls = (*env)->FindClass(env, "java/lang/String"));
+ NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "<init>", "([B)V"));
+ ary = (*env)->NewByteArray(env, len);
+ if (ary != 0) {
+ jstring str = 0;
+ (*env)->SetByteArrayRegion(env, ary, 0, len, (jbyte *)s);
+ if (!(*env)->ExceptionOccurred(env)) {
+ str = (*env)->NewObject(env, cls, mid, ary);
+ }
+ (*env)->DeleteLocalRef(env, ary);
+ return str;
+ }
+ return 0;
+}
+
+/*
+ * Returns a new array of Java string objects for the specified
+ * array of platform strings.
+ */
+static jobjectArray
+NewPlatformStringArray(JNIEnv *env, char **strv, int strc)
+{
+ jarray cls;
+ jarray ary;
+ int i;
+
+ NULL_CHECK0(cls = (*env)->FindClass(env, "java/lang/String"));
+ NULL_CHECK0(ary = (*env)->NewObjectArray(env, strc, cls, 0));
+ for (i = 0; i < strc; i++) {
+ jstring str = NewPlatformString(env, *strv++);
+ NULL_CHECK0(str);
+ (*env)->SetObjectArrayElement(env, ary, i, str);
+ (*env)->DeleteLocalRef(env, str);
+ }
+ return ary;
+}
+
+/*
+ * Loads a class, convert the '.' to '/'.
+ */
+static jclass
+LoadClass(JNIEnv *env, char *name)
+{
+ char *buf = MemAlloc(strlen(name) + 1);
+ char *s = buf, *t = name, c;
+ jclass cls;
+
+ do {
+ c = *t++;
+ *s++ = (c == '.') ? '/' : c;
+ } while (c != '\0');
+ cls = (*env)->FindClass(env, buf);
+ free(buf);
+
+ return cls;
+}
+
+/*
+ * Returns the main class name for the specified jar file.
+ */
+static jstring
+GetMainClassName(JNIEnv *env, char *jarname)
+{
+#define MAIN_CLASS "Main-Class"
+ jclass cls;
+ jmethodID mid;
+ jobject jar, man, attr;
+ jstring str, result = 0;
+
+ NULL_CHECK0(cls = (*env)->FindClass(env, "java/util/jar/JarFile"));
+ NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "<init>",
+ "(Ljava/lang/String;)V"));
+ NULL_CHECK0(str = NewPlatformString(env, jarname));
+ NULL_CHECK0(jar = (*env)->NewObject(env, cls, mid, str));
+ NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "getManifest",
+ "()Ljava/util/jar/Manifest;"));
+ man = (*env)->CallObjectMethod(env, jar, mid);
+ if (man != 0) {
+ NULL_CHECK0(mid = (*env)->GetMethodID(env,
+ (*env)->GetObjectClass(env, man),
+ "getMainAttributes",
+ "()Ljava/util/jar/Attributes;"));
+ attr = (*env)->CallObjectMethod(env, man, mid);
+ if (attr != 0) {
+ NULL_CHECK0(mid = (*env)->GetMethodID(env,
+ (*env)->GetObjectClass(env, attr),
+ "getValue",
+ "(Ljava/lang/String;)Ljava/lang/String;"));
+ NULL_CHECK0(str = NewPlatformString(env, MAIN_CLASS));
+ result = (*env)->CallObjectMethod(env, attr, mid, str);
+ }
+ }
+ return result;
+}
+
+/*
+ * inject the -Dsun.java.command pseudo property into the args structure
+ * this pseudo property is used in the HotSpot VM to expose the
+ * Java class name and arguments to the main method to the VM. The
+ * HotSpot VM uses this pseudo property to store the Java class name
+ * (or jar file name) and the arguments to the class's main method
+ * to the instrumentation memory region. The sun.java.command pseudo
+ * property is not exported by HotSpot to the Java layer.
+ */
+void
+SetJavaCommandLineProp(char *classname, char *jarfile,
+ int argc, char **argv)
+{
+
+ int i = 0;
+ size_t len = 0;
+ char* javaCommand = NULL;
+ char* dashDstr = "-Dsun.java.command=";
+
+ if (classname == NULL && jarfile == NULL) {
+ /* unexpected, one of these should be set. just return without
+ * setting the property
+ */
+ return;
+ }
+
+ /* if the class name is not set, then use the jarfile name */
+ if (classname == NULL) {
+ classname = jarfile;
+ }
+
+ /* determine the amount of memory to allocate assuming
+ * the individual components will be space separated
+ */
+ len = strlen(classname);
+ for (i = 0; i < argc; i++) {
+ len += strlen(argv[i]) + 1;
+ }
+
+ /* allocate the memory */
+ javaCommand = (char*) MemAlloc(len + strlen(dashDstr) + 1);
+
+ /* build the -D string */
+ *javaCommand = '\0';
+ strcat(javaCommand, dashDstr);
+ strcat(javaCommand, classname);
+
+ for (i = 0; i < argc; i++) {
+ /* the components of the string are space separated. In
+ * the case of embedded white space, the relationship of
+ * the white space separated components to their true
+ * positional arguments will be ambiguous. This issue may
+ * be addressed in a future release.
+ */
+ strcat(javaCommand, " ");
+ strcat(javaCommand, argv[i]);
+ }
+
+ AddOption(javaCommand, NULL);
+}
+
+/*
+ * Prints the version information from the java.version and other properties.
+ */
+static void
+PrintJavaVersion(JNIEnv *env)
+{
+ jclass ver;
+ jmethodID print;
+
+ NULL_CHECK(ver = (*env)->FindClass(env, "sun/misc/Version"));
+ NULL_CHECK(print = (*env)->GetStaticMethodID(env, ver, "print", "()V"));
+
+ (*env)->CallStaticVoidMethod(env, ver, print);
+}
+
+
+/*
+ * Read the jvm.cfg file and fill the knownJVMs[] array.
+ *
+ * The functionality of the jvm.cfg file is subject to change without
+ * notice and the mechanism will be removed in the future.
+ *
+ * The lexical structure of the jvm.cfg file is as follows:
+ *
+ * jvmcfg := { vmLine }
+ * vmLine := knownLine
+ * | aliasLine
+ * | warnLine
+ * | errorLine
+ * | commentLine
+ * knownLine := flag "KNOWN" EOL
+ * warnLine := flag "WARN" EOL
+ * errorLine := flag "ERROR" EOL
+ * aliasLine := flag "ALIASED_TO" flag EOL
+ * commentLine := "#" text EOL
+ * flag := "-" identifier
+ *
+ * The semantics are that when someone specifies a flag on the command line:
+ * - if the flag appears on a knownLine, then the identifier is used as
+ * the name of the directory holding the JVM library (the name of the JVM).
+ * - if the flag appears as the first flag on an aliasLine, the identifier
+ * of the second flag is used as the name of the JVM.
+ * - if the flag appears on a warnLine, the identifier is used as the
+ * name of the JVM, but a warning is generated.
+ * - if the flag appears on an errorLine, an error is generated.
+ * If no flag is given on the command line, the first vmLine of the jvm.cfg
+ * file determines the name of the JVM.
+ *
+ * The intent of the jvm.cfg file is to allow several JVM libraries to
+ * be installed in different subdirectories of a single JRE installation,
+ * for space-savings and convenience in testing.
+ * The intent is explicitly not to provide a full aliasing or predicate
+ * mechanism.
+ */
+jint
+ReadKnownVMs(const char *jrepath, char * arch, jboolean speculative)
+{
+ FILE *jvmCfg;
+ char jvmCfgName[MAXPATHLEN+20];
+ char line[MAXPATHLEN+20];
+ int cnt = 0;
+ int lineno = 0;
+ int vmType;
+ char *tmpPtr;
+ char *altVMName;
+ struct stat s;
+ static char *whiteSpace = " \t";
+
+ sprintf(jvmCfgName, "%s\\lib\\%s\\jvm.cfg\0", jrepath, arch);
+ if(stat(jvmCfgName, &s) != 0)
+ // try without arch -- for java 1.3 compatability
+ sprintf(jvmCfgName, "%s\\lib\\jvm.cfg\0", jrepath);
+
+ jvmCfg = fopen(jvmCfgName, "r");
+ if (jvmCfg == NULL) {
+ if (!speculative) {
+ ReportErrorMessage2("Error: could not open `%s'", jvmCfgName,
+ JNI_TRUE);
+ return -1;
+ } else {
+ return -1;
+ }
+ }
+ while (fgets(line, sizeof(line), jvmCfg) != NULL) {
+ vmType = VM_UNKNOWN;
+ lineno++;
+ if (line[0] == '#')
+ continue;
+ if (line[0] != '-') {
+ fprintf(stderr, "Warning: no leading - on line %d of `%s'\n",
+ lineno, jvmCfgName);
+ }
+ if (cnt >= knownVMsLimit) {
+ GrowKnownVMs(cnt);
+ }
+ line[strlen(line)-1] = '\0'; /* remove trailing newline */
+ tmpPtr = line + strcspn(line, whiteSpace);
+ if (*tmpPtr == 0) {
+ fprintf(stderr, "Warning: missing VM type on line %d of `%s'\n",
+ lineno, jvmCfgName);
+ vmType = VM_KNOWN; // assume known, for java 1.3 compatability
+ } else {
+ /* Null-terminate this string for strdup below */
+ *tmpPtr++ = 0;
+ tmpPtr += strspn(tmpPtr, whiteSpace);
+ if (*tmpPtr == 0) {
+ fprintf(stderr, "Warning: missing VM type on line %d of `%s'\n",
+ lineno, jvmCfgName);
+ } else {
+ if (!strncmp(tmpPtr, "KNOWN", strlen("KNOWN"))) {
+ vmType = VM_KNOWN;
+ } else if (!strncmp(tmpPtr, "ALIASED_TO", strlen("ALIASED_TO"))) {
+ tmpPtr += strcspn(tmpPtr, whiteSpace);
+ if (*tmpPtr != 0) {
+ tmpPtr += strspn(tmpPtr, whiteSpace);
+ }
+ if (*tmpPtr == 0) {
+ fprintf(stderr, "Warning: missing VM alias on line %d of `%s'\n",
+ lineno, jvmCfgName);
+ } else {
+ /* Null terminate altVMName */
+ altVMName = tmpPtr;
+ tmpPtr += strcspn(tmpPtr, whiteSpace);
+ *tmpPtr = 0;
+ vmType = VM_ALIASED_TO;
+ }
+ } else if (!strncmp(tmpPtr, "WARN", strlen("WARN"))) {
+ vmType = VM_WARN;
+ } else if (!strncmp(tmpPtr, "ERROR", strlen("ERROR"))) {
+ vmType = VM_ERROR;
+ } else {
+ fprintf(stderr, "Warning: unknown VM type on line %d of `%s'\n",
+ lineno, &jvmCfgName[0]);
+ vmType = VM_KNOWN;
+ }
+ }
+ }
+
+ if (vmType != VM_UNKNOWN) {
+ knownVMs[cnt].name = strdup(line);
+ knownVMs[cnt].flag = vmType;
+ switch (vmType) {
+ default:
+ break;
+ case VM_ALIASED_TO:
+ knownVMs[cnt].alias = strdup(altVMName);
+ break;
+ }
+ cnt++;
+ }
+ }
+ fclose(jvmCfg);
+ knownVMsCount = cnt;
+
+
+ return cnt;
+}
+
+
+static void
+GrowKnownVMs(int minimum)
+{
+ struct vmdesc* newKnownVMs;
+ int newMax;
+
+ newMax = (knownVMsLimit == 0 ? INIT_MAX_KNOWN_VMS : (2 * knownVMsLimit));
+ if (newMax <= minimum) {
+ newMax = minimum;
+ }
+ newKnownVMs = (struct vmdesc*) MemAlloc(newMax * sizeof(struct vmdesc));
+ if (knownVMs != NULL) {
+ memcpy(newKnownVMs, knownVMs, knownVMsLimit * sizeof(struct vmdesc));
+ }
+ free(knownVMs);
+ knownVMs = newKnownVMs;
+ knownVMsLimit = newMax;
+}
+
+
+/* Returns index of VM or -1 if not found */
+static int
+KnownVMIndex(const char* name)
+{
+ int i;
+ if (strncmp(name, "-J", 2) == 0) name += 2;
+ for (i = 0; i < knownVMsCount; i++) {
+ if (!strcmp(name, knownVMs[i].name)) {
+ return i;
+ }
+ }
+ return -1;
+}
+
+static void
+FreeKnownVMs()
+{
+ int i;
+ for (i = 0; i < knownVMsCount; i++) {
+ free(knownVMs[i].name);
+ knownVMs[i].name = NULL;
+ }
+ free(knownVMs);
+}
diff --git a/installer/c/limewireExe/java.h b/installer/c/limewireExe/java.h
new file mode 100644
index 0000000000..37b0754b9b
--- /dev/null
+++ b/installer/c/limewireExe/java.h
@@ -0,0 +1,76 @@
+/*
+ * @(#)java.h 1.23 04/04/24
+ *
+ * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+/* Backported from Tiger (1.5) java.h 1.26 04/01/12 */
+
+#ifndef _JAVA_H_
+#define _JAVA_H_
+
+/*
+ * Get system specific defines.
+ */
+#include "jni.h"
+#include "java_md.h"
+
+/*
+ * Pointers to the needed JNI invocation API, initialized by LoadJavaVM.
+ */
+typedef jint (JNICALL *CreateJavaVM_t)(JavaVM **pvm, void **env, void *args);
+typedef jint (JNICALL *GetDefaultJavaVMInitArgs_t)(void *args);
+
+typedef struct {
+ CreateJavaVM_t CreateJavaVM;
+ GetDefaultJavaVMInitArgs_t GetDefaultJavaVMInitArgs;
+} InvocationFunctions;
+
+/*
+ * Prototypes for launcher functions in the system specific java_md.c.
+ */
+
+jboolean
+LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn);
+
+jboolean
+GetApplicationHome(char *buf, jint bufsize);
+
+const char *
+GetArch();
+
+int CreateExecutionEnvironment(int *_argc,
+ char ***_argv,
+ char jrepath[],
+ jint so_jrepath,
+ char jvmpath[],
+ jint so_jvmpath,
+ char **original_argv);
+
+/*
+ * Report an error message to stderr or a window as appropriate. The
+ * flag always is set to JNI_TRUE if message is to be reported to both
+ * strerr and windows and set to JNI_FALSE if the message should only
+ * be sent to a window.
+ */
+void ReportErrorMessage(char * message, jboolean always);
+void ReportErrorMessage2(char * format, char * string, jboolean always);
+
+/*
+ * Report an exception which terminates the vm to stderr or a window
+ * as appropriate.
+ */
+void ReportExceptionDescription(JNIEnv * env);
+
+jboolean RemovableMachineDependentOption(char * option);
+void PrintMachineDependentOptions();
+
+/*
+ * Functions defined in java.c and used in java_md.c.
+ */
+jint ReadKnownVMs(const char *jrepath, char * arch, jboolean speculative);
+char *CheckJvmType(int *argc, char ***argv, jboolean speculative);
+void* MemAlloc(size_t size);
+
+#endif /* _JAVA_H_ */
diff --git a/installer/c/limewireExe/java_md.c b/installer/c/limewireExe/java_md.c
new file mode 100644
index 0000000000..9f336c0c97
--- /dev/null
+++ b/installer/c/limewireExe/java_md.c
@@ -0,0 +1,388 @@
+/**
+ * Derived from the shared source for the 'java' commandline tool.
+ */
+
+/* Backported from Tiger (1.5) java_md.c 1.40 04/01/12 */
+/* AMD64 support removed */
+
+#include <windows.h>
+#include <process.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "jni.h"
+#include "java.h"
+
+#define JVM_DLL "jvm.dll"
+#define JAVA_DLL "java.dll"
+
+/*
+ * Prototypes.
+ */
+static jboolean GetPublicJREHome(char *path, jint pathsize);
+static jboolean GetJVMPath(const char *jrepath, const char *jvmtype,
+ char *jvmpath, jint jvmpathsize);
+static jboolean GetJREPath(char *path, jint pathsize);
+
+const char *
+GetArch()
+{
+#ifdef _WIN64
+ return "ia64";
+#else
+ return "i386";
+#endif
+}
+
+/*
+ *
+ */
+int
+CreateExecutionEnvironment(int *_argc,
+ char ***_argv,
+ char jrepath[],
+ jint so_jrepath,
+ char jvmpath[],
+ jint so_jvmpath,
+ char **original_argv) {
+ char * jvmtype;
+
+ /* Find out where the JRE is that we will be using. */
+ if (!GetJREPath(jrepath, so_jrepath)) {
+ ReportErrorMessage("Could not find a suitable Java 2 Runtime Environment.",
+ JNI_TRUE);
+ return 1;
+ }
+
+ /* Find the specified JVM type */
+ if (ReadKnownVMs(jrepath, (char*)GetArch(), JNI_FALSE) < 1) {
+ ReportErrorMessage("Error: no known VMs. (check for corrupt jvm.cfg file)",
+ JNI_TRUE);
+ return 1;
+ }
+ jvmtype = CheckJvmType(_argc, _argv, JNI_FALSE);
+
+ jvmpath[0] = '\0';
+ if (!GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath)) {
+ char * message=NULL;
+ const char * format = "Error: no `%s' JVM at `%s'.";
+ message = (char *)MemAlloc((strlen(format)+strlen(jvmtype)+
+ strlen(jvmpath)) * sizeof(char));
+ sprintf(message,format, jvmtype, jvmpath);
+ ReportErrorMessage(message, JNI_TRUE);
+ return 1;
+ }
+ /* If we got here, jvmpath has been correctly initialized. */
+ return 0;
+
+}
+
+/*
+ * Find path to JRE based on .exe's location or registry settings.
+ */
+jboolean
+GetJREPath(char *path, jint pathsize)
+{
+ char javadll[MAXPATHLEN];
+ struct stat s;
+//
+// if (GetApplicationHome(path, pathsize)) {
+// /* Is JRE co-located with the application? */
+// sprintf(javadll, "%s\\bin\\" JAVA_DLL, path);
+// if (stat(javadll, &s) == 0) {
+// goto found;
+// }
+
+// /* Does this app ship a private JRE in <apphome>\jre directory? */
+// sprintf(javadll, "%s\\jre\\bin\\" JAVA_DLL, path);
+// if (stat(javadll, &s) == 0) {
+// strcat(path, "\\jre");
+// goto found;
+// }
+// }
+
+ /* Look for a public JRE on this machine. */
+ if (GetPublicJREHome(path, pathsize))
+ goto found;
+
+ fprintf(stderr, "Error: could not find " JAVA_DLL "\n");
+ return JNI_FALSE;
+
+ found:
+
+ {
+ // trick into thinking that the jre/bin path is in the PATH
+ char *oldPath = getenv("PATH");
+ char *newPath;
+ if(oldPath != NULL) {
+ newPath = MemAlloc(strlen(oldPath) + strlen(path) + 6 + 6 + 1); // PATH=<new>\bin;<old>
+ sprintf(newPath, "PATH=%s\\bin;%s", path, oldPath);
+ } else {
+ newPath = MemAlloc(strlen(path) + 6 + 1);
+ sprintf(newPath, "PATH=%s\\bin", path);
+ }
+ _putenv(newPath);
+ free(newPath);
+ }
+
+ return JNI_TRUE;
+}
+
+/*
+ * Given a JRE location and a JVM type, construct what the name the
+ * JVM shared library will be. Return true, if such a library
+ * exists, false otherwise.
+ */
+static jboolean
+GetJVMPath(const char *jrepath, const char *jvmtype,
+ char *jvmpath, jint jvmpathsize)
+{
+ struct stat s;
+ if (strchr(jvmtype, '/') || strchr(jvmtype, '\\')) {
+ sprintf(jvmpath, "%s\\" JVM_DLL, jvmtype);
+ } else {
+ sprintf(jvmpath, "%s\\bin\\%s\\" JVM_DLL, jrepath, jvmtype);
+ }
+ if (stat(jvmpath, &s) == 0) {
+ return JNI_TRUE;
+ } else {
+ return JNI_FALSE;
+ }
+}
+
+/*
+ * Load a jvm from "jvmpath" and initialize the invocation functions.
+ */
+jboolean
+LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn)
+{
+ HINSTANCE handle;
+
+ /* Load the Java VM DLL */
+ if ((handle = LoadLibrary(jvmpath)) == 0) {
+ ReportErrorMessage2("Error loading: %s", (char *)jvmpath, JNI_TRUE);
+ return JNI_FALSE;
+ }
+
+ /* Now get the function addresses */
+ ifn->CreateJavaVM =
+ (void *)GetProcAddress(handle, "JNI_CreateJavaVM");
+ ifn->GetDefaultJavaVMInitArgs =
+ (void *)GetProcAddress(handle, "JNI_GetDefaultJavaVMInitArgs");
+ if (ifn->CreateJavaVM == 0 || ifn->GetDefaultJavaVMInitArgs == 0) {
+ ReportErrorMessage2("Error: can't find JNI interfaces in: %s",
+ (char *)jvmpath, JNI_TRUE);
+ return JNI_FALSE;
+ }
+
+ return JNI_TRUE;
+}
+
+
+/*
+ * If app is "c:\foo\bin\javac", then put "c:\foo" into buf.
+ */
+jboolean
+GetApplicationHome(char *buf, jint bufsize)
+{
+ char *cp;
+ GetModuleFileName(0, buf, bufsize);
+ *strrchr(buf, '\\') = '\0'; /* remove .exe file name */
+ if ((cp = strrchr(buf, '\\')) == 0) {
+ /* This happens if the application is in a drive root, and
+ * there is no bin directory. */
+ buf[0] = '\0';
+ return JNI_FALSE;
+ }
+ if(strcmp(cp, "\\bin") == 0)
+ *cp = '\0'; /* remove the bin\ part */
+ // else c:\foo\something\javac
+ return JNI_TRUE;
+}
+
+/*
+ * Helpers to look in the registry for a public JRE.
+ */
+ /* Same for 1.5.0, 1.5.1, 1.5.2 etc. */
+#define DOTRELEASE JDK_MAJOR_VERSION "." JDK_MINOR_VERSION
+#define JRE_KEY "Software\\JavaSoft\\Java Runtime Environment"
+
+static jboolean
+GetStringFromRegistry(HKEY key, const char *name, char *buf, jint bufsize)
+{
+ DWORD type, size;
+
+ if (RegQueryValueEx(key, name, 0, &type, 0, &size) == 0
+ && type == REG_SZ
+ && (size < (unsigned int)bufsize)) {
+ if (RegQueryValueEx(key, name, 0, 0, buf, &size) == 0) {
+ return JNI_TRUE;
+ }
+ }
+ return JNI_FALSE;
+}
+
+static BOOL versionOk(char *version)
+{
+ char *major;
+ int major_version;
+ int minor_version;
+ char *minor_start;
+ // 1. find the .
+ minor_start = strstr(version,".");
+ if (minor_start == NULL) // no . found.
+ return FALSE;
+
+ major = (char *)malloc(minor_start - version + 1);
+ strncpy(major,version,minor_start - version);
+ major[minor_start - version]='\0';
+ major_version = atoi(major);
+ free(major);
+
+ if (minor_start[1] == '\0') // "x." ?
+ return FALSE;
+
+ // anything less than 1.6 is not supported
+ minor_version = atoi(++minor_start);
+ if (major_version <1 || (major_version < 2 && minor_version < 6))
+ return FALSE;
+
+ return TRUE;
+}
+
+static jboolean
+GetPublicJREHome(char *buf, jint bufsize)
+{
+ HKEY key, subkey;
+ char version[MAXPATHLEN];
+
+ /* Find the current version of the JRE */
+ if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, JRE_KEY, 0, KEY_READ, &key) != 0) {
+ fprintf(stderr, "Error opening registry key '" JRE_KEY "'\n");
+ return JNI_FALSE;
+ }
+
+ if (!GetStringFromRegistry(key, "CurrentVersion",
+ version, sizeof(version))) {
+ fprintf(stderr, "Failed reading value of registry key:\n\t"
+ JRE_KEY "\\CurrentVersion\n");
+ RegCloseKey(key);
+ return JNI_FALSE;
+ }
+
+ /* Check if the version is good */
+ if (!versionOk(version))
+ {
+ RegCloseKey(key);
+ return JNI_FALSE;
+ }
+
+ /* Find directory where the current version is installed. */
+ if (RegOpenKeyEx(key, version, 0, KEY_READ, &subkey) != 0) {
+ fprintf(stderr, "Error opening registry key '"
+ JRE_KEY "\\%s'\n", version);
+ RegCloseKey(key);
+ return JNI_FALSE;
+ }
+
+ if (!GetStringFromRegistry(subkey, "JavaHome", buf, bufsize)) {
+ fprintf(stderr, "Failed reading value of registry key:\n\t"
+ JRE_KEY "\\%s\\JavaHome\n", version);
+ RegCloseKey(key);
+ RegCloseKey(subkey);
+ return JNI_FALSE;
+ }
+
+ RegCloseKey(key);
+ RegCloseKey(subkey);
+ return JNI_TRUE;
+}
+
+
+void ReportErrorMessage(char * message, jboolean always) {
+ if (message != NULL) {
+ // MessageBox(NULL, message, "Java Virtual Machine Launcher",
+ // (MB_OK|MB_ICONSTOP|MB_APPLMODAL));
+ }
+}
+
+void ReportErrorMessage2(char * format, char * string, jboolean always) {
+ /*
+ * The format argument must be a printf format string with one %s
+ * argument, which is passed the string argument.
+ */
+ size_t size;
+ char * message;
+ size = strlen(format) + strlen(string);
+ message = (char*)MemAlloc(size*sizeof(char));
+ sprintf(message, (const char *)format, string);
+
+ if (message != NULL) {
+ // MessageBox(NULL, message, "Java Virtual Machine Launcher",
+ // (MB_OK|MB_ICONSTOP|MB_APPLMODAL));
+ }
+}
+
+void ReportExceptionDescription(JNIEnv * env) {
+ /*
+ * This code should be replaced by code which opens a window with
+ * the exception detail message.
+ */
+ (*env)->ExceptionDescribe(env);
+}
+
+
+/*
+ * Return JNI_TRUE for an option string that has no effect but should
+ * _not_ be passed on to the vm; return JNI_FALSE otherwise. On
+ * windows, there are no options that should be screened in this
+ * manner.
+ */
+jboolean RemovableMachineDependentOption(char * option) {
+ return JNI_FALSE;
+}
+
+void PrintMachineDependentOptions() {
+ return;
+}
+
+jboolean
+ServerClassMachine() {
+ jboolean result = JNI_FALSE;
+ return result;
+}
+
+
+/*
+ * Wrapper for platform dependent unsetenv function.
+ */
+int
+UnsetEnv(char *name)
+{
+ int ret;
+ char *buf = MemAlloc(strlen(name) + 2);
+ buf = strcat(strcpy(buf, name), "=");
+ ret = _putenv(buf);
+ free(buf);
+ return (ret);
+}
+
+/*
+ * The following just map the common UNIX name to the Windows API name,
+ * so that the common UNIX name can be used in shared code.
+ */
+int
+strcasecmp(const char *s1, const char *s2)
+{
+ return (stricmp(s1, s2));
+}
+
+int
+strncasecmp(const char *s1, const char *s2, size_t n)
+{
+ return (strnicmp(s1, s2, n));
+}
diff --git a/installer/c/limewireExe/java_md.h b/installer/c/limewireExe/java_md.h
new file mode 100644
index 0000000000..0cb4d8f0c1
--- /dev/null
+++ b/installer/c/limewireExe/java_md.h
@@ -0,0 +1,28 @@
+/*
+ * @(#)java_md.h 1.10 04/04/24
+ *
+ * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+/* Backported from Tiger (1.5) java_md.h 1.13 04/01/12 */
+
+#ifndef JAVA_MD_H
+#define JAVA_MD_H
+
+#include "jni.h"
+#include <windows.h>
+#include <io.h>
+
+#define PATH_SEPARATOR ';'
+#define FILESEP "\\"
+#define FILE_SEPARATOR '\\'
+#define MAXPATHLEN MAX_PATH
+#define MAXNAMELEN MAX_PATH
+
+
+int UnsetEnv(char *name);
+int strcasecmp(const char *s1, const char *s2);
+int strncasecmp(const char *s1, const char *s2, size_t n);
+
+#endif
diff --git a/installer/c/limewireExe/jni.h b/installer/c/limewireExe/jni.h
new file mode 100644
index 0000000000..f53476c096
--- /dev/null
+++ b/installer/c/limewireExe/jni.h
@@ -0,0 +1,1944 @@
+/*
+ * @(#)jni.h 1.62 06/02/02
+ *
+ * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+/*
+ * We used part of Netscape's Java Runtime Interface (JRI) as the starting
+ * point of our design and implementation.
+ */
+
+/******************************************************************************
+ * Java Runtime Interface
+ * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
+ *****************************************************************************/
+
+#ifndef _JAVASOFT_JNI_H_
+#define _JAVASOFT_JNI_H_
+
+#include <stdio.h>
+#include <stdarg.h>
+
+/* jni_md.h contains the machine-dependent typedefs for jbyte, jint
+ and jlong */
+
+#include "jni_md.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * JNI Types
+ */
+
+#ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H
+
+typedef unsigned char jboolean;
+typedef unsigned short jchar;
+typedef short jshort;
+typedef float jfloat;
+typedef double jdouble;
+
+typedef jint jsize;
+
+#ifdef __cplusplus
+
+class _jobject {};
+class _jclass : public _jobject {};
+class _jthrowable : public _jobject {};
+class _jstring : public _jobject {};
+class _jarray : public _jobject {};
+class _jbooleanArray : public _jarray {};
+class _jbyteArray : public _jarray {};
+class _jcharArray : public _jarray {};
+class _jshortArray : public _jarray {};
+class _jintArray : public _jarray {};
+class _jlongArray : public _jarray {};
+class _jfloatArray : public _jarray {};
+class _jdoubleArray : public _jarray {};
+class _jobjectArray : public _jarray {};
+
+typedef _jobject *jobject;
+typedef _jclass *jclass;
+typedef _jthrowable *jthrowable;
+typedef _jstring *jstring;
+typedef _jarray *jarray;
+typedef _jbooleanArray *jbooleanArray;
+typedef _jbyteArray *jbyteArray;
+typedef _jcharArray *jcharArray;
+typedef _jshortArray *jshortArray;
+typedef _jintArray *jintArray;
+typedef _jlongArray *jlongArray;
+typedef _jfloatArray *jfloatArray;
+typedef _jdoubleArray *jdoubleArray;
+typedef _jobjectArray *jobjectArray;
+
+#else
+
+struct _jobject;
+
+typedef struct _jobject *jobject;
+typedef jobject jclass;
+typedef jobject jthrowable;
+typedef jobject jstring;
+typedef jobject jarray;
+typedef jarray jbooleanArray;
+typedef jarray jbyteArray;
+typedef jarray jcharArray;
+typedef jarray jshortArray;
+typedef jarray jintArray;
+typedef jarray jlongArray;
+typedef jarray jfloatArray;
+typedef jarray jdoubleArray;
+typedef jarray jobjectArray;
+
+#endif
+
+typedef jobject jweak;
+
+typedef union jvalue {
+ jboolean z;
+ jbyte b;
+ jchar c;
+ jshort s;
+ jint i;
+ jlong j;
+ jfloat f;
+ jdouble d;
+ jobject l;
+} jvalue;
+
+struct _jfieldID;
+typedef struct _jfieldID *jfieldID;
+
+struct _jmethodID;
+typedef struct _jmethodID *jmethodID;
+
+/* Return values from jobjectRefType */
+typedef enum _jobjectType {
+ JNIInvalidRefType = 0,
+ JNILocalRefType = 1,
+ JNIGlobalRefType = 2,
+ JNIWeakGlobalRefType = 3
+} jobjectRefType;
+
+
+#endif /* JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H */
+
+/*
+ * jboolean constants
+ */
+
+#define JNI_FALSE 0
+#define JNI_TRUE 1
+
+/*
+ * possible return values for JNI functions.
+ */
+
+#define JNI_OK 0 /* success */
+#define JNI_ERR (-1) /* unknown error */
+#define JNI_EDETACHED (-2) /* thread detached from the VM */
+#define JNI_EVERSION (-3) /* JNI version error */
+#define JNI_ENOMEM (-4) /* not enough memory */
+#define JNI_EEXIST (-5) /* VM already created */
+#define JNI_EINVAL (-6) /* invalid arguments */
+
+/*
+ * used in ReleaseScalarArrayElements
+ */
+
+#define JNI_COMMIT 1
+#define JNI_ABORT 2
+
+/*
+ * used in RegisterNatives to describe native method name, signature,
+ * and function pointer.
+ */
+
+typedef struct {
+ char *name;
+ char *signature;
+ void *fnPtr;
+} JNINativeMethod;
+
+/*
+ * JNI Native Method Interface.
+ */
+
+struct JNINativeInterface_;
+
+struct JNIEnv_;
+
+#ifdef __cplusplus
+typedef JNIEnv_ JNIEnv;
+#else
+typedef const struct JNINativeInterface_ *JNIEnv;
+#endif
+
+/*
+ * JNI Invocation Interface.
+ */
+
+struct JNIInvokeInterface_;
+
+struct JavaVM_;
+
+#ifdef __cplusplus
+typedef JavaVM_ JavaVM;
+#else
+typedef const struct JNIInvokeInterface_ *JavaVM;
+#endif
+
+struct JNINativeInterface_ {
+ void *reserved0;
+ void *reserved1;
+ void *reserved2;
+
+ void *reserved3;
+ jint (JNICALL *GetVersion)(JNIEnv *env);
+
+ jclass (JNICALL *DefineClass)
+ (JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
+ jsize len);
+ jclass (JNICALL *FindClass)
+ (JNIEnv *env, const char *name);
+
+ jmethodID (JNICALL *FromReflectedMethod)
+ (JNIEnv *env, jobject method);
+ jfieldID (JNICALL *FromReflectedField)
+ (JNIEnv *env, jobject field);
+
+ jobject (JNICALL *ToReflectedMethod)
+ (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
+
+ jclass (JNICALL *GetSuperclass)
+ (JNIEnv *env, jclass sub);
+ jboolean (JNICALL *IsAssignableFrom)
+ (JNIEnv *env, jclass sub, jclass sup);
+
+ jobject (JNICALL *ToReflectedField)
+ (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);
+
+ jint (JNICALL *Throw)
+ (JNIEnv *env, jthrowable obj);
+ jint (JNICALL *ThrowNew)
+ (JNIEnv *env, jclass clazz, const char *msg);
+ jthrowable (JNICALL *ExceptionOccurred)
+ (JNIEnv *env);
+ void (JNICALL *ExceptionDescribe)
+ (JNIEnv *env);
+ void (JNICALL *ExceptionClear)
+ (JNIEnv *env);
+ void (JNICALL *FatalError)
+ (JNIEnv *env, const char *msg);
+
+ jint (JNICALL *PushLocalFrame)
+ (JNIEnv *env, jint capacity);
+ jobject (JNICALL *PopLocalFrame)
+ (JNIEnv *env, jobject result);
+
+ jobject (JNICALL *NewGlobalRef)
+ (JNIEnv *env, jobject lobj);
+ void (JNICALL *DeleteGlobalRef)
+ (JNIEnv *env, jobject gref);
+ void (JNICALL *DeleteLocalRef)
+ (JNIEnv *env, jobject obj);
+ jboolean (JNICALL *IsSameObject)
+ (JNIEnv *env, jobject obj1, jobject obj2);
+ jobject (JNICALL *NewLocalRef)
+ (JNIEnv *env, jobject ref);
+ jint (JNICALL *EnsureLocalCapacity)
+ (JNIEnv *env, jint capacity);
+
+ jobject (JNICALL *AllocObject)
+ (JNIEnv *env, jclass clazz);
+ jobject (JNICALL *NewObject)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jobject (JNICALL *NewObjectV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jobject (JNICALL *NewObjectA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jclass (JNICALL *GetObjectClass)
+ (JNIEnv *env, jobject obj);
+ jboolean (JNICALL *IsInstanceOf)
+ (JNIEnv *env, jobject obj, jclass clazz);
+
+ jmethodID (JNICALL *GetMethodID)
+ (JNIEnv *env, jclass clazz, const char *name, const char *sig);
+
+ jobject (JNICALL *CallObjectMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jobject (JNICALL *CallObjectMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jobject (JNICALL *CallObjectMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
+
+ jboolean (JNICALL *CallBooleanMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jboolean (JNICALL *CallBooleanMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jboolean (JNICALL *CallBooleanMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
+
+ jbyte (JNICALL *CallByteMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jbyte (JNICALL *CallByteMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jbyte (JNICALL *CallByteMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
+
+ jchar (JNICALL *CallCharMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jchar (JNICALL *CallCharMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jchar (JNICALL *CallCharMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
+
+ jshort (JNICALL *CallShortMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jshort (JNICALL *CallShortMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jshort (JNICALL *CallShortMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
+
+ jint (JNICALL *CallIntMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jint (JNICALL *CallIntMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jint (JNICALL *CallIntMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
+
+ jlong (JNICALL *CallLongMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jlong (JNICALL *CallLongMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jlong (JNICALL *CallLongMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
+
+ jfloat (JNICALL *CallFloatMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jfloat (JNICALL *CallFloatMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jfloat (JNICALL *CallFloatMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
+
+ jdouble (JNICALL *CallDoubleMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jdouble (JNICALL *CallDoubleMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jdouble (JNICALL *CallDoubleMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
+
+ void (JNICALL *CallVoidMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ void (JNICALL *CallVoidMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ void (JNICALL *CallVoidMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
+
+ jobject (JNICALL *CallNonvirtualObjectMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jobject (JNICALL *CallNonvirtualObjectMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jobject (JNICALL *CallNonvirtualObjectMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue * args);
+
+ jboolean (JNICALL *CallNonvirtualBooleanMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jboolean (JNICALL *CallNonvirtualBooleanMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jboolean (JNICALL *CallNonvirtualBooleanMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue * args);
+
+ jbyte (JNICALL *CallNonvirtualByteMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jbyte (JNICALL *CallNonvirtualByteMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jbyte (JNICALL *CallNonvirtualByteMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue *args);
+
+ jchar (JNICALL *CallNonvirtualCharMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jchar (JNICALL *CallNonvirtualCharMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jchar (JNICALL *CallNonvirtualCharMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue *args);
+
+ jshort (JNICALL *CallNonvirtualShortMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jshort (JNICALL *CallNonvirtualShortMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jshort (JNICALL *CallNonvirtualShortMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue *args);
+
+ jint (JNICALL *CallNonvirtualIntMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jint (JNICALL *CallNonvirtualIntMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jint (JNICALL *CallNonvirtualIntMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue *args);
+
+ jlong (JNICALL *CallNonvirtualLongMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jlong (JNICALL *CallNonvirtualLongMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jlong (JNICALL *CallNonvirtualLongMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue *args);
+
+ jfloat (JNICALL *CallNonvirtualFloatMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jfloat (JNICALL *CallNonvirtualFloatMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jfloat (JNICALL *CallNonvirtualFloatMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue *args);
+
+ jdouble (JNICALL *CallNonvirtualDoubleMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jdouble (JNICALL *CallNonvirtualDoubleMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jdouble (JNICALL *CallNonvirtualDoubleMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue *args);
+
+ void (JNICALL *CallNonvirtualVoidMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ void (JNICALL *CallNonvirtualVoidMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ void (JNICALL *CallNonvirtualVoidMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue * args);
+
+ jfieldID (JNICALL *GetFieldID)
+ (JNIEnv *env, jclass clazz, const char *name, const char *sig);
+
+ jobject (JNICALL *GetObjectField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jboolean (JNICALL *GetBooleanField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jbyte (JNICALL *GetByteField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jchar (JNICALL *GetCharField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jshort (JNICALL *GetShortField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jint (JNICALL *GetIntField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jlong (JNICALL *GetLongField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jfloat (JNICALL *GetFloatField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jdouble (JNICALL *GetDoubleField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+
+ void (JNICALL *SetObjectField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
+ void (JNICALL *SetBooleanField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
+ void (JNICALL *SetByteField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
+ void (JNICALL *SetCharField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
+ void (JNICALL *SetShortField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
+ void (JNICALL *SetIntField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
+ void (JNICALL *SetLongField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
+ void (JNICALL *SetFloatField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
+ void (JNICALL *SetDoubleField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
+
+ jmethodID (JNICALL *GetStaticMethodID)
+ (JNIEnv *env, jclass clazz, const char *name, const char *sig);
+
+ jobject (JNICALL *CallStaticObjectMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jobject (JNICALL *CallStaticObjectMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jobject (JNICALL *CallStaticObjectMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jboolean (JNICALL *CallStaticBooleanMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jboolean (JNICALL *CallStaticBooleanMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jboolean (JNICALL *CallStaticBooleanMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jbyte (JNICALL *CallStaticByteMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jbyte (JNICALL *CallStaticByteMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jbyte (JNICALL *CallStaticByteMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jchar (JNICALL *CallStaticCharMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jchar (JNICALL *CallStaticCharMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jchar (JNICALL *CallStaticCharMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jshort (JNICALL *CallStaticShortMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jshort (JNICALL *CallStaticShortMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jshort (JNICALL *CallStaticShortMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jint (JNICALL *CallStaticIntMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jint (JNICALL *CallStaticIntMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jint (JNICALL *CallStaticIntMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jlong (JNICALL *CallStaticLongMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jlong (JNICALL *CallStaticLongMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jlong (JNICALL *CallStaticLongMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jfloat (JNICALL *CallStaticFloatMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jfloat (JNICALL *CallStaticFloatMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jfloat (JNICALL *CallStaticFloatMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jdouble (JNICALL *CallStaticDoubleMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jdouble (JNICALL *CallStaticDoubleMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jdouble (JNICALL *CallStaticDoubleMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ void (JNICALL *CallStaticVoidMethod)
+ (JNIEnv *env, jclass cls, jmethodID methodID, ...);
+ void (JNICALL *CallStaticVoidMethodV)
+ (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
+ void (JNICALL *CallStaticVoidMethodA)
+ (JNIEnv *env, jclass cls, jmethodID methodID, const jvalue * args);
+
+ jfieldID (JNICALL *GetStaticFieldID)
+ (JNIEnv *env, jclass clazz, const char *name, const char *sig);
+ jobject (JNICALL *GetStaticObjectField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jboolean (JNICALL *GetStaticBooleanField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jbyte (JNICALL *GetStaticByteField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jchar (JNICALL *GetStaticCharField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jshort (JNICALL *GetStaticShortField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jint (JNICALL *GetStaticIntField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jlong (JNICALL *GetStaticLongField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jfloat (JNICALL *GetStaticFloatField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jdouble (JNICALL *GetStaticDoubleField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+
+ void (JNICALL *SetStaticObjectField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
+ void (JNICALL *SetStaticBooleanField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
+ void (JNICALL *SetStaticByteField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
+ void (JNICALL *SetStaticCharField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
+ void (JNICALL *SetStaticShortField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
+ void (JNICALL *SetStaticIntField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
+ void (JNICALL *SetStaticLongField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
+ void (JNICALL *SetStaticFloatField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
+ void (JNICALL *SetStaticDoubleField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
+
+ jstring (JNICALL *NewString)
+ (JNIEnv *env, const jchar *unicode, jsize len);
+ jsize (JNICALL *GetStringLength)
+ (JNIEnv *env, jstring str);
+ const jchar *(JNICALL *GetStringChars)
+ (JNIEnv *env, jstring str, jboolean *isCopy);
+ void (JNICALL *ReleaseStringChars)
+ (JNIEnv *env, jstring str, const jchar *chars);
+
+ jstring (JNICALL *NewStringUTF)
+ (JNIEnv *env, const char *utf);
+ jsize (JNICALL *GetStringUTFLength)
+ (JNIEnv *env, jstring str);
+ const char* (JNICALL *GetStringUTFChars)
+ (JNIEnv *env, jstring str, jboolean *isCopy);
+ void (JNICALL *ReleaseStringUTFChars)
+ (JNIEnv *env, jstring str, const char* chars);
+
+
+ jsize (JNICALL *GetArrayLength)
+ (JNIEnv *env, jarray array);
+
+ jobjectArray (JNICALL *NewObjectArray)
+ (JNIEnv *env, jsize len, jclass clazz, jobject init);
+ jobject (JNICALL *GetObjectArrayElement)
+ (JNIEnv *env, jobjectArray array, jsize index);
+ void (JNICALL *SetObjectArrayElement)
+ (JNIEnv *env, jobjectArray array, jsize index, jobject val);
+
+ jbooleanArray (JNICALL *NewBooleanArray)
+ (JNIEnv *env, jsize len);
+ jbyteArray (JNICALL *NewByteArray)
+ (JNIEnv *env, jsize len);
+ jcharArray (JNICALL *NewCharArray)
+ (JNIEnv *env, jsize len);
+ jshortArray (JNICALL *NewShortArray)
+ (JNIEnv *env, jsize len);
+ jintArray (JNICALL *NewIntArray)
+ (JNIEnv *env, jsize len);
+ jlongArray (JNICALL *NewLongArray)
+ (JNIEnv *env, jsize len);
+ jfloatArray (JNICALL *NewFloatArray)
+ (JNIEnv *env, jsize len);
+ jdoubleArray (JNICALL *NewDoubleArray)
+ (JNIEnv *env, jsize len);
+
+ jboolean * (JNICALL *GetBooleanArrayElements)
+ (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
+ jbyte * (JNICALL *GetByteArrayElements)
+ (JNIEnv *env, jbyteArray array, jboolean *isCopy);
+ jchar * (JNICALL *GetCharArrayElements)
+ (JNIEnv *env, jcharArray array, jboolean *isCopy);
+ jshort * (JNICALL *GetShortArrayElements)
+ (JNIEnv *env, jshortArray array, jboolean *isCopy);
+ jint * (JNICALL *GetIntArrayElements)
+ (JNIEnv *env, jintArray array, jboolean *isCopy);
+ jlong * (JNICALL *GetLongArrayElements)
+ (JNIEnv *env, jlongArray array, jboolean *isCopy);
+ jfloat * (JNICALL *GetFloatArrayElements)
+ (JNIEnv *env, jfloatArray array, jboolean *isCopy);
+ jdouble * (JNICALL *GetDoubleArrayElements)
+ (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
+
+ void (JNICALL *ReleaseBooleanArrayElements)
+ (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
+ void (JNICALL *ReleaseByteArrayElements)
+ (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
+ void (JNICALL *ReleaseCharArrayElements)
+ (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
+ void (JNICALL *ReleaseShortArrayElements)
+ (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
+ void (JNICALL *ReleaseIntArrayElements)
+ (JNIEnv *env, jintArray array, jint *elems, jint mode);
+ void (JNICALL *ReleaseLongArrayElements)
+ (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
+ void (JNICALL *ReleaseFloatArrayElements)
+ (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
+ void (JNICALL *ReleaseDoubleArrayElements)
+ (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
+
+ void (JNICALL *GetBooleanArrayRegion)
+ (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
+ void (JNICALL *GetByteArrayRegion)
+ (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
+ void (JNICALL *GetCharArrayRegion)
+ (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
+ void (JNICALL *GetShortArrayRegion)
+ (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
+ void (JNICALL *GetIntArrayRegion)
+ (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
+ void (JNICALL *GetLongArrayRegion)
+ (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
+ void (JNICALL *GetFloatArrayRegion)
+ (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
+ void (JNICALL *GetDoubleArrayRegion)
+ (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
+
+ void (JNICALL *SetBooleanArrayRegion)
+ (JNIEnv *env, jbooleanArray array, jsize start, jsize l, const jboolean *buf);
+ void (JNICALL *SetByteArrayRegion)
+ (JNIEnv *env, jbyteArray array, jsize start, jsize len, const jbyte *buf);
+ void (JNICALL *SetCharArrayRegion)
+ (JNIEnv *env, jcharArray array, jsize start, jsize len, const jchar *buf);
+ void (JNICALL *SetShortArrayRegion)
+ (JNIEnv *env, jshortArray array, jsize start, jsize len, const jshort *buf);
+ void (JNICALL *SetIntArrayRegion)
+ (JNIEnv *env, jintArray array, jsize start, jsize len, const jint *buf);
+ void (JNICALL *SetLongArrayRegion)
+ (JNIEnv *env, jlongArray array, jsize start, jsize len, const jlong *buf);
+ void (JNICALL *SetFloatArrayRegion)
+ (JNIEnv *env, jfloatArray array, jsize start, jsize len, const jfloat *buf);
+ void (JNICALL *SetDoubleArrayRegion)
+ (JNIEnv *env, jdoubleArray array, jsize start, jsize len, const jdouble *buf);
+
+ jint (JNICALL *RegisterNatives)
+ (JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
+ jint nMethods);
+ jint (JNICALL *UnregisterNatives)
+ (JNIEnv *env, jclass clazz);
+
+ jint (JNICALL *MonitorEnter)
+ (JNIEnv *env, jobject obj);
+ jint (JNICALL *MonitorExit)
+ (JNIEnv *env, jobject obj);
+
+ jint (JNICALL *GetJavaVM)
+ (JNIEnv *env, JavaVM **vm);
+
+ void (JNICALL *GetStringRegion)
+ (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
+ void (JNICALL *GetStringUTFRegion)
+ (JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
+
+ void * (JNICALL *GetPrimitiveArrayCritical)
+ (JNIEnv *env, jarray array, jboolean *isCopy);
+ void (JNICALL *ReleasePrimitiveArrayCritical)
+ (JNIEnv *env, jarray array, void *carray, jint mode);
+
+ const jchar * (JNICALL *GetStringCritical)
+ (JNIEnv *env, jstring string, jboolean *isCopy);
+ void (JNICALL *ReleaseStringCritical)
+ (JNIEnv *env, jstring string, const jchar *cstring);
+
+ jweak (JNICALL *NewWeakGlobalRef)
+ (JNIEnv *env, jobject obj);
+ void (JNICALL *DeleteWeakGlobalRef)
+ (JNIEnv *env, jweak ref);
+
+ jboolean (JNICALL *ExceptionCheck)
+ (JNIEnv *env);
+
+ jobject (JNICALL *NewDirectByteBuffer)
+ (JNIEnv* env, void* address, jlong capacity);
+ void* (JNICALL *GetDirectBufferAddress)
+ (JNIEnv* env, jobject buf);
+ jlong (JNICALL *GetDirectBufferCapacity)
+ (JNIEnv* env, jobject buf);
+
+ /* New JNI 1.6 Features */
+
+ jobjectRefType (JNICALL *GetObjectRefType)
+ (JNIEnv* env, jobject obj);
+};
+
+/*
+ * We use inlined functions for C++ so that programmers can write:
+ *
+ * env->FindClass("java/lang/String")
+ *
+ * in C++ rather than:
+ *
+ * (*env)->FindClass(env, "java/lang/String")
+ *
+ * in C.
+ */
+
+struct JNIEnv_ {
+ const struct JNINativeInterface_ *functions;
+#ifdef __cplusplus
+
+ jint GetVersion() {
+ return functions->GetVersion(this);
+ }
+ jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
+ jsize len) {
+ return functions->DefineClass(this, name, loader, buf, len);
+ }
+ jclass FindClass(const char *name) {
+ return functions->FindClass(this, name);
+ }
+ jmethodID FromReflectedMethod(jobject method) {
+ return functions->FromReflectedMethod(this,method);
+ }
+ jfieldID FromReflectedField(jobject field) {
+ return functions->FromReflectedField(this,field);
+ }
+
+ jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
+ return functions->ToReflectedMethod(this, cls, methodID, isStatic);
+ }
+
+ jclass GetSuperclass(jclass sub) {
+ return functions->GetSuperclass(this, sub);
+ }
+ jboolean IsAssignableFrom(jclass sub, jclass sup) {
+ return functions->IsAssignableFrom(this, sub, sup);
+ }
+
+ jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {
+ return functions->ToReflectedField(this,cls,fieldID,isStatic);
+ }
+
+ jint Throw(jthrowable obj) {
+ return functions->Throw(this, obj);
+ }
+ jint ThrowNew(jclass clazz, const char *msg) {
+ return functions->ThrowNew(this, clazz, msg);
+ }
+ jthrowable ExceptionOccurred() {
+ return functions->ExceptionOccurred(this);
+ }
+ void ExceptionDescribe() {
+ functions->ExceptionDescribe(this);
+ }
+ void ExceptionClear() {
+ functions->ExceptionClear(this);
+ }
+ void FatalError(const char *msg) {
+ functions->FatalError(this, msg);
+ }
+
+ jint PushLocalFrame(jint capacity) {
+ return functions->PushLocalFrame(this,capacity);
+ }
+ jobject PopLocalFrame(jobject result) {
+ return functions->PopLocalFrame(this,result);
+ }
+
+ jobject NewGlobalRef(jobject lobj) {
+ return functions->NewGlobalRef(this,lobj);
+ }
+ void DeleteGlobalRef(jobject gref) {
+ functions->DeleteGlobalRef(this,gref);
+ }
+ void DeleteLocalRef(jobject obj) {
+ functions->DeleteLocalRef(this, obj);
+ }
+
+ jboolean IsSameObject(jobject obj1, jobject obj2) {
+ return functions->IsSameObject(this,obj1,obj2);
+ }
+
+ jobject NewLocalRef(jobject ref) {
+ return functions->NewLocalRef(this,ref);
+ }
+ jint EnsureLocalCapacity(jint capacity) {
+ return functions->EnsureLocalCapacity(this,capacity);
+ }
+
+ jobject AllocObject(jclass clazz) {
+ return functions->AllocObject(this,clazz);
+ }
+ jobject NewObject(jclass clazz, jmethodID methodID, ...) {
+ va_list args;
+ jobject result;
+ va_start(args, methodID);
+ result = functions->NewObjectV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jobject NewObjectV(jclass clazz, jmethodID methodID,
+ va_list args) {
+ return functions->NewObjectV(this,clazz,methodID,args);
+ }
+ jobject NewObjectA(jclass clazz, jmethodID methodID,
+ const jvalue *args) {
+ return functions->NewObjectA(this,clazz,methodID,args);
+ }
+
+ jclass GetObjectClass(jobject obj) {
+ return functions->GetObjectClass(this,obj);
+ }
+ jboolean IsInstanceOf(jobject obj, jclass clazz) {
+ return functions->IsInstanceOf(this,obj,clazz);
+ }
+
+ jmethodID GetMethodID(jclass clazz, const char *name,
+ const char *sig) {
+ return functions->GetMethodID(this,clazz,name,sig);
+ }
+
+ jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jobject result;
+ va_start(args,methodID);
+ result = functions->CallObjectMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jobject CallObjectMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallObjectMethodV(this,obj,methodID,args);
+ }
+ jobject CallObjectMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallObjectMethodA(this,obj,methodID,args);
+ }
+
+ jboolean CallBooleanMethod(jobject obj,
+ jmethodID methodID, ...) {
+ va_list args;
+ jboolean result;
+ va_start(args,methodID);
+ result = functions->CallBooleanMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallBooleanMethodV(this,obj,methodID,args);
+ }
+ jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallBooleanMethodA(this,obj,methodID, args);
+ }
+
+ jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jbyte result;
+ va_start(args,methodID);
+ result = functions->CallByteMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jbyte CallByteMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallByteMethodV(this,obj,methodID,args);
+ }
+ jbyte CallByteMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallByteMethodA(this,obj,methodID,args);
+ }
+
+ jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jchar result;
+ va_start(args,methodID);
+ result = functions->CallCharMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jchar CallCharMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallCharMethodV(this,obj,methodID,args);
+ }
+ jchar CallCharMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallCharMethodA(this,obj,methodID,args);
+ }
+
+ jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jshort result;
+ va_start(args,methodID);
+ result = functions->CallShortMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jshort CallShortMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallShortMethodV(this,obj,methodID,args);
+ }
+ jshort CallShortMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallShortMethodA(this,obj,methodID,args);
+ }
+
+ jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jint result;
+ va_start(args,methodID);
+ result = functions->CallIntMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jint CallIntMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallIntMethodV(this,obj,methodID,args);
+ }
+ jint CallIntMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallIntMethodA(this,obj,methodID,args);
+ }
+
+ jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jlong result;
+ va_start(args,methodID);
+ result = functions->CallLongMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jlong CallLongMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallLongMethodV(this,obj,methodID,args);
+ }
+ jlong CallLongMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallLongMethodA(this,obj,methodID,args);
+ }
+
+ jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jfloat result;
+ va_start(args,methodID);
+ result = functions->CallFloatMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallFloatMethodV(this,obj,methodID,args);
+ }
+ jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallFloatMethodA(this,obj,methodID,args);
+ }
+
+ jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jdouble result;
+ va_start(args,methodID);
+ result = functions->CallDoubleMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallDoubleMethodV(this,obj,methodID,args);
+ }
+ jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallDoubleMethodA(this,obj,methodID,args);
+ }
+
+ void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ va_start(args,methodID);
+ functions->CallVoidMethodV(this,obj,methodID,args);
+ va_end(args);
+ }
+ void CallVoidMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ functions->CallVoidMethodV(this,obj,methodID,args);
+ }
+ void CallVoidMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ functions->CallVoidMethodA(this,obj,methodID,args);
+ }
+
+ jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jobject result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
+ jmethodID methodID, const jvalue * args) {
+ return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jboolean result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
+ jmethodID methodID, const jvalue * args) {
+ return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
+ methodID, args);
+ }
+
+ jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jbyte result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallNonvirtualByteMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
+ jmethodID methodID, const jvalue * args) {
+ return functions->CallNonvirtualByteMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jchar result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallNonvirtualCharMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
+ jmethodID methodID, const jvalue * args) {
+ return functions->CallNonvirtualCharMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jshort result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallNonvirtualShortMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
+ jmethodID methodID, const jvalue * args) {
+ return functions->CallNonvirtualShortMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jint result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallNonvirtualIntMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
+ jmethodID methodID, const jvalue * args) {
+ return functions->CallNonvirtualIntMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jlong result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallNonvirtualLongMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
+ jmethodID methodID, const jvalue * args) {
+ return functions->CallNonvirtualLongMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jfloat result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
+ jmethodID methodID,
+ va_list args) {
+ return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
+ jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jdouble result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
+ jmethodID methodID,
+ va_list args) {
+ return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
+ jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ va_start(args,methodID);
+ functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
+ va_end(args);
+ }
+ void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
+ jmethodID methodID,
+ va_list args) {
+ functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
+ }
+ void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
+ jmethodID methodID,
+ const jvalue * args) {
+ functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
+ }
+
+ jfieldID GetFieldID(jclass clazz, const char *name,
+ const char *sig) {
+ return functions->GetFieldID(this,clazz,name,sig);
+ }
+
+ jobject GetObjectField(jobject obj, jfieldID fieldID) {
+ return functions->GetObjectField(this,obj,fieldID);
+ }
+ jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
+ return functions->GetBooleanField(this,obj,fieldID);
+ }
+ jbyte GetByteField(jobject obj, jfieldID fieldID) {
+ return functions->GetByteField(this,obj,fieldID);
+ }
+ jchar GetCharField(jobject obj, jfieldID fieldID) {
+ return functions->GetCharField(this,obj,fieldID);
+ }
+ jshort GetShortField(jobject obj, jfieldID fieldID) {
+ return functions->GetShortField(this,obj,fieldID);
+ }
+ jint GetIntField(jobject obj, jfieldID fieldID) {
+ return functions->GetIntField(this,obj,fieldID);
+ }
+ jlong GetLongField(jobject obj, jfieldID fieldID) {
+ return functions->GetLongField(this,obj,fieldID);
+ }
+ jfloat GetFloatField(jobject obj, jfieldID fieldID) {
+ return functions->GetFloatField(this,obj,fieldID);
+ }
+ jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
+ return functions->GetDoubleField(this,obj,fieldID);
+ }
+
+ void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
+ functions->SetObjectField(this,obj,fieldID,val);
+ }
+ void SetBooleanField(jobject obj, jfieldID fieldID,
+ jboolean val) {
+ functions->SetBooleanField(this,obj,fieldID,val);
+ }
+ void SetByteField(jobject obj, jfieldID fieldID,
+ jbyte val) {
+ functions->SetByteField(this,obj,fieldID,val);
+ }
+ void SetCharField(jobject obj, jfieldID fieldID,
+ jchar val) {
+ functions->SetCharField(this,obj,fieldID,val);
+ }
+ void SetShortField(jobject obj, jfieldID fieldID,
+ jshort val) {
+ functions->SetShortField(this,obj,fieldID,val);
+ }
+ void SetIntField(jobject obj, jfieldID fieldID,
+ jint val) {
+ functions->SetIntField(this,obj,fieldID,val);
+ }
+ void SetLongField(jobject obj, jfieldID fieldID,
+ jlong val) {
+ functions->SetLongField(this,obj,fieldID,val);
+ }
+ void SetFloatField(jobject obj, jfieldID fieldID,
+ jfloat val) {
+ functions->SetFloatField(this,obj,fieldID,val);
+ }
+ void SetDoubleField(jobject obj, jfieldID fieldID,
+ jdouble val) {
+ functions->SetDoubleField(this,obj,fieldID,val);
+ }
+
+ jmethodID GetStaticMethodID(jclass clazz, const char *name,
+ const char *sig) {
+ return functions->GetStaticMethodID(this,clazz,name,sig);
+ }
+
+ jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
+ ...) {
+ va_list args;
+ jobject result;
+ va_start(args,methodID);
+ result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
+ va_list args) {
+ return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
+ }
+ jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
+ const jvalue *args) {
+ return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
+ }
+
+ jboolean CallStaticBooleanMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jboolean result;
+ va_start(args,methodID);
+ result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jboolean CallStaticBooleanMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
+ }
+ jboolean CallStaticBooleanMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
+ }
+
+ jbyte CallStaticByteMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jbyte result;
+ va_start(args,methodID);
+ result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jbyte CallStaticByteMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticByteMethodV(this,clazz,methodID,args);
+ }
+ jbyte CallStaticByteMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticByteMethodA(this,clazz,methodID,args);
+ }
+
+ jchar CallStaticCharMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jchar result;
+ va_start(args,methodID);
+ result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jchar CallStaticCharMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticCharMethodV(this,clazz,methodID,args);
+ }
+ jchar CallStaticCharMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticCharMethodA(this,clazz,methodID,args);
+ }
+
+ jshort CallStaticShortMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jshort result;
+ va_start(args,methodID);
+ result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jshort CallStaticShortMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticShortMethodV(this,clazz,methodID,args);
+ }
+ jshort CallStaticShortMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticShortMethodA(this,clazz,methodID,args);
+ }
+
+ jint CallStaticIntMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jint result;
+ va_start(args,methodID);
+ result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jint CallStaticIntMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticIntMethodV(this,clazz,methodID,args);
+ }
+ jint CallStaticIntMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticIntMethodA(this,clazz,methodID,args);
+ }
+
+ jlong CallStaticLongMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jlong result;
+ va_start(args,methodID);
+ result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jlong CallStaticLongMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticLongMethodV(this,clazz,methodID,args);
+ }
+ jlong CallStaticLongMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticLongMethodA(this,clazz,methodID,args);
+ }
+
+ jfloat CallStaticFloatMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jfloat result;
+ va_start(args,methodID);
+ result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jfloat CallStaticFloatMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
+ }
+ jfloat CallStaticFloatMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
+ }
+
+ jdouble CallStaticDoubleMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jdouble result;
+ va_start(args,methodID);
+ result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jdouble CallStaticDoubleMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
+ }
+ jdouble CallStaticDoubleMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
+ }
+
+ void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
+ va_list args;
+ va_start(args,methodID);
+ functions->CallStaticVoidMethodV(this,cls,methodID,args);
+ va_end(args);
+ }
+ void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
+ va_list args) {
+ functions->CallStaticVoidMethodV(this,cls,methodID,args);
+ }
+ void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
+ const jvalue * args) {
+ functions->CallStaticVoidMethodA(this,cls,methodID,args);
+ }
+
+ jfieldID GetStaticFieldID(jclass clazz, const char *name,
+ const char *sig) {
+ return functions->GetStaticFieldID(this,clazz,name,sig);
+ }
+ jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticObjectField(this,clazz,fieldID);
+ }
+ jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticBooleanField(this,clazz,fieldID);
+ }
+ jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticByteField(this,clazz,fieldID);
+ }
+ jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticCharField(this,clazz,fieldID);
+ }
+ jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticShortField(this,clazz,fieldID);
+ }
+ jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticIntField(this,clazz,fieldID);
+ }
+ jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticLongField(this,clazz,fieldID);
+ }
+ jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticFloatField(this,clazz,fieldID);
+ }
+ jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticDoubleField(this,clazz,fieldID);
+ }
+
+ void SetStaticObjectField(jclass clazz, jfieldID fieldID,
+ jobject value) {
+ functions->SetStaticObjectField(this,clazz,fieldID,value);
+ }
+ void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
+ jboolean value) {
+ functions->SetStaticBooleanField(this,clazz,fieldID,value);
+ }
+ void SetStaticByteField(jclass clazz, jfieldID fieldID,
+ jbyte value) {
+ functions->SetStaticByteField(this,clazz,fieldID,value);
+ }
+ void SetStaticCharField(jclass clazz, jfieldID fieldID,
+ jchar value) {
+ functions->SetStaticCharField(this,clazz,fieldID,value);
+ }
+ void SetStaticShortField(jclass clazz, jfieldID fieldID,
+ jshort value) {
+ functions->SetStaticShortField(this,clazz,fieldID,value);
+ }
+ void SetStaticIntField(jclass clazz, jfieldID fieldID,
+ jint value) {
+ functions->SetStaticIntField(this,clazz,fieldID,value);
+ }
+ void SetStaticLongField(jclass clazz, jfieldID fieldID,
+ jlong value) {
+ functions->SetStaticLongField(this,clazz,fieldID,value);
+ }
+ void SetStaticFloatField(jclass clazz, jfieldID fieldID,
+ jfloat value) {
+ functions->SetStaticFloatField(this,clazz,fieldID,value);
+ }
+ void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
+ jdouble value) {
+ functions->SetStaticDoubleField(this,clazz,fieldID,value);
+ }
+
+ jstring NewString(const jchar *unicode, jsize len) {
+ return functions->NewString(this,unicode,len);
+ }
+ jsize GetStringLength(jstring str) {
+ return functions->GetStringLength(this,str);
+ }
+ const jchar *GetStringChars(jstring str, jboolean *isCopy) {
+ return functions->GetStringChars(this,str,isCopy);
+ }
+ void ReleaseStringChars(jstring str, const jchar *chars) {
+ functions->ReleaseStringChars(this,str,chars);
+ }
+
+ jstring NewStringUTF(const char *utf) {
+ return functions->NewStringUTF(this,utf);
+ }
+ jsize GetStringUTFLength(jstring str) {
+ return functions->GetStringUTFLength(this,str);
+ }
+ const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
+ return functions->GetStringUTFChars(this,str,isCopy);
+ }
+ void ReleaseStringUTFChars(jstring str, const char* chars) {
+ functions->ReleaseStringUTFChars(this,str,chars);
+ }
+
+ jsize GetArrayLength(jarray array) {
+ return functions->GetArrayLength(this,array);
+ }
+
+ jobjectArray NewObjectArray(jsize len, jclass clazz,
+ jobject init) {
+ return functions->NewObjectArray(this,len,clazz,init);
+ }
+ jobject GetObjectArrayElement(jobjectArray array, jsize index) {
+ return functions->GetObjectArrayElement(this,array,index);
+ }
+ void SetObjectArrayElement(jobjectArray array, jsize index,
+ jobject val) {
+ functions->SetObjectArrayElement(this,array,index,val);
+ }
+
+ jbooleanArray NewBooleanArray(jsize len) {
+ return functions->NewBooleanArray(this,len);
+ }
+ jbyteArray NewByteArray(jsize len) {
+ return functions->NewByteArray(this,len);
+ }
+ jcharArray NewCharArray(jsize len) {
+ return functions->NewCharArray(this,len);
+ }
+ jshortArray NewShortArray(jsize len) {
+ return functions->NewShortArray(this,len);
+ }
+ jintArray NewIntArray(jsize len) {
+ return functions->NewIntArray(this,len);
+ }
+ jlongArray NewLongArray(jsize len) {
+ return functions->NewLongArray(this,len);
+ }
+ jfloatArray NewFloatArray(jsize len) {
+ return functions->NewFloatArray(this,len);
+ }
+ jdoubleArray NewDoubleArray(jsize len) {
+ return functions->NewDoubleArray(this,len);
+ }
+
+ jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
+ return functions->GetBooleanArrayElements(this,array,isCopy);
+ }
+ jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
+ return functions->GetByteArrayElements(this,array,isCopy);
+ }
+ jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
+ return functions->GetCharArrayElements(this,array,isCopy);
+ }
+ jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
+ return functions->GetShortArrayElements(this,array,isCopy);
+ }
+ jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
+ return functions->GetIntArrayElements(this,array,isCopy);
+ }
+ jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
+ return functions->GetLongArrayElements(this,array,isCopy);
+ }
+ jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
+ return functions->GetFloatArrayElements(this,array,isCopy);
+ }
+ jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
+ return functions->GetDoubleArrayElements(this,array,isCopy);
+ }
+
+ void ReleaseBooleanArrayElements(jbooleanArray array,
+ jboolean *elems,
+ jint mode) {
+ functions->ReleaseBooleanArrayElements(this,array,elems,mode);
+ }
+ void ReleaseByteArrayElements(jbyteArray array,
+ jbyte *elems,
+ jint mode) {
+ functions->ReleaseByteArrayElements(this,array,elems,mode);
+ }
+ void ReleaseCharArrayElements(jcharArray array,
+ jchar *elems,
+ jint mode) {
+ functions->ReleaseCharArrayElements(this,array,elems,mode);
+ }
+ void ReleaseShortArrayElements(jshortArray array,
+ jshort *elems,
+ jint mode) {
+ functions->ReleaseShortArrayElements(this,array,elems,mode);
+ }
+ void ReleaseIntArrayElements(jintArray array,
+ jint *elems,
+ jint mode) {
+ functions->ReleaseIntArrayElements(this,array,elems,mode);
+ }
+ void ReleaseLongArrayElements(jlongArray array,
+ jlong *elems,
+ jint mode) {
+ functions->ReleaseLongArrayElements(this,array,elems,mode);
+ }
+ void ReleaseFloatArrayElements(jfloatArray array,
+ jfloat *elems,
+ jint mode) {
+ functions->ReleaseFloatArrayElements(this,array,elems,mode);
+ }
+ void ReleaseDoubleArrayElements(jdoubleArray array,
+ jdouble *elems,
+ jint mode) {
+ functions->ReleaseDoubleArrayElements(this,array,elems,mode);
+ }
+
+ void GetBooleanArrayRegion(jbooleanArray array,
+ jsize start, jsize len, jboolean *buf) {
+ functions->GetBooleanArrayRegion(this,array,start,len,buf);
+ }
+ void GetByteArrayRegion(jbyteArray array,
+ jsize start, jsize len, jbyte *buf) {
+ functions->GetByteArrayRegion(this,array,start,len,buf);
+ }
+ void GetCharArrayRegion(jcharArray array,
+ jsize start, jsize len, jchar *buf) {
+ functions->GetCharArrayRegion(this,array,start,len,buf);
+ }
+ void GetShortArrayRegion(jshortArray array,
+ jsize start, jsize len, jshort *buf) {
+ functions->GetShortArrayRegion(this,array,start,len,buf);
+ }
+ void GetIntArrayRegion(jintArray array,
+ jsize start, jsize len, jint *buf) {
+ functions->GetIntArrayRegion(this,array,start,len,buf);
+ }
+ void GetLongArrayRegion(jlongArray array,
+ jsize start, jsize len, jlong *buf) {
+ functions->GetLongArrayRegion(this,array,start,len,buf);
+ }
+ void GetFloatArrayRegion(jfloatArray array,
+ jsize start, jsize len, jfloat *buf) {
+ functions->GetFloatArrayRegion(this,array,start,len,buf);
+ }
+ void GetDoubleArrayRegion(jdoubleArray array,
+ jsize start, jsize len, jdouble *buf) {
+ functions->GetDoubleArrayRegion(this,array,start,len,buf);
+ }
+
+ void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
+ const jboolean *buf) {
+ functions->SetBooleanArrayRegion(this,array,start,len,buf);
+ }
+ void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
+ const jbyte *buf) {
+ functions->SetByteArrayRegion(this,array,start,len,buf);
+ }
+ void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
+ const jchar *buf) {
+ functions->SetCharArrayRegion(this,array,start,len,buf);
+ }
+ void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
+ const jshort *buf) {
+ functions->SetShortArrayRegion(this,array,start,len,buf);
+ }
+ void SetIntArrayRegion(jintArray array, jsize start, jsize len,
+ const jint *buf) {
+ functions->SetIntArrayRegion(this,array,start,len,buf);
+ }
+ void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
+ const jlong *buf) {
+ functions->SetLongArrayRegion(this,array,start,len,buf);
+ }
+ void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
+ const jfloat *buf) {
+ functions->SetFloatArrayRegion(this,array,start,len,buf);
+ }
+ void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
+ const jdouble *buf) {
+ functions->SetDoubleArrayRegion(this,array,start,len,buf);
+ }
+
+ jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
+ jint nMethods) {
+ return functions->RegisterNatives(this,clazz,methods,nMethods);
+ }
+ jint UnregisterNatives(jclass clazz) {
+ return functions->UnregisterNatives(this,clazz);
+ }
+
+ jint MonitorEnter(jobject obj) {
+ return functions->MonitorEnter(this,obj);
+ }
+ jint MonitorExit(jobject obj) {
+ return functions->MonitorExit(this,obj);
+ }
+
+ jint GetJavaVM(JavaVM **vm) {
+ return functions->GetJavaVM(this,vm);
+ }
+
+ void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {
+ functions->GetStringRegion(this,str,start,len,buf);
+ }
+ void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {
+ functions->GetStringUTFRegion(this,str,start,len,buf);
+ }
+
+ void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) {
+ return functions->GetPrimitiveArrayCritical(this,array,isCopy);
+ }
+ void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) {
+ functions->ReleasePrimitiveArrayCritical(this,array,carray,mode);
+ }
+
+ const jchar * GetStringCritical(jstring string, jboolean *isCopy) {
+ return functions->GetStringCritical(this,string,isCopy);
+ }
+ void ReleaseStringCritical(jstring string, const jchar *cstring) {
+ functions->ReleaseStringCritical(this,string,cstring);
+ }
+
+ jweak NewWeakGlobalRef(jobject obj) {
+ return functions->NewWeakGlobalRef(this,obj);
+ }
+ void DeleteWeakGlobalRef(jweak ref) {
+ functions->DeleteWeakGlobalRef(this,ref);
+ }
+
+ jboolean ExceptionCheck() {
+ return functions->ExceptionCheck(this);
+ }
+
+ jobject NewDirectByteBuffer(void* address, jlong capacity) {
+ return functions->NewDirectByteBuffer(this, address, capacity);
+ }
+ void* GetDirectBufferAddress(jobject buf) {
+ return functions->GetDirectBufferAddress(this, buf);
+ }
+ jlong GetDirectBufferCapacity(jobject buf) {
+ return functions->GetDirectBufferCapacity(this, buf);
+ }
+ jobjectRefType GetObjectRefType(jobject obj) {
+ return functions->GetObjectRefType(this, obj);
+ }
+
+#endif /* __cplusplus */
+};
+
+typedef struct JavaVMOption {
+ char *optionString;
+ void *extraInfo;
+} JavaVMOption;
+
+typedef struct JavaVMInitArgs {
+ jint version;
+
+ jint nOptions;
+ JavaVMOption *options;
+ jboolean ignoreUnrecognized;
+} JavaVMInitArgs;
+
+typedef struct JavaVMAttachArgs {
+ jint version;
+
+ char *name;
+ jobject group;
+} JavaVMAttachArgs;
+
+/* These will be VM-specific. */
+
+#define JDK1_2
+#define JDK1_4
+
+/* End VM-specific. */
+
+struct JNIInvokeInterface_ {
+ void *reserved0;
+ void *reserved1;
+ void *reserved2;
+
+ jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
+
+ jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
+
+ jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
+
+ jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
+
+ jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);
+};
+
+struct JavaVM_ {
+ const struct JNIInvokeInterface_ *functions;
+#ifdef __cplusplus
+
+ jint DestroyJavaVM() {
+ return functions->DestroyJavaVM(this);
+ }
+ jint AttachCurrentThread(void **penv, void *args) {
+ return functions->AttachCurrentThread(this, penv, args);
+ }
+ jint DetachCurrentThread() {
+ return functions->DetachCurrentThread(this);
+ }
+
+ jint GetEnv(void **penv, jint version) {
+ return functions->GetEnv(this, penv, version);
+ }
+ jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
+ return functions->AttachCurrentThreadAsDaemon(this, penv, args);
+ }
+#endif
+};
+
+#ifdef _JNI_IMPLEMENTATION_
+#define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
+#else
+#define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
+#endif
+_JNI_IMPORT_OR_EXPORT_ jint JNICALL
+JNI_GetDefaultJavaVMInitArgs(void *args);
+
+_JNI_IMPORT_OR_EXPORT_ jint JNICALL
+JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
+
+_JNI_IMPORT_OR_EXPORT_ jint JNICALL
+JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
+
+/* Defined by native libraries. */
+JNIEXPORT jint JNICALL
+JNI_OnLoad(JavaVM *vm, void *reserved);
+
+JNIEXPORT void JNICALL
+JNI_OnUnload(JavaVM *vm, void *reserved);
+
+#define JNI_VERSION_1_1 0x00010001
+#define JNI_VERSION_1_2 0x00010002
+#define JNI_VERSION_1_4 0x00010004
+#define JNI_VERSION_1_6 0x00010006
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
+
+#endif /* !_JAVASOFT_JNI_H_ */
+
+
+
diff --git a/installer/c/limewireExe/jni_md.h b/installer/c/limewireExe/jni_md.h
new file mode 100644
index 0000000000..9f0cfa4638
--- /dev/null
+++ b/installer/c/limewireExe/jni_md.h
@@ -0,0 +1,19 @@
+/*
+ * @(#)jni_md.h 1.15 05/11/17
+ *
+ * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+#ifndef _JAVASOFT_JNI_MD_H_
+#define _JAVASOFT_JNI_MD_H_
+
+#define JNIEXPORT __declspec(dllexport)
+#define JNIIMPORT __declspec(dllimport)
+#define JNICALL __stdcall
+
+typedef long jint;
+typedef __int64 jlong;
+typedef signed char jbyte;
+
+#endif /* !_JAVASOFT_JNI_MD_H_ */
diff --git a/installer/c/limewireExe/limewire.c b/installer/c/limewireExe/limewire.c
new file mode 100644
index 0000000000..876e49fa3f
--- /dev/null
+++ b/installer/c/limewireExe/limewire.c
@@ -0,0 +1,234 @@
+/**
+ * Customized LimeWire launcher.
+ * Launches the JRE within the process, to allow Task Manager to show
+ * "LimeWire.exe" as the process, and firewalls to control access of
+ * "LimeWire.exe".
+ */
+
+#include "errors.h"
+
+#include <windows.h>
+#include <stdio.h>
+#include <malloc.h>
+#include <sys/stat.h>
+
+//BOOL MoveFontPropertiesFile(const char *path);
+void SetWorkingDirectory(char *path);
+void readOptions(char***, int*);
+//BOOL localJREExists(const char*);
+BOOL exist(const char*);
+
+// defined in java.c
+extern void* MemAlloc(size_t);
+// defined in java.c
+extern int launchJVM(int, char**);
+
+
+int
+main(int argc, char** argv) {
+
+ int read_options_size;
+ char** read_options;
+ int ret = 0;
+ int current_argc = 0;
+ int new_argc;
+ char** new_argv;
+ int i;
+ char currentDirectory[MAX_PATH+1];
+
+ // Set/get the correct working directory.
+ SetWorkingDirectory(currentDirectory);
+
+ // Read in options from disk (launch.properties)
+ // or the default ones (if no launch.properties existed)
+ readOptions(&read_options, &read_options_size);
+
+ // Construct a new argc & argv to pass to launchJVM
+ new_argc = read_options_size + argc;
+ new_argv = (char**)MemAlloc(sizeof(char*) * (new_argc+1));
+
+ // copy process name
+ new_argv[0] = argv[0];
+ // copy arguments from properties file
+ for(i = 1; i <= read_options_size; i++)
+ new_argv[i] = read_options[i-1];
+ // copy argv arguments as arguments after the properties file
+ // (generally used as arguments for LimeWire)
+ for(current_argc = 1; current_argc < argc; current_argc++)
+ new_argv[i++] = argv[current_argc];
+
+ new_argv[i] = NULL;
+
+ // options are no longer necessary -- free them up.
+ if(read_options != 0)
+ free(read_options);
+
+ ret = launchJVM(new_argc, new_argv);
+ free(new_argv);
+ switch(ret) {
+ case ERROR_COULDNT_FIND_JVM:
+ case ERROR_COULDNT_INITIALIZE_JVM:
+ case ERROR_COULDNT_LOAD_JVM:
+ if (MessageBox(NULL, "MuWire needs the Java Runtime Environment 6.0 or above. Click OK to go to www.java.com, where you can install Java.",
+ "MuWire Launcher Error",
+ MB_ICONWARNING | MB_OKCANCEL) == IDOK)
+ ShellExecute(NULL, NULL, "http://www.java.com/", "", "", SW_SHOWNORMAL);
+ break;
+ case ERROR_COULDNT_PARSE_ARGUMENTS:
+ MessageBox(NULL, "MuWire failed to parse the commandline arguments to Java.\n"
+ "Please download and install MuWire again.",
+ "MuWire Launcher Error", MB_OK);
+ break;
+ case ERROR_STARTING_PROGRAM:
+ MessageBox(NULL, "MuWire was unable to load.\n"
+ "Please download and install MuWire again.",
+ "MuWire Launcher Error", MB_OK);
+ break;
+ }
+ return ret;
+}
+
+
+
+#define MAX_OPTION_SIZE 100
+#define MAX_OPTIONS 100
+
+/**
+ * Read in the launch.properties file and generate psuedo-commandline arguments.
+ */
+void readOptions(char*** options, int* size) {
+ FILE* file;
+ char* buffer;
+ int i;
+ size_t currentlen;
+ char* command;
+
+ file = fopen("launch.properties", "r");
+ if(file == NULL) {
+ // default to certain values.
+ *size = 10;
+#ifdef ALPHA
+ *size = (*size) + 1;
+#endif
+
+ *options = (char**)MemAlloc(sizeof(char*) * (*size));
+ i = 0;
+ (*options)[i++] = "-Xms64m";
+ (*options)[i++] = "-Xmx256m";
+ (*options)[i++] = "-Dasdf=fdsa";
+ (*options)[i++] = "-Dorg.apache.commons.logging.Log=org.apache.commons.logging.impl.NoOpLog";
+ //(*options)[i++] = "-Djava.net.preferIPv6Addresses=false";
+ (*options)[i++] = "-Djava.net.preferIPv4Stack=true";
+ (*options)[i++] = "-ea:com.limegroup...";
+ (*options)[i++] = "-ea:org.limewire...";
+ (*options)[i++] = "-Djava.library.path=lib";
+ (*options)[i++] = "-jar";
+ (*options)[i++] = "lib\\MuWire.jar";
+#ifdef ALPHA
+#pragma message ("\n\n!!!!!!!!!!!!!! building ALPHA !!!!!!!!!!!!!!\n\n")
+ (*options)[(*size) - 3] = "-agentlib:yjpagent=port=11111";
+ (*options)[(*size) - 2] = "-jar";
+ (*options)[(*size) - 1] = "LimeWire.jar";
+#endif
+ return;
+ }
+
+ *options = (char**)MemAlloc(sizeof(char*) * MAX_OPTIONS);
+ *size = 0;
+
+ for(i = 0; i < MAX_OPTIONS && !feof(file); i++) {
+ buffer = (char*)MemAlloc(sizeof(char) * MAX_OPTION_SIZE);
+ // get the next option.
+ if(fgets(buffer, MAX_OPTION_SIZE - 1, file) == NULL)
+ break;
+ // strip off the \n if it exists.
+ currentlen = strlen(buffer);
+ if(currentlen > 0 && buffer[currentlen-1] == '\n') {
+ buffer[currentlen-1] = 0;
+ currentlen--;
+ }
+ // downsize the storage for the command.
+ currentlen++; // (include \0)
+ command = (char*)MemAlloc(sizeof(char) * currentlen);
+ strcpy(command, buffer);
+ free(buffer);
+
+ // set the option & increase the size
+ if(currentlen > 0) {
+ (*options)[i] = command;
+ (*size)++;
+ }
+ }
+
+ if(file != NULL)
+ fclose(file);
+}
+
+/*
+ * Sets the current working directory to wherever LimeWire.exe is located
+ */
+static void
+SetWorkingDirectory(char *path) {
+ GetModuleFileName(NULL, path, MAX_PATH + 1);
+ *strrchr(path, '\\') = '\0'; // remove the .exe
+ SetCurrentDirectory(path);
+ GetCurrentDirectory(MAX_PATH + 1, path);
+}
+
+/**
+ * Checks to see if an app-installed JRE exists.
+ */
+/*
+BOOL localJREExists(const char* path) {
+ char localBuf[MAX_PATH + 1];
+ sprintf(localBuf, "%s\\jre\\bin\\hotspot\\jvm.dll\0", path);
+ return exist(localBuf);
+}
+*/
+
+/**
+ * Copies the windows.font.properties file to the jre so that
+ * we use the proper fonts for international installs.
+ */
+/*
+BOOL
+MoveFontPropertiesFile(const char *path) {
+ char curFontFile[MAX_PATH + 1];
+ char newFontFile[MAX_PATH + 1];
+ BOOL copySucceeded;
+ sprintf(curFontFile, "%s\\windows.font.properties\0", path);
+ sprintf(newFontFile, "%s\\jre\\lib\\font.properties\0", path);
+ if(!exist(curFontFile))
+ return TRUE;
+
+ copySucceeded = CopyFile(curFontFile, newFontFile, FALSE);
+ if(copySucceeded)
+ DeleteFile(curFontFile);
+ return copySucceeded;
+}
+*/
+
+BOOL exist(const char *filename) {
+ struct stat s;
+ return stat(filename, &s) == 0 ? TRUE : FALSE;
+}
+
+
+__declspec(dllimport) char **__initenv;
+
+int WINAPI
+WinMain(HINSTANCE inst, HINSTANCE previnst, LPSTR cmdline, int cmdshow)
+{
+ int ret;
+
+ /* It turns out, that Windows can set thread locale to default user locale
+ * instead of default system locale. We correct this by explicitely setting
+ * thread locale to system default.
+ */
+ SetThreadLocale(GetSystemDefaultLCID());
+
+ __initenv = _environ;
+ ret = main(__argc, __argv);
+
+ return ret;
+}
\ No newline at end of file
diff --git a/installer/c/limewireExe/merged icon.ico b/installer/c/limewireExe/merged icon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..d43cef886eb91d286c0208e0d84baa3bd7b41f4d
GIT binary patch
literal 97294
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
literal 0
HcmV?d00001
diff --git a/installer/c/limewireExe/resource1.h b/installer/c/limewireExe/resource1.h
new file mode 100644
index 0000000000..cd8ba7818e
--- /dev/null
+++ b/installer/c/limewireExe/resource1.h
@@ -0,0 +1,17 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by LimeWire31.rc
+//
+#define IDI_ICON1 111
+#define IDI_ICON2 112
+
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE 113
+#define _APS_NEXT_COMMAND_VALUE 40001
+#define _APS_NEXT_CONTROL_VALUE 1001
+#define _APS_NEXT_SYMED_VALUE 101
+#endif
+#endif
diff --git a/installer/c/limewireExe/torrent.ico b/installer/c/limewireExe/torrent.ico
new file mode 100644
index 0000000000000000000000000000000000000000..3a4da56a01182ff29a808612d1549fbbbb86975e
GIT binary patch
literal 25214
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
Hu4(*V@^m`>
literal 0
HcmV?d00001
--
GitLab