1/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ 2/* ***** BEGIN LICENSE BLOCK ***** 3 * Version: NPL 1.1/GPL 2.0/LGPL 2.1 4 * 5 * The contents of this file are subject to the Netscape Public License 6 * Version 1.1 (the "License"); you may not use this file except in 7 * compliance with the License. You may obtain a copy of the License at 8 * http://www.mozilla.org/NPL/ 9 * 10 * Software distributed under the License is distributed on an "AS IS" basis, 11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 12 * for the specific language governing rights and limitations under the 13 * License. 14 * 15 * The Original Code is mozilla.org code. 16 * 17 * The Initial Developer of the Original Code is 18 * Netscape Communications Corporation. 19 * Portions created by the Initial Developer are Copyright (C) 1998 20 * the Initial Developer. All Rights Reserved. 21 * 22 * Contributor(s): 23 * 24 * Alternatively, the contents of this file may be used under the terms of 25 * either the GNU General Public License Version 2 or later (the "GPL"), or 26 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), 27 * in which case the provisions of the GPL or the LGPL are applicable instead 28 * of those above. If you wish to allow use of your version of this file only 29 * under the terms of either the GPL or the LGPL, and not to allow others to 30 * use your version of this file under the terms of the NPL, indicate your 31 * decision by deleting the provisions above and replace them with the notice 32 * and other provisions required by the GPL or the LGPL. If you do not delete 33 * the provisions above, a recipient may use your version of this file under 34 * the terms of any one of the NPL, the GPL or the LGPL. 35 * 36 * ***** END LICENSE BLOCK ***** */ 37 38/******************************************************************************* 39 * Java Runtime Interface 40 ******************************************************************************/ 41 42#ifndef JRITYPES_H 43#define JRITYPES_H 44 45#include "jri_md.h" 46#include "jni.h" 47#include <stddef.h> 48#include <stdlib.h> 49#include <stdarg.h> 50 51#ifdef __cplusplus 52extern "C" { 53#endif 54 55/******************************************************************************* 56 * Types 57 ******************************************************************************/ 58 59struct JRIEnvInterface; 60 61typedef void* JRIRef; 62typedef void* JRIGlobalRef; 63 64typedef jint JRIFieldID; 65typedef jint JRIMethodID; 66 67/* synonyms: */ 68typedef JRIGlobalRef jglobal; 69 70typedef union JRIValue { 71 jbool z; 72 jbyte b; 73 jchar c; 74 jshort s; 75 jint i; 76 jlong l; 77 jfloat f; 78 jdouble d; 79 jref r; 80} JRIValue; 81 82typedef enum JRIBoolean { 83 JRIFalse = 0, 84 JRITrue = 1 85} JRIBoolean; 86 87typedef enum JRIConstant { 88 JRIUninitialized = -1 89} JRIConstant; 90 91/* convenience types (these must be distinct struct types for c++ overloading): */ 92#if 0 /* now in jni.h */ 93typedef struct jbooleanArrayStruct* jbooleanArray; 94typedef struct jbyteArrayStruct* jbyteArray; 95typedef struct jcharArrayStruct* jcharArray; 96typedef struct jshortArrayStruct* jshortArray; 97typedef struct jintArrayStruct* jintArray; 98typedef struct jlongArrayStruct* jlongArray; 99typedef struct jfloatArrayStruct* jfloatArray; 100typedef struct jdoubleArrayStruct* jdoubleArray; 101typedef struct jobjectArrayStruct* jobjectArray; 102#endif 103typedef struct jstringArrayStruct* jstringArray; 104typedef struct jarrayArrayStruct* jarrayArray; 105 106#define JRIConstructorMethodName "<init>" 107 108/******************************************************************************* 109 * Signature Construction Macros 110 ******************************************************************************/ 111 112/* 113** These macros can be used to construct signature strings. Hopefully their names 114** are a little easier to remember than the single character they correspond to. 115** For example, to specify the signature of the method: 116** 117** public int read(byte b[], int off, int len); 118** 119** you could write something like this in C: 120** 121** char* readSig = JRISigMethod(JRISigArray(JRISigByte) 122** JRISigInt 123** JRISigInt) JRISigInt; 124** 125** Of course, don't put commas between the types. 126*/ 127#define JRISigArray(T) "[" T 128#define JRISigByte "B" 129#define JRISigChar "C" 130#define JRISigClass(name) "L" name ";" 131#define JRISigFloat "F" 132#define JRISigDouble "D" 133#define JRISigMethod(args) "(" args ")" 134#define JRISigNoArgs "" 135#define JRISigInt "I" 136#define JRISigLong "J" 137#define JRISigShort "S" 138#define JRISigVoid "V" 139#define JRISigBoolean "Z" 140 141/******************************************************************************* 142 * Environments 143 ******************************************************************************/ 144 145extern JRI_PUBLIC_API(const struct JRIEnvInterface**) 146JRI_GetCurrentEnv(void); 147 148/******************************************************************************* 149 * Specific Scalar Array Types 150 ******************************************************************************/ 151 152/* 153** The JRI Native Method Interface does not support boolean arrays. This 154** is to allow Java runtime implementations to optimize boolean array 155** storage. Using the ScalarArray operations on boolean arrays is bound 156** to fail, so convert any boolean arrays to byte arrays in Java before 157** passing them to a native method. 158*/ 159 160#define JRI_NewByteArray(env, length, initialValues) \ 161 JRI_NewScalarArray(env, length, JRISigByte, (jbyte*)(initialValues)) 162#define JRI_GetByteArrayLength(env, array) \ 163 JRI_GetScalarArrayLength(env, array) 164#define JRI_GetByteArrayElements(env, array) \ 165 JRI_GetScalarArrayElements(env, array) 166 167#define JRI_NewCharArray(env, length, initialValues) \ 168 JRI_NewScalarArray(env, ((length) * sizeof(jchar)), JRISigChar, (jbyte*)(initialValues)) 169#define JRI_GetCharArrayLength(env, array) \ 170 JRI_GetScalarArrayLength(env, array) 171#define JRI_GetCharArrayElements(env, array) \ 172 ((jchar*)JRI_GetScalarArrayElements(env, array)) 173 174#define JRI_NewShortArray(env, length, initialValues) \ 175 JRI_NewScalarArray(env, ((length) * sizeof(jshort)), JRISigShort, (jbyte*)(initialValues)) 176#define JRI_GetShortArrayLength(env, array) \ 177 JRI_GetScalarArrayLength(env, array) 178#define JRI_GetShortArrayElements(env, array) \ 179 ((jshort*)JRI_GetScalarArrayElements(env, array)) 180 181#define JRI_NewIntArray(env, length, initialValues) \ 182 JRI_NewScalarArray(env, ((length) * sizeof(jint)), JRISigInt, (jbyte*)(initialValues)) 183#define JRI_GetIntArrayLength(env, array) \ 184 JRI_GetScalarArrayLength(env, array) 185#define JRI_GetIntArrayElements(env, array) \ 186 ((jint*)JRI_GetScalarArrayElements(env, array)) 187 188#define JRI_NewLongArray(env, length, initialValues) \ 189 JRI_NewScalarArray(env, ((length) * sizeof(jlong)), JRISigLong, (jbyte*)(initialValues)) 190#define JRI_GetLongArrayLength(env, array) \ 191 JRI_GetScalarArrayLength(env, array) 192#define JRI_GetLongArrayElements(env, array) \ 193 ((jlong*)JRI_GetScalarArrayElements(env, array)) 194 195#define JRI_NewFloatArray(env, length, initialValues) \ 196 JRI_NewScalarArray(env, ((length) * sizeof(jfloat)), JRISigFloat, (jbyte*)(initialValues)) 197#define JRI_GetFloatArrayLength(env, array) \ 198 JRI_GetScalarArrayLength(env, array) 199#define JRI_GetFloatArrayElements(env, array) \ 200 ((jfloat*)JRI_GetScalarArrayElements(env, array)) 201 202#define JRI_NewDoubleArray(env, length, initialValues) \ 203 JRI_NewScalarArray(env, ((length) * sizeof(jdouble)), JRISigDouble, (jbyte*)(initialValues)) 204#define JRI_GetDoubleArrayLength(env, array) \ 205 JRI_GetScalarArrayLength(env, array) 206#define JRI_GetDoubleArrayElements(env, array) \ 207 ((jdouble*)JRI_GetScalarArrayElements(env, array)) 208 209/******************************************************************************/ 210/* 211** JDK Stuff -- This stuff is still needed while we're using the JDK 212** dynamic linking strategy to call native methods. 213*/ 214 215typedef union JRI_JDK_stack_item { 216 /* Non pointer items */ 217 jint i; 218 jfloat f; 219 jint o; 220 /* Pointer items */ 221 void *h; 222 void *p; 223 unsigned char *addr; 224#ifdef IS_64 225 double d; 226 long l; /* == 64bits! */ 227#endif 228} JRI_JDK_stack_item; 229 230typedef union JRI_JDK_Java8Str { 231 jint x[2]; 232 jdouble d; 233 jlong l; 234 void *p; 235 float f; 236} JRI_JDK_Java8; 237 238/******************************************************************************/ 239#ifdef __cplusplus 240} 241#endif 242#endif /* JRITYPES_H */ 243/******************************************************************************/ 244