1 /* -*- tab-width: 4 -*-
2 *
3 * Electric(tm) VLSI Design System
4 *
5 * File: dblangjava.cpp
6 * Java interface module
7 * Written by: Steven M. Rubin, Static Free Software
8 *
9 * Copyright (c) 2000 Static Free Software.
10 *
11 * Electric(tm) is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * Electric(tm) is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with Electric(tm); see the file COPYING. If not, write to
23 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
24 * Boston, Mass 02111-1307, USA.
25 *
26 * Static Free Software
27 * 4119 Alpine Road
28 * Portola Valley, California 94028
29 * info@staticfreesoft.com
30 */
31
32 #include "config.h"
33 #if LANGJAVA
34
35 #include "global.h"
36 #include "dblang.h"
37 #include "usr.h"
38
39 #define MAXLINE 300
40 /* #define OLDJAVA 1 */ /* uncomment to force JDK 1.1 */
41 #ifdef WIN32
42 # define PATHSEP ';'
43 #else
44 # define PATHSEP ':'
45 #endif
46
47 INTBIG java_inited = 0;
48 JavaVM *java_virtualmachine; /* denotes a Java VM */
49 JNIEnv *java_environment; /* pointer to native method interface */
50 jclass java_electricclass;
51 jclass java_electriceoutclass;
52 jfieldID java_addressID;
53 jfieldID java_xarrayVID;
54 jobject java_nullobject;
55 CHAR *java_arraybuffer;
56 INTBIG java_arraybuffersize = 0;
57
58 /* for the Bean Shell */
59 jobject java_bshInterpreterObject;
60 jmethodID java_bshEvalMID;
61
62 CHAR java_outputbuffer[MAXLINE+1];
63 INTBIG java_outputposition = 0;
64
65 jclass java_classstring;
66 jclass java_classint;
67 jclass java_classfloat;
68 jclass java_classdouble;
69 jclass java_classarrayint;
70 jmethodID java_midIntValue, java_midIntInit;
71 jmethodID java_midFloatValue, java_midFloatInit;
72 jmethodID java_midDoubleValue;
73
74 jclass java_classnodeinst;
75 jclass java_classnodeproto;
76 jclass java_classportarcinst;
77 jclass java_classportexpinst;
78 jclass java_classportproto;
79 jclass java_classarcinst;
80 jclass java_classarcproto;
81 jclass java_classgeom;
82 jclass java_classlibrary;
83 jclass java_classtechnology;
84 jclass java_classtool;
85 jclass java_classrtnode;
86 jclass java_classnetwork;
87 jclass java_classview;
88 jclass java_classwindowpart;
89 jclass java_classwindowframe;
90 jclass java_classgraphics;
91 jclass java_classconstraint;
92 jclass java_classpolygon;
93 jclass java_classxarray;
94
95 extern "C"
96 {
97 JNIEXPORT jobject JNICALL Java_Electric_curLib(JNIEnv *env, jobject obj);
98 JNIEXPORT jobject JNICALL Java_Electric_curTech(JNIEnv *env, jobject obj);
99 JNIEXPORT jobject JNICALL Java_Electric_getValNodeinst(JNIEnv *env, jobject obj,
100 jobject object, jstring qual);
101 JNIEXPORT jobject JNICALL Java_Electric_getValNodeproto(JNIEnv *env, jobject obj,
102 jobject object, jstring qual);
103 JNIEXPORT jobject JNICALL Java_Electric_getValPortarcinst(JNIEnv *env, jobject obj,
104 jobject object, jstring qual);
105 JNIEXPORT jobject JNICALL Java_Electric_getValPortexpinst(JNIEnv *env, jobject obj,
106 jobject object, jstring qual);
107 JNIEXPORT jobject JNICALL Java_Electric_getValPortproto(JNIEnv *env, jobject obj,
108 jobject object, jstring qual);
109 JNIEXPORT jobject JNICALL Java_Electric_getValArcinst(JNIEnv *env, jobject obj,
110 jobject object, jstring qual);
111 JNIEXPORT jobject JNICALL Java_Electric_getValArcproto(JNIEnv *env, jobject obj,
112 jobject object, jstring qual);
113 JNIEXPORT jobject JNICALL Java_Electric_getValGeom(JNIEnv *env, jobject obj,
114 jobject object, jstring qual);
115 JNIEXPORT jobject JNICALL Java_Electric_getValLibrary(JNIEnv *env, jobject obj,
116 jobject object, jstring qual);
117 JNIEXPORT jobject JNICALL Java_Electric_getValTechnology(JNIEnv *env, jobject obj,
118 jobject object, jstring qual);
119 JNIEXPORT jobject JNICALL Java_Electric_getValTool(JNIEnv *env, jobject obj,
120 jobject object, jstring qual);
121 JNIEXPORT jobject JNICALL Java_Electric_getValRTNode(JNIEnv *env, jobject obj,
122 jobject object, jstring qual);
123 JNIEXPORT jobject JNICALL Java_Electric_getValNetwork(JNIEnv *env, jobject obj,
124 jobject object, jstring qual);
125 JNIEXPORT jobject JNICALL Java_Electric_getValView(JNIEnv *env, jobject obj,
126 jobject object, jstring qual);
127 JNIEXPORT jobject JNICALL Java_Electric_getValWindowpart(JNIEnv *env, jobject obj,
128 jobject object, jstring qual);
129 JNIEXPORT jobject JNICALL Java_Electric_getValWindowframe(JNIEnv *env, jobject obj,
130 jobject object, jstring qual);
131 JNIEXPORT jobject JNICALL Java_Electric_getValGraphics(JNIEnv *env, jobject obj,
132 jobject object, jstring qual);
133 JNIEXPORT jobject JNICALL Java_Electric_getValConstraint(JNIEnv *env, jobject obj,
134 jobject object, jstring qual);
135 JNIEXPORT jobject JNICALL Java_Electric_getValPolygon(JNIEnv *env, jobject obj,
136 jobject object, jstring qual);
137 JNIEXPORT jobject JNICALL Java_Electric_getParentVal(JNIEnv *env, jobject obj,
138 jstring jname, jobject jdefault, jint jheight);
139 JNIEXPORT void JNICALL Java_Electric_setVal(JNIEnv *env, jobject obj,
140 jobject jobj, jstring jqual, jobject jattr, jint jbits);
141 JNIEXPORT void JNICALL Java_Electric_setInd(JNIEnv *env, jobject obj,
142 jobject jobj, jstring jname, jint index, jobject jattr);
143 JNIEXPORT void JNICALL Java_Electric_delVal(JNIEnv *env, jobject obj,
144 jobject jobj, jstring jname);
145 JNIEXPORT jint JNICALL Java_Electric_initSearch(JNIEnv *env, jobject obj,
146 jint lx, jint hx, jint ly, jint hy, jobject cell);
147 JNIEXPORT jobject JNICALL Java_Electric_nextObject(JNIEnv *env, jobject obj,
148 jint sea);
149 JNIEXPORT void JNICALL Java_Electric_termSearch(JNIEnv *env, jobject obj,
150 jint sea);
151 JNIEXPORT jobject JNICALL Java_Electric_getTool(JNIEnv *env, jobject obj,
152 jstring name);
153 JNIEXPORT jint JNICALL Java_Electric_maxTool(JNIEnv *env, jobject obj);
154 JNIEXPORT jobject JNICALL Java_Electric_indexTool(JNIEnv *env, jobject obj,
155 jint index);
156 JNIEXPORT void JNICALL Java_Electric_toolTurnOn(JNIEnv *env, jobject obj,
157 jobject tool);
158 JNIEXPORT void JNICALL Java_Electric_toolTurnOff(JNIEnv *env, jobject obj,
159 jobject tool);
160 JNIEXPORT void JNICALL Java_Electric_tellTool(JNIEnv *env, jobject obj,
161 jobject tool, jint argc, jobjectArray jargv);
162 JNIEXPORT jobject JNICALL Java_Electric_getLibrary(JNIEnv *env, jobject obj,
163 jstring name);
164 JNIEXPORT jobject JNICALL Java_Electric_newLibrary(JNIEnv *env, jobject obj,
165 jstring libname, jstring libfile);
166 JNIEXPORT void JNICALL Java_Electric_killLibrary(JNIEnv *env, jobject obj,
167 jobject lib);
168 JNIEXPORT void JNICALL Java_Electric_eraseLibrary(JNIEnv *env, jobject obj,
169 jobject lib);
170 JNIEXPORT void JNICALL Java_Electric_selectLibrary(JNIEnv *env, jobject obj,
171 jobject lib);
172 JNIEXPORT jobject JNICALL Java_Electric_getNodeProto(JNIEnv *env, jobject obj,
173 jstring name);
174 JNIEXPORT jobject JNICALL Java_Electric_newNodeProto(JNIEnv *env, jobject obj,
175 jstring name, jobject lib);
176 JNIEXPORT jint JNICALL Java_Electric_killNodeProto(JNIEnv *env, jobject obj,
177 jobject cell);
178 JNIEXPORT jobject JNICALL Java_Electric_copyNodeProto(JNIEnv *env, jobject obj,
179 jobject cell, jobject lib, jstring name);
180 JNIEXPORT jobject JNICALL Java_Electric_iconView(JNIEnv *env, jobject obj,
181 jobject cell);
182 JNIEXPORT jobject JNICALL Java_Electric_contentsView(JNIEnv *env, jobject obj,
183 jobject cell);
184 JNIEXPORT jobject JNICALL Java_Electric_newNodeInst(JNIEnv *env, jobject obj,
185 jobject proto, jint lx, jint hx, jint ly, jint hy, jint trans, jint rot, jobject cell);
186 JNIEXPORT void JNICALL Java_Electric_modifyNodeInst(JNIEnv *env, jobject obj,
187 jobject node, jint dlx, jint dly, jint dhx, jint dhy, jint drot, jint dtrans);
188 JNIEXPORT jint JNICALL Java_Electric_killNodeInst(JNIEnv *env, jobject obj,
189 jobject node);
190 JNIEXPORT jobject JNICALL Java_Electric_replaceNodeInst(JNIEnv *env, jobject obj,
191 jobject node, jobject proto);
192 JNIEXPORT jint JNICALL Java_Electric_nodeFunction(JNIEnv *env, jobject obj,
193 jobject node);
194 JNIEXPORT jint JNICALL Java_Electric_nodePolys(JNIEnv *env, jobject obj,
195 jobject node);
196 JNIEXPORT jobject JNICALL Java_Electric_shapeNodePoly(JNIEnv *env, jobject obj,
197 jobject node, jint jindex);
198 JNIEXPORT jint JNICALL Java_Electric_nodeEPolys(JNIEnv *env, jobject obj,
199 jobject node);
200 JNIEXPORT jobject JNICALL Java_Electric_shapeENodePoly(JNIEnv *env, jobject obj,
201 jobject node, jint jindex);
202 JNIEXPORT jobject JNICALL Java_Electric_makeRot(JNIEnv *env, jobject obj,
203 jobject node);
204 JNIEXPORT jobject JNICALL Java_Electric_makeTrans(JNIEnv *env, jobject obj,
205 jobject node);
206 JNIEXPORT jintArray JNICALL Java_Electric_nodeProtoSizeOffset(JNIEnv *env, jobject obj,
207 jobject jnp);
208 JNIEXPORT jobject JNICALL Java_Electric_newArcInst(JNIEnv *env, jobject obj,
209 jobject proto, jint wid, jint bits, jobject node1, jobject port1, jint x1, jint y1,
210 jobject node2, jobject port2, jint x2, jint y2, jobject cell);
211 JNIEXPORT jint JNICALL Java_Electric_modifyArcInst(JNIEnv *env, jobject obj,
212 jobject arc, jint dwid, jint dx1, jint dy1, jint dx2, jint dy2);
213 JNIEXPORT jint JNICALL Java_Electric_killArcInst(JNIEnv *env, jobject obj,
214 jobject arc);
215 JNIEXPORT jobject JNICALL Java_Electric_replaceArcInst(JNIEnv *env, jobject obj,
216 jobject arc, jobject proto);
217 JNIEXPORT jint JNICALL Java_Electric_arcPolys(JNIEnv *env, jobject obj,
218 jobject arc);
219 JNIEXPORT jobject JNICALL Java_Electric_shapeArcPoly(JNIEnv *env, jobject obj,
220 jobject arc, jint jindex);
221 JNIEXPORT jint JNICALL Java_Electric_arcProtoWidthOffset(JNIEnv *env, jobject obj,
222 jobject jap);
223 JNIEXPORT jobject JNICALL Java_Electric_newPortProto(JNIEnv *env, jobject obj,
224 jobject cell, jobject node, jobject port, jstring name);
225 JNIEXPORT jobjectArray JNICALL Java_Electric_portPosition(JNIEnv *env, jobject obj,
226 jobject jni, jobject jpp);
227 JNIEXPORT jobject JNICALL Java_Electric_getPortProto(JNIEnv *env, jobject obj,
228 jobject cell, jstring name);
229 JNIEXPORT jint JNICALL Java_Electric_killPortProto(JNIEnv *env, jobject obj,
230 jobject cell, jobject port);
231 JNIEXPORT jint JNICALL Java_Electric_movePortProto(JNIEnv *env, jobject obj,
232 jobject cell, jobject oldport, jobject newnode, jobject newport);
233 JNIEXPORT jobject JNICALL Java_Electric_shapePortPoly(JNIEnv *env, jobject obj,
234 jobject jnode, jobject jport);
235 JNIEXPORT jint JNICALL Java_Electric_undoABatch(JNIEnv *env, jobject obj);
236 JNIEXPORT void JNICALL Java_Electric_noUndoAllowed(JNIEnv *env, jobject obj);
237 JNIEXPORT void JNICALL Java_Electric_flushChanges(JNIEnv *env, jobject obj);
238 JNIEXPORT jobject JNICALL Java_Electric_getView(JNIEnv *env, jobject obj,
239 jstring name);
240 JNIEXPORT jobject JNICALL Java_Electric_newView(JNIEnv *env, jobject obj,
241 jstring name, jstring sname);
242 JNIEXPORT jint JNICALL Java_Electric_killView(JNIEnv *env, jobject obj,
243 jobject view);
244 JNIEXPORT jobject JNICALL Java_Electric_getArcProto(JNIEnv *env, jobject obj,
245 jstring name);
246 JNIEXPORT jobject JNICALL Java_Electric_getTechnology(JNIEnv *env, jobject obj,
247 jstring name);
248 JNIEXPORT jobject JNICALL Java_Electric_getPinProto(JNIEnv *env, jobject obj,
249 jobject arcproto);
250 JNIEXPORT jobject JNICALL Java_Electric_getNetwork(JNIEnv *env, jobject obj,
251 jstring name, jobject cell);
252 JNIEXPORT jstring JNICALL Java_Electric_layerName(JNIEnv *env, jobject obj,
253 jobject jtech, jint jlayer);
254 JNIEXPORT jint JNICALL Java_Electric_layerFunction(JNIEnv *env, jobject obj,
255 jobject jtech, jint jlayer);
256 JNIEXPORT jint JNICALL Java_Electric_maxDRCSurround(JNIEnv *env, jobject obj,
257 jobject jtech, jobject jlib, jint jlayer);
258 JNIEXPORT jint JNICALL Java_Electric_DRCMinDistance(JNIEnv *env, jobject obj,
259 jobject jtech, jobject jlib, jint jlayer1, jint jlayer2, jint jconnected);
260 JNIEXPORT jint JNICALL Java_Electric_DRCMinWidth(JNIEnv *env, jobject obj,
261 jobject jtech, jobject jlib, jint jlayer);
262 JNIEXPORT void JNICALL Java_Electric_xformPoly(JNIEnv *env, jobject obj,
263 jobject jpoly, jobject jtrans);
264 JNIEXPORT jobject JNICALL Java_Electric_transMult(JNIEnv *env, jobject obj,
265 jobject jtransa, jobject jtransb);
266 JNIEXPORT void JNICALL Java_Electric_freePolygon(JNIEnv *env, jobject obj,
267 jobject jpoly);
268 JNIEXPORT void JNICALL Java_Electric_beginTraverseHierarchy(JNIEnv *env, jobject obj);
269 JNIEXPORT void JNICALL Java_Electric_downHierarchy(JNIEnv *env, jobject obj,
270 jobject jni, jint jindex);
271 JNIEXPORT void JNICALL Java_Electric_upHierarchy(JNIEnv *env, jobject obj);
272 JNIEXPORT void JNICALL Java_Electric_endTraverseHierarchy(JNIEnv *env, jobject obj);
273 JNIEXPORT jobject JNICALL Java_Electric_getTraversalPath(JNIEnv *env, jobject obj);
274
275 JNIEXPORT void JNICALL Java_Electric_eoutWriteOne(JNIEnv *env, jobject obj,
276 jint byte);
277 JNIEXPORT void JNICALL Java_Electric_eoutWriteString(JNIEnv *env, jobject obj,
278 jstring string);
279 }
280
281 static JNINativeMethod electricmethods[] =
282 {
283 /***************** DATABASE EXAMINATION ROUTINES *****************/
284 {b_("curLib"),
285 b_("()LCOM/staticfreesoft/Electric$Library;"),
286 (void *)Java_Electric_curLib},
287 {b_("curTech"),
288 b_("()LCOM/staticfreesoft/Electric$Technology;"),
289 (void *)Java_Electric_curTech},
290 {b_("getVal"),
291 b_("(LCOM/staticfreesoft/Electric$NodeInst;Ljava/lang/String;)Ljava/lang/Object;"),
292 (void *)Java_Electric_getValNodeinst},
293 {b_("getVal"),
294 b_("(LCOM/staticfreesoft/Electric$NodeProto;Ljava/lang/String;)Ljava/lang/Object;"),
295 (void *)Java_Electric_getValNodeproto},
296 {b_("getVal"),
297 b_("(LCOM/staticfreesoft/Electric$PortArcInst;Ljava/lang/String;)Ljava/lang/Object;"),
298 (void *)Java_Electric_getValPortarcinst},
299 {b_("getVal"),
300 b_("(LCOM/staticfreesoft/Electric$PortExpInst;Ljava/lang/String;)Ljava/lang/Object;"),
301 (void *)Java_Electric_getValPortexpinst},
302 {b_("getVal"),
303 b_("(LCOM/staticfreesoft/Electric$PortProto;Ljava/lang/String;)Ljava/lang/Object;"),
304 (void *)Java_Electric_getValPortproto},
305 {b_("getVal"),
306 b_("(LCOM/staticfreesoft/Electric$ArcInst;Ljava/lang/String;)Ljava/lang/Object;"),
307 (void *)Java_Electric_getValArcinst},
308 {b_("getVal"),
309 b_("(LCOM/staticfreesoft/Electric$ArcProto;Ljava/lang/String;)Ljava/lang/Object;"),
310 (void *)Java_Electric_getValArcproto},
311 {b_("getVal"),
312 b_("(LCOM/staticfreesoft/Electric$Geom;Ljava/lang/String;)Ljava/lang/Object;"),
313 (void *)Java_Electric_getValGeom},
314 {b_("getVal"),
315 b_("(LCOM/staticfreesoft/Electric$Library;Ljava/lang/String;)Ljava/lang/Object;"),
316 (void *)Java_Electric_getValLibrary},
317 {b_("getVal"),
318 b_("(LCOM/staticfreesoft/Electric$Technology;Ljava/lang/String;)Ljava/lang/Object;"),
319 (void *)Java_Electric_getValTechnology},
320 {b_("getVal"),
321 b_("(LCOM/staticfreesoft/Electric$Tool;Ljava/lang/String;)Ljava/lang/Object;"),
322 (void *)Java_Electric_getValTool},
323 {b_("getVal"),
324 b_("(LCOM/staticfreesoft/Electric$RTNode;Ljava/lang/String;)Ljava/lang/Object;"),
325 (void *)Java_Electric_getValRTNode},
326 {b_("getVal"),
327 b_("(LCOM/staticfreesoft/Electric$Network;Ljava/lang/String;)Ljava/lang/Object;"),
328 (void *)Java_Electric_getValNetwork},
329 {b_("getVal"),
330 b_("(LCOM/staticfreesoft/Electric$View;Ljava/lang/String;)Ljava/lang/Object;"),
331 (void *)Java_Electric_getValView},
332 {b_("getVal"),
333 b_("(LCOM/staticfreesoft/Electric$WindowPart;Ljava/lang/String;)Ljava/lang/Object;"),
334 (void *)Java_Electric_getValWindowpart},
335 {b_("getVal"),
336 b_("(LCOM/staticfreesoft/Electric$WindowFrame;Ljava/lang/String;)Ljava/lang/Object;"),
337 (void *)Java_Electric_getValWindowframe},
338 {b_("getVal"),
339 b_("(LCOM/staticfreesoft/Electric$Graphics;Ljava/lang/String;)Ljava/lang/Object;"),
340 (void *)Java_Electric_getValGraphics},
341 {b_("getVal"),
342 b_("(LCOM/staticfreesoft/Electric$Constraint;Ljava/lang/String;)Ljava/lang/Object;"),
343 (void *)Java_Electric_getValConstraint},
344 {b_("getVal"),
345 b_("(LCOM/staticfreesoft/Electric$Polygon;Ljava/lang/String;)Ljava/lang/Object;"),
346 (void *)Java_Electric_getValPolygon},
347 {b_("getParentVal"),
348 b_("(Ljava/lang/String;Ljava/lang/Object;I)Ljava/lang/Object;"),
349 (void *)Java_Electric_getParentVal},
350 {b_("setVal"),
351 b_("(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;I)V"),
352 (void *)Java_Electric_setVal},
353 {b_("setInd"),
354 b_("(Ljava/lang/Object;Ljava/lang/String;ILjava/lang/Object;)V"),
355 (void *)Java_Electric_setInd},
356 {b_("delVal"),
357 b_("(Ljava/lang/Object;Ljava/lang/String;)V"),
358 (void *)Java_Electric_delVal},
359 {b_("initSearch"),
360 b_("(IIIILCOM/staticfreesoft/Electric$NodeProto;)I"),
361 (void *)Java_Electric_initSearch},
362 {b_("nextObject"),
363 b_("(I)Ljava/lang/Object;"),
364 (void *)Java_Electric_nextObject},
365 {b_("termSearch"),
366 b_("(I)V"),
367 (void *)Java_Electric_termSearch},
368
369 /***************** TOOL ROUTINES *****************/
370 {b_("getTool"),
371 b_("(Ljava/lang/String;)LCOM/staticfreesoft/Electric$Tool;"),
372 (void *)Java_Electric_getTool},
373 {b_("maxTool"),
374 b_("()I"),
375 (void *)Java_Electric_maxTool},
376 {b_("indexTool"),
377 b_("(I)LCOM/staticfreesoft/Electric$Tool;"),
378 (void *)Java_Electric_indexTool},
379 {b_("toolTurnOn"),
380 b_("(LCOM/staticfreesoft/Electric$Tool;)V"),
381 (void *)Java_Electric_toolTurnOn},
382 {b_("toolTurnOff"),
383 b_("(LCOM/staticfreesoft/Electric$Tool;)V"),
384 (void *)Java_Electric_toolTurnOff},
385 {b_("tellTool"),
386 b_("(LCOM/staticfreesoft/Electric$Tool;I[Ljava/lang/String;)V"),
387 (void *)Java_Electric_tellTool},
388
389 /***************** LIBRARY ROUTINES *****************/
390 {b_("getLibrary"),
391 b_("(Ljava/lang/String;)LCOM/staticfreesoft/Electric$Library;"),
392 (void *)Java_Electric_getLibrary},
393 {b_("newLibrary"),
394 b_("(Ljava/lang/String;Ljava/lang/String;)LCOM/staticfreesoft/Electric$Library;"),
395 (void *)Java_Electric_newLibrary},
396 {b_("killLibrary"),
397 b_("(LCOM/staticfreesoft/Electric$Library;)V"),
398 (void *)Java_Electric_killLibrary},
399 {b_("eraseLibrary"),
400 b_("(LCOM/staticfreesoft/Electric$Library;)V"),
401 (void *)Java_Electric_eraseLibrary},
402 {b_("selectLibrary"),
403 b_("(LCOM/staticfreesoft/Electric$Library;)V"),
404 (void *)Java_Electric_selectLibrary},
405
406 /***************** NODEPROTO ROUTINES *****************/
407 {b_("getNodeProto"),
408 b_("(Ljava/lang/String;)LCOM/staticfreesoft/Electric$NodeProto;"),
409 (void *)Java_Electric_getNodeProto},
410 {b_("newNodeProto"),
411 b_("(Ljava/lang/String;LCOM/staticfreesoft/Electric$Library;)LCOM/staticfreesoft/Electric$NodeProto;"),
412 (void *)Java_Electric_newNodeProto},
413 {b_("killNodeProto"),
414 b_("(LCOM/staticfreesoft/Electric$NodeProto;)I"),
415 (void *)Java_Electric_killNodeProto},
416 {b_("copyNodeProto"),
417 b_("(LCOM/staticfreesoft/Electric$NodeProto;LCOM/staticfreesoft/Electric$Library;Ljava/lang/String;)LCOM/staticfreesoft/Electric$NodeProto;"),
418 (void *)Java_Electric_copyNodeProto},
419 {b_("iconView"),
420 b_("(LCOM/staticfreesoft/Electric$NodeProto;)LCOM/staticfreesoft/Electric$NodeProto;"),
421 (void *)Java_Electric_iconView},
422 {b_("contentsView"),
423 b_("(LCOM/staticfreesoft/Electric$NodeProto;)LCOM/staticfreesoft/Electric$NodeProto;"),
424 (void *)Java_Electric_contentsView},
425
426 /***************** NODEINST ROUTINES *****************/
427 {b_("newNodeInst"),
428 b_("(LCOM/staticfreesoft/Electric$NodeProto;IIIIIILCOM/staticfreesoft/Electric$NodeProto;)LCOM/staticfreesoft/Electric$NodeInst;"),
429 (void *)Java_Electric_newNodeInst},
430 {b_("modifyNodeInst"),
431 b_("(LCOM/staticfreesoft/Electric$NodeInst;IIIIII)V"),
432 (void *)Java_Electric_modifyNodeInst},
433 {b_("killNodeInst"),
434 b_("(LCOM/staticfreesoft/Electric$NodeInst;)I"),
435 (void *)Java_Electric_killNodeInst},
436 {b_("replaceNodeInst"),
437 b_("(LCOM/staticfreesoft/Electric$NodeInst;LCOM/staticfreesoft/Electric$NodeProto;)LCOM/staticfreesoft/Electric$NodeInst;"),
438 (void *)Java_Electric_replaceNodeInst},
439 {b_("nodeFunction"),
440 b_("(LCOM/staticfreesoft/Electric$NodeInst;)I"),
441 (void *)Java_Electric_nodeFunction},
442 {b_("nodePolys"),
443 b_("(LCOM/staticfreesoft/Electric$NodeInst;)I"),
444 (void *)Java_Electric_nodePolys},
445 {b_("shapeNodePoly"),
446 b_("(LCOM/staticfreesoft/Electric$NodeInst;I)LCOM/staticfreesoft/Electric$Polygon;"),
447 (void *)Java_Electric_shapeNodePoly},
448 {b_("nodeEPolys"),
449 b_("(LCOM/staticfreesoft/Electric$NodeInst;)I"),
450 (void *)Java_Electric_nodeEPolys},
451 {b_("shapeENodePoly"),
452 b_("(LCOM/staticfreesoft/Electric$NodeInst;I)LCOM/staticfreesoft/Electric$Polygon;"),
453 (void *)Java_Electric_shapeENodePoly},
454 {b_("makeRot"),
455 b_("(LCOM/staticfreesoft/Electric$NodeInst;)LCOM/staticfreesoft/Electric$XArray;"),
456 (void *)Java_Electric_makeRot},
457 {b_("makeTrans"),
458 b_("(LCOM/staticfreesoft/Electric$NodeInst;)LCOM/staticfreesoft/Electric$XArray;"),
459 (void *)Java_Electric_makeTrans},
460 {b_("nodeProtoSizeOffset"),
461 b_("(LCOM/staticfreesoft/Electric$NodeProto;)[I"),
462 (void *)Java_Electric_nodeProtoSizeOffset},
463
464 /***************** ARCINST ROUTINES *****************/
465 {b_("newArcInst"),
466 b_("(LCOM/staticfreesoft/Electric$ArcProto;IILCOM/staticfreesoft/Electric$NodeInst;LCOM/staticfreesoft/Electric$PortProto;IILCOM/staticfreesoft/Electric$NodeInst;LCOM/staticfreesoft/Electric$PortProto;IILCOM/staticfreesoft/Electric$NodeProto;)LCOM/staticfreesoft/Electric$ArcInst;"),
467 (void *)Java_Electric_newArcInst},
468 {b_("modifyArcInst"),
469 b_("(LCOM/staticfreesoft/Electric$ArcInst;IIIII)I"),
470 (void *)Java_Electric_modifyArcInst},
471 {b_("killArcInst"),
472 b_("(LCOM/staticfreesoft/Electric$ArcInst;)I"),
473 (void *)Java_Electric_killArcInst},
474 {b_("replaceArcInst"),
475 b_("(LCOM/staticfreesoft/Electric$ArcInst;LCOM/staticfreesoft/Electric$ArcProto;)LCOM/staticfreesoft/Electric$ArcInst;"),
476 (void *)Java_Electric_replaceArcInst},
477 {b_("arcPolys"),
478 b_("(LCOM/staticfreesoft/Electric$ArcInst;)I"),
479 (void *)Java_Electric_arcPolys},
480 {b_("shapeArcPoly"),
481 b_("(LCOM/staticfreesoft/Electric$ArcInst;I)LCOM/staticfreesoft/Electric$Polygon;"),
482 (void *)Java_Electric_shapeArcPoly},
483 {b_("arcProtoWidthOffset"),
484 b_("(LCOM/staticfreesoft/Electric$ArcProto;)I"),
485 (void *)Java_Electric_arcProtoWidthOffset},
486
487 /***************** PORTPROTO ROUTINES *****************/
488 {b_("newPortProto"),
489 b_("(LCOM/staticfreesoft/Electric$NodeProto;LCOM/staticfreesoft/Electric$NodeInst;LCOM/staticfreesoft/Electric$PortProto;Ljava/lang/String;)LCOM/staticfreesoft/Electric$PortProto;"),
490 (void *)Java_Electric_newPortProto},
491 {b_("portPosition"),
492 b_("(LCOM/staticfreesoft/Electric$NodeInst;LCOM/staticfreesoft/Electric$PortProto;)[Ljava/lang/Integer;"),
493 (void *)Java_Electric_portPosition},
494 {b_("getPortProto"),
495 b_("(LCOM/staticfreesoft/Electric$NodeProto;Ljava/lang/String;)LCOM/staticfreesoft/Electric$PortProto;"),
496 (void *)Java_Electric_getPortProto},
497 {b_("killPortProto"),
498 b_("(LCOM/staticfreesoft/Electric$NodeProto;LCOM/staticfreesoft/Electric$PortProto;)I"),
499 (void *)Java_Electric_killPortProto},
500 {b_("movePortProto"),
501 b_("(LCOM/staticfreesoft/Electric$NodeProto;LCOM/staticfreesoft/Electric$PortProto;LCOM/staticfreesoft/Electric$NodeInst;LCOM/staticfreesoft/Electric$PortProto;)I"),
502 (void *)Java_Electric_movePortProto},
503 {b_("shapePortPoly"),
504 b_("(LCOM/staticfreesoft/Electric$NodeInst;LCOM/staticfreesoft/Electric$PortProto;)LCOM/staticfreesoft/Electric$Polygon;"),
505 (void *)Java_Electric_shapePortPoly},
506
507 /***************** CHANGE CONTROL ROUTINES *****************/
508 {b_("undoABatch"),
509 b_("()I"),
510 (void *)Java_Electric_undoABatch},
511 {b_("noUndoAllowed"),
512 b_("()V"),
513 (void *)Java_Electric_noUndoAllowed},
514 {b_("flushChanges"),
515 b_("()V"),
516 (void *)Java_Electric_flushChanges},
517
518 /***************** VIEW ROUTINES *****************/
519 {b_("getView"),
520 b_("(Ljava/lang/String;)LCOM/staticfreesoft/Electric$View;"),
521 (void *)Java_Electric_getView},
522 {b_("newView"),
523 b_("(Ljava/lang/String;Ljava/lang/String;)LCOM/staticfreesoft/Electric$View;"),
524 (void *)Java_Electric_newView},
525 {b_("killView"),
526 b_("(LCOM/staticfreesoft/Electric$View;)I"),
527 (void *)Java_Electric_killView},
528
529 /***************** MISCELLANEOUS ROUTINES *****************/
530 {b_("getArcProto"),
531 b_("(Ljava/lang/String;)LCOM/staticfreesoft/Electric$ArcProto;"),
532 (void *)Java_Electric_getArcProto},
533 {b_("getTechnology"),
534 b_("(Ljava/lang/String;)LCOM/staticfreesoft/Electric$Technology;"),
535 (void *)Java_Electric_getTechnology},
536 {b_("getPinProto"),
537 b_("(LCOM/staticfreesoft/Electric$ArcProto;)LCOM/staticfreesoft/Electric$NodeProto;"),
538 (void *)Java_Electric_getPinProto},
539 {b_("getNetwork"),
540 b_("(Ljava/lang/String;LCOM/staticfreesoft/Electric$NodeProto;)LCOM/staticfreesoft/Electric$Network;"),
541 (void *)Java_Electric_getNetwork},
542 {b_("layerName"),
543 b_("(LCOM/staticfreesoft/Electric$Technology;I)Ljava/lang/String;"),
544 (void *)Java_Electric_layerName},
545 {b_("layerFunction"),
546 b_("(LCOM/staticfreesoft/Electric$Technology;I)I"),
547 (void *)Java_Electric_layerFunction},
548 {b_("maxDRCSurround"),
549 b_("(LCOM/staticfreesoft/Electric$Technology;LCOM/staticfreesoft/Electric$Library;I)I"),
550 (void *)Java_Electric_maxDRCSurround},
551 {b_("DRCMinDistance"),
552 b_("(LCOM/staticfreesoft/Electric$Technology;LCOM/staticfreesoft/Electric$Library;III)I"),
553 (void *)Java_Electric_DRCMinDistance},
554 {b_("DRCMinWidth"),
555 b_("(LCOM/staticfreesoft/Electric$Technology;LCOM/staticfreesoft/Electric$Library;I)I"),
556 (void *)Java_Electric_DRCMinWidth},
557 {b_("xformPoly"),
558 b_("(LCOM/staticfreesoft/Electric$Polygon;LCOM/staticfreesoft/Electric$XArray;)V"),
559 (void *)Java_Electric_xformPoly},
560 {b_("transMult"),
561 b_("(LCOM/staticfreesoft/Electric$XArray;LCOM/staticfreesoft/Electric$XArray;)LCOM/staticfreesoft/Electric$XArray;"),
562 (void *)Java_Electric_transMult},
563 {b_("freePolygon"),
564 b_("(LCOM/staticfreesoft/Electric$Polygon;)V"),
565 (void *)Java_Electric_freePolygon},
566 {b_("beginTraverseHierarchy"),
567 b_("()V"),
568 (void *)Java_Electric_beginTraverseHierarchy},
569 {b_("downHierarchy"),
570 b_("(LCOM/staticfreesoft/Electric$NodeInst;I)V"),
571 (void *)Java_Electric_downHierarchy},
572 {b_("upHierarchy"),
573 b_("()V"),
574 (void *)Java_Electric_upHierarchy},
575 {b_("endTraverseHierarchy"),
576 b_("()V"),
577 (void *)Java_Electric_endTraverseHierarchy},
578 {b_("getTraversalPath"),
579 b_("()[LCOM/staticfreesoft/Electric$NodeInst;"),
580 (void *)Java_Electric_getTraversalPath}
581 };
582
583 static JNINativeMethod electriceoutmethods[] =
584 {
585 {b_("write"),
586 b_("(I)V"),
587 (void *)Java_Electric_eoutWriteOne},
588 {b_("ewrite"),
589 b_("(Ljava/lang/String;)V"),
590 (void *)Java_Electric_eoutWriteString}
591 };
592
593 /* prototypes for local routines */
594 static jint JNICALL java_vfprintf(FILE *fp, const CHAR1 *format, va_list args);
595 static void JNICALL java_exit(jint code);
596 static jobject java_getval(jobject obj, INTBIG type, jstring jname);
597 static void java_addcharacter(CHAR chr);
598 static void java_getobjectaddrtype(jobject obj, INTBIG *addr, INTBIG *type, CHAR **description);
599 static BOOLEAN java_allocarraybuffer(INTBIG size);
600 static jobject java_makejavaobject(INTBIG addr, INTBIG type, jclass javaclass, INTBIG desttype);
601 static BOOLEAN java_reportexceptions(void);
602 static CHAR *java_finddbmirror(void); /* added by Mike Wessler on 5/20/02 */
603 static CHAR *java_findbeanshell(void);
604 static void java_dumpclass(jclass theClass);
605
606 /****************************** ELECTRIC INTERFACE ******************************/
607
608 /*
609 * Routine to free all memory associated with this module.
610 */
java_freememory(void)611 void java_freememory(void)
612 {
613 if (java_arraybuffersize > 0)
614 efree((CHAR *)java_arraybuffer);
615 }
616
java_init(void)617 CHAR *java_init(void)
618 {
619 CHAR *userclasspath, *allocatedpath;
620 CHAR1 *properties[10];
621 static CHAR *bsh, *classpath, *dbmirror;
622 INTBIG ac, err, i, noptions;
623 jclass interpreterClass, classClz;
624 jmethodID mid;
625 jstring string;
626 REGISTER void *infstr;
627 static CHAR *bshInit[] =
628 {
629 x_("E = new COM.staticfreesoft.Electric();"),
630 x_("Object P(String par) { return E.getParentVal(\"ATTR_\"+par, new Integer(0), 1); }"),
631 x_("Object PD(String par, int def) { return E.getParentVal(\"ATTR_\"+par, new Integer(def), 1); }"),
632 x_("Object PD(String par, float def) { return E.getParentVal(\"ATTR_\"+par, new Float(def), 1); }"),
633 x_("Object PD(String par, Object def) { return E.getParentVal(\"ATTR_\"+par, def, 1); }"),
634 x_("Object PAR(String par) { return E.getParentVal(\"ATTR_\"+par, new Integer(0), 0); }"),
635 x_("Object PARD(String par, int def) { return E.getParentVal(\"ATTR_\"+par, new Integer(def), 0); }"),
636 x_("Object PARD(String par, float def) { return E.getParentVal(\"ATTR_\"+par, new Float(def), 0); }"),
637 x_("Object PARD(String par, Object def) { return E.getParentVal(\"ATTR_\"+par, def, 0); }"),
638 0
639 };
640 JDK1_1InitArgs vm1args;
641 JavaVMInitArgs vm2args;
642 JavaVMOption joptions[10];
643
644 if (java_inited != 0)
645 {
646 if (bsh != 0) return(x_("Java Bean Shell"));
647 return(x_("Java"));
648 }
649
650 /* construct the class path */
651 infstr = initinfstr();
652
653 /* add the environment variable CLASSPATH if it exists */
654 userclasspath = egetenv(x_("CLASSPATH"));
655 if (userclasspath != 0)
656 formatinfstr(infstr, x_("%c%s"), PATHSEP, userclasspath);
657
658 /* add the Bean Shell to the class path if it exists */
659 bsh = java_findbeanshell();
660 if (bsh != 0)
661 formatinfstr(infstr, x_("%c%sjava%c%s"), PATHSEP, el_libdir, DIRSEP, bsh);
662
663 /* add the dbmirror to the class path if it exists (MW 5/20/02) */
664 dbmirror = java_finddbmirror();
665 if (dbmirror != 0)
666 formatinfstr(infstr, x_("%c%sjava%c%s"), PATHSEP, el_libdir, DIRSEP, dbmirror);
667
668 /* add Electric's java directory to the class path */
669 formatinfstr(infstr, x_("%c%sjava"), PATHSEP, el_libdir);
670
671 /* save the class path */
672 (void)allocstring(&classpath, returninfstr(infstr), db_cluster);
673
674 #ifdef OLDJAVA
675 /* see if JDK 1.1 exists */
676 vm1args.version = 0x00010001;
677 err = JNI_GetDefaultJavaVMInitArgs(&vm1args);
678 #else
679 /* presume that JDK 1.1 does not exist */
680 err = 1;
681 #endif
682 if (err != 0)
683 {
684 /* use the newer JDK, 1.2 */
685 vm2args.version = 0x00010002;
686 /* vm2args.version = 0x00010004; */
687 err = JNI_GetDefaultJavaVMInitArgs(&vm2args);
688 noptions = 0;
689 infstr = initinfstr();
690 formatinfstr(infstr, x_("-Djava.class.path=%s"), classpath);
691 (void)allocstring(&allocatedpath, returninfstr(infstr), db_cluster);
692 joptions[noptions++].optionString = allocatedpath;
693 /* joptions[noptions++].optionString = "-Xmx327680"; */
694 /* joptions[noptions++].optionString = b_("-Xmx268435456");*/
695 /*stop piddling around. Let's give this baby some REAL memory (1.2GB)*/
696 joptions[noptions++].optionString = b_("-Xmx500m");
697 /* joptions[noptions++].optionString= "-verbose:gc"; */
698 joptions[noptions].optionString = b_("vfprintf");
699 joptions[noptions++].extraInfo = (void *)java_vfprintf;
700 joptions[noptions].optionString = b_("exit");
701 joptions[noptions++].extraInfo = (void *)java_exit;
702
703 /* use compiler? */
704 /* TODO: compiler flag */
705
706 vm2args.options = joptions;
707 vm2args.nOptions = noptions;
708 vm2args.ignoreUnrecognized = 1;
709 err = JNI_CreateJavaVM(&java_virtualmachine, (void **)&java_environment, &vm2args);
710 if (err != 0)
711 {
712 ttyputerr(_("Cannot initialize Java VM (err %d)"), err);
713 return(0);
714 }
715 efree(allocatedpath);
716 } else
717 {
718 /* use the older JDK, 1.1 */
719 infstr = initinfstr();
720 addstringtoinfstr(infstr, classpath);
721 addtoinfstr(infstr, PATHSEP);
722 addtoinfstr(infstr, '.');
723 addstringtoinfstr(infstr, classpath);
724 vm1args.classpath = returninfstr(infstr);
725
726 /* see if compiler should be disabled */
727 ac = 0;
728 if ((us_javaflags&JAVANOCOMPILER) != 0)
729 properties[ac++] = b_("java.compiler=NONE");
730 properties[ac] = 0;
731 vm1args.properties = properties;
732
733 /* set overrides */
734 vm1args.vfprintf = java_vfprintf;
735 vm1args.exit = java_exit;
736
737 /* load and initialize a Java VM, return a JNI interface pointer in env */
738 err = JNI_CreateJavaVM(&java_virtualmachine, (void **)&java_environment, &vm1args);
739 if (err != 0)
740 {
741 ttyputerr(_("Cannot create Java VM (error %ld)"), err);
742 return(0);
743 }
744 }
745 efree(classpath);
746
747 java_inited = 1;
748
749 /* get the basic Electric class and register native methods */
750 java_electricclass = java_environment->FindClass(b_("COM/staticfreesoft/Electric"));
751 if (java_electricclass == 0)
752 {
753 ttyputerr(_("Cannot find COM.staticfreesoft.Electric class"));
754 return(0);
755 }
756 if (java_environment->RegisterNatives(java_electricclass, electricmethods,
757 sizeof(electricmethods)/sizeof(JNINativeMethod)) < 0)
758 ttyputerr(_("Failed to register native interfaces"));
759
760 /* override the "write" method of out "eout" class */
761 java_electriceoutclass = java_environment->FindClass(b_("COM/staticfreesoft/Electric$eout"));
762 if (java_electriceoutclass == 0)
763 {
764 ttyputerr(_("Cannot find COM.staticfreesoft.Electric$eout class"));
765 return(0);
766 }
767 if (java_environment->RegisterNatives(java_electriceoutclass, electriceoutmethods, 2) < 0)
768 ttyputerr(_("Failed to register output interface"));
769 jobject object = java_environment->AllocObject(java_electriceoutclass);
770 mid = java_environment->GetMethodID(java_electriceoutclass, b_("takeover"), b_("()V"));
771 java_environment->CallVoidMethod(object, mid);
772
773 /* get the attribute pointer to the "address" field on each class */
774 java_addressID = java_environment->GetFieldID(java_electricclass, b_("address"), b_("J"));
775
776 /* create the null object */
777 java_nullobject = java_environment->NewStringUTF(b_("NULL"));
778 java_environment->NewGlobalRef(java_nullobject);
779
780 /* get the basic subclasses */
781 java_classstring = java_environment->FindClass(b_("java/lang/String"));
782 if (java_classstring == 0)
783 {
784 ttyputerr(_("Cannot find java.lang.String class"));
785 return(0);
786 }
787 java_classint = java_environment->FindClass(b_("java/lang/Integer"));
788 if (java_classint == 0) return(0);
789 java_classfloat = java_environment->FindClass(b_("java/lang/Float"));
790 if (java_classfloat == 0) return(0);
791 java_classdouble = java_environment->FindClass(b_("java/lang/Double"));
792 if (java_classdouble == 0) return(0);
793 java_classarrayint = java_environment->FindClass(b_("[I"));
794 if (java_classarrayint == 0)
795 {
796 ttyputerr(_("Cannot find int[] class"));
797 return(0);
798 }
799
800 /* get the methods on the basic subclasses */
801 java_midIntValue = java_environment->GetMethodID(java_classint, b_("intValue"), b_("()I"));
802 java_midFloatValue = java_environment->GetMethodID(java_classfloat, b_("floatValue"), b_("()F"));
803 java_midDoubleValue = java_environment->GetMethodID(java_classdouble, b_("doubleValue"), b_("()D"));
804 java_midIntInit = java_environment->GetMethodID(java_classint, b_("<init>"), b_("(I)V"));
805 java_midFloatInit = java_environment->GetMethodID(java_classfloat, b_("<init>"), b_("(F)V"));
806
807 /* get the basic Electric subclasses */
808 java_classnodeinst = java_environment->FindClass(b_("COM/staticfreesoft/Electric$NodeInst"));
809 if (java_classnodeinst == 0) return(0);
810 java_classnodeproto = java_environment->FindClass(b_("COM/staticfreesoft/Electric$NodeProto"));
811 if (java_classnodeproto == 0) return(0);
812 java_classportarcinst = java_environment->FindClass(b_("COM/staticfreesoft/Electric$PortArcInst"));
813 if (java_classportarcinst == 0) return(0);
814 java_classportexpinst = java_environment->FindClass(b_("COM/staticfreesoft/Electric$PortExpInst"));
815 if (java_classportexpinst == 0) return(0);
816 java_classportproto = java_environment->FindClass(b_("COM/staticfreesoft/Electric$PortProto"));
817 if (java_classportproto == 0) return(0);
818 java_classarcinst = java_environment->FindClass(b_("COM/staticfreesoft/Electric$ArcInst"));
819 if (java_classarcinst == 0) return(0);
820 java_classarcproto = java_environment->FindClass(b_("COM/staticfreesoft/Electric$ArcProto"));
821 if (java_classarcproto == 0) return(0);
822 java_classgeom = java_environment->FindClass(b_("COM/staticfreesoft/Electric$Geom"));
823 if (java_classgeom == 0) return(0);
824 java_classlibrary = java_environment->FindClass(b_("COM/staticfreesoft/Electric$Library"));
825 if (java_classlibrary == 0) return(0);
826 java_classtechnology = java_environment->FindClass(b_("COM/staticfreesoft/Electric$Technology"));
827 if (java_classtechnology == 0) return(0);
828 java_classtool = java_environment->FindClass(b_("COM/staticfreesoft/Electric$Tool"));
829 if (java_classtool == 0) return(0);
830 java_classrtnode = java_environment->FindClass(b_("COM/staticfreesoft/Electric$RTNode"));
831 if (java_classrtnode == 0) return(0);
832 java_classnetwork = java_environment->FindClass(b_("COM/staticfreesoft/Electric$Network"));
833 if (java_classnetwork == 0) return(0);
834 java_classview = java_environment->FindClass(b_("COM/staticfreesoft/Electric$View"));
835 if (java_classview == 0) return(0);
836 java_classwindowpart = java_environment->FindClass(b_("COM/staticfreesoft/Electric$WindowPart"));
837 if (java_classwindowpart == 0) return(0);
838 java_classwindowframe = java_environment->FindClass(b_("COM/staticfreesoft/Electric$WindowFrame"));
839 if (java_classwindowframe == 0) return(0);
840 java_classgraphics = java_environment->FindClass(b_("COM/staticfreesoft/Electric$Graphics"));
841 if (java_classgraphics == 0) return(0);
842 java_classconstraint = java_environment->FindClass(b_("COM/staticfreesoft/Electric$Constraint"));
843 if (java_classconstraint == 0) return(0);
844 java_classpolygon = java_environment->FindClass(b_("COM/staticfreesoft/Electric$Polygon"));
845 if (java_classpolygon == 0) return(0);
846 java_classxarray = java_environment->FindClass(b_("COM/staticfreesoft/Electric$XArray"));
847 if (java_classxarray == 0) return(0);
848
849 /* get the attribute pointer to the fields on the XARRAY class */
850 java_xarrayVID = java_environment->GetFieldID(java_classxarray, b_("v"), b_("[I"));
851
852 /* if there is a Bean Shell, create an interpreter */
853 java_bshInterpreterObject = 0;
854 if (bsh != 0)
855 {
856 interpreterClass = java_environment->FindClass(b_("bsh/Interpreter"));
857 if (interpreterClass != 0)
858 {
859 mid = java_environment->GetMethodID(interpreterClass, b_("<init>"), b_("()V"));
860 java_bshInterpreterObject = java_environment->NewObject(interpreterClass, mid);
861 if (java_bshInterpreterObject != 0)
862 {
863 classClz = java_environment->GetObjectClass(java_bshInterpreterObject);
864 java_bshEvalMID = java_environment->GetMethodID(classClz, b_("eval"),
865 b_("(Ljava/lang/String;)Ljava/lang/Object;"));
866 if (java_bshEvalMID == 0) java_bshInterpreterObject = 0;
867 }
868 }
869 for(i=0; bshInit[i] != 0; i++)
870 {
871 #ifdef _UNICODE
872 string = java_environment->NewString(bshInit[i], estrlen(bshInit[i]));
873 #else
874 string = java_environment->NewStringUTF(bshInit[i]);
875 #endif
876 java_environment->CallObjectMethod(java_bshInterpreterObject, java_bshEvalMID, string);
877 }
878
879 return(x_("Java Bean Shell"));
880 }
881 return(x_("Java"));
882 }
883
884 /*
885 * Routine to add additional native function definitions to Java. The name of the method is
886 * "methodname". The description of its parameters and return values is "methodsignature".
887 * The actual routine is "methodfunction". Returns TRUE on error.
888 *
889 * The parameter "methodsignature" has the form: (PARAMETERS)RETURNTYPE
890 * where PARAMETERS is a list of 0 or more type descriptions for each parameter
891 * and RETURNTYPE is a single type description for the return value.
892 *
893 * The type descriptions can be these Java types:
894 * "I" for integer
895 * "V" for void (a null return value)
896 * "Ljava/lang/String;" for a string
897 * "Ljava/lang/Object;" for a general Java object
898 * "LCOM/staticfreesoft/Electric$TYPE;" for an Electric object of type TYPE
899 * where TYPE is NodeInst, NodeProto, ArcInst, Tool, etc.
900 * Some examples of method signatures:
901 * A routine that takes two Integers and returns a string would have this signature:
902 * "(II)Ljava/lang/String;"
903 * A routine that takes a NodeInst and a Technology and returns nothing would have this signature:
904 * "(LCOM/staticfreesoft/Electric$NodeInst;LCOM/staticfreesoft/Electric$Technology;)V"
905 *
906 * The routine that is passed (the "methodfunction" parameter) must have this form:
907 * JNIEXPORT RETURNTYPE JNICALL methodfunction(JNIEnv *env, PARAMETERS)
908 * {
909 * return(RETURNVALUE);
910 * }
911 *
912 * If a PARAMETER is an integer, declare it "jint" and simply assign it to an "int".
913 * If a PARAMETER is a string, declare it "jstring" and use this code to access it:
914 * char *cstring = (CHAR *)java_environment->GetStringUTFChars(PARAMETER, &isCopy);
915 * where "isCopy" is a "jboolean", and insert this code when done with the string:
916 * if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(PARAMETER, cstring);
917 * If a PARAMETER is an Electric object, declare it "jobject" and use this code to access it:
918 * ai = (ARCINST *)java_environment->GetLongField(PARAMETER, java_addressID);
919 *
920 * If the routine returns nothing, set the RETURNTYPE to "void".
921 * If the routine returns an integer, set the RETURNTYPE to "jint".
922 * If the routine returns a string, set the RETURNTYPE to "jstring" and create it with:
923 * jstring javastring = java_environment->NewStringUTF(cstring);
924 * If the routine returns an Electric type, set the RETURNTYPE to "jobject" and create it with:
925 * jobject returnvalue = java_makeobject((INTBIG)np, VNODEPROTO);
926 *
927 * BE WARNED! This interface is C++, so any module that uses this must also be C++ and not C
928 * (the extension on the file name must be ".cpp" and not ".c").
929 *
930 * Also, your routine should include "dblang.h" in order to access this interface.
931 */
java_addprivatenatives(CHAR1 * methodname,CHAR1 * methodsignature,void * methodfunction)932 BOOLEAN java_addprivatenatives(CHAR1 *methodname, CHAR1 *methodsignature, void *methodfunction)
933 {
934 JNINativeMethod electriceoutmethods;
935
936 electriceoutmethods.name = methodname;
937 electriceoutmethods.signature = methodsignature;
938 electriceoutmethods.fnPtr = methodfunction;
939
940 if (java_environment->RegisterNatives(java_electriceoutclass, &electriceoutmethods, 1) < 0)
941 return(TRUE);
942 return(FALSE);
943 }
944
945 /*
946 * Routine to evaluate the string "str". Returns true on error.
947 */
java_evaluate(CHAR * str)948 BOOLEAN java_evaluate(CHAR *str)
949 {
950 CHAR *evaluation;
951 INTBIG type, err;
952
953 /* special command to exit the JVM */
954 if (estrcmp(str, x_("exit")) == 0)
955 {
956 err = java_virtualmachine->DestroyJavaVM();
957 if (err != 0)
958 {
959 ttyputmsg(x_("Error %ld exiting JVM"), err);
960 return(FALSE);
961 }
962 java_inited = 0;
963 ttyputmsg(_("The JVM has exited"));
964 return(TRUE);
965 }
966
967 /* evaluate the string */
968 evaluation = java_query(str, &type);
969 if (evaluation == 0) return(FALSE);
970 switch (type)
971 {
972 case METHODRETURNSERROR:
973 ttyputmsg(x_("ERROR: %s"), evaluation);
974 break;
975 case METHODRETURNSVOID:
976 ttyputmsg(x_("(void)"));
977 break;
978 case METHODRETURNSOBJECT:
979 ttyputmsg(x_("(object)%s"), evaluation);
980 break;
981 case METHODRETURNSBOOLEAN:
982 ttyputmsg(x_("(boolean)%s"), evaluation);
983 break;
984 case METHODRETURNSBYTE:
985 ttyputmsg(x_("(byte)%s"), evaluation);
986 break;
987 case METHODRETURNSCHAR:
988 ttyputmsg(x_("(char)%s"), evaluation);
989 break;
990 case METHODRETURNSSHORT:
991 ttyputmsg(x_("(short)%s"), evaluation);
992 break;
993 case METHODRETURNSINT:
994 ttyputmsg(x_("(int)%s"), evaluation);
995 break;
996 case METHODRETURNSLONG:
997 ttyputmsg(x_("(long)%s"), evaluation);
998 break;
999 case METHODRETURNSFLOAT:
1000 ttyputmsg(x_("(float)%s"), evaluation);
1001 break;
1002 case METHODRETURNSDOUBLE:
1003 ttyputmsg(x_("(double)%s"), evaluation);
1004 break;
1005 }
1006 return(FALSE);
1007 }
1008
java_query(CHAR * str,INTBIG * methodreturntype)1009 CHAR *java_query(CHAR *str, INTBIG *methodreturntype)
1010 {
1011 CHAR *pt, *methodName, *thisMethodName, *className, *returnClassName;
1012 static CHAR resultString[100];
1013 jclass theClass, classClz, methodClass, returnClass, returnClassClz;
1014 static jclass modifierClass = 0;
1015 REGISTER INTBIG len, i, gotMethod;
1016 INTBIG addr, type;
1017 CHAR sig[300], *sigpt, *description;
1018 int modifiers;
1019 jfloat fvalue;
1020 jlong lvalue;
1021 jdouble dvalue;
1022 jboolean bvalue;
1023 jobject ovalue, result, thisMethod;
1024 jboolean isCopy;
1025 jthrowable throwObj;
1026 jmethodID getmethodsmid, mid;
1027 jobjectArray methodlist, methodParams;
1028 jstring jMethodName, jReturnClassName, string;
1029 REGISTER void *infstr;
1030
1031 /* if not evaluating, just return the input */
1032 if ((us_javaflags&JAVANOEVALUATE) != 0)
1033 {
1034 getsimpletype(str, &type, &addr, 0);
1035 switch (type)
1036 {
1037 case VINTEGER: *methodreturntype = METHODRETURNSINT; break;
1038 case VFLOAT: *methodreturntype = METHODRETURNSFLOAT; break;
1039 case VSTRING: *methodreturntype = METHODRETURNSCHAR; break;
1040 default: *methodreturntype = METHODRETURNSOBJECT; break;
1041 }
1042 return(str);
1043 }
1044
1045 /* see if this request escapes the Bean shell */
1046 while (*str == ' ' || *str == '\t') str++;
1047 if (*str == 0) return(0);
1048
1049 /* if Bean Shell exists, use it to evaluate */
1050 if (*str == '!') str++; else
1051 {
1052 if (java_bshInterpreterObject != 0)
1053 {
1054 /* do substitution of "@" symbol (becomes "P()") */
1055 for(pt = str; *pt != 0; pt++)
1056 if (*pt == '@') break;
1057 if (*pt != 0)
1058 {
1059 infstr = initinfstr();
1060 for(pt = str; *pt != 0; pt++)
1061 {
1062 if (*pt != '@') addtoinfstr(infstr, *pt); else
1063 {
1064 addstringtoinfstr(infstr, x_("P(\""));
1065 for(;;)
1066 {
1067 pt++;
1068 if (isalnum(*pt) || *pt == '$' || *pt == '_')
1069 addtoinfstr(infstr, *pt); else break;
1070 }
1071 addstringtoinfstr(infstr, x_("\")"));
1072 pt--;
1073 }
1074 }
1075 str = returninfstr(infstr);
1076 }
1077 #ifdef _UNICODE
1078 string = java_environment->NewString(str, estrlen(str));
1079 #else
1080 string = java_environment->NewStringUTF(str);
1081 #endif
1082
1083 /* clear exceptions */
1084 java_environment->ExceptionClear();
1085
1086 /* evaluate the string */
1087 result = java_environment->CallObjectMethod(java_bshInterpreterObject, java_bshEvalMID, string);
1088 java_environment->DeleteLocalRef(string);
1089
1090 /* report errors if they occurred */
1091 throwObj = java_environment->ExceptionOccurred();
1092 if (throwObj != NULL)
1093 {
1094 java_environment->ExceptionClear();
1095 *methodreturntype = METHODRETURNSERROR;
1096 classClz = java_environment->GetObjectClass(throwObj);
1097 mid = java_environment->GetMethodID(classClz, b_("getMessage"),
1098 b_("()Ljava/lang/String;"));
1099 string = (jstring)java_environment->CallObjectMethod(throwObj, mid, NULL);
1100
1101 /* "string" was zero (when out of memory?) */
1102 if (string == 0)
1103 {
1104 ttyputmsg(x_("No memory in Java interface!"));
1105 return(x_("error"));
1106 }
1107
1108 description = (CHAR *)java_environment->GetStringUTFChars(string, &isCopy);
1109 return(description);
1110 }
1111
1112 /* valid result: return it */
1113 if (result == 0)
1114 {
1115 *methodreturntype = METHODRETURNSVOID;
1116 return(x_(""));
1117 }
1118 java_getobjectaddrtype(result, &addr, &type, &description);
1119 switch (type)
1120 {
1121 case VINTEGER: *methodreturntype = METHODRETURNSINT; break;
1122 case VFLOAT: *methodreturntype = METHODRETURNSFLOAT; break;
1123 case VSTRING: *methodreturntype = METHODRETURNSCHAR; break;
1124 default: *methodreturntype = METHODRETURNSOBJECT; break;
1125 }
1126 return(description);
1127 }
1128 }
1129
1130 /* parse string into CLASS.METHOD (must be static and take no parameters) */
1131 className = str;
1132 while (*className == ' ' || *className == '\t') className++;
1133 len = estrlen(className);
1134 for(i=len-1; i>0; i--)
1135 if (className[i] == '.') break;
1136 if (i == 0)
1137 {
1138 ttyputerr(_("Cannot determine class and method of '%s'"), str);
1139 return(0);
1140 }
1141 methodName = &className[i+1];
1142 className[i] = 0;
1143 for(pt = className; *pt != 0; pt++) if (*pt == '.') *pt = '/';
1144
1145 /* find the class */
1146 theClass = java_environment->FindClass(string1byte(className));
1147 if (theClass == 0)
1148 {
1149 ttyputerr(_("Cannot find class '%s'"), className);
1150 className[i] = '.';
1151 return(0);
1152 }
1153 className[i] = '.';
1154
1155 /* get the list of methods on "theClass" */
1156 classClz = java_environment->GetObjectClass(theClass);
1157 getmethodsmid = java_environment->GetMethodID(classClz, b_("getMethods"),
1158 b_("()[Ljava/lang/reflect/Method;"));
1159 methodlist = (jobjectArray)java_environment->CallObjectMethod(theClass, getmethodsmid, NULL);
1160
1161 /* look at all methods */
1162 len = java_environment->GetArrayLength(methodlist);
1163 for(i=0; i<len; i++)
1164 {
1165 /* get a method */
1166 thisMethod = java_environment->GetObjectArrayElement(methodlist, i);
1167
1168 /* get the method's name */
1169 methodClass = java_environment->GetObjectClass(thisMethod);
1170 mid = java_environment->GetMethodID(methodClass, b_("getName"), b_("()Ljava/lang/String;"));
1171 jMethodName = (jstring)java_environment->CallObjectMethod(thisMethod, mid, NULL);
1172 thisMethodName = (CHAR *)java_environment->GetStringUTFChars(jMethodName, &isCopy);
1173 gotMethod = estrcmp(methodName, thisMethodName);
1174 if (isCopy == JNI_TRUE)
1175 java_environment->ReleaseStringUTFChars((jstring)jMethodName, thisMethodName);
1176 if (gotMethod != 0) continue;
1177
1178 /* found method "thisMethod"...it must have zero parameters */
1179 mid = java_environment->GetMethodID(methodClass, b_("getParameterTypes"), b_("()[Ljava/lang/Class;"));
1180 methodParams = (jobjectArray)java_environment->CallObjectMethod(thisMethod, mid, NULL);
1181 if (java_environment->GetArrayLength(methodParams) != 0) continue;
1182
1183 /* the method must be static */
1184 mid = java_environment->GetMethodID(methodClass, b_("getModifiers"), b_("()I"));
1185 modifiers = java_environment->CallIntMethod(thisMethod, mid, NULL);
1186 if (modifierClass == 0)
1187 modifierClass = java_environment->FindClass(b_("java/lang/reflect/Modifier"));
1188 mid = java_environment->GetStaticMethodID(modifierClass, b_("isStatic"), b_("(I)Z"));
1189 if (java_environment->CallStaticBooleanMethod(modifierClass, mid, modifiers) == JNI_FALSE) continue;
1190
1191 /* get the return type of the method */
1192 mid = java_environment->GetMethodID(methodClass, b_("getReturnType"), b_("()Ljava/lang/Class;"));
1193 returnClass = (jclass)java_environment->CallObjectMethod(thisMethod, mid, NULL);
1194 returnClassClz = java_environment->GetObjectClass(returnClass);
1195 mid = java_environment->GetMethodID(returnClassClz, b_("toString"), b_("()Ljava/lang/String;"));
1196 jReturnClassName = (jstring)java_environment->CallObjectMethod(returnClass, mid, NULL);
1197 returnClassName = (CHAR *)java_environment->GetStringUTFChars(jReturnClassName, &isCopy);
1198
1199 /* convert that return-type to a signature */
1200 sigpt = sig;
1201 *sigpt++ = '(';
1202 *sigpt++ = ')';
1203 if (estrcmp(returnClassName, x_("void")) == 0)
1204 {
1205 *sigpt++ = 'V';
1206 *methodreturntype = METHODRETURNSVOID;
1207 } else if (estrncmp(returnClassName, x_("class "), 6) == 0)
1208 {
1209 *sigpt++ = 'L';
1210 for(pt = &returnClassName[6]; *pt != 0; pt++)
1211 if (*pt == '.') *sigpt++ = '/'; else
1212 *sigpt++ = *pt;
1213 *sigpt++ = ';';
1214 *methodreturntype = METHODRETURNSOBJECT;
1215 } else if (estrcmp(returnClassName, x_("boolean")) == 0)
1216 {
1217 *sigpt++ = 'Z';
1218 *methodreturntype = METHODRETURNSBOOLEAN;
1219 } else if (estrcmp(returnClassName, x_("byte")) == 0)
1220 {
1221 *sigpt++ = 'B';
1222 *methodreturntype = METHODRETURNSBYTE;
1223 } else if (estrcmp(returnClassName, x_("char")) == 0)
1224 {
1225 *sigpt++ = 'C';
1226 *methodreturntype = METHODRETURNSCHAR;
1227 } else if (estrcmp(returnClassName, x_("short")) == 0)
1228 {
1229 *sigpt++ = 'S';
1230 *methodreturntype = METHODRETURNSSHORT;
1231 } else if (estrcmp(returnClassName, x_("int")) == 0)
1232 {
1233 *sigpt++ = 'I';
1234 *methodreturntype = METHODRETURNSINT;
1235 } else if (estrcmp(returnClassName, x_("long")) == 0)
1236 {
1237 *sigpt++ = 'J';
1238 *methodreturntype = METHODRETURNSLONG;
1239 } else if (estrcmp(returnClassName, x_("float")) == 0)
1240 {
1241 *sigpt++ = 'F';
1242 *methodreturntype = METHODRETURNSFLOAT;
1243 } else if (estrcmp(returnClassName, x_("double")) == 0)
1244 {
1245 *sigpt++ = 'D';
1246 *methodreturntype = METHODRETURNSDOUBLE;
1247 } else
1248 {
1249 ttyputerr(_("%s returns unrecognized type '%s'"), str, returnClassName);
1250 return(0);
1251 }
1252 *sigpt = 0;
1253 if (isCopy == JNI_TRUE)
1254 java_environment->ReleaseStringUTFChars((jstring)jReturnClassName, returnClassName);
1255
1256 mid = java_environment->GetStaticMethodID(theClass, methodName, sig);
1257 if (mid == 0)
1258 {
1259 ttyputerr(_("Error getting method pointer to %s (signature '%s')"), str, sig);
1260 return(0);
1261 }
1262
1263 /* run the method and print the result */
1264 switch (*methodreturntype)
1265 {
1266 case METHODRETURNSVOID:
1267 java_environment->CallStaticVoidMethod(theClass, mid);
1268 if (java_reportexceptions()) return(0);
1269 return(x_(""));
1270 case METHODRETURNSOBJECT:
1271 ovalue = java_environment->CallStaticObjectMethod(theClass, mid);
1272 if (java_reportexceptions()) return(0);
1273 java_getobjectaddrtype(ovalue, &addr, &type, &description);
1274 return(description);
1275 case METHODRETURNSBOOLEAN:
1276 bvalue = java_environment->CallStaticBooleanMethod(theClass, mid);
1277 if (java_reportexceptions()) return(0);
1278 esnprintf(resultString, 100, x_("%s"), bvalue ? _("True") : _("False"));
1279 return(resultString);
1280 case METHODRETURNSBYTE:
1281 i = java_environment->CallStaticByteMethod(theClass, mid);
1282 if (java_reportexceptions()) return(0);
1283 esnprintf(resultString, 100, x_("%ld"), i);
1284 return(resultString);
1285 case METHODRETURNSCHAR:
1286 i = java_environment->CallStaticCharMethod(theClass, mid);
1287 if (java_reportexceptions()) return(0);
1288 esnprintf(resultString, 100, x_("'%c'"), i);
1289 return(resultString);
1290 case METHODRETURNSSHORT:
1291 i = java_environment->CallStaticShortMethod(theClass, mid);
1292 if (java_reportexceptions()) return(0);
1293 esnprintf(resultString, 100, x_("%ld"), i);
1294 return(resultString);
1295 case METHODRETURNSINT:
1296 i = java_environment->CallStaticIntMethod(theClass, mid);
1297 if (java_reportexceptions()) return(0);
1298 esnprintf(resultString, 100, x_("%ld"), i);
1299 return(resultString);
1300 case METHODRETURNSLONG:
1301 lvalue = java_environment->CallStaticLongMethod(theClass, mid);
1302 if (java_reportexceptions()) return(0);
1303 esnprintf(resultString, 100, x_("%ld"), lvalue);
1304 return(resultString);
1305 case METHODRETURNSFLOAT:
1306 fvalue = java_environment->CallStaticFloatMethod(theClass, mid);
1307 if (java_reportexceptions()) return(0);
1308 esnprintf(resultString, 100, x_("%g"), fvalue);
1309 return(resultString);
1310 case METHODRETURNSDOUBLE:
1311 dvalue = java_environment->CallStaticDoubleMethod(theClass, mid);
1312 if (java_reportexceptions()) return(0);
1313 esnprintf(resultString, 100, x_("%g"), dvalue);
1314 return(resultString);
1315 }
1316 }
1317 ttyputerr(_("Cannot find static method '%s' that takes no parameters"), str);
1318 return(0);
1319 }
1320
java_reportexceptions(void)1321 BOOLEAN java_reportexceptions(void)
1322 {
1323 if (java_environment->ExceptionOccurred() == NULL) return(FALSE);
1324 java_environment->ExceptionDescribe();
1325 java_environment->ExceptionClear();
1326 return(TRUE);
1327 }
1328
1329 /****************************** ELECTRIC DATABASE EXAMINATION ROUTINES ******************************/
1330
Java_Electric_curLib(JNIEnv * env,jobject obj)1331 JNIEXPORT jobject JNICALL Java_Electric_curLib(JNIEnv *env, jobject obj)
1332 {
1333 jobject jlib;
1334
1335 /* convert C result to Java */
1336 jlib = java_makeobject((INTBIG)el_curlib, VLIBRARY);
1337 return(jlib);
1338 }
1339
Java_Electric_curTech(JNIEnv * env,jobject obj)1340 JNIEXPORT jobject JNICALL Java_Electric_curTech(JNIEnv *env, jobject obj)
1341 {
1342 jobject jtech;
1343
1344 /* convert C result to Java */
1345 jtech = java_makeobject((INTBIG)el_curtech, VTECHNOLOGY);
1346 return(jtech);
1347 }
1348
Java_Electric_getValNodeinst(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1349 JNIEXPORT jobject JNICALL Java_Electric_getValNodeinst(JNIEnv *env, jobject obj,
1350 jobject jobj, jstring jname)
1351 {
1352 return(java_getval(jobj, VNODEINST, jname));
1353 }
1354
Java_Electric_getValNodeproto(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1355 JNIEXPORT jobject JNICALL Java_Electric_getValNodeproto(JNIEnv *env, jobject obj,
1356 jobject jobj, jstring jname)
1357 {
1358 return(java_getval(jobj, VNODEPROTO, jname));
1359 }
1360
Java_Electric_getValPortarcinst(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1361 JNIEXPORT jobject JNICALL Java_Electric_getValPortarcinst(JNIEnv *env, jobject obj,
1362 jobject jobj, jstring jname)
1363 {
1364 return(java_getval(jobj, VPORTARCINST, jname));
1365 }
1366
Java_Electric_getValPortexpinst(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1367 JNIEXPORT jobject JNICALL Java_Electric_getValPortexpinst(JNIEnv *env, jobject obj,
1368 jobject jobj, jstring jname)
1369 {
1370 return(java_getval(jobj, VPORTEXPINST, jname));
1371 }
1372
Java_Electric_getValPortproto(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1373 JNIEXPORT jobject JNICALL Java_Electric_getValPortproto(JNIEnv *env, jobject obj,
1374 jobject jobj, jstring jname)
1375 {
1376 return(java_getval(jobj, VPORTPROTO, jname));
1377 }
1378
Java_Electric_getValArcinst(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1379 JNIEXPORT jobject JNICALL Java_Electric_getValArcinst(JNIEnv *env, jobject obj,
1380 jobject jobj, jstring jname)
1381 {
1382 return(java_getval(jobj, VARCINST, jname));
1383 }
1384
Java_Electric_getValArcproto(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1385 JNIEXPORT jobject JNICALL Java_Electric_getValArcproto(JNIEnv *env, jobject obj,
1386 jobject jobj, jstring jname)
1387 {
1388 return(java_getval(jobj, VARCPROTO, jname));
1389 }
1390
Java_Electric_getValGeom(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1391 JNIEXPORT jobject JNICALL Java_Electric_getValGeom(JNIEnv *env, jobject obj,
1392 jobject jobj, jstring jname)
1393 {
1394 return(java_getval(jobj, VGEOM, jname));
1395 }
1396
Java_Electric_getValLibrary(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1397 JNIEXPORT jobject JNICALL Java_Electric_getValLibrary(JNIEnv *env, jobject obj,
1398 jobject jobj, jstring jname)
1399 {
1400 return(java_getval(jobj, VLIBRARY, jname));
1401 }
1402
Java_Electric_getValTechnology(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1403 JNIEXPORT jobject JNICALL Java_Electric_getValTechnology(JNIEnv *env, jobject obj,
1404 jobject jobj, jstring jname)
1405 {
1406 return(java_getval(jobj, VTECHNOLOGY, jname));
1407 }
1408
Java_Electric_getValTool(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1409 JNIEXPORT jobject JNICALL Java_Electric_getValTool(JNIEnv *env, jobject obj,
1410 jobject jobj, jstring jname)
1411 {
1412 return(java_getval(jobj, VTOOL, jname));
1413 }
1414
Java_Electric_getValRTNode(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1415 JNIEXPORT jobject JNICALL Java_Electric_getValRTNode(JNIEnv *env, jobject obj,
1416 jobject jobj, jstring jname)
1417 {
1418 return(java_getval(jobj, VRTNODE, jname));
1419 }
1420
Java_Electric_getValNetwork(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1421 JNIEXPORT jobject JNICALL Java_Electric_getValNetwork(JNIEnv *env, jobject obj,
1422 jobject jobj, jstring jname)
1423 {
1424 return(java_getval(jobj, VNETWORK, jname));
1425 }
1426
Java_Electric_getValView(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1427 JNIEXPORT jobject JNICALL Java_Electric_getValView(JNIEnv *env, jobject obj,
1428 jobject jobj, jstring jname)
1429 {
1430 return(java_getval(jobj, VVIEW, jname));
1431 }
1432
Java_Electric_getValWindowpart(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1433 JNIEXPORT jobject JNICALL Java_Electric_getValWindowpart(JNIEnv *env, jobject obj,
1434 jobject jobj, jstring jname)
1435 {
1436 return(java_getval(jobj, VWINDOWPART, jname));
1437 }
1438
Java_Electric_getValWindowframe(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1439 JNIEXPORT jobject JNICALL Java_Electric_getValWindowframe(JNIEnv *env, jobject obj,
1440 jobject jobj, jstring jname)
1441 {
1442 return(java_getval(jobj, VWINDOWFRAME, jname));
1443 }
1444
Java_Electric_getValGraphics(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1445 JNIEXPORT jobject JNICALL Java_Electric_getValGraphics(JNIEnv *env, jobject obj,
1446 jobject jobj, jstring jname)
1447 {
1448 return(java_getval(jobj, VGRAPHICS, jname));
1449 }
1450
Java_Electric_getValConstraint(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1451 JNIEXPORT jobject JNICALL Java_Electric_getValConstraint(JNIEnv *env, jobject obj,
1452 jobject jobj, jstring jname)
1453 {
1454 return(java_getval(jobj, VCONSTRAINT, jname));
1455 }
1456
Java_Electric_getValPolygon(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1457 JNIEXPORT jobject JNICALL Java_Electric_getValPolygon(JNIEnv *env, jobject obj,
1458 jobject jobj, jstring jname)
1459 {
1460 return(java_getval(jobj, VPOLYGON, jname));
1461 }
1462
java_getval(jobject jobj,INTBIG type,jstring jname)1463 jobject java_getval(jobject jobj, INTBIG type, jstring jname)
1464 {
1465 CHAR *name;
1466 jboolean isCopy;
1467 jobject retval;
1468 INTBIG addr;
1469 REGISTER VARIABLE *var;
1470
1471 /* convert Java parameters to C */
1472 if (jobj == 0) return(java_nullobject);
1473 addr = (INTBIG)java_environment->GetLongField(jobj, java_addressID);
1474 name = (CHAR *)(INTBIG)java_environment->GetStringUTFChars(jname, &isCopy);
1475
1476 /* make the Electric call */
1477 var = getval(addr, type, -1, name);
1478 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
1479
1480 /* convert C result to Java */
1481 if (var == NOVARIABLE) return(java_nullobject);
1482 retval = java_makeobject(var->addr, var->type);
1483 return(retval);
1484 }
1485
Java_Electric_getParentVal(JNIEnv * env,jobject obj,jstring jname,jobject jdefault,jint jheight)1486 JNIEXPORT jobject JNICALL Java_Electric_getParentVal(JNIEnv *env, jobject obj,
1487 jstring jname, jobject jdefault, jint jheight)
1488 {
1489 CHAR *name;
1490 jboolean isCopy;
1491 VARIABLE *var;
1492 jobject retval;
1493 INTBIG height;
1494
1495 /* convert Java parameters to C */
1496 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
1497 height = jheight;
1498
1499 /* make the Electric call */
1500 var = getparentval((CHAR *)name, height);
1501
1502 /* convert C result to Java */
1503 if (var == NOVARIABLE) retval = jdefault; else
1504 retval = java_makeobject(var->addr, var->type);
1505 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
1506 return(retval);
1507 }
1508
Java_Electric_setVal(JNIEnv * env,jobject obj,jobject jobj,jstring jname,jobject jattr,jint jbits)1509 JNIEXPORT void JNICALL Java_Electric_setVal(JNIEnv *env, jobject obj,
1510 jobject jobj, jstring jname, jobject jattr, jint jbits)
1511 {
1512 CHAR *name;
1513 jboolean isCopy;
1514 INTBIG addr, type, bits, newaddr, newtype;
1515 VARIABLE *var;
1516
1517 /* convert Java parameters to C */
1518 if (jobj == 0) return;
1519 if (jattr == 0) return;
1520 java_getobjectaddrtype(jobj, &addr, &type, 0);
1521 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
1522 java_getobjectaddrtype(jattr, &newaddr, &newtype, 0);
1523 bits = jbits;
1524
1525 /* make the Electric call */
1526 var = getval(addr, type, -1, name);
1527 if (var != NOVARIABLE)
1528 {
1529 if (((var->type&VTYPE) == VSHORT || (var->type&VTYPE) == VBOOLEAN) && newtype == VINTEGER)
1530 newtype = var->type&VTYPE;
1531 }
1532 (void)setval(addr, type, name, newaddr, newtype|bits);
1533 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
1534 }
1535
Java_Electric_setInd(JNIEnv * env,jobject obj,jobject jobj,jstring jname,jint jindex,jobject jattr)1536 JNIEXPORT void JNICALL Java_Electric_setInd(JNIEnv *env, jobject obj,
1537 jobject jobj, jstring jname, jint jindex, jobject jattr)
1538 {
1539 CHAR *name;
1540 jboolean isCopy;
1541 INTBIG addr, type, index, newaddr, newtype;
1542
1543 /* convert Java parameters to C */
1544 if (jobj == 0) return;
1545 if (jattr == 0) return;
1546 java_getobjectaddrtype(jobj, &addr, &type, 0);
1547 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
1548 index = jindex;
1549 java_getobjectaddrtype(jattr, &newaddr, &newtype, 0);
1550
1551 /* make the Electric call */
1552 (void)setind(addr, type, name, index, newaddr);
1553 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
1554 }
1555
Java_Electric_delVal(JNIEnv * env,jobject obj,jobject jobj,jstring jname)1556 JNIEXPORT void JNICALL Java_Electric_delVal(JNIEnv *env, jobject obj,
1557 jobject jobj, jstring jname)
1558 {
1559 CHAR *name;
1560 jboolean isCopy;
1561 INTBIG addr, type;
1562
1563 /* convert Java parameters to C */
1564 if (jobj == 0) return;
1565 java_getobjectaddrtype(jobj, &addr, &type, 0);
1566 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
1567
1568 /* make the Electric call */
1569 (void)delval(addr, type, name);
1570 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
1571 }
1572
Java_Electric_initSearch(JNIEnv * env,jobject obj,jint jlx,jint jhx,jint jly,jint jhy,jobject jcell)1573 JNIEXPORT jint JNICALL Java_Electric_initSearch(JNIEnv *env, jobject obj,
1574 jint jlx, jint jhx, jint jly, jint jhy, jobject jcell)
1575 {
1576 NODEPROTO *cell;
1577 INTBIG sea, lx, hx, ly, hy;
1578 jint jsea;
1579
1580 /* convert Java parameters to C */
1581 lx = jlx; hx = jhx;
1582 ly = jly; hy = jhy;
1583 if (jcell == 0) return(0);
1584 cell = (NODEPROTO *)(INTBIG)java_environment->GetLongField(jcell, java_addressID);
1585
1586 /* make the Electric call */
1587 sea = initsearch(lx, hx, ly, hy, cell);
1588
1589 /* convert C result to Java */
1590 jsea = sea;
1591 return(jsea);
1592 }
1593
Java_Electric_nextObject(JNIEnv * env,jobject obj,jint jsea)1594 JNIEXPORT jobject JNICALL Java_Electric_nextObject(JNIEnv *env, jobject obj,
1595 jint jsea)
1596 {
1597 GEOM *geom;
1598 jobject jgeom;
1599 INTBIG sea;
1600
1601 /* convert Java parameters to C */
1602 if (jsea == 0) return(java_nullobject);
1603 sea = jsea;
1604
1605 /* make the Electric call */
1606 geom = nextobject(sea);
1607
1608 /* convert C result to Java */
1609 jgeom = java_makeobject((INTBIG)geom, VGEOM);
1610 return(jgeom);
1611 }
1612
Java_Electric_termSearch(JNIEnv * env,jobject obj,jint jsea)1613 JNIEXPORT void JNICALL Java_Electric_termSearch(JNIEnv *env, jobject obj,
1614 jint jsea)
1615 {
1616 INTBIG sea;
1617
1618 /* convert Java parameters to C */
1619 if (jsea == 0) return;
1620 sea = jsea;
1621
1622 /* make the Electric call */
1623 termsearch(sea);
1624 }
1625
1626 /****************************** ELECTRIC TOOL ROUTINES ******************************/
1627
Java_Electric_getTool(JNIEnv * env,jobject obj,jstring jname)1628 JNIEXPORT jobject JNICALL Java_Electric_getTool(JNIEnv *env, jobject obj,
1629 jstring jname)
1630 {
1631 jboolean isCopy;
1632 CHAR *name;
1633 TOOL *tool;
1634 jobject jtool;
1635
1636 /* convert Java parameters to C */
1637 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
1638
1639 /* make the Electric call */
1640 tool = gettool(name);
1641 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
1642
1643 /* convert C result to Java */
1644 jtool = java_makeobject((INTBIG)tool, VTOOL);
1645 return(jtool);
1646 }
1647
Java_Electric_maxTool(JNIEnv * env,jobject obj)1648 JNIEXPORT jint JNICALL Java_Electric_maxTool(JNIEnv *env, jobject obj)
1649 {
1650 jint jmaxtool;
1651
1652 /* convert C result to Java */
1653 jmaxtool = el_maxtools;
1654 return(jmaxtool);
1655 }
1656
Java_Electric_indexTool(JNIEnv * env,jobject obj,jint jindex)1657 JNIEXPORT jobject JNICALL Java_Electric_indexTool(JNIEnv *env, jobject obj,
1658 jint jindex)
1659 {
1660 INTBIG index;
1661 TOOL *tool;
1662 jobject jtool;
1663
1664 /* convert Java parameters to C */
1665 index = jindex;
1666
1667 /* make the Electric call */
1668 if (index < 0 || index >= el_maxtools) tool = NOTOOL; else tool = &el_tools[index];
1669
1670 /* convert C result to Java */
1671 jtool = java_makeobject((INTBIG)tool, VTOOL);
1672 return(jtool);
1673 }
1674
Java_Electric_toolTurnOn(JNIEnv * env,jobject obj,jobject jtool)1675 JNIEXPORT void JNICALL Java_Electric_toolTurnOn(JNIEnv *env, jobject obj,
1676 jobject jtool)
1677 {
1678 TOOL *tool;
1679
1680 /* convert Java parameters to C */
1681 if (jtool == 0) return;
1682 tool = (TOOL *)(INTBIG)java_environment->GetLongField(jtool, java_addressID);
1683
1684 /* make the Electric call */
1685 toolturnon(tool);
1686 }
1687
Java_Electric_toolTurnOff(JNIEnv * env,jobject obj,jobject jtool)1688 JNIEXPORT void JNICALL Java_Electric_toolTurnOff(JNIEnv *env, jobject obj,
1689 jobject jtool)
1690 {
1691 TOOL *tool;
1692
1693 /* convert Java parameters to C */
1694 if (jtool == 0) return;
1695 tool = (TOOL *)(INTBIG)java_environment->GetLongField(jtool, java_addressID);
1696
1697 /* make the Electric call */
1698 toolturnoff(tool, TRUE);
1699 }
1700
Java_Electric_tellTool(JNIEnv * env,jobject obj,jobject jtool,jint jargc,jobjectArray jargv)1701 JNIEXPORT void JNICALL Java_Electric_tellTool(JNIEnv *env, jobject obj,
1702 jobject jtool, jint jargc, jobjectArray jargv)
1703 {
1704 jboolean *isCopy;
1705 CHAR **argv;
1706 jstring str;
1707 INTBIG argc, i;
1708 TOOL *tool;
1709
1710 /* convert Java parameters to C */
1711 if (jtool == 0) return;
1712 if (jargc == 0) return;
1713 tool = (TOOL *)(INTBIG)java_environment->GetLongField(jtool, java_addressID);
1714 argc = jargc;
1715 isCopy = (jboolean *)emalloc(argc * (sizeof (jboolean)), el_tempcluster);
1716 argv = (CHAR **)emalloc(argc * (sizeof (CHAR *)), el_tempcluster);
1717 for(i=0; i<argc; i++)
1718 {
1719 str = (jstring)java_environment->GetObjectArrayElement(jargv, i);
1720 argv[i] = (CHAR *)java_environment->GetStringUTFChars(str, &isCopy[i]);
1721 }
1722
1723 /* make the Electric call */
1724 telltool(tool, argc, argv);
1725 for(i=0; i<argc; i++)
1726 {
1727 str = (jstring)java_environment->GetObjectArrayElement(jargv, i);
1728 if (isCopy[i] == JNI_TRUE) java_environment->ReleaseStringUTFChars(str, argv[i]);
1729 }
1730 efree((CHAR *)isCopy);
1731 efree((CHAR *)argv);
1732 }
1733
1734 /****************************** ELECTRIC LIBRARY ROUTINES ******************************/
1735
Java_Electric_getLibrary(JNIEnv * env,jobject obj,jstring jname)1736 JNIEXPORT jobject JNICALL Java_Electric_getLibrary(JNIEnv *env, jobject obj,
1737 jstring jname)
1738 {
1739 jboolean isCopy;
1740 CHAR *name;
1741 LIBRARY *lib;
1742 jobject jlib;
1743
1744 /* convert Java parameters to C */
1745 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
1746
1747 /* make the Electric call */
1748 lib = getlibrary(name);
1749 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
1750
1751 /* convert C result to Java */
1752 jlib = java_makeobject((INTBIG)lib, VLIBRARY);
1753 return(jlib);
1754 }
1755
Java_Electric_newLibrary(JNIEnv * env,jobject obj,jstring jlibname,jstring jlibfile)1756 JNIEXPORT jobject JNICALL Java_Electric_newLibrary(JNIEnv *env, jobject obj,
1757 jstring jlibname, jstring jlibfile)
1758 {
1759 jboolean isCopy1, isCopy2;
1760 CHAR *libname, *libfile;
1761 LIBRARY *lib;
1762 jobject jlib;
1763
1764 /* convert Java parameters to C */
1765 libname = (CHAR *)java_environment->GetStringUTFChars(jlibname, &isCopy1);
1766 libfile = (CHAR *)java_environment->GetStringUTFChars(jlibfile, &isCopy2);
1767
1768 /* make the Electric call */
1769 lib = newlibrary(libname, libfile);
1770 if (isCopy1 == JNI_TRUE) java_environment->ReleaseStringUTFChars(jlibname, libname);
1771 if (isCopy2 == JNI_TRUE) java_environment->ReleaseStringUTFChars(jlibfile, libfile);
1772
1773 /* convert C result to Java */
1774 jlib = java_makeobject((INTBIG)lib, VLIBRARY);
1775 return(jlib);
1776 }
1777
Java_Electric_killLibrary(JNIEnv * env,jobject obj,jobject jlib)1778 JNIEXPORT void JNICALL Java_Electric_killLibrary(JNIEnv *env, jobject obj,
1779 jobject jlib)
1780 {
1781 LIBRARY *lib;
1782
1783 /* convert Java parameters to C */
1784 if (jlib == 0) return;
1785 lib = (LIBRARY *)(INTBIG)java_environment->GetLongField(jlib, java_addressID);
1786
1787 /* make the Electric call */
1788 killlibrary(lib);
1789 }
1790
Java_Electric_eraseLibrary(JNIEnv * env,jobject obj,jobject jlib)1791 JNIEXPORT void JNICALL Java_Electric_eraseLibrary(JNIEnv *env, jobject obj,
1792 jobject jlib)
1793 {
1794 LIBRARY *lib;
1795
1796 /* convert Java parameters to C */
1797 if (jlib == 0) return;
1798 lib = (LIBRARY *)(INTBIG)java_environment->GetLongField(jlib, java_addressID);
1799
1800 /* make the Electric call */
1801 eraselibrary(lib);
1802 }
1803
Java_Electric_selectLibrary(JNIEnv * env,jobject obj,jobject jlib)1804 JNIEXPORT void JNICALL Java_Electric_selectLibrary(JNIEnv *env, jobject obj,
1805 jobject jlib)
1806 {
1807 LIBRARY *lib;
1808
1809 /* convert Java parameters to C */
1810 if (jlib == 0) return;
1811 lib = (LIBRARY *)(INTBIG)java_environment->GetLongField(jlib, java_addressID);
1812
1813 /* make the Electric call */
1814 selectlibrary(lib, TRUE);
1815 }
1816
1817 /****************************** ELECTRIC LIBRARY ROUTINES ******************************/
1818
Java_Electric_getNodeProto(JNIEnv * env,jobject obj,jstring jname)1819 JNIEXPORT jobject JNICALL Java_Electric_getNodeProto(JNIEnv *env, jobject obj,
1820 jstring jname)
1821 {
1822 jboolean isCopy;
1823 CHAR *name;
1824 NODEPROTO *np;
1825 jobject jnp;
1826
1827 /* convert Java parameters to C */
1828 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
1829
1830 /* make the Electric call */
1831 np = getnodeproto(name);
1832 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
1833
1834 /* convert C result to Java */
1835 jnp = java_makeobject((INTBIG)np, VNODEPROTO);
1836 return(jnp);
1837 }
1838
Java_Electric_newNodeProto(JNIEnv * env,jobject obj,jstring jname,jobject jlib)1839 JNIEXPORT jobject JNICALL Java_Electric_newNodeProto(JNIEnv *env, jobject obj,
1840 jstring jname, jobject jlib)
1841 {
1842 jboolean isCopy;
1843 CHAR *name;
1844 NODEPROTO *np;
1845 LIBRARY *lib;
1846 jobject jnp;
1847
1848 /* convert Java parameters to C */
1849 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
1850 if (jlib == 0) return(java_nullobject);
1851 lib = (LIBRARY *)(INTBIG)java_environment->GetLongField(jlib, java_addressID);
1852
1853 /* make the Electric call */
1854 np = newnodeproto(name, lib);
1855 if (np != NONODEPROTO) endobjectchange((INTBIG)np, VNODEPROTO);
1856 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
1857
1858 /* convert C result to Java */
1859 jnp = java_makeobject((INTBIG)np, VNODEPROTO);
1860 return(jnp);
1861 }
1862
Java_Electric_killNodeProto(JNIEnv * env,jobject obj,jobject jcell)1863 JNIEXPORT jint JNICALL Java_Electric_killNodeProto(JNIEnv *env, jobject obj,
1864 jobject jcell)
1865 {
1866 BOOLEAN ret;
1867 jint jret;
1868 NODEPROTO *cell;
1869
1870 /* convert Java parameters to C */
1871 if (jcell == 0) return(1);
1872 cell = (NODEPROTO *)(INTBIG)java_environment->GetLongField(jcell, java_addressID);
1873
1874 /* make the Electric call */
1875 startobjectchange((INTBIG)cell, VNODEPROTO);
1876 ret = killnodeproto(cell);
1877
1878 /* convert C result to Java */
1879 jret = ret?1:0;
1880 return(jret);
1881 }
1882
Java_Electric_copyNodeProto(JNIEnv * env,jobject obj,jobject jcell,jobject jlib,jstring jname)1883 JNIEXPORT jobject JNICALL Java_Electric_copyNodeProto(JNIEnv *env, jobject obj,
1884 jobject jcell, jobject jlib, jstring jname)
1885 {
1886 jboolean isCopy;
1887 CHAR *name;
1888 NODEPROTO *np, *cell;
1889 LIBRARY *lib;
1890 jobject jnp;
1891
1892 /* convert Java parameters to C */
1893 if (jcell == 0) return(java_nullobject);
1894 if (jlib == 0) return(java_nullobject);
1895 cell = (NODEPROTO *)(INTBIG)java_environment->GetLongField(jcell, java_addressID);
1896 lib = (LIBRARY *)(INTBIG)java_environment->GetLongField(jlib, java_addressID);
1897 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
1898
1899 /* make the Electric call */
1900 np = copynodeproto(cell, lib, name, FALSE);
1901 if (np != NONODEPROTO) endobjectchange((INTBIG)np, VNODEPROTO);
1902 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
1903
1904 /* convert C result to Java */
1905 jnp = java_makeobject((INTBIG)np, VNODEPROTO);
1906 return(jnp);
1907 }
1908
Java_Electric_iconView(JNIEnv * env,jobject obj,jobject jcell)1909 JNIEXPORT jobject JNICALL Java_Electric_iconView(JNIEnv *env, jobject obj,
1910 jobject jcell)
1911 {
1912 jobject jiconcell;
1913 NODEPROTO *cell, *iconcell;
1914
1915 /* convert Java parameters to C */
1916 if (jcell == 0) return(java_nullobject);
1917 cell = (NODEPROTO *)(INTBIG)java_environment->GetLongField(jcell, java_addressID);
1918
1919 /* make the Electric call */
1920 iconcell = iconview(cell);
1921
1922 /* convert C result to Java */
1923 jiconcell = java_makeobject((INTBIG)iconcell, VNODEPROTO);
1924 return(jiconcell);
1925 }
1926
Java_Electric_contentsView(JNIEnv * env,jobject obj,jobject jcell)1927 JNIEXPORT jobject JNICALL Java_Electric_contentsView(JNIEnv *env, jobject obj,
1928 jobject jcell)
1929 {
1930 jobject jcontentscell;
1931 NODEPROTO *cell, *contentscell;
1932
1933 /* convert Java parameters to C */
1934 if (jcell == 0) return(java_nullobject);
1935 cell = (NODEPROTO *)(INTBIG)java_environment->GetLongField(jcell, java_addressID);
1936
1937 /* make the Electric call */
1938 contentscell = contentsview(cell);
1939
1940 /* convert C result to Java */
1941 jcontentscell = java_makeobject((INTBIG)contentscell, VNODEPROTO);
1942 return(jcontentscell);
1943 }
1944
1945 /****************************** ELECTRIC NODEINST ROUTINES ******************************/
1946
Java_Electric_newNodeInst(JNIEnv * env,jobject obj,jobject jproto,jint jlx,jint jhx,jint jly,jint jhy,jint jtrans,jint jrot,jobject jcell)1947 JNIEXPORT jobject JNICALL Java_Electric_newNodeInst(JNIEnv *env, jobject obj,
1948 jobject jproto, jint jlx, jint jhx, jint jly, jint jhy, jint jtrans, jint jrot, jobject jcell)
1949 {
1950 jobject jni;
1951 NODEINST *ni;
1952 NODEPROTO *cell, *proto;
1953 INTBIG lx, hx, ly, hy;
1954 INTBIG rot, trans;
1955
1956 /* convert Java parameters to C */
1957 if (jproto == 0) return(java_nullobject);
1958 if (jcell == 0) return(java_nullobject);
1959 proto = (NODEPROTO *)(INTBIG)java_environment->GetLongField(jproto, java_addressID);
1960 lx = jlx; hx = jhx;
1961 ly = jly; hy = jhy;
1962 trans = jtrans;
1963 rot = jrot;
1964 cell = (NODEPROTO *)(INTBIG)java_environment->GetLongField(jcell, java_addressID);
1965
1966 /* make the Electric call */
1967 ni = newnodeinst(proto, lx, hx, ly, hy, trans, rot, cell);
1968 if (ni != NONODEINST) endobjectchange((INTBIG)ni, VNODEINST);
1969
1970 /* convert C result to Java */
1971 jni = java_makeobject((INTBIG)ni, VNODEINST);
1972 return(jni);
1973 }
1974
Java_Electric_modifyNodeInst(JNIEnv * env,jobject obj,jobject jni,jint jdlx,jint jdly,jint jdhx,jint jdhy,jint jdrot,jint jdtrans)1975 JNIEXPORT void JNICALL Java_Electric_modifyNodeInst(JNIEnv *env, jobject obj,
1976 jobject jni, jint jdlx, jint jdly, jint jdhx, jint jdhy, jint jdrot, jint jdtrans)
1977 {
1978 NODEINST *ni;
1979 INTBIG dlx, dhx, dly, dhy;
1980 INTBIG drot, dtrans;
1981
1982 /* convert Java parameters to C */
1983 if (jni == 0) return;
1984 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
1985 dlx = jdlx; dhx = jdhx;
1986 dly = jdly; dhy = jdhy;
1987 drot = jdrot;
1988 dtrans = jdtrans;
1989
1990 /* make the Electric call */
1991 startobjectchange((INTBIG)ni, VNODEINST);
1992 modifynodeinst(ni, dlx, dly, dhx, dhy, drot, dtrans);
1993 endobjectchange((INTBIG)ni, VNODEINST);
1994 }
1995
Java_Electric_killNodeInst(JNIEnv * env,jobject obj,jobject jni)1996 JNIEXPORT jint JNICALL Java_Electric_killNodeInst(JNIEnv *env, jobject obj,
1997 jobject jni)
1998 {
1999 NODEINST *ni;
2000 BOOLEAN ret;
2001 jint jret;
2002
2003 /* convert Java parameters to C */
2004 if (jni == 0) return(1);
2005 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
2006
2007 /* make the Electric call */
2008 startobjectchange((INTBIG)ni, VNODEINST);
2009 ret = killnodeinst(ni);
2010
2011 /* convert C result to Java */
2012 jret = ret?1:0;
2013 return(jret);
2014 }
2015
Java_Electric_replaceNodeInst(JNIEnv * env,jobject obj,jobject jni,jobject jproto)2016 JNIEXPORT jobject JNICALL Java_Electric_replaceNodeInst(JNIEnv *env, jobject obj,
2017 jobject jni, jobject jproto)
2018 {
2019 NODEINST *ni, *newni;
2020 NODEPROTO *proto;
2021 jobject jnewni;
2022
2023 /* convert Java parameters to C */
2024 if (jni == 0) return(java_nullobject);
2025 if (jproto == 0) return(java_nullobject);
2026 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
2027 proto = (NODEPROTO*)(INTBIG)java_environment->GetLongField(jproto, java_addressID);
2028
2029 /* make the Electric call */
2030 startobjectchange((INTBIG)ni, VNODEINST);
2031 newni = replacenodeinst(ni, proto, FALSE, FALSE);
2032 if (newni != NONODEINST) endobjectchange((INTBIG)newni, VNODEINST);
2033
2034 /* convert C result to Java */
2035 jnewni = java_makeobject((INTBIG)newni, VNODEINST);
2036 return(jnewni);
2037 }
2038
Java_Electric_nodeFunction(JNIEnv * env,jobject obj,jobject jni)2039 JNIEXPORT jint JNICALL Java_Electric_nodeFunction(JNIEnv *env, jobject obj,
2040 jobject jni)
2041 {
2042 NODEINST *ni;
2043 INTBIG fun;
2044 jint jfun;
2045
2046 /* convert Java parameters to C */
2047 if (jni == 0) return(0);
2048 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
2049
2050 /* make the Electric call */
2051 fun = nodefunction(ni);
2052
2053 /* convert C result to Java */
2054 jfun = fun;
2055 return(jfun);
2056 }
2057
Java_Electric_nodePolys(JNIEnv * env,jobject obj,jobject jni)2058 JNIEXPORT jint JNICALL Java_Electric_nodePolys(JNIEnv *env, jobject obj,
2059 jobject jni)
2060 {
2061 NODEINST *ni;
2062 INTBIG count;
2063 jint jcount;
2064
2065 /* convert Java parameters to C */
2066 if (jni == 0) return(0);
2067 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
2068
2069 /* make the Electric call */
2070 count = nodepolys(ni, 0, NOWINDOWPART);
2071
2072 /* convert C result to Java */
2073 jcount = count;
2074 return(jcount);
2075 }
2076
Java_Electric_shapeNodePoly(JNIEnv * env,jobject obj,jobject jni,jint jindex)2077 JNIEXPORT jobject JNICALL Java_Electric_shapeNodePoly(JNIEnv *env, jobject obj,
2078 jobject jni, jint jindex)
2079 {
2080 NODEINST *ni;
2081 INTBIG index;
2082 jobject jpoly;
2083 POLYGON *poly;
2084
2085 /* convert Java parameters to C */
2086 if (jni == 0) return(java_nullobject);
2087 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
2088 index = jindex;
2089
2090 /* make the Electric call */
2091 poly = allocpolygon(4, db_cluster);
2092 shapenodepoly(ni, index, poly);
2093
2094 /* convert C result to Java */
2095 jpoly = java_makeobject((INTBIG)poly, VPOLYGON);
2096 return(jpoly);
2097 }
2098
Java_Electric_nodeEPolys(JNIEnv * env,jobject obj,jobject jni)2099 JNIEXPORT jint JNICALL Java_Electric_nodeEPolys(JNIEnv *env, jobject obj,
2100 jobject jni)
2101 {
2102 NODEINST *ni;
2103 INTBIG count;
2104 jint jcount;
2105
2106 /* convert Java parameters to C */
2107 if (jni == 0) return(0);
2108 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
2109
2110 /* make the Electric call */
2111 count = nodeEpolys(ni, 0, NOWINDOWPART);
2112
2113 /* convert C result to Java */
2114 jcount = count;
2115 return(jcount);
2116 }
2117
Java_Electric_shapeENodePoly(JNIEnv * env,jobject obj,jobject jni,jint jindex)2118 JNIEXPORT jobject JNICALL Java_Electric_shapeENodePoly(JNIEnv *env, jobject obj,
2119 jobject jni, jint jindex)
2120 {
2121 NODEINST *ni;
2122 INTBIG index;
2123 jobject jpoly;
2124 POLYGON *poly;
2125
2126 /* convert Java parameters to C */
2127 if (jni == 0) return(java_nullobject);
2128 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
2129 index = jindex;
2130
2131 /* make the Electric call */
2132 poly = allocpolygon(4, db_cluster);
2133 shapeEnodepoly(ni, index, poly);
2134
2135 /* convert C result to Java */
2136 jpoly = java_makeobject((INTBIG)poly, VPOLYGON);
2137 return(jpoly);
2138 }
2139
Java_Electric_makeRot(JNIEnv * env,jobject obj,jobject jni)2140 JNIEXPORT jobject JNICALL Java_Electric_makeRot(JNIEnv *env, jobject obj,
2141 jobject jni)
2142 {
2143 NODEINST *ni;
2144 XARRAY trans;
2145 jobject object;
2146 jintArray vArray;
2147
2148 /* convert Java parameters to C */
2149 if (jni == 0) return(java_nullobject);
2150 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
2151
2152 /* make the Electric call */
2153 makerot(ni, trans);
2154
2155 /* convert C result to Java */
2156 object = java_environment->AllocObject(java_classxarray);
2157 vArray = java_environment->NewIntArray(9);
2158 java_environment->SetIntArrayRegion(vArray, (jsize)0, (jsize)9, (jint *)&trans[0][0]);
2159 java_environment->SetObjectField(object, java_xarrayVID, (jobject)vArray);
2160 return(object);
2161 }
2162
Java_Electric_makeTrans(JNIEnv * env,jobject obj,jobject jni)2163 JNIEXPORT jobject JNICALL Java_Electric_makeTrans(JNIEnv *env, jobject obj,
2164 jobject jni)
2165 {
2166 NODEINST *ni;
2167 XARRAY trans;
2168 jobject object;
2169 jintArray vArray;
2170
2171 /* convert Java parameters to C */
2172 if (jni == 0) return(java_nullobject);
2173 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
2174
2175 /* make the Electric call */
2176 maketrans(ni, trans);
2177
2178 /* convert C result to Java */
2179 object = java_environment->AllocObject(java_classxarray);
2180 vArray = java_environment->NewIntArray(9);
2181 java_environment->SetIntArrayRegion(vArray, (jsize)0, (jsize)9, (jint *)&trans[0][0]);
2182 java_environment->SetObjectField(object, java_xarrayVID, (jobject)vArray);
2183 return(object);
2184 }
2185
Java_Electric_nodeProtoSizeOffset(JNIEnv * env,jobject obj,jobject jnp)2186 JNIEXPORT jintArray JNICALL Java_Electric_nodeProtoSizeOffset(JNIEnv *env, jobject obj,
2187 jobject jnp)
2188 {
2189 NODEPROTO *np;
2190 INTBIG lx, hx, ly, hy;
2191 jintArray retarray;
2192 jint *retarrayptr;
2193 jboolean isCopy;
2194
2195 /* convert Java parameters to C */
2196 if (jnp == 0) return((jintArray)java_nullobject);
2197 np = (NODEPROTO *)(INTBIG)java_environment->GetLongField(jnp, java_addressID);
2198
2199 /* make the Electric call */
2200 nodeprotosizeoffset(np, &lx, &ly, &hx, &hy, NONODEPROTO);
2201
2202 /* convert C result to Java */
2203 retarray = java_environment->NewIntArray(4);
2204 retarrayptr = java_environment->GetIntArrayElements(retarray, &isCopy);
2205 retarrayptr[0] = lx;
2206 retarrayptr[1] = ly;
2207 retarrayptr[2] = hx;
2208 retarrayptr[3] = hy;
2209 return(retarray);
2210 }
2211
2212 /****************************** ELECTRIC ARCINST ROUTINES ******************************/
2213
Java_Electric_newArcInst(JNIEnv * env,jobject obj,jobject jproto,jint jwid,jint jbits,jobject jni1,jobject jpp1,jint jx1,jint jy1,jobject jni2,jobject jpp2,jint jx2,jint jy2,jobject jcell)2214 JNIEXPORT jobject JNICALL Java_Electric_newArcInst(JNIEnv *env, jobject obj,
2215 jobject jproto, jint jwid, jint jbits, jobject jni1, jobject jpp1, jint jx1, jint jy1,
2216 jobject jni2, jobject jpp2, jint jx2, jint jy2, jobject jcell)
2217 {
2218 jobject jai;
2219 ARCINST *ai;
2220 NODEPROTO *cell;
2221 NODEINST *ni1, *ni2;
2222 PORTPROTO *pp1, *pp2;
2223 ARCPROTO *proto;
2224 INTBIG wid, bits, x1, y1, x2, y2;
2225
2226 /* convert Java parameters to C */
2227 if (jproto == 0) return(java_nullobject);
2228 if (jni1 == 0 || jpp1 == 0) return(java_nullobject);
2229 if (jni2 == 0 || jpp2 == 0) return(java_nullobject);
2230 if (jcell == 0) return(java_nullobject);
2231 proto = (ARCPROTO *)(INTBIG)java_environment->GetLongField(jproto, java_addressID);
2232 wid = jwid; bits = jbits;
2233 ni1 = (NODEINST *)(INTBIG)java_environment->GetLongField(jni1, java_addressID);
2234 pp1 = (PORTPROTO *)(INTBIG)java_environment->GetLongField(jpp1, java_addressID);
2235 x1 = jx1; y1 = jy1;
2236 ni2 = (NODEINST *)(INTBIG)java_environment->GetLongField(jni2, java_addressID);
2237 pp2 = (PORTPROTO *)(INTBIG)java_environment->GetLongField(jpp2, java_addressID);
2238 x2 = jx2; y2 = jy2;
2239 cell = (NODEPROTO *)(INTBIG)java_environment->GetLongField(jcell, java_addressID);
2240
2241 /* make the Electric call */
2242 ai = newarcinst(proto, wid, bits, ni1, pp1, x1, y1, ni2, pp2, x2, y2, cell);
2243 if (ai != NOARCINST) endobjectchange((INTBIG)ai, VARCINST);
2244
2245 /* convert C result to Java */
2246 jai = java_makeobject((INTBIG)ai, VARCINST);
2247 return(jai);
2248 }
2249
Java_Electric_modifyArcInst(JNIEnv * env,jobject obj,jobject jai,jint jdwid,jint jdx1,jint jdy1,jint jdx2,jint jdy2)2250 JNIEXPORT jint JNICALL Java_Electric_modifyArcInst(JNIEnv *env, jobject obj,
2251 jobject jai, jint jdwid, jint jdx1, jint jdy1, jint jdx2, jint jdy2)
2252 {
2253 ARCINST *ai;
2254 INTBIG dwid, dx1, dy1, dx2, dy2;
2255 BOOLEAN ret;
2256 jint jret;
2257
2258 /* convert Java parameters to C */
2259 if (jai == 0) return(1);
2260 ai = (ARCINST *)(INTBIG)java_environment->GetLongField(jai, java_addressID);
2261 dwid = jdwid;
2262 dx1 = jdx1; dy1 = jdy1;
2263 dx2 = jdx2; dy2 = jdy2;
2264
2265 /* make the Electric call */
2266 startobjectchange((INTBIG)ai, VARCINST);
2267 ret = modifyarcinst(ai, dwid, dx1, dy1, dx2, dy2);
2268 endobjectchange((INTBIG)ai, VARCINST);
2269
2270 /* convert C result to Java */
2271 jret = ret?1:0;
2272 return(jret);
2273 }
2274
Java_Electric_killArcInst(JNIEnv * env,jobject obj,jobject jai)2275 JNIEXPORT jint JNICALL Java_Electric_killArcInst(JNIEnv *env, jobject obj,
2276 jobject jai)
2277 {
2278 ARCINST *ai;
2279 BOOLEAN ret;
2280 jint jret;
2281
2282 /* convert Java parameters to C */
2283 if (jai == 0) return(1);
2284 ai = (ARCINST *)(INTBIG)java_environment->GetLongField(jai, java_addressID);
2285
2286 /* make the Electric call */
2287 startobjectchange((INTBIG)ai, VARCINST);
2288 ret = killarcinst(ai);
2289
2290 /* convert C result to Java */
2291 jret = ret?1:0;
2292 return(jret);
2293 }
2294
Java_Electric_replaceArcInst(JNIEnv * env,jobject obj,jobject jai,jobject jap)2295 JNIEXPORT jobject JNICALL Java_Electric_replaceArcInst(JNIEnv *env, jobject obj,
2296 jobject jai, jobject jap)
2297 {
2298 ARCINST *ai, *newai;
2299 ARCPROTO *ap;
2300 jobject jnewai;
2301
2302 /* convert Java parameters to C */
2303 if (jai == 0) return(java_nullobject);
2304 if (jap == 0) return(java_nullobject);
2305 ai = (ARCINST *)(INTBIG)java_environment->GetLongField(jai, java_addressID);
2306 ap = (ARCPROTO *)(INTBIG)java_environment->GetLongField(jap, java_addressID);
2307
2308 /* make the Electric call */
2309 startobjectchange((INTBIG)ai, VARCINST);
2310 newai = replacearcinst(ai, ap);
2311 if (newai != NOARCINST) endobjectchange((INTBIG)newai, VARCINST);
2312
2313 /* convert C result to Java */
2314 jnewai = java_makeobject((INTBIG)newai, VARCINST);
2315 return(jnewai);
2316 }
2317
Java_Electric_arcPolys(JNIEnv * env,jobject obj,jobject jai)2318 JNIEXPORT jint JNICALL Java_Electric_arcPolys(JNIEnv *env, jobject obj,
2319 jobject jai)
2320 {
2321 ARCINST *ai;
2322 INTBIG count;
2323 jint jcount;
2324
2325 /* convert Java parameters to C */
2326 if (jai == 0) return(0);
2327 ai = (ARCINST *)(INTBIG)java_environment->GetLongField(jai, java_addressID);
2328
2329 /* make the Electric call */
2330 count = arcpolys(ai, NOWINDOWPART);
2331
2332 /* convert C result to Java */
2333 jcount = count;
2334 return(jcount);
2335 }
2336
Java_Electric_shapeArcPoly(JNIEnv * env,jobject obj,jobject jai,jint jindex)2337 JNIEXPORT jobject JNICALL Java_Electric_shapeArcPoly(JNIEnv *env, jobject obj,
2338 jobject jai, jint jindex)
2339 {
2340 ARCINST *ai;
2341 INTBIG index;
2342 jobject jpoly;
2343 POLYGON *poly;
2344
2345 /* convert Java parameters to C */
2346 if (jai == 0) return(java_nullobject);
2347 ai = (ARCINST *)(INTBIG)java_environment->GetLongField(jai, java_addressID);
2348 index = jindex;
2349
2350 /* make the Electric call */
2351 poly = allocpolygon(4, db_cluster);
2352 shapearcpoly(ai, index, poly);
2353
2354 /* convert C result to Java */
2355 jpoly = java_makeobject((INTBIG)poly, VPOLYGON);
2356 return(jpoly);
2357 }
2358
Java_Electric_arcProtoWidthOffset(JNIEnv * env,jobject obj,jobject jap)2359 JNIEXPORT jint JNICALL Java_Electric_arcProtoWidthOffset(JNIEnv *env, jobject obj,
2360 jobject jap)
2361 {
2362 ARCPROTO *ap;
2363 INTBIG offset;
2364 jint joffset;
2365
2366 /* convert Java parameters to C */
2367 if (jap == 0) return(0);
2368 ap = (ARCPROTO *)(INTBIG)java_environment->GetLongField(jap, java_addressID);
2369
2370 /* make the Electric call */
2371 offset = arcprotowidthoffset(ap);
2372
2373 /* convert C result to Java */
2374 joffset = offset;
2375 return(joffset);
2376 }
2377
2378 /****************************** ELECTRIC PORTPROTO ROUTINES ******************************/
2379
Java_Electric_newPortProto(JNIEnv * env,jobject obj,jobject jnp,jobject jni,jobject jpp,jstring jname)2380 JNIEXPORT jobject JNICALL Java_Electric_newPortProto(JNIEnv *env, jobject obj,
2381 jobject jnp, jobject jni, jobject jpp, jstring jname)
2382 {
2383 NODEPROTO *np;
2384 jboolean isCopy;
2385 NODEINST *ni;
2386 PORTPROTO *pp, *newpp;
2387 CHAR *name;
2388 jobject jnewpp;
2389
2390 /* convert Java parameters to C */
2391 if (jnp == 0) return(java_nullobject);
2392 if (jni == 0) return(java_nullobject);
2393 if (jpp == 0) return(java_nullobject);
2394 np = (NODEPROTO *)(INTBIG)java_environment->GetLongField(jnp, java_addressID);
2395 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
2396 pp = (PORTPROTO *)(INTBIG)java_environment->GetLongField(jpp, java_addressID);
2397 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
2398
2399 /* make the Electric call */
2400 newpp = newportproto(np, ni, pp, name);
2401 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
2402
2403 /* convert C result to Java */
2404 jnewpp = java_makeobject((INTBIG)newpp, VPORTPROTO);
2405 return(jnewpp);
2406 }
2407
Java_Electric_portPosition(JNIEnv * env,jobject obj,jobject jni,jobject jpp)2408 JNIEXPORT jobjectArray JNICALL Java_Electric_portPosition(JNIEnv *env, jobject obj,
2409 jobject jni, jobject jpp)
2410 {
2411 NODEINST *ni;
2412 PORTPROTO *pp;
2413 INTBIG x, y;
2414 jobjectArray retarray;
2415
2416 /* convert Java parameters to C */
2417 if (jni == 0) return((jobjectArray)java_nullobject);
2418 if (jpp == 0) return((jobjectArray)java_nullobject);
2419 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
2420 pp = (PORTPROTO *)(INTBIG)java_environment->GetLongField(jpp, java_addressID);
2421
2422 /* make the Electric call */
2423 portposition(ni, pp, &x, &y);
2424
2425 /* convert C result to Java */
2426 retarray = java_environment->NewObjectArray(2, java_classint, NULL);
2427 java_environment->SetObjectArrayElement(retarray, 0, java_makeobject(x, VINTEGER));
2428 java_environment->SetObjectArrayElement(retarray, 1, java_makeobject(y, VINTEGER));
2429 return(retarray);
2430 }
2431
Java_Electric_getPortProto(JNIEnv * env,jobject obj,jobject jnp,jstring jname)2432 JNIEXPORT jobject JNICALL Java_Electric_getPortProto(JNIEnv *env, jobject obj,
2433 jobject jnp, jstring jname)
2434 {
2435 NODEPROTO *np;
2436 PORTPROTO *pp;
2437 jboolean isCopy;
2438 CHAR *name;
2439 jobject jpp;
2440
2441 /* convert Java parameters to C */
2442 if (jnp == 0) return(java_nullobject);
2443 np = (NODEPROTO *)(INTBIG)java_environment->GetLongField(jnp, java_addressID);
2444 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
2445
2446 /* make the Electric call */
2447 pp = getportproto(np, name);
2448 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
2449
2450 /* convert C result to Java */
2451 jpp = java_makeobject((INTBIG)pp, VPORTPROTO);
2452 return(jpp);
2453 }
2454
Java_Electric_killPortProto(JNIEnv * env,jobject obj,jobject jnp,jobject jpp)2455 JNIEXPORT jint JNICALL Java_Electric_killPortProto(JNIEnv *env, jobject obj,
2456 jobject jnp, jobject jpp)
2457 {
2458 NODEPROTO *np;
2459 PORTPROTO *pp;
2460 BOOLEAN ret;
2461 jint jret;
2462
2463 /* convert Java parameters to C */
2464 if (jnp == 0) return(1);
2465 if (jpp == 0) return(1);
2466 np = (NODEPROTO *)(INTBIG)java_environment->GetLongField(jnp, java_addressID);
2467 pp = (PORTPROTO *)(INTBIG)java_environment->GetLongField(jpp, java_addressID);
2468
2469 /* make the Electric call */
2470 ret = killportproto(np, pp);
2471
2472 /* convert C result to Java */
2473 jret = ret?1:0;
2474 return(jret);
2475 }
2476
Java_Electric_movePortProto(JNIEnv * env,jobject obj,jobject jnp,jobject joldpp,jobject jni,jobject jpp)2477 JNIEXPORT jint JNICALL Java_Electric_movePortProto(JNIEnv *env, jobject obj,
2478 jobject jnp, jobject joldpp, jobject jni, jobject jpp)
2479 {
2480 NODEPROTO *np;
2481 NODEINST *ni;
2482 PORTPROTO *pp, *oldpp;
2483 BOOLEAN ret;
2484 jint jret;
2485
2486 /* convert Java parameters to C */
2487 if (jnp == 0) return(1);
2488 if (joldpp == 0) return(1);
2489 if (jni == 0) return(1);
2490 if (jpp == 0) return(1);
2491 np = (NODEPROTO *)(INTBIG)java_environment->GetLongField(jnp, java_addressID);
2492 oldpp = (PORTPROTO *)(INTBIG)java_environment->GetLongField(joldpp, java_addressID);
2493 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
2494 pp = (PORTPROTO *)(INTBIG)java_environment->GetLongField(jpp, java_addressID);
2495
2496 /* make the Electric call */
2497 ret = moveportproto(np, oldpp, ni, pp);
2498
2499 /* convert C result to Java */
2500 jret = ret?1:0;
2501 return(jret);
2502 }
2503
Java_Electric_shapePortPoly(JNIEnv * env,jobject obj,jobject jni,jobject jpp)2504 JNIEXPORT jobject JNICALL Java_Electric_shapePortPoly(JNIEnv *env, jobject obj,
2505 jobject jni, jobject jpp)
2506 {
2507 NODEINST *ni;
2508 PORTPROTO *pp;
2509 jobject jpoly;
2510 POLYGON *poly;
2511
2512 /* convert Java parameters to C */
2513 if (jni == 0 || jpp == 0) return(java_nullobject);
2514 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
2515 pp = (PORTPROTO *)(INTBIG)java_environment->GetLongField(jpp, java_addressID);
2516
2517 /* make the Electric call */
2518 poly = allocpolygon(4, db_cluster);
2519 shapeportpoly(ni, pp, poly, FALSE);
2520
2521 /* convert C result to Java */
2522 jpoly = java_makeobject((INTBIG)poly, VPOLYGON);
2523 return(jpoly);
2524 }
2525
2526 /****************************** ELECTRIC CHANGE CONTROL ROUTINES ******************************/
2527
Java_Electric_undoABatch(JNIEnv * env,jobject obj)2528 JNIEXPORT jint JNICALL Java_Electric_undoABatch(JNIEnv *env, jobject obj)
2529 {
2530 TOOL *tool;
2531 INTBIG ret;
2532 jint jret;
2533
2534 /* make the Electric call */
2535 ret = undoabatch(&tool);
2536
2537 /* convert C result to Java */
2538 jret = ret;
2539 return(jret);
2540 }
2541
Java_Electric_noUndoAllowed(JNIEnv * env,jobject obj)2542 JNIEXPORT void JNICALL Java_Electric_noUndoAllowed(JNIEnv *env, jobject obj)
2543 {
2544 /* make the Electric call */
2545 noundoallowed();
2546 }
2547
Java_Electric_flushChanges(JNIEnv * env,jobject obj)2548 JNIEXPORT void JNICALL Java_Electric_flushChanges(JNIEnv *env, jobject obj)
2549 {
2550 /* make the Electric call */
2551 (*el_curconstraint->solve)(NONODEPROTO);
2552 us_endchanges(NOWINDOWPART);
2553 }
2554
2555 /****************************** ELECTRIC VIEW ROUTINES ******************************/
2556
Java_Electric_getView(JNIEnv * env,jobject obj,jstring jname)2557 JNIEXPORT jobject JNICALL Java_Electric_getView(JNIEnv *env, jobject obj,
2558 jstring jname)
2559 {
2560 jboolean isCopy;
2561 CHAR *name;
2562 VIEW *view;
2563 jobject jview;
2564
2565 /* convert Java parameters to C */
2566 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
2567
2568 /* make the Electric call */
2569 view = getview(name);
2570 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
2571
2572 /* convert C result to Java */
2573 jview = java_makeobject((INTBIG)view, VVIEW);
2574 return(jview);
2575 }
2576
Java_Electric_newView(JNIEnv * env,jobject obj,jstring jname,jstring jsname)2577 JNIEXPORT jobject JNICALL Java_Electric_newView(JNIEnv *env, jobject obj,
2578 jstring jname, jstring jsname)
2579 {
2580 jboolean isCopy1, isCopy2;
2581 CHAR *name, *sname;
2582 VIEW *view;
2583 jobject jview;
2584
2585 /* convert Java parameters to C */
2586 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy1);
2587 sname = (CHAR *)java_environment->GetStringUTFChars(jsname, &isCopy2);
2588
2589 /* make the Electric call */
2590 view = newview(name, sname);
2591 if (isCopy1 == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
2592 if (isCopy2 == JNI_TRUE) java_environment->ReleaseStringUTFChars(jsname, sname);
2593
2594 /* convert C result to Java */
2595 jview = java_makeobject((INTBIG)view, VVIEW);
2596 return(jview);
2597 }
2598
Java_Electric_killView(JNIEnv * env,jobject obj,jobject jview)2599 JNIEXPORT jint JNICALL Java_Electric_killView(JNIEnv *env, jobject obj,
2600 jobject jview)
2601 {
2602 VIEW *view;
2603 BOOLEAN ret;
2604 jint jret;
2605
2606 /* convert Java parameters to C */
2607 if (jview == 0) return(1);
2608 view = (VIEW *)(INTBIG)java_environment->GetLongField(jview, java_addressID);
2609
2610 /* make the Electric call */
2611 ret = killview(view);
2612
2613 /* convert C result to Java */
2614 jret = ret?1:0;
2615 return(jret);
2616 }
2617
2618 /****************************** ELECTRIC MISCELLANEOUS ROUTINES ******************************/
2619
Java_Electric_getArcProto(JNIEnv * env,jobject obj,jstring jname)2620 JNIEXPORT jobject JNICALL Java_Electric_getArcProto(JNIEnv *env, jobject obj,
2621 jstring jname)
2622 {
2623 jboolean isCopy;
2624 CHAR *name;
2625 ARCPROTO *ap;
2626 jobject jap;
2627
2628 /* convert Java parameters to C */
2629 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
2630
2631 /* make the Electric call */
2632 ap = getarcproto(name);
2633 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
2634
2635 /* convert C result to Java */
2636 jap = java_makeobject((INTBIG)ap, VARCPROTO);
2637 return(jap);
2638 }
2639
Java_Electric_getTechnology(JNIEnv * env,jobject obj,jstring jname)2640 JNIEXPORT jobject JNICALL Java_Electric_getTechnology(JNIEnv *env, jobject obj,
2641 jstring jname)
2642 {
2643 jboolean isCopy;
2644 CHAR *name;
2645 TECHNOLOGY *tech;
2646 jobject jtech;
2647
2648 /* convert Java parameters to C */
2649 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
2650
2651 /* make the Electric call */
2652 tech = gettechnology(name);
2653 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
2654
2655 /* convert C result to Java */
2656 jtech = java_makeobject((INTBIG)tech, VTECHNOLOGY);
2657 return(jtech);
2658 }
2659
Java_Electric_getPinProto(JNIEnv * env,jobject obj,jobject jap)2660 JNIEXPORT jobject JNICALL Java_Electric_getPinProto(JNIEnv *env, jobject obj,
2661 jobject jap)
2662 {
2663 ARCPROTO *ap;
2664 NODEPROTO *np;
2665 jobject jnp;
2666
2667 /* convert Java parameters to C */
2668 if (jap == 0) return(java_nullobject);
2669 ap = (ARCPROTO *)(INTBIG)java_environment->GetLongField(jap, java_addressID);
2670
2671 /* make the Electric call */
2672 np = getpinproto(ap);
2673
2674 /* convert C result to Java */
2675 jnp = java_makeobject((INTBIG)np, VNODEPROTO);
2676 return(jnp);
2677 }
2678
Java_Electric_getNetwork(JNIEnv * env,jobject obj,jstring jname,jobject jnp)2679 JNIEXPORT jobject JNICALL Java_Electric_getNetwork(JNIEnv *env, jobject obj,
2680 jstring jname, jobject jnp)
2681 {
2682 NETWORK *net;
2683 NODEPROTO *np;
2684 jobject jnet;
2685 jboolean isCopy;
2686 CHAR *name;
2687
2688 /* convert Java parameters to C */
2689 if (jnp == 0) return(java_nullobject);
2690 name = (CHAR *)java_environment->GetStringUTFChars(jname, &isCopy);
2691 np = (NODEPROTO *)(INTBIG)java_environment->GetLongField(jnp, java_addressID);
2692
2693 /* make the Electric call */
2694 net = getnetwork(name, np);
2695 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jname, name);
2696
2697 /* convert C result to Java */
2698 jnet = java_makeobject((INTBIG)net, VNETWORK);
2699 return(jnet);
2700 }
2701
Java_Electric_layerName(JNIEnv * env,jobject obj,jobject jtech,jint jlayer)2702 JNIEXPORT jstring JNICALL Java_Electric_layerName(JNIEnv *env, jobject obj,
2703 jobject jtech, jint jlayer)
2704 {
2705 TECHNOLOGY *tech;
2706 INTBIG layer;
2707 CHAR *name;
2708 jstring jname;
2709
2710 /* convert Java parameters to C */
2711 if (jtech == 0) return(0);
2712 tech = (TECHNOLOGY *)(INTBIG)java_environment->GetLongField(jtech, java_addressID);
2713 layer = jlayer;
2714
2715 /* make the Electric call */
2716 name = layername(tech, layer);
2717
2718 /* convert C result to Java */
2719 jname = java_environment->NewStringUTF(string1byte(name));
2720 return(jname);
2721 }
2722
Java_Electric_layerFunction(JNIEnv * env,jobject obj,jobject jtech,jint jlayer)2723 JNIEXPORT jint JNICALL Java_Electric_layerFunction(JNIEnv *env, jobject obj,
2724 jobject jtech, jint jlayer)
2725 {
2726 TECHNOLOGY *tech;
2727 INTBIG layer, fun;
2728 jint jfun;
2729
2730 /* convert Java parameters to C */
2731 if (jtech == 0) return(0);
2732 tech = (TECHNOLOGY *)(INTBIG)java_environment->GetLongField(jtech, java_addressID);
2733 layer = jlayer;
2734
2735 /* make the Electric call */
2736 fun = layerfunction(tech, layer);
2737
2738 /* convert C result to Java */
2739 jfun = fun;
2740 return(jfun);
2741 }
2742
Java_Electric_maxDRCSurround(JNIEnv * env,jobject obj,jobject jtech,jobject jlib,jint jlayer)2743 JNIEXPORT jint JNICALL Java_Electric_maxDRCSurround(JNIEnv *env, jobject obj,
2744 jobject jtech, jobject jlib, jint jlayer)
2745 {
2746 TECHNOLOGY *tech;
2747 LIBRARY *lib;
2748 INTBIG layer, dist;
2749 jint jdist;
2750
2751 /* convert Java parameters to C */
2752 if (jtech == 0 || jlib == 0) return(0);
2753 tech = (TECHNOLOGY *)(INTBIG)java_environment->GetLongField(jtech, java_addressID);
2754 lib = (LIBRARY *)(INTBIG)java_environment->GetLongField(jlib, java_addressID);
2755 layer = jlayer;
2756
2757 /* make the Electric call */
2758 dist = maxdrcsurround(tech, lib, layer);
2759
2760 /* convert C result to Java */
2761 jdist = dist;
2762 return(jdist);
2763 }
2764
Java_Electric_DRCMinDistance(JNIEnv * env,jobject obj,jobject jtech,jobject jlib,jint jlayer1,jint jlayer2,jint jconnected)2765 JNIEXPORT jint JNICALL Java_Electric_DRCMinDistance(JNIEnv *env, jobject obj,
2766 jobject jtech, jobject jlib, jint jlayer1, jint jlayer2, jint jconnected)
2767 {
2768 TECHNOLOGY *tech;
2769 LIBRARY *lib;
2770 INTBIG layer1, layer2, dist, edge;
2771 BOOLEAN connected;
2772 jint jdist;
2773
2774 /* convert Java parameters to C */
2775 if (jtech == 0 || jlib == 0) return(0);
2776 tech = (TECHNOLOGY *)(INTBIG)java_environment->GetLongField(jtech, java_addressID);
2777 lib = (LIBRARY *)(INTBIG)java_environment->GetLongField(jlib, java_addressID);
2778 layer1 = jlayer1;
2779 layer2 = jlayer2;
2780 connected = jconnected != 0 ? TRUE : FALSE;
2781
2782 /* make the Electric call */
2783 dist = drcmindistance(tech, lib, layer1, 0, layer2, 0, connected, FALSE, &edge, 0);
2784
2785 /* convert C result to Java */
2786 jdist = dist;
2787 return(jdist);
2788 }
2789
Java_Electric_DRCMinWidth(JNIEnv * env,jobject obj,jobject jtech,jobject jlib,jint jlayer)2790 JNIEXPORT jint JNICALL Java_Electric_DRCMinWidth(JNIEnv *env, jobject obj,
2791 jobject jtech, jobject jlib, jint jlayer)
2792 {
2793 TECHNOLOGY *tech;
2794 LIBRARY *lib;
2795 INTBIG layer, dist;
2796 jint jdist;
2797
2798 /* convert Java parameters to C */
2799 if (jtech == 0 || jlib == 0) return(0);
2800 tech = (TECHNOLOGY *)(INTBIG)java_environment->GetLongField(jtech, java_addressID);
2801 lib = (LIBRARY *)(INTBIG)java_environment->GetLongField(jlib, java_addressID);
2802 layer = jlayer;
2803
2804 /* make the Electric call */
2805 dist = drcminwidth(tech, lib, layer, 0);
2806
2807 /* convert C result to Java */
2808 jdist = dist;
2809 return(jdist);
2810 }
2811
Java_Electric_xformPoly(JNIEnv * env,jobject obj,jobject jpoly,jobject jtrans)2812 JNIEXPORT void JNICALL Java_Electric_xformPoly(JNIEnv *env, jobject obj,
2813 jobject jpoly, jobject jtrans)
2814 {
2815 XARRAY trans;
2816 POLYGON *poly;
2817 INTBIG i;
2818 jintArray vArray;
2819
2820 /* convert Java parameters to C */
2821 if (jpoly == 0 || jtrans == 0) return;
2822 poly = (POLYGON *)(INTBIG)java_environment->GetLongField(jpoly, java_addressID);
2823 vArray = (jintArray)java_environment->GetObjectField(jtrans, java_xarrayVID);
2824 java_environment->GetIntArrayRegion(vArray, 0, 9, (jint *)&trans[0][0]);
2825
2826 /* make the Electric call */
2827 for(i=0; i<poly->count; i++)
2828 xform(poly->xv[i], poly->yv[i], &poly->xv[i], &poly->yv[i], trans);
2829 }
2830
Java_Electric_transMult(JNIEnv * env,jobject obj,jobject jtransa,jobject jtransb)2831 JNIEXPORT jobject JNICALL Java_Electric_transMult(JNIEnv *env, jobject obj,
2832 jobject jtransa, jobject jtransb)
2833 {
2834 XARRAY transa, transb, transc;
2835 jintArray vArray;
2836 jobject object;
2837
2838 /* convert Java parameters to C */
2839 if (jtransa == 0 || jtransb == 0) return(0);
2840 vArray = (jintArray)java_environment->GetObjectField(jtransa, java_xarrayVID);
2841 java_environment->GetIntArrayRegion(vArray, 0, 9, (jint *)&transa[0][0]);
2842 vArray = (jintArray)java_environment->GetObjectField(jtransb, java_xarrayVID);
2843 java_environment->GetIntArrayRegion(vArray, 0, 9, (jint *)&transb[0][0]);
2844
2845 /* make the Electric call */
2846 transmult(transa, transb, transc);
2847
2848 /* convert C result to Java */
2849 object = java_environment->AllocObject(java_classxarray);
2850 vArray = java_environment->NewIntArray(9);
2851 java_environment->SetIntArrayRegion(vArray, (jsize)0, (jsize)9, (jint *)&transc[0][0]);
2852 java_environment->SetObjectField(object, java_xarrayVID, (jobject)vArray);
2853 return(object);
2854 }
2855
Java_Electric_freePolygon(JNIEnv * env,jobject obj,jobject jpoly)2856 JNIEXPORT void JNICALL Java_Electric_freePolygon(JNIEnv *env, jobject obj,
2857 jobject jpoly)
2858 {
2859 POLYGON *poly;
2860
2861 /* convert Java parameters to C */
2862 if (jpoly == 0) return;
2863 poly = (POLYGON *)(INTBIG)java_environment->GetLongField(jpoly, java_addressID);
2864
2865 /* make the Electric call */
2866 freepolygon(poly);
2867 }
2868
Java_Electric_beginTraverseHierarchy(JNIEnv * env,jobject obj)2869 JNIEXPORT void JNICALL Java_Electric_beginTraverseHierarchy(JNIEnv *env, jobject obj)
2870 {
2871 /* make the Electric call */
2872 begintraversehierarchy();
2873 }
2874
Java_Electric_downHierarchy(JNIEnv * env,jobject obj,jobject jni,jint jindex)2875 JNIEXPORT void JNICALL Java_Electric_downHierarchy(JNIEnv *env, jobject obj,
2876 jobject jni, jint jindex)
2877 {
2878 NODEINST *ni;
2879 NODEPROTO *np, *cnp;
2880 INTBIG index;
2881
2882 /* convert Java parameters to C */
2883 if (jni == 0) return;
2884 ni = (NODEINST *)(INTBIG)java_environment->GetLongField(jni, java_addressID);
2885 index = jindex;
2886
2887 /* make the Electric call */
2888 np = ni->proto;
2889 cnp = contentsview(np);
2890 if (cnp != NONODEPROTO) np = cnp;
2891 downhierarchy(ni, cnp, index);
2892 }
2893
Java_Electric_upHierarchy(JNIEnv * env,jobject obj)2894 JNIEXPORT void JNICALL Java_Electric_upHierarchy(JNIEnv *env, jobject obj)
2895 {
2896 /* make the Electric call */
2897 uphierarchy();
2898 }
2899
Java_Electric_endTraverseHierarchy(JNIEnv * env,jobject obj)2900 JNIEXPORT void JNICALL Java_Electric_endTraverseHierarchy(JNIEnv *env, jobject obj)
2901 {
2902 /* make the Electric call */
2903 endtraversehierarchy();
2904 }
2905
Java_Electric_getTraversalPath(JNIEnv * env,jobject obj)2906 JNIEXPORT jobject JNICALL Java_Electric_getTraversalPath(JNIEnv *env, jobject obj)
2907 {
2908 NODEINST **nilist;
2909 INTBIG depth, i, *indexlist;
2910 jobjectArray retarray;
2911
2912 /* make the Electric call */
2913 gettraversalpath(el_curlib->curnodeproto, NOWINDOWPART, &nilist, &indexlist, &depth, 0);
2914
2915 /* convert C result to Java */
2916 retarray = java_environment->NewObjectArray((depth+1), java_classnodeinst, NULL);
2917 for(i=0; i<depth; i++)
2918 java_environment->SetObjectArrayElement(retarray, i,
2919 java_makeobject((INTBIG)nilist[i], VNODEINST));
2920 java_environment->SetObjectArrayElement(retarray, depth,
2921 java_makeobject((INTBIG)NONODEINST, VNODEINST));
2922 return(retarray);
2923 }
2924
2925 /****************************** SUPPORT ******************************/
2926
2927 /*
2928 * Helper routine to buffer characters that are sent to standard output.
2929 * Writes a line when carriage-return is typed.
2930 */
java_addcharacter(CHAR chr)2931 void java_addcharacter(CHAR chr)
2932 {
2933 if (chr != '\n')
2934 java_outputbuffer[java_outputposition++] = chr;
2935
2936 if (chr == '\n' || java_outputposition >= MAXLINE)
2937 {
2938 if (java_outputposition == 0)
2939 java_outputbuffer[java_outputposition++] = ' ';
2940 java_outputbuffer[java_outputposition] = 0;
2941 ttyputmsg(x_("%s"), java_outputbuffer);
2942 java_outputposition = 0;
2943 }
2944 }
2945
2946 /*
2947 * Routine that is called when a single character is written to the
2948 * standard output.
2949 */
Java_Electric_eoutWriteOne(JNIEnv * env,jobject obj,jint byte)2950 JNIEXPORT void JNICALL Java_Electric_eoutWriteOne(JNIEnv *env, jobject obj,
2951 jint byte)
2952 {
2953 java_addcharacter((CHAR)byte);
2954 }
2955
2956 /*
2957 * Routine that is called when a string is written to the
2958 * standard output.
2959 */
Java_Electric_eoutWriteString(JNIEnv * env,jobject obj,jstring jstr)2960 JNIEXPORT void JNICALL Java_Electric_eoutWriteString(JNIEnv *env, jobject obj,
2961 jstring jstr)
2962 {
2963 CHAR *str;
2964 INTBIG i, len;
2965 jboolean isCopy;
2966
2967 str = (CHAR *)java_environment->GetStringUTFChars(jstr, &isCopy);
2968 len = estrlen(str);
2969 for(i=0; i<len; i++) java_addcharacter(str[i]);
2970 if (isCopy == JNI_TRUE) java_environment->ReleaseStringUTFChars(jstr, str);
2971 }
2972
java_vfprintf(FILE * fp,const CHAR1 * format,va_list args)2973 jint JNICALL java_vfprintf(FILE *fp, const CHAR1 *format, va_list args)
2974 {
2975 us_ttyprint(FALSE, string2byte((CHAR1 *)format), args);
2976 return(1);
2977 }
2978
2979 /*
2980 * Coroutine that is called when Java exits.
2981 */
java_exit(jint code)2982 void JNICALL java_exit(jint code)
2983 {
2984 ttyputmsg(_("Exiting Java with code %d"), code);
2985 }
2986
2987 /*
2988 * Routine to ensure that the global "java_arraybuffer" has at least "size" bytes in
2989 * it. Returns true on error.
2990 */
java_allocarraybuffer(INTBIG size)2991 BOOLEAN java_allocarraybuffer(INTBIG size)
2992 {
2993 if (size <= java_arraybuffersize) return(FALSE);
2994 if (java_arraybuffersize > 0)
2995 efree((CHAR *)java_arraybuffer);
2996 java_arraybuffersize = 0;
2997 java_arraybuffer = (CHAR *)emalloc(size, db_cluster);
2998 if (java_arraybuffer == 0) return(TRUE);
2999 java_arraybuffersize = size;
3000 return(FALSE);
3001 }
3002
3003 /*
3004 * Routine to convert the Java object "obj" into an "address/type" pair
3005 * in "addr" and "type".
3006 */
java_getobjectaddrtype(jobject obj,INTBIG * addr,INTBIG * type,CHAR ** description)3007 void java_getobjectaddrtype(jobject obj, INTBIG *addr, INTBIG *type, CHAR **description)
3008 {
3009 CHAR *rstr;
3010 double dvalue;
3011 float fvalue;
3012 jboolean isCopy;
3013 INTBIG arrlen, i;
3014 jint *jarrdata;
3015 static CHAR mydescr[300];
3016 REGISTER void *infstr;
3017
3018 /* defaults */
3019 *addr = 0;
3020 *type = VUNKNOWN;
3021 if (description != 0) *description = mydescr;
3022
3023 /* Integer */
3024 if (java_environment->IsInstanceOf(obj, java_classint))
3025 {
3026 *addr = java_environment->CallIntMethod(obj, java_midIntValue);
3027 *type = VINTEGER;
3028 if (description != 0)
3029 esnprintf(mydescr, 300, x_("%ld"), *addr);
3030 return;
3031 }
3032
3033 /* Float */
3034 if (java_environment->IsInstanceOf(obj, java_classfloat))
3035 {
3036 fvalue = java_environment->CallFloatMethod(obj, java_midFloatValue);
3037 *addr = castint(fvalue);
3038 *type = VFLOAT;
3039 if (description != 0)
3040 esnprintf(mydescr, 300, x_("%g"), fvalue);
3041 return;
3042 }
3043
3044 /* Double */
3045 if (java_environment->IsInstanceOf(obj, java_classdouble))
3046 {
3047 dvalue = java_environment->CallDoubleMethod(obj, java_midDoubleValue);
3048 *addr = castint((float)dvalue);
3049 *type = VFLOAT;
3050 if (description != 0)
3051 esnprintf(mydescr, 300, x_("%g"), dvalue);
3052 return;
3053 }
3054
3055 /* String */
3056 if (java_environment->IsInstanceOf(obj, java_classstring))
3057 {
3058 rstr = (CHAR *)java_environment->GetStringUTFChars((jstring)obj, &isCopy);
3059 infstr = initinfstr();
3060 addstringtoinfstr(infstr, rstr);
3061 if (isCopy == JNI_TRUE)
3062 java_environment->ReleaseStringUTFChars((jstring)obj, rstr);
3063 *addr = (INTBIG)returninfstr(infstr);
3064 *type = VSTRING;
3065 if (description != 0)
3066 *description = (CHAR *)*addr;
3067 return;
3068 }
3069
3070 /* the Electric classes */
3071 if (java_environment->IsInstanceOf(obj, java_classnodeinst))
3072 {
3073 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3074 *type = VNODEINST;
3075 if (description != 0)
3076 esnprintf(mydescr, 300, x_("Nodeinst(%ld)"), *addr);
3077 return;
3078 }
3079 if (java_environment->IsInstanceOf(obj, java_classnodeproto))
3080 {
3081 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3082 *type = VNODEPROTO;
3083 if (description != 0)
3084 esnprintf(mydescr, 300, x_("Nodeproto(%ld)"), *addr);
3085 return;
3086 }
3087 if (java_environment->IsInstanceOf(obj, java_classportarcinst))
3088 {
3089 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3090 *type = VPORTARCINST;
3091 if (description != 0)
3092 esnprintf(mydescr, 300, x_("Portarcinst(%ld)"), *addr);
3093 return;
3094 }
3095 if (java_environment->IsInstanceOf(obj, java_classportexpinst))
3096 {
3097 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3098 *type = VPORTEXPINST;
3099 if (description != 0)
3100 esnprintf(mydescr, 300, x_("Portexpinst(%ld)"), *addr);
3101 return;
3102 }
3103 if (java_environment->IsInstanceOf(obj, java_classportproto))
3104 {
3105 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3106 *type = VPORTPROTO;
3107 if (description != 0)
3108 esnprintf(mydescr, 300, x_("Portproto(%ld)"), *addr);
3109 return;
3110 }
3111 if (java_environment->IsInstanceOf(obj, java_classarcinst))
3112 {
3113 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3114 *type = VARCINST;
3115 if (description != 0)
3116 esnprintf(mydescr, 300, x_("Arcinst(%ld)"), *addr);
3117 return;
3118 }
3119 if (java_environment->IsInstanceOf(obj, java_classarcproto))
3120 {
3121 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3122 *type = VARCPROTO;
3123 if (description != 0)
3124 esnprintf(mydescr, 300, x_("Arcproto(%ld)"), *addr);
3125 return;
3126 }
3127 if (java_environment->IsInstanceOf(obj, java_classgeom))
3128 {
3129 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3130 *type = VGEOM;
3131 if (description != 0)
3132 esnprintf(mydescr, 300, x_("Geom(%ld)"), *addr);
3133 return;
3134 }
3135 if (java_environment->IsInstanceOf(obj, java_classlibrary))
3136 {
3137 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3138 *type = VLIBRARY;
3139 if (description != 0)
3140 esnprintf(mydescr, 300, x_("Library(%ld)"), *addr);
3141 return;
3142 }
3143 if (java_environment->IsInstanceOf(obj, java_classtechnology))
3144 {
3145 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3146 *type = VTECHNOLOGY;
3147 if (description != 0)
3148 esnprintf(mydescr, 300, x_("Technology(%ld)"), *addr);
3149 return;
3150 }
3151 if (java_environment->IsInstanceOf(obj, java_classtool))
3152 {
3153 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3154 *type = VTOOL;
3155 if (description != 0)
3156 esnprintf(mydescr, 300, x_("Tool(%ld)"), *addr);
3157 return;
3158 }
3159 if (java_environment->IsInstanceOf(obj, java_classrtnode))
3160 {
3161 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3162 *type = VRTNODE;
3163 if (description != 0)
3164 esnprintf(mydescr, 300, x_("RTnode(%ld)"), *addr);
3165 return;
3166 }
3167 if (java_environment->IsInstanceOf(obj, java_classnetwork))
3168 {
3169 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3170 *type = VNETWORK;
3171 if (description != 0)
3172 esnprintf(mydescr, 300, x_("Network(%ld)"), *addr);
3173 return;
3174 }
3175 if (java_environment->IsInstanceOf(obj, java_classview))
3176 {
3177 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3178 *type = VVIEW;
3179 if (description != 0)
3180 esnprintf(mydescr, 300, x_("View(%ld)"), *addr);
3181 return;
3182 }
3183 if (java_environment->IsInstanceOf(obj, java_classwindowpart))
3184 {
3185 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3186 *type = VWINDOWPART;
3187 if (description != 0)
3188 esnprintf(mydescr, 300, x_("Windowpart(%ld)"), *addr);
3189 return;
3190 }
3191 if (java_environment->IsInstanceOf(obj, java_classwindowframe))
3192 {
3193 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3194 *type = VWINDOWFRAME;
3195 if (description != 0)
3196 esnprintf(mydescr, 300, x_("Windowframe(%ld)"), *addr);
3197 return;
3198 }
3199 if (java_environment->IsInstanceOf(obj, java_classgraphics))
3200 {
3201 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3202 *type = VGRAPHICS;
3203 if (description != 0)
3204 esnprintf(mydescr, 300, x_("Graphics(%ld)"), *addr);
3205 return;
3206 }
3207 if (java_environment->IsInstanceOf(obj, java_classconstraint))
3208 {
3209 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3210 *type = VCONSTRAINT;
3211 if (description != 0)
3212 esnprintf(mydescr, 300, x_("Constraint(%ld)"), *addr);
3213 return;
3214 }
3215 if (java_environment->IsInstanceOf(obj, java_classpolygon))
3216 {
3217 *addr = (INTBIG)java_environment->GetLongField(obj, java_addressID);
3218 *type = VPOLYGON;
3219 if (description != 0)
3220 esnprintf(mydescr, 300, x_("Polygon(%ld)"), *addr);
3221 return;
3222 }
3223
3224 /* int arrays */
3225 if (java_environment->IsInstanceOf(obj, java_classarrayint))
3226 {
3227 arrlen = java_environment->GetArrayLength((jintArray)obj);
3228 jarrdata = java_environment->GetIntArrayElements((jintArray)obj, &isCopy);
3229 if (java_allocarraybuffer(arrlen*SIZEOFINTBIG)) return;
3230 for(i=0; i<arrlen; i++)
3231 ((INTBIG *)java_arraybuffer)[i] = jarrdata[i];
3232 if (isCopy == JNI_TRUE)
3233 java_environment->ReleaseIntArrayElements((jintArray)obj, jarrdata, JNI_ABORT);
3234 *addr = (INTBIG)java_arraybuffer;
3235 *type = VINTEGER | VISARRAY | (arrlen << VLENGTHSH);
3236 if (description != 0)
3237 esnprintf(mydescr, 300, x_("Integer Array"));
3238 return;
3239 }
3240
3241 /* unknown object: get its name and print an error */
3242 jclass objectClass = java_environment->GetObjectClass(obj);
3243 jclass objClazz = java_environment->GetObjectClass(objectClass);
3244 jmethodID mid = java_environment->GetMethodID(objClazz, b_("toString"),b_("()Ljava/lang/String;"));
3245 jstring jMethodName = (jstring)java_environment->CallObjectMethod(objectClass, mid, NULL);
3246 CHAR *thisMethodName = (CHAR *)java_environment->GetStringUTFChars(jMethodName, &isCopy);
3247 if (description != 0)
3248 estrcpy(mydescr, thisMethodName);
3249 if (isCopy == JNI_TRUE)
3250 java_environment->ReleaseStringUTFChars((jstring)jMethodName, thisMethodName);
3251 }
3252
3253 /*
3254 * Routine to create a Java object that describes object "addr" of type
3255 * "type".
3256 */
java_makeobject(INTBIG addr,INTBIG type)3257 jobject java_makeobject(INTBIG addr, INTBIG type)
3258 {
3259 jobject object;
3260 INTBIG stype, saddr;
3261
3262 /* create an object of type "object" */
3263 switch (type&VTYPE)
3264 {
3265 case VINTEGER:
3266 case VSHORT:
3267 case VBOOLEAN:
3268 object = java_makejavaobject(addr, type, java_classint, VINTEGER);
3269 break;
3270 case VFLOAT:
3271 object = java_makejavaobject(addr, type, java_classfloat, VFLOAT);
3272 break;
3273 case VFRACT:
3274 object = java_makejavaobject(addr, type, java_classfloat, VFRACT);
3275 break;
3276 case VSTRING:
3277 getsimpletype((CHAR *)addr, &stype, &saddr, 0);
3278 if (stype == VSTRING)
3279 {
3280 object = java_environment->NewStringUTF((CHAR *)addr);
3281 } else if (stype == VFLOAT)
3282 {
3283 type = (type & ~VTYPE) | VFLOAT;
3284 object = java_makejavaobject(addr, type, java_classfloat, VFLOAT);
3285 } else
3286 {
3287 type = (type & ~VTYPE) | (stype & VTYPE);
3288 object = java_makejavaobject(saddr, type, java_classint, VINTEGER);
3289 }
3290 break;
3291 case VNODEINST:
3292 object = java_makejavaobject(addr, type, java_classnodeinst, VNODEINST);
3293 break;
3294 case VNODEPROTO:
3295 object = java_makejavaobject(addr, type, java_classnodeproto, VNODEPROTO);
3296 break;
3297 case VPORTARCINST:
3298 object = java_makejavaobject(addr, type, java_classportarcinst, VPORTARCINST);
3299 break;
3300 case VPORTEXPINST:
3301 object = java_makejavaobject(addr, type, java_classportexpinst, VPORTEXPINST);
3302 break;
3303 case VPORTPROTO:
3304 object = java_makejavaobject(addr, type, java_classportproto, VPORTPROTO);
3305 break;
3306 case VARCINST:
3307 object = java_makejavaobject(addr, type, java_classarcinst, VARCINST);
3308 break;
3309 case VARCPROTO:
3310 object = java_makejavaobject(addr, type, java_classarcproto, VARCPROTO);
3311 break;
3312 case VGEOM:
3313 object = java_makejavaobject(addr, type, java_classgeom, VGEOM);
3314 break;
3315 case VLIBRARY:
3316 object = java_makejavaobject(addr, type, java_classlibrary, VLIBRARY);
3317 break;
3318 case VTECHNOLOGY:
3319 object = java_makejavaobject(addr, type, java_classtechnology, VTECHNOLOGY);
3320 break;
3321 case VTOOL:
3322 object = java_makejavaobject(addr, type, java_classtool, VTOOL);
3323 break;
3324 case VRTNODE:
3325 object = java_makejavaobject(addr, type, java_classrtnode, VRTNODE);
3326 break;
3327 case VNETWORK:
3328 object = java_makejavaobject(addr, type, java_classnetwork, VNETWORK);
3329 break;
3330 case VVIEW:
3331 object = java_makejavaobject(addr, type, java_classview, VVIEW);
3332 break;
3333 case VWINDOWPART:
3334 object = java_makejavaobject(addr, type, java_classwindowpart, VWINDOWPART);
3335 break;
3336 case VWINDOWFRAME:
3337 object = java_makejavaobject(addr, type, java_classwindowframe, VWINDOWFRAME);
3338 break;
3339 case VGRAPHICS:
3340 object = java_makejavaobject(addr, type, java_classgraphics, VGRAPHICS);
3341 break;
3342 case VCONSTRAINT:
3343 object = java_makejavaobject(addr, type, java_classconstraint, VCONSTRAINT);
3344 break;
3345 case VPOLYGON:
3346 object = java_makejavaobject(addr, type, java_classpolygon, VPOLYGON);
3347 break;
3348 default:
3349 object = java_nullobject;
3350 break;
3351 }
3352 return(object);
3353 }
3354
java_makejavaobject(INTBIG addr,INTBIG type,jclass javaclass,INTBIG desttype)3355 jobject java_makejavaobject(INTBIG addr, INTBIG type, jclass javaclass, INTBIG desttype)
3356 {
3357 VARIABLE myvar;
3358 REGISTER INTBIG i, len;
3359 jobjectArray objArray;
3360 jobject object, subobject;
3361
3362 if ((type&VISARRAY) != 0)
3363 {
3364 myvar.addr = addr; myvar.type = type;
3365 len = getlength(&myvar);
3366 objArray = java_environment->NewObjectArray(len, javaclass, NULL);
3367 for(i=0; i<len; i++)
3368 {
3369 subobject = java_makeobject(((INTBIG *)addr)[i], desttype);
3370 java_environment->SetObjectArrayElement(objArray, i, subobject);
3371 }
3372 object = (jobject)objArray;
3373 } else
3374 {
3375 object = java_environment->AllocObject(javaclass);
3376 if ((type&VTYPE) == VFLOAT)
3377 {
3378 java_environment->CallVoidMethod(object, java_midFloatInit, (jfloat)castfloat(addr));
3379 } else if ((type&VTYPE) == VFRACT)
3380 {
3381 java_environment->CallVoidMethod(object, java_midFloatInit, addr/(jfloat)WHOLE);
3382 } else if ((type&VTYPE) == VINTEGER || (type&VTYPE) == VSHORT || (type&VTYPE) == VBOOLEAN)
3383 {
3384 java_environment->CallVoidMethod(object, java_midIntInit, (jint)addr);
3385 } else
3386 {
3387 java_environment->SetLongField(object, java_addressID, (jlong)addr);
3388 }
3389 }
3390 return(object);
3391 }
3392
3393 /* added by MW, 5/20/02 */
java_finddbmirror(void)3394 CHAR *java_finddbmirror(void)
3395 {
3396 return x_("dbmirror.jar");
3397 }
3398
java_findbeanshell(void)3399 CHAR *java_findbeanshell(void)
3400 {
3401 INTBIG count, i;
3402 INTBIG len;
3403 CHAR **filelist, *pt;
3404 REGISTER void *infstr;
3405
3406 infstr = initinfstr();
3407 addstringtoinfstr(infstr, el_libdir);
3408 addstringtoinfstr(infstr, x_("java"));
3409 addtoinfstr(infstr, DIRSEP);
3410 count = filesindirectory(returninfstr(infstr), &filelist);
3411 for(i=0; i<count; i++)
3412 {
3413 pt = filelist[i];
3414 if (estrncmp(pt, x_("bsh-"), 4) != 0) continue;
3415 len = estrlen(pt);
3416 if (estrcmp(&pt[len-4], x_(".jar")) != 0) continue;
3417 return(pt);
3418 }
3419 return(0);
3420 }
3421
3422 #endif
3423