rJava/src/rJava.h at master · s-u/rJava · GitHub

History

280 lines (233 loc) · 8.68 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

#ifndef __RJAVA_H__

#define __RJAVA_H__

#define RJAVA_VER 0x010013 /* rJava v1.0-19 */

/* important changes between versions:

3.0 - adds compiler

2.0

1.0 - custom package class loaders

0.9 - rectangular arrays, flattening, import

(really introduced in later 0.8 versions but they broke

the API compatibility so 0.9 attempts to fix that)

0.8 - new exception handling using Exception condition

0.7 - new reflection code, new REngine API (JRI)

0.6 - adds serialization, (auto-)deserialization and cache

0.5 - integrates JRI, adds callbacks and class-loader

0.4 - includes JRI

0.3 - uses EXTPTR in jobj slot, adds finalizers

0.2 - uses S4 classes

0.1 - first public release */

#include <jni.h>

#include <R.h>

#include <Rinternals.h>

#include <Rversion.h>

#include <Rdefines.h>

#include <Rversion.h>

#if (R_VERSION >= R_Version(4,6,0))

#include <R_ext/ObjectTable.h>

#else

#include <R_ext/Callbacks.h>

#endif

/* R API compatibility re-mapping */

#if (R_VERSION >= R_Version(2,0,0))

/* EXTPTR */

#ifdef EXTPTR_PTR

#undef EXTPTR_PTR

#endif

#define EXTPTR_PTR(X) R_ExternalPtrAddr(X)

#ifdef EXTPTR_PROT

#undef EXTPTR_PROT

#endif

#define EXTPTR_PROT(X) R_ExternalPtrProtected(X)

#ifdef EXTPTR_TAG

#undef EXTPTR_TAG

#endif

#define EXTPTR_TAG(X) R_ExternalPtrTag(X)

#endif

/* flags used in function declarations:

HIDE - hidden (used internally in rJava only)

REP - R Entry Point - .C convention

REPE - R Entry Point - .External convention

REPC - R Entry Point - .Call convention

- inline and/or hide functions that are not externally visible

- automatically generate symbol registration table

#ifdef ONEFILE

#ifdef HAVE_STATIC_INLINE

#define HIDE static inline

#else

#define HIDE static

#endif

#else

#define HIDE

#endif

#define REP

#define REPE

#define REPC

#if defined WIN32 && ! defined Win32

#define Win32

#endif

#if defined Win32 && ! defined WIN32

#define WIN32

#endif

#include "config.h"

/* R 4.0.1 broke EXTPTR_PTR ABI so re-map it to safety at the small expense of speed */

#ifdef EXTPTR_PTR

#undef EXTPTR_PTR

#endif

#define EXTPTR_PTR(X) R_ExternalPtrAddr(X)

/* PROT/TAG are safe so far, but just to make sure ... */

#ifdef EXTPTR_PROT

#undef EXTPTR_PROT

#endif

#define EXTPTR_PROT(X) R_ExternalPtrProtected(X)

#ifdef EXTPTR_TAG

#undef EXTPTR_TAG

#endif

#define EXTPTR_TAG(X) R_ExternalPtrTag(X)

#ifdef MEMPROF

#include <stdio.h>

#include <time.h>

extern FILE* memprof_f;

#define _mp(X) X

#define MEM_PROF_OUT(X ...) { if (memprof_f) { long t = time(0); fprintf(memprof_f, "<%08x> %x:%02d ", (int) env, t/60, t%60); fprintf(memprof_f, X); }; }

#else

#define _mp(X)

#endif

/* debugging output (enable with -DRJ_DEBUG) */

#ifdef RJ_DEBUG

void rjprintf(char *fmt, ...); /* in Rglue.c */

/* we can't assume ISO C99 (variadic macros), so we have to use one more level of wrappers */

#define _dbg(X) X

#else

#define _dbg(X)

#endif

/* profiling */

#ifdef RJ_PROFILE

#define profStart() profilerTime=time_ms()

#define _prof(X) X

long time_ms(void); /* those are acutally in Rglue.c */

void profReport(char *fmt, ...);

#else

#define profStart()

#define _prof(X)

#endif

#ifdef ENABLE_JRICB

#define BEGIN_RJAVA_CALL { int save_in_RJava = RJava_has_control; RJava_has_control=1; {

#define END_RJAVA_CALL }; RJava_has_control = save_in_RJava; }

#else

#define BEGIN_RJAVA_CALL {

#define END_RJAVA_CALL };

#endif

/* define mkCharUTF8 in a compatible fashion

NOTE: those should NOT be used anymore since native

Java strings use UTF-16 so use only in cases where UTF8 is required */

#if R_VERSION < R_Version(2,7,0)

#define mkCharUTF8(X) mkChar(X)

#define CHAR_UTF8(X) CHAR(X)

#else

#define mkCharUTF8(X) rj_mkCharUTF8(X)

#define CHAR_UTF8(X) rj_char_utf8(X)

extern SEXP rj_mkCharUTF8(const char *); /* rjstring.c */

extern const char *rj_char_utf8(SEXP); /* Rglue.c */

#endif

/* signatures are stored in a local buffer if they fit. Only if they don't fit a heap buffer is allocated and used. */

typedef struct sig_buffer {

char *sig; /* if sig doesn't point to sigbuf then it's allocated from heap */

int maxsig, len;

char sigbuf[256]; /* default size of the local buffer (on the stack) */

} sig_buffer_t;

/* in callbacks.c */

extern int RJava_has_control;

/* in rJava.c */

extern JNIEnv *eenv; /* should NOT be used since not thread-safe; use getJNIEnv instead */

HIDE JNIEnv* getJNIEnv(void);

HIDE void ckx(JNIEnv *env);

HIDE void clx(JNIEnv *env);

HIDE SEXP getStringArrayCont(jarray) ;

HIDE jarray getSimpleClassNames( jobject, jboolean ) ;

HIDE SEXP getSimpleClassNames_asSEXP( jobject, jboolean ) ;

REPC SEXP RgetSimpleClassNames( SEXP, SEXP );

/* in init.c */

extern JavaVM *jvm;

extern int rJava_initialized;

#define JVM_STATE_NONE 0 /* no JVM */

#define JVM_STATE_CREATED 1 /* JVM was created by us */

#define JVM_STATE_ATTACHED 2 /* we attached to another JVM */

#define JVM_STATE_DEAD 4 /* set when Java exit handler was called */

#define JVM_STATE_DESTROYED 8 /* JVM was destroyed */

extern int rJava_JVM_state;

extern int java_is_dead;

extern jclass javaStringClass;

extern jclass javaObjectClass;

extern jclass javaClassClass;

extern jclass javaFieldClass;

extern jclass rj_RJavaTools_Class ;

extern jmethodID mid_forName;

extern jmethodID mid_getName;

extern jmethodID mid_getSuperclass;

extern jmethodID mid_getType;

extern jmethodID mid_getField;

extern jmethodID mid_rj_getSimpleClassNames;

extern jmethodID mid_RJavaTools_getFieldTypeName;

/* RJavaImport */

extern jclass rj_RJavaImport_Class ;

extern jmethodID mid_RJavaImport_getKnownClasses ;

extern jmethodID mid_RJavaImport_lookup ;

extern jmethodID mid_RJavaImport_exists ;

HIDE void init_rJava(void);

/* in otables.c */

// turn this for debugging in otables.c

// #define LOOKUP_DEBUG

REPC SEXP newRJavaLookupTable(SEXP) ;

HIDE SEXP R_getUnboundValue(void) ;

HIDE SEXP rJavaLookupTable_objects(R_ObjectTable *) ;

HIDE SEXP rJavaLookupTable_assign(const char * const, SEXP, R_ObjectTable * ) ;

HIDE Rboolean rJavaLookupTable_canCache(const char * const, R_ObjectTable *) ;

HIDE int rJavaLookupTable_remove(const char * const, R_ObjectTable *) ;

HIDE SEXP rJavaLookupTable_get(const char * const, Rboolean *, R_ObjectTable *) ;

HIDE Rboolean rJavaLookupTable_exists(const char * const, Rboolean *, R_ObjectTable *) ;

HIDE jobject getImporterReference(R_ObjectTable *) ;

HIDE SEXP getKnownClasses( R_ObjectTable * );

HIDE SEXP classNameLookup( R_ObjectTable *, const char * const ) ;

HIDE Rboolean classNameLookupExists(R_ObjectTable *, const char * const ) ;

/* in loader.c */

extern jclass clClassLoader;

extern jobject oClassLoader;

/* in Rglue */

HIDE SEXP j2SEXP(JNIEnv *env, jobject o, int releaseLocal);

HIDE SEXP new_jobjRef(JNIEnv *env, jobject o, const char *klass);

HIDE jvalue R1par2jvalue(JNIEnv *env, SEXP par, sig_buffer_t *sig, jobject *otr);

HIDE void init_sigbuf(sig_buffer_t *sb);

HIDE void done_sigbuf(sig_buffer_t *sb);

HIDE SEXP getName( JNIEnv *, jobject/*Class*/ );

HIDE SEXP new_jclassName(JNIEnv *, jobject/*Class*/ ) ;

/* in tools.c */

HIDE jstring callToString(JNIEnv *env, jobject o);

/* in callJNI */

HIDE jobject createObject(JNIEnv *env, const char *class, const char *sig, jvalue *par, int silent, jobject loader);

HIDE jclass findClass(JNIEnv *env, const char *class, jobject loader);

HIDE jclass objectClass(JNIEnv *env, jobject o);

HIDE jdoubleArray newDoubleArray(JNIEnv *env, double *cont, int len);

HIDE jintArray newIntArray(JNIEnv *env, int *cont, int len);

HIDE jbooleanArray newBooleanArrayI(JNIEnv *env, int *cont, int len);

HIDE jstring newString(JNIEnv *env, const char *cont);

HIDE jstring newString16(JNIEnv *env, const jchar *cont, jsize len);

HIDE jcharArray newCharArrayI(JNIEnv *env, int *cont, int len);

HIDE jshortArray newShortArrayI(JNIEnv *env, int *cont, int len);

HIDE jfloatArray newFloatArrayD(JNIEnv *env, double *cont, int len);

HIDE jlongArray newLongArrayD(JNIEnv *env, double *cont, int len);

HIDE jintArray newByteArray(JNIEnv *env, void *cont, int len);

HIDE jbyteArray newByteArrayI(JNIEnv *env, int *cont, int len);

HIDE jobject makeGlobal(JNIEnv *env, jobject o);

HIDE void releaseObject(JNIEnv *env, jobject o);

HIDE void releaseGlobal(JNIEnv *env, jobject o);

HIDE void printObject(JNIEnv *env, jobject o);

HIDE int checkExceptionsX(JNIEnv *env, int silent);

HIDE int initClassLoader(JNIEnv *env, jobject cl);

HIDE void deserializeSEXP(SEXP o);

/* this is a hook for de-serialization */

#define jverify(X) if (X && TYPEOF(X) == EXTPTRSXP && EXTPTR_PROT(X) != R_NilValue) deserializeSEXP(X)

#define IS_JOBJREF(obj) ( inherits(obj, "jobjRef") || inherits(obj, "jarrayRef") || inherits(obj,"jrectRef") )

#define IS_JARRAYREF(obj) ( inherits(obj, "jobjRef") || inherits(obj, "jarrayRef") || inherits(obj, "jrectRef") )

#define IS_JRECTREF(obj) ( inherits(obj,"jrectRef") )

#endif

rJava/src/rJava.h at master · s-u/rJava · GitHub

Expand file tree

Breadcrumbs

rJava.h

Latest commit

History

Breadcrumbs

rJava.h

File metadata and controls