Yea verily dude John F. Woods hath spoken, quoting me:

   > But the day is coming when I would like to be _able_ to build from source
   > without encountering a discontinuity in the life-graph of the
   > binary/source world.]

  [ John says here that GCC is not possible here... ]

to which I am thinking, Okay, I can live with having to fetch the CCS.

But once I've done that, I should be able to rebuild from the ground up, no?

   Yeah, I would LIKE that too, but it occurs to me that at least for GCC,
   you're just about guaranteed that it is not possible.  GCC is outside the
   control of the NetBSD core group (unless you want them never to upgrade
   again, in which case maybe you can argue with all the people who want every
   single patch and point release thrown into the tree immediately), 

To attempt to argue this one way or the other is sheer lunacy -- people
are almost more religious over the integration (or not) of GCC than they
are with respect to which brand of OS they love/hate.

   and it is
   structured so that a large number of its features are wired into the
   compiler source in a way that guarantees discontinuity (remember the recent
   _XF problem?).

Can't say as I do -- my attempts at building have been spotty at best
until recently.

   Aside from that, though, it would be nice if the number of discontinuities
   were small.  But how much does that really take?  Keep the Makefiles in
   share/mk and usr.bin/make as plain as possible, and don't use exciting new
   library features in make and whatever other tools are needed to build the
   library, and it should be possible at least to build make with old headers
   and libraries, build libc.a with new headers, build the rest of the build
   tools, then you're ready to roll -- but probably with a manual process,
   since you're not likely to want to overwrite your live system with
   half-built stuff (if you *do* want to, you're probably living dangerously
   enough to render moot the conservativism that led you to want a source-only
   distribution in the first place).

You may consider me insanely suicidal, then, for doing a build-in-place from
single-user-mode is precisely what I was trying to accomplish.

   So, aside from gcc (and that's a big aside, in more than one way!), it
   should take relatively little discipline to make source-only rebuilds
   *possible*, but I think making source-only rebuilds *automatic* for
   *everyone* is still not really practical.

Wasn't looking for automagic, necessarily, just looking to make it possible.

   Hmm.  Yeah, ld also rears its ugly head every few months with sea changes,
   and some of the important changes can't be accomplished gracefully.  (Well,
   I guess the least graceful changes have been in dynamic linking, so using
   static-linking to generate one's rebuild-kit might be sufficient.)

   Perhaps a reasonable compromise would be to accompany full releases with a
   "development kit" that comprises static-linked build tools sufficient to
   build a new source tree from scratch.  This could even be created by some
   interested third party, rather than being a core release function.

Gee, I said this above -- you beat me to it!

				--*greywolf;
--
"You're...mocking me, aren't you?"	-- Buzz Lightyear