Hi Joe -- Thank you so much for your guidance. I'm assuming that it is the
basis\bootstrap\image\image.factor and the core\bootstrap\primitives.factor,
stage1.factor and syntax.factor that you are referring to? One question just to
help me get oriented before I go into heavy head-twisting mode. I notice that
all these files have significant numbers of pre-existing vocabularies that they
use. If this is what is used to generate the early stage1 bootstrapping stuff,
then am I correct to assume that this is done from some version of factor where
all this stuff has built already from scratch (that would be the implication,
if all these files are able to use those vocabularies)? Or is there some other
mechanism at work here that I should know about, and if so, is it written up
anywhere that you know about. I have just read Slava's January 2010 post on the
bootstrapping mechanism, so I understand the mechanism a bit better now, but am
still thinking there has to be some Factor system somewhere that was built
without a bootstrap image in order to have the vocabularies available that are
used to generate the bootstrapping. Is there anything anywhere documenting
that aspect of the picture. The reason I ask is that I would like to get a
sense of how extensive that core fundamental set of vocabularies is that is
needed to process the primitives and stage1 factor files. Here's the USING
statement for primitives.factor: USING: alien alien.strings arrays byte-arrays
generic hashtables
hashtables.private io io.encodings.ascii kernel math
math.private math.order namespaces make parser sequences strings
vectors words quotations assocs layouts classes classes.private
classes.builtin classes.singleton classes.tuple
classes.tuple.private kernel.private vocabs vocabs.loader
source-files definitions slots classes.union
classes.intersection classes.predicate compiler.units
bootstrap.image.private io.files accessors combinators ;
IN: bootstrap.primitives It's got a lot of stuff there. Is a lot of this built
in the C++ code that constitutes the VM? Or is some fundamental processing
capability put into place that allows the processing of factor files to build
these vocabularies? And if so, is the factor source used also included in the
downloaded platform? Or was this a special primordial code base that was used
once and never really needed again? Any clarification you can provide (or
better yet, any sources you can point me to that I can go and do the work to
gain an understanding of this) would be greatly, greatly appreciated. I
envision creating my own "Inside the Factor VM" and possibly "inside the Factor
Compiler" writeup once I have accomplished what I am after. So hopefully I can
give back a little after traveling up these respective learning curves. Thanks
much. Mike P.S. Incidentally, while I am on the subject, I find myself able
to trace through the VM startup code in Visual Studio with no problem at all,
until I get to the factor_vm::c_to_factor, which wraps a c-to-factor
sub-primitive inside of a callback stub and then invokes that function. On
both a Windows 7 platform and a Windows Server 2008 platform, my Visual Studio
blows up when the callback address loaded into EDX is called. Anybody ever
encountered this and any idea how to get around it? Thanks.> Date: Wed, 8 Aug
2012 20:23:04 -0700
> From: arc...@gmail.com
> To: factor-talk@lists.sourceforge.net
> Subject: Re: [Factor-talk] Any way of making sense of what's in the boot
> image?
>
> On Wed, Aug 8, 2012 at 3:24 PM, Michael Clagett <mclag...@hotmail.com> wrote:
> > Hi --
> >
> > I've been tracing through the initial vm initialization code trying to get a
> > picture of how Factor bootstraps itself. Does anyone know if there is a way
> > to resolve code in the initial boot image that is being jit-compiled by
> > factor_vm::prepare_boot_image to a set of symbolic names that can give a
> > hint as to what functionality is included there? I'm trying to get a sense
> > of the minimal functional set included here that allows higher-level initial
> > code to be compiled. The comment on prepare_boot-image says "/* Compile
> > code in boot image so that we can execute the startup quotation */". It
> > would be nice to know what this code includes. My guess is that the answer
> > is "no, there is no way" and that one just has to be in possession of
> > whatever code generated it (and there's nothing to say that this was even a
> > Factor system that did this in the first place; could have easily been some
> > C++ code that just knew what bits to emit).
> >
> > But it never hurts to ask...
> >
> > Presumably if I proceed past this to a point where actual Factor code is
> > being parsed and compiled, I'll be able to get a feel for what primitives
> > are already being depended on? Or maybe not. Maybe it's just a "big bang"
> > where earlier word definitions can depend on later word definitions having
> > been initialized before they start their execution. Is mine a hopeless
> > effort? Would be nice to know before I suck up too much time with it.
> >
> > Thanks for any guidance anyone can provide.
> >
> > Regards,
> >
> > Mike
>
> The code in the bootstrap.image module outputs the bootstrap image as
> a binary blob. You can get a sense for the format of the bootstrap
> image and its contents by looking at that module.
>
> -Joe
>
> ------------------------------------------------------------------------------
> Live Security Virtual Conference
> Exclusive live event will cover all the ways today's security and
> threat landscape has changed and how IT managers can respond. Discussions
> will include endpoint security, mobile security and the latest in malware
> threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
> _______________________________________________
> Factor-talk mailing list
> Factor-talk@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/factor-talk
------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and
threat landscape has changed and how IT managers can respond. Discussions
will include endpoint security, mobile security and the latest in malware
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
_______________________________________________
Factor-talk mailing list
Factor-talk@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/factor-talk
