src/third_party/npapi/npspy/extern/java/jritypes.h

   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
  52 extern "C" {
  53 #endif
  54
  55 /*******************************************************************************
  56  * Types
  57  ******************************************************************************/
  58
  59 struct JRIEnvInterface;
  60
  61 typedef void*           JRIRef;
  62 typedef void*           JRIGlobalRef;
  63
  64 typedef jint            JRIFieldID;
  65 typedef jint            JRIMethodID;
  66
  67 /* synonyms: */
  68 typedef JRIGlobalRef    jglobal;
  69
  70 typedef 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
  82 typedef enum JRIBoolean {
  83     JRIFalse            = 0,
  84     JRITrue                     = 1
  85 } JRIBoolean;
  86
  87 typedef 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 */
  93 typedef struct jbooleanArrayStruct*             jbooleanArray;
  94 typedef struct jbyteArrayStruct*                jbyteArray;
  95 typedef struct jcharArrayStruct*                jcharArray;
  96 typedef struct jshortArrayStruct*               jshortArray;
  97 typedef struct jintArrayStruct*                 jintArray;
  98 typedef struct jlongArrayStruct*                jlongArray;
  99 typedef struct jfloatArrayStruct*               jfloatArray;
 100 typedef struct jdoubleArrayStruct*              jdoubleArray;
 101 typedef struct jobjectArrayStruct*              jobjectArray;
 102 #endif
 103 typedef struct jstringArrayStruct*              jstringArray;
 104 typedef 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
 145 extern JRI_PUBLIC_API(const struct JRIEnvInterface**)
 146 JRI_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
 215 typedef 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
 230 typedef 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 /******************************************************************************/