mirror of
https://github.com/ilyakooo0/urbit.git
synced 2024-11-27 14:07:34 +03:00
arvo: removes neo-arvo and obsolete pill generators
This commit is contained in:
parent
f8b2beae32
commit
b2eaa5e5b8
@ -1,255 +0,0 @@
|
||||
:- %say
|
||||
|= $: {now/@da eny/@uvJ bec/beak}
|
||||
*
|
||||
==
|
||||
:- %noun
|
||||
=>
|
||||
|%
|
||||
:: fundamental hierarchical node XX s/b +arch
|
||||
::
|
||||
++ node
|
||||
=< |$ [item]
|
||||
[fil=(unit item) dir=(map @ta $)]
|
||||
::
|
||||
|%
|
||||
++ de
|
||||
=| fat=(node)
|
||||
|@
|
||||
::
|
||||
++ get-node
|
||||
|= pax=path
|
||||
^+ fat
|
||||
?~ pax fat
|
||||
=/ kid (~(get by dir.fat) i.pax)
|
||||
?~ kid [~ ~]
|
||||
$(fat u.kid, pax t.pax)
|
||||
::
|
||||
++ get
|
||||
|= pax=path
|
||||
^+ fil.fat
|
||||
fil:(get-node pax)
|
||||
::
|
||||
++ got
|
||||
|= pax=path
|
||||
(need (get pax))
|
||||
::
|
||||
++ has
|
||||
|= pax=path
|
||||
^- ?
|
||||
!=(~ (get pax))
|
||||
::
|
||||
++ put
|
||||
|* [pax=path dat=*]
|
||||
=> .(dat `_?>(?=(^ fil.fat) u.fil.fat)`dat)
|
||||
^+ fat
|
||||
?~ pax fat(fil `dat)
|
||||
=/ kid (~(get by dir.fat) i.pax)
|
||||
=/ new (fall kid fat(fil ~, dir ~))
|
||||
fat(dir (~(put by dir.fat) i.pax $(fat new, pax t.pax)))
|
||||
::
|
||||
++ gas
|
||||
|= lit=(list (pair path _?>(?=(^ fil.fat) u.fil.fat)))
|
||||
^+ fat
|
||||
?~ lit fat
|
||||
$(fat (put p.i.lit q.i.lit), lit t.lit)
|
||||
::
|
||||
++ tap
|
||||
=| pax=path
|
||||
=| out=(list (pair path _?>(?=(^ fil.fat) u.fil.fat)))
|
||||
|- ^+ out
|
||||
=? out ?=(^ fil.fat) :_(out [pax u.fil.fat])
|
||||
=/ dir ~(tap by dir.fat)
|
||||
|- ^+ out
|
||||
?~ dir out
|
||||
%= $
|
||||
dir t.dir
|
||||
out ^$(pax (weld pax /[p.i.dir]), fat q.i.dir)
|
||||
==
|
||||
-- :: de
|
||||
-- :: node
|
||||
--
|
||||
=>
|
||||
|%
|
||||
+$ hoof @t :: hoon source file
|
||||
+$ news
|
||||
$: :: use: non-system files
|
||||
:: new: new set
|
||||
:: sys: installs + replacements
|
||||
::
|
||||
use=(map path plum)
|
||||
new=(set path)
|
||||
sys=(map path plum)
|
||||
==
|
||||
+$ plum (cask)
|
||||
+$ seed [hoon=(unit hoof) arvo=hoof]
|
||||
+$ sprig
|
||||
$: lull=(unit hoof)
|
||||
zuse=(unit hoof)
|
||||
vane=(list (pair term hoof))
|
||||
==
|
||||
::
|
||||
++ wilt :: deep file as source
|
||||
|= =plum
|
||||
^- hoof
|
||||
?>(?=([%hoon @t] plum) q.plum)
|
||||
::
|
||||
++ adapt
|
||||
=* de de:node
|
||||
|_ fat=(node plum)
|
||||
::
|
||||
:: +group: collate changes
|
||||
::
|
||||
++ group
|
||||
|= fal=(list (pair path plum))
|
||||
=| del=news
|
||||
|- ^+ del
|
||||
?~ fal
|
||||
~? !=(~ use.del)
|
||||
[%what-use ~(tap in ~(key by use.del))]
|
||||
~? !=(~ new.del)
|
||||
[%what-new ~(tap in new.del)]
|
||||
~? !=(~ sys.del)
|
||||
[%what-sys ~(tap in ~(key by sys.del))]
|
||||
del
|
||||
::
|
||||
=* pax p.i.fal
|
||||
=* dat q.i.fal
|
||||
=/ old (~(get de fat) pax)
|
||||
::
|
||||
:: ignore unchanged data
|
||||
::
|
||||
?: =(old `dat)
|
||||
$(fal t.fal)
|
||||
::
|
||||
:: classify as user, system install or replacement
|
||||
::
|
||||
?. ?=([%sys *] pax)
|
||||
=. use.del (~(put by use.del) pax dat)
|
||||
$(fal t.fal)
|
||||
=? new.del ?=(~ old)
|
||||
(~(put in new.del) pax)
|
||||
=. sys.del (~(put by sys.del) pax dat)
|
||||
$(fal t.fal)
|
||||
:: +usurp: consider self-replacement
|
||||
::
|
||||
++ usurp
|
||||
|= del=news
|
||||
^- (unit seed)
|
||||
::
|
||||
:: when we get new hoon and arvo system files,
|
||||
:: we assume they match what's running now
|
||||
::
|
||||
=* adopt-new
|
||||
|=(=path ?:((~(has in new.del) path) ~ (~(get by sys.del) path)))
|
||||
::
|
||||
=/ hun (adopt-new /sys/hoon)
|
||||
=/ arv (adopt-new /sys/arvo)
|
||||
?~ hun
|
||||
?~ arv ~
|
||||
::
|
||||
:: light reboot, arvo only
|
||||
::
|
||||
~& %light-reboot
|
||||
``(wilt u.arv)
|
||||
::
|
||||
:: heavy reboot, hoon and arvo
|
||||
::
|
||||
~& %heavy-reboot
|
||||
:+ ~
|
||||
`(wilt u.hun)
|
||||
(wilt ?^(arv u.arv (~(got de fat) /sys/arvo)))
|
||||
:: +adorn: augment capabilities
|
||||
::
|
||||
++ adorn
|
||||
|= [del=news force=?]
|
||||
^- sprig
|
||||
:: lull: shared structures
|
||||
::
|
||||
=/ lull
|
||||
?^ lul=(~(get by sys.del) /sys/lull)
|
||||
`(wilt u.lul)
|
||||
?.(force ~ `(wilt (~(got de fat) /sys/lull)))
|
||||
::
|
||||
:: zuse: shared library
|
||||
::
|
||||
:: %lull is the subject of %zuse; force %zuse if we have a new %lull
|
||||
::
|
||||
=/ zuse
|
||||
=. force ?=(^ lull)
|
||||
?^ zus=(~(get by sys.del) /sys/zuse)
|
||||
`(wilt u.zus)
|
||||
?.(force ~ `(wilt (~(got de fat) /sys/zuse)))
|
||||
::
|
||||
:+ lull
|
||||
zuse
|
||||
::
|
||||
:: kernel modules
|
||||
::
|
||||
:: %zuse is the subject of the vanes; force all if we have a new %zuse
|
||||
::
|
||||
=/ current=(list (pair term hoof))
|
||||
=. force ?=(^ zuse)
|
||||
?. force ~
|
||||
%+ turn
|
||||
~(tap by dir:(~(get-node de fat) /sys/vane))
|
||||
|=([name=@ta (node plum)] [`@tas`name (wilt (need fil))])
|
||||
::
|
||||
=/ updates=(list (pair term hoof))
|
||||
%+ turn
|
||||
%+ skim
|
||||
~(tap by sys.del)
|
||||
|=([=path *] ?=([%sys %vane @tas ~] path))
|
||||
|= [=path =plum]
|
||||
?> ?=([%sys %vane @tas ~] path)
|
||||
=* name i.t.t.path
|
||||
?> ((sane %tas) name)
|
||||
[`@tas`name (wilt plum)]
|
||||
::
|
||||
%+ sort
|
||||
%~ tap by
|
||||
%- ~(gas by *(map term hoof))
|
||||
(weld current updates)
|
||||
|=([[a=@tas *] [b=@tas *]] (aor a b))
|
||||
-- :: adapt
|
||||
::
|
||||
++ what
|
||||
|= fat=(node plum)
|
||||
::
|
||||
|= fal=(list (pair path plum))
|
||||
=/ del (~(group adapt fat) fal)
|
||||
=/ but (~(usurp adapt fat) del)
|
||||
=/ job (~(adorn adapt fat) del force=?=(^ but))
|
||||
::
|
||||
:: adopt system changes
|
||||
::
|
||||
=. fat (~(gas de:node fat) ~(tap by sys.del))
|
||||
::
|
||||
:: just adopt user changes, which have no systems impact
|
||||
::
|
||||
:: XX or ignore? useful for bootstrap?
|
||||
::
|
||||
=. fat (~(gas de:node fat) ~(tap by use.del))
|
||||
::
|
||||
[[but job] fat]
|
||||
--
|
||||
::
|
||||
=| fat=(node plum)
|
||||
=^ one fat
|
||||
%- (what fat)
|
||||
:~ /sys/hoon^hoon+%a
|
||||
/sys/arvo^hoon+%a
|
||||
/sys/lull^hoon+%a
|
||||
/sys/zuse^hoon+%a
|
||||
/sys/vane/foo^hoon+%a
|
||||
/sys/vane/bar^hoon+%a
|
||||
/sys/vane/baz^hoon+%a
|
||||
/app/dojo^hoon+%a
|
||||
/lib/drum^hoon+%a
|
||||
==
|
||||
=^ two fat
|
||||
%- (what fat)
|
||||
:~ /sys/arvo^hoon+%b
|
||||
/sys/lull^hoon+%b
|
||||
/sys/vane/foo^hoon+%b
|
||||
==
|
||||
[one two fat]
|
@ -1,132 +0,0 @@
|
||||
:: Produce a glass pill
|
||||
::
|
||||
:::: /hoon/glass/gen
|
||||
::
|
||||
/? 310
|
||||
::
|
||||
::::
|
||||
::
|
||||
:- %say
|
||||
|= $: {now/@da eny/@uvJ bec/beak}
|
||||
*
|
||||
==
|
||||
=< [%noun ~]
|
||||
=> |%
|
||||
++ wasp :: arvo effect
|
||||
$% {$wack p/@uvJ} :: add entropy
|
||||
{$what p/(list (pair path (pair term noun)))} :: reset reptile
|
||||
{$whom p/@p} :: id and boot
|
||||
==
|
||||
--
|
||||
::
|
||||
:: deterministic test
|
||||
::
|
||||
=. eny 0v0
|
||||
::
|
||||
:: build arvo with existing compiler
|
||||
::
|
||||
|^ ^- *
|
||||
::
|
||||
:: neo: root path to boot system, `/~me/[desk]/now/neo`
|
||||
::
|
||||
=+ neo=`path`/(scot %p p.bec)/[q.bec]/(scot %da now)/neo
|
||||
::
|
||||
:: arvo-source: hoon source file producing arvo kernel, `neo/arvo`
|
||||
::
|
||||
=+ arvo-source=.^(@t %cx (welp neo /arvo/hoon))
|
||||
::
|
||||
:: arvo-twig: parsed arvo source
|
||||
::
|
||||
~& [%parsing `@p`(mug arvo-source)]
|
||||
=+ arvo-twig=(ream arvo-source)
|
||||
~& %parsed
|
||||
::
|
||||
:: arvo-kernel: a living urbit
|
||||
::
|
||||
~& [%compiling `@p`(mug arvo-twig)]
|
||||
=+ arvo-kernel=+:(slap !>(..ream) arvo-twig)
|
||||
~& %compiled
|
||||
::
|
||||
:: events: list of events to feed our urbit
|
||||
::
|
||||
~& %loading
|
||||
=+ events=main-events
|
||||
~& [%loaded `@p`(mug events)]
|
||||
::
|
||||
:: execute events
|
||||
::
|
||||
=+ number=0
|
||||
|- ^- *
|
||||
?~ events arvo-kernel
|
||||
~& number+number
|
||||
%= $
|
||||
events t.events
|
||||
number +(number)
|
||||
arvo-kernel .*(arvo-kernel(+< i.events) -.arvo-kernel)
|
||||
==
|
||||
::
|
||||
++ main-events
|
||||
=. now ~2017.3.1
|
||||
=+ mov=main-moves
|
||||
|- ^- (list (pair @da ovum))
|
||||
?~ mov ~
|
||||
:- [now i.mov]
|
||||
$(mov t.mov, now (add now (bex 48)))
|
||||
::
|
||||
++ main-moves
|
||||
^- (list ovum)
|
||||
:~ [[%$ ~] [%what boot-files]]
|
||||
:: [[%$ ~] [%whom ~zod]]
|
||||
==
|
||||
++ boot-files
|
||||
^- (list (pair path (pair term noun)))
|
||||
::
|
||||
:: userspace:
|
||||
::
|
||||
:: /app %gall applications
|
||||
:: /gen :dojo generators
|
||||
:: /lib %ford libraries
|
||||
:: /mar %ford marks
|
||||
:: /sur %ford structures
|
||||
:: /ren %ford renderers
|
||||
:: /web %eyre web content
|
||||
:: /sys system files
|
||||
:: /neo new system files
|
||||
::
|
||||
(user-files /neo ~)
|
||||
::
|
||||
++ user-files :: userspace loading
|
||||
|= :: sal: all spurs to load from
|
||||
::
|
||||
sal/(list spur)
|
||||
^- (list (pair path (pair term noun)))
|
||||
::
|
||||
:: hav: all user files
|
||||
::
|
||||
=| hav/(list (pair path (pair term noun)))
|
||||
|- ^+ hav
|
||||
?~ sal ~
|
||||
=. hav $(sal t.sal)
|
||||
::
|
||||
:: tyl: spur
|
||||
::
|
||||
=/ tyl i.sal
|
||||
|- ^+ hav
|
||||
::
|
||||
:: pax: full path at `tyl`
|
||||
:: lon: directory at `tyl`
|
||||
::
|
||||
=/ pax (en-beam:format bec (flop tyl))
|
||||
=/ lon .^(arch %cy pax)
|
||||
=? hav ?=(^ fil.lon)
|
||||
::
|
||||
:: install only hoon files for now
|
||||
::
|
||||
?. ?=({$hoon *} tyl) hav
|
||||
:_(hav [(flop `path`t.tyl) [%hoon .^(@t %cx pax)]])
|
||||
::
|
||||
=/ all ~(tap by dir.lon)
|
||||
|- ^+ hav
|
||||
?~ all hav
|
||||
$(all t.all, hav ^$(tyl [p.i.all tyl]))
|
||||
--
|
@ -1,319 +0,0 @@
|
||||
:: Produce a metal pill
|
||||
::
|
||||
:::: /hoon/metal/gen
|
||||
::
|
||||
/? 310
|
||||
::
|
||||
::::
|
||||
!:
|
||||
:- %say
|
||||
|= $: {now/@da * bec/beak}
|
||||
{{who/@p ~} try/_| ~}
|
||||
==
|
||||
::
|
||||
:: we're creating an event series E whose lifecycle can be computed
|
||||
:: with the urbit lifecycle formula L, `[2 [0 3] [0 2]]`. that is:
|
||||
:: if E is the list of events processed by a computer in its life,
|
||||
:: its final state is S, where S is nock(E L).
|
||||
::
|
||||
:: in practice, the first five nouns in E are: two boot formulas,
|
||||
:: a hoon compiler as a nock formula, the same compiler as source,
|
||||
:: and the arvo kernel as source.
|
||||
::
|
||||
:: after the first five special events, we enter an iterative
|
||||
:: sequence of regular events which continues for the rest of the
|
||||
:: computer's life. during this sequence, each state is a function
|
||||
:: that, passed the next event, produces the next state.
|
||||
::
|
||||
:: each event is a `[date wire type data]` tuple, where `date` is a
|
||||
:: 128-bit Urbit date; `wire` is an opaque path which output can
|
||||
:: match to track causality; `type` is a symbol describing the type
|
||||
:: of input; and `data` is input data specific to `type`.
|
||||
::
|
||||
:: in real life we don't actually run the lifecycle loop,
|
||||
:: since real life is updated incrementally and also cares
|
||||
:: about things like output. we couple to the internal
|
||||
:: structure of the state machine and work directly with
|
||||
:: the underlying arvo engine.
|
||||
::
|
||||
:: this arvo core, which is at `+7` (Lisp `cddr`) of the state
|
||||
:: function (see its public interface in `sys/arvo`), gives us
|
||||
:: extra features, like output, which are relevant to running
|
||||
:: a real-life urbit vm, but don't affect the formal definition.
|
||||
::
|
||||
:: so a real-life urbit interpreter is coupled to the shape of
|
||||
:: the arvo core. it becomes very hard to change this shape.
|
||||
:: fortunately, it is not a very complex interface.
|
||||
::
|
||||
:- %noun
|
||||
::
|
||||
:: boot-one: lifecycle formula
|
||||
::
|
||||
=+ ^= boot-one
|
||||
::
|
||||
:: event 1 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.
|
||||
::
|
||||
|- ?@ main-sequence
|
||||
state-gate
|
||||
%= $
|
||||
main-sequence +.main-sequence
|
||||
state-gate .*(state-gate [%9 2 %10 [6 %1 -.main-sequence] %0 1])
|
||||
==
|
||||
::
|
||||
:: boot-two: startup formula
|
||||
::
|
||||
=+ ^= boot-two
|
||||
::
|
||||
:: event 2 is the startup formula, which verifies the compiler
|
||||
:: and starts the main lifecycle.
|
||||
::
|
||||
=> :* :: event 3: a formula producing the hoon compiler
|
||||
::
|
||||
compiler-formula=**
|
||||
::
|
||||
:: event 4: hoon compiler source, compiling to event 2
|
||||
::
|
||||
compiler-source=*@t
|
||||
::
|
||||
:: event 5: arvo kernel source
|
||||
::
|
||||
arvo-source=*@t
|
||||
::
|
||||
:: events 6..n: main sequence with normal semantics
|
||||
::
|
||||
main-sequence=**
|
||||
==
|
||||
!= :_ main-sequence
|
||||
::
|
||||
:: activate the compiler gate. the product of this formula
|
||||
:: is smaller than the formula. so you might think we should
|
||||
:: save the gate itself rather than the formula producing it.
|
||||
:: but we have to run the formula at runtime, to register jets.
|
||||
::
|
||||
:: as always, we have to use raw nock as we have no type.
|
||||
:: the gate is in fact ++ride.
|
||||
::
|
||||
~> %slog.[0 leaf+"1-b"]
|
||||
=+ ^= compiler-gate
|
||||
.*(0 compiler-formula)
|
||||
::
|
||||
:: compile the compiler source, producing (pair span nock).
|
||||
:: the compiler ignores its input so we use a trivial span.
|
||||
::
|
||||
~> %slog.[0 leaf+"1-c"]
|
||||
=+ ^= compiler-tool
|
||||
.*(compiler-gate [%9 2 %10 [6 %1 [%noun compiler-source]] %0 1])
|
||||
::
|
||||
:: switch to the second-generation compiler. we want to be
|
||||
:: able to generate matching reflection nouns even if the
|
||||
:: language changes -- the first-generation formula will
|
||||
:: generate last-generation spans for `!>`, etc.
|
||||
::
|
||||
~> %slog.[0 leaf+"1-d"]
|
||||
=. compiler-gate .*(0 +:compiler-tool)
|
||||
::
|
||||
:: get the span (type) of the kernel core, which is the context
|
||||
:: of the compiler gate. we just compiled the compiler,
|
||||
:: so we know the span (type) of the compiler gate. its
|
||||
:: context is at tree address `+>` (ie, `+7` or Lisp `cddr`).
|
||||
:: we use the compiler again to infer this trivial program.
|
||||
::
|
||||
~> %slog.[0 leaf+"1-e"]
|
||||
=+ ^= kernel-span
|
||||
-:.*(compiler-gate [%9 2 %10 [6 %1 [-.compiler-tool '+>']] %0 1])
|
||||
::
|
||||
:: compile the arvo source against the kernel core.
|
||||
::
|
||||
~> %slog.[0 leaf+"1-f"]
|
||||
=+ ^= kernel-tool
|
||||
.*(compiler-gate [%9 2 %10 [6 %1 [kernel-span arvo-source]] %0 1])
|
||||
::
|
||||
:: create the arvo kernel, whose subject is the kernel core.
|
||||
::
|
||||
~> %slog.[0 leaf+"1-g"]
|
||||
.*(+>:compiler-gate +:kernel-tool)
|
||||
::
|
||||
:: sys: root path to boot system, `/~me/[desk]/now/sys`
|
||||
::
|
||||
=+ sys=`path`/(scot %p p.bec)/[q.bec]/(scot %da now)/sys
|
||||
::
|
||||
:: compiler-source: hoon source file producing compiler, `sys/hoon`
|
||||
::
|
||||
=+ compiler-source=.^(@t %cx (welp sys /hoon/hoon))
|
||||
::
|
||||
:: compiler-twig: compiler as hoon expression
|
||||
::
|
||||
~& %metal-parsing
|
||||
=+ compiler-twig=(ream compiler-source)
|
||||
~& %metal-parsed
|
||||
::
|
||||
:: compiler-formula: compiler as nock formula
|
||||
::
|
||||
~& %metal-compiling
|
||||
=+ compiler-formula=q:(~(mint ut %noun) %noun compiler-twig)
|
||||
~& %metal-compiled
|
||||
::
|
||||
:: arvo-source: hoon source file producing arvo kernel, `sys/arvo`
|
||||
::
|
||||
=+ arvo-source=.^(@t %cx (welp sys /arvo/hoon))
|
||||
::
|
||||
:: main-moves: installation actions
|
||||
::
|
||||
=+ ^= main-moves
|
||||
|^ ^- (list ovum)
|
||||
:~ ::
|
||||
:: configure identity
|
||||
::
|
||||
[[%name (scot %p who) ~] [%veal who]]
|
||||
::
|
||||
:: sys/zuse: standard library
|
||||
::
|
||||
(vent %$ /zuse)
|
||||
::
|
||||
:: sys/vane/ames: network
|
||||
::
|
||||
(vent %a /vane/ames)
|
||||
::
|
||||
:: sys/vane/behn: timer
|
||||
::
|
||||
(vent %b /vane/behn)
|
||||
::
|
||||
:: sys/vane/clay: revision control
|
||||
::
|
||||
(vent %c /vane/clay)
|
||||
::
|
||||
:: sys/vane/dill: console
|
||||
::
|
||||
(vent %d /vane/dill)
|
||||
::
|
||||
:: sys/vane/eyre: web
|
||||
::
|
||||
(vent %e /vane/eyre)
|
||||
::
|
||||
:: sys/vane/gall: applications
|
||||
::
|
||||
(vent %g /vane/gall)
|
||||
::
|
||||
:: sys/vane/jael: security
|
||||
::
|
||||
(vent %j /vane/jael)
|
||||
::
|
||||
:: legacy boot event
|
||||
::
|
||||
[[%$ %term '1' ~] [%boot %sith who `@uw`who &]]
|
||||
::
|
||||
:: userspace:
|
||||
::
|
||||
:: /app %gall applications
|
||||
:: /gen :dojo generators
|
||||
:: /lib %ford libraries
|
||||
:: /mar %ford marks
|
||||
:: /sur %ford structures
|
||||
:: /ren %ford renderers
|
||||
:: /web %eyre web content
|
||||
:: /sys system files
|
||||
::
|
||||
(user /app /gen /lib /mar /ren /sec /sur /sys /web ~)
|
||||
==
|
||||
:: ::
|
||||
++ user :: userspace loading
|
||||
|= :: sal: all spurs to load from
|
||||
::
|
||||
sal/(list spur)
|
||||
^- ovum
|
||||
::
|
||||
:: hav: all user files
|
||||
::
|
||||
=; hav ~& user-files+(lent hav)
|
||||
[[%$ %sync ~] [%into %$ & hav]]
|
||||
=| hav/mode:clay
|
||||
|- ^+ hav
|
||||
?~ sal ~
|
||||
=. hav $(sal t.sal)
|
||||
::
|
||||
:: tyl: spur
|
||||
::
|
||||
=/ tyl i.sal
|
||||
|- ^+ hav
|
||||
::
|
||||
:: pax: full path at `tyl`
|
||||
:: lon: directory at `tyl`
|
||||
::
|
||||
=/ pax (en-beam:format bec (flop tyl))
|
||||
=/ lon .^(arch %cy pax)
|
||||
=? hav ?=(^ fil.lon)
|
||||
?. ?=({$hoon *} tyl)
|
||||
::
|
||||
:: install only hoon files for now
|
||||
::
|
||||
hav
|
||||
::
|
||||
:: cot: file as plain-text octet-stream
|
||||
::
|
||||
=; cot [[(flop `path`tyl) `[/text/plain cot]] hav]
|
||||
^- octs
|
||||
?- tyl
|
||||
{$hoon *}
|
||||
=/ dat .^(@t %cx pax)
|
||||
[(met 3 dat) dat]
|
||||
==
|
||||
=/ all ~(tap by dir.lon)
|
||||
|- ^- mode:clay
|
||||
?~ all hav
|
||||
$(all t.all, hav ^$(tyl [p.i.all tyl]))
|
||||
::
|
||||
++ vent
|
||||
|= {abr/term den/path}
|
||||
=+ pax=(weld sys den)
|
||||
=+ txt=.^(@ %cx (welp pax /hoon))
|
||||
`ovum`[[%vane den] [%veer abr pax txt]]
|
||||
--
|
||||
::
|
||||
:: main-events: full events with advancing times
|
||||
::
|
||||
=. now ~2017.3.1
|
||||
=+ ^= main-events
|
||||
|- ^- (list (pair @da ovum))
|
||||
?~ main-moves ~
|
||||
:- [now i.main-moves]
|
||||
$(main-moves t.main-moves, now (add now (bex 48)))
|
||||
::
|
||||
~? try
|
||||
~& %metal-testing
|
||||
=+ ^= yop
|
||||
^- @p
|
||||
%- mug
|
||||
.* :* boot-one
|
||||
boot-two
|
||||
compiler-formula
|
||||
compiler-source
|
||||
arvo-source
|
||||
main-events
|
||||
==
|
||||
[2 [0 3] [0 2]]
|
||||
[%metal-tested yop]
|
||||
::
|
||||
:* boot-one
|
||||
boot-two
|
||||
compiler-formula
|
||||
compiler-source
|
||||
arvo-source
|
||||
main-events
|
||||
==
|
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user