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