EOJ: incorrect giws file after jcreatejar introduction
[scilab.git] / scilab / modules / external_objects_java / src / jni / ScilabJavaCompiler.cpp
1 #include "ScilabJavaCompiler.hxx"
2 /* Generated by GIWS (version 2.0.2) with command:
3 giws -e -f ScilabObjects.giws.xml 
4 */
5 /*
6
7 This is generated code.
8
9 This software is a computer program whose purpose is to hide the complexity
10 of accessing Java objects/methods from C++ code.
11
12 This software is governed by the CeCILL-B license under French law and
13 abiding by the rules of distribution of free software.  You can  use,
14 modify and/ or redistribute the software under the terms of the CeCILL-B
15 license as circulated by CEA, CNRS and INRIA at the following URL
16 "http://www.cecill.info".
17
18 As a counterpart to the access to the source code and  rights to copy,
19 modify and redistribute granted by the license, users are provided only
20 with a limited warranty  and the software's author,  the holder of the
21 economic rights,  and the successive licensors  have only  limited
22 liability.
23
24 In this respect, the user's attention is drawn to the risks associated
25 with loading,  using,  modifying and/or developing or reproducing the
26 software by the user in light of its specific status of free software,
27 that may mean  that it is complicated to manipulate,  and  that  also
28 therefore means  that it is reserved for developers  and  experienced
29 professionals having in-depth computer knowledge. Users are therefore
30 encouraged to load and test the software's suitability as regards their
31 requirements in conditions enabling the security of their systems and/or
32 data to be ensured and,  more generally, to use and operate it in the
33 same conditions as regards security.
34
35 The fact that you are presently reading this means that you have had
36 knowledge of the CeCILL-B license and that you accept its terms.
37 */
38
39 namespace org_scilab_modules_external_objects_java {
40
41                 // Static declarations (if any)
42                 
43 // Returns the current env
44
45 JNIEnv * ScilabJavaCompiler::getCurrentEnv() {
46 JNIEnv * curEnv = NULL;
47 jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
48 if (res != JNI_OK) {
49 throw GiwsException::JniException(getCurrentEnv());
50 }
51 return curEnv;
52 }
53 // Destructor
54
55 ScilabJavaCompiler::~ScilabJavaCompiler() {
56 JNIEnv * curEnv = NULL;
57 this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
58 curEnv->DeleteGlobalRef(this->instance);
59 curEnv->DeleteGlobalRef(this->instanceClass);
60 curEnv->DeleteGlobalRef(this->stringArrayClass);}
61 // Constructors
62 ScilabJavaCompiler::ScilabJavaCompiler(JavaVM * jvm_) {
63 jmethodID constructObject = NULL ;
64 jobject localInstance ;
65 jclass localClass ;
66
67 const std::string construct="<init>";
68 const std::string param="()V";
69 jvm=jvm_;
70
71 JNIEnv * curEnv = getCurrentEnv();
72
73 localClass = curEnv->FindClass( this->className().c_str() ) ;
74 if (localClass == NULL) {
75   throw GiwsException::JniClassNotFoundException(curEnv, this->className());
76 }
77
78 this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
79
80 /* localClass is not needed anymore */
81 curEnv->DeleteLocalRef(localClass);
82
83 if (this->instanceClass == NULL) {
84 throw GiwsException::JniObjectCreationException(curEnv, this->className());
85 }
86
87
88 constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
89 if(constructObject == NULL){
90 throw GiwsException::JniObjectCreationException(curEnv, this->className());
91 }
92
93 localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
94 if(localInstance == NULL){
95 throw GiwsException::JniObjectCreationException(curEnv, this->className());
96 }
97  
98 this->instance = curEnv->NewGlobalRef(localInstance) ;
99 if(this->instance == NULL){
100 throw GiwsException::JniObjectCreationException(curEnv, this->className());
101 }
102 /* localInstance not needed anymore */
103 curEnv->DeleteLocalRef(localInstance);
104
105                 /* Methods ID set to NULL */
106 jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
107
108
109 }
110
111 ScilabJavaCompiler::ScilabJavaCompiler(JavaVM * jvm_, jobject JObj) {
112         jvm=jvm_;
113
114         JNIEnv * curEnv = getCurrentEnv();
115
116 jclass localClass = curEnv->GetObjectClass(JObj);
117         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
118         curEnv->DeleteLocalRef(localClass);
119
120         if (this->instanceClass == NULL) {
121 throw GiwsException::JniObjectCreationException(curEnv, this->className());
122         }
123
124         this->instance = curEnv->NewGlobalRef(JObj) ;
125         if(this->instance == NULL){
126 throw GiwsException::JniObjectCreationException(curEnv, this->className());
127         }
128         /* Methods ID set to NULL */
129         jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
130
131
132 }
133
134 // Generic methods
135
136 void ScilabJavaCompiler::synchronize() {
137 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
138 throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaCompiler");
139 }
140 }
141
142 void ScilabJavaCompiler::endSynchronize() {
143 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
144 throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaCompiler");
145 }
146 }
147 // Method(s)
148
149 int ScilabJavaCompiler::compileCode (JavaVM * jvm_, char const* classname, char const* const* code, int codeSize){
150
151 JNIEnv * curEnv = NULL;
152 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
153 jclass cls = curEnv->FindClass( className().c_str() );
154 if ( cls == NULL) {
155 throw GiwsException::JniCallMethodException(curEnv);
156 }
157
158 jmethodID jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "compileCode", "(Ljava/lang/String;[Ljava/lang/String;)I" ) ;
159 if (jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
160 throw GiwsException::JniMethodNotFoundException(curEnv, "compileCode");
161 }
162
163 jstring classname_ = curEnv->NewStringUTF( classname );
164 if (classname != NULL && classname_ == NULL)
165 {
166 throw GiwsException::JniBadAllocException(curEnv);
167 }
168
169 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
170
171 // create java array of strings.
172 jobjectArray code_ = curEnv->NewObjectArray( codeSize, stringArrayClass, NULL);
173 if (code_ == NULL)
174 {
175 throw GiwsException::JniBadAllocException(curEnv);
176 }
177
178 // convert each char * to java strings and fill the java array.
179 for ( int i = 0; i < codeSize; i++)
180 {
181 jstring TempString = curEnv->NewStringUTF( code[i] );
182 if (TempString == NULL)
183 {
184 throw GiwsException::JniBadAllocException(curEnv);
185 }
186
187 curEnv->SetObjectArrayElement( code_, i, TempString);
188
189 // avoid keeping reference on too many strings
190 curEnv->DeleteLocalRef(TempString);
191 }
192                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID ,classname_, code_));
193                         curEnv->DeleteLocalRef(stringArrayClass);
194 curEnv->DeleteLocalRef(classname_);
195 curEnv->DeleteLocalRef(code_);
196 curEnv->DeleteLocalRef(cls);
197 if (curEnv->ExceptionCheck()) {
198 throw GiwsException::JniCallMethodException(curEnv);
199 }
200 return res;
201
202 }
203
204 }