I got your email about the error message issue so I'll remove my reply to that part :).
%% "Mike Maxwell" <[EMAIL PROTECTED]> writes: >> Given your description of what happened, the >> error message make printed would have been some form of: >> >> No rule to make target `XXX'. >> >> IMO that message is much clearer than what you wrote above. mm> I'll agree with that last statement. Unfortunately, that's not mm> what 'make' did, and that's the point of my original msg. It would have printed that, if your rule had been an explicit rule like the example you showed in your email. Since your _real_ makefile used a completely different implementation than the example in your email, it's not surprising that you won't get the same messages. >> As Noel pointed out, if this is _REALLY_ what your makefile said then >> make would have told you that it didn't know how to build foo.ReadMe. mm> Again, I agree. For the record, here's the line in my makefile (minus a mm> comment at the end that makes it wrap in email): mm> tarsets/%.stage2.tgz: stage2/% %.mchist %.ID %.ReadMe Right, just as I said: >> From your description of what happened, I believe that you really had >> defined an implicit rule here, rather than an explicit rule as your >> example shows. In your original email you showed an explicit rule: > foo.bar: foo.baz foo.ReadMe Now we see, in this mail, that you didn't have an explicit rule in your makefile at all, you had an _implicit_ (pattern) rule: > tarsets/%.stage2.tgz: stage2/% %.mchist %.ID %.ReadMe The way these resolve is very different, so that change between what you actually did and what you told us you did makes all the difference in the world. Thus, my request to not paraphrase your errors and your makefile and instead post the _real_ text of the error and the _real_ rule in your makefile. Paraphrasing just leads to confusion. An explicit rule says "here make, this is how you build foo.bar". If make can't solve _that exact rule_, it will fail. Make knows that it _MUST_ build foo.ReadMe since it's a prerequisite of an explicit rule. If make can't build foo.ReadMe, it will say: No rule to make target 'foo.ReadMe', needed by 'foo.bar'. But, you had an implicit rule. An implicit rule shows _one possible way_ that a target could be built. More than one implicit rule can and usually will match that target. Make can't know that _this_ particular explicit rule is the one that should have matched, and it can't print errors about each rule that doesn't match: you'd get dozens of error messages printed before it found one that matched! At the end, if none of the rules matched, the best it can say is "I looked, but I can't find any instructions on how to build this", which is what "No rule to build ..." means. How can make know which of the many ways it tried to build the target was the one that you think should have worked? >> Make output doesn't print "failed", but you know it failed because >> it went on to continue looking for another rule to match. mm> Yes, but that requires a lot of sifting through and interpreting mm> of output to figure out; whereas if it output 'failed' when it mm> failed, I could look for a top-level failure (presumably indented mm> less than lower-level success/failures, which might even allow me mm> to grep it out), which would be the .ReadMe prereq; then I could mm> go about looking for why that prereq failed (which might take me mm> into the second-level success/failures which contain '.ReadMe', mm> which I could again grep out, etc.) No you couldn't. Make could have, and probably did, try a large number of patterns before it got to the one you care about. Not only did it try patterns for the prerequisites you listed, but it tries patterns to create any prerequisite that might enable it to use that pattern, but which doesn't exist yet. Etc. If make printed "failed" after every single implicit rule that didn't match there would be hundreds if not thousands of "failed" messages in the debug output. That would not help you find the "right" one in any way, certainly you couldn't just go to "the first one". The first "failed" message will be at about line 4 of the debug output. What you want to do with the debug output is, find the name of the target that didn't get built. From there watch make checking implicit rules until it tries the one you care about. Then from there see why it couldn't use that rule for that target. -- ------------------------------------------------------------------------------- Paul D. Smith <[EMAIL PROTECTED]> Find some GNU make tips at: http://www.gnu.org http://make.paulandlesley.org "Please remain calm...I may be mad, but I am a professional." --Mad Scientist _______________________________________________ Help-make mailing list [EMAIL PROTECTED] http://mail.gnu.org/mailman/listinfo/help-make
