bug=80906
ra=edburns author= Nikolay Igotti Added and removed files - continued previous checkin. git-svn-id: svn://10.0.0.236/trunk@99136 18797224-902f-48f8-a5cc-f745e15eee43
This commit is contained in:
edburns%acm.org
@@ -1,112 +0,0 @@
|
||||
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
||||
*
|
||||
* The contents of this file are subject to the Mozilla Public
|
||||
* License Version 1.1 (the "License"); you may not use this file
|
||||
* except in compliance with the License. You may obtain a copy of
|
||||
* the License at http://www.mozilla.org/MPL/
|
||||
*
|
||||
* Software distributed under the License is distributed on an "AS
|
||||
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* The Original Code is The Waterfall Java Plugin Module
|
||||
*
|
||||
* The Initial Developer of the Original Code is Sun Microsystems Inc
|
||||
* Portions created by Sun Microsystems Inc are Copyright (C) 2001
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* $Id: Aptest.java,v 1.1.1.1 2001-05-10 18:12:36 edburns%acm.org Exp $
|
||||
*
|
||||
*
|
||||
* Contributor(s):
|
||||
*
|
||||
* Nikolay N. Igotti <inn@sparc.spb.su>
|
||||
*/
|
||||
|
||||
import java.util.*;
|
||||
import java.awt.*;
|
||||
import java.awt.event.*;
|
||||
import java.applet.*;
|
||||
import java.text.*;
|
||||
import java.net.*;
|
||||
|
||||
public class Aptest extends Applet implements Runnable {
|
||||
Thread timer; // The thread that displays clock
|
||||
int lastxs, lastys, lastxm,
|
||||
lastym, lastxh, lastyh; // Dimensions used to draw hands
|
||||
SimpleDateFormat formatter; // Formats the date displayed
|
||||
String lastdate; // String to hold date displayed
|
||||
Font clockFaceFont; // Font for number display on clock
|
||||
Date currentDate; // Used to get date to display
|
||||
Color handColor; // Color of main hands and dial
|
||||
Color numberColor; // Color of second hand and numbers
|
||||
|
||||
public void init() {
|
||||
Button b1 = new Button("Show status");
|
||||
b1.setBounds(0, 0, 40, 40);
|
||||
b1.addActionListener(new ActionListener()
|
||||
{
|
||||
public void actionPerformed(ActionEvent e)
|
||||
{
|
||||
AppletContext ctx = getAppletContext();
|
||||
ctx.showStatus("DONE SHOW STATUS");
|
||||
}
|
||||
});
|
||||
Button b2 = new Button("Show document");
|
||||
b2.setBounds(0, 0, 40, 40);
|
||||
b2.addActionListener(new ActionListener()
|
||||
{
|
||||
public void actionPerformed(ActionEvent e)
|
||||
{
|
||||
AppletContext ctx = getAppletContext();
|
||||
try {
|
||||
ctx.showDocument(new URL("http://www.sun.com"));
|
||||
} catch (Exception ex) {}
|
||||
}
|
||||
});
|
||||
setLayout(new FlowLayout(FlowLayout.CENTER));
|
||||
|
||||
add(b1);
|
||||
add(b2);
|
||||
resize(300,300); // Set clock window size
|
||||
}
|
||||
|
||||
public void start() {
|
||||
timer = new Thread(this);
|
||||
timer.start();
|
||||
}
|
||||
|
||||
public void stop() {
|
||||
timer = null;
|
||||
}
|
||||
|
||||
public void run() {
|
||||
Thread me = Thread.currentThread();
|
||||
while (timer == me) {
|
||||
try {
|
||||
Thread.currentThread().sleep(100);
|
||||
} catch (InterruptedException e) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void update(Graphics g) {
|
||||
paint(g);
|
||||
}
|
||||
|
||||
public String getAppletInfo() {
|
||||
return "Title: A Clock \nAuthor: Rachel Gollub, 1995 \nAn analog clock.";
|
||||
}
|
||||
|
||||
public String[][] getParameterInfo() {
|
||||
String[][] info = {
|
||||
{"bgcolor", "hexadecimal RGB number", "The background color. Default is the color of your browser."},
|
||||
{"fgcolor1", "hexadecimal RGB number", "The color of the hands and dial. Default is blue."},
|
||||
{"fgcolor2", "hexadecimal RGB number", "The color of the seconds hand and numbers. Default is dark gray."}
|
||||
};
|
||||
return info;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,329 +0,0 @@
|
||||
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
||||
*
|
||||
* The contents of this file are subject to the Mozilla Public
|
||||
* License Version 1.1 (the "License"); you may not use this file
|
||||
* except in compliance with the License. You may obtain a copy of
|
||||
* the License at http://www.mozilla.org/MPL/
|
||||
*
|
||||
* Software distributed under the License is distributed on an "AS
|
||||
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* The Original Code is The Waterfall Java Plugin Module
|
||||
*
|
||||
* The Initial Developer of the Original Code is Sun Microsystems Inc
|
||||
* Portions created by Sun Microsystems Inc are Copyright (C) 2001
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* $Id: UnixShell.c,v 1.1.1.1 2001-05-10 18:12:37 edburns%acm.org Exp $
|
||||
*
|
||||
*
|
||||
* Contributor(s):
|
||||
*
|
||||
* Nikolay N. Igotti <inn@sparc.spb.su>
|
||||
*/
|
||||
|
||||
/* -*- Mode: C; tab-width: 4; -*- */
|
||||
/******************************************************************************
|
||||
* Copyright (c) 1996 Netscape Communications. All rights reserved.
|
||||
******************************************************************************/
|
||||
/*
|
||||
* UnixShell.c
|
||||
*
|
||||
* Netscape Client Plugin API
|
||||
* - Function that need to be implemented by plugin developers
|
||||
*
|
||||
* This file defines a "Template" plugin that plugin developers can use
|
||||
* as the basis for a real plugin. This shell just provides empty
|
||||
* implementations of all functions that the plugin can implement
|
||||
* that will be called by Netscape (the NPP_xxx methods defined in
|
||||
* npapi.h).
|
||||
*
|
||||
* dp Suresh <dp@netscape.com>
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include "npapi.h"
|
||||
|
||||
/***********************************************************************
|
||||
* Instance state information about the plugin.
|
||||
*
|
||||
* PLUGIN DEVELOPERS:
|
||||
* Use this struct to hold per-instance information that you'll
|
||||
* need in the various functions in this file.
|
||||
***********************************************************************/
|
||||
|
||||
typedef struct _PluginInstance
|
||||
{
|
||||
int nothing;
|
||||
} PluginInstance;
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* Empty implementations of plugin API functions
|
||||
*
|
||||
* PLUGIN DEVELOPERS:
|
||||
* You will need to implement these functions as required by your
|
||||
* plugin.
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
char*
|
||||
NPP_GetMIMEDescription(void)
|
||||
{
|
||||
return("mime/type:sample:Template Only");
|
||||
}
|
||||
|
||||
NPError
|
||||
NPP_GetValue(void *future, NPPVariable variable, void *value)
|
||||
{
|
||||
NPError err = NPERR_NO_ERROR;
|
||||
|
||||
switch (variable) {
|
||||
case NPPVpluginNameString:
|
||||
*((char **)value) = "Template plugin";
|
||||
break;
|
||||
case NPPVpluginDescriptionString:
|
||||
*((char **)value) =
|
||||
"This plugins handles nothing. This is only"
|
||||
" a template.";
|
||||
break;
|
||||
default:
|
||||
err = NPERR_GENERIC_ERROR;
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
NPError
|
||||
NPP_Initialize(void)
|
||||
{
|
||||
return NPERR_NO_ERROR;
|
||||
}
|
||||
|
||||
|
||||
jref
|
||||
NPP_GetJavaClass()
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
NPP_Shutdown(void)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
NPError
|
||||
NPP_New(NPMIMEType pluginType,
|
||||
NPP instance,
|
||||
uint16 mode,
|
||||
int16 argc,
|
||||
char* argn[],
|
||||
char* argv[],
|
||||
NPSavedData* saved)
|
||||
{
|
||||
PluginInstance* This;
|
||||
|
||||
if (instance == NULL)
|
||||
return NPERR_INVALID_INSTANCE_ERROR;
|
||||
|
||||
instance->pdata = NPN_MemAlloc(sizeof(PluginInstance));
|
||||
|
||||
This = (PluginInstance*) instance->pdata;
|
||||
|
||||
if (This != NULL)
|
||||
return NPERR_NO_ERROR;
|
||||
else
|
||||
return NPERR_OUT_OF_MEMORY_ERROR;
|
||||
}
|
||||
|
||||
|
||||
NPError
|
||||
NPP_Destroy(NPP instance, NPSavedData** save)
|
||||
{
|
||||
PluginInstance* This;
|
||||
|
||||
if (instance == NULL)
|
||||
return NPERR_INVALID_INSTANCE_ERROR;
|
||||
|
||||
This = (PluginInstance*) instance->pdata;
|
||||
|
||||
/* PLUGIN DEVELOPERS:
|
||||
* If desired, call NP_MemAlloc to create a
|
||||
* NPSavedDate structure containing any state information
|
||||
* that you want restored if this plugin instance is later
|
||||
* recreated.
|
||||
*/
|
||||
|
||||
if (This != NULL) {
|
||||
NPN_MemFree(instance->pdata);
|
||||
instance->pdata = NULL;
|
||||
}
|
||||
|
||||
return NPERR_NO_ERROR;
|
||||
}
|
||||
|
||||
|
||||
|
||||
NPError
|
||||
NPP_SetWindow(NPP instance, NPWindow* window)
|
||||
{
|
||||
PluginInstance* This;
|
||||
|
||||
if (instance == NULL)
|
||||
return NPERR_INVALID_INSTANCE_ERROR;
|
||||
|
||||
if (window == NULL)
|
||||
return NPERR_NO_ERROR;
|
||||
|
||||
This = (PluginInstance*) instance->pdata;
|
||||
|
||||
/*
|
||||
* PLUGIN DEVELOPERS:
|
||||
* Before setting window to point to the
|
||||
* new window, you may wish to compare the new window
|
||||
* info to the previous window (if any) to note window
|
||||
* size changes, etc.
|
||||
*/
|
||||
|
||||
return NPERR_NO_ERROR;
|
||||
}
|
||||
|
||||
|
||||
NPError
|
||||
NPP_NewStream(NPP instance,
|
||||
NPMIMEType type,
|
||||
NPStream *stream,
|
||||
NPBool seekable,
|
||||
uint16 *stype)
|
||||
{
|
||||
NPByteRange range;
|
||||
PluginInstance* This;
|
||||
|
||||
if (instance == NULL)
|
||||
return NPERR_INVALID_INSTANCE_ERROR;
|
||||
|
||||
This = (PluginInstance*) instance->pdata;
|
||||
|
||||
return NPERR_NO_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/* PLUGIN DEVELOPERS:
|
||||
* These next 2 functions are directly relevant in a plug-in which
|
||||
* handles the data in a streaming manner. If you want zero bytes
|
||||
* because no buffer space is YET available, return 0. As long as
|
||||
* the stream has not been written to the plugin, Navigator will
|
||||
* continue trying to send bytes. If the plugin doesn't want them,
|
||||
* just return some large number from NPP_WriteReady(), and
|
||||
* ignore them in NPP_Write(). For a NP_ASFILE stream, they are
|
||||
* still called but can safely be ignored using this strategy.
|
||||
*/
|
||||
|
||||
int32 STREAMBUFSIZE = 0X0FFFFFFF; /* If we are reading from a file in NPAsFile
|
||||
* mode so we can take any size stream in our
|
||||
* write call (since we ignore it) */
|
||||
|
||||
int32
|
||||
NPP_WriteReady(NPP instance, NPStream *stream)
|
||||
{
|
||||
PluginInstance* This;
|
||||
if (instance != NULL)
|
||||
This = (PluginInstance*) instance->pdata;
|
||||
|
||||
return STREAMBUFSIZE;
|
||||
}
|
||||
|
||||
|
||||
int32
|
||||
NPP_Write(NPP instance, NPStream *stream, int32 offset, int32 len, void *buffer)
|
||||
{
|
||||
if (instance != NULL)
|
||||
{
|
||||
PluginInstance* This = (PluginInstance*) instance->pdata;
|
||||
}
|
||||
|
||||
return len; /* The number of bytes accepted */
|
||||
}
|
||||
|
||||
|
||||
NPError
|
||||
NPP_DestroyStream(NPP instance, NPStream *stream, NPError reason)
|
||||
{
|
||||
PluginInstance* This;
|
||||
|
||||
if (instance == NULL)
|
||||
return NPERR_INVALID_INSTANCE_ERROR;
|
||||
This = (PluginInstance*) instance->pdata;
|
||||
|
||||
return NPERR_NO_ERROR;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
NPP_StreamAsFile(NPP instance, NPStream *stream, const char* fname)
|
||||
{
|
||||
PluginInstance* This;
|
||||
if (instance != NULL)
|
||||
This = (PluginInstance*) instance->pdata;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
NPP_Print(NPP instance, NPPrint* printInfo)
|
||||
{
|
||||
if(printInfo == NULL)
|
||||
return;
|
||||
|
||||
if (instance != NULL) {
|
||||
PluginInstance* This = (PluginInstance*) instance->pdata;
|
||||
|
||||
if (printInfo->mode == NP_FULL) {
|
||||
/*
|
||||
* PLUGIN DEVELOPERS:
|
||||
* If your plugin would like to take over
|
||||
* printing completely when it is in full-screen mode,
|
||||
* set printInfo->pluginPrinted to TRUE and print your
|
||||
* plugin as you see fit. If your plugin wants Netscape
|
||||
* to handle printing in this case, set
|
||||
* printInfo->pluginPrinted to FALSE (the default) and
|
||||
* do nothing. If you do want to handle printing
|
||||
* yourself, printOne is true if the print button
|
||||
* (as opposed to the print menu) was clicked.
|
||||
* On the Macintosh, platformPrint is a THPrint; on
|
||||
* Windows, platformPrint is a structure
|
||||
* (defined in npapi.h) containing the printer name, port,
|
||||
* etc.
|
||||
*/
|
||||
|
||||
void* platformPrint =
|
||||
printInfo->print.fullPrint.platformPrint;
|
||||
NPBool printOne =
|
||||
printInfo->print.fullPrint.printOne;
|
||||
|
||||
/* Do the default*/
|
||||
printInfo->print.fullPrint.pluginPrinted = FALSE;
|
||||
}
|
||||
else { /* If not fullscreen, we must be embedded */
|
||||
/*
|
||||
* PLUGIN DEVELOPERS:
|
||||
* If your plugin is embedded, or is full-screen
|
||||
* but you returned false in pluginPrinted above, NPP_Print
|
||||
* will be called with mode == NP_EMBED. The NPWindow
|
||||
* in the printInfo gives the location and dimensions of
|
||||
* the embedded plugin on the printed page. On the
|
||||
* Macintosh, platformPrint is the printer port; on
|
||||
* Windows, platformPrint is the handle to the printing
|
||||
* device context.
|
||||
*/
|
||||
|
||||
NPWindow* printWindow =
|
||||
&(printInfo->print.embedPrint.window);
|
||||
void* platformPrint =
|
||||
printInfo->print.embedPrint.platformPrint;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,85 +0,0 @@
|
||||
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
||||
*
|
||||
* The contents of this file are subject to the Mozilla Public
|
||||
* License Version 1.1 (the "License"); you may not use this file
|
||||
* except in compliance with the License. You may obtain a copy of
|
||||
* the License at http://www.mozilla.org/MPL/
|
||||
*
|
||||
* Software distributed under the License is distributed on an "AS
|
||||
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* The Original Code is The Waterfall Java Plugin Module
|
||||
*
|
||||
* The Initial Developer of the Original Code is Sun Microsystems Inc
|
||||
* Portions created by Sun Microsystems Inc are Copyright (C) 2001
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* $Id: common.h,v 1.1.1.1 2001-05-10 18:12:36 edburns%acm.org Exp $
|
||||
*
|
||||
*
|
||||
* Contributor(s):
|
||||
*
|
||||
* Nikolay N. Igotti <inn@sparc.spb.su>
|
||||
*/
|
||||
|
||||
#ifndef _common_h
|
||||
#define _common_h
|
||||
#include "npapi.h"
|
||||
/***********************************************************************
|
||||
* Instance state information about the plugin.
|
||||
*
|
||||
* PLUGIN DEVELOPERS:
|
||||
* Use this struct to hold per-instance information that you'll
|
||||
* need in the various functions in this file.
|
||||
***********************************************************************/
|
||||
|
||||
typedef struct _PluginInstance
|
||||
{
|
||||
void* info; /* really "this" */
|
||||
NPP m_peer;
|
||||
jint m_id;
|
||||
jint m_wid;
|
||||
int16 m_argc;
|
||||
char** m_argn;
|
||||
char** m_argv;
|
||||
char* m_docbase;
|
||||
} PluginInstance;
|
||||
|
||||
typedef struct _GlobalData
|
||||
{
|
||||
#ifdef XP_UNIX
|
||||
Display* m_dpy;
|
||||
/* message queue ID of shared memory transport in host -> JVM direction */
|
||||
int m_msgid;
|
||||
/* message queue ID of shared memory transport in JVM -> host direction */
|
||||
int m_msgid1;
|
||||
/* XID of widget used to notify browser about our requests */
|
||||
XID m_xid;
|
||||
#endif
|
||||
} GlobalData;
|
||||
|
||||
#define PE_NOPE 0
|
||||
#define PE_CREATE 1
|
||||
#define PE_SETWINDOW 2
|
||||
#define PE_DESTROY 3
|
||||
#define PE_START 4
|
||||
#define PE_STOP 5
|
||||
#define PE_NEWPARAMS 6
|
||||
#define PE_SETTYPE 7
|
||||
|
||||
#define PV_UNKNOWN 0
|
||||
#define PV_MOZILLA6 1
|
||||
#define PV_MOZILLA4 2
|
||||
|
||||
#define PT_UNKNOWN 0
|
||||
#define PT_EMBED 1
|
||||
#define PT_OBJECT 2
|
||||
#define PT_APPLET 3
|
||||
#define PT_PLUGLET 4
|
||||
|
||||
#define WFNetscape4VendorID 2 /* Netscape 4 */
|
||||
#define WFNetscape4ExtVersion 1
|
||||
|
||||
#endif
|
||||
@@ -1,667 +0,0 @@
|
||||
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
||||
*
|
||||
* The contents of this file are subject to the Mozilla Public
|
||||
* License Version 1.1 (the "License"); you may not use this file
|
||||
* except in compliance with the License. You may obtain a copy of
|
||||
* the License at http://www.mozilla.org/MPL/
|
||||
*
|
||||
* Software distributed under the License is distributed on an "AS
|
||||
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* The Original Code is The Waterfall Java Plugin Module
|
||||
*
|
||||
* The Initial Developer of the Original Code is Sun Microsystems Inc
|
||||
* Portions created by Sun Microsystems Inc are Copyright (C) 2001
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* $Id: jri.h,v 1.1.1.1 2001-05-10 18:12:36 edburns%acm.org Exp $
|
||||
*
|
||||
*
|
||||
* Contributor(s):
|
||||
*
|
||||
* Nikolay N. Igotti <inn@sparc.spb.su>
|
||||
*/
|
||||
|
||||
/* -*- Mode: C; tab-width: 4; -*- */
|
||||
/*******************************************************************************
|
||||
* Java Runtime Interface
|
||||
* Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
|
||||
******************************************************************************/
|
||||
|
||||
#ifndef JRI_H
|
||||
#define JRI_H
|
||||
|
||||
#include "jritypes.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/*******************************************************************************
|
||||
* JRIEnv
|
||||
******************************************************************************/
|
||||
|
||||
/* The type of the JRIEnv interface. */
|
||||
typedef struct JRIEnvInterface JRIEnvInterface;
|
||||
|
||||
/* The type of a JRIEnv instance. */
|
||||
typedef const JRIEnvInterface* JRIEnv;
|
||||
|
||||
/*******************************************************************************
|
||||
* JRIEnv Operations
|
||||
******************************************************************************/
|
||||
|
||||
#define JRI_DefineClass(env, classLoader, buf, bufLen) \
|
||||
(((*(env))->DefineClass)(env, JRI_DefineClass_op, classLoader, buf, bufLen))
|
||||
|
||||
#define JRI_FindClass(env, name) \
|
||||
(((*(env))->FindClass)(env, JRI_FindClass_op, name))
|
||||
|
||||
#define JRI_Throw(env, obj) \
|
||||
(((*(env))->Throw)(env, JRI_Throw_op, obj))
|
||||
|
||||
#define JRI_ThrowNew(env, clazz, message) \
|
||||
(((*(env))->ThrowNew)(env, JRI_ThrowNew_op, clazz, message))
|
||||
|
||||
#define JRI_ExceptionOccurred(env) \
|
||||
(((*(env))->ExceptionOccurred)(env, JRI_ExceptionOccurred_op))
|
||||
|
||||
#define JRI_ExceptionDescribe(env) \
|
||||
(((*(env))->ExceptionDescribe)(env, JRI_ExceptionDescribe_op))
|
||||
|
||||
#define JRI_ExceptionClear(env) \
|
||||
(((*(env))->ExceptionClear)(env, JRI_ExceptionClear_op))
|
||||
|
||||
#define JRI_NewGlobalRef(env, ref) \
|
||||
(((*(env))->NewGlobalRef)(env, JRI_NewGlobalRef_op, ref))
|
||||
|
||||
#define JRI_DisposeGlobalRef(env, gref) \
|
||||
(((*(env))->DisposeGlobalRef)(env, JRI_DisposeGlobalRef_op, gref))
|
||||
|
||||
#define JRI_GetGlobalRef(env, gref) \
|
||||
(((*(env))->GetGlobalRef)(env, JRI_GetGlobalRef_op, gref))
|
||||
|
||||
#define JRI_SetGlobalRef(env, gref, ref) \
|
||||
(((*(env))->SetGlobalRef)(env, JRI_SetGlobalRef_op, gref, ref))
|
||||
|
||||
#define JRI_IsSameObject(env, a, b) \
|
||||
(((*(env))->IsSameObject)(env, JRI_IsSameObject_op, a, b))
|
||||
|
||||
#define JRI_NewObject(env) ((*(env))->NewObject)
|
||||
#define JRI_NewObjectV(env, clazz, methodID, args) \
|
||||
(((*(env))->NewObjectV)(env, JRI_NewObject_op_va_list, clazz, methodID, args))
|
||||
#define JRI_NewObjectA(env, clazz, method, args) \
|
||||
(((*(env))->NewObjectA)(env, JRI_NewObject_op_array, clazz, methodID, args))
|
||||
|
||||
#define JRI_GetObjectClass(env, obj) \
|
||||
(((*(env))->GetObjectClass)(env, JRI_GetObjectClass_op, obj))
|
||||
|
||||
#define JRI_IsInstanceOf(env, obj, clazz) \
|
||||
(((*(env))->IsInstanceOf)(env, JRI_IsInstanceOf_op, obj, clazz))
|
||||
|
||||
#define JRI_GetMethodID(env, clazz, name, sig) \
|
||||
(((*(env))->GetMethodID)(env, JRI_GetMethodID_op, clazz, name, sig))
|
||||
|
||||
#define JRI_CallMethod(env) ((*(env))->CallMethod)
|
||||
#define JRI_CallMethodV(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodV)(env, JRI_CallMethod_op_va_list, obj, methodID, args))
|
||||
#define JRI_CallMethodA(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodA)(env, JRI_CallMethod_op_array, obj, methodID, args))
|
||||
|
||||
#define JRI_CallMethodBoolean(env) ((*(env))->CallMethodBoolean)
|
||||
#define JRI_CallMethodBooleanV(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodBooleanV)(env, JRI_CallMethodBoolean_op_va_list, obj, methodID, args))
|
||||
#define JRI_CallMethodBooleanA(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodBooleanA)(env, JRI_CallMethodBoolean_op_array, obj, methodID, args))
|
||||
|
||||
#define JRI_CallMethodByte(env) ((*(env))->CallMethodByte)
|
||||
#define JRI_CallMethodByteV(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodByteV)(env, JRI_CallMethodByte_op_va_list, obj, methodID, args))
|
||||
#define JRI_CallMethodByteA(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodByteA)(env, JRI_CallMethodByte_op_array, obj, methodID, args))
|
||||
|
||||
#define JRI_CallMethodChar(env) ((*(env))->CallMethodChar)
|
||||
#define JRI_CallMethodCharV(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodCharV)(env, JRI_CallMethodChar_op_va_list, obj, methodID, args))
|
||||
#define JRI_CallMethodCharA(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodCharA)(env, JRI_CallMethodChar_op_array, obj, methodID, args))
|
||||
|
||||
#define JRI_CallMethodShort(env) ((*(env))->CallMethodShort)
|
||||
#define JRI_CallMethodShortV(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodShortV)(env, JRI_CallMethodShort_op_va_list, obj, methodID, args))
|
||||
#define JRI_CallMethodShortA(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodShortA)(env, JRI_CallMethodShort_op_array, obj, methodID, args))
|
||||
|
||||
#define JRI_CallMethodInt(env) ((*(env))->CallMethodInt)
|
||||
#define JRI_CallMethodIntV(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodIntV)(env, JRI_CallMethodInt_op_va_list, obj, methodID, args))
|
||||
#define JRI_CallMethodIntA(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodIntA)(env, JRI_CallMethodInt_op_array, obj, methodID, args))
|
||||
|
||||
#define JRI_CallMethodLong(env) ((*(env))->CallMethodLong)
|
||||
#define JRI_CallMethodLongV(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodLongV)(env, JRI_CallMethodLong_op_va_list, obj, methodID, args))
|
||||
#define JRI_CallMethodLongA(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodLongA)(env, JRI_CallMethodLong_op_array, obj, methodID, args))
|
||||
|
||||
#define JRI_CallMethodFloat(env) ((*(env))->CallMethodFloat)
|
||||
#define JRI_CallMethodFloatV(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodFloatV)(env, JRI_CallMethodFloat_op_va_list, obj, methodID, args))
|
||||
#define JRI_CallMethodFloatA(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodFloatA)(env, JRI_CallMethodFloat_op_array, obj, methodID, args))
|
||||
|
||||
#define JRI_CallMethodDouble(env) ((*(env))->CallMethodDouble)
|
||||
#define JRI_CallMethodDoubleV(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodDoubleV)(env, JRI_CallMethodDouble_op_va_list, obj, methodID, args))
|
||||
#define JRI_CallMethodDoubleA(env, obj, methodID, args) \
|
||||
(((*(env))->CallMethodDoubleA)(env, JRI_CallMethodDouble_op_array, obj, methodID, args))
|
||||
|
||||
#define JRI_GetFieldID(env, clazz, name, sig) \
|
||||
(((*(env))->GetFieldID)(env, JRI_GetFieldID_op, clazz, name, sig))
|
||||
|
||||
#define JRI_GetField(env, obj, fieldID) \
|
||||
(((*(env))->GetField)(env, JRI_GetField_op, obj, fieldID))
|
||||
|
||||
#define JRI_GetFieldBoolean(env, obj, fieldID) \
|
||||
(((*(env))->GetFieldBoolean)(env, JRI_GetFieldBoolean_op, obj, fieldID))
|
||||
|
||||
#define JRI_GetFieldByte(env, obj, fieldID) \
|
||||
(((*(env))->GetFieldByte)(env, JRI_GetFieldByte_op, obj, fieldID))
|
||||
|
||||
#define JRI_GetFieldChar(env, obj, fieldID) \
|
||||
(((*(env))->GetFieldChar)(env, JRI_GetFieldChar_op, obj, fieldID))
|
||||
|
||||
#define JRI_GetFieldShort(env, obj, fieldID) \
|
||||
(((*(env))->GetFieldShort)(env, JRI_GetFieldShort_op, obj, fieldID))
|
||||
|
||||
#define JRI_GetFieldInt(env, obj, fieldID) \
|
||||
(((*(env))->GetFieldInt)(env, JRI_GetFieldInt_op, obj, fieldID))
|
||||
|
||||
#define JRI_GetFieldLong(env, obj, fieldID) \
|
||||
(((*(env))->GetFieldLong)(env, JRI_GetFieldLong_op, obj, fieldID))
|
||||
|
||||
#define JRI_GetFieldFloat(env, obj, fieldID) \
|
||||
(((*(env))->GetFieldFloat)(env, JRI_GetFieldFloat_op, obj, fieldID))
|
||||
|
||||
#define JRI_GetFieldDouble(env, obj, fieldID) \
|
||||
(((*(env))->GetFieldDouble)(env, JRI_GetFieldDouble_op, obj, fieldID))
|
||||
|
||||
#define JRI_SetField(env, obj, fieldID, value) \
|
||||
(((*(env))->SetField)(env, JRI_SetField_op, obj, fieldID, value))
|
||||
|
||||
#define JRI_SetFieldBoolean(env, obj, fieldID, value) \
|
||||
(((*(env))->SetFieldBoolean)(env, JRI_SetFieldBoolean_op, obj, fieldID, value))
|
||||
|
||||
#define JRI_SetFieldByte(env, obj, fieldID, value) \
|
||||
(((*(env))->SetFieldByte)(env, JRI_SetFieldByte_op, obj, fieldID, value))
|
||||
|
||||
#define JRI_SetFieldChar(env, obj, fieldID, value) \
|
||||
(((*(env))->SetFieldChar)(env, JRI_SetFieldChar_op, obj, fieldID, value))
|
||||
|
||||
#define JRI_SetFieldShort(env, obj, fieldID, value) \
|
||||
(((*(env))->SetFieldShort)(env, JRI_SetFieldShort_op, obj, fieldID, value))
|
||||
|
||||
#define JRI_SetFieldInt(env, obj, fieldID, value) \
|
||||
(((*(env))->SetFieldInt)(env, JRI_SetFieldInt_op, obj, fieldID, value))
|
||||
|
||||
#define JRI_SetFieldLong(env, obj, fieldID, value) \
|
||||
(((*(env))->SetFieldLong)(env, JRI_SetFieldLong_op, obj, fieldID, value))
|
||||
|
||||
#define JRI_SetFieldFloat(env, obj, fieldID, value) \
|
||||
(((*(env))->SetFieldFloat)(env, JRI_SetFieldFloat_op, obj, fieldID, value))
|
||||
|
||||
#define JRI_SetFieldDouble(env, obj, fieldID, value) \
|
||||
(((*(env))->SetFieldDouble)(env, JRI_SetFieldDouble_op, obj, fieldID, value))
|
||||
|
||||
#define JRI_IsSubclassOf(env, a, b) \
|
||||
(((*(env))->IsSubclassOf)(env, JRI_IsSubclassOf_op, a, b))
|
||||
|
||||
#define JRI_GetStaticMethodID(env, clazz, name, sig) \
|
||||
(((*(env))->GetStaticMethodID)(env, JRI_GetStaticMethodID_op, clazz, name, sig))
|
||||
|
||||
#define JRI_CallStaticMethod(env) ((*(env))->CallStaticMethod)
|
||||
#define JRI_CallStaticMethodV(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodV)(env, JRI_CallStaticMethod_op_va_list, clazz, methodID, args))
|
||||
#define JRI_CallStaticMethodA(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodA)(env, JRI_CallStaticMethod_op_array, clazz, methodID, args))
|
||||
|
||||
#define JRI_CallStaticMethodBoolean(env) ((*(env))->CallStaticMethodBoolean)
|
||||
#define JRI_CallStaticMethodBooleanV(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodBooleanV)(env, JRI_CallStaticMethodBoolean_op_va_list, clazz, methodID, args))
|
||||
#define JRI_CallStaticMethodBooleanA(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodBooleanA)(env, JRI_CallStaticMethodBoolean_op_array, clazz, methodID, args))
|
||||
|
||||
#define JRI_CallStaticMethodByte(env) ((*(env))->CallStaticMethodByte)
|
||||
#define JRI_CallStaticMethodByteV(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodByteV)(env, JRI_CallStaticMethodByte_op_va_list, clazz, methodID, args))
|
||||
#define JRI_CallStaticMethodByteA(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodByteA)(env, JRI_CallStaticMethodByte_op_array, clazz, methodID, args))
|
||||
|
||||
#define JRI_CallStaticMethodChar(env) ((*(env))->CallStaticMethodChar)
|
||||
#define JRI_CallStaticMethodCharV(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodCharV)(env, JRI_CallStaticMethodChar_op_va_list, clazz, methodID, args))
|
||||
#define JRI_CallStaticMethodCharA(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodCharA)(env, JRI_CallStaticMethodChar_op_array, clazz, methodID, args))
|
||||
|
||||
#define JRI_CallStaticMethodShort(env) ((*(env))->CallStaticMethodShort)
|
||||
#define JRI_CallStaticMethodShortV(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodShortV)(env, JRI_CallStaticMethodShort_op_va_list, clazz, methodID, args))
|
||||
#define JRI_CallStaticMethodShortA(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodShortA)(env, JRI_CallStaticMethodShort_op_array, clazz, methodID, args))
|
||||
|
||||
#define JRI_CallStaticMethodInt(env) ((*(env))->CallStaticMethodInt)
|
||||
#define JRI_CallStaticMethodIntV(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodIntV)(env, JRI_CallStaticMethodInt_op_va_list, clazz, methodID, args))
|
||||
#define JRI_CallStaticMethodIntA(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodIntA)(env, JRI_CallStaticMethodInt_op_array, clazz, methodID, args))
|
||||
|
||||
#define JRI_CallStaticMethodLong(env) ((*(env))->CallStaticMethodLong)
|
||||
#define JRI_CallStaticMethodLongV(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodLongV)(env, JRI_CallStaticMethodLong_op_va_list, clazz, methodID, args))
|
||||
#define JRI_CallStaticMethodLongA(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodLongA)(env, JRI_CallStaticMethodLong_op_array, clazz, methodID, args))
|
||||
|
||||
#define JRI_CallStaticMethodFloat(env) ((*(env))->CallStaticMethodFloat)
|
||||
#define JRI_CallStaticMethodFloatV(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodFloatV)(env, JRI_CallStaticMethodFloat_op_va_list, clazz, methodID, args))
|
||||
#define JRI_CallStaticMethodFloatA(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodFloatA)(env, JRI_CallStaticMethodFloat_op_array, clazz, methodID, args))
|
||||
|
||||
#define JRI_CallStaticMethodDouble(env) ((*(env))->CallStaticMethodDouble)
|
||||
#define JRI_CallStaticMethodDoubleV(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodDoubleV)(env, JRI_CallStaticMethodDouble_op_va_list, clazz, methodID, args))
|
||||
#define JRI_CallStaticMethodDoubleA(env, clazz, methodID, args) \
|
||||
(((*(env))->CallStaticMethodDoubleA)(env, JRI_CallStaticMethodDouble_op_array, clazz, methodID, args))
|
||||
|
||||
#define JRI_GetStaticFieldID(env, clazz, name, sig) \
|
||||
(((*(env))->GetStaticFieldID)(env, JRI_GetStaticFieldID_op, clazz, name, sig))
|
||||
|
||||
#define JRI_GetStaticField(env, clazz, fieldID) \
|
||||
(((*(env))->GetStaticField)(env, JRI_GetStaticField_op, clazz, fieldID))
|
||||
|
||||
#define JRI_GetStaticFieldBoolean(env, clazz, fieldID) \
|
||||
(((*(env))->GetStaticFieldBoolean)(env, JRI_GetStaticFieldBoolean_op, clazz, fieldID))
|
||||
|
||||
#define JRI_GetStaticFieldByte(env, clazz, fieldID) \
|
||||
(((*(env))->GetStaticFieldByte)(env, JRI_GetStaticFieldByte_op, clazz, fieldID))
|
||||
|
||||
#define JRI_GetStaticFieldChar(env, clazz, fieldID) \
|
||||
(((*(env))->GetStaticFieldChar)(env, JRI_GetStaticFieldChar_op, clazz, fieldID))
|
||||
|
||||
#define JRI_GetStaticFieldShort(env, clazz, fieldID) \
|
||||
(((*(env))->GetStaticFieldShort)(env, JRI_GetStaticFieldShort_op, clazz, fieldID))
|
||||
|
||||
#define JRI_GetStaticFieldInt(env, clazz, fieldID) \
|
||||
(((*(env))->GetStaticFieldInt)(env, JRI_GetStaticFieldInt_op, clazz, fieldID))
|
||||
|
||||
#define JRI_GetStaticFieldLong(env, clazz, fieldID) \
|
||||
(((*(env))->GetStaticFieldLong)(env, JRI_GetStaticFieldLong_op, clazz, fieldID))
|
||||
|
||||
#define JRI_GetStaticFieldFloat(env, clazz, fieldID) \
|
||||
(((*(env))->GetStaticFieldFloat)(env, JRI_GetStaticFieldFloat_op, clazz, fieldID))
|
||||
|
||||
#define JRI_GetStaticFieldDouble(env, clazz, fieldID) \
|
||||
(((*(env))->GetStaticFieldDouble)(env, JRI_GetStaticFieldDouble_op, clazz, fieldID))
|
||||
|
||||
#define JRI_SetStaticField(env, clazz, fieldID, value) \
|
||||
(((*(env))->SetStaticField)(env, JRI_SetStaticField_op, clazz, fieldID, value))
|
||||
|
||||
#define JRI_SetStaticFieldBoolean(env, clazz, fieldID, value) \
|
||||
(((*(env))->SetStaticFieldBoolean)(env, JRI_SetStaticFieldBoolean_op, clazz, fieldID, value))
|
||||
|
||||
#define JRI_SetStaticFieldByte(env, clazz, fieldID, value) \
|
||||
(((*(env))->SetStaticFieldByte)(env, JRI_SetStaticFieldByte_op, clazz, fieldID, value))
|
||||
|
||||
#define JRI_SetStaticFieldChar(env, clazz, fieldID, value) \
|
||||
(((*(env))->SetStaticFieldChar)(env, JRI_SetStaticFieldChar_op, clazz, fieldID, value))
|
||||
|
||||
#define JRI_SetStaticFieldShort(env, clazz, fieldID, value) \
|
||||
(((*(env))->SetStaticFieldShort)(env, JRI_SetStaticFieldShort_op, clazz, fieldID, value))
|
||||
|
||||
#define JRI_SetStaticFieldInt(env, clazz, fieldID, value) \
|
||||
(((*(env))->SetStaticFieldInt)(env, JRI_SetStaticFieldInt_op, clazz, fieldID, value))
|
||||
|
||||
#define JRI_SetStaticFieldLong(env, clazz, fieldID, value) \
|
||||
(((*(env))->SetStaticFieldLong)(env, JRI_SetStaticFieldLong_op, clazz, fieldID, value))
|
||||
|
||||
#define JRI_SetStaticFieldFloat(env, clazz, fieldID, value) \
|
||||
(((*(env))->SetStaticFieldFloat)(env, JRI_SetStaticFieldFloat_op, clazz, fieldID, value))
|
||||
|
||||
#define JRI_SetStaticFieldDouble(env, clazz, fieldID, value) \
|
||||
(((*(env))->SetStaticFieldDouble)(env, JRI_SetStaticFieldDouble_op, clazz, fieldID, value))
|
||||
|
||||
#define JRI_NewString(env, unicode, len) \
|
||||
(((*(env))->NewString)(env, JRI_NewString_op, unicode, len))
|
||||
|
||||
#define JRI_GetStringLength(env, string) \
|
||||
(((*(env))->GetStringLength)(env, JRI_GetStringLength_op, string))
|
||||
|
||||
#define JRI_GetStringChars(env, string) \
|
||||
(((*(env))->GetStringChars)(env, JRI_GetStringChars_op, string))
|
||||
|
||||
#define JRI_NewStringUTF(env, utf, len) \
|
||||
(((*(env))->NewStringUTF)(env, JRI_NewStringUTF_op, utf, len))
|
||||
|
||||
#define JRI_GetStringUTFLength(env, string) \
|
||||
(((*(env))->GetStringUTFLength)(env, JRI_GetStringUTFLength_op, string))
|
||||
|
||||
#define JRI_GetStringUTFChars(env, string) \
|
||||
(((*(env))->GetStringUTFChars)(env, JRI_GetStringUTFChars_op, string))
|
||||
|
||||
#define JRI_NewScalarArray(env, length, elementSig, initialElements) \
|
||||
(((*(env))->NewScalarArray)(env, JRI_NewScalarArray_op, length, elementSig, initialElements))
|
||||
|
||||
#define JRI_GetScalarArrayLength(env, array) \
|
||||
(((*(env))->GetScalarArrayLength)(env, JRI_GetScalarArrayLength_op, array))
|
||||
|
||||
#define JRI_GetScalarArrayElements(env, array) \
|
||||
(((*(env))->GetScalarArrayElements)(env, JRI_GetScalarArrayElements_op, array))
|
||||
|
||||
#define JRI_NewObjectArray(env, length, elementClass, initialElement) \
|
||||
(((*(env))->NewObjectArray)(env, JRI_NewObjectArray_op, length, elementClass, initialElement))
|
||||
|
||||
#define JRI_GetObjectArrayLength(env, array) \
|
||||
(((*(env))->GetObjectArrayLength)(env, JRI_GetObjectArrayLength_op, array))
|
||||
|
||||
#define JRI_GetObjectArrayElement(env, array, index) \
|
||||
(((*(env))->GetObjectArrayElement)(env, JRI_GetObjectArrayElement_op, array, index))
|
||||
|
||||
#define JRI_SetObjectArrayElement(env, array, index, value) \
|
||||
(((*(env))->SetObjectArrayElement)(env, JRI_SetObjectArrayElement_op, array, index, value))
|
||||
|
||||
#define JRI_RegisterNatives(env, clazz, nameAndSigArray, nativeProcArray) \
|
||||
(((*(env))->RegisterNatives)(env, JRI_RegisterNatives_op, clazz, nameAndSigArray, nativeProcArray))
|
||||
|
||||
#define JRI_UnregisterNatives(env, clazz) \
|
||||
(((*(env))->UnregisterNatives)(env, JRI_UnregisterNatives_op, clazz))
|
||||
|
||||
/*******************************************************************************
|
||||
* JRIEnv Interface
|
||||
******************************************************************************/
|
||||
|
||||
struct java_lang_ClassLoader;
|
||||
struct java_lang_Class;
|
||||
struct java_lang_Throwable;
|
||||
struct java_lang_Object;
|
||||
struct java_lang_String;
|
||||
|
||||
struct JRIEnvInterface {
|
||||
void* reserved0;
|
||||
void* reserved1;
|
||||
void* reserved2;
|
||||
void* reserved3;
|
||||
struct java_lang_Class* (*FindClass)(JRIEnv* env, jint op, const char* a);
|
||||
void (*Throw)(JRIEnv* env, jint op, struct java_lang_Throwable* a);
|
||||
void (*ThrowNew)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b);
|
||||
struct java_lang_Throwable* (*ExceptionOccurred)(JRIEnv* env, jint op);
|
||||
void (*ExceptionDescribe)(JRIEnv* env, jint op);
|
||||
void (*ExceptionClear)(JRIEnv* env, jint op);
|
||||
jglobal (*NewGlobalRef)(JRIEnv* env, jint op, void* a);
|
||||
void (*DisposeGlobalRef)(JRIEnv* env, jint op, jglobal a);
|
||||
void* (*GetGlobalRef)(JRIEnv* env, jint op, jglobal a);
|
||||
void (*SetGlobalRef)(JRIEnv* env, jint op, jglobal a, void* b);
|
||||
jbool (*IsSameObject)(JRIEnv* env, jint op, void* a, void* b);
|
||||
void* (*NewObject)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...);
|
||||
void* (*NewObjectV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c);
|
||||
void* (*NewObjectA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c);
|
||||
struct java_lang_Class* (*GetObjectClass)(JRIEnv* env, jint op, void* a);
|
||||
jbool (*IsInstanceOf)(JRIEnv* env, jint op, void* a, struct java_lang_Class* b);
|
||||
jint (*GetMethodID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c);
|
||||
void* (*CallMethod)(JRIEnv* env, jint op, void* a, jint b, ...);
|
||||
void* (*CallMethodV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
|
||||
void* (*CallMethodA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
|
||||
jbool (*CallMethodBoolean)(JRIEnv* env, jint op, void* a, jint b, ...);
|
||||
jbool (*CallMethodBooleanV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
|
||||
jbool (*CallMethodBooleanA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
|
||||
jbyte (*CallMethodByte)(JRIEnv* env, jint op, void* a, jint b, ...);
|
||||
jbyte (*CallMethodByteV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
|
||||
jbyte (*CallMethodByteA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
|
||||
jchar (*CallMethodChar)(JRIEnv* env, jint op, void* a, jint b, ...);
|
||||
jchar (*CallMethodCharV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
|
||||
jchar (*CallMethodCharA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
|
||||
jshort (*CallMethodShort)(JRIEnv* env, jint op, void* a, jint b, ...);
|
||||
jshort (*CallMethodShortV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
|
||||
jshort (*CallMethodShortA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
|
||||
jint (*CallMethodInt)(JRIEnv* env, jint op, void* a, jint b, ...);
|
||||
jint (*CallMethodIntV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
|
||||
jint (*CallMethodIntA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
|
||||
jlong (*CallMethodLong)(JRIEnv* env, jint op, void* a, jint b, ...);
|
||||
jlong (*CallMethodLongV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
|
||||
jlong (*CallMethodLongA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
|
||||
jfloat (*CallMethodFloat)(JRIEnv* env, jint op, void* a, jint b, ...);
|
||||
jfloat (*CallMethodFloatV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
|
||||
jfloat (*CallMethodFloatA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
|
||||
jdouble (*CallMethodDouble)(JRIEnv* env, jint op, void* a, jint b, ...);
|
||||
jdouble (*CallMethodDoubleV)(JRIEnv* env, jint op, void* a, jint b, va_list c);
|
||||
jdouble (*CallMethodDoubleA)(JRIEnv* env, jint op, void* a, jint b, JRIValue* c);
|
||||
jint (*GetFieldID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c);
|
||||
void* (*GetField)(JRIEnv* env, jint op, void* a, jint b);
|
||||
jbool (*GetFieldBoolean)(JRIEnv* env, jint op, void* a, jint b);
|
||||
jbyte (*GetFieldByte)(JRIEnv* env, jint op, void* a, jint b);
|
||||
jchar (*GetFieldChar)(JRIEnv* env, jint op, void* a, jint b);
|
||||
jshort (*GetFieldShort)(JRIEnv* env, jint op, void* a, jint b);
|
||||
jint (*GetFieldInt)(JRIEnv* env, jint op, void* a, jint b);
|
||||
jlong (*GetFieldLong)(JRIEnv* env, jint op, void* a, jint b);
|
||||
jfloat (*GetFieldFloat)(JRIEnv* env, jint op, void* a, jint b);
|
||||
jdouble (*GetFieldDouble)(JRIEnv* env, jint op, void* a, jint b);
|
||||
void (*SetField)(JRIEnv* env, jint op, void* a, jint b, void* c);
|
||||
void (*SetFieldBoolean)(JRIEnv* env, jint op, void* a, jint b, jbool c);
|
||||
void (*SetFieldByte)(JRIEnv* env, jint op, void* a, jint b, jbyte c);
|
||||
void (*SetFieldChar)(JRIEnv* env, jint op, void* a, jint b, jchar c);
|
||||
void (*SetFieldShort)(JRIEnv* env, jint op, void* a, jint b, jshort c);
|
||||
void (*SetFieldInt)(JRIEnv* env, jint op, void* a, jint b, jint c);
|
||||
void (*SetFieldLong)(JRIEnv* env, jint op, void* a, jint b, jlong c);
|
||||
void (*SetFieldFloat)(JRIEnv* env, jint op, void* a, jint b, jfloat c);
|
||||
void (*SetFieldDouble)(JRIEnv* env, jint op, void* a, jint b, jdouble c);
|
||||
jbool (*IsSubclassOf)(JRIEnv* env, jint op, struct java_lang_Class* a, struct java_lang_Class* b);
|
||||
jint (*GetStaticMethodID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c);
|
||||
void* (*CallStaticMethod)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...);
|
||||
void* (*CallStaticMethodV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c);
|
||||
void* (*CallStaticMethodA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c);
|
||||
jbool (*CallStaticMethodBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...);
|
||||
jbool (*CallStaticMethodBooleanV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c);
|
||||
jbool (*CallStaticMethodBooleanA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c);
|
||||
jbyte (*CallStaticMethodByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...);
|
||||
jbyte (*CallStaticMethodByteV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c);
|
||||
jbyte (*CallStaticMethodByteA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c);
|
||||
jchar (*CallStaticMethodChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...);
|
||||
jchar (*CallStaticMethodCharV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c);
|
||||
jchar (*CallStaticMethodCharA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c);
|
||||
jshort (*CallStaticMethodShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...);
|
||||
jshort (*CallStaticMethodShortV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c);
|
||||
jshort (*CallStaticMethodShortA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c);
|
||||
jint (*CallStaticMethodInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...);
|
||||
jint (*CallStaticMethodIntV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c);
|
||||
jint (*CallStaticMethodIntA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c);
|
||||
jlong (*CallStaticMethodLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...);
|
||||
jlong (*CallStaticMethodLongV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c);
|
||||
jlong (*CallStaticMethodLongA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c);
|
||||
jfloat (*CallStaticMethodFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...);
|
||||
jfloat (*CallStaticMethodFloatV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c);
|
||||
jfloat (*CallStaticMethodFloatA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c);
|
||||
jdouble (*CallStaticMethodDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, ...);
|
||||
jdouble (*CallStaticMethodDoubleV)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, va_list c);
|
||||
jdouble (*CallStaticMethodDoubleA)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, JRIValue* c);
|
||||
jint (*GetStaticFieldID)(JRIEnv* env, jint op, struct java_lang_Class* a, const char* b, const char* c);
|
||||
void* (*GetStaticField)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b);
|
||||
jbool (*GetStaticFieldBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b);
|
||||
jbyte (*GetStaticFieldByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b);
|
||||
jchar (*GetStaticFieldChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b);
|
||||
jshort (*GetStaticFieldShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b);
|
||||
jint (*GetStaticFieldInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b);
|
||||
jlong (*GetStaticFieldLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b);
|
||||
jfloat (*GetStaticFieldFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b);
|
||||
jdouble (*GetStaticFieldDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b);
|
||||
void (*SetStaticField)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, void* c);
|
||||
void (*SetStaticFieldBoolean)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jbool c);
|
||||
void (*SetStaticFieldByte)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jbyte c);
|
||||
void (*SetStaticFieldChar)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jchar c);
|
||||
void (*SetStaticFieldShort)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jshort c);
|
||||
void (*SetStaticFieldInt)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jint c);
|
||||
void (*SetStaticFieldLong)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jlong c);
|
||||
void (*SetStaticFieldFloat)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jfloat c);
|
||||
void (*SetStaticFieldDouble)(JRIEnv* env, jint op, struct java_lang_Class* a, jint b, jdouble c);
|
||||
struct java_lang_String* (*NewString)(JRIEnv* env, jint op, const jchar* a, jint b);
|
||||
jint (*GetStringLength)(JRIEnv* env, jint op, struct java_lang_String* a);
|
||||
const jchar* (*GetStringChars)(JRIEnv* env, jint op, struct java_lang_String* a);
|
||||
struct java_lang_String* (*NewStringUTF)(JRIEnv* env, jint op, const jbyte* a, jint b);
|
||||
jint (*GetStringUTFLength)(JRIEnv* env, jint op, struct java_lang_String* a);
|
||||
const jbyte* (*GetStringUTFChars)(JRIEnv* env, jint op, struct java_lang_String* a);
|
||||
void* (*NewScalarArray)(JRIEnv* env, jint op, jint a, const char* b, const jbyte* c);
|
||||
jint (*GetScalarArrayLength)(JRIEnv* env, jint op, void* a);
|
||||
jbyte* (*GetScalarArrayElements)(JRIEnv* env, jint op, void* a);
|
||||
void* (*NewObjectArray)(JRIEnv* env, jint op, jint a, struct java_lang_Class* b, void* c);
|
||||
jint (*GetObjectArrayLength)(JRIEnv* env, jint op, void* a);
|
||||
void* (*GetObjectArrayElement)(JRIEnv* env, jint op, void* a, jint b);
|
||||
void (*SetObjectArrayElement)(JRIEnv* env, jint op, void* a, jint b, void* c);
|
||||
void (*RegisterNatives)(JRIEnv* env, jint op, struct java_lang_Class* a, char** b, void** c);
|
||||
void (*UnregisterNatives)(JRIEnv* env, jint op, struct java_lang_Class* a);
|
||||
struct java_lang_Class* (*DefineClass)(JRIEnv* env, jint op, struct java_lang_ClassLoader* a, jbyte* b, jsize bLen);
|
||||
};
|
||||
|
||||
/*******************************************************************************
|
||||
* JRIEnv Operation IDs
|
||||
******************************************************************************/
|
||||
|
||||
typedef enum JRIEnvOperations {
|
||||
JRI_Reserved0_op,
|
||||
JRI_Reserved1_op,
|
||||
JRI_Reserved2_op,
|
||||
JRI_Reserved3_op,
|
||||
JRI_FindClass_op,
|
||||
JRI_Throw_op,
|
||||
JRI_ThrowNew_op,
|
||||
JRI_ExceptionOccurred_op,
|
||||
JRI_ExceptionDescribe_op,
|
||||
JRI_ExceptionClear_op,
|
||||
JRI_NewGlobalRef_op,
|
||||
JRI_DisposeGlobalRef_op,
|
||||
JRI_GetGlobalRef_op,
|
||||
JRI_SetGlobalRef_op,
|
||||
JRI_IsSameObject_op,
|
||||
JRI_NewObject_op,
|
||||
JRI_NewObject_op_va_list,
|
||||
JRI_NewObject_op_array,
|
||||
JRI_GetObjectClass_op,
|
||||
JRI_IsInstanceOf_op,
|
||||
JRI_GetMethodID_op,
|
||||
JRI_CallMethod_op,
|
||||
JRI_CallMethod_op_va_list,
|
||||
JRI_CallMethod_op_array,
|
||||
JRI_CallMethodBoolean_op,
|
||||
JRI_CallMethodBoolean_op_va_list,
|
||||
JRI_CallMethodBoolean_op_array,
|
||||
JRI_CallMethodByte_op,
|
||||
JRI_CallMethodByte_op_va_list,
|
||||
JRI_CallMethodByte_op_array,
|
||||
JRI_CallMethodChar_op,
|
||||
JRI_CallMethodChar_op_va_list,
|
||||
JRI_CallMethodChar_op_array,
|
||||
JRI_CallMethodShort_op,
|
||||
JRI_CallMethodShort_op_va_list,
|
||||
JRI_CallMethodShort_op_array,
|
||||
JRI_CallMethodInt_op,
|
||||
JRI_CallMethodInt_op_va_list,
|
||||
JRI_CallMethodInt_op_array,
|
||||
JRI_CallMethodLong_op,
|
||||
JRI_CallMethodLong_op_va_list,
|
||||
JRI_CallMethodLong_op_array,
|
||||
JRI_CallMethodFloat_op,
|
||||
JRI_CallMethodFloat_op_va_list,
|
||||
JRI_CallMethodFloat_op_array,
|
||||
JRI_CallMethodDouble_op,
|
||||
JRI_CallMethodDouble_op_va_list,
|
||||
JRI_CallMethodDouble_op_array,
|
||||
JRI_GetFieldID_op,
|
||||
JRI_GetField_op,
|
||||
JRI_GetFieldBoolean_op,
|
||||
JRI_GetFieldByte_op,
|
||||
JRI_GetFieldChar_op,
|
||||
JRI_GetFieldShort_op,
|
||||
JRI_GetFieldInt_op,
|
||||
JRI_GetFieldLong_op,
|
||||
JRI_GetFieldFloat_op,
|
||||
JRI_GetFieldDouble_op,
|
||||
JRI_SetField_op,
|
||||
JRI_SetFieldBoolean_op,
|
||||
JRI_SetFieldByte_op,
|
||||
JRI_SetFieldChar_op,
|
||||
JRI_SetFieldShort_op,
|
||||
JRI_SetFieldInt_op,
|
||||
JRI_SetFieldLong_op,
|
||||
JRI_SetFieldFloat_op,
|
||||
JRI_SetFieldDouble_op,
|
||||
JRI_IsSubclassOf_op,
|
||||
JRI_GetStaticMethodID_op,
|
||||
JRI_CallStaticMethod_op,
|
||||
JRI_CallStaticMethod_op_va_list,
|
||||
JRI_CallStaticMethod_op_array,
|
||||
JRI_CallStaticMethodBoolean_op,
|
||||
JRI_CallStaticMethodBoolean_op_va_list,
|
||||
JRI_CallStaticMethodBoolean_op_array,
|
||||
JRI_CallStaticMethodByte_op,
|
||||
JRI_CallStaticMethodByte_op_va_list,
|
||||
JRI_CallStaticMethodByte_op_array,
|
||||
JRI_CallStaticMethodChar_op,
|
||||
JRI_CallStaticMethodChar_op_va_list,
|
||||
JRI_CallStaticMethodChar_op_array,
|
||||
JRI_CallStaticMethodShort_op,
|
||||
JRI_CallStaticMethodShort_op_va_list,
|
||||
JRI_CallStaticMethodShort_op_array,
|
||||
JRI_CallStaticMethodInt_op,
|
||||
JRI_CallStaticMethodInt_op_va_list,
|
||||
JRI_CallStaticMethodInt_op_array,
|
||||
JRI_CallStaticMethodLong_op,
|
||||
JRI_CallStaticMethodLong_op_va_list,
|
||||
JRI_CallStaticMethodLong_op_array,
|
||||
JRI_CallStaticMethodFloat_op,
|
||||
JRI_CallStaticMethodFloat_op_va_list,
|
||||
JRI_CallStaticMethodFloat_op_array,
|
||||
JRI_CallStaticMethodDouble_op,
|
||||
JRI_CallStaticMethodDouble_op_va_list,
|
||||
JRI_CallStaticMethodDouble_op_array,
|
||||
JRI_GetStaticFieldID_op,
|
||||
JRI_GetStaticField_op,
|
||||
JRI_GetStaticFieldBoolean_op,
|
||||
JRI_GetStaticFieldByte_op,
|
||||
JRI_GetStaticFieldChar_op,
|
||||
JRI_GetStaticFieldShort_op,
|
||||
JRI_GetStaticFieldInt_op,
|
||||
JRI_GetStaticFieldLong_op,
|
||||
JRI_GetStaticFieldFloat_op,
|
||||
JRI_GetStaticFieldDouble_op,
|
||||
JRI_SetStaticField_op,
|
||||
JRI_SetStaticFieldBoolean_op,
|
||||
JRI_SetStaticFieldByte_op,
|
||||
JRI_SetStaticFieldChar_op,
|
||||
JRI_SetStaticFieldShort_op,
|
||||
JRI_SetStaticFieldInt_op,
|
||||
JRI_SetStaticFieldLong_op,
|
||||
JRI_SetStaticFieldFloat_op,
|
||||
JRI_SetStaticFieldDouble_op,
|
||||
JRI_NewString_op,
|
||||
JRI_GetStringLength_op,
|
||||
JRI_GetStringChars_op,
|
||||
JRI_NewStringUTF_op,
|
||||
JRI_GetStringUTFLength_op,
|
||||
JRI_GetStringUTFChars_op,
|
||||
JRI_NewScalarArray_op,
|
||||
JRI_GetScalarArrayLength_op,
|
||||
JRI_GetScalarArrayElements_op,
|
||||
JRI_NewObjectArray_op,
|
||||
JRI_GetObjectArrayLength_op,
|
||||
JRI_GetObjectArrayElement_op,
|
||||
JRI_SetObjectArrayElement_op,
|
||||
JRI_RegisterNatives_op,
|
||||
JRI_UnregisterNatives_op,
|
||||
JRI_DefineClass_op
|
||||
} JRIEnvOperations;
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* JRI_H */
|
||||
/******************************************************************************/
|
||||
@@ -1,196 +0,0 @@
|
||||
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
||||
*
|
||||
* The contents of this file are subject to the Mozilla Public
|
||||
* License Version 1.1 (the "License"); you may not use this file
|
||||
* except in compliance with the License. You may obtain a copy of
|
||||
* the License at http://www.mozilla.org/MPL/
|
||||
*
|
||||
* Software distributed under the License is distributed on an "AS
|
||||
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* The Original Code is The Waterfall Java Plugin Module
|
||||
*
|
||||
* The Initial Developer of the Original Code is Sun Microsystems Inc
|
||||
* Portions created by Sun Microsystems Inc are Copyright (C) 2001
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* $Id: jri_md.h,v 1.1.1.1 2001-05-10 18:12:36 edburns%acm.org Exp $
|
||||
*
|
||||
*
|
||||
* Contributor(s):
|
||||
*
|
||||
* Nikolay N. Igotti <inn@sparc.spb.su>
|
||||
*/
|
||||
|
||||
/* -*- Mode: C; tab-width: 4; -*- */
|
||||
/*******************************************************************************
|
||||
* Java Runtime Interface - Machine Dependent Types
|
||||
* Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
|
||||
******************************************************************************/
|
||||
|
||||
#ifndef JRI_MD_H
|
||||
#define JRI_MD_H
|
||||
|
||||
#include <assert.h>
|
||||
#include "jni.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*******************************************************************************
|
||||
* WHAT'S UP WITH THIS FILE?
|
||||
*
|
||||
* This is where we define the mystical JRI_PUBLIC_API macro that works on all
|
||||
* platforms. If you're running with Visual C++, Symantec C, or Borland's
|
||||
* development environment on the PC, you're all set. Or if you're on the Mac
|
||||
* with Metrowerks, Symantec or MPW with SC you're ok too. For UNIX it shouldn't
|
||||
* matter.
|
||||
*
|
||||
* On UNIX though you probably care about a couple of other symbols though:
|
||||
* IS_LITTLE_ENDIAN must be defined for little-endian systems
|
||||
* HAVE_LONG_LONG must be defined on systems that have 'long long' integers
|
||||
* HAVE_ALIGNED_LONGLONGS must be defined if long-longs must be 8 byte aligned
|
||||
* HAVE_ALIGNED_DOUBLES must be defined if doubles must be 8 byte aligned
|
||||
* IS_64 must be defined on 64-bit machines (like Dec Alpha)
|
||||
******************************************************************************/
|
||||
|
||||
/* DLL Entry modifiers... */
|
||||
|
||||
/* PC */
|
||||
#if defined(XP_PC) || defined(_WINDOWS) || defined(WIN32) || defined(_WIN32)
|
||||
# include <windows.h>
|
||||
# if defined(_MSC_VER)
|
||||
# if defined(WIN32) || defined(_WIN32)
|
||||
# define JRI_PUBLIC_API(ResultType) _declspec(dllexport) ResultType
|
||||
# define JRI_CALLBACK
|
||||
# else /* !_WIN32 */
|
||||
# if defined(_WINDLL)
|
||||
# define JRI_PUBLIC_API(ResultType) ResultType __cdecl __export __loadds
|
||||
# define JRI_CALLBACK __loadds
|
||||
# else /* !WINDLL */
|
||||
# define JRI_PUBLIC_API(ResultType) ResultType __cdecl __export
|
||||
# define JRI_CALLBACK __export
|
||||
# endif /* !WINDLL */
|
||||
# endif /* !_WIN32 */
|
||||
# elif defined(__BORLANDC__)
|
||||
# if defined(WIN32) || defined(_WIN32)
|
||||
# define JRI_PUBLIC_API(ResultType) __export ResultType
|
||||
# define JRI_CALLBACK
|
||||
# else /* !_WIN32 */
|
||||
# define JRI_PUBLIC_API(ResultType) ResultType _cdecl _export _loadds
|
||||
# define JRI_CALLBACK _loadds
|
||||
# endif
|
||||
# else
|
||||
# error Unsupported PC development environment.
|
||||
# endif
|
||||
# ifndef IS_LITTLE_ENDIAN
|
||||
# define IS_LITTLE_ENDIAN
|
||||
# endif
|
||||
|
||||
/* Mac */
|
||||
#elif macintosh || Macintosh || THINK_C
|
||||
# if defined(__MWERKS__) /* Metrowerks */
|
||||
# if !__option(enumsalwaysint)
|
||||
# error You need to define 'Enums Always Int' for your project.
|
||||
# endif
|
||||
# if defined(GENERATING68K) && !GENERATINGCFM
|
||||
# if !__option(fourbyteints)
|
||||
# error You need to define 'Struct Alignment: 68k' for your project.
|
||||
# endif
|
||||
# endif /* !GENERATINGCFM */
|
||||
# elif defined(__SC__) /* Symantec */
|
||||
# error What are the Symantec defines? (warren@netscape.com)
|
||||
# elif macintosh && applec /* MPW */
|
||||
# error Please upgrade to the latest MPW compiler (SC).
|
||||
# else
|
||||
# error Unsupported Mac development environment.
|
||||
# endif
|
||||
# define JRI_PUBLIC_API(ResultType) ResultType
|
||||
# define JRI_CALLBACK
|
||||
|
||||
/* Unix or else */
|
||||
#else
|
||||
# define JRI_PUBLIC_API(ResultType) ResultType
|
||||
# define JRI_CALLBACK
|
||||
#endif
|
||||
|
||||
#ifndef FAR /* for non-Win16 */
|
||||
#define FAR
|
||||
#endif
|
||||
|
||||
/******************************************************************************/
|
||||
|
||||
/* Java Scalar Types */
|
||||
|
||||
typedef unsigned char jbool;
|
||||
#ifdef IS_64 /* XXX ok for alpha, but not right on all 64-bit architectures */
|
||||
typedef unsigned int juint;
|
||||
typedef int jint;
|
||||
#else
|
||||
typedef unsigned long juint;
|
||||
#endif
|
||||
|
||||
|
||||
/******************************************************************************/
|
||||
/*
|
||||
** JDK Stuff -- This stuff is still needed while we're using the JDK
|
||||
** dynamic linking strategy to call native methods.
|
||||
*/
|
||||
|
||||
typedef union JRI_JDK_stack_item {
|
||||
/* Non pointer items */
|
||||
jint i;
|
||||
jfloat f;
|
||||
jint o;
|
||||
/* Pointer items */
|
||||
void *h;
|
||||
void *p;
|
||||
unsigned char *addr;
|
||||
#ifdef IS_64
|
||||
double d;
|
||||
long l; /* == 64bits! */
|
||||
#endif
|
||||
} JRI_JDK_stack_item;
|
||||
|
||||
typedef union JRI_JDK_Java8Str {
|
||||
jint x[2];
|
||||
jdouble d;
|
||||
jlong l;
|
||||
void *p;
|
||||
float f;
|
||||
} JRI_JDK_Java8;
|
||||
|
||||
#ifdef HAVE_ALIGNED_LONGLONGS
|
||||
#define JRI_GET_INT64(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \
|
||||
((_t).x[1] = ((jint*)(_addr))[1]), \
|
||||
(_t).l )
|
||||
#define JRI_SET_INT64(_t, _addr, _v) ( (_t).l = (_v), \
|
||||
((jint*)(_addr))[0] = (_t).x[0], \
|
||||
((jint*)(_addr))[1] = (_t).x[1] )
|
||||
#else
|
||||
#define JRI_GET_INT64(_t,_addr) (*(jlong*)(_addr))
|
||||
#define JRI_SET_INT64(_t, _addr, _v) (*(jlong*)(_addr) = (_v))
|
||||
#endif
|
||||
|
||||
/* If double's must be aligned on doubleword boundaries then define this */
|
||||
#ifdef HAVE_ALIGNED_DOUBLES
|
||||
#define JRI_GET_DOUBLE(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \
|
||||
((_t).x[1] = ((jint*)(_addr))[1]), \
|
||||
(_t).d )
|
||||
#define JRI_SET_DOUBLE(_t, _addr, _v) ( (_t).d = (_v), \
|
||||
((jint*)(_addr))[0] = (_t).x[0], \
|
||||
((jint*)(_addr))[1] = (_t).x[1] )
|
||||
#else
|
||||
#define JRI_GET_DOUBLE(_t,_addr) (*(jdouble*)(_addr))
|
||||
#define JRI_SET_DOUBLE(_t, _addr, _v) (*(jdouble*)(_addr) = (_v))
|
||||
#endif
|
||||
|
||||
/******************************************************************************/
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* JRI_MD_H */
|
||||
/******************************************************************************/
|
||||
@@ -1,193 +0,0 @@
|
||||
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
||||
*
|
||||
* The contents of this file are subject to the Mozilla Public
|
||||
* License Version 1.1 (the "License"); you may not use this file
|
||||
* except in compliance with the License. You may obtain a copy of
|
||||
* the License at http://www.mozilla.org/MPL/
|
||||
*
|
||||
* Software distributed under the License is distributed on an "AS
|
||||
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* The Original Code is The Waterfall Java Plugin Module
|
||||
*
|
||||
* The Initial Developer of the Original Code is Sun Microsystems Inc
|
||||
* Portions created by Sun Microsystems Inc are Copyright (C) 2001
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* $Id: jritypes.h,v 1.1.1.1 2001-05-10 18:12:36 edburns%acm.org Exp $
|
||||
*
|
||||
*
|
||||
* Contributor(s):
|
||||
*
|
||||
* Nikolay N. Igotti <inn@sparc.spb.su>
|
||||
*/
|
||||
|
||||
/* -*- Mode: C; tab-width: 4; -*- */
|
||||
/*******************************************************************************
|
||||
* Java Runtime Interface
|
||||
* Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
|
||||
******************************************************************************/
|
||||
|
||||
#ifndef JRITYPES_H
|
||||
#define JRITYPES_H
|
||||
|
||||
#include "jri_md.h"
|
||||
#include <stddef.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*******************************************************************************
|
||||
* Types
|
||||
******************************************************************************/
|
||||
|
||||
struct JRIEnvInterface;
|
||||
|
||||
typedef void* JRIRef;
|
||||
typedef void* JRIGlobalRef;
|
||||
|
||||
typedef jint JRIInterfaceID[4];
|
||||
typedef jint JRIFieldID;
|
||||
typedef jint JRIMethodID;
|
||||
|
||||
/* synonyms: */
|
||||
typedef JRIGlobalRef jglobal;
|
||||
typedef JRIRef jref;
|
||||
|
||||
typedef union JRIValue {
|
||||
jbool z;
|
||||
jbyte b;
|
||||
jchar c;
|
||||
jshort s;
|
||||
jint i;
|
||||
jlong l;
|
||||
jfloat f;
|
||||
jdouble d;
|
||||
jref r;
|
||||
} JRIValue;
|
||||
|
||||
|
||||
typedef enum JRIBoolean {
|
||||
JRIFalse = 0,
|
||||
JRITrue = 1
|
||||
} JRIBoolean;
|
||||
|
||||
typedef enum JRIConstant {
|
||||
JRIUninitialized = -1
|
||||
} JRIConstant;
|
||||
|
||||
/* convenience types: */
|
||||
#define JRIConstructorMethodName "<init>"
|
||||
|
||||
/*******************************************************************************
|
||||
* Signature Construction Macros
|
||||
******************************************************************************/
|
||||
|
||||
/*
|
||||
** These macros can be used to construct signature strings. Hopefully their names
|
||||
** are a little easier to remember than the single character they correspond to.
|
||||
** For example, to specify the signature of the method:
|
||||
**
|
||||
** public int read(byte b[], int off, int len);
|
||||
**
|
||||
** you could write something like this in C:
|
||||
**
|
||||
** char* readSig = JRISigMethod(JRISigArray(JRISigByte)
|
||||
** JRISigInt
|
||||
** JRISigInt) JRISigInt;
|
||||
**
|
||||
** Of course, don't put commas between the types.
|
||||
*/
|
||||
#define JRISigArray(T) "[" T
|
||||
#define JRISigByte "B"
|
||||
#define JRISigChar "C"
|
||||
#define JRISigClass(name) "L" name ";"
|
||||
#define JRISigFloat "F"
|
||||
#define JRISigDouble "D"
|
||||
#define JRISigMethod(args) "(" args ")"
|
||||
#define JRISigNoArgs ""
|
||||
#define JRISigInt "I"
|
||||
#define JRISigLong "J"
|
||||
#define JRISigShort "S"
|
||||
#define JRISigVoid "V"
|
||||
#define JRISigBoolean "Z"
|
||||
|
||||
/*******************************************************************************
|
||||
* Environments
|
||||
******************************************************************************/
|
||||
|
||||
extern JRI_PUBLIC_API(const struct JRIEnvInterface**)
|
||||
JRI_GetCurrentEnv(void);
|
||||
|
||||
/*******************************************************************************
|
||||
* Specific Scalar Array Types
|
||||
******************************************************************************/
|
||||
|
||||
/*
|
||||
** The JRI Native Method Interface does not support boolean arrays. This
|
||||
** is to allow Java runtime implementations to optimize boolean array
|
||||
** storage. Using the ScalarArray operations on boolean arrays is bound
|
||||
** to fail, so convert any boolean arrays to byte arrays in Java before
|
||||
** passing them to a native method.
|
||||
*/
|
||||
|
||||
#define JRI_NewByteArray(env, length, initialValues) \
|
||||
JRI_NewScalarArray(env, length, JRISigByte, (jbyte*)(initialValues))
|
||||
#define JRI_GetByteArrayLength(env, array) \
|
||||
JRI_GetScalarArrayLength(env, array)
|
||||
#define JRI_GetByteArrayElements(env, array) \
|
||||
JRI_GetScalarArrayElements(env, array)
|
||||
|
||||
#define JRI_NewCharArray(env, length, initialValues) \
|
||||
JRI_NewScalarArray(env, ((length) * sizeof(jchar)), JRISigChar, (jbyte*)(initialValues))
|
||||
#define JRI_GetCharArrayLength(env, array) \
|
||||
JRI_GetScalarArrayLength(env, array)
|
||||
#define JRI_GetCharArrayElements(env, array) \
|
||||
((jchar*)JRI_GetScalarArrayElements(env, array))
|
||||
|
||||
#define JRI_NewShortArray(env, length, initialValues) \
|
||||
JRI_NewScalarArray(env, ((length) * sizeof(jshort)), JRISigShort, (jbyte*)(initialValues))
|
||||
#define JRI_GetShortArrayLength(env, array) \
|
||||
JRI_GetScalarArrayLength(env, array)
|
||||
#define JRI_GetShortArrayElements(env, array) \
|
||||
((jshort*)JRI_GetScalarArrayElements(env, array))
|
||||
|
||||
#define JRI_NewIntArray(env, length, initialValues) \
|
||||
JRI_NewScalarArray(env, ((length) * sizeof(jint)), JRISigInt, (jbyte*)(initialValues))
|
||||
#define JRI_GetIntArrayLength(env, array) \
|
||||
JRI_GetScalarArrayLength(env, array)
|
||||
#define JRI_GetIntArrayElements(env, array) \
|
||||
((jint*)JRI_GetScalarArrayElements(env, array))
|
||||
|
||||
#define JRI_NewLongArray(env, length, initialValues) \
|
||||
JRI_NewScalarArray(env, ((length) * sizeof(jlong)), JRISigLong, (jbyte*)(initialValues))
|
||||
#define JRI_GetLongArrayLength(env, array) \
|
||||
JRI_GetScalarArrayLength(env, array)
|
||||
#define JRI_GetLongArrayElements(env, array) \
|
||||
((jlong*)JRI_GetScalarArrayElements(env, array))
|
||||
|
||||
#define JRI_NewFloatArray(env, length, initialValues) \
|
||||
JRI_NewScalarArray(env, ((length) * sizeof(jfloat)), JRISigFloat, (jbyte*)(initialValues))
|
||||
#define JRI_GetFloatArrayLength(env, array) \
|
||||
JRI_GetScalarArrayLength(env, array)
|
||||
#define JRI_GetFloatArrayElements(env, array) \
|
||||
((jfloat*)JRI_GetScalarArrayElements(env, array))
|
||||
|
||||
#define JRI_NewDoubleArray(env, length, initialValues) \
|
||||
JRI_NewScalarArray(env, ((length) * sizeof(jdouble)), JRISigDouble, (jbyte*)(initialValues))
|
||||
#define JRI_GetDoubleArrayLength(env, array) \
|
||||
JRI_GetScalarArrayLength(env, array)
|
||||
#define JRI_GetDoubleArrayElements(env, array) \
|
||||
((jdouble*)JRI_GetScalarArrayElements(env, array))
|
||||
|
||||
/******************************************************************************/
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* JRITYPES_H */
|
||||
/******************************************************************************/
|
||||
127
mozilla/java/pluggable-jvm/wf/src/plugin/win32/installer.c
Normal file
127
mozilla/java/pluggable-jvm/wf/src/plugin/win32/installer.c
Normal file
@@ -0,0 +1,127 @@
|
||||
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
||||
*
|
||||
* The contents of this file are subject to the Mozilla Public
|
||||
* License Version 1.1 (the "License"); you may not use this file
|
||||
* except in compliance with the License. You may obtain a copy of
|
||||
* the License at http://www.mozilla.org/MPL/
|
||||
*
|
||||
* Software distributed under the License is distributed on an "AS
|
||||
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* rights and limitations under the License.
|
||||
*
|
||||
* The Original Code is The Waterfall Java Plugin Module
|
||||
*
|
||||
* The Initial Developer of the Original Code is Sun Microsystems Inc
|
||||
* Portions created by Sun Microsystems Inc are Copyright (C) 2001
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* $Id: installer.c,v 1.1 2001-07-12 20:26:30 edburns%acm.org Exp $
|
||||
*
|
||||
* Contributor(s):
|
||||
*
|
||||
* Nikolay N. Igotti <nikolay.igotti@Sun.Com>
|
||||
*/
|
||||
|
||||
#include <windows.h>
|
||||
#include <stdio.h>
|
||||
//#include "dialogs.h"
|
||||
//#include "ifuncns.h"
|
||||
|
||||
#define CLASS_NAME "WFInstall"
|
||||
|
||||
/* global variables */
|
||||
HINSTANCE hInst;
|
||||
|
||||
HANDLE hAccelTable;
|
||||
|
||||
HWND hDlgUninstall;
|
||||
HWND hDlgMessage;
|
||||
HWND hWndMain;
|
||||
|
||||
LPSTR szEGlobalAlloc;
|
||||
LPSTR szEStringLoad;
|
||||
LPSTR szEDllLoad;
|
||||
LPSTR szEStringNull;
|
||||
LPSTR szTempSetupPath;
|
||||
|
||||
LPSTR szClassName;
|
||||
LPSTR szUninstallDir;
|
||||
LPSTR szTempDir;
|
||||
LPSTR szOSTempDir;
|
||||
LPSTR szFileIniUninstall;
|
||||
LPSTR gszSharedFilename;
|
||||
|
||||
ULONG ulOSType;
|
||||
DWORD dwScreenX;
|
||||
DWORD dwScreenY;
|
||||
|
||||
void Log(char* str)
|
||||
{
|
||||
MessageBox(hWndMain, str, NULL, MB_ICONEXCLAMATION);
|
||||
}
|
||||
|
||||
|
||||
BOOL InitApplication(HINSTANCE hInstance)
|
||||
{
|
||||
WNDCLASS wc;
|
||||
|
||||
wc.style = CS_DBLCLKS | CS_SAVEBITS | CS_BYTEALIGNWINDOW;
|
||||
wc.lpfnWndProc = DefDlgProc;
|
||||
wc.cbClsExtra = 0;
|
||||
wc.cbWndExtra = DLGWINDOWEXTRA;
|
||||
wc.hInstance = hInstance;
|
||||
//wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_UNINSTALL));
|
||||
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
||||
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
|
||||
wc.lpszMenuName = NULL;
|
||||
wc.lpszClassName = szClassName;
|
||||
|
||||
return(RegisterClass(&wc));
|
||||
}
|
||||
|
||||
HRESULT Initialize(HINSTANCE hInstance)
|
||||
{
|
||||
szClassName = (LPSTR)GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT, 50);
|
||||
lstrcpy(szClassName, CLASS_NAME);
|
||||
Log(szClassName);
|
||||
return(0);
|
||||
}
|
||||
|
||||
int APIENTRY WinMain(HINSTANCE hInstance,
|
||||
HINSTANCE hPrevInstance,
|
||||
LPSTR lpszCmdLine,
|
||||
int nCmdShow)
|
||||
{
|
||||
/***********************************************************************/
|
||||
/* HANDLE hInstance; handle for this instance */
|
||||
/* HANDLE hPrevInstance; handle for possible previous instances */
|
||||
/* LPSTR lpszCmdLine; long pointer to exec command line */
|
||||
/* int nCmdShow; Show code for main window display */
|
||||
/***********************************************************************/
|
||||
|
||||
MSG msg;
|
||||
|
||||
if(!hPrevInstance)
|
||||
{
|
||||
hInst = GetModuleHandle(NULL);
|
||||
Log("1");
|
||||
if(Initialize(hInst))
|
||||
{
|
||||
Log("2");
|
||||
PostQuitMessage(1);
|
||||
}
|
||||
else if(!InitApplication(hInst))
|
||||
{
|
||||
Log("3");
|
||||
PostQuitMessage(1);
|
||||
}
|
||||
}
|
||||
Log("4");
|
||||
while(GetMessage(&msg, NULL, 0, 0))
|
||||
{
|
||||
TranslateMessage(&msg);
|
||||
DispatchMessage(&msg);
|
||||
}
|
||||
return(msg.wParam);
|
||||
} /* End of WinMain */
|
||||
Reference in New Issue
Block a user