source: trunk/abcl/doc/manual/java.tex @ 14931

Last change on this file since 14931 was 14931, checked in by Mark Evenson, 5 years ago

Bless EXT:GET-PID as the offical way to get procees id

Regenerate TeX artifacts. My they were a bit dusty…

N.b. under pure Threaded OS platforms such as Microsoft Windows, there
is no valid process id.

File size: 25.8 KB
Line 
1\paragraph{}
2\label{JAVA:*JAVA-OBJECT-TO-STRING-LENGTH*}
3\index{*JAVA-OBJECT-TO-STRING-LENGTH*}
4--- Variable: \textbf{*java-object-to-string-length*} [\textbf{java}] \textit{}
5
6\begin{adjustwidth}{5em}{5em}
7Length to truncate toString() PRINT-OBJECT output for an otherwise unspecialized JAVA-OBJECT.  Can be set to NIL to indicate no limit.
8\end{adjustwidth}
9
10\paragraph{}
11\label{JAVA:+FALSE+}
12\index{+FALSE+}
13--- Variable: \textbf{+false+} [\textbf{java}] \textit{}
14
15\begin{adjustwidth}{5em}{5em}
16The JVM primitive value for boolean false.
17\end{adjustwidth}
18
19\paragraph{}
20\label{JAVA:+NULL+}
21\index{+NULL+}
22--- Variable: \textbf{+null+} [\textbf{java}] \textit{}
23
24\begin{adjustwidth}{5em}{5em}
25The JVM null object reference.
26\end{adjustwidth}
27
28\paragraph{}
29\label{JAVA:+TRUE+}
30\index{+TRUE+}
31--- Variable: \textbf{+true+} [\textbf{java}] \textit{}
32
33\begin{adjustwidth}{5em}{5em}
34The JVM primitive value for boolean true.
35\end{adjustwidth}
36
37\paragraph{}
38\label{JAVA:ADD-TO-CLASSPATH}
39\index{ADD-TO-CLASSPATH}
40--- Generic Function: \textbf{add-to-classpath} [\textbf{java}] \textit{}
41
42\begin{adjustwidth}{5em}{5em}
43Add JAR-OR-JARS to the JVM classpath optionally specifying the CLASSLOADER to add.
44
45JAR-OR-JARS is either a pathname designating a jar archive or the root
46directory to search for classes or a list of such values.
47\end{adjustwidth}
48
49\paragraph{}
50\label{JAVA:CHAIN}
51\index{CHAIN}
52--- Macro: \textbf{chain} [\textbf{java}] \textit{}
53
54\begin{adjustwidth}{5em}{5em}
55Performs chained method invocations. `target' is the receiver
56object (when the first call is a virtual method call) or a list in the
57form (:static <jclass>) when the first method call is a static method
58call. `op' and each of the `ops' are either method designators or lists
59in the form (<method designator> \&rest args), where a method designator
60is either a string naming a method, or a jmethod object. `chain' will
61perform the method call specified by `op' on `target'; then, for each
62of the `ops', `chain' will perform the specified method call using the
63object returned by the previous method call as the receiver, and will
64ultimately return the result of the last method call.
65  For example, the form:
66
67  (chain (:static "java.lang.Runtime") "getRuntime" ("exec" "ls"))
68
69  is equivalent to the following Java code:
70
71  java.lang.Runtime.getRuntime().exec("ls");
72\end{adjustwidth}
73
74\paragraph{}
75\label{JAVA:DEFINE-JAVA-CLASS}
76\index{DEFINE-JAVA-CLASS}
77--- Macro: \textbf{define-java-class} [\textbf{java}] \textit{}
78
79\begin{adjustwidth}{5em}{5em}
80not-documented
81\end{adjustwidth}
82
83\paragraph{}
84\label{JAVA:DESCRIBE-JAVA-OBJECT}
85\index{DESCRIBE-JAVA-OBJECT}
86--- Function: \textbf{describe-java-object} [\textbf{java}] \textit{}
87
88\begin{adjustwidth}{5em}{5em}
89not-documented
90\end{adjustwidth}
91
92\paragraph{}
93\label{JAVA:DUMP-CLASSPATH}
94\index{DUMP-CLASSPATH}
95--- Function: \textbf{dump-classpath} [\textbf{java}] \textit{\&optional classloader}
96
97\begin{adjustwidth}{5em}{5em}
98not-documented
99\end{adjustwidth}
100
101\paragraph{}
102\label{JAVA:ENSURE-JAVA-CLASS}
103\index{ENSURE-JAVA-CLASS}
104--- Function: \textbf{ensure-java-class} [\textbf{java}] \textit{jclass}
105
106\begin{adjustwidth}{5em}{5em}
107Attempt to ensure that the Java class referenced by JCLASS exists in the current process of the implementation.
108\end{adjustwidth}
109
110\paragraph{}
111\label{JAVA:ENSURE-JAVA-OBJECT}
112\index{ENSURE-JAVA-OBJECT}
113--- Function: \textbf{ensure-java-object} [\textbf{java}] \textit{obj}
114
115\begin{adjustwidth}{5em}{5em}
116Ensures OBJ is wrapped in a JAVA-OBJECT, wrapping it if necessary.
117\end{adjustwidth}
118
119\paragraph{}
120\label{JAVA:GET-CURRENT-CLASSLOADER}
121\index{GET-CURRENT-CLASSLOADER}
122--- Function: \textbf{get-current-classloader} [\textbf{java}] \textit{}
123
124\begin{adjustwidth}{5em}{5em}
125not-documented
126\end{adjustwidth}
127
128\paragraph{}
129\label{JAVA:GET-DEFAULT-CLASSLOADER}
130\index{GET-DEFAULT-CLASSLOADER}
131--- Function: \textbf{get-default-classloader} [\textbf{java}] \textit{}
132
133\begin{adjustwidth}{5em}{5em}
134not-documented
135\end{adjustwidth}
136
137\paragraph{}
138\label{JAVA:JARRAY-COMPONENT-TYPE}
139\index{JARRAY-COMPONENT-TYPE}
140--- Function: \textbf{jarray-component-type} [\textbf{java}] \textit{atype}
141
142\begin{adjustwidth}{5em}{5em}
143Returns the component type of the array type ATYPE
144\end{adjustwidth}
145
146\paragraph{}
147\label{JAVA:JARRAY-FROM-LIST}
148\index{JARRAY-FROM-LIST}
149--- Function: \textbf{jarray-from-list} [\textbf{java}] \textit{list}
150
151\begin{adjustwidth}{5em}{5em}
152Return a Java array from LIST whose type is inferred from the first element.
153
154For more control over the type of the array, use JNEW-ARRAY-FROM-LIST.
155\end{adjustwidth}
156
157\paragraph{}
158\label{JAVA:JARRAY-LENGTH}
159\index{JARRAY-LENGTH}
160--- Function: \textbf{jarray-length} [\textbf{java}] \textit{java-array}
161
162\begin{adjustwidth}{5em}{5em}
163Returns the length of a Java primitive array.
164\end{adjustwidth}
165
166\paragraph{}
167\label{JAVA:JARRAY-REF}
168\index{JARRAY-REF}
169--- Function: \textbf{jarray-ref} [\textbf{java}] \textit{java-array \&rest indices}
170
171\begin{adjustwidth}{5em}{5em}
172Dereferences the Java array JAVA-ARRAY using the given INDICIES, coercing the result into a Lisp object, if possible.
173\end{adjustwidth}
174
175\paragraph{}
176\label{JAVA:JARRAY-REF-RAW}
177\index{JARRAY-REF-RAW}
178--- Function: \textbf{jarray-ref-raw} [\textbf{java}] \textit{java-array \&rest indices}
179
180\begin{adjustwidth}{5em}{5em}
181Dereference the Java array JAVA-ARRAY using the given INDICIES. Does not attempt to coerce the result into a Lisp object.
182\end{adjustwidth}
183
184\paragraph{}
185\label{JAVA:JARRAY-SET}
186\index{JARRAY-SET}
187--- Function: \textbf{jarray-set} [\textbf{java}] \textit{java-array new-value \&rest indices}
188
189\begin{adjustwidth}{5em}{5em}
190Stores NEW-VALUE at the given index in JAVA-ARRAY.
191\end{adjustwidth}
192
193\paragraph{}
194\label{JAVA:JAVA-CLASS}
195\index{JAVA-CLASS}
196--- Class: \textbf{java-class} [\textbf{java}] \textit{}
197
198\begin{adjustwidth}{5em}{5em}
199not-documented
200\end{adjustwidth}
201
202\paragraph{}
203\label{JAVA:JAVA-EXCEPTION}
204\index{JAVA-EXCEPTION}
205--- Class: \textbf{java-exception} [\textbf{java}] \textit{}
206
207\begin{adjustwidth}{5em}{5em}
208not-documented
209\end{adjustwidth}
210
211\paragraph{}
212\label{JAVA:JAVA-EXCEPTION-CAUSE}
213\index{JAVA-EXCEPTION-CAUSE}
214--- Function: \textbf{java-exception-cause} [\textbf{java}] \textit{java-exception}
215
216\begin{adjustwidth}{5em}{5em}
217Returns the cause of JAVA-EXCEPTION. (The cause is the Java Throwable
218  object that caused JAVA-EXCEPTION to be signalled.)
219\end{adjustwidth}
220
221\paragraph{}
222\label{JAVA:JAVA-OBJECT}
223\index{JAVA-OBJECT}
224--- Class: \textbf{java-object} [\textbf{java}] \textit{}
225
226\begin{adjustwidth}{5em}{5em}
227not-documented
228\end{adjustwidth}
229
230\paragraph{}
231\label{JAVA:JAVA-OBJECT-P}
232\index{JAVA-OBJECT-P}
233--- Function: \textbf{java-object-p} [\textbf{java}] \textit{object}
234
235\begin{adjustwidth}{5em}{5em}
236Returns T if OBJECT is a JAVA-OBJECT.
237\end{adjustwidth}
238
239\paragraph{}
240\label{JAVA:JCALL}
241\index{JCALL}
242--- Function: \textbf{jcall} [\textbf{java}] \textit{method-ref instance \&rest args}
243
244\begin{adjustwidth}{5em}{5em}
245Invokes the Java method METHOD-REF on INSTANCE with arguments ARGS, coercing the result into a Lisp object, if possible.
246\end{adjustwidth}
247
248\paragraph{}
249\label{JAVA:JCALL-RAW}
250\index{JCALL-RAW}
251--- Function: \textbf{jcall-raw} [\textbf{java}] \textit{method-ref instance \&rest args}
252
253\begin{adjustwidth}{5em}{5em}
254Invokes the Java method METHOD-REF on INSTANCE with arguments ARGS. Does not attempt to coerce the result into a Lisp object.
255\end{adjustwidth}
256
257\paragraph{}
258\label{JAVA:JCLASS}
259\index{JCLASS}
260--- Function: \textbf{jclass} [\textbf{java}] \textit{name-or-class-ref \&optional class-loader}
261
262\begin{adjustwidth}{5em}{5em}
263Returns a reference to the Java class designated by NAME-OR-CLASS-REF. If the CLASS-LOADER parameter is passed, the class is resolved with respect to the given ClassLoader.
264\end{adjustwidth}
265
266\paragraph{}
267\label{JAVA:JCLASS-ARRAY-P}
268\index{JCLASS-ARRAY-P}
269--- Function: \textbf{jclass-array-p} [\textbf{java}] \textit{class}
270
271\begin{adjustwidth}{5em}{5em}
272Returns T if CLASS is an array class
273\end{adjustwidth}
274
275\paragraph{}
276\label{JAVA:JCLASS-CONSTRUCTORS}
277\index{JCLASS-CONSTRUCTORS}
278--- Function: \textbf{jclass-constructors} [\textbf{java}] \textit{class}
279
280\begin{adjustwidth}{5em}{5em}
281Returns a vector of constructors for CLASS
282\end{adjustwidth}
283
284\paragraph{}
285\label{JAVA:JCLASS-FIELD}
286\index{JCLASS-FIELD}
287--- Function: \textbf{jclass-field} [\textbf{java}] \textit{class field-name}
288
289\begin{adjustwidth}{5em}{5em}
290Returns the field named FIELD-NAME of CLASS
291\end{adjustwidth}
292
293\paragraph{}
294\label{JAVA:JCLASS-FIELDS}
295\index{JCLASS-FIELDS}
296--- Function: \textbf{jclass-fields} [\textbf{java}] \textit{class \&key declared public}
297
298\begin{adjustwidth}{5em}{5em}
299Returns a vector of all (or just the declared/public, if DECLARED/PUBLIC is true) fields of CLASS
300\end{adjustwidth}
301
302\paragraph{}
303\label{JAVA:JCLASS-INTERFACE-P}
304\index{JCLASS-INTERFACE-P}
305--- Function: \textbf{jclass-interface-p} [\textbf{java}] \textit{class}
306
307\begin{adjustwidth}{5em}{5em}
308Returns T if CLASS is an interface
309\end{adjustwidth}
310
311\paragraph{}
312\label{JAVA:JCLASS-INTERFACES}
313\index{JCLASS-INTERFACES}
314--- Function: \textbf{jclass-interfaces} [\textbf{java}] \textit{class}
315
316\begin{adjustwidth}{5em}{5em}
317Returns the vector of interfaces of CLASS
318\end{adjustwidth}
319
320\paragraph{}
321\label{JAVA:JCLASS-METHODS}
322\index{JCLASS-METHODS}
323--- Function: \textbf{jclass-methods} [\textbf{java}] \textit{class \&key declared public}
324
325\begin{adjustwidth}{5em}{5em}
326Return a vector of all (or just the declared/public, if DECLARED/PUBLIC is true) methods of CLASS
327\end{adjustwidth}
328
329\paragraph{}
330\label{JAVA:JCLASS-NAME}
331\index{JCLASS-NAME}
332--- Function: \textbf{jclass-name} [\textbf{java}] \textit{class-ref \&optional name}
333
334\begin{adjustwidth}{5em}{5em}
335When called with one argument, returns the name of the Java class
336  designated by CLASS-REF. When called with two arguments, tests
337  whether CLASS-REF matches NAME.
338\end{adjustwidth}
339
340\paragraph{}
341\label{JAVA:JCLASS-OF}
342\index{JCLASS-OF}
343--- Function: \textbf{jclass-of} [\textbf{java}] \textit{object \&optional name}
344
345\begin{adjustwidth}{5em}{5em}
346not-documented
347\end{adjustwidth}
348
349\paragraph{}
350\label{JAVA:JCLASS-SUPERCLASS}
351\index{JCLASS-SUPERCLASS}
352--- Function: \textbf{jclass-superclass} [\textbf{java}] \textit{class}
353
354\begin{adjustwidth}{5em}{5em}
355Returns the superclass of CLASS, or NIL if it hasn't got one
356\end{adjustwidth}
357
358\paragraph{}
359\label{JAVA:JCLASS-SUPERCLASS-P}
360\index{JCLASS-SUPERCLASS-P}
361--- Function: \textbf{jclass-superclass-p} [\textbf{java}] \textit{class-1 class-2}
362
363\begin{adjustwidth}{5em}{5em}
364Returns T if CLASS-1 is a superclass or interface of CLASS-2
365\end{adjustwidth}
366
367\paragraph{}
368\label{JAVA:JCOERCE}
369\index{JCOERCE}
370--- Function: \textbf{jcoerce} [\textbf{java}] \textit{object intended-class}
371
372\begin{adjustwidth}{5em}{5em}
373Attempts to coerce OBJECT into a JavaObject of class INTENDED-CLASS.  Raises a TYPE-ERROR if no conversion is possible.
374\end{adjustwidth}
375
376\paragraph{}
377\label{JAVA:JCONSTRUCTOR}
378\index{JCONSTRUCTOR}
379--- Function: \textbf{jconstructor} [\textbf{java}] \textit{class-ref \&rest parameter-class-refs}
380
381\begin{adjustwidth}{5em}{5em}
382Returns a reference to the Java constructor of CLASS-REF with the given PARAMETER-CLASS-REFS.
383\end{adjustwidth}
384
385\paragraph{}
386\label{JAVA:JCONSTRUCTOR-PARAMS}
387\index{JCONSTRUCTOR-PARAMS}
388--- Function: \textbf{jconstructor-params} [\textbf{java}] \textit{constructor}
389
390\begin{adjustwidth}{5em}{5em}
391Returns a vector of parameter types (Java classes) for CONSTRUCTOR
392\end{adjustwidth}
393
394\paragraph{}
395\label{JAVA:JEQUAL}
396\index{JEQUAL}
397--- Function: \textbf{jequal} [\textbf{java}] \textit{obj1 obj2}
398
399\begin{adjustwidth}{5em}{5em}
400Compares obj1 with obj2 using java.lang.Object.equals()
401\end{adjustwidth}
402
403\paragraph{}
404\label{JAVA:JFIELD}
405\index{JFIELD}
406--- Function: \textbf{jfield} [\textbf{java}] \textit{class-ref-or-field field-or-instance \&optional instance value}
407
408\begin{adjustwidth}{5em}{5em}
409Retrieves or modifies a field in a Java class or instance.
410
411Supported argument patterns:
412
413   Case 1: class-ref  field-name:
414      Retrieves the value of a static field.
415
416   Case 2: class-ref  field-name  instance-ref:
417      Retrieves the value of a class field of the instance.
418
419   Case 3: class-ref  field-name  primitive-value:
420      Stores a primitive-value in a static field.
421
422   Case 4: class-ref  field-name  instance-ref  value:
423      Stores value in a class field of the instance.
424
425   Case 5: class-ref  field-name  nil  value:
426      Stores value in a static field (when value may be
427      confused with an instance-ref).
428
429   Case 6: field-name  instance:
430      Retrieves the value of a field of the instance. The
431      class is derived from the instance.
432
433   Case 7: field-name  instance  value:
434      Stores value in a field of the instance. The class is
435      derived from the instance.
436
437
438\end{adjustwidth}
439
440\paragraph{}
441\label{JAVA:JFIELD-NAME}
442\index{JFIELD-NAME}
443--- Function: \textbf{jfield-name} [\textbf{java}] \textit{field}
444
445\begin{adjustwidth}{5em}{5em}
446Returns the name of FIELD as a Lisp string
447\end{adjustwidth}
448
449\paragraph{}
450\label{JAVA:JFIELD-RAW}
451\index{JFIELD-RAW}
452--- Function: \textbf{jfield-raw} [\textbf{java}] \textit{class-ref-or-field field-or-instance \&optional instance value}
453
454\begin{adjustwidth}{5em}{5em}
455Retrieves or modifies a field in a Java class or instance. Does not
456attempt to coerce its value or the result into a Lisp object.
457
458Supported argument patterns:
459
460   Case 1: class-ref  field-name:
461      Retrieves the value of a static field.
462
463   Case 2: class-ref  field-name  instance-ref:
464      Retrieves the value of a class field of the instance.
465
466   Case 3: class-ref  field-name  primitive-value:
467      Stores a primitive-value in a static field.
468
469   Case 4: class-ref  field-name  instance-ref  value:
470      Stores value in a class field of the instance.
471
472   Case 5: class-ref  field-name  nil  value:
473      Stores value in a static field (when value may be
474      confused with an instance-ref).
475
476   Case 6: field-name  instance:
477      Retrieves the value of a field of the instance. The
478      class is derived from the instance.
479
480   Case 7: field-name  instance  value:
481      Stores value in a field of the instance. The class is
482      derived from the instance.
483
484
485\end{adjustwidth}
486
487\paragraph{}
488\label{JAVA:JFIELD-TYPE}
489\index{JFIELD-TYPE}
490--- Function: \textbf{jfield-type} [\textbf{java}] \textit{field}
491
492\begin{adjustwidth}{5em}{5em}
493Returns the type (Java class) of FIELD
494\end{adjustwidth}
495
496\paragraph{}
497\label{JAVA:JINPUT-STREAM}
498\index{JINPUT-STREAM}
499--- Function: \textbf{jinput-stream} [\textbf{java}] \textit{pathname}
500
501\begin{adjustwidth}{5em}{5em}
502Returns a java.io.InputStream for resource denoted by PATHNAME.
503\end{adjustwidth}
504
505\paragraph{}
506\label{JAVA:JINSTANCE-OF-P}
507\index{JINSTANCE-OF-P}
508--- Function: \textbf{jinstance-of-p} [\textbf{java}] \textit{obj class}
509
510\begin{adjustwidth}{5em}{5em}
511OBJ is an instance of CLASS (or one of its subclasses)
512\end{adjustwidth}
513
514\paragraph{}
515\label{JAVA:JINTERFACE-IMPLEMENTATION}
516\index{JINTERFACE-IMPLEMENTATION}
517--- Function: \textbf{jinterface-implementation} [\textbf{java}] \textit{interface \&rest method-names-and-defs}
518
519\begin{adjustwidth}{5em}{5em}
520Creates and returns an implementation of a Java interface with
521   methods calling Lisp closures as given in METHOD-NAMES-AND-DEFS.
522
523   INTERFACE is either a Java interface or a string naming one.
524
525   METHOD-NAMES-AND-DEFS is an alternating list of method names
526   (strings) and method definitions (closures).
527
528   For missing methods, a dummy implementation is provided that
529   returns nothing or null depending on whether the return type is
530   void or not. This is for convenience only, and a warning is issued
531   for each undefined method.
532\end{adjustwidth}
533
534\paragraph{}
535\label{JAVA:JMAKE-INVOCATION-HANDLER}
536\index{JMAKE-INVOCATION-HANDLER}
537--- Function: \textbf{jmake-invocation-handler} [\textbf{java}] \textit{function}
538
539\begin{adjustwidth}{5em}{5em}
540not-documented
541\end{adjustwidth}
542
543\paragraph{}
544\label{JAVA:JMAKE-PROXY}
545\index{JMAKE-PROXY}
546--- Generic Function: \textbf{jmake-proxy} [\textbf{java}] \textit{}
547
548\begin{adjustwidth}{5em}{5em}
549Returns a proxy Java object implementing the provided interface(s) using methods implemented in Lisp - typically closures, but implementations are free to provide other mechanisms. You can pass an optional 'lisp-this' object that will be passed to the implementing methods as their first argument. If you don't provide this object, NIL will be used. The second argument of the Lisp methods is the name of the Java method being implemented. This has the implication that overloaded methods are merged, so you have to manually discriminate them if you want to. The remaining arguments are java-objects wrapping the method's parameters.
550\end{adjustwidth}
551
552\paragraph{}
553\label{JAVA:JMEMBER-PROTECTED-P}
554\index{JMEMBER-PROTECTED-P}
555--- Function: \textbf{jmember-protected-p} [\textbf{java}] \textit{member}
556
557\begin{adjustwidth}{5em}{5em}
558MEMBER is a protected member of its declaring class
559\end{adjustwidth}
560
561\paragraph{}
562\label{JAVA:JMEMBER-PUBLIC-P}
563\index{JMEMBER-PUBLIC-P}
564--- Function: \textbf{jmember-public-p} [\textbf{java}] \textit{member}
565
566\begin{adjustwidth}{5em}{5em}
567MEMBER is a public member of its declaring class
568\end{adjustwidth}
569
570\paragraph{}
571\label{JAVA:JMEMBER-STATIC-P}
572\index{JMEMBER-STATIC-P}
573--- Function: \textbf{jmember-static-p} [\textbf{java}] \textit{member}
574
575\begin{adjustwidth}{5em}{5em}
576MEMBER is a static member of its declaring class
577\end{adjustwidth}
578
579\paragraph{}
580\label{JAVA:JMETHOD}
581\index{JMETHOD}
582--- Function: \textbf{jmethod} [\textbf{java}] \textit{class-ref method-name \&rest parameter-class-refs}
583
584\begin{adjustwidth}{5em}{5em}
585Returns a reference to the Java method METHOD-NAME of CLASS-REF with the given PARAMETER-CLASS-REFS.
586\end{adjustwidth}
587
588\paragraph{}
589\label{JAVA:JMETHOD-LET}
590\index{JMETHOD-LET}
591--- Macro: \textbf{jmethod-let} [\textbf{java}] \textit{}
592
593\begin{adjustwidth}{5em}{5em}
594not-documented
595\end{adjustwidth}
596
597\paragraph{}
598\label{JAVA:JMETHOD-NAME}
599\index{JMETHOD-NAME}
600--- Function: \textbf{jmethod-name} [\textbf{java}] \textit{method}
601
602\begin{adjustwidth}{5em}{5em}
603Returns the name of METHOD as a Lisp string
604\end{adjustwidth}
605
606\paragraph{}
607\label{JAVA:JMETHOD-PARAMS}
608\index{JMETHOD-PARAMS}
609--- Function: \textbf{jmethod-params} [\textbf{java}] \textit{method}
610
611\begin{adjustwidth}{5em}{5em}
612Returns a vector of parameter types (Java classes) for METHOD
613\end{adjustwidth}
614
615\paragraph{}
616\label{JAVA:JMETHOD-RETURN-TYPE}
617\index{JMETHOD-RETURN-TYPE}
618--- Function: \textbf{jmethod-return-type} [\textbf{java}] \textit{method}
619
620\begin{adjustwidth}{5em}{5em}
621Returns the result type (Java class) of the METHOD
622\end{adjustwidth}
623
624\paragraph{}
625\label{JAVA:JNEW}
626\index{JNEW}
627--- Function: \textbf{jnew} [\textbf{java}] \textit{constructor \&rest args}
628
629\begin{adjustwidth}{5em}{5em}
630Invokes the Java constructor CONSTRUCTOR with the arguments ARGS.
631\end{adjustwidth}
632
633\paragraph{}
634\label{JAVA:JNEW-ARRAY}
635\index{JNEW-ARRAY}
636--- Function: \textbf{jnew-array} [\textbf{java}] \textit{element-type \&rest dimensions}
637
638\begin{adjustwidth}{5em}{5em}
639Creates a new Java array of type ELEMENT-TYPE, with the given DIMENSIONS.
640\end{adjustwidth}
641
642\paragraph{}
643\label{JAVA:JNEW-ARRAY-FROM-ARRAY}
644\index{JNEW-ARRAY-FROM-ARRAY}
645--- Function: \textbf{jnew-array-from-array} [\textbf{java}] \textit{element-type array}
646
647\begin{adjustwidth}{5em}{5em}
648Returns a new Java array with base type ELEMENT-TYPE (a string or a class-ref)
649   initialized from ARRAY.
650\end{adjustwidth}
651
652\paragraph{}
653\label{JAVA:JNEW-ARRAY-FROM-LIST}
654\index{JNEW-ARRAY-FROM-LIST}
655--- Function: \textbf{jnew-array-from-list} [\textbf{java}] \textit{element-type list}
656
657\begin{adjustwidth}{5em}{5em}
658Returns a new Java array with base type ELEMENT-TYPE (a string or a class-ref)
659   initialized from a Lisp list.
660\end{adjustwidth}
661
662\paragraph{}
663\label{JAVA:JNEW-RUNTIME-CLASS}
664\index{JNEW-RUNTIME-CLASS}
665--- Function: \textbf{jnew-runtime-class} [\textbf{java}] \textit{class-name \&rest args \&key (superclass java.lang.Object) interfaces constructors methods fields (access-flags (quote (public))) annotations (class-loader (make-memory-class-loader))}
666
667\begin{adjustwidth}{5em}{5em}
668Creates and loads a Java class with methods calling Lisp closures
669   as given in METHODS.  CLASS-NAME and SUPER-NAME are strings,
670   INTERFACES is a list of strings, CONSTRUCTORS, METHODS and FIELDS are
671   lists of constructor, method and field definitions.
672
673   Constructor definitions - currently NOT supported - are lists of the form
674   (argument-types function \&optional super-invocation-arguments)
675   where argument-types is a list of strings and function is a lisp function of
676   (1+ (length argument-types)) arguments; the instance (`this') is passed in as
677   the last argument. The optional super-invocation-arguments is a list of numbers
678   between 1 and (length argument-types), where the number k stands for the kth argument
679   to the just defined constructor. If present, the constructor of the superclass
680   will be called with the appropriate arguments. E.g., if the constructor definition is
681   (("java.lang.String" "int") \#'(lambda (string i this) ...) (2 1))
682   then the constructor of the superclass with argument types (int, java.lang.String) will
683   be called with the second and first arguments.
684
685   Method definitions are lists of the form
686
687     (METHOD-NAME RETURN-TYPE ARGUMENT-TYPES FUNCTION \&key MODIFIERS ANNOTATIONS)
688
689   where
690      METHOD-NAME is a string
691      RETURN-TYPE denotes the type of the object returned by the method
692      ARGUMENT-TYPES is a list of parameters to the method
693
694        The types are either strings naming fully qualified java classes or Lisp keywords referring to
695        primitive types (:void, :int, etc.).
696
697     FUNCTION is a Lisp function of minimum arity (1+ (length
698     argument-types)). The instance (`this') is passed as the first
699     argument.
700
701   Field definitions are lists of the form (field-name type \&key modifiers annotations).
702\end{adjustwidth}
703
704\paragraph{}
705\label{JAVA:JNULL-REF-P}
706\index{JNULL-REF-P}
707--- Function: \textbf{jnull-ref-p} [\textbf{java}] \textit{object}
708
709\begin{adjustwidth}{5em}{5em}
710Returns a non-NIL value when the JAVA-OBJECT `object` is `null`,
711or signals a TYPE-ERROR condition if the object isn't of
712the right type.
713\end{adjustwidth}
714
715\paragraph{}
716\label{JAVA:JOBJECT-CLASS}
717\index{JOBJECT-CLASS}
718--- Function: \textbf{jobject-class} [\textbf{java}] \textit{obj}
719
720\begin{adjustwidth}{5em}{5em}
721Returns the Java class that OBJ belongs to
722\end{adjustwidth}
723
724\paragraph{}
725\label{JAVA:JOBJECT-LISP-VALUE}
726\index{JOBJECT-LISP-VALUE}
727--- Function: \textbf{jobject-lisp-value} [\textbf{java}] \textit{java-object}
728
729\begin{adjustwidth}{5em}{5em}
730Attempts to coerce JAVA-OBJECT into a Lisp object.
731\end{adjustwidth}
732
733\paragraph{}
734\label{JAVA:JPROPERTY-VALUE}
735\index{JPROPERTY-VALUE}
736--- Function: \textbf{jproperty-value} [\textbf{java}] \textit{object property}
737
738\begin{adjustwidth}{5em}{5em}
739setf-able access on the Java Beans notion of property named PROPETRY on OBJECT.
740\end{adjustwidth}
741
742\paragraph{}
743\label{JAVA:JREGISTER-HANDLER}
744\index{JREGISTER-HANDLER}
745--- Function: \textbf{jregister-handler} [\textbf{java}] \textit{object event handler \&key data count}
746
747\begin{adjustwidth}{5em}{5em}
748not-documented
749\end{adjustwidth}
750
751\paragraph{}
752\label{JAVA:JRESOLVE-METHOD}
753\index{JRESOLVE-METHOD}
754--- Function: \textbf{jresolve-method} [\textbf{java}] \textit{method-name instance \&rest args}
755
756\begin{adjustwidth}{5em}{5em}
757Finds the most specific Java method METHOD-NAME on INSTANCE applicable to arguments ARGS. Returns NIL if no suitable method is found. The algorithm used for resolution is the same used by JCALL when it is called with a string as the first parameter (METHOD-REF).
758\end{adjustwidth}
759
760\paragraph{}
761\label{JAVA:JRUN-EXCEPTION-PROTECTED}
762\index{JRUN-EXCEPTION-PROTECTED}
763--- Function: \textbf{jrun-exception-protected} [\textbf{java}] \textit{closure}
764
765\begin{adjustwidth}{5em}{5em}
766Invokes the function CLOSURE and returns the result.  Signals an error if stack or heap exhaustion occurs.
767\end{adjustwidth}
768
769\paragraph{}
770\label{JAVA:JSTATIC}
771\index{JSTATIC}
772--- Function: \textbf{jstatic} [\textbf{java}] \textit{method class \&rest args}
773
774\begin{adjustwidth}{5em}{5em}
775Invokes the static method METHOD on class CLASS with ARGS.
776\end{adjustwidth}
777
778\paragraph{}
779\label{JAVA:JSTATIC-RAW}
780\index{JSTATIC-RAW}
781--- Function: \textbf{jstatic-raw} [\textbf{java}] \textit{method class \&rest args}
782
783\begin{adjustwidth}{5em}{5em}
784Invokes the static method METHOD on class CLASS with ARGS. Does not attempt to coerce the arguments or result into a Lisp object.
785\end{adjustwidth}
786
787\paragraph{}
788\label{JAVA:MAKE-CLASSLOADER}
789\index{MAKE-CLASSLOADER}
790--- Function: \textbf{make-classloader} [\textbf{java}] \textit{\&optional parent}
791
792\begin{adjustwidth}{5em}{5em}
793not-documented
794\end{adjustwidth}
795
796\paragraph{}
797\label{JAVA:MAKE-IMMEDIATE-OBJECT}
798\index{MAKE-IMMEDIATE-OBJECT}
799--- Function: \textbf{make-immediate-object} [\textbf{java}] \textit{object \&optional type}
800
801\begin{adjustwidth}{5em}{5em}
802Attempts to coerce a given Lisp object into a java-object of the
803given type.  If type is not provided, works as jobject-lisp-value.
804Currently, type may be :BOOLEAN, treating the object as a truth value,
805or :REF, which returns Java null if NIL is provided.
806
807Deprecated.  Please use JAVA:+NULL+, JAVA:+TRUE+, and JAVA:+FALSE+ for
808constructing wrapped primitive types, JAVA:JOBJECT-LISP-VALUE for converting a
809JAVA:JAVA-OBJECT to a Lisp value, or JAVA:JNULL-REF-P to distinguish a wrapped
810null JAVA-OBJECT from NIL.
811\end{adjustwidth}
812
813\paragraph{}
814\label{JAVA:REGISTER-JAVA-EXCEPTION}
815\index{REGISTER-JAVA-EXCEPTION}
816--- Function: \textbf{register-java-exception} [\textbf{java}] \textit{exception-name condition-symbol}
817
818\begin{adjustwidth}{5em}{5em}
819Registers the Java Throwable named by the symbol EXCEPTION-NAME as the condition designated by CONDITION-SYMBOL.  Returns T if successful, NIL if not.
820\end{adjustwidth}
821
822\paragraph{}
823\label{JAVA:UNREGISTER-JAVA-EXCEPTION}
824\index{UNREGISTER-JAVA-EXCEPTION}
825--- Function: \textbf{unregister-java-exception} [\textbf{java}] \textit{exception-name}
826
827\begin{adjustwidth}{5em}{5em}
828Unregisters the Java Throwable EXCEPTION-NAME previously registered by REGISTER-JAVA-EXCEPTION.
829\end{adjustwidth}
830
Note: See TracBrowser for help on using the repository browser.