armedbear-devel January 2010

armedbear-devel@common-lisp.net

15 participants
51 discussions

[armedbear-devel] Proposed change to jar:file semantics
by Mark Evenson 09 Jan '10

09 Jan '10

My initial code to get LOAD to use "jar:file:" was rather hackish in that it didn't consider enough scope of the impact so I've been looking hard at implementing TRUENAME, PROBE-FILE, MERGE-PATHNAMES (and eventually PROBE-DIRECTORY and DIRECTORY) for "jar:file" entries. I'd like to propose we change the use of the "jar:file:" string to only occur in the namestring representation of a jar file entry, i.e. the device entry would always be a "real" pathname. So what would currently be CL-USER> (pathname-name (pathname-device #p"jar:file:abcl.jar!/foo")) "jar:file:abcl" which would become CL-USER> (pathname-name (pathname-device #p"jar:file:abcl.jar!/foo")) "abcl" under my proposal. This would simplify the needed code quite a bit as one just has to detect we are dealing with a jar entry reference, pull the pathname out of device, and pass it to a sub-routine. And according to the unofficial specification of the "jar:file" URI schema, it is invalid not to have a reference to the entry by the path following the "!/" (i.e. "jar:file:abcl.jar" has no meaning, just "jar:file:abcl.jar!/foo"). I've started to implement this, but would like to float this idea across the list to see if there are objections and/or problems I've not foreseen. -- "A screaming comes across the sky. It has happened before, but there is nothing to compare to it now."

1 1

[armedbear-devel] Questions for use in a server
by Blake McBride 09 Jan '10

09 Jan '10

Greetings, I am considering using ABCL as an extension language to a Web server app I have. I know the answer to many of the questions I have in choosing the correct extension language and ABCL seems to fit the bill well. I do have some questions, however. 1. Can ABCL run concurrently in multiple threads without any problems (I understand the ramifications in terms of my application code)? 2. I would like to have some utility code which is loaded once and shared by all the ABCL threads. Each thread can then run code that is independent (i.e. they can have the same function names with different definitions). (Perhaps I'd have to use packages for this.) 3. If I am running a lot of different threads will ABCL allow code to be GC'd when the thread ends (presuming no other thread is using that code)? 4. ABCL seems to have a somewhat heavy startup time. This is okay for the first time, but I need the threads to start much faster (much less than half a second). Thanks for the answers! Blake

4 5

[armedbear-devel] Why does jcall use reflection?
by Axel Rauschmayer 09 Jan '10

09 Jan '10

I hope this is not a stupid question, but: Why does jcall use reflection? Doesn't ABCL compile lisp to byte code? If one could statically declare to the compiler the intended Java class, couldn't method invocations be compiled instead of being performed via reflection? OTOH, I don't know how ABCL handles interpretation versus compilation, so that might be an issue. -- Axel.Rauschmayer(a)ifi.lmu.de http://www.pst.ifi.lmu.de/~rauschma/

3 4

[armedbear-devel] new jcall / jar:file: path functions
by Alan Ruttenberg 09 Jan '10

09 Jan '10

I'm trying to use the new jcall code in place of jss calls. However I am getting an error I don't understand. In the following: (defun directory-in-jar (pathname) (let* ((jarfile (subseq (namestring (pathname-device pathname)) 9)) (rest-pathname (namestring (make-pathname :directory (pathname-directory pathname) :name (pathname-name pathname) :type (pathname-type pathname))))) (if (or (position #\* (namestring rest-pathname)) (wild-pathname-p rest-pathname)) (let ((jar (jnew "java.util.zip.ZipFile" jarfile))) (let ((els (jcall "entries" jar))) (loop while (#"hasMoreElements" els) for name = (jcall "getName" (#"nextElement" els)) when (pathname-match-p (concatenate 'string "/" name) rest-pathname) collect (make-pathname :device (pathname-device pathname) :name (pathname-name name) :type (pathname-type name) :directory `(:absolute ,@(cdr (pathname-directory name))))))) (let ((truename (probe-file-in-jar pathname))) (if truename (list truename) nil))))) If I replace the call (#"hasMoreElements" els) with (jcall "hasMoreElements" els) I get the error: java.lang.IllegalAccessException: Class org.armedbear.lisp.Java can not access a member of class java.util.zip.ZipFile$3 with modifiers "public" at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:65) at java.lang.reflect.Method.invoke(Method.java:583) at org.armedbear.lisp.Java.jcall(Java.java:660) ... If I replace the call (#"nextElement" els) with (jcall "nextElement" els) I get the error java.lang.IllegalAccessException: Class org.armedbear.lisp.Java can not access a member of class java.util.zip.ZipFile$3 with modifiers "public volatile" at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:65) at java.lang.reflect.Method.invoke(Method.java:583) at org.armedbear.lisp.Java.jcall(Java.java:660) This from http://svn.mumble.net:8080/svn/lsw/trunk/patches/jarfile.lisp where I'm starting to add more path functions that work with the jar:file: pathname scheme. Feel free to steal and incorporate into abcl. -Alan

3 12

[armedbear-devel] loading from jar files
by Alan Ruttenberg 08 Jan '10

08 Jan '10

Seems like the extension is ignored and either lisp or .abcls files are loaded. This means that .asd files are not (an error is thrown) It also means that requests for files that don't exist get satisfied, e.g. if you give it a bogus filetype but there is a .lisp or .abcl file present. e.g. (load "jar:file:/Users/alanr/repos/lsw/trunk/patches/test.jar!/bar/bar1.li") ; Loading jar:file:/Users/alanr/repos/lsw/trunk/patches/test.jar!/bar/bar1.li ... Whoops - there is no bar1.li, just bar1.lisp (load "jar:file:/Users/alanr/repos/lsw/trunk/patches/test.jar!/bar/bar.asd") The file #P"jar:file:/Users/alanr/repos/lsw/trunk/patches/test.jar!/bar/bar.asd" does not exist. Whoops - it does so! -Alan

3 8

[armedbear-devel] compiler problem
by Alan Ruttenberg 08 Jan '10

08 Jan '10

I sent a message earlier in the week about a miscompilation - a case where jss was landing up calling a java function on a cons rather than the intended object. In case it helps, here is a function in which that happens as well as the disassembly. The call that is miscompiled is the call to #"setLayout, which expands to ((LAMBDA (OBJECT &REST ARGS) (INVOKE-RESTARGS "setLayout" OBJECT ARGS NIL)) PANEL LAYOUT) It's hard for me to follow the disassembly, but I see: ; // 142 242:getstatic #88 <Field Symbol SYM13802_GET_JAVA_FIELD> ; // 143 245:getstatic #86 <Field Symbol SYM13801_JAVAAWTGRIDBAGCONSTRAINTS> ; // 144 248:getstatic #90 <Field SimpleString STR13803> ; // 145 251:invokevirtual #93 <Method LispObject LispThread.execute(LispObject, LispObject, LispObject)> which apparently is the call to compute the value for remainder, immediately before the setLayout call. I'm guessing that <Field LispObject LFUN13809> is the compiled function for the lambda in the macroexpansion. (BTW, I don't see why there would be an actual function created here - should be optimized away) You can see that the values to the call to setLayout, are java objects. (panel (new 'javax.swing.JPanel)) (layout (new 'java.awt.GridBagLayout)) However the call results in the error Debugger invoked on condition of type JAVA-EXCEPTION: SchemeException: ERROR: NO INSTANCE METHOD OF TYPE (.setLayout org.armedbear.lisp.Cons ...) at jsint.E.error(E.java:14) at jsint.E.error(E.java:19) at jsint.Invoke.methodTable(Invoke.java:221) at jsint.Invoke.invokeMethod(Invoke.java:117) at jsint.Invoke.invokeInstance(Invoke.java:110) at sun.reflect.GeneratedMethodAccessor7.invoke(Unknown Source) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at java.lang.reflect.Method.invoke(Method.java:592) at org.armedbear.lisp.Java.jstatic(Java.java:393) at org.armedbear.lisp.Java.access$600(Java.java:51) at org.armedbear.lisp.Java$8.execute(Java.java:424) at org.armedbear.lisp.Primitive.execute(Primitive.java:174) .... So apparently the wrong argument is being passed in. As I said, the function executes properly when evaluated. The same error occurs in other methods that call java function in this way - the wrong argument is passed in. In another call (in a different function) I see (.setLayout org.armedbear.lisp.StandardGenericFunction ...) at jsint.E.error(E.java:14) at jsint.E.error(E.java:19) And elsewhere with calls to different java functions. Hope this gives you something to go on. -Alan (defmethod make-contents ((this inspector)) (with-slots (object header fields table table-maker history) this (let ((table-panel nil) (panel (new 'javax.swing.JPanel)) (layout (new 'java.awt.GridBagLayout)) (constraints (new 'java.awt.GridBagConstraints)) (remainder (get-java-field 'java.awt.GridBagConstraints "REMAINDER"))) (#"setLayout" panel layout) (labels ((add-component (comp) (#"setConstraints" layout comp constraints) (#"add" panel comp)) (jump-selected () (multiple-value-bind (field row) (selected-field this) (oojump this field row t)))) (loop for button in (make-inspector-buttons this) do (add-component button)) (setq table-maker #'(lambda () (if table-panel (let ((parent (#"getParent" table-panel))) (#"remove" parent table-panel))) (set-java-field constraints "gridwidth" remainder) (set-java-field constraints "gridheight" remainder) (set-java-field constraints "weightx" 1.0) (set-java-field constraints "weighty" 1.0) (set-java-field constraints "gridx" 0) (set-java-field constraints "gridy" 1) (set-java-field constraints "fill" (get-java-field 'java.awt.GridBagConstraints "BOTH")) (let ((data (oinspect-data this object))) (setq header (car data)) (setq fields (cdr data)) (setq table (make-table (mapcar #'(lambda (row) (mapcar #'(lambda (field) (tostring this field)) row)) fields) header))) (#"addMouseListener" table (jinterface-safe-implementation (jclass "java.awt.event.MouseListener") "mousePressed" #'(lambda (evt) (if (= (#"getClickCount" evt) 2) (jump-selected))))) (#"addMouseMotionListener" table (jinterface-safe-implementation (jclass "java.awt.event.MouseMotionListener") "mouseMoved" #'(lambda (evt) (let* ((point (#"getPoint" evt)) (col (#"columnAtPoint" table point)) (row (#"rowAtPoint" table point)) (value (value-at this row col))) (#"setToolTipText" table (html-wrap-string (tostring this value))))))) (setq table-panel (make-table-panel table 350 200)) (add-component table-panel))) (funcall table-maker) panel)))) CL-USER(82): (disassemble (mop::%method-function (car (mop::%compute-applicable-methods #'make-contents (list (make-instance 'inspector)))))) ; Couldn't fully decompile method execute ; // Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov. ; // Jad home page: http://www.kpdus.com/jad.html ; // Decompiler options: packimports(3) annotate ; // Source File Name: oinspect.lisp ; ; package org.armedbear.lisp; ; ; ; // Referenced classes of package org.armedbear.lisp: ; // Primitive, LispThread, ClosureBinding, LispObject, ; // Lisp, CompiledClosure, Symbol, SimpleString, ; // AutoloadedFunctionProxy ; ; public class oinspect_21 extends Primitive ; { ; ; public LispObject execute(LispObject lispobject, LispObject lispobject1) ; { ; LispThread lispthread; ; ClosureBinding aclosurebinding[]; ; lispthread = LispThread.currentThread(); ; // 0 0:invokestatic #54 <Method LispThread LispThread.currentThread()> ; // 1 3:astore_3 ; aclosurebinding = (new ClosureBinding[] { ; new ClosureBinding(null), new ClosureBinding(null), new ClosureBinding(null), new ClosureBinding(null), new ClosureBinding(null), new ClosureBinding(null), new ClosureBinding(null), new ClosureBinding(null), new ClosureBinding(null) ; }); ; // 2 4:bipush 9 ; // 3 6:anewarray ClosureBinding[] ; // 4 9:dup ; // 5 10:iconst_0 ; // 6 11:new #56 <Class ClosureBinding> ; // 7 14:dup ; // 8 15:aconst_null ; // 9 16:invokespecial #60 <Method void ClosureBinding(LispObject)> ; // 10 19:aastore ; // 11 20:dup ; // 12 21:iconst_1 ; // 13 22:new #56 <Class ClosureBinding> ; // 14 25:dup ; // 15 26:aconst_null ; // 16 27:invokespecial #60 <Method void ClosureBinding(LispObject)> ; // 17 30:aastore ; // 18 31:dup ; // 19 32:iconst_2 ; // 20 33:new #56 <Class ClosureBinding> ; // 21 36:dup ; // 22 37:aconst_null ; // 23 38:invokespecial #60 <Method void ClosureBinding(LispObject)> ; // 24 41:aastore ; // 25 42:dup ; // 26 43:iconst_3 ; // 27 44:new #56 <Class ClosureBinding> ; // 28 47:dup ; // 29 48:aconst_null ; // 30 49:invokespecial #60 <Method void ClosureBinding(LispObject)> ; // 31 52:aastore ; // 32 53:dup ; // 33 54:iconst_4 ; // 34 55:new #56 <Class ClosureBinding> ; // 35 58:dup ; // 36 59:aconst_null ; // 37 60:invokespecial #60 <Method void ClosureBinding(LispObject)> ; // 38 63:aastore ; // 39 64:dup ; // 40 65:iconst_5 ; // 41 66:new #56 <Class ClosureBinding> ; // 42 69:dup ; // 43 70:aconst_null ; // 44 71:invokespecial #60 <Method void ClosureBinding(LispObject)> ; // 45 74:aastore ; // 46 75:dup ; // 47 76:bipush 6 ; // 48 78:new #56 <Class ClosureBinding> ; // 49 81:dup ; // 50 82:aconst_null ; // 51 83:invokespecial #60 <Method void ClosureBinding(LispObject)> ; // 52 86:aastore ; // 53 87:dup ; // 54 88:bipush 7 ; // 55 90:new #56 <Class ClosureBinding> ; // 56 93:dup ; // 57 94:aconst_null ; // 58 95:invokespecial #60 <Method void ClosureBinding(LispObject)> ; // 59 98:aastore ; // 60 99:dup ; // 61 100:bipush 8 ; // 62 102:new #56 <Class ClosureBinding> ; // 63 105:dup ; // 64 106:aconst_null ; // 65 107:invokespecial #60 <Method void ClosureBinding(LispObject)> ; // 66 110:aastore ; // 67 111:astore 4 ; new ClosureBinding(lispobject.car()); ; // 68 113:aload_1 ; // 69 114:invokevirtual #66 <Method LispObject LispObject.car()> ; // 70 117:new #56 <Class ClosureBinding> ; // 71 120:dup_x1 ; // 72 121:swap ; // 73 122:invokespecial #60 <Method void ClosureBinding(LispObject)> ; aclosurebinding; ; // 74 125:aload 4 ; JVM INSTR swap ; ; // 75 127:swap ; 0; ; // 76 128:iconst_0 ; JVM INSTR swap ; ; // 77 129:swap ; JVM INSTR aastore ; ; // 78 130:aastore ; new ClosureBinding(aclosurebinding[0].value); ; // 79 131:aload 4 ; // 80 133:iconst_0 ; // 81 134:aaload ; // 82 135:getfield #69 <Field LispObject ClosureBinding.value> ; // 83 138:new #56 <Class ClosureBinding> ; // 84 141:dup_x1 ; // 85 142:swap ; // 86 143:invokespecial #60 <Method void ClosureBinding(LispObject)> ; aclosurebinding; ; // 87 146:aload 4 ; JVM INSTR swap ; ; // 88 148:swap ; 1; ; // 89 149:iconst_1 ; JVM INSTR swap ; ; // 90 150:swap ; JVM INSTR aastore ; ; // 91 151:aastore ; new ClosureBinding(Lisp.NIL); ; // 92 152:getstatic #74 <Field LispObject Lisp.NIL> ; // 93 155:new #56 <Class ClosureBinding> ; // 94 158:dup_x1 ; // 95 159:swap ; // 96 160:invokespecial #60 <Method void ClosureBinding(LispObject)> ; aclosurebinding; ; // 97 163:aload 4 ; JVM INSTR swap ; ; // 98 165:swap ; 2; ; // 99 166:iconst_2 ; JVM INSTR swap ; ; // 100 167:swap ; JVM INSTR aastore ; ; // 101 168:aastore ; new ClosureBinding(lispthread.execute(SYM13798_NEW, SYM13799_JAVAXSWINGJPANEL)); ; // 102 169:aload_3 ; // 103 170:getstatic #78 <Field Symbol SYM13798_NEW> ; // 104 173:getstatic #80 <Field Symbol SYM13799_JAVAXSWINGJPANEL> ; // 105 176:invokevirtual #82 <Method LispObject LispThread.execute(LispObject, LispObject)> ; // 106 179:new #56 <Class ClosureBinding> ; // 107 182:dup_x1 ; // 108 183:swap ; // 109 184:invokespecial #60 <Method void ClosureBinding(LispObject)> ; aclosurebinding; ; // 110 187:aload 4 ; JVM INSTR swap ; ; // 111 189:swap ; 3; ; // 112 190:iconst_3 ; JVM INSTR swap ; ; // 113 191:swap ; JVM INSTR aastore ; ; // 114 192:aastore ; new ClosureBinding(lispthread.execute(SYM13798_NEW, SYM13800_JAVAAWTGRIDBAGLAYOUT)); ; // 115 193:aload_3 ; // 116 194:getstatic #78 <Field Symbol SYM13798_NEW> ; // 117 197:getstatic #84 <Field Symbol SYM13800_JAVAAWTGRIDBAGLAYOUT> ; // 118 200:invokevirtual #82 <Method LispObject LispThread.execute(LispObject, LispObject)> ; // 119 203:new #56 <Class ClosureBinding> ; // 120 206:dup_x1 ; // 121 207:swap ; // 122 208:invokespecial #60 <Method void ClosureBinding(LispObject)> ; aclosurebinding; ; // 123 211:aload 4 ; JVM INSTR swap ; ; // 124 213:swap ; 4; ; // 125 214:iconst_4 ; JVM INSTR swap ; ; // 126 215:swap ; JVM INSTR aastore ; ; // 127 216:aastore ; new ClosureBinding(lispthread.execute(SYM13798_NEW, SYM13801_JAVAAWTGRIDBAGCONSTRAINTS)); ; // 128 217:aload_3 ; // 129 218:getstatic #78 <Field Symbol SYM13798_NEW> ; // 130 221:getstatic #86 <Field Symbol SYM13801_JAVAAWTGRIDBAGCONSTRAINTS> ; // 131 224:invokevirtual #82 <Method LispObject LispThread.execute(LispObject, LispObject)> ; // 132 227:new #56 <Class ClosureBinding> ; // 133 230:dup_x1 ; // 134 231:swap ; // 135 232:invokespecial #60 <Method void ClosureBinding(LispObject)> ; aclosurebinding; ; // 136 235:aload 4 ; JVM INSTR swap ; ; // 137 237:swap ; 5; ; // 138 238:iconst_5 ; JVM INSTR swap ; ; // 139 239:swap ; JVM INSTR aastore ; ; // 140 240:aastore ; new ClosureBinding(lispthread.execute(SYM13802_GET_JAVA_FIELD, SYM13801_JAVAAWTGRIDBAGCONSTRAINTS, STR13803)); ; // 141 241:aload_3 ; // 142 242:getstatic #88 <Field Symbol SYM13802_GET_JAVA_FIELD> ; // 143 245:getstatic #86 <Field Symbol SYM13801_JAVAAWTGRIDBAGCONSTRAINTS> ; // 144 248:getstatic #90 <Field SimpleString STR13803> ; // 145 251:invokevirtual #93 <Method LispObject LispThread.execute(LispObject, LispObject, LispObject)> ; // 146 254:new #56 <Class ClosureBinding> ; // 147 257:dup_x1 ; // 148 258:swap ; // 149 259:invokespecial #60 <Method void ClosureBinding(LispObject)> ; aclosurebinding; ; // 150 262:aload 4 ; JVM INSTR swap ; ; // 151 264:swap ; 6; ; // 152 265:bipush 6 ; JVM INSTR swap ; ; // 153 267:swap ; JVM INSTR aastore ; ; // 154 268:aastore ; ClosureBinding aclosurebinding1[]; ; lispthread._values = null; ; // 155 269:aload_3 ; // 156 270:aconst_null ; // 157 271:putfield #97 <Field LispObject[] LispThread._values> ; //* 158 274:getstatic #99 <Field LispObject LFUN13809> ; System.arraycopy(aclosurebinding, 0, aclosurebinding1 = new ClosureBinding[9], 0, 9); ; // 159 277:aload 4 ; // 160 279:iconst_0 ; // 161 280:bipush 9 ; // 162 282:anewarray ClosureBinding[] ; // 163 285:dup ; // 164 286:astore 5 ; // 165 288:iconst_0 ; // 166 289:bipush 9 ; // 167 291:invokestatic #105 <Method void System.arraycopy(Object, int, Object, int, int)> ; Lisp.makeCompiledClosure(LFUN13809, aclosurebinding1); ; // 168 294:aload 5 ; // 169 296:invokestatic #109 <Method LispObject Lisp.makeCompiledClosure(LispObject, ClosureBinding[])> ; lispthread; ; // 170 299:aload_3 ; JVM INSTR swap ; ; // 171 300:swap ; aclosurebinding[3].value; ; // 172 301:aload 4 ; // 173 303:iconst_3 ; // 174 304:aaload ; // 175 305:getfield #69 <Field LispObject ClosureBinding.value> ; aclosurebinding[4].value; ; // 176 308:aload 4 ; // 177 310:iconst_4 ; // 178 311:aaload ; // 179 312:getfield #69 <Field LispObject ClosureBinding.value> ; execute(); ; // 180 315:invokevirtual #93 <Method LispObject LispThread.execute(LispObject, LispObject, LispObject)> ; JVM INSTR pop ; ; // 181 318:pop ; lispthread._values = null; ; // 182 319:aload_3 ; // 183 320:aconst_null ; // 184 321:putfield #97 <Field LispObject[] LispThread._values> ; //* 185 324:getstatic #111 <Field LispObject LFUN13827> ; //* 186 327:checkcast #113 <Class CompiledClosure> ; System.arraycopy(aclosurebinding, 0, aclosurebinding1 = new ClosureBinding[9], 0, 9); ; // 187 330:aload 4 ; // 188 332:iconst_0 ; // 189 333:bipush 9 ; // 190 335:anewarray ClosureBinding[] ; // 191 338:dup ; // 192 339:astore 5 ; // 193 341:iconst_0 ; // 194 342:bipush 9 ; // 195 344:invokestatic #105 <Method void System.arraycopy(Object, int, Object, int, int)> ; Lisp.makeCompiledClosure((CompiledClosure)LFUN13827, aclosurebinding1); ; // 196 347:aload 5 ; // 197 349:invokestatic #109 <Method LispObject Lisp.makeCompiledClosure(LispObject, ClosureBinding[])> ; aclosurebinding[7]; ; // 198 352:aload 4 ; // 199 354:bipush 7 ; // 200 356:aaload ; JVM INSTR swap ; ; // 201 357:swap ; value; ; // 202 358:putfield #69 <Field LispObject ClosureBinding.value> ; //* 203 361:getstatic #115 <Field LispObject LFUN13838> ; //* 204 364:checkcast #113 <Class CompiledClosure> ; System.arraycopy(aclosurebinding, 0, aclosurebinding1 = new ClosureBinding[9], 0, 9); ; // 205 367:aload 4 ; // 206 369:iconst_0 ; // 207 370:bipush 9 ; // 208 372:anewarray ClosureBinding[] ; // 209 375:dup ; // 210 376:astore 5 ; // 211 378:iconst_0 ; // 212 379:bipush 9 ; // 213 381:invokestatic #105 <Method void System.arraycopy(Object, int, Object, int, int)> ; Lisp.makeCompiledClosure((CompiledClosure)LFUN13838, aclosurebinding1); ; // 214 384:aload 5 ; // 215 386:invokestatic #109 <Method LispObject Lisp.makeCompiledClosure(LispObject, ClosureBinding[])> ; aclosurebinding[8]; ; // 216 389:aload 4 ; // 217 391:bipush 8 ; // 218 393:aaload ; JVM INSTR swap ; ; // 219 394:swap ; value; ; // 220 395:putfield #69 <Field LispObject ClosureBinding.value> ; LispObject lispobject2 = Lisp.NIL; ; // 221 398:getstatic #74 <Field LispObject Lisp.NIL> ; // 222 401:astore 5 ; LispObject lispobject4 = lispthread.execute(SYM13842_MAKE_INSPECTOR_BUTTONS, aclosurebinding[0].value); ; // 223 403:aload_3 ; // 224 404:getstatic #117 <Field Symbol SYM13842_MAKE_INSPECTOR_BUTTONS> ; // 225 407:aload 4 ; // 226 409:iconst_0 ; // 227 410:aaload ; // 228 411:getfield #69 <Field LispObject ClosureBinding.value> ; // 229 414:invokevirtual #82 <Method LispObject LispThread.execute(LispObject, LispObject)> ; // 230 417:astore 6 ; lispthread._values = null; ; // 231 419:aload_3 ; // 232 420:aconst_null ; // 233 421:putfield #97 <Field LispObject[] LispThread._values> ; do ; { ; if(lispobject4.endp()) ; //* 234 424:aload 6 ; //* 235 426:invokevirtual #121 <Method boolean LispObject.endp()> ; //* 236 429:ifeq 444 ; { ; if(Lisp.interrupted) ; //* 237 432:getstatic #125 <Field boolean Lisp.interrupted> ; //* 238 435:ifeq 441 ; Lisp.handleInterrupt(); ; // 239 438:invokestatic #129 <Method void Lisp.handleInterrupt()> ; break; ; // 240 441:goto 484 ; } ; LispObject lispobject3 = lispobject4.car(); ; // 241 444:aload 6 ; // 242 446:invokevirtual #66 <Method LispObject LispObject.car()> ; // 243 449:astore 5 ; lispobject4 = lispobject4.cdr(); ; // 244 451:aload 6 ; // 245 453:invokevirtual #132 <Method LispObject LispObject.cdr()> ; // 246 456:astore 6 ; aclosurebinding[7].value.execute(lispobject3); ; // 247 458:aload 4 ; // 248 460:bipush 7 ; // 249 462:aaload ; // 250 463:getfield #69 <Field LispObject ClosureBinding.value> ; // 251 466:aload 5 ; // 252 468:invokevirtual #135 <Method LispObject LispObject.execute(LispObject)> ; // 253 471:pop ; if(Lisp.interrupted) ; //* 254 472:getstatic #125 <Field boolean Lisp.interrupted> ; //* 255 475:ifeq 481 ; Lisp.handleInterrupt(); ; // 256 478:invokestatic #129 <Method void Lisp.handleInterrupt()> ; } while(true); ; // 257 481:goto 424 ; lispthread._values = null; ; // 258 484:aload_3 ; // 259 485:aconst_null ; // 260 486:putfield #97 <Field LispObject[] LispThread._values> ; //* 261 489:aload_3 ; //* 262 490:getstatic #137 <Field Symbol SYM13851_SET_SLOT_VALUE> ; //* 263 493:aload 4 ; //* 264 495:iconst_1 ; //* 265 496:aaload ; //* 266 497:getfield #69 <Field LispObject ClosureBinding.value> ; //* 267 500:getstatic #139 <Field Symbol SYM13852_TABLE_MAKER> ; //* 268 503:getstatic #141 <Field LispObject LFUN13987> ; ClosureBinding aclosurebinding2[]; ; System.arraycopy(aclosurebinding, 0, aclosurebinding2 = new ClosureBinding[9], 0, 9); ; // 269 506:aload 4 ; // 270 508:iconst_0 ; // 271 509:bipush 9 ; // 272 511:anewarray ClosureBinding[] ; // 273 514:dup ; // 274 515:astore 5 ; // 275 517:iconst_0 ; // 276 518:bipush 9 ; // 277 520:invokestatic #105 <Method void System.arraycopy(Object, int, Object, int, int)> ; lispthread.execute(SYM13851_SET_SLOT_VALUE, aclosurebinding[1].value, SYM13852_TABLE_MAKER, Lisp.makeCompiledClosure(LFUN13987, aclosurebinding2)); ; // 278 523:aload 5 ; // 279 525:invokestatic #109 <Method LispObject Lisp.makeCompiledClosure(LispObject, ClosureBinding[])> ; // 280 528:invokevirtual #144 <Method LispObject LispThread.execute(LispObject, LispObject, LispObject, LispObject)> ; // 281 531:pop ; lispthread.execute(Symbol.SLOT_VALUE, aclosurebinding[1].value, SYM13852_TABLE_MAKER); ; // 282 532:aload_3 ; // 283 533:getstatic #149 <Field Symbol Symbol.SLOT_VALUE> ; // 284 536:aload 4 ; // 285 538:iconst_1 ; // 286 539:aaload ; // 287 540:getfield #69 <Field LispObject ClosureBinding.value> ; // 288 543:getstatic #139 <Field Symbol SYM13852_TABLE_MAKER> ; // 289 546:invokevirtual #93 <Method LispObject LispThread.execute(LispObject, LispObject, LispObject)> ; lispthread; ; // 290 549:aload_3 ; JVM INSTR swap ; ; // 291 550:swap ; execute(); ; // 292 551:invokevirtual #150 <Method LispObject LispThread.execute(LispObject)> ; JVM INSTR pop ; ; // 293 554:pop ; lispthread._values = null; ; // 294 555:aload_3 ; // 295 556:aconst_null ; // 296 557:putfield #97 <Field LispObject[] LispThread._values> ; return aclosurebinding[3].value; ; // 297 560:aload 4 ; // 298 562:iconst_3 ; // 299 563:aaload ; // 300 564:getfield #69 <Field LispObject ClosureBinding.value> ; // 301 567:areturn ; } ; ; public oinspect_21() ; { ; super(Lisp.NIL, Lisp.readObjectFromString("(MOP::ARGS MOP::NEXT-EMFUN)")); ; // 0 0:aload_0 ; // 1 1:getstatic #74 <Field LispObject Lisp.NIL> ; // 2 4:ldc1 #154 <String "(MOP::ARGS MOP::NEXT-EMFUN)"> ; // 3 6:invokestatic #158 <Method LispObject Lisp.readObjectFromString(String)> ; // 4 9:invokespecial #161 <Method void Primitive(LispObject, LispObject)> ; // 5 12:ldc1 #6 <String "NEW"> ; // 6 14:ldc1 #8 <String "COMMON-LISP-USER"> ; // 7 16:invokestatic #165 <Method Symbol Lisp.internInPackage(String, String)> ; // 8 19:putstatic #78 <Field Symbol SYM13798_NEW> ; // 9 22:ldc1 #11 <String "JAVAX.SWING.JPANEL"> ; // 10 24:ldc1 #8 <String "COMMON-LISP-USER"> ; // 11 26:invokestatic #165 <Method Symbol Lisp.internInPackage(String, String)> ; // 12 29:putstatic #80 <Field Symbol SYM13799_JAVAXSWINGJPANEL> ; // 13 32:ldc1 #14 <String "JAVA.AWT.GRIDBAGLAYOUT"> ; // 14 34:ldc1 #8 <String "COMMON-LISP-USER"> ; // 15 36:invokestatic #165 <Method Symbol Lisp.internInPackage(String, String)> ; // 16 39:putstatic #84 <Field Symbol SYM13800_JAVAAWTGRIDBAGLAYOUT> ; // 17 42:ldc1 #17 <String "JAVA.AWT.GRIDBAGCONSTRAINTS"> ; // 18 44:ldc1 #8 <String "COMMON-LISP-USER"> ; // 19 46:invokestatic #165 <Method Symbol Lisp.internInPackage(String, String)> ; // 20 49:putstatic #86 <Field Symbol SYM13801_JAVAAWTGRIDBAGCONSTRAINTS> ; // 21 52:ldc1 #20 <String "GET-JAVA-FIELD"> ; // 22 54:ldc1 #8 <String "COMMON-LISP-USER"> ; // 23 56:invokestatic #165 <Method Symbol Lisp.internInPackage(String, String)> ; // 24 59:putstatic #88 <Field Symbol SYM13802_GET_JAVA_FIELD> ; // 25 62:new #167 <Class SimpleString> ; // 26 65:dup ; // 27 66:ldc1 #24 <String "REMAINDER"> ; // 28 68:invokespecial #170 <Method void SimpleString(String)> ; // 29 71:putstatic #90 <Field SimpleString STR13803> ; // 30 74:ldc1 #28 <String "oinspect-22.cls"> ; // 31 76:invokestatic #175 <Method LispObject AutoloadedFunctionProxy.loadPreloadedFunction(String)> ; // 32 79:putstatic #99 <Field LispObject LFUN13809> ; // 33 82:ldc1 #31 <String "oinspect-23.cls"> ; // 34 84:invokestatic #175 <Method LispObject AutoloadedFunctionProxy.loadPreloadedFunction(String)> ; // 35 87:putstatic #111 <Field LispObject LFUN13827> ; // 36 90:ldc1 #34 <String "oinspect-26.cls"> ; // 37 92:invokestatic #175 <Method LispObject AutoloadedFunctionProxy.loadPreloadedFunction(String)> ; // 38 95:putstatic #115 <Field LispObject LFUN13838> ; // 39 98:ldc1 #37 <String "MAKE-INSPECTOR-BUTTONS"> ; // 40 100:ldc1 #8 <String "COMMON-LISP-USER"> ; // 41 102:invokestatic #165 <Method Symbol Lisp.internInPackage(String, String)> ; // 42 105:putstatic #117 <Field Symbol SYM13842_MAKE_INSPECTOR_BUTTONS> ; // 43 108:ldc1 #40 <String "%SET-SLOT-VALUE"> ; // 44 110:ldc1 #42 <String "MOP"> ; // 45 112:invokestatic #165 <Method Symbol Lisp.internInPackage(String, String)> ; // 46 115:putstatic #137 <Field Symbol SYM13851_SET_SLOT_VALUE> ; // 47 118:ldc1 #45 <String "TABLE-MAKER"> ; // 48 120:ldc1 #8 <String "COMMON-LISP-USER"> ; // 49 122:invokestatic #165 <Method Symbol Lisp.internInPackage(String, String)> ; // 50 125:putstatic #139 <Field Symbol SYM13852_TABLE_MAKER> ; // 51 128:ldc1 #48 <String "oinspect-27.cls"> ; // 52 130:invokestatic #175 <Method LispObject AutoloadedFunctionProxy.loadPreloadedFunction(String)> ; // 53 133:putstatic #141 <Field LispObject LFUN13987> ; // 54 136:return ; } ; ; static final LispObject LFUN13987 = AutoloadedFunctionProxy.loadPreloadedFunction("oinspect-27.cls"); ; private static final Symbol SYM13852_TABLE_MAKER = Lisp.internInPackage("TABLE-MAKER", "COMMON-LISP-USER"); ; private static final Symbol SYM13851_SET_SLOT_VALUE = Lisp.internInPackage("%SET-SLOT-VALUE", "MOP"); ; private static final Symbol SYM13842_MAKE_INSPECTOR_BUTTONS = Lisp.internInPackage("MAKE-INSPECTOR-BUTTONS", "COMMON-LISP-USER"); ; static final LispObject LFUN13838 = AutoloadedFunctionProxy.loadPreloadedFunction("oinspect-26.cls"); ; static final LispObject LFUN13827 = AutoloadedFunctionProxy.loadPreloadedFunction("oinspect-23.cls"); ; static final LispObject LFUN13809 = AutoloadedFunctionProxy.loadPreloadedFunction("oinspect-22.cls"); ; private static final SimpleString STR13803 = new SimpleString("REMAINDER"); ; private static final Symbol SYM13802_GET_JAVA_FIELD = Lisp.internInPackage("GET-JAVA-FIELD", "COMMON-LISP-USER"); ; private static final Symbol SYM13801_JAVAAWTGRIDBAGCONSTRAINTS = Lisp.internInPackage("JAVA.AWT.GRIDBAGCONSTRAINTS", "COMMON-LISP-USER"); ; private static final Symbol SYM13800_JAVAAWTGRIDBAGLAYOUT = Lisp.internInPackage("JAVA.AWT.GRIDBAGLAYOUT", "COMMON-LISP-USER"); ; private static final Symbol SYM13799_JAVAXSWINGJPANEL = Lisp.internInPackage("JAVAX.SWING.JPANEL", "COMMON-LISP-USER"); ; private static final Symbol SYM13798_NEW = Lisp.internInPackage("NEW", "COMMON-LISP-USER"); ; }

2 7

[armedbear-devel] Spurious errors about redefinitions
by Mark Evenson 07 Jan '10

07 Jan '10

Since Erik's autoload patches of about a week ago hit the tree that started to optimize the FASL loading, I see a lot of spurious errors about redefining symbols like the following when loading SLIME: STYLE-WARNING: redefining SWANK::%MAKE-FUZZY-MATCHING in #P"/Users/evenson/work/slime/contrib/swank-fuzzy.lisp" (previously defined in NIL) STYLE-WARNING: redefining SWANK::FUZZY-MATCHING-P in #P"/Users/evenson/work/slime/contrib/swank-fuzzy.lisp" (previously defined in NIL) STYLE-WARNING: redefining SWANK::FUZZY-MATCHING.SYMBOL in #P"/Users/evenson/work/slime/contrib/swank-fuzzy.lisp" (previously defined in NIL) STYLE-WARNING: redefining SWANK::FUZZY-MATCHING.PACKAGE-NAME in #P"/Users/evenson/work/slime/contrib/swank-fuzzy.lisp" (previously defined in NIL) I thought this was taken care of with [svn 12324][1], but this doesn't seem to be the case. I haven't yet been able to isolate the behavior yet, but if someone knows a quick fix, that would be great. [1]: http://code.google.com/p/abcl-dynamic-install/source/detail?r=ad17b2b2733ee… -- "A screaming comes across the sky. It has happened before, but there is nothing to compare to it now."

4 8

[armedbear-devel] User-extensible sequences?
by Axel Rauschmayer 06 Jan '10

06 Jan '10

I was looking for something similar to lazy lists or iterators in CL and asked a friend who told me about the following paper (abstract see below): http://www.doc.gold.ac.uk/~mas01cr/papers/ilc2007/sequences-20070301.pdf Is this something worthy of inclusion into ABCL? -- Axel.Rauschmayer(a)ifi.lmu.de http://www.pst.ifi.lmu.de/~rauschma/ User-extensible sequences in Common Lisp Christophe Rhodes Common Lisp is often touted as the programmable programming language, yet it sometimes places large barriers in the way, with the best of intentions. One of those barriers is a limit to the extensibility by the user of certain core language constructs, such as the ability to define subclasses of builtin classes usable with standard functions: even where this could be achievable with minimal penalties. We introduce the notion of user-extensible sequences, describing a protocol which implementations of such classes should follow. We show examples of their use, and discuss the issues observed in providing support for this protocol in a Common Lisp, including ensuring that there is no performance impact from its inclusion.

2 2

[armedbear-devel] Working toward an 0.18 release
by Erik Huelsmann 05 Jan '10

05 Jan '10

Even though trunk isn't "feature complete" yet, I'd like us to start preparing the 0.18 release as we do every roughly 2 months. Every release consists of the following steps: * Update CHANGES * Check/update INSTALL * Write release notes * Run ANSI tests and CL-BENCH on trunk (but preferrably also Maxima tests) * Trial-run the release script for source and binary distributions * Run ANSI test and CL-BENCH on the release trial-release archives (but preferrably also Maxima tests) [Don't distribute the trial-release archives! We don't want several version 0.18's floating around...] Because I'd like to distribute the work, making light work for everybody, I'm looking for takers on any of these tasks. Bye, Erik.

2 2

[armedbear-devel] Tip: asterisks in classpaths
by Axel Rauschmayer 05 Jan '10

05 Jan '10

Java 6 has a feature that can help with plugging external JARs into ABCL: If the classpath includes an asterisk, all JARs in the given directory are added. For example, I've created the directory ~/local/abcl for my ABCL installation that includes abcl.jar plus any other JARs I want to use. Then the following command automatically adds everything in that directory to the classpath and starts ABCL: > exec java -cp "$HOME/local/abcl/*" \ > org.armedbear.lisp.Main \ > "$@" (The "exec" can probably be omitted) -- Axel.Rauschmayer(a)ifi.lmu.de http://www.pst.ifi.lmu.de/~rauschma/

1 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

armedbear-devel January 2010