- armedbear-devel - mailman3.common-lisp.net

[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

[armedbear-devel] patch for converting LispErrors to ProgramErrors in Closure.java, also removes some of the assertions
by Ville Voutilainen 04 Jan '10

04 Jan '10

It looks like some of the assertions may be actually valid as assertions. The remaining ones are: 1) in Closure constructor, parsing of parameters else if (obj instanceof Cons) { if (state == STATE_AUX) { Symbol sym = checkSymbol(obj.car()); LispObject initForm = obj.cadr(); Debug.assertTrue(initForm != null); if (aux == null) aux = new ArrayList<Parameter>(); aux.add(new Parameter(sym, initForm, AUX)); } I don't see how to create a null initform other than creating a Cons that has a null car or cdr. And I don't know how to do that from lisp code. To me, that looks like it requires serious abuse from the Java side to accomplish. And I don't think that would be the only place where the validity of a Cons would need to be checked. I'm inclined to just remove that assertion completely. 2) again in Closure constructor, else { // Lambda list is empty. Debug.assertTrue(lambdaList == NIL); arity = 0; maxArgs = 0; } That's an else branch of if (lambdaList instanceof Cons), and it looks like it asserts that our own code in Closure is correct. I'm inclined to keep that assertion as is. 3) if (arity >= 0) Debug.assertTrue(arity == minArgs); a couple of lines down, check that minArgs is equal to arity if arity isn't negative. Looks correct to me, I'm inclined to keep it as is. 4) if (optionalParameters.length == 0 && keywordParameters.length == 0) args = fastProcessArgs(args); else args = processArgs(args, thread); Debug.assertTrue(args.length == variables.length); in the array version of execute. That looks like it verifies that our argument processing works, and looks correct to me. I'm inclined to keep it as is. 5) Parameter.processInitForm: if (initForm.constantp()) { if (initForm instanceof Symbol) return initForm.getSymbolValue(); if (initForm instanceof Cons) { Debug.assertTrue(initForm.car() == Symbol.QUOTE); return initForm.cadr(); } I'm not sure what is going on here. I don't know how to concoct a lambda that has a constant initform for a parameter so that the initform is Cons but is not quoted. Granted, I've mainly tested these changes with defuns, so I wouldn't be surprised if such a failure case can be demonstrated. I have no inclination here, this looks like it should probably be a ProgramError rather than an assert. Please review these cases (and the patch itself) and comment. I ran the tests and I have a failure in MAKE-BROADCAST-STREAM.8 that my baseline doesn't have, but I'm not sure if it's related to these changes.

1 0

Re: [armedbear-devel] SETF for JFEILDS
by logicmoo＠gmail.com 30 Dec '09

30 Dec '09

Thanks, you are right, much better to use the built-in key stuff (defun (setf jfield) (newvalue class-ref-or-field field-or-instance &optional ( instance nil instance-supplied-p) unused-value) (declare (ignore unused-value)) (if instance-supplied-p (jfield class-ref-or-field field-or-instance instance newvalue) (jfield class-ref-or-field field-or-instance newvalue))) ----- Original Message ----- From: "Thomas Russ" <tar(a)ISI.EDU> To: <dmiles(a)users.sourceforge.net> Sent: Tuesday, November 24, 2009 9:24 AM Subject: Re: [armedbear-devel] SETF for JFEILDS On Nov 23, 2009, at 6:47 AM, logicmoo(a)gmail.com wrote: > So actually > > (defun (setf jfield) (newvalue class-ref-or-field field-or- > instance &optional ( instance :noinst) unusedvalue) > (if (eq instance :noinst) > (jfield class-ref-or-field field-or-instance newvalue) > (jfield class-ref-or-field field-or-instance instance newvalue))) > > Would be a little better.. good eye. For what it's worth, I am not a fan of using special values to determine whether optional (or keyword) arguments are actually passed or not. I prefer to use the predicate forms from the lambda list, so something more like (defun (setf jfield) (newvalue class-ref-or-field field-or-instance &optional ( instance nil instance-supplied-p) unusedvalue) (declare (ignore unusedvalue)) (if instance-supplied-p (jfield class-ref-or-field field-or-instance newvalue) (jfield class-ref-or-field field-or-instance instance newvalue))) > > > ----- Original Message ----- > From: <dmiles(a)users.sourceforge.net> > To: "Alessio Stalla" <alessiostalla(a)gmail.com> > Cc: "Armed Bear" <armedbear-devel(a)common-lisp.net> > Sent: Monday, November 23, 2009 6:27 AM > Subject: Re: [armedbear-devel] SETF for JFEILDS > > >> >> ----- Original Message ----- >> From: "Alessio Stalla" <alessiostalla(a)gmail.com> >> To: <dmiles(a)users.sourceforge.net> >> Cc: "Armed Bear" <armedbear-devel(a)common-lisp.net> >> Sent: Monday, November 23, 2009 5:42 AM >> Subject: Re: [armedbear-devel] SETF for JFEILDS >> >> >> On Mon, Nov 23, 2009 at 2:36 PM, <logicmoo(a)gmail.com> wrote: >>>> Does anyone object to adding this to java.lisp? If not could it >>>> be done? >>>> >>>> (defun (setf jfield) >>>> (newvalue class-ref-or-field field-or-instance &optional >>>> ( instance :noinst) (value :novalue)) >>>> (if (eq instance :noinst) >>>> (jfield class-ref-or-field field-or-instance newvalue) >>>> (jfield class-ref-or-field field-or-instance instance newvalue))) >> >>> It seems a nice idea to me, but there are a couple of things that I >>> don't understand: >> >> A>- why :noinst and not simply nil? >> >> JFIELD is defined as: class-ref-or-field field-or-instance >> &optional instance value >> The valid argument patterns for this operation are: >> (class-ref field-name): to retrieve the value of a static field. >> (class-ref field-name instance-ref): to retrieve the value of a >> class field of the instance. >> (class-ref field-name primitive-value:) to store primitive-value >> in a static field. >> (class-ref field-name instance-ref value): to store value in a >> class field of the instance. >> (class-ref field-name nil value): to store value in a static >> field (when value may be confused with an instance-ref). >> (field-name instance): to retrieve the value of a field of the >> instance. The class is derived from the instance. >> (field-name instance value): to store value in a field of the >> instance. The class is derived from the instance. >> >> JFIELD doesn't distingusih between static and non static fields >> >> Also cases of "class-ref field-name instance-ref >> value" (accessing superclass field) >> >> Depending on how the field is defined >> >> (setf (jfield *MyClass* "someStaticBooleanField") NIL) >> it is distinguable from >> (setf (jfield *MySuperClass* "nonStaticBooleanField" *my- >> instance* ) NIL) >> >> >> -------------------------------------------------------------------------------------------------------------------------- >> A>- value is not used, what's the point of it? >> >> correct the "default :novalue" is not needed. >> (I was debugging and trying to find corner cases with all those >> bizzare legal jfield signatures ) >> >> >> but... "value" as an &optional was needed to match the signature >> of what is legal for jfield so things like this can work: >> >> (define-symbol-macro %iscold (jfield "org.armedbear.lisp.Lisp" >> "cold")) >> %iscold ;; ==> NIL >> (setq %iscold T) ;; ==> T >> %iscold ;; ==> T >> (setq %iscold NIL) ;; ==> NIL >> >> > > _______________________________________________ > armedbear-devel mailing list > armedbear-devel(a)common-lisp.net > http://common-lisp.net/cgi-bin/mailman/listinfo/armedbear-devel

7 19

[armedbear-devel] How do I release ABCL's "package-lock"?
by Peter Olsen 30 Dec '09

30 Dec '09

I'm writing to ask how to redefine the "or" macro in ABCL. I'm working on a project and there's one package in which I need "or" to mean something else than its usual definition. I've tried simply to redefine it, but it doesn't work. I understand that the Common Lisp spec requires special provision for that to be done --- such as the package-lock construct in SBCL. How can I do that in ABCL? I want to be able to do this within the code, for example, with in a "let" so that I can bound its scope. Can anyone point me in the right direction? My first --- failed --- experiment is below. Thanks! Peter ------------------------------------------------------- A way that doesn't work. slipstream:~ pcolsen$ abcl Armed Bear Common Lisp 0.17.0 Java 1.5.0_20 Apple Inc. Java HotSpot(TM) Client VM Low-level initialization completed in 1.476 seconds. Startup completed in 4.363 seconds. Type ":help" for a list of available commands. CL-USER(1): (or nil t) T CL-USER(2): (defmacro or (x) (+ 1 x)) ; My very own new "or" OR CL-USER(3): (or 3) ; Result should be 4 3 CL-USER(4): (or nil nil) ; My "or" should take only one argument. NIL CL-USER(5): (or nil t) T CL-USER(6): ;;; Redefinition didn't work. Peter Olsen olsen(a)sigmaxi.net I have loved the stars too fondly to be fearful of the night. Galileo Galilei

4 3

[armedbear-devel] Fwd: [armedbear-cvs] r12311 - trunk/abcl/src/org/armedbear/lisp
by Erik Huelsmann 30 Dec '09

30 Dec '09

Accidentally sent to Alessio only: ---------- Forwarded message ---------- From: Erik Huelsmann <ehuels(a)gmail.com> Date: Wed, Dec 30, 2009 at 12:08 AM Subject: Re: [armedbear-devel] [armedbear-cvs] r12311 - trunk/abcl/src/org/armedbear/lisp To: Alessio Stalla <alessiostalla(a)gmail.com> On Tue, Dec 29, 2009 at 1:16 AM, Alessio Stalla <alessiostalla(a)gmail.com> wrote: > On Tue, Dec 29, 2009 at 12:29 AM, Erik Huelsmann <ehuels(a)gmail.com> wrote: >> While the fix below does seem to fix slime - on my system, it doesn't >> fix all cases of what we're seeing: infinite recursion in clos.lisp, >> related to initial-discriminating-function. >> >> My own application suffers from the same issue, even after this fix. >> >> (just to let you know what our progress is) > > Erik, to update you on my own progress: > I found out that the infinite recursion is caused by > initial-discriminating-function being called before the class > standard-generic-function has been installed - (find-class > 'standard-generic-function) returns NIL. This means that the branch > that calls std-compute-discr.-function (the base case) never gets to > run, causing an infinite loop. To follow up on this discussion: Alessio and I found and fixed the issue: r12306 had broken an assumption in LOAD-TIME-VALUE. The fix has been committed. Bye, Erik.

2 4