Hi, there is an additional problem with matlisp.asd, and that is that it recompiles everything (but not the fortran code) everytime I load the system, even though I have loaded it before into the same lisp, and even though everything was already compiled before.

From looking at the .asd I have no clue about what might be wrong. Any ideas on what to look for?

Regards, and thanks, Mario

Faré <fahree@gmail.com> writes:

Does it work better with ASDF 1.672? If not, you might have to define some method for operation-done-p or some such.

No, unfortunately it does not work better. And operation-done-p is returning T's and NIL's with the new asdf as well as with the one packaged with sbcl, but the latter simply does not take that as a reason to recompile the lisp files, while the former does, or recompiles them for some other reason. Regards, Mario

Hello, Faré <fahree@gmail.com> writes:

Ahem. I admit this is a part of ASDF I am not familiar with.

What does traverse return? Can you trace every exported defgeneric in ASDF and attach to a launchpad bug traces of what happens in either ASDF 1 or ASDF 2?

I can try. For now I made a much smaller .asd, whith a defsystem that looks like this: (defsystem :matlispbug :components ((:unix-dso "alien code" :pathname "" :dso-name "libmatlisp" :components ((:alien-module "CPOLY" :pathname "lib-src/cpoly/" :components ((:fortran-source-file "cpoly"))))) (:file "packages") (:module "foreign-interface" :pathname "src/" :depends-on ("packages" "alien code") :components ((:file "f77-mangling") (:file "ffi-sbcl"))))) and that shows the behavior of interest. That is, with the new asdf, the module "foreign-interface" gets compiled every time I load the system, whereas under the old asdf that does not happen. From staring at the source of the .asd, I haven't been able to see what is wrong. I have uploaded a tarball with an abridged (to reduce size) version of matlisp to common-lisp.net, in case anyone wants to try: http://common-lisp.net/~mmommer/matlispasdfissue.tar.gz The shortened .asd is called matlispbug.asd. To readers in the future: I will remove the file as soon as this issue is resolved, and then this link will be broken. Regards, and thanks, Mario.

Unfortunately, I don't believe this is possible. This is YA problem arising from the fact that asdf has no object that stands for the module with it's components. Operation-done-p on a module doesn't mean the op is done on this module & components, only on the suffix of the module after it's components. E.g., if you have a module m & component c, for op o, you will see first (perform o c) Then (perform o m) In the plan, so operation-done-p does not prevent doing o on c, only on the m object itself. Traverse does a postorder traversal on the system tree. I could not figure out how to fix this while maintaining any semblance of backward compatibility. On Apr 11, 2010, at 8:09, james anderson <james.anderson@setf.de> wrote:

good afternoon;

if one invoked load-system with the factors traced which contribute to done-ness, it reads as if operation-done-p needs to be specialized for modules to delegate to the constituents. of the asdf/test/*module*.asd examples, there is one which has a similar structure. it is not obvious clear why the matlisp .asd behaves differently.

On 2010-04-11, at 13:28 , Mario S. Mommer wrote:

...

Hello,

Faré <fahree@gmail.com> writes:

...

Ahem. I admit this is a part of ASDF I am not familiar with.

What does traverse return? Can you trace every exported defgeneric in ASDF and attach to a launchpad bug traces of what happens in either ASDF 1 or ASDF 2?

I can try. For now I made a much smaller .asd, whith a defsystem that looks like this:

(defsystem :matlispbug :components ((:unix-dso "alien code" :pathname "" :dso-name "libmatlisp" :components ((:alien-module "CPOLY" :pathname "lib-src/cpoly/" :components ((:fortran-source-file "cpoly"))))) (:file "packages") (:module "foreign-interface" :pathname "src/" :depends-on ("packages" "alien code") :components ((:file "f77-mangling") (:file "ffi-sbcl")))))

and that shows the behavior of interest. That is, with the new asdf, the module "foreign-interface" gets compiled every time I load the system, whereas under the old asdf that does not happen. From staring at the source of the .asd, I haven't been able to see what is wrong.

I have uploaded a tarball with an abridged (to reduce size) version of matlisp to common-lisp.net, in case anyone wants to try:

http://common-lisp.net/~mmommer/matlispasdfissue.tar.gz

The shortened .asd is called matlispbug.asd.

To readers in the future: I will remove the file as soon as this issue is resolved, and then this link will be broken.

Regards, and thanks,

Mario.

_______________________________________________ asdf-devel mailing list asdf-devel@common-lisp.net http://common-lisp.net/cgi-bin/mailman/listinfo/asdf-devel

_______________________________________________ asdf-devel mailing list asdf-devel@common-lisp.net http://common-lisp.net/cgi-bin/mailman/listinfo/asdf-devel

On 4/11/10 Apr 11 -10:28 AM, james anderson wrote:

good afternoon;

reading traverse is not my idea of a good time, but when i persevere, i do not arrive at the same conclusion.

Here is the logic as I understand it. I will cite line numbers. I wish I knew how to do this reliably --- I can only say that these numbers work for me as of this writing (git pull done). Jargon: I think of this as a tree walk, so use the term "node" and "component" interchangeably. Plan = return value of TRAVERSE; an ordered sequences (specifically a list) of Planops Planop = a piece of a plan: a dotted pair whose car is an operation and whose cdr is a component. 1. L1400: make sure we don't visit the same nodes in the tree > 1. If we have already visited this, skip. A pruned-op may be returned. Check for circular dependencies, and mark this node (component) as in progress (visiting). 2. loop at 1414: check all of the current nodes dependencies. This loop side-effects onto the local variable FORCED. FORCED is going to accumulate all the operations needed for this sub-plan (i.e., the part of the TRAVERSE plan that is generated from the current component). 3. 1421: block that is run only for the benefit of components of type MODULE (which includes SYSTEMs). Note that at the top we bind a number of variables, including the FORCED special, which is the only way to permit us to call do-one-dep here [someday, in my fantasy world, traverse will be rewritten to be purely functional and not side-effect onto FORCED everywhere.]. As a result of running the code in this block, we will bind the MODULE-OPS lexical variable, which tells us what operations need to be performed on the current module. 3.1 1428: MUST-OPERATE is bound to tell us whether the components of the current module must be operated on. The check is whether there is *FORCING* bound around us, or if the component is not a system. This is my attempt to see if the component IS a module simpliciter. [In my ideal world, ASDF would be refactored so that there are three classes --- HAS-COMPONENTS, MODULE and SYSTEM, and MODULE isa HAS-COMPONENTS and SYSTEM isa HAS-COMPONENTS but SYSTEM is no longer a sub-class of MODULE... Currently there is no really reliable way to tell that something is "just" an internal module, since the class hierarchy is mutable...]: (and (not (typep c 'system)) forced) recall that FORCED was bound earlier to the set of planops that must be performed on this node's dependencies. This was done for backward compatibility, and because we don't have good tests for a system being operated on. Space does not permit me to explain this here. Note that there is no check here for OPERATION-DONE-P on the module itself. That test is performed downstream. 3.2 1435: Foreach of the module's components, bind *FORCING* to MUST-OPERATE. This ensures that all the modules components will be operated on if any of the module's dependencies have changed. Then traverse each of the component's children, checking for component dependency failures. 4. 1456: If we have a module as our node, then we are done here operating on the module's components and are now working on the module object proper. So you see what I have been saying about the module object representing, at one and the same time, both the module as thing with components AND any post-operations on the module, after the operation has been done on its components (postorder tree traversal). 4.1 Do we need to operate on the object? OR: 1456: are there upstream operations done (FORCED) or were operations done on this components children (if any --- MODULE-OPS)? 1457: are all operations forced (*FORCING*)? 1458: is this operation as yet not done (OPERATION-DONE-P)? As you see, the OPERATION-DONE-P test on a module will be performed AFTER working on its children in step 3. Note that *it must be this way* for backward compatibility. This is a consequence of the double-meaning of MODULE. 1459 - 1470: A test that I do not understand and was too frightened of to remove or rewrite. 1471-1473: The op x component's DO-FIRSTs are processed. 1475-7: accumulate the return values. 1478-9: update the visiting logic 5. Mark the node as visited and return the sub-plan. I think this analysis bears out my claim. I can't pretend to respond to your experience with this particular system; I can't make MATLISPBUG run on my linux box. Currently, if I try to do load-system on it a second time, it crashes my lisp hard, taking down SLIME. I am updating SLIME and SBCL now, and will try again when I have time. Hope this analysis helps. Fare, maybe it would be worth writing an article about ASDF and the ASDF2-ing for ILC. This reconstruction might be an important part of such an article. best, r

On 4/11/10 Apr 11 -11:42 AM, Faré wrote:

1- Would making unix-dso a subclass of component but not of module somehow help solve the problem?

<blush>I didn't even carefully read the system definition --- I just dug in to trying to make it load. You are right --- I don't see any reason why this should be a subclass of module instead of component.</blush>

2- I admit I have little familiarity with TRAVERSE. Looking at it makes me shudder. I really don't want to try understanding it enough to be able to modify it in ways that I can say for sure will be backwards compatible with all previous reasonable uses. It's one of the reasons I'd rather spend time on XCVB.

Right. I /have/ tried to understand and modify it, and there are still a few corners that I truly don't understand.

3- To debug with a 32-bit implementation on a 64-bit architecture, give the -m32 flag to gcc. Dunno exactly about ld; same flag or different flag might be needed. Otherwise, you can install a 32-bit chroot installation and run stuff inside it.

Thanks.

4- Is there an ILC this year? Where, when? I could talk about ASDF 2, but I wouldn't be able to talk competently about TRAVERSE. If some kind soul would co-present a paper with me, we could do the whole thing.

I would be delighted to coauthor a paper with you about ASDF. I thought the ILC was going to be in Japan. If so, I'm sorry, but my back and height put Japan out of range by coach flight, so no co-presenting! But I've been dying for an excuse to go to Europe for a lisp symposium! ;-) Best, r

good evening; On 2010-04-11, at 18:04 , Robert Goldman wrote:

On 4/11/10 Apr 11 -10:28 AM, james anderson wrote:

...

good afternoon;

reading traverse is not my idea of a good time, but when i persevere, i do not arrive at the same conclusion.

Here is the logic as I understand it. I will cite line numbers. I wish I knew how to do this reliably --- I can only say that these numbers work for me as of this writing (git pull done).

Jargon: I think of this as a tree walk, so use the term "node" and "component" interchangeably. Plan = return value of TRAVERSE; an ordered sequences (specifically a list) of Planops Planop = a piece of a plan: a dotted pair whose car is an operation and whose cdr is a component.

[1. - 3. ok, but not directly relevant ]

4. 1456: If we have a module as our node, then we are done here operating on the module's components and are now working on the module object proper. So you see what I have been saying about the module object representing, at one and the same time, both the module as thing with components AND any post-operations on the module, after the operation has been done on its components (postorder tree traversal).

4.1 Do we need to operate on the object? OR: 1456: are there upstream operations done (FORCED) or were operations done on this components children (if any --- MODULE-OPS)?

this is where the module's spurious op planup causes the dependent to believe it needs a planop.

[ ... not relevant ] 1458: is this operation as yet not done (OPERATION-DONE-P)? As you see, the OPERATION-DONE-P test on a module will be performed AFTER working on its children in step 3. Note that *it must be this way* for backward compatibility. This is a consequence of the double- meaning of MODULE.

this is where the method for modules causes the module itself to add a planop.

[... also true, but not relevant]

Hope this analysis helps. Fare, maybe it would be worth writing an article about ASDF and the ASDF2-ing for ILC. This reconstruction might be an important part of such an article.

)) 5: (ASDF::TRAVERSE #<ASDF:LOAD-OP NIL {B545431}> #<MATLISP.SYSTEM::FORTRAN-SOURCE-FILE "cpoly" {B0F0AB1}>)

)) 2: (ASDF::TRAVERSE #<ASDF:LOAD-OP NIL {B4E07F1}> #<ASDF:CL-SOURCE-FILE "packages" {B0F0AC1}>) 2: ASDF::TRAVERSE returned NIL 2: (ASDF::TRAVERSE #<ASDF:LOAD-OP NIL {B4E07F1}> #<ASDF:CL-SOURCE-FILE "f77- mangling" {B0F0A81}>)

traverse reads as if the lines most pertinent to this issue are 1417-19, 1435-38, and 1456-58. strip everything else out. it is a straight depth-first walk to collect planops. we can neglect a true force, as none appears here. in which case, a planop is added for a given component depends if either one was added for a dependent (1419 through the recursion at 1334) or the component itself is not done. where modules are never done, they always generate planops. here is a transcript with probes of this sort: (format *trace-output* "~&traverse: (~a ~a) initially: ~s~%" (type-of operation) (asdf:component-name c) forced) added at lines 1407, 1456, and 1479 and tracing for traverse and perform. you will observer that, when the modules are never done, that contribute to spurious "forced" values for their dependents. * (asdf:load-system :matlispbug) 0: (ASDF::TRAVERSE #<ASDF:LOAD-OP NIL {B4E07F1}> #<ASDF:SYSTEM "matlispbug" {B046A99}>) traverse: (LOAD-OP matlispbug) initially: NIL 1: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:SYSTEM "matlispbug" {B046A99}>) traverse: (COMPILE-OP matlispbug) initially: NIL 2: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) traverse: (COMPILE-OP alien code) initially: NIL 3: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B4E58C9}> #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) traverse: (COMPILE-OP CPOLY) initially: NIL 4: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B4E58C9}> #<MATLISP.SYSTEM::FORTRAN-SOURCE-FILE "cpoly" {B0F0AB1}>) traverse: (COMPILE-OP cpoly) initially: NIL traverse: (COMPILE-OP cpoly) itself: NIL 5: (ASDF:OPERATION-DONE-P #<ASDF:COMPILE-OP NIL {B4E58C9}> #<MATLISP.SYSTEM::FORTRAN- SOURCE-FILE "cpoly" {B0F0AB1}>) 5: ASDF:OPERATION-DONE-P returned T traverse: (COMPILE-OP cpoly) result: NIL 4: ASDF::TRAVERSE returned NIL traverse: (COMPILE-OP CPOLY) itself: NIL 4: (ASDF:OPERATION-DONE-P #<ASDF:COMPILE-OP NIL {B4E58C9}> #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) 4: ASDF:OPERATION-DONE-P returned NIL traverse: (COMPILE-OP CPOLY) result: ((#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<MATLISP.SYSTEM::ALIEN- MODULE "CPOLY" {B0F0AA1}>)) 3: ASDF::TRAVERSE returned ((#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>)) traverse: (COMPILE-OP alien code) itself: NIL traverse: (COMPILE-OP alien code) result: ((#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>)) 2: ASDF::TRAVERSE returned ((#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>)) 2: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:CL-SOURCE-FILE "packages" {B0F0AC1}>) traverse: (COMPILE-OP packages) initially: NIL traverse: (COMPILE-OP packages) itself: NIL 3: (ASDF:OPERATION-DONE-P #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:CL-SOURCE-FILE "packages" {B0F0AC1}>) 3: ASDF:OPERATION-DONE-P returned T traverse: (COMPILE-OP packages) result: NIL 2: ASDF::TRAVERSE returned NIL 2: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:MODULE "foreign-interface" {B0F0A61}>) traverse: (COMPILE-OP foreign-interface) initially: NIL 3: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) 3: ASDF::TRAVERSE returned ((ASDF::PRUNED-OP . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>)) 3: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:CL-SOURCE-FILE "packages" {B0F0AC1}>) 3: ASDF::TRAVERSE returned NIL 3: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:CL-SOURCE-FILE "f77- mangling" {B0F0A81}>) traverse: (COMPILE-OP f77-mangling) initially: NIL traverse: (COMPILE-OP f77-mangling) itself: NIL traverse: (COMPILE-OP f77-mangling) result: ((#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "f77- mangling" {B0F0A81}>)) 3: ASDF::TRAVERSE returned ((#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "f77-mangling" {B0F0A81}>)) 3: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>) traverse: (COMPILE-OP ffi-sbcl) initially: NIL traverse: (COMPILE-OP ffi-sbcl) itself: NIL traverse: (COMPILE-OP ffi-sbcl) result: ((#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>)) 3: ASDF::TRAVERSE returned ((#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>)) traverse: (COMPILE-OP foreign-interface) itself: ((ASDF::PRUNED-OP . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>)) 3: (ASDF::TRAVERSE #<ASDF:LOAD-OP NIL {B5374F1}> #<ASDF:CL-SOURCE-FILE "packages" {B0F0AC1}>) traverse: (LOAD-OP packages) initially: NIL 4: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B539A09}> #<ASDF:CL-SOURCE-FILE "packages" {B0F0AC1}>) 4: ASDF::TRAVERSE returned NIL traverse: (LOAD-OP packages) itself: NIL 4: (ASDF:OPERATION-DONE-P #<ASDF:LOAD-OP NIL {B5374F1}> #<ASDF:CL-SOURCE-FILE "packages" {B0F0AC1}>) 4: ASDF:OPERATION-DONE-P returned T traverse: (LOAD-OP packages) result: NIL 3: ASDF::TRAVERSE returned NIL 3: (ASDF::TRAVERSE #<ASDF:LOAD-OP NIL {B545431}> #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) traverse: (LOAD-OP alien code) initially: NIL 4: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B547A09}> #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) 4: ASDF::TRAVERSE returned ((ASDF::PRUNED-OP . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>)) 4: (ASDF::TRAVERSE #<ASDF:LOAD-OP NIL {B545431}> #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) traverse: (LOAD-OP CPOLY) initially: NIL 5: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B54D5C1}> #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) 5: ASDF::TRAVERSE returned ((ASDF::PRUNED-OP . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1} traverse: (LOAD-OP cpoly) initially: NIL 6: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B5531D9}> #<MATLISP.SYSTEM::FORTRAN-SOURCE- FILE "cpoly" {B0F0AB1}>) 6: ASDF::TRAVERSE returned NIL traverse: (LOAD-OP cpoly) itself: NIL traverse: (LOAD-OP cpoly) result: ((#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::FORTRAN- SOURCE-FILE "cpoly" {B0F0AB1}>)) 5: ASDF::TRAVERSE returned ((#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::FORTRAN-SOURCE-FILE "cpoly" {B0F0AB1}>)) traverse: (LOAD-OP CPOLY) itself: ((ASDF::PRUNED-OP . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>)) traverse: (LOAD-OP CPOLY) result: ((#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::FORTRAN- SOURCE-FILE "cpoly" {B0F0AB1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>)) 4: ASDF::TRAVERSE returned ((#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::FORTRAN-SOURCE-FILE "cpoly" {B0F0AB1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>)) traverse: (LOAD-OP alien code) itself: ((ASDF::PRUNED-OP . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>)) traverse: (LOAD-OP alien code) result: ((#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::FORTRAN- SOURCE-FILE "cpoly" {B0F0AB1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::ALIEN- MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>)) 3: ASDF::TRAVERSE returned ((#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::FORTRAN-SOURCE-FILE "cpoly" {B0F0AB1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>)) traverse: (COMPILE-OP foreign-interface) result: ((#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::FORTRAN-SOURCE-FILE "cpoly" {B0F0AB1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL- SOURCE-FILE "f77-mangling" {B0F0A81}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL- SOURCE-FILE "ffi- sbcl" {B0F0A71}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:MODULE "foreign- interface" {B0F0A61}>)) 2: ASDF::TRAVERSE returned ((#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::FORTRAN-SOURCE-FILE "cpoly" {B0F0AB1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "f77-mangling" {B0F0A81}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:MODULE "foreign-interface" {B0F0A61}>)) traverse: (COMPILE-OP matlispbug) itself: NIL traverse: (COMPILE-OP matlispbug) result: ((#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::FORTRAN-SOURCE-FILE "cpoly" {B0F0AB1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "f77- mangling" {B0F0A81}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:MODULE "foreign- interface" {B0F0A61}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:SYSTEM "matlispbug" {B046A99}>)) 1: ASDF::TRAVERSE returned ((#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::FORTRAN-SOURCE-FILE "cpoly" {B0F0AB1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "f77-mangling" {B0F0A81}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:MODULE "foreign-interface" {B0F0A61}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:SYSTEM "matlispbug" {B046A99}>)) 1: (ASDF::TRAVERSE #<ASDF:LOAD-OP NIL {B4E07F1}> #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) 1: ASDF::TRAVERSE returned ((ASDF::PRUNED-OP . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>)) 1: (ASDF::TRAVERSE #<ASDF:LOAD-OP NIL {B4E07F1}> #<ASDF:CL-SOURCE-FILE "packages" {B0F0AC1}>) 1: ASDF::TRAVERSE returned NIL 1: (ASDF::TRAVERSE #<ASDF:LOAD-OP NIL {B4E07F1}> #<ASDF:MODULE "foreign-interface" {B0F0A61}>) traverse: (LOAD-OP foreign-interface) initially: NIL 2: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B57BE41}> #<ASDF:MODULE "foreign-interface" {B0F0A61}>) 2: ASDF::TRAVERSE returned ((ASDF::PRUNED-OP . #<ASDF:MODULE "foreign- interface" {B0F0A61}>)) 2: (ASDF::TRAVERSE #<ASDF:LOAD-OP NIL {B4E07F1}> #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) 2: ASDF::TRAVERSE returned ((ASDF::PRUNED-OP . #<ASDF:UNIX-DSO "alien code" {B0F0A91} traverse: (LOAD-OP f77-mangling) initially: NIL 3: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B587069}> #<ASDF:CL-SOURCE-FILE "f77- mangling" {B0F0A81}>) 3: ASDF::TRAVERSE returned ((ASDF::PRUNED-OP . #<ASDF:CL-SOURCE-FILE "f77-mangling" {B0F0A81}>)) traverse: (LOAD-OP f77-mangling) itself: ((ASDF::PRUNED-OP . #<ASDF:CL-SOURCE-FILE "f77- mangling" {B0F0A81}>)) traverse: (LOAD-OP f77-mangling) result: ((#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:CL-SOURCE-FILE "f77- mangling" {B0F0A81}>)) 2: ASDF::TRAVERSE returned ((#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:CL-SOURCE-FILE "f77-mangling" {B0F0A81}>)) 2: (ASDF::TRAVERSE #<ASDF:LOAD-OP NIL {B4E07F1}> #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>) traverse: (LOAD-OP ffi-sbcl) initially: NIL 3: (ASDF::TRAVERSE #<ASDF:COMPILE-OP NIL {B5907D1}> #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>) 3: ASDF::TRAVERSE returned ((ASDF::PRUNED-OP . #<ASDF:CL-SOURCE-FILE "ffi- sbcl" {B0F0A71}>)) traverse: (LOAD-OP ffi-sbcl) itself: ((ASDF::PRUNED-OP . #<ASDF:CL-SOURCE-FILE "ffi- sbcl" {B0F0A71}>)) traverse: (LOAD-OP ffi-sbcl) result: ((#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:CL-SOURCE-FILE "ffi- sbcl" {B0F0A71}>)) 2: ASDF::TRAVERSE returned ((#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>)) traverse: (LOAD-OP foreign-interface) itself: ((ASDF::PRUNED-OP . #<ASDF:MODULE "foreign-interface" {B0F0A61}>) (ASDF::PRUNED-OP . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>)) traverse: (LOAD-OP foreign-interface) result: ((#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:CL-SOURCE-FILE "f77- mangling" {B0F0A81}>) (#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:CL-SOURCE-FILE "ffi- sbcl" {B0F0A71}>) (#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:MODULE "foreign-interface" {B0F0A61}>)) 1: ASDF::TRAVERSE returned ((#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:CL-SOURCE-FILE "f77-mangling" {B0F0A81}>) (#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>) (#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:MODULE "foreign-interface" {B0F0A61}>)) traverse: (LOAD-OP matlispbug) itself: ((#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<MATLISP.SYSTEM::ALIEN- MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::FORTRAN- SOURCE-FILE "cpoly" {B0F0AB1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::ALIEN- MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "f77-mangling" {B0F0A81}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:MODULE "foreign- interface" {B0F0A61}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:SYSTEM "matlispbug" {B046A99}>)) traverse: (LOAD-OP matlispbug) result: ((#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<MATLISP.SYSTEM::ALIEN- MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::FORTRAN- SOURCE-FILE "cpoly" {B0F0AB1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::ALIEN- MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "f77-mangling" {B0F0A81}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:MODULE "foreign- interface" {B0F0A61}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:SYSTEM "matlispbug" {B046A99}>) (#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:CL-SOURCE-FILE "f77-mangling" {B0F0A81}>) (#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>) (#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:MODULE "foreign- interface" {B0F0A61}>) (#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:SYSTEM "matlispbug" {B046A99}>)) 0: ASDF::TRAVERSE returned ((#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::FORTRAN-SOURCE-FILE "cpoly" {B0F0AB1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) (#<ASDF:LOAD-OP NIL {B545431}> . #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "f77-mangling" {B0F0A81}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:MODULE "foreign-interface" {B0F0A61}>) (#<ASDF:COMPILE-OP NIL {B4E58C9}> . #<ASDF:SYSTEM "matlispbug" {B046A99}>) (#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:CL-SOURCE-FILE "f77-mangling" {B0F0A81}>) (#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>) (#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:MODULE "foreign-interface" {B0F0A61}>) (#<ASDF:LOAD-OP NIL {B4E07F1}> . #<ASDF:SYSTEM "matlispbug" {B046A99}>)) 0: (ASDF:PERFORM #<ASDF:COMPILE-OP NIL {B4E58C9}> #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) 0: ASDF:PERFORM returned NIL 0: (ASDF:PERFORM #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) 1: (ASDF:OPERATION-DONE-P #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) 1: ASDF:OPERATION-DONE-P returned T 0: ASDF:PERFORM returned NIL 0: (ASDF:PERFORM #<ASDF:LOAD-OP NIL {B545431}> #<MATLISP.SYSTEM::FORTRAN-SOURCE-FILE "cpoly" {B0F0AB1}>) 0: ASDF:PERFORM returned T 0: (ASDF:PERFORM #<ASDF:LOAD-OP NIL {B545431}> #<MATLISP.SYSTEM::ALIEN-MODULE "CPOLY" {B0F0AA1}>) 0: ASDF:PERFORM returned NIL 0: (ASDF:PERFORM #<ASDF:LOAD-OP NIL {B545431}> #<ASDF:UNIX-DSO "alien code" {B0F0A91}>) 0: ASDF:PERFORM returned #P"/home/asdf/.cache/common-lisp/sbcl-1.0.36-linux-x86/ebs/ source/upload/net/common-lisp/matlisp/libmatlisp.so" 0: (ASDF:PERFORM #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:CL-SOURCE-FILE "f77-mangling" {B0F0A81}>) ; compiling file "/ebs/source/upload/net/common-lisp/matlisp/src/f77- mangling.lisp" (written 18 MAR 2010 10:22:00 PM): ; compiling (IN-PACKAGE "FORTRAN-FFI-ACCESSORS") ; compiling (DEFCONSTANT +F77-LOWER-CASE+ ...) ; compiling (DEFCONSTANT +F77-UNDERSCORE+ ...) ; compiling (DEFCONSTANT +F77-EXTRA-UNDERSCORE+ ...) ; compiling (DEFUN %CAT% ...) ; compiling (DEFUN SCAT ...) ; compiling (DEFUN MAKE-FORTRAN-FFI-NAME ...) ; compiling (DEFUN MAKE-FORTRAN-NAME ...) ; file: /ebs/source/upload/net/common-lisp/matlisp/src/f77-mangling.lisp ; in: DEFUN MAKE-FORTRAN-NAME ; (IF FORTRAN-FFI-ACCESSORS::+F77-UNDERSCORE+ ; "_" ; "") ; ==> ; "" ; ; note: deleting unreachable code ; (AND FORTRAN-FFI-ACCESSORS::+F77-EXTRA-UNDERSCORE+ ; FORTRAN-FFI-ACCESSORS::INTERNAL-UNDERSCORE-P) ; --> IF AND THE ; ==> ; FORTRAN-FFI-ACCESSORS::INTERNAL-UNDERSCORE-P ; ; note: deleting unreachable code ; (IF (AND FORTRAN-FFI-ACCESSORS::+F77-EXTRA-UNDERSCORE+ ; FORTRAN-FFI-ACCESSORS::INTERNAL-UNDERSCORE-P) ; "_" ; "") ; ==> ; "_" ; ; note: deleting unreachable code ; (IF FORTRAN-FFI-ACCESSORS::+F77-LOWER-CASE+ ; (STRING-DOWNCASE FORTRAN-FFI-ACCESSORS::NAME) ; FORTRAN-FFI-ACCESSORS::NAME) ; ==> ; FORTRAN-FFI-ACCESSORS::NAME ; ; note: deleting unreachable code ; /home/asdf/.cache/common-lisp/sbcl-1.0.36-linux-x86/ebs/source/ upload/net/common-lisp/matlisp/src/f77-mangling.fasl written ; compilation finished in 0:00:00.036 0: ASDF:PERFORM returned NIL 0: (ASDF:PERFORM #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>) ; compiling file "/ebs/source/upload/net/common-lisp/matlisp/src/ffi- sbcl.lisp" (written 18 MAR 2010 10:21:59 PM): ; compiling (IN-PACKAGE "FORTRAN-FFI-ACCESSORS") ; compiling (DEFUN PARSE-DOC-&-PARAMETERS ...) ; compiling (DEFUN CAST-AS-ARRAY-P ...) ; compiling (DEFUN GET-READ-IN-TYPE ...) ; compiling (DEFUN GET-READ-OUT-TYPE ...) ; compiling (DEFUN GET-READ-IN-STYLE ...) ; compiling (DEFUN GET-READ-OUT-STYLE ...) ; compiling (DEFUN PARSE-FORTRAN-PARAMETERS ...) ; compiling (DEFUN DEF-FORTRAN-INTERFACE ...) ; compiling (DEFMACRO DEF-FORTRAN-ROUTINE ...) ; compiling (DEFMACRO INCF-SAP ...) ; compiling (DEFTYPE MATLISP-SPECIALIZED-ARRAY ...) ; compiling (DECLAIM (INLINE VECTOR-DATA-ADDRESS)) ; compiling (DEFUN VECTOR-DATA-ADDRESS ...) ; compiling (DEFMACRO WITH-FORTRAN-FLOAT-MODES ...) ; compiling (DEFMACRO WITH-VECTOR-DATA-ADDRESSES ...) ; compiling (DEFMACRO WITH-GENSYMS ...) ; /home/asdf/.cache/common-lisp/sbcl-1.0.36-linux-x86/ebs/source/ upload/net/common-lisp/matlisp/src/ffi-sbcl.fasl written ; compilation finished in 0:00:00.652 0: ASDF:PERFORM returned NIL 0: (ASDF:PERFORM #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:MODULE "foreign-interface" {B0F0A61}>) 0: ASDF:PERFORM returned NIL 0: (ASDF:PERFORM #<ASDF:COMPILE-OP NIL {B4E58C9}> #<ASDF:SYSTEM "matlispbug" {B046A99}>) 0: ASDF:PERFORM returned NIL 0: (ASDF:PERFORM #<ASDF:LOAD-OP NIL {B4E07F1}> #<ASDF:CL-SOURCE-FILE "f77-mangling" {B0F0A81}>) 0: ASDF:PERFORM returned (T) 0: (ASDF:PERFORM #<ASDF:LOAD-OP NIL {B4E07F1}> #<ASDF:CL-SOURCE-FILE "ffi-sbcl" {B0F0A71}>) 0: ASDF:PERFORM returned (T) 0: (ASDF:PERFORM #<ASDF:LOAD-OP NIL {B4E07F1}> #<ASDF:MODULE "foreign-interface" {B0F0A61}>) 0: ASDF:PERFORM returned NIL 0: (ASDF:PERFORM #<ASDF:LOAD-OP NIL {B4E07F1}> #<ASDF:SYSTEM "matlispbug" {B046A99}>) 0: ASDF:PERFORM returned NIL ; ; compilation unit finished ; printed 4 notes #<ASDF:LOAD-OP NIL {B4E07F1}> *

On 4/11/10 Apr 11 -12:47 PM, Mario S. Mommer wrote:

Hello,

I was wondering - what is the working hypothesis? Is this a bug in the .asd or a bug in the new version of asdf? :-)

I still can't get this to run twice (whether or not with an excess recompile) --- running it twice causes what seems like an unrelated crash. This is SBCL 1.0.37.57 on linux x86_64. The first load-system completes successfully; the second gives me the following transcript. I'm more than happy to help debug ASDF issues, but I don't understand the crash I'm getting here, and it doesn't seem to be ASDF-related. I don't understand why SB-ACLREPL is on the stack, either. I made sure that I wasn't loading it, and then just to be doubly-sure, I retried using sbcl --no-userinit, and got a similar (but not identical) crash. So it's not my .sbclrc, and it's not SLIME --- I get this behavior running SBCL from a shell. The error is just different (see further down). Error transcript using my normal SBCL, at the shell: CL-USER(5): (asdf:load-system :matlispbug) ; compiling file "/home/rpg/lisp/matlisp/src/f77-mangling.lisp" (written 11 APR 2010 10:30:03 AM): ; compiling (IN-PACKAGE "FORTRAN-FFI-ACCESSORS") ; compiling (DEFCONSTANT +F77-LOWER-CASE+ ...) ; compiling (DEFCONSTANT +F77-UNDERSCORE+ ...) ; compiling (DEFCONSTANT +F77-EXTRA-UNDERSCORE+ ...) ; compiling (DEFUN %CAT% ...) ; compiling (DEFUN SCAT ...) ; compiling (DEFUN MAKE-FORTRAN-FFI-NAME ...) ; compiling (DEFUN MAKE-FORTRAN-NAME ...) ; file: /home/rpg/lisp/matlisp/src/f77-mangling.lisp ; in: DEFUN MAKE-FORTRAN-NAME ; (IF FORTRAN-FFI-ACCESSORS::+F77-UNDERSCORE+ ; "_" ; "") ; ==> ; "_" ; ; note: deleting unreachable code ; (AND FORTRAN-FFI-ACCESSORS::+F77-EXTRA-UNDERSCORE+ ; FORTRAN-FFI-ACCESSORS::INTERNAL-UNDERSCORE-P) ; --> IF AND THE ; ==> ; FORTRAN-FFI-ACCESSORS::INTERNAL-UNDERSCORE-P ; ; note: deleting unreachable code ; (IF (AND FORTRAN-FFI-ACCESSORS::+F77-EXTRA-UNDERSCORE+ ; FORTRAN-FFI-ACCESSORS::INTERNAL-UNDERSCORE-P) ; "_" ; "") ; ==> ; "_" ; ; note: deleting unreachable code ; (IF FORTRAN-FFI-ACCESSORS::+F77-LOWER-CASE+ ; (STRING-DOWNCASE FORTRAN-FFI-ACCESSORS::NAME) ; FORTRAN-FFI-ACCESSORS::NAME) ; ==> ; FORTRAN-FFI-ACCESSORS::NAME ; ; note: deleting unreachable code ; /home/rpg/.cache/common-lisp/sbcl-1.0.37.57-linux-x86-64/home/rpg/lisp/matlisp/src/f77-mangling.fasl written ; compilation finished in 0:00:00.015 ; compiling file "/home/rpg/lisp/matlisp/src/ffi-sbcl.lisp" (written 18 MAR 2010 05:21:59 PM): ; compiling (IN-PACKAGE "FORTRAN-FFI-ACCESSORS") ; compiling (DEFUN PARSE-DOC-&-PARAMETERS ...) ; compiling (DEFUN CAST-AS-ARRAY-P ...) ; compiling (DEFUN GET-READ-IN-TYPE ...) ; compiling (DEFUN GET-READ-OUT-TYPE ...) ; compiling (DEFUN GET-READ-IN-STYLE ...) ; compiling (DEFUN GET-READ-OUT-STYLE ...) ; compiling (DEFUN PARSE-FORTRAN-PARAMETERS ...) ; compiling (DEFUN DEF-FORTRAN-INTERFACE ...) ; compiling (DEFMACRO DEF-FORTRAN-ROUTINE ...) ; compiling (DEFMACRO INCF-SAP ...) ; compiling (DEFTYPE MATLISP-SPECIALIZED-ARRAY ...) ; compiling (DECLAIM (INLINE VECTOR-DATA-ADDRESS)) ; compiling (DEFUN VECTOR-DATA-ADDRESS ...) ; compiling (DEFMACRO WITH-FORTRAN-FLOAT-MODES ...) ; compiling (DEFMACRO WITH-VECTOR-DATA-ADDRESSES ...) ; compiling (DEFMACRO WITH-GENSYMS ...) ; /home/rpg/.cache/common-lisp/sbcl-1.0.37.57-linux-x86-64/home/rpg/lisp/matlisp/src/ffi-sbcl.fasl written ; compilation finished in 0:00:00.104 ; ; compilation unit finished ; printed 4 notes #<ASDF:LOAD-OP NIL {1003BE9C31}> CL-USER(5): debugger invoked on a SB-INT:SIMPLE-STREAM-ERROR in thread #<THREAD "initial thread" RUNNING {1002AB6031}>: couldn't check whether #<SB-SYS:FD-STREAM for "standard input" {1002AB65F1}> is readable: Bad file descriptor Type HELP for debugger help, or (SB-EXT:QUIT) to exit from SBCL. restarts (invokable by number or by possibly-abbreviated name): 0: [ABORT] Exit debugger, returning to top level. (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't check whether ~S is readable" #<SB-SYS:FD-STREAM for "standard input" {1002AB65F1}> 9) 0] backtrace 0: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't check whether ~S is readable" #<SB-SYS:FD-STREAM for "standard input" {1002AB65F1}> 9) 1: (SB-IMPL::SYSREAD-MAY-BLOCK-P #<SB-SYS:FD-STREAM for "standard input" {1002AB65F1}>) 2: (SB-IMPL::REFILL-INPUT-BUFFER #<SB-SYS:FD-STREAM for "standard input" {1002AB65F1}>) 3: (SB-IMPL::INPUT-CHAR/UTF-8 #<SB-SYS:FD-STREAM for "standard input" {1002AB65F1}> NIL :EOF) 4: ((LAMBDA (&REST REST)) #<SB-SYS:FD-STREAM for "standard input" {1002AB65F1}> NIL :EOF) 5: ((LAMBDA (&REST REST)) #<SB-SYS:FD-STREAM for "standard input" {1002AB65F1}> NIL :EOF)[:OPTIONAL] 6: (READ-CHAR #<SB-SYS:FD-STREAM for "standard input" {1002AB65F1}> NIL :EOF #<unused argument>) 7: (PEEK-CHAR NIL #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDIN* {100019E381}> NIL :EOF #<unused argument>) 8: (SB-ACLREPL::PEEK-CHAR-NON-WHITESPACE #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDIN* {100019E381}>) 9: (SB-ACLREPL::READ-CMD #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDIN* {100019E381}>) 10: (SB-ACLREPL::REPL-READ-FORM-FUN #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDIN* {100019E381}> #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDOUT* {10001DAAB1}>) 11: (SB-ACLREPL::REP-ONE) 12: (SB-ACLREPL::REPL)[:EXTERNAL] 13: ((LAMBDA (SB-ACLREPL::NOPRINT)) NIL) 14: ((LAMBDA ())) 15: (SB-IMPL::%WITH-REBOUND-IO-SYNTAX #<CLOSURE (LAMBDA #) {1002BA7679}>) 16: (SB-IMPL::TOPLEVEL-REPL NIL) 17: (SB-IMPL::TOPLEVEL-INIT) 18: ((LABELS SB-IMPL::RESTART-LISP)) 0] The first load-system gave me this: CL-USER(4): (asdf:load-system :matlispbug) ; loading system definition from /home/rpg/lisp/matlisp/matlispbug.asd into ; #<PACKAGE "ASDF0"> ; registering #<SYSTEM :MATLISPBUG {1003A24391}> as MATLISPBUG WARNING: Redefining DEFTYPE type to be a class: REAL ; compiling file "/home/rpg/lisp/matlisp/src/f77-mangling.lisp" (written 11 APR 2010 10:30:03 AM): ; compiling (IN-PACKAGE "FORTRAN-FFI-ACCESSORS") ; compiling (DEFCONSTANT +F77-LOWER-CASE+ ...) ; compiling (DEFCONSTANT +F77-UNDERSCORE+ ...) ; compiling (DEFCONSTANT +F77-EXTRA-UNDERSCORE+ ...) ; compiling (DEFUN %CAT% ...) ; compiling (DEFUN SCAT ...) ; compiling (DEFUN MAKE-FORTRAN-FFI-NAME ...) ; compiling (DEFUN MAKE-FORTRAN-NAME ...) ; file: /home/rpg/lisp/matlisp/src/f77-mangling.lisp ; in: DEFUN MAKE-FORTRAN-NAME ; (IF FORTRAN-FFI-ACCESSORS::+F77-UNDERSCORE+ ; "_" ; "") ; ==> ; "_" ; ; note: deleting unreachable code ; (AND FORTRAN-FFI-ACCESSORS::+F77-EXTRA-UNDERSCORE+ ; FORTRAN-FFI-ACCESSORS::INTERNAL-UNDERSCORE-P) ; --> IF AND THE ; ==> ; FORTRAN-FFI-ACCESSORS::INTERNAL-UNDERSCORE-P ; ; note: deleting unreachable code ; (IF (AND FORTRAN-FFI-ACCESSORS::+F77-EXTRA-UNDERSCORE+ ; FORTRAN-FFI-ACCESSORS::INTERNAL-UNDERSCORE-P) ; "_" ; "") ; ==> ; "_" ; ; note: deleting unreachable code ; (IF FORTRAN-FFI-ACCESSORS::+F77-LOWER-CASE+ ; (STRING-DOWNCASE FORTRAN-FFI-ACCESSORS::NAME) ; FORTRAN-FFI-ACCESSORS::NAME) ; ==> ; FORTRAN-FFI-ACCESSORS::NAME ; ; note: deleting unreachable code ; /home/rpg/.cache/common-lisp/sbcl-1.0.37.57-linux-x86-64/home/rpg/lisp/matlisp/src/f77-mangling.fasl written ; compilation finished in 0:00:00.015 ; compiling file "/home/rpg/lisp/matlisp/src/ffi-sbcl.lisp" (written 18 MAR 2010 05:21:59 PM): ; compiling (IN-PACKAGE "FORTRAN-FFI-ACCESSORS") ; compiling (DEFUN PARSE-DOC-&-PARAMETERS ...) ; compiling (DEFUN CAST-AS-ARRAY-P ...) ; compiling (DEFUN GET-READ-IN-TYPE ...) ; compiling (DEFUN GET-READ-OUT-TYPE ...) ; compiling (DEFUN GET-READ-IN-STYLE ...) ; compiling (DEFUN GET-READ-OUT-STYLE ...) ; compiling (DEFUN PARSE-FORTRAN-PARAMETERS ...) ; compiling (DEFUN DEF-FORTRAN-INTERFACE ...) ; compiling (DEFMACRO DEF-FORTRAN-ROUTINE ...) ; compiling (DEFMACRO INCF-SAP ...) ; compiling (DEFTYPE MATLISP-SPECIALIZED-ARRAY ...) ; compiling (DECLAIM (INLINE VECTOR-DATA-ADDRESS)) ; compiling (DEFUN VECTOR-DATA-ADDRESS ...) ; compiling (DEFMACRO WITH-FORTRAN-FLOAT-MODES ...) ; compiling (DEFMACRO WITH-VECTOR-DATA-ADDRESSES ...) ; compiling (DEFMACRO WITH-GENSYMS ...) ; /home/rpg/.cache/common-lisp/sbcl-1.0.37.57-linux-x86-64/home/rpg/lisp/matlisp/src/ffi-sbcl.fasl written ; compilation finished in 0:00:00.118 ; ; compilation unit finished ; printed 4 notes #<ASDF:LOAD-OP NIL {10035B43B1}> Error transcript using --no-userinit: * debugger invoked on a SB-INT:SIMPLE-STREAM-ERROR in thread #<THREAD "initial thread" RUNNING {1002AB6101}>: couldn't check whether #<SB-SYS:FD-STREAM for "standard input" {1002AB66C1}> is readable: Bad file descriptor Type HELP for debugger help, or (SB-EXT:QUIT) to exit from SBCL. restarts (invokable by number or by possibly-abbreviated name): 0: [ABORT] Exit debugger, returning to top level. (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't check whether ~S is readable" #<SB-SYS:FD-STREAM for "standard input" {1002AB66C1}> 9) 0] backtrace 0: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't check whether ~S is readable" #<SB-SYS:FD-STREAM for "standard input" {1002AB66C1}> 9) 1: (SB-IMPL::SYSREAD-MAY-BLOCK-P #<SB-SYS:FD-STREAM for "standard input" {1002AB66C1}>) 2: (SB-IMPL::REFILL-INPUT-BUFFER #<SB-SYS:FD-STREAM for "standard input" {1002AB66C1}>) 3: (SB-IMPL::INPUT-CHAR/UTF-8 #<SB-SYS:FD-STREAM for "standard input" {1002AB66C1}> NIL #:EOF-OBJECT) 4: ((LAMBDA (&REST REST)) #<SB-SYS:FD-STREAM for "standard input" {1002AB66C1}> NIL #:EOF-OBJECT) 5: ((LAMBDA (&REST REST)) #<SB-SYS:FD-STREAM for "standard input" {1002AB66C1}> NIL #:EOF-OBJECT)[:OPTIONAL] 6: (READ-CHAR #<SB-SYS:FD-STREAM for "standard input" {1002AB66C1}> NIL #:EOF-OBJECT #<unused argument>) 7: (READ-CHAR #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDIN* {100019E381}> NIL #:EOF-OBJECT #<unused argument>) 8: (SB-IMPL::%READ-PRESERVING-WHITESPACE #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDIN* {100019E381}> NIL (NIL) T) 9: (SB-IMPL::%READ-PRESERVING-WHITESPACE #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDIN* {100019E381}> NIL (NIL) NIL) 10: (READ #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDIN* {100019E381}> NIL (NIL) NIL) 11: (SB-IMPL::REPL-READ-FORM-FUN #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDIN* {100019E381}> #<unavailable argument>) 12: (SB-IMPL::REPL-FUN NIL) 13: ((LAMBDA ())) 14: (SB-IMPL::%WITH-REBOUND-IO-SYNTAX #<CLOSURE (LAMBDA #) {1002AB99F9}>) 15: (SB-IMPL::TOPLEVEL-REPL NIL) 16: (SB-IMPL::TOPLEVEL-INIT) 17: ((LABELS SB-IMPL::RESTART-LISP)) 0] Best, r

On 4/11/10 Apr 11 -2:51 PM, Mario S. Mommer wrote:

Hi,

The error with the fd-stream is ignorable. In slime just let the buffer with C-x 1 while in the repl, and that's it. As far as I know, that is a gfortran bug that is not there in the next version. If you bury the buffer with that error you can continue to work without trouble. Strange, but true. I've been doing that for about a year :-)

If that does not work, I'll attempt to do a lisp-only or some other non-fd-crashing thing.

(re aclrepl: maybe you built sbcl with sb-aclrepl?)

There seems to be a lot of contingent stuff here that may be obscuring any ASDF issues. Question: is it possible to get an analogous issue using only lisp files? Thanks, r

On 2010-04-11, at 21:57 , Robert Goldman wrote:

On 4/11/10 Apr 11 -2:51 PM, Mario S. Mommer wrote:

...

Hi,

The error with the fd-stream is ignorable. In slime just let the buffer with C-x 1 while in the repl, and that's it. As far as I know, that is a gfortran bug that is not there in the next version. If you bury the buffer with that error you can continue to work without trouble. Strange, but true. I've been doing that for about a year :-)

If that does not work, I'll attempt to do a lisp-only or some other non-fd-crashing thing.

(re aclrepl: maybe you built sbcl with sb-aclrepl?)

There seems to be a lot of contingent stuff here that may be obscuring any ASDF issues.

Question: is it possible to get an analogous issue using only lisp files?

not in the standard configuration. the unix-dso has output files, which result causes operation-done-p to assert that it is never done. a vanilla module does not. however, take the matlispbug system definition, - strip out everything except the file, components, and module terms, - declare all the files to be :file, declare all the modules to be :module, - make the proper arrangements in the file system, _and_ add a gratuitous in-line output-files method to the initial modules to return a list of files, and you will observe that an operation gets carried through dependency on the module.

On 4/11/10 Apr 11 -10:06 AM, Robert Goldman wrote:

Trying to test this now, on my linux box, but am having problems. I'd like to use ACL, which has a debugger I'm more familiar with, but have 32-bit ACL on a 64-bit linux. Even installing 32-bit gnu fortran, I get a failure, probably because the makefile is detecting that I have a 64-bit OS.

If you can help me through this, I might be able to solve your ASDF problems.

best, r

Do you think you could publish a version of this that is loadable on ACL? The current version has sb-alien:: package hard-coded into the .asd file.... I'll have a whack at this with SBCL, but I'm substantially crippled by my lack of familiarity with SBCL's debugger and with SLIME.... thanks, r

On 4/11/10 Apr 11 -12:45 PM, Mario S. Mommer wrote:

Hi Robert,

Robert Goldman <rpgoldman@sift.info> writes:

...

Do you think you could publish a version of this that is loadable on ACL?

The current version has sb-alien:: package hard-coded into the .asd file....

the only line wehere sb-alien is used is on line 102 of matlispbug.asd. If you comment out that line (and close parentheses appropriately) and it should "work" everywhere. Up to stuff in the actual files to be loaded.

Tried this, putting #+sbcl in front of the sb-alien call and #+allegro (load ...) in, since ACL docs say to load .so files with LOAD. This crashes for me for a reason we discussed earlier --- ASDF tries to find the .so file in the cache created by asdf-output-translations, rather than where-ever it should be.... This may be my fault for using ACL/problem with the fortran compilation. With ACL, because of the punitive pricing on 64-bit versions, you can't count on the user having a 64-bit lisp on his/her 64-bit OS. So on ACL at least (possibly other lisps, as well?) need to ask the lisp if it's 32 or 64-bit and then compile the fortran accordingly. Is that right? I'm old, but not old enough ever to have used fortran ;-) r