mirror of
https://github.com/ilyakooo0/urbit.git
synced 2024-12-16 02:22:12 +03:00
157 lines
4.9 KiB
Plaintext
157 lines
4.9 KiB
Plaintext
::
|
|
:::: /hoon/metal/gen
|
|
::
|
|
/? 310
|
|
::
|
|
::::
|
|
!:
|
|
:- %say
|
|
|= $: {now/@da *}
|
|
*
|
|
==
|
|
:- %noun
|
|
=+ ^= event-zero
|
|
::
|
|
:: event 0 is the lifecycle formula which computes the final
|
|
:: state from the full event sequence.
|
|
::
|
|
:: the formal urbit state is always just a gate (function)
|
|
:: which, passed the next event, produces the next state.
|
|
::
|
|
=> [boot-formula=* full-sequence=*]
|
|
!= ::
|
|
:: first we use the boot formula (event 1) to set up
|
|
:: the pair of state function and main sequence. the boot
|
|
:: formula peels off the first n (currently 3) events
|
|
:: to set up the lifecycle loop.
|
|
::
|
|
=+ ^= [state-gate main-sequence]
|
|
.*(full-sequence boot-formula)
|
|
::
|
|
:: in this lifecycle loop, we replace the state function
|
|
:: with its product, called on the next event, until
|
|
:: we run out of events.
|
|
::
|
|
:: we have to use raw nock to "call" the function,
|
|
:: since these are untyped nouns.
|
|
::
|
|
:: in real life we don't actually run the lifecycle loop,
|
|
:: since
|
|
::
|
|
|- ?@ main-sequence
|
|
state-gate
|
|
%= $
|
|
main-sequence +.main-sequence
|
|
state-gate .*(state-gate(+< -.main-sequence) -.state-gate)
|
|
==
|
|
=+ ^= event-one
|
|
::
|
|
:: event 1 is the boot formula, which verifies the compiler
|
|
:: and starts the main lifecycle.
|
|
::
|
|
=> :* :: event 2: a trap (hoon |.), producing the hoon compiler
|
|
::
|
|
compiler-trap/*
|
|
::
|
|
:: event 3: hoon compiler source, compiling to event 2
|
|
::
|
|
compiler-source/@
|
|
::
|
|
:: event 4: arvo kernel source
|
|
::
|
|
kernel-source/@
|
|
::
|
|
:: events 5..n: main sequence with normal semantics
|
|
::
|
|
main-sequence/*
|
|
==
|
|
!= :_ main-sequence
|
|
::
|
|
:: activate the compiler gate. the reason we use a trap
|
|
:: here is to actually compose the gate live, activating
|
|
:: any jets as we build the cores. the compiler trap is
|
|
:: the only true binary used in the boot sequence.
|
|
::
|
|
:: as always, we have to use raw nock as we have no type.
|
|
:: the gate is in fact ++ride.
|
|
::
|
|
=+ ^= compiler-gate
|
|
.*(compiler-trap -:compiler-trap)
|
|
::
|
|
:: compile the compiler source, producing (pair span nock).
|
|
:: the compiler ignores its input so we use a trivial span.
|
|
::
|
|
=+ ^= compiler-tool
|
|
.*(compiler-gate(+< [%noun compiler-source]) -.compiler-gate)
|
|
::
|
|
:: run the nock to produce a new copy of the compiler trap;
|
|
:: check that it equals the old one.
|
|
::
|
|
?> =(compiler-trap -:*(0 +:compiler-tool))
|
|
::
|
|
:: get the span (type) of the context of the compiler gate,
|
|
:: which is the compiler core. this is at tree address 15
|
|
:: from the span produced by compiling the compiler source,
|
|
:: which is the span of the compiler trap.
|
|
::
|
|
=+ ^= compiler-span
|
|
.*(compiler-gate(+< [-.compiler-gate '+15']) -.compiler-gate)
|
|
::
|
|
:: compile the arvo source against the compiler core.
|
|
::
|
|
=+ ^= kernel-tool
|
|
.*(compiler-gate(+< [compiler-span kernel-source]) -.compiler-gate)
|
|
::
|
|
:: pass the compiler core to the arvo kernel, and we done
|
|
::
|
|
.*(+>:compiler-gate +:kernel-tool)
|
|
::
|
|
:: load files. ship and desk are in generator beak. case is now.
|
|
:: source files:
|
|
::
|
|
:: sys/hoon compiler
|
|
:: sys/arvo kernel
|
|
:: sys/zuse standard library
|
|
:: sys/vane/ames network vane
|
|
:: sys/vane/behn timer vane
|
|
:: sys/vane/clay revision-control vane
|
|
:: sys/vane/dill console vane
|
|
:: sys/vane/eyre web/internet vane
|
|
:: sys/vane/ford build vane
|
|
:: sys/vane/gall app vane
|
|
:: sys/vane/jael security vane
|
|
::
|
|
=+ top=`path`/(scot %p p.bec)/[q.bec]/(scot %da now)/arvo
|
|
=+ ^= com
|
|
=+ pax=`path`(weld top `path`[%hoon ~])
|
|
~& %plastic-start
|
|
=+ gen=(reck (weld
|
|
~& %plastic-parsed
|
|
=+ ken=q:(~(mint ut %noun) %noun gen)
|
|
~& %plastic-compiled
|
|
:- ken
|
|
=+ all=.*(0 ken)
|
|
=+ ^= vent
|
|
|= {abr/term den/path}
|
|
=+ pax=(weld top den)
|
|
=+ txt=.^(@ %cx (weld pax `path`[%hoon ~]))
|
|
`ovum`[[%vane den] [%veer abr pax txt]]
|
|
=+ ^= evo
|
|
^- (list ovum)
|
|
:~ (vent %$ /zuse)
|
|
[[%name (scot %p who) ~] [%veal who]]
|
|
(vent %c /vane/clay)
|
|
(vent %g /vane/gall)
|
|
(vent %f /vane/ford)
|
|
(vent %a /vane/ames)
|
|
(vent %b /vane/behn)
|
|
(vent %d /vane/dill)
|
|
(vent %e /vane/eyre)
|
|
==
|
|
|- ^+ all
|
|
?~ evo all
|
|
~& [%plastic-step p.i.evo]
|
|
=+ gat=.*(all .*(all [0 42]))
|
|
=+ nex=+:.*([-.gat [[now i.evo] +>.gat]] -.gat)
|
|
$(evo t.evo, all nex)
|