urbit/shrub
1
1
Fork 0
mirror of https://github.com/urbit/shrub.git synced 2024-12-20 01:01:37 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'release/next-vere' into jb/leaky

Browse Source 
* release/next-vere: (104 commits)
  vere: adds backwards-compatibility TODO comments for terminal inputs
  vere: adds backwards-compatibility to blit handling under -t
  u3: replaces spurious bloq-size bail:exit's in +rap and +rep jets
  build: patch windows uv_pipe impl to allow null writes
  build: update pmnsh to support cachix text/x-nix-narinfo responses
  vere: renames terminal streams for clarity, removes unused uv_tcp_t
  vere: refactors _term_it_send_csi()
  vere: suppress null writes in term.c
  vere: use memset to wipe hashmaps
  pill: all
  webterm: simpler TermState
  webterm: clean up component state derivation
  webterm: fix broken api interactions
  herm: close old-style subscriptions
  webterm: include @urbit/api/term files
  herm: accept old /view/* wires
  hood, pill: clean up merge artifacts
  webterm: improve container handling
  webterm: factor logic out into functions
  webterm: more idiomatic array type definitions
  ...
This commit is contained in:
Joe Bryan 2021-09-16 22:48:34 -04:00
commit 2897d3a764
90 changed files with 35413 additions and 26177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
bin/brass.pill
View File

@ -1,3 +1,3 @@
version https://git-lfs.github.com/spec/v1 version https://git-lfs.github.com/spec/v1
oid sha256:8c497bba51152dc3e54463a9f33c02876345419457a2f0ce2f15810db9daac72 oid sha256:f70a6e20ac6fd7dfb620f7ace725c5b031d040c0fe97caab251233ba31bc9819
size 5041231 size 5155717

4
bin/ivory.pill
View File

@ -1,3 +1,3 @@
version https://git-lfs.github.com/spec/v1 version https://git-lfs.github.com/spec/v1
oid sha256:5c6ad04e9c83caf6667ef12f4ba9627e9d409381fc4cd151dd2964faed105f8a oid sha256:c871af4da5d779a2ccc8a8187ca06e2ccf19a984db9bede7f2d721fa43525210
size 1148833 size 1259429

4
bin/solid.pill
View File

@ -1,3 +1,3 @@
version https://git-lfs.github.com/spec/v1 version https://git-lfs.github.com/spec/v1
oid sha256:3cc76dec0e5110e35647a8a7341c5c1648d33eab636c067b4ce5893d13af86d8 oid sha256:5f97a6c105b89973b6f7ee2bace9f0aff018efb65db7a3b90948761abb8c6b18
size 6755088 size 6876039

91
pkg/arvo/app/herm.hoon
View File

@ -1,7 +1,13 @@
:: herm: stand-in for term.c with http interface :: herm: stand-in for term.c with http interface
:: ::
/- herm
/+ default-agent, dbug, verb /+ default-agent, dbug, verb
=, jael :: keep relevant mark conversions in cache for performance
::
/$ bj %blit %json
/$ jb %json %belt
/$ jt %json %herm-task
::
|% |%
+$ state-0 [%0 ~] +$ state-0 [%0 ~]
-- --
@ -12,17 +18,9 @@
%- agent:dbug %- agent:dbug
^- agent:gall ^- agent:gall
=> |% => |%
++ request-tube ++ pass-session
|= [bowl:gall from=mark to=mark next=?] |= [ses=@tas tas=session-task:dill]
^- card:agent:gall [%pass /dill/[ses] %arvo %d %shot ses tas]
:* %pass /tube/[from]/[to]
%arvo %c %warp
our q.byk ~
::
?: next
[%next %c da+now /[from]/[to]]
[%sing %c da+now /[from]/[to]]
==
-- --
|_ =bowl:gall |_ =bowl:gall
+* this . +* this .
@ -30,14 +28,7 @@
:: ::
++ on-init ++ on-init
^- (quip card:agent:gall _this) ^- (quip card:agent:gall _this)
:_ this [~ this]
:: set up dill session subscription,
:: and ensure the tubes we use are in cache
::
:~ [%pass [%view %$ ~] %arvo %d %view ~]
(request-tube bowl %blit %json |)
(request-tube bowl %json %belt |)
==
:: ::
++ on-save !>([%0 ~]) ++ on-save !>([%0 ~])
++ on-load ++ on-load
@ -48,54 +39,70 @@
++ on-watch ++ on-watch
|= =path |= =path
^- (quip card:agent:gall _this) ^- (quip card:agent:gall _this)
?> ?=([%session @ ~] path)
:_ this :_ this
:: scry prompt and cursor position out of dill for initial response ?> ?=([%session @ ~] path)
:: =* ses i.t.path
=/ base=^path :~ :: subscribe to the requested session
/dx/(scot %p our.bowl)//(scot %da now.bowl)/sessions ::
:~ [%give %fact ~ %blit !>(.^(blit:dill (weld base //line)))] ::NOTE multiple views do not result in multiple subscriptions
[%give %fact ~ %blit !>(`blit:dill`hop+.^(@ud (weld base //cursor)))] :: because they go over the same wire/duct
::
(pass-session ses %view ~)
:: tell session to refresh, so new client knows what's on screen
::TODO should client be responsible for this?
::
(pass-session ses %hail ~)
== ==
:: ::
++ on-arvo ++ on-arvo
|= [=wire =sign-arvo] |= [=wire =sign-arvo]
^- (quip card:agent:gall _this) ^- (quip card:agent:gall _this)
~| wire
?+ wire !! ?+ wire !!
:: pass on dill blits for the session :: pass on dill blits for the session
:: ::
[%view %$ ~] [%dill @ ~]
=* ses i.t.wire
?. ?=([%dill %blit *] sign-arvo) ?. ?=([%dill %blit *] sign-arvo)
~| [%unexpected-sign [- +<]:sign-arvo] ~| [%unexpected-sign [- +<]:sign-arvo]
!! !!
:_ this :_ this
%+ turn p.sign-arvo %+ turn p.sign-arvo
|= =blit:dill |= =blit:dill
[%give %fact [%session %$ ~]~ %blit !>(blit)] [%give %fact [%session ses ~]~ %blit !>(blit)]
:: ::
:: ensure the tubes we need remain in cache :: clean up old-style subscriptions
:: ::
[%tube @ @ ~] [%view @ ~]
=* from i.t.wire =* ses i.t.wire
=* to i.t.t.wire
?. ?=([%clay %writ *] sign-arvo)
~| [%unexpected-sign [- +<]:sign-arvo]
!!
:_ this :_ this
[(request-tube bowl from to &)]~ [%pass wire %arvo %d %shot ses %flee ~]~
== ==
:: ::
++ on-poke ++ on-poke
|= [=mark =vase] |= [=mark =vase]
^- (quip card:agent:gall _this) ^- (quip card:agent:gall _this)
?. ?=(%belt mark)
~| [%unexpected-mark mark]
!!
:_ this :_ this
[%pass [%belt %$ ~] %arvo %d %belt !<(belt:dill vase)]~ :_ ~
?+ mark ~|([%unexpected-mark mark] !!)
%belt (pass-session %$ %belt !<(belt:dill vase))
%herm-task (pass-session !<(task:herm vase))
==
::
++ on-peek
|= =path
^- (unit (unit cage))
?+ path ~
[%x %sessions ~]
:+ ~ ~
:- %json
!> ^- json
=- a+(turn ~(tap in -) (lead %s))
.^((set @tas) %dy /(scot %p our.bowl)//(scot %da now.bowl)/sessions)
==
:: ::
++ on-leave on-leave:def ++ on-leave on-leave:def
++ on-peek on-peek:def ::
++ on-agent on-agent:def ++ on-agent on-agent:def
++ on-fail on-fail:def ++ on-fail on-fail:def
-- --

25
pkg/arvo/app/hood.hoon
View File

@ -2,7 +2,7 @@
/+ drum=hood-drum, helm=hood-helm, kiln=hood-kiln /+ drum=hood-drum, helm=hood-helm, kiln=hood-kiln
|% |%
+$ state +$ state
$: %15 $: %16
drum=state:drum drum=state:drum
helm=state:helm helm=state:helm
kiln=state:kiln kiln=state:kiln
@ -10,14 +10,15 @@
+$ any-state +$ any-state
$% state $% state
[ver=?(%1 %2 %3 %4 %5 %6) lac=(map @tas fin-any-state)] [ver=?(%1 %2 %3 %4 %5 %6) lac=(map @tas fin-any-state)]
[%7 drum=state:drum helm=state:helm kiln=state-1:kiln] [%7 drum=any-state:drum helm=state:helm kiln=state-1:kiln]
[%8 drum=state:drum helm=state:helm kiln=state-1:kiln] [%8 drum=any-state:drum helm=state:helm kiln=state-1:kiln]
[%9 drum=state:drum helm=state:helm kiln=state-1:kiln] [%9 drum=any-state:drum helm=state:helm kiln=state-1:kiln]
[%10 drum=state:drum helm=state:helm kiln=state-1:kiln] [%10 drum=any-state:drum helm=state:helm kiln=state-1:kiln]
[%11 drum=state:drum helm=state:helm kiln=state-1:kiln] [%11 drum=any-state:drum helm=state:helm kiln=state-1:kiln]
[%12 drum=state:drum helm=state:helm kiln=state-1:kiln] [%12 drum=any-state:drum helm=state:helm kiln=state-1:kiln]
[%13 drum=state:drum helm=state:helm kiln=state-1:kiln] [%13 drum=any-state:drum helm=state:helm kiln=state-1:kiln]
[%14 drum=state:drum helm=state:helm kiln=state:kiln] [%14 drum=any-state:drum helm=state:helm kiln=state:kiln]
[%15 drum=any-state:drum helm=state:helm kiln=state:kiln]
== ==
+$ any-state-tuple +$ any-state-tuple
$: drum=any-state:drum $: drum=any-state:drum
@ -83,8 +84,7 @@
:: ::
?+ mark (on-poke:def mark vase) ?+ mark (on-poke:def mark vase)
%atom poke-helm(mark %helm-atom) %atom poke-helm(mark %helm-atom)
%dill-belt poke-drum(mark %drum-dill-belt) %dill-poke poke-drum
%dill-blit poke-drum(mark %drum-dill-blit)
%hood-sync poke-kiln(mark %kiln-sync) %hood-sync poke-kiln(mark %kiln-sync)
%write-sec-atom poke-helm(mark %helm-write-sec-atom) %write-sec-atom poke-helm(mark %helm-write-sec-atom)
== ==
@ -97,7 +97,7 @@
|= =path |= =path
^- step:agent:gall ^- step:agent:gall
?+ path (on-watch:def +<) ?+ path (on-watch:def +<)
[%drum *] =^(c drum.state (peer:drum-core +<) [c this]) [%dill *] =^(c drum.state (peer:drum-core +<) [c this])
== ==
:: ::
++ on-agent ++ on-agent
@ -114,7 +114,6 @@
|= [=wire syn=sign-arvo] |= [=wire syn=sign-arvo]
^- step:agent:gall ^- step:agent:gall
?+ wire ~|([%hood-bad-wire wire] !!) ?+ wire ~|([%hood-bad-wire wire] !!)
[%drum *] =^(c drum.state (take-arvo:drum-core t.wire syn) [c this])
[%helm *] =^(c helm.state (take-arvo:helm-core t.wire syn) [c this]) [%helm *] =^(c helm.state (take-arvo:helm-core t.wire syn) [c this])
[%kiln *] =^(c kiln.state (take-arvo:kiln-core t.wire syn) [c this]) [%kiln *] =^(c kiln.state (take-arvo:kiln-core t.wire syn) [c this])
== ==

4
pkg/arvo/gen/aqua/dojo.hoon
View File

@ -5,8 +5,8 @@
:- %aqua-events :- %aqua-events
%+ turn %+ turn
^- (list unix-event) ^- (list unix-event)
:~ [/d/term/1 %belt %ctl `@c`%e] :~ [/d/term/1 %belt %mod %ctl `@c`%e]
[/d/term/1 %belt %ctl `@c`%u] [/d/term/1 %belt %mod %ctl `@c`%u]
[/d/term/1 %belt %txt ((list @c) command)] [/d/term/1 %belt %txt ((list @c) command)]
[/d/term/1 %belt %ret ~] [/d/term/1 %belt %ret ~]
== ==

93
pkg/arvo/lib/dill.hoon Normal file
View File

@ -0,0 +1,93 @@
:: dill: utilities for dill's data structures
::
=, dill
|%
++ enjs
|%
++ blit
|= =blit:dill
^- json
=, enjs:format
%+ frond -.blit
?- -.blit
%bel b+&
%clr b+&
%hop ?@ p.blit (numb p.blit)
(pairs 'r'^(numb r.p.blit) 'c'^(numb c.p.blit) ~)
%put a+(turn p.blit |=(c=@c s+(tuft c)))
%nel b+&
%url s+p.blit
%wyp b+&
::
%sag
%- pairs
:~ 'path'^(path p.blit)
'file'^s+(en:base64:mimes:html (as-octs:mimes:html (jam q.blit)))
==
::
%sav
%- pairs
:~ 'path'^(path p.blit)
'file'^s+(en:base64:mimes:html (as-octs:mimes:html q.blit))
==
::
%klr
:- %a
%+ turn p.blit
|= [=stye text=(list @c)]
%- pairs
:~ 'text'^a+(turn text |=(c=@c s+(tuft c)))
::
:- 'stye'
%- pairs
|^ :~ 'back'^(color p.q.stye)
'fore'^(color q.q.stye)
'deco'^a+(turn ~(tap in p.stye) |=(d=deco ?~(d ~ s+d)))
==
++ color
|= =tint
?@ tint ?~(tint ~ s+tint)
=, tint
(pairs r+(numb r) g+(numb g) b+(numb b) ~)
--
==
==
--
::
++ dejs
|%
++ belt
|= jon=json
^- belt:dill
?: ?=([%s *] jon)
(taft p.jon)
=, dejs:format
%. jon
%- of
|^ :* mod+(ot 'mod'^mod 'key'^bot ~)
txt+(ar (cu taft so))
bol
==
::
++ bol
:~ aro+(su (perk %d %l %r %u ~))
bac+ul
del+ul
hit+(ot 'r'^ni 'c'^ni ~)
ret+ul
==
::
++ bot
|= j=json
^- bolt:dill
?+ j !!
[%s *] (taft p.j)
[%o *] ((of bol) j)
==
::
++ mod
|= j=json
((su (perk %ctl %met %hyp ~)) j)
--
--
--

391
pkg/arvo/lib/hood/drum.hoon
View File

@ -1,14 +1,14 @@
/- *sole /- *sole
/+ sole /+ sole
|% |%
+$ any-state $%(state) +$ any-state $%(state state-2)
+$ state [%2 pith-2] +$ state [%3 pith]
:: ::
++ pith-2 :: ++ pith ::
$: eel=(set gill:gall) :: connect to $: eel=(set gill:gall) :: connect to
ray=(set well:gall) :: ray=(set well:gall) ::
fur=(map dude:gall (unit server)) :: servers fur=(map dude:gall (unit server)) :: servers
bin=(map bone source) :: terminals bin=(map @ source) :: terminals
== :: == ::
:: :: :: ::
++ server :: running server ++ server :: running server
@ -49,6 +49,42 @@
pom=sole-prompt :: static prompt pom=sole-prompt :: static prompt
inp=sole-command :: input state inp=sole-command :: input state
== :: == ::
::
::
+$ state-2 [%2 pith-2]
::
+$ pith-2
$: eel=(set gill:gall)
ray=(set well:gall)
fur=(map dude:gall (unit server))
bin=(map bone source-2)
==
::
+$ source-2
$: edg=_80
off=@ud
kil=kill
inx=@ud
fug=(map gill:gall (unit target-2))
mir=(pair @ud stub)
==
::
+$ target-2
$: $= blt
%+ pair
(unit dill-belt-2)
(unit dill-belt-2)
ris=(unit search)
hit=history
pom=sole-prompt
inp=sole-command
==
::
+$ dill-belt-2
$% [%ctl p=@c]
[%met p=@c]
dill-belt:dill
==
-- --
:: :: :: :: :: ::
:::: :: :: :::: :: ::
@ -121,26 +157,34 @@
++ en-gill :: gill to wire ++ en-gill :: gill to wire
|= gyl=gill:gall |= gyl=gill:gall
^- wire ^- wire
::TODO include session?
[%drum %phat (scot %p p.gyl) q.gyl ~] [%drum %phat (scot %p p.gyl) q.gyl ~]
:: ::
++ de-gill :: gill from wire ++ de-gill :: gill from wire
|= way=wire ^- gill:gall |= way=wire ^- gill:gall
?>(?=([@ @ ~] way) [(slav %p i.way) i.t.way]) ?>(?=([@ @ ~] way) [(slav %p i.way) i.t.way])
-- --
:: TODO: remove .ost
:: ::
|= [hid=bowl:gall state] |= [hid=bowl:gall state]
=* sat +<+ =* sat +<+
=/ ost 0 =/ ses=@tas %$
=+ (~(gut by bin) ost *source) =+ (~(gut by bin) ses *source)
=* dev - =* dev -
=| moz=(list card:agent:gall) =| moz=(list card:agent:gall)
=| biz=(list dill-blit:dill) =| biz=(list dill-blit:dill)
|% |%
++ this . ++ this .
++ klr klr:format
+$ state ^state :: proxy +$ state ^state :: proxy
+$ any-state ^any-state :: proxy +$ any-state ^any-state :: proxy
++ on-init se-abet:this(eel (deft-fish our.hid)) ++ on-init se-abet:this(eel (deft-fish our.hid))
::
++ prep
|= s=@tas
=. ses ses
=. dev (~(gut by bin) ses *source)
this
::
++ diff-sole-effect-phat :: app event ++ diff-sole-effect-phat :: app event
|= [way=wire fec=sole-effect] |= [way=wire fec=sole-effect]
=< se-abet =< se-view =< se-abet =< se-view
@ -150,6 +194,8 @@
:: ::
++ peer :: ++ peer ::
|= pax=path |= pax=path
=? this ?=([%dill @ ~] pax)
(prep i.t.pax)
~| [%drum-unauthorized our+our.hid src+src.hid] :: ourself ~| [%drum-unauthorized our+our.hid src+src.hid] :: ourself
?> (team:title our.hid src.hid) :: or our own moon ?> (team:title our.hid src.hid) :: or our own moon
=< se-abet =< se-view =< se-abet =< se-view
@ -166,15 +212,15 @@
=. ray (deft-apes our.hid lit) =. ray (deft-apes our.hid lit)
[~ sat] [~ sat]
:: ::
++ poke-dill
|= [ses=@tas bet=dill-belt:dill]
(poke-dill-belt:(prep ses) bet)
::
++ poke-dill-belt :: terminal event ++ poke-dill-belt :: terminal event
|= bet=dill-belt:dill |= bet=dill-belt:dill
=< se-abet =< se-view =< se-abet =< se-view
(se-belt bet) (se-belt bet)
:: ::
++ poke-dill-blit :: terminal output
|= bit=dill-blit:dill
se-abet:(se-blit-sys bit)
::
++ poke-start :: start app ++ poke-start :: start app
|= wel=well:gall |= wel=well:gall
=< se-abet =< se-view =< se-abet =< se-view
@ -206,8 +252,7 @@
++ poke ++ poke
|= [=mark =vase] |= [=mark =vase]
?+ mark ~|([%poke-drum-bad-mark mark] !!) ?+ mark ~|([%poke-drum-bad-mark mark] !!)
%drum-dill-belt =;(f (f !<(_+<.f vase)) poke-dill-belt) %dill-poke =;(f (f !<(_+<.f vase)) poke-dill)
%drum-dill-blit =;(f (f !<(_+<.f vase)) poke-dill-blit)
%drum-exit =;(f (f !<(_+<.f vase)) poke-exit) %drum-exit =;(f (f !<(_+<.f vase)) poke-exit)
%drum-link =;(f (f !<(_+<.f vase)) poke-link) %drum-link =;(f (f !<(_+<.f vase)) poke-link)
%drum-put =;(f (f !<(_+<.f vase)) poke-put) %drum-put =;(f (f !<(_+<.f vase)) poke-put)
@ -218,53 +263,89 @@
== ==
:: ::
++ on-load ++ on-load
|= [hood-version=@ud old=any-state] |^ |= [hood-version=@ud old=any-state]
=< se-abet =< se-view =< se-abet =< se-view
=. sat old =. sat (load-state old)
=. dev (~(gut by bin) ost *source) =. dev (~(gut by bin) ses *source)
=? ..on-load (lte hood-version %4) (load-apps hood-version)
~> %slog.0^leaf+"drum: starting os1 agents" ::
=> (se-born | %home %s3-store) ++ load-state
=> (se-born | %home %contact-view) |= old=any-state
=> (se-born | %home %contact-hook) ^- state
=> (se-born | %home %contact-store) ?- -.old
=> (se-born | %home %metadata-hook) %3 old
=> (se-born | %home %metadata-store) %2 [%3 (pith-2-to-3 +.old)]
=> (se-born | %home %goad) ==
~> %slog.0^leaf+"drum: resubscribing to %dojo and %chat-cli" ::
=> (se-drop:(se-pull our.hid %dojo) | our.hid %dojo) ++ pith-2-to-3
(se-drop:(se-pull our.hid %chat-cli) | our.hid %chat-cli) |= p=pith-2
=? ..on-load (lte hood-version %5) ^- pith
(se-born | %home %file-server) p(bin (~(run by bin.p) source-2-to-3))
=? ..on-load (lte hood-version %7) ::
(se-born | %home %glob) ++ source-2-to-3
=? ..on-load (lte hood-version %8) |= s=source-2
=> (se-born | %home %group-push-hook) ^- source
(se-born | %home %group-pull-hook) s(fug (~(run by fug.s) |=(t=(unit target-2) (bind t target-2-to-3))))
=? ..on-load (lte hood-version %9) ::
(se-born | %home %graph-store) ++ target-2-to-3
=? ..on-load (lte hood-version %10) |= t=target-2
=> (se-born | %home %graph-push-hook) ^- target
(se-born | %home %graph-pull-hook) :_ +.t
=? ..on-load (lte hood-version %11) :- (bind p.blt.t belt-2-to-3)
=> (se-born | %home %hark-graph-hook) (bind q.blt.t belt-2-to-3)
=> (se-born | %home %hark-group-hook) ::
=> (se-born | %home %hark-chat-hook) ++ belt-2-to-3
=> (se-born | %home %hark-store) |= b=dill-belt-2
=> (se-born | %home %observe-hook) ^- dill-belt:dill
=> (se-born | %home %metadata-pull-hook) ?. ?=(?(%ctl %met) -.b) b
=> (se-born | %home %metadata-push-hook) [%mod -.b p.b]
(se-born | %home %herm) ::
=? ..on-load (lte hood-version %12) ++ load-apps
=> (se-born | %home %contact-push-hook) |= hood-version=@ud
=> (se-born | %home %contact-pull-hook) =? ..on-load (lte hood-version %4)
=> (se-born | %home %settings-store) ~> %slog.0^leaf+"drum: starting os1 agents"
(se-born | %home %group-view) => (se-born | %home %s3-store)
=? ..on-load (lte hood-version %13) => (se-born | %home %contact-view)
(se-born | %home %dm-hook) => (se-born | %home %contact-hook)
=? ..on-load (lte hood-version %15) => (se-born | %home %contact-store)
(se-born | %home %notify) => (se-born | %home %metadata-hook)
..on-load => (se-born | %home %metadata-store)
=> (se-born | %home %goad)
~> %slog.0^leaf+"drum: resubscribing to %dojo and %chat-cli"
=> (se-drop:(se-pull our.hid %dojo) | our.hid %dojo)
(se-drop:(se-pull our.hid %chat-cli) | our.hid %chat-cli)
=? ..on-load (lte hood-version %5)
(se-born | %home %file-server)
=? ..on-load (lte hood-version %7)
(se-born | %home %glob)
=? ..on-load (lte hood-version %8)
=> (se-born | %home %group-push-hook)
(se-born | %home %group-pull-hook)
=? ..on-load (lte hood-version %9)
(se-born | %home %graph-store)
=? ..on-load (lte hood-version %10)
=> (se-born | %home %graph-push-hook)
(se-born | %home %graph-pull-hook)
=? ..on-load (lte hood-version %11)
=> (se-born | %home %hark-graph-hook)
=> (se-born | %home %hark-group-hook)
=> (se-born | %home %hark-chat-hook)
=> (se-born | %home %hark-store)
=> (se-born | %home %observe-hook)
=> (se-born | %home %metadata-pull-hook)
=> (se-born | %home %metadata-push-hook)
(se-born | %home %herm)
=? ..on-load (lte hood-version %12)
=> (se-born | %home %contact-push-hook)
=> (se-born | %home %contact-pull-hook)
=> (se-born | %home %settings-store)
(se-born | %home %group-view)
=? ..on-load (lte hood-version %13)
(se-born | %home %dm-hook)
=? ..on-load (lte hood-version %15)
(se-born | %home %notify)
..on-load
--
:: ::
++ reap-phat :: ack connect ++ reap-phat :: ack connect
|= [way=wire saw=(unit tang)] |= [way=wire saw=(unit tang)]
@ -277,12 +358,6 @@
:: ::
(se-drop & gyl) (se-drop & gyl)
:: ::
++ take-arvo
|= [=wire =sign-arvo]
%+ take-onto wire
?> ?=(%onto +<.sign-arvo)
+>.sign-arvo
::
++ take-coup-phat :: ack poke ++ take-coup-phat :: ack poke
|= [way=wire saw=(unit tang)] |= [way=wire saw=(unit tang)]
=< se-abet =< se-view =< se-abet =< se-view
@ -293,19 +368,6 @@
:_ u.saw :_ u.saw
>[%drum-coup-fail src.hid gyl]< >[%drum-coup-fail src.hid gyl]<
:: ::
++ take-onto :: ack start
|= [way=wire saw=(each suss:gall tang)]
=< se-abet =< se-view
?> ?=([@ @ ~] way)
?> (~(has by fur) i.t.way)
=/ wel=well:gall [i.way i.t.way]
?- saw
[%| *] (se-dump p.saw)
[%& *] ?> =(q.wel p.p.saw)
:: =. +>.$ (se-text "live {<p.saw>}")
+>.$(fur (~(put by fur) q.wel `[p.wel %da r.p.saw]))
==
::
++ take-agent ++ take-agent
|= [=wire =sign:agent:gall] |= [=wire =sign:agent:gall]
?+ wire ~|([%drum-bad-take-agent wire -.sign] !!) ?+ wire ~|([%drum-bad-take-agent wire -.sign] !!)
@ -333,12 +395,13 @@
++ se-abet :: resolve ++ se-abet :: resolve
^- (quip card:agent:gall state) ^- (quip card:agent:gall state)
=. . se-subze:se-adze:se-subit:se-adit =. . se-subze:se-adze:se-subit:se-adit
:_ sat(bin (~(put by bin) ost dev)) :_ sat(bin (~(put by bin) ses dev))
^- (list card:agent:gall) ^- (list card:agent:gall)
?~ biz (flop moz) ?~ biz (flop moz)
:_ (flop moz) :_ (flop moz)
=/ =dill-blit:dill ?~(t.biz i.biz [%mor (flop biz)]) =/ =dill-blit:dill ?~(t.biz i.biz [%mor (flop biz)])
[%give %fact ~[/drum] %dill-blit !>(dill-blit)] ::TODO remove /drum after dill cleans up
[%give %fact ~[/drum /dill/[ses]] %dill-blit !>(dill-blit)]
:: ::
++ se-adit :: update servers ++ se-adit :: update servers
^+ this ^+ this
@ -423,14 +486,14 @@
(se-peer gil) (se-peer gil)
:: ::
++ se-subze :: downdate connections ++ se-subze :: downdate connections
=< .(dev (~(got by bin) ost)) =< .(dev (~(got by bin) ses))
=. bin (~(put by bin) ost dev) =. bin (~(put by bin) ses dev)
^+ . ^+ .
%- ~(rep by bin) %- ~(rep by bin)
=< .(con +>) =< .(con +>)
|: $:,[[ost=bone dev=source] con=_.] ^+ con |: $:,[[ses=@tas dev=source] con=_.] ^+ con
=+ xeno=se-subze-local:%_(con ost ost, dev dev) =+ xeno=se-subze-local:%_(con ses ses, dev dev)
xeno(ost ost.con, dev dev.con, bin (~(put by bin) ost dev.xeno)) xeno(ses ses.con, dev dev.con, bin (~(put by bin) ses dev.xeno))
:: ::
++ se-subze-local ++ se-subze-local
^+ . ^+ .
@ -445,7 +508,7 @@
++ se-aint :: ignore result ++ se-aint :: ignore result
|= gyl=gill:gall |= gyl=gill:gall
^- ? ^- ?
?. (~(has by bin) ost) & ?. (~(has by bin) ses) &
=+ gyr=(~(get by fug) gyl) =+ gyr=(~(get by fug) gyl)
|(?=(~ gyr) ?=(~ u.gyr)) |(?=(~ gyr) ?=(~ u.gyr))
:: ::
@ -554,6 +617,21 @@
leaf+(weld (scag (sub edg 3) tape) "...") leaf+(weld (scag (sub edg 3) tape) "...")
leaf+tape leaf+tape
:: ::
++ se-blin :: print and newline
|= $= lin
$~ [%put ~]
$>(?(%put %klr) dill-blit:dill)
^+ +>
:: newline means we need to redraw the prompt,
:: so update the prompt mirror accordingly.
::
=. mir [0 ~]
::TODO doing hops and wyps conditionally based on the mirror state seems
:: better, but doesn't cover edge cases. results in dojo's ">=" being
:: rendered alongside the prompt in scrollback, for example.
:: figure out a way to make that work!
(se-blit %mor [%hop 0] [%wyp ~] lin [%nel ~] ~)
::
++ se-dump :: print tanks ++ se-dump :: print tanks
|= tac=(list tank) |= tac=(list tank)
^+ +> ^+ +>
@ -564,7 +642,7 @@
?. ((sane %t) (crip i.wol)) :: XX upstream validation ?. ((sane %t) (crip i.wol)) :: XX upstream validation
~& bad-text+<`*`i.wol> ~& bad-text+<`*`i.wol>
$(wol t.wol) $(wol t.wol)
$(wol t.wol, +>.^$ (se-blit %out (tuba i.wol))) $(wol t.wol, +>.^$ (se-blin %put (tuba i.wol)))
:: ::
++ se-join :: confirm connection ++ se-join :: confirm connection
|= gyl=gill:gall |= gyl=gill:gall
@ -597,15 +675,16 @@
:: ::
++ se-blit-sys :: output to system ++ se-blit-sys :: output to system
|= bil=dill-blit:dill ^+ +> |= bil=dill-blit:dill ^+ +>
(se-emit %give %fact ~[/drum] %dill-blit !>(bil)) ::TODO remove /drum after dill cleans up
(se-emit %give %fact ~[/drum /dill/[ses]] %dill-blit !>(bil))
:: ::
++ se-show :: show buffer, raw ++ se-show :: show buffer, raw
|= lin=(pair @ud stub) |= lin=(pair @ud stub)
^+ +> ^+ +>
?: =(mir lin) +> ?: =(mir lin) +>
=. +> ?:(=(p.mir p.lin) +> (se-blit %hop p.lin)) %- se-blit(mir lin)
=. +> ?:(=(q.mir q.lin) +> (se-blit %pom q.lin)) ?: =(q.mir q.lin) [%hop p.lin]
+>(mir lin) mor+[[%hop 0] [%wyp ~] [%klr q.lin] [%hop p.lin] ~]
:: ::
++ se-just :: adjusted buffer ++ se-just :: adjusted buffer
|= [pom=stub lin=(pair @ud (list @c))] |= [pom=stub lin=(pair @ud (list @c))]
@ -643,7 +722,7 @@
?. ((sane %t) (crip txt)) :: XX upstream validation ?. ((sane %t) (crip txt)) :: XX upstream validation
~& bad-text+<`*`txt> ~& bad-text+<`*`txt>
+> +>
(se-blit %out (tuba txt)) (se-blin %put (tuba txt))
:: ::
++ se-poke :: send a poke ++ se-poke :: send a poke
|= [gyl=gill:gall par=cage] |= [gyl=gill:gall par=cage]
@ -651,6 +730,7 @@
:: ::
++ se-peer :: send a peer ++ se-peer :: send a peer
|= gyl=gill:gall |= gyl=gill:gall
::TODO include session
=/ =path /sole/(cat 3 'drum_' (scot %p our.hid)) =/ =path /sole/(cat 3 'drum_' (scot %p our.hid))
%- se-emit(fug (~(put by fug) gyl ~)) %- se-emit(fug (~(put by fug) gyl ~))
[%pass (en-gill gyl) %agent gyl %watch path] [%pass (en-gill gyl) %agent gyl %watch path]
@ -711,13 +791,19 @@
?< ?=([?(%cru %hey %rez %yow) *] bet) :: target-specific ?< ?=([?(%cru %hey %rez %yow) *] bet) :: target-specific
=. blt [q.blt `bet] :: remember belt =. blt [q.blt `bet] :: remember belt
?- bet ?- bet
@ (ta-txt bet ~)
[%aro *] (ta-aro p.bet) [%aro *] (ta-aro p.bet)
[%bac *] ta-bac [%bac *] ta-bac
[%ctl *] (ta-ctl p.bet)
[%del *] ta-del [%del *] ta-del
[%met *] (ta-met p.bet) [%hit *] (ta-hit +.bet)
[%ret *] ta-ret [%ret *] ta-ret
[%txt *] (ta-txt p.bet) [%txt *] (ta-txt p.bet)
::
[%mod *]
?+ mod.bet $(bet key.bet)
%ctl (ta-ctl key.bet)
%met (ta-met key.bet)
==
== ==
:: ::
++ ta-det :: send edit ++ ta-det :: send edit
@ -741,7 +827,7 @@
(ta-hom %del (dec pos.inp)) (ta-hom %del (dec pos.inp))
:: ::
++ ta-ctl :: hear control ++ ta-ctl :: hear control
|= key=@ud |= key=bolt:dill
^+ +> ^+ +>
=. ris ?.(?=(?(%g %r) key) ~ ris) =. ris ?.(?=(?(%g %r) key) ~ ris)
?+ key ta-bel ?+ key ta-bel
@ -762,7 +848,7 @@
?: =(pos.inp len) ?: =(pos.inp len)
ta-bel ta-bel
(ta-kil %r [pos.inp (sub len pos.inp)]) (ta-kil %r [pos.inp (sub len pos.inp)])
%l +>(..ta (se-blit %clr ~)) %l +>(..ta (se-blit(q.mir ~) %clr ~))
%n (ta-aro %d) %n (ta-aro %d)
%p (ta-aro %u) %p (ta-aro %u)
%r ?~ ris %r ?~ ris
@ -795,6 +881,15 @@
ta-bel ta-bel
(ta-hom %del pos.inp) (ta-hom %del pos.inp)
:: ::
++ ta-hit :: hear click
|= [r=@ud c=@ud]
^+ +>
?. =(0 r) +>
=/ pol=@ud
(lent-char:klr (make:klr cad.pom))
?: (lth c pol) +>.$
+>.$(pos.inp (min (sub c pol) (lent buf.say.inp)))
::
++ ta-erl :: hear local error ++ ta-erl :: hear local error
|= pos=@ud |= pos=@ud
ta-bel(pos.inp (min pos (lent buf.say.inp))) ta-bel(pos.inp (min pos (lent buf.say.inp)))
@ -806,14 +901,13 @@
++ ta-fec :: apply effect ++ ta-fec :: apply effect
|= fec=sole-effect |= fec=sole-effect
^+ +> ^+ +>
?- fec ?+ fec +>(..ta (se-blit fec))
[%bel *] ta-bel [%bel *] ta-bel
[%blk *] +> [%blk *] +>
[%bye *] +>(..ta (se-klin gyl)) [%bye *] +>(..ta (se-klin gyl))
[%clr *] +>(..ta (se-blit fec))
[%det *] (ta-got +.fec) [%det *] (ta-got +.fec)
[%err *] (ta-err p.fec) [%err *] (ta-err p.fec)
[%klr *] +>(..ta (se-blit %klr (make:klr p.fec))) [%klr *] +>(..ta (se-blin %klr (make:klr p.fec)))
[%mor *] |- ^+ +>.^$ [%mor *] |- ^+ +>.^$
?~ p.fec +>.^$ ?~ p.fec +>.^$
$(p.fec t.p.fec, +>.^$ ^$(fec i.p.fec)) $(p.fec t.p.fec, +>.^$ ^$(fec i.p.fec))
@ -821,10 +915,8 @@
[%pro *] (ta-pro +.fec) [%pro *] (ta-pro +.fec)
[%tab *] +>(..ta (se-tab p.fec)) [%tab *] +>(..ta (se-tab p.fec))
[%tan *] +>(..ta (se-dump p.fec)) [%tan *] +>(..ta (se-dump p.fec))
[%sag *] +>(..ta (se-blit fec))
[%sav *] +>(..ta (se-blit fec))
[%txt *] +>(..ta (se-text p.fec)) [%txt *] +>(..ta (se-text p.fec))
[%url *] +>(..ta (se-blit fec)) [%url *] +>(..ta (se-text:(se-blit fec) (trip p.fec)))
== ==
:: ::
++ ta-dog :: change cursor ++ ta-dog :: change cursor
@ -876,8 +968,8 @@
kil kil
?. ?& ?=(^ old.kil) ?. ?& ?=(^ old.kil)
?=(^ p.blt) ?=(^ p.blt)
?| ?=([%ctl ?(%k %u %w)] u.p.blt) ?| ?=([%mod %ctl ?(%k %u %w)] u.p.blt)
?=([%met ?(%d %bac)] u.p.blt) ?=([%mod %met ?(%d [%bac ~])] u.p.blt)
== == == ==
%= kil :: prepend %= kil :: prepend
num +(num.kil) num +(num.kil)
@ -894,17 +986,18 @@
== ==
:: ::
++ ta-met :: meta key ++ ta-met :: meta key
|= key=@ud |= key=bolt:dill
^+ +> ^+ +>
=. ris ~ =. ris ~
?+ key ta-bel ?+ key ta-bel
%dot ?. &(?=(^ old.hit) ?=(^ i.old.hit)) :: last "arg" from hist %'.' ?. &(?=(^ old.hit) ?=(^ i.old.hit)) :: last "arg" from hist
ta-bel ta-bel
=+ old=`(list @c)`i.old.hit =+ old=`(list @c)`i.old.hit
=+ sop=(ta-jump(buf.say.inp old) %l %ace (lent old)) =+ sop=(ta-jump(buf.say.inp old) %l %ace (lent old))
(ta-hom (cat:edit pos.inp (slag sop old))) (ta-hom (cat:edit pos.inp (slag sop old)))
:: ::
%bac ?: =(0 pos.inp) :: kill left-word [%bac ~]
?: =(0 pos.inp) :: kill left-word
ta-bel ta-bel
=+ sop=(ta-pos %l %edg pos.inp) =+ sop=(ta-pos %l %edg pos.inp)
(ta-kil %l [(sub pos.inp sop) sop]) (ta-kil %l [(sub pos.inp sop) sop])
@ -960,8 +1053,8 @@
:: ::
%y ?. ?& ?=(^ old.kil) :: rotate & yank %y ?. ?& ?=(^ old.kil) :: rotate & yank
?=(^ p.blt) ?=(^ p.blt)
?| ?=([%ctl %y] u.p.blt) ?| ?=([%mod %ctl %y] u.p.blt)
?=([%met %y] u.p.blt) ?=([%mod %met %y] u.p.blt)
== == == ==
ta-bel ta-bel
=+ las=(lent ta-yan) =+ las=(lent ta-yan)
@ -1139,82 +1232,4 @@
?: |(?=(~ a) (alnm i.a)) i ?: |(?=(~ a) (alnm i.a)) i
$(i +(i), a t.a) $(i +(i), a t.a)
-- --
::
++ klr :: styx/stub engine
=, dill
|%
++ make :: stub from styx
|= a=styx ^- stub
=| b=stye
%+ reel
|- ^- stub
%- zing %+ turn a
|= a=$@(@t (pair styl styx))
?@ a [b (tuba (trip a))]~
^$(a q.a, b (styd p.a b))
::
|= [a=(pair stye (list @c)) b=stub]
?~ b [a ~]
?. =(p.a p.i.b) [a b]
[[p.a (weld q.a q.i.b)] t.b]
::
++ styd :: stye from styl
|= [a=styl b=stye] ^+ b :: with inheritance
:+ ?~ p.a p.b
?~ u.p.a ~
(~(put in p.b) u.p.a)
(fall p.q.a p.q.b)
(fall q.q.a q.q.b)
::
++ lent-char
|= a=stub ^- @
(roll (lnts-char a) add)
::
++ lnts-char :: stub pair tail lengths
|= a=stub ^- (list @)
%+ turn a
|= a=(pair stye (list @c))
(lent q.a)
::
++ brek :: index + incl-len of
|= [a=@ b=(list @)] :: stub pair w= idx a
=| [c=@ i=@]
|- ^- (unit (pair @ @))
?~ b ~
=. c (add c i.b)
?: (gte c a)
`[i c]
$(i +(i), b t.b)
::
++ slag :: slag stub, keep stye
|= [a=@ b=stub]
^- stub
=+ c=(lnts-char b)
=+ i=(brek a c)
?~ i b
=+ r=(^slag +(p.u.i) b)
?: =(a q.u.i)
r
=+ n=(snag p.u.i b)
:_ r :- p.n
(^slag (sub (snag p.u.i c) (sub q.u.i a)) q.n)
::
++ scag :: scag stub, keep stye
|= [a=@ b=stub]
^- stub
=+ c=(lnts-char b)
=+ i=(brek a c)
?~ i b
?: =(a q.u.i)
(^scag +(p.u.i) b)
%+ welp
(^scag p.u.i b)
=+ n=(snag p.u.i b)
:_ ~ :- p.n
(^scag (sub (snag p.u.i c) (sub q.u.i a)) q.n)
::
++ swag :: swag stub, keep stye
|= [[a=@ b=@] c=stub]
(scag b (slag a c))
--
-- --

8
pkg/arvo/lib/ph/util.hoon
View File

@ -28,8 +28,8 @@
%+ send-events-to who %+ send-events-to who
^- (list unix-event) ^- (list unix-event)
:~ :~
[/d/term/1 %belt %ctl `@c`%e] [/d/term/1 %belt %mod %ctl `@c`%e]
[/d/term/1 %belt %ctl `@c`%u] [/d/term/1 %belt %mod %ctl `@c`%u]
[/d/term/1 %belt %txt ((list @c) what)] [/d/term/1 %belt %txt ((list @c) what)]
[/d/term/1 %belt %ret ~] [/d/term/1 %belt %ret ~]
== ==
@ -40,7 +40,7 @@
|= [who=ship what=term] |= [who=ship what=term]
^- (list ph-event) ^- (list ph-event)
%+ send-events-to who %+ send-events-to who
:~ [/d/term/1 %belt %ctl (,@c what)] :~ [/d/term/1 %belt %mod %ctl (,@c what)]
== ==
:: ::
:: Inject a file into a ship :: Inject a file into a ship
@ -67,7 +67,7 @@
:: ::
%+ lien p.q.uf %+ lien p.q.uf
|= =blit:dill |= =blit:dill
?. ?=(%lin -.blit) ?. ?=(%put -.blit)
| |
!=(~ (find what p.blit)) !=(~ (find what p.blit))
== ==

15
pkg/arvo/mar/belt.hoon
View File

@ -1,5 +1,7 @@
:: belt: runtime belt structure :: belt: runtime belt structure
:: ::
/+ dill
::
|_ =belt:dill |_ =belt:dill
++ grad %noun ++ grad %noun
:: +grab: convert from :: +grab: convert from
@ -7,18 +9,7 @@
++ grab ++ grab
|% |%
++ noun belt:dill ++ noun belt:dill
++ json ++ json belt:dejs:dill
^- $-(^json belt:dill)
=, dejs:format
%- of
:~ aro+(su (perk %d %l %r %u ~))
bac+ul
ctl+(cu taft so)
del+ul
met+(cu taft so)
ret+ul
txt+(ar (cu taft so))
==
-- --
:: +grow: convert to :: +grow: convert to
:: ::

47
pkg/arvo/mar/blit.hoon
View File

@ -1,5 +1,7 @@
:: blit: runtime blit structure :: blit: runtime blit structure
:: ::
/+ dill
::
|_ =blit:dill |_ =blit:dill
++ grad %noun ++ grad %noun
:: +grab: convert from :: +grab: convert from
@ -13,49 +15,6 @@
++ grow ++ grow
|% |%
++ noun blit ++ noun blit
++ json ++ json (blit:enjs:dill blit)
^- ^json
=, enjs:format
%+ frond -.blit
?- -.blit
%bel b+&
%clr b+&
%hop (numb p.blit)
%lin a+(turn p.blit |=(c=@c s+(tuft c)))
%mor b+&
%url s+p.blit
::
%sag
%- pairs
:~ 'path'^(path p.blit)
'file'^s+(en:base64:mimes:html (as-octs:mimes:html (jam q.blit)))
==
::
%sav
%- pairs
:~ 'path'^(path p.blit)
'file'^s+(en:base64:mimes:html (as-octs:mimes:html q.blit))
==
::
%klr
:- %a
%+ turn p.blit
|= [=stye text=(list @c)]
%- pairs
:~ 'text'^a+(turn text |=(c=@c s+(tuft c)))
::
:- 'stye'
%- pairs
|^ :~ 'back'^(color p.q.stye)
'fore'^(color q.q.stye)
'deco'^a+(turn ~(tap in p.stye) |=(d=deco ?~(d ~ s+d)))
==
++ color
|= =tint
?@ tint ?~(tint ~ s+tint)
s+(crip ((x-co:co 6) (rep 3 ~[b g r]:tint)))
--
==
==
-- --
-- --

4
pkg/arvo/mar/dill/belt.hoon
View File

@ -45,8 +45,8 @@
=+ cha=(tuba (trip q.kev)) =+ cha=(tuba (trip q.kev))
?> ?=([@ ~] cha) :: of a single character ?> ?=([@ ~] cha) :: of a single character
?+ mod !! :: modified by one buckykey ?+ mod !! :: modified by one buckykey
[%ctrl ~ ~] [%ctl i.cha] [%ctrl ~ ~] [%mod %ctl i.cha]
[%alt ~ ~] [%met i.cha] [%alt ~ ~] [%mod %met i.cha]
== ==
?@ q.kev ?@ q.kev
[%txt (tuba (trip q.kev))] [%txt (tuba (trip q.kev))]

6
pkg/arvo/mar/dill/blit.hoon
View File

@ -19,8 +19,10 @@
^- ^json ^- ^json
?+ -.dib ~|(unsupported-blit+-.dib !!) ?+ -.dib ~|(unsupported-blit+-.dib !!)
%mor [%a (turn p.dib |=(a=dill-blit:dill json(dib a)))] %mor [%a (turn p.dib |=(a=dill-blit:dill json(dib a)))]
%hop (frond %hop (numb p.dib)) %hop %+ frond %hop
?(%pro %out) (frond -.dib (tape (tufa p.dib))) ?@ p.dib (numb p.dib)
(pairs 'r'^(numb r.p.dib) 'c'^(numb c.p.dib) ~)
%put (frond -.dib (tape (tufa p.dib)))
?(%bel %clr) (frond %act %s -.dib) ?(%bel %clr) (frond %act %s -.dib)
== ==
-- --

46
pkg/arvo/mar/herm/task.hoon Normal file
View File

@ -0,0 +1,46 @@
:: task: herm task for passthrough to dill
::
/- herm
/+ dill
::
|_ =task:herm
++ grad %noun
:: +grab: convert from
::
++ grab
|%
++ noun task:herm
::
++ json
|= jon=^json
^+ task
~| jon
?> ?=([%o *] jon)
=+ ses=(~(got by p.jon) 'session')
?> ?=([%s *] ses)
:- ?: =('' p.ses) %$
(slav %tas p.ses)
=. p.jon (~(del by p.jon) 'session')
%. jon
=, dejs:format
|^ task
++ task
%- of
:~ belt+belt:dejs:^dill
blew+(ot 'w'^ni 'h'^ni ~)
hail+ul
open+(ot 'term'^(se %tas) 'apps'^(ar gill) ~)
shut+ul
==
::
++ gill
(ot 'who'^(se %p) 'app'^(se %tas) ~)
--
--
:: +grow: convert to
::
++ grow
|%
++ noun task
--
--

9
pkg/arvo/sur/herm.hoon Normal file
View File

@ -0,0 +1,9 @@
:: herm: stand-in for term.c with http interface
::
|%
+$ task
$~ [%$ %hail ~]
$: session=@tas
task=$>(?(%open %shut %belt %blew %hail) session-task:dill)
==
--

86
pkg/arvo/sys/lull.hoon
View File

@ -741,7 +741,6 @@
[%hill p=(list @tas)] :: mount points [%hill p=(list @tas)] :: mount points
[%done error=(unit error:ames)] :: ames message (n)ack [%done error=(unit error:ames)] :: ames message (n)ack
[%mere p=(each (set path) (pair term tang))] :: merge result [%mere p=(each (set path) (pair term tang))] :: merge result
[%note p=@tD q=tank] :: debug message
[%ogre p=@tas] :: delete mount point [%ogre p=@tas] :: delete mount point
[%rule red=dict wit=dict] :: node r+w permissions [%rule red=dict wit=dict] :: node r+w permissions
[%writ p=riot] :: response [%writ p=riot] :: response
@ -1031,9 +1030,7 @@
++ dill ^? ++ dill ^?
|% |%
+$ gift :: out result <-$ +$ gift :: out result <-$
$% [%bbye ~] :: reset prompt $% [%blit p=(list blit)] :: terminal output
[%blit p=(list blit)] :: terminal output
[%burl p=@t] :: activate url
[%logo ~] :: logout [%logo ~] :: logout
[%meld ~] :: unify memory [%meld ~] :: unify memory
[%pack ~] :: compact memory [%pack ~] :: compact memory
@ -1041,29 +1038,32 @@
== :: == ::
+$ task :: in request ->$ +$ task :: in request ->$
$~ [%vega ~] :: $~ [%vega ~] ::
$% [%belt p=belt] :: terminal input $% [%boot lit=? p=*] :: weird %dill boot
[%blew p=blew] :: terminal config
[%boot lit=? p=*] :: weird %dill boot
[%crop p=@ud] :: trim kernel state [%crop p=@ud] :: trim kernel state
[%crud p=@tas q=(list tank)] :: print error [%crud p=@tas q=(list tank)] :: print error
[%flee session=~] :: unwatch session
[%flog p=flog] :: wrapped error [%flog p=flog] :: wrapped error
[%flow p=@tas q=(list gill:gall)] :: terminal config
[%hail ~] :: terminal refresh
[%heft ~] :: memory report [%heft ~] :: memory report
[%hook ~] :: this term hung up
[%harm ~] :: all terms hung up
$>(%init vane-task) :: after gall ready $>(%init vane-task) :: after gall ready
[%meld ~] :: unify memory [%meld ~] :: unify memory
[%noop ~] :: no operation
[%pack ~] :: compact memory [%pack ~] :: compact memory
[%talk p=tank] :: [%shot ses=@tas task=session-task] :: task for session
[%text p=tape] :: [%talk p=(list tank)] :: print tanks
[%view session=~] :: watch session blits [%text p=tape] :: print tape
$>(%trim vane-task) :: trim state $>(%trim vane-task) :: trim state
$>(%vega vane-task) :: report upgrade $>(%vega vane-task) :: report upgrade
[%verb ~] :: verbose mode [%verb ~] :: verbose mode
[%knob tag=term level=?(%hush %soft %loud)] :: error verbosity [%knob tag=term level=?(%hush %soft %loud)] :: error verbosity
session-task :: for default session
== ::
:: ::
+$ session-task :: session request
$% [%belt p=belt] :: terminal input
[%blew p=blew] :: terminal config
[%flee ~] :: unwatch session
[%hail ~] :: terminal refresh
[%open p=dude:gall q=(list gill:gall)] :: setup session
[%shut ~] :: close session
[%view ~] :: watch session blits
== :: == ::
:: ::
:::: :: (1d2) :::: :: (1d2)
@ -1071,14 +1071,10 @@
+$ blew [p=@ud q=@ud] :: columns rows +$ blew [p=@ud q=@ud] :: columns rows
+$ belt :: client input +$ belt :: client input
$? bolt :: simple input $? bolt :: simple input
$% [%mod mod=?(%ctl %met %hyp) key=bolt] :: w/ modifier [%mod mod=?(%ctl %met %hyp) key=bolt] :: w/ modifier
[%txt p=(list @c)] :: utf32 text [%txt p=(list @c)] :: utf32 text
::TODO consider moving %hey, %rez, %yow here :: ::TODO consider moving %hey, %rez, %yow here ::
::TMP forward backwards-compatibility :: == ::
:: ::
[%ctl p=@c] ::
[%met p=@c] ::
== == ::
+$ bolt :: simple input +$ bolt :: simple input
$@ @c :: simple keystroke $@ @c :: simple keystroke
$% [%aro p=?(%d %l %r %u)] :: arrow key $% [%aro p=?(%d %l %r %u)] :: arrow key
@ -1087,43 +1083,29 @@
[%hit r=@ud c=@ud] :: mouse click [%hit r=@ud c=@ud] :: mouse click
[%ret ~] :: return [%ret ~] :: return
== :: == ::
+$ blit :: old blit +$ blit :: client output
$% [%bel ~] :: make a noise $% [%bel ~] :: make a noise
[%clr ~] :: clear the screen [%clr ~] :: clear the screen
[%hop p=@ud] :: set cursor position [%hop p=$@(@ud [r=@ud c=@ud])] :: set cursor col/pos
[%klr p=stub] :: set styled line [%klr p=stub] :: put styled
[%lin p=(list @c)] :: set current line [%put p=(list @c)] :: put text at cursor
[%mor ~] :: newline [%nel ~] :: newline
[%sag p=path q=*] :: save to jamfile [%sag p=path q=*] :: save to jamfile
[%sav p=path q=@] :: save to file [%sav p=path q=@] :: save to file
[%url p=@t] :: activate url [%url p=@t] :: activate url
[%wyp ~] :: wipe cursor line
== :: == ::
+$ dill-belt :: new belt +$ dill-belt :: arvo input
$% [%aro p=?(%d %l %r %u)] :: arrow key $% belt :: client input
[%bac ~] :: true backspace
[%cru p=@tas q=(list tank)] :: echo error [%cru p=@tas q=(list tank)] :: echo error
[%ctl p=@] :: control-key
[%del ~] :: true delete
[%hey ~] :: refresh [%hey ~] :: refresh
[%met p=@] :: meta-key
[%ret ~] :: return
[%rez p=@ud q=@ud] :: resize, cols, rows [%rez p=@ud q=@ud] :: resize, cols, rows
[%txt p=(list @c)] :: utf32 text
[%yow p=gill:gall] :: connect to app [%yow p=gill:gall] :: connect to app
== :: == ::
+$ dill-blit :: new blit +$ dill-blit :: arvo output
$% [%bel ~] :: make a noise $% blit :: client output
[%clr ~] :: clear the screen
[%hop p=@ud] :: set cursor position
[%klr p=stub] :: styled text
[%mor p=(list dill-blit)] :: multiple blits [%mor p=(list dill-blit)] :: multiple blits
[%pom p=stub] :: styled prompt
[%pro p=(list @c)] :: show as cursor+line
[%qit ~] :: close console [%qit ~] :: close console
[%out p=(list @c)] :: send output line
[%sag p=path q=*] :: save to jamfile
[%sav p=path q=@] :: save to file
[%url p=@t] :: activate url
== :: == ::
+$ flog :: sent to %dill +$ flog :: sent to %dill
$% [%crop p=@ud] :: trim kernel state $% [%crop p=@ud] :: trim kernel state
@ -1134,6 +1116,11 @@
[%text p=tape] :: [%text p=tape] ::
[%verb ~] :: verbose mode [%verb ~] :: verbose mode
== :: == ::
:: ::
+$ poke :: dill to userspace
$: ses=@tas :: target session
dill-belt :: input
== ::
-- ::dill -- ::dill
:: :::: :: ::::
:::: ++eyre :: (1e) http-server :::: ++eyre :: (1e) http-server
@ -1634,7 +1621,6 @@
+$ gift :: outgoing result +$ gift :: outgoing result
$% [%boon payload=*] :: ames response $% [%boon payload=*] :: ames response
[%done error=(unit error:ames)] :: ames message (n)ack [%done error=(unit error:ames)] :: ames message (n)ack
[%onto p=(each suss tang)] :: about agent
[%unto p=sign:agent] :: [%unto p=sign:agent] ::
== :: == ::
+$ task :: incoming request +$ task :: incoming request
@ -2163,9 +2149,6 @@
:: %ames: hear packet :: %ames: hear packet
:: ::
$>(%hear task:ames) $>(%hear task:ames)
:: %dill: hangup
::
$>(%hook task:dill)
:: %clay: external edit :: %clay: external edit
:: ::
$>(%into task:clay) $>(%into task:clay)
@ -2181,6 +2164,9 @@
:: %eyre: starts handling an backdoor http request :: %eyre: starts handling an backdoor http request
:: ::
$>(%request-local task:eyre) $>(%request-local task:eyre)
:: %dill: close session
::
$>(%shut task:dill)
:: %behn: wakeup :: %behn: wakeup
:: ::
$>(%wake task:behn) $>(%wake task:behn)

10
pkg/arvo/sys/vane/clay.hoon
View File

@ -319,7 +319,10 @@
task :: task ::
== :: == ::
$: %d :: to %dill $: %d :: to %dill
$>(%flog task:dill) :: $> $? %flog ::
%text ::
== ::
task:dill ::
== :: == ::
$: %g :: to %gall $: %g :: to %gall
$>(%deal task:gall) :: $>(%deal task:gall) ::
@ -343,7 +346,6 @@
== == :: == == ::
$: %clay :: $: %clay ::
$> $? %mere :: $> $? %mere ::
%note ::
%writ :: %writ ::
== :: == ::
gift :: gift ::
@ -1890,7 +1892,8 @@
|= [prefix=@tD paths=(set path)] |= [prefix=@tD paths=(set path)]
%+ turn ~(tap in paths) %+ turn ~(tap in paths)
|= =path |= =path
[u.hun %give %note prefix (path-to-tank path)] ^- move
[u.hun %pass /note %d %text prefix ' ' ~(ram re (path-to-tank path))]
:: ::
++ path-to-tank ++ path-to-tank
|= =path |= =path
@ -4788,7 +4791,6 @@
q.p.p.+.hin q.p.p.+.hin
[~ ..^$] [~ ..^$]
:: ::
%note [[hen %give +.hin]~ ..^$]
%wake %wake
:: TODO: handle behn errors :: TODO: handle behn errors
:: ::

320
pkg/arvo/sys/vane/dill.hoon
View File

@ -8,27 +8,25 @@
-- :: -- ::
=> |% :: console protocol => |% :: console protocol
+$ axle :: +$ axle ::
$: %4 ::TODO replace ducts with session ids :: $: %5 ::
hey=(unit duct) :: default duct hey=(unit duct) :: default duct
dug=(map duct axon) :: conversations dug=(map @tas axon) :: conversations
eye=(jug duct duct) :: outside listeners eye=(jug @tas duct) :: outside listeners
lit=? :: boot in lite mode lit=? :: boot in lite mode
$= veb :: vane verbosities $= veb :: vane verbosities
$~ (~(put by *(map @tas log-level)) %hole %soft) :: quiet packet crashes $~ (~(put by *(map @tas log-level)) %hole %soft) :: quiet packet crashes
(map @tas log-level) :: (map @tas log-level) ::
== :: == ::
+$ axon :: dill per duct +$ axon :: dill session
$: ram=term :: console program $: ram=term :: console program
tem=(unit (list dill-belt)) :: pending, reverse tem=(unit (list dill-belt)) :: pending, reverse
wid=_80 :: terminal width wid=_80 :: terminal width
pos=@ud :: cursor position
see=$%([%lin (list @c)] [%klr stub]) :: current line
== :: == ::
+$ log-level ?(%hush %soft %loud) :: none, line, full +$ log-level ?(%hush %soft %loud) :: none, line, full
-- => :: -- => ::
|% :: protocol outward |% :: protocol outward
+$ mess :: +$ mess ::
$% [%dill-belt p=(hypo dill-belt)] :: $% [%dill-poke p=(hypo poke)] ::
== :: == ::
+$ move [p=duct q=(wind note gift)] :: local move +$ move [p=duct q=(wind note gift)] :: local move
+$ note :: out request $-> +$ note :: out request $->
@ -72,7 +70,6 @@
== == :: == == ::
$: %clay :: $: %clay ::
$> $? %mere :: $> $? %mere ::
%note ::
%writ :: %writ ::
== :: == ::
gift:clay :: gift:clay ::
@ -81,10 +78,7 @@
$>(%blit gift:dill) :: $>(%blit gift:dill) ::
== :: == ::
$: %gall :: $: %gall ::
$> $? %onto :: $>(%unto gift:gall) ::
%unto ::
== ::
gift:gall ::
== == :: == == ::
:::::::: :: dill tiles :::::::: :: dill tiles
-- --
@ -94,39 +88,27 @@
|% |%
++ as :: per cause ++ as :: per cause
=| moz=(list move) =| moz=(list move)
|_ [hen=duct axon] |_ [hen=duct ses=@tas axon]
++ abet :: resolve ++ abet :: resolve
^- [(list move) axle] ^- [(list move) axle]
[(flop moz) all(dug (~(put by dug.all) hen +<+))] [(flop moz) all(dug (~(put by dug.all) ses +<+>))]
:: ::
++ call :: receive input ++ call :: receive input
|= kyz=task |= kyz=task
^+ +> ^+ +>
?+ -.kyz ~& [%strange-kiss -.kyz] +> ?+ -.kyz ~& [%strange-kiss -.kyz] +>
%flow +>
%harm +>
%hail (send %hey ~) %hail (send %hey ~)
%text (from %out (tuba p.kyz)) %belt (send `dill-belt`p.kyz)
%talk (talk p.kyz)
%text (fore (tuba p.kyz) ~)
%crud :: (send `dill-belt`[%cru p.kyz q.kyz]) %crud :: (send `dill-belt`[%cru p.kyz q.kyz])
(crud p.kyz q.kyz) (crud p.kyz q.kyz)
%blew (send %rez p.p.kyz q.p.kyz) %blew (send(wid p.p.kyz) %rez p.p.kyz q.p.kyz)
%heft (pass /whey %$ whey/~) %heft (pass /whey %$ whey/~)
%meld (dump kyz) %meld (dump kyz)
%pack (dump kyz) %pack (dump kyz)
%crop (dump trim+p.kyz) %crop (dump trim+p.kyz)
%verb (pass /verb %$ kyz) %verb (pass /verb %$ kyz)
::
%belt
%- send
::TMP forwards compatibility with next-dill
::
?@ p.kyz [%txt p.kyz ~]
?: ?=(%hit -.p.kyz) [%txt ~]
?. ?=(%mod -.p.kyz) p.kyz
=/ =@c
?@ key.p.kyz key.p.kyz
?:(?=(?(%bac %del %ret) -.key.p.kyz) `@`-.key.p.kyz ~-)
?:(?=(%met mod.p.kyz) [%met c] [%ctl c])
== ==
:: ::
++ crud ++ crud
@ -136,30 +118,30 @@
=/ lev=log-level (~(gut by veb.all) err %loud) =/ lev=log-level (~(gut by veb.all) err %loud)
:: apply log level for this error tag :: apply log level for this error tag
:: ::
=/ =wall ?- lev
?- lev %hush +>.$
%hush ~ %soft (fore (tuba "crud: %{(trip err)} event failed") ~)
%soft ~["crud: %{(trip err)} event failed"] %loud (talk leaf+"crud: %{(trip err)} event failed" (flop tac))
%loud :- "crud: %{(trip err)} event failed" ==
%- zing ::
%+ turn (flop tac) ++ talk
|=(a=tank (~(win re a) [0 wid])) |= tac=(list tank)
== %- fore
|- ^+ +>.^$ %- zing
?~ wall +>.^$ %+ turn tac
$(wall t.wall, +>.^$ (from %out (tuba i.wall))) |= a=tank
(turn (~(win re a) [0 wid]) tuba)
:: ::
++ dump :: pass down to hey ++ dump :: pass down to hey
|= git=gift |= git=gift
?> ?=(^ hey.all) ?> ?=(^ hey.all)
+>(moz [[u.hey.all %give git] moz]) +>(moz [[u.hey.all %give git] moz])
:: ::
++ done :: return gift ++ done :: gift to viewers
|= git=gift |= git=gift
=- +>.$(moz (weld - moz)) =- +>.$(moz (weld - moz))
%+ turn %+ turn
:- hen ~(tap in (~(get ju eye.all) ses))
~(tap in (~(get ju eye.all) hen))
|=(=duct [duct %give git]) |=(=duct [duct %give git])
:: ::
++ deal :: pass to %gall ++ deal :: pass to %gall
@ -170,6 +152,30 @@
|= [=wire =note] |= [=wire =note]
+>(moz :_(moz [hen %pass wire note])) +>(moz :_(moz [hen %pass wire note]))
:: ::
++ fore :: send dill output
::NOTE there are still implicit assumptions
:: about the underlying console app's
:: semantics here. specifically, trailing
:: newlines are important to not getting
:: overwritten by the drum prompt, and a
:: bottom-of-screen cursor position gives
:: nicest results. a more agnostic solution
:: will need to replace this arm, someday.
:: perhaps +send this to .ram instead?
::
|= liz=(list (list @c))
~? !=(%$ ses) [%d %foreing-in-session ses]
^+ +>
=. +>
=| biz=(list blit)
|- ^+ +>.^$
?~ liz (done %blit [%hop 0] [%wyp ~] biz)
$(liz t.liz, biz (welp biz [%put i.liz] [%nel ~] ~))
:: since dill is acting on its own accord,
:: we %hey the term app so it may clean up.
::
(send %hey ~)
::
++ from :: receive blit ++ from :: receive blit
|= bit=dill-blit |= bit=dill-blit
^+ +> ^+ +>
@ -177,34 +183,6 @@
|- ^+ +>.^$ |- ^+ +>.^$
?~ p.bit +>.^$ ?~ p.bit +>.^$
$(p.bit t.p.bit, +>.^$ ^$(bit i.p.bit)) $(p.bit t.p.bit, +>.^$ ^$(bit i.p.bit))
?: ?=(%out -.bit)
%+ done %blit
:~ [%lin p.bit]
[%mor ~]
see
[%hop pos]
==
?: ?=(%klr -.bit)
%+ done %blit
:~ [%klr p.bit]
[%mor ~]
see
[%hop pos]
==
?: ?=(%pro -.bit)
=. see [%lin p.bit]
(done %blit [see [%hop pos] ~])
?: ?=(%pom -.bit)
::NOTE treat "styled prompt" without style as plain prompt,
:: to allow rendering by older runtimes
::TODO remove me once v0.10.9+ has high/guaranteed adoption
::
?: (levy p.bit (cork head |*(s=stye =(*stye s))))
$(bit [%pro (zing (turn p.bit tail))])
=. see [%klr p.bit]
(done %blit [see [%hop pos] ~])
?: ?=(%hop -.bit)
(done(pos p.bit) %blit [bit ~])
?: ?=(%qit -.bit) ?: ?=(%qit -.bit)
(dump %logo ~) (dump %logo ~)
(done %blit [bit ~]) (done %blit [bit ~])
@ -241,18 +219,33 @@
=. tem `(turn gyl |=(a=gill [%yow a])) =. tem `(turn gyl |=(a=gill [%yow a]))
(pass / [%c %warp our %home `[%sing %y [%ud 1] /]]) (pass / [%c %warp our %home `[%sing %y [%ud 1] /]])
:: ::
++ open
|= gyl=(list gill)
=. +> (pass / %g %conf ram)
=. +> peer
%+ roll gyl
|= [g=gill _..open]
(send [%yow g])
::
++ shut
::TODO send a %bye blit?
pull(eye.all (~(del by eye.all) ses))
::
++ send :: send action ++ send :: send action
|= bet=dill-belt |= bet=dill-belt
^+ +> ^+ +>
?^ tem ?^ tem
+>(tem `[bet u.tem]) +>(tem `[bet u.tem])
(deal / [%poke [%dill-belt -:!>(bet) bet]]) (deal /send/[ses] [%poke [%dill-poke !>([ses bet])]])
:: ::
++ hood-set-boot-apps ++ hood-set-boot-apps
(deal / [%poke %drum-set-boot-apps !>(lit.all)]) (deal / [%poke %drum-set-boot-apps !>(lit.all)])
:: ::
++ peer ++ peer
(deal / [%watch /drum]) (deal /peer/[ses] %watch /dill/[ses])
::
++ pull
(deal /peer/[ses] %leave ~)
:: ::
++ show :: permit reads on desk ++ show :: permit reads on desk
|= des=desk |= des=desk
@ -266,13 +259,6 @@
|= [tea=wire sih=sign] |= [tea=wire sih=sign]
^+ +> ^+ +>
?- sih ?- sih
[%gall %onto *]
:: ~& [%take-gall-onto +>.sih]
?- -.+>.sih
%| (crud %onto p.p.+>.sih)
%& (done %blit [%lin (tuba "{<p.p.sih>}")]~)
==
::
[%gall %unto *] [%gall %unto *]
:: ~& [%take-gall-unto +>.sih] :: ~& [%take-gall-unto +>.sih]
?- -.+>.sih ?- -.+>.sih
@ -288,9 +274,6 @@
+>.$ +>.$
(from ;;(dill-blit q.q.cage.p.+>.sih)) (from ;;(dill-blit q.q.cage.p.+>.sih))
== ==
::
[%clay %note *]
(from %out (tuba p.sih ' ' ~(ram re q.sih)))
:: ::
[?(%behn %clay) %writ *] [?(%behn %clay) %writ *]
init init
@ -305,12 +288,20 @@
== ==
-- --
:: ::
++ ax :: make ++as ++ ax :: make ++as from name
|= hen=duct |= [hen=duct ses=@tas]
^- (unit _as) ^- (unit _as)
=/ nux (~(get by dug.all) hen) =/ nux (~(get by dug.all) ses)
?~ nux ~ ?~ nux ~
(some ~(. as hen u.nux)) (some ~(. as hen ses u.nux))
::
++ aw :: make ++as from wire
|= [hen=duct wir=wire]
^- (unit _as)
%+ ax hen
?+ wir %$
[?(%peer %send) @ *] i.t.wir
==
-- --
|% :: poke+peek pattern |% :: poke+peek pattern
++ call :: handle request ++ call :: handle request
@ -321,7 +312,10 @@
^+ [*(list move) ..^$] ^+ [*(list move) ..^$]
~| wrapped-task ~| wrapped-task
=/ task=task ((harden task) wrapped-task) =/ task=task ((harden task) wrapped-task)
:: unwrap session tasks, default to session %$
:: ::
=^ ses=@tas task
?:(?=(%shot -.task) +.task [%$ task])
:: error notifications "downcast" to %crud :: error notifications "downcast" to %crud
:: ::
=? task ?=(^ dud) =? task ?=(^ dud)
@ -351,10 +345,11 @@
:: ::
=* duc (need hey.all) =* duc (need hey.all)
=/ app %hood =/ app %hood
=/ see (tuba "<awaiting {(trip app)}, this may take a minute>") =/ say (tuba "<awaiting {(trip app)}, this may take a minute>")
=/ zon=axon [app input=[~ ~] width=80 cursor=(lent see) lin+see] =/ zon=axon [app input=[~ ~] width=80]
:: ::
=^ moz all abet:(~(into as duc zon) ~) =^ moz all abet:(~(into as duc %$ zon) ~)
=. eye.all (~(put ju eye.all) %$ duc)
[moz ..^$] [moz ..^$]
:: %flog tasks are unwrapped and sent back to us on our default duct :: %flog tasks are unwrapped and sent back to us on our default duct
:: ::
@ -375,35 +370,55 @@
?: ?=(%knob -.task) ?: ?=(%knob -.task)
=. veb.all (~(put by veb.all) tag.task level.task) =. veb.all (~(put by veb.all) tag.task level.task)
[~ ..^$] [~ ..^$]
:: %open opens a new dill session
::
?: ?=(%open -.task)
?: (~(has by dug.all) ses)
::TODO should we allow, and just send the %yow blits?
~| [%cannot-open-existing ses]
!!
=/ zon=axon [p.task ~ width=80]
=^ moz all abet:(~(open as hen ses zon) q.task)
=. eye.all (~(put ju eye.all) ses hen)
[moz ..^$]
:: %shut closes an existing dill session
::
?: ?=(%shut -.task)
?: =(%$ ses)
~| %cannot-shut-default-session
!!
=/ nus
~| [%no-session ses]
(need (ax hen ses))
=^ moz all abet:shut:nus
[moz ..^$]
:: %view opens a subscription to the target session, on the current duct
:: ::
?: ?=(%view -.task) ?: ?=(%view -.task)
:: crash on viewing non-existent session =/ nus
:: crash on viewing non-existent session
::
~| [%no-session ses]
(need (ax hen ses))
:: register the viewer and send a %hey so they get the full screen
:: ::
~| [%no-session session.task] =^ moz all
?> =(~ session.task) abet:(send:nus %hey ~)
=/ session (need hey.all) :- moz
=/ =axon (~(got by dug.all) session) ..^$(eye.all (~(put ju eye.all) ses hen))
:: register the viewer and send them the prompt line :: %flee closes a subscription to the target session, from the current duct
::
:- [hen %give %blit [see.axon]~]~
..^$(eye.all (~(put ju eye.all) session hen))
:: ::
?: ?=(%flee -.task) ?: ?=(%flee -.task)
:- ~ :- ~
~| [%no-session session.task] ..^$(eye.all (~(del ju eye.all) ses hen))
?> =(~ session.task)
=/ session (need hey.all)
..^$(eye.all (~(del ju eye.all) session hen))
:: ::
=/ nus (ax hen) =/ nus
=? nus &(?=(~ nus) ?=(^ hey.all)) (ax hen ses)
::TODO allow specifying target session in task
(ax u.hey.all)
?~ nus ?~ nus
:: :hen is an unrecognized duct :: session :ses does not exist
:: could be before %boot (or %boot failed) :: could be before %boot (or %boot failed)
:: ::
~& [%dill-call-no-flow hen -.task] ~& [%dill-call-no-session ses hen -.task]
=/ tan ?:(?=(%crud -.task) q.task ~) =/ tan ?:(?=(%crud -.task) q.task ~)
[((slog (flop tan)) ~) ..^$] [((slog (flop tan)) ~) ..^$]
:: ::
@ -411,8 +426,63 @@
[moz ..^$] [moz ..^$]
:: ::
++ load :: import old state ++ load :: import old state
|= old=axle =< |= old=any-axle
..^$(all old) ?- -.old
%5 ..^$(all old)
%4 $(old (axle-4-to-5 old))
==
|%
+$ any-axle $%(axle axle-4)
::
+$ axle-4
$: %4
hey=(unit duct)
dug=(map duct axon-4)
eye=(jug duct duct)
lit=?
veb=(map @tas log-level)
==
::
+$ axon-4
$: ram=term
tem=(unit (list dill-belt-4))
wid=_80
pos=$@(@ud [@ud @ud])
see=$%([%lin (list @c)] [%klr stub])
==
::
+$ dill-belt-4
$% [%ctl p=@c]
[%met p=@c]
dill-belt
==
::
++ axle-4-to-5
|= axle-4
^- axle
:- %5
=- [hey nug nay lit veb]
%+ roll ~(tap by dug)
|= [[=duct =axon-4] nug=(map @tas axon) nay=(jug @tas duct)]
=/ ses=@tas
~| [%unexpected-duct duct]
?>(=([//term/1]~ duct) %$)
:- (~(put by nug) ses (axon-4-to-5 axon-4))
%+ ~(put by nay) ses
(~(put in (~(get ju eye) duct)) duct)
::
++ axon-4-to-5
|= axon-4
^- axon
=; tem [ram tem wid]
?~ tem ~
%- some
%+ turn u.tem
|= b=dill-belt-4
^- dill-belt
?. ?=(?(%ctl %met) -.b) b
[%mod -.b p.b]
--
:: ::
++ scry ++ scry
^- roon ^- roon
@ -441,19 +511,12 @@
=(%$ syd) =(%$ syd)
== ==
~ ~
:: /dx/sessions//line blit current line (prompt) of default session :: /dy/sessions (set @tas) all existing sessions
:: /dx/sessions//cursor @ud current cursor position of default session :: /du/sessions/[ses] ? does session ses exist?
::TODO support asking for specific sessions once session ids are real
:: ::
?. ?=(%x ren) ~ ?+ [ren tyl] ~
?+ tyl ~ [%y %sessions ~] ``noun+!>(~(key by dug.all))
[%sessions %$ *] [%u %sessions @ ~] ``noun+!>((~(has by dug.all) (snag 1 tyl)))
?~ hey.all [~ ~]
?~ session=(~(get by dug.all) u.hey.all) [~ ~]
?+ t.t.tyl ~
[%line ~] ``blit+!>(`blit`see.u.session)
[%cursor ~] ``atom+!>(pos.u.session)
==
== ==
:: ::
++ stay all ++ stay all
@ -464,12 +527,11 @@
?^ dud ?^ dud
~|(%dill-take-dud (mean tang.u.dud)) ~|(%dill-take-dud (mean tang.u.dud))
:: ::
=/ nus (ax hen) =/ nus (aw hen tea)
?~ nus ?~ nus
:: :hen is an unrecognized duct :: :tea points to an unrecognized session
:: could be before %boot (or %boot failed)
:: ::
~& [%dill-take-no-flow hen -.hin +<.hin] ~& [%dill-take-no-session tea -.hin +<.hin]
[~ ..^$] [~ ..^$]
=^ moz all abet:(take:u.nus tea hin) =^ moz all abet:(take:u.nus tea hin)
[moz ..^$] [moz ..^$]

20
pkg/arvo/sys/vane/gall.hoon
View File

@ -266,12 +266,22 @@
:: +mo-abet: finalize, reversing moves :: +mo-abet: finalize, reversing moves
:: +mo-pass: prepend a standard %pass to the current list of moves :: +mo-pass: prepend a standard %pass to the current list of moves
:: +mo-give: prepend a standard %give to the current list of moves :: +mo-give: prepend a standard %give to the current list of moves
:: +mo-talk: build task to print config report or failure trace
:: ::
++ mo-core . ++ mo-core .
++ mo-abed |=(hun=duct mo-core(hen hun)) ++ mo-abed |=(hun=duct mo-core(hen hun))
++ mo-abet [(flop moves) gall-payload] ++ mo-abet [(flop moves) gall-payload]
++ mo-pass |=(p=[wire note-arvo] mo-core(moves [[hen pass+p] moves])) ++ mo-pass |=(p=[wire note-arvo] mo-core(moves [[hen pass+p] moves]))
++ mo-give |=(g=gift mo-core(moves [[hen give+g] moves])) ++ mo-give |=(g=gift mo-core(moves [[hen give+g] moves]))
++ mo-talk
|= rup=(each suss tang)
^- [wire note-arvo]
:+ /sys/say %d
^- task:dill
?- -.rup
%& [%text "gall: {(t q)}ed %{(t p)}":[t=trip p.rup]]
%| [%talk leaf+"gall: failed" (flop p.rup)]
==
:: +mo-boot: ask %ford to build us a core for the specified agent. :: +mo-boot: ask %ford to build us a core for the specified agent.
:: ::
++ mo-boot ++ mo-boot
@ -349,12 +359,12 @@
=/ ap-core +.wag =/ ap-core +.wag
?^ maybe-tang ?^ maybe-tang
=. mo-core old =. mo-core old
(mo-give %onto %.n u.maybe-tang) (mo-pass (mo-talk %.n u.maybe-tang))
:: ::
=. mo-core ap-abet:ap-core =. mo-core ap-abet:ap-core
=. mo-core (mo-clear-queue dap) =. mo-core (mo-clear-queue dap)
=/ =suss [dap %boot now] =/ =suss [dap %boot now]
(mo-give %onto [%.y suss]) (mo-pass (mo-talk %.y suss))
:: +mo-subscribe-to-agent-builds: request agent update notices :: +mo-subscribe-to-agent-builds: request agent update notices
:: ::
:: Also subscribe to our own source path, in case we get reloaded :: Also subscribe to our own source path, in case we get reloaded
@ -544,7 +554,7 @@
++ fail ++ fail
|= =tang |= =tang
^+ mo-core ^+ mo-core
=. mo-core (mo-give %onto |+tang) =. mo-core (mo-pass (mo-talk |+tang))
=/ =case [%da tim] =/ =case [%da tim]
=/ =wire /sys/cor/[dap]/[her]/[desk]/(scot case) =/ =wire /sys/cor/[dap]/[her]/[desk]/(scot case)
(mo-pass wire %c %warp p.beak desk ~ %next %a case /app/[dap]/hoon) (mo-pass wire %c %warp p.beak desk ~ %next %a case /app/[dap]/hoon)
@ -1019,8 +1029,8 @@
:: ::
=/ running (~(put by yokes.state) agent-name current-agent) =/ running (~(put by yokes.state) agent-name current-agent)
=/ moves =/ moves
=/ giver |=(report=(each suss tang) [hen %give %onto report]) =/ talker |=(report=(each suss tang) [hen %pass (mo-talk report)])
=/ from-suss (turn agent-config giver) =/ from-suss (turn agent-config talker)
:(weld agent-moves from-suss moves) :(weld agent-moves from-suss moves)
:: ::
%_ mo-core %_ mo-core

11
pkg/arvo/sys/vane/jael.hoon
View File

@ -107,11 +107,8 @@
$>(%wake gift:behn) :: $>(%wake gift:behn) ::
== :: == ::
$: %gall :: $: %gall ::
$> $? %onto :: $>(%unto gift:gall) ::
%unto :: == ::
== ::
gift:gall ::
==
== :: == ::
-- :: -- ::
:: :::: :: ::::
@ -557,10 +554,6 @@
=/ ships (~(get ju ship-sources-reverse.etn) source-id) =/ ships (~(get ju ship-sources-reverse.etn) source-id)
%- curd =< abet %- curd =< abet
(sources:~(feel su hen now pki etn) ships source) (sources:~(feel su hen now pki etn) ships source)
::
[%gall %onto *]
~& [%jael-onto tea hin]
+>.$
:: ::
[%gall %unto *] [%gall %unto *]
?- +>-.hin ?- +>-.hin

101
pkg/arvo/sys/zuse.hoon
View File

@ -3728,6 +3728,107 @@
~ ~
(some (~(run by lum) need)) (some (~(run by lum) need))
-- ::dejs-soft -- ::dejs-soft
::
++ klr :: styx/stub engine
=, dill
|%
++ make :: stub from styx
|= a=styx ^- stub
=| b=stye
%+ reel
|- ^- stub
%- zing %+ turn a
|= a=$@(@t (pair styl styx))
?@ a [b (tuba (trip a))]~
^$(a q.a, b (styd p.a b))
::
|= [a=(pair stye (list @c)) b=stub]
?~ b [a ~]
?. =(p.a p.i.b) [a b]
[[p.a (weld q.a q.i.b)] t.b]
::
++ styd :: stye from styl
|= [a=styl b=stye] ^+ b :: with inheritance
:+ ?~ p.a p.b
?~ u.p.a ~
(~(put in p.b) u.p.a)
(fall p.q.a p.q.b)
(fall q.q.a q.q.b)
::
++ lent-char
|= a=stub ^- @
(roll (lnts-char a) add)
::
++ lnts-char :: stub text lengths
|= a=stub ^- (list @)
%+ turn a
|= a=(pair stye (list @c))
(lent q.a)
::
++ brek :: index + incl-len of
|= [a=@ b=(list @)] :: stub pair w/ idx a
=| [c=@ i=@]
|- ^- (unit (pair @ @))
?~ b ~
=. c (add c i.b)
?: (gte c a)
`[i c]
$(i +(i), b t.b)
::
++ pact :: condense stub
|= a=stub
^- stub
?~ a ~
?~ t.a a
?. =(p.i.a p.i.t.a) [i.a $(a t.a)]
=. q.i.t.a (weld q.i.a q.i.t.a)
$(a t.a)
::
++ slag :: slag stub
|= [a=@ b=stub]
^- stub
=+ c=(lnts-char b)
=+ i=(brek a c)
?~ i ~
=+ r=(^slag +(p.u.i) b)
?: =(a q.u.i)
r
=+ n=(snag p.u.i b)
:_ r :- p.n
(^slag (sub (snag p.u.i c) (sub q.u.i a)) q.n)
::
++ scag :: scag stub
|= [a=@ b=stub]
^- stub
=+ c=(lnts-char b)
=+ i=(brek a c)
?~ i b
?: =(a q.u.i)
(^scag +(p.u.i) b)
%+ welp
(^scag p.u.i b)
=+ n=(snag p.u.i b)
:_ ~ :- p.n
(^scag (sub (snag p.u.i c) (sub q.u.i a)) q.n)
::
++ swag :: swag stub
|= [[a=@ b=@] c=stub]
(scag b (slag a c))
::
++ wail :: overlay stub
|= [a=stub b=@ c=stub d=@c]
^- stub
;: weld
(scag b a)
::
=+ e=(lent-char a)
?: (lte b e) ~
[*stye (reap (sub b e) d)]~
::
c
(slag (add b (lent-char c)) a)
==
-- :: klr
-- --
:: :: :: ::
:::: ++differ :: (2d) hunt-mcilroy :::: ++differ :: (2d) hunt-mcilroy

5
pkg/arvo/ted/aqua/dill.hoon
View File

@ -17,15 +17,16 @@
%+ roll blits %+ roll blits
|= [b=blit:dill line=tape] |= [b=blit:dill line=tape]
?- -.b ?- -.b
%lin (tape p.b) %put (tape p.b)
%klr (tape (zing (turn p.b tail))) %klr (tape (zing (turn p.b tail)))
%mor ~& "{<who>}: {line}" "" %nel ~& "{<who>}: {line}" ""
%hop line %hop line
%bel line %bel line
%clr "" %clr ""
%sag ~& [%save-jamfile-to p.b] line %sag ~& [%save-jamfile-to p.b] line
%sav ~& [%save-file-to p.b] line %sav ~& [%save-file-to p.b] line
%url ~& [%activate-url p.b] line %url ~& [%activate-url p.b] line
%wyp ""
== ==
~? !=(~ last-line) last-line ~? !=(~ last-line) last-line
~ ~

37
pkg/hs/urbit-king/lib/Urbit/Arvo/Effect.hs
View File

@ -119,15 +119,25 @@ deriveNoun ''BehnEf
data Blit data Blit
= Bel () = Bel ()
| Clr () | Clr ()
| Hop Word64 | Hop HopTarget
| Klr Stub | Klr Stub
| Lin [Char] | Put [Char]
| Mor () | Nel ()
| Sag Path Noun | Sag Path Noun
| Sav Path Atom | Sav Path Atom
| Url Cord | Url Cord
| Wyp ()
--TMP backwards compatibility
| Lin [Char]
| Mor ()
deriving (Eq, Ord) deriving (Eq, Ord)
--NOTE bottom-left-0-based coordinates
data HopTarget
= Col Word64
| Roc Word64 Word64 -- row, col
deriving (Eq, Ord, Show)
data Deco data Deco
= DecoBl = DecoBl
| DecoBr | DecoBr
@ -205,18 +215,33 @@ instance FromNoun Tint where
"w" -> pure TintW "w" -> pure TintW
t -> fail ("invalid: " <> unpack t) t -> fail ("invalid: " <> unpack t)
instance FromNoun HopTarget where
parseNoun = \case
A c -> pure $ Col (fromIntegral c)
C (A r) (A c) -> pure $ Roc (fromIntegral r) (fromIntegral c)
n -> fail ("invalid hop target: " <> show n)
instance ToNoun HopTarget where
toNoun = \case
Col c -> A (fromIntegral c)
Roc r c -> C (A (fromIntegral r)) (A (fromIntegral c))
-- Manual instance to not save the noun/atom in Sag/Sav, because these can be -- Manual instance to not save the noun/atom in Sag/Sav, because these can be
-- megabytes and makes king hang. -- megabytes and makes king hang.
instance Show Blit where instance Show Blit where
show (Bel ()) = "Bel ()" show (Bel ()) = "Bel ()"
show (Clr ()) = "Clr ()" show (Clr ()) = "Clr ()"
show (Hop x) = "Hop " ++ (show x) show (Hop t) = "Hop " ++ (show t)
show (Klr s) = "Klr " ++ (show s) show (Klr s) = "Klr " ++ (show s)
show (Lin c) = "Lin " ++ (show c) show (Put c) = "Put " ++ (show c)
show (Mor ()) = "Mor ()" show (Nel ()) = "Nel ()"
show (Sag path _) = "Sag " ++ (show path) show (Sag path _) = "Sag " ++ (show path)
show (Sav path _) = "Sav " ++ (show path) show (Sav path _) = "Sav " ++ (show path)
show (Url c) = "Url " ++ (show c) show (Url c) = "Url " ++ (show c)
show (Wyp ()) = "Wyp ()"
--
show (Lin c) = "Lin " ++ (show c)
show (Mor ()) = "Mor ()"
{-| {-|
%blip -- TODO %blip -- TODO

80
pkg/hs/urbit-king/lib/Urbit/Arvo/Event.hs
View File

@ -20,6 +20,7 @@ import Urbit.Arvo.Common (ReOrg(..), reorgThroughNoun)
import qualified Crypto.Sign.Ed25519 as Ed import qualified Crypto.Sign.Ed25519 as Ed
import qualified Data.ByteString as BS import qualified Data.ByteString as BS
import qualified Data.Char as C
import qualified Data.ByteString.Char8 as C import qualified Data.ByteString.Char8 as C
import qualified Network.HTTP.Types.Method as H import qualified Network.HTTP.Types.Method as H
@ -318,19 +319,52 @@ data LegacyBootEvent
| Dawn Dawn | Dawn Dawn
deriving (Eq, Show) deriving (Eq, Show)
data ArrowKey = D | L | R | U data Bolt
= Key Char
| Aro ArrowKey
| Bac ()
| Del ()
| Hit Word64 Word64
| Ret ()
deriving (Eq, Ord, Show) deriving (Eq, Ord, Show)
data Belt data Belt
= Aro ArrowKey = Bol Bolt
| Bac () | Mod Modifier Bolt
| Ctl Cord
| Del ()
| Met Cord
| Ret ()
| Txt Tour | Txt Tour
deriving (Eq, Ord, Show) deriving (Eq, Ord, Show)
data ArrowKey = D | L | R | U
deriving (Eq, Ord, Show)
data Modifier = Ctl | Met | Hyp
deriving (Eq, Ord, Show)
--NOTE required to get the above declarations into reify's type environment
-- see also ghc/ghc#9813
$(pure [])
instance FromNoun Bolt where
parseNoun = \case
A c -> pure $ Key $ C.chr $ fromIntegral c
C (A 7955819) _ -> fail "%key not valid bolt tag"
n -> $(deriveFromNounFunc ''Bolt) n
instance FromNoun Belt where
parseNoun = \case
C (A 7106402) _ -> fail "%bol not valid belt tag"
n -> Bol <$> parseNoun n <|> $(deriveFromNounFunc ''Belt) n
instance ToNoun Bolt where
toNoun = \case
Key c -> A $ fromIntegral $ C.ord c
n -> $(deriveToNounFunc ''Bolt) n
instance ToNoun Belt where
toNoun = \case
Bol b -> toNoun b
n -> $(deriveToNounFunc ''Belt) n
data TermEv data TermEv
= TermEvBelt (UD, ()) Belt = TermEvBelt (UD, ()) Belt
| TermEvBlew (UD, ()) Word Word | TermEvBlew (UD, ()) Word Word
@ -341,7 +375,7 @@ data TermEv
deriveNoun ''LegacyBootEvent deriveNoun ''LegacyBootEvent
deriveNoun ''ArrowKey deriveNoun ''ArrowKey
deriveNoun ''Belt deriveNoun ''Modifier
deriveNoun ''TermEv deriveNoun ''TermEv
@ -392,27 +426,23 @@ instance FromNoun Ev where
-- Short Event Names ----------------------------------------------------------- -- Short Event Names -----------------------------------------------------------
{- {-
In the case of the user hitting enter, the cause is technically a In the case of user input, the cause is technically a terminal event,
terminal event, but we don't display any name because the cause is but we don't display any name because the cause is really the user.
really the user.
-} -}
getSpinnerNameForEvent :: Ev -> Maybe Text getSpinnerNameForEvent :: Ev -> Maybe Text
getSpinnerNameForEvent = \case getSpinnerNameForEvent = \case
EvBlip b -> case b of EvBlip b -> case b of
BlipEvAmes _ -> Just "ames" BlipEvAmes _ -> Just "ames"
BlipEvArvo _ -> Just "arvo" BlipEvArvo _ -> Just "arvo"
BlipEvBehn _ -> Just "behn" BlipEvBehn _ -> Just "behn"
BlipEvBoat _ -> Just "boat" BlipEvBoat _ -> Just "boat"
BlipEvHttpClient _ -> Just "iris" BlipEvHttpClient _ -> Just "iris"
BlipEvHttpServer _ -> Just "eyre" BlipEvHttpServer _ -> Just "eyre"
BlipEvJael _ -> Just "jael" BlipEvJael _ -> Just "jael"
BlipEvNewt _ -> Just "newt" BlipEvNewt _ -> Just "newt"
BlipEvSync _ -> Just "clay" BlipEvSync _ -> Just "clay"
BlipEvTerm t | isRet t -> Nothing BlipEvTerm (TermEvBelt _ _) -> Nothing
BlipEvTerm t -> Just "term" BlipEvTerm t -> Just "term"
where
isRet (TermEvBelt _ (Ret ())) = True
isRet _ = False
summarizeEvent :: Ev -> Text summarizeEvent :: Ev -> Text
summarizeEvent ev = summarizeEvent ev =

2
pkg/hs/urbit-king/lib/Urbit/Vere/Pier.hs
View File

@ -333,7 +333,7 @@ pier (serf, log) vSlog startedSig injected = do
io $ readTVarIO siteSlog >>= ($ s) io $ readTVarIO siteSlog >>= ($ s)
logOther "serf" (display $ T.strip $ tankToText tank) logOther "serf" (display $ T.strip $ tankToText tank)
let err = atomically . Term.trace muxed . (<> "\r\n") let err = atomically . Term.trace muxed
(bootEvents, startDrivers) <- do (bootEvents, startDrivers) <- do
env <- ask env <- ask
siz <- atomically $ Term.curDemuxSize demux siz <- atomically $ Term.curDemuxSize demux

295
pkg/hs/urbit-king/lib/Urbit/Vere/Term.hs
View File

@ -45,8 +45,8 @@ import qualified Urbit.Vere.Term.Render as T
-- | All stateful data in the printing to stdOutput. -- | All stateful data in the printing to stdOutput.
data LineState = LineState data LineState = LineState
{ lsLine :: Text { lsLine :: [(Stye, [Char])]
, lsCurPos :: Int , lsCurPos :: CurPos
, lsSpinTimer :: Maybe (Async ()) , lsSpinTimer :: Maybe (Async ())
, lsSpinCause :: Maybe Text , lsSpinCause :: Maybe Text
, lsSpinFirstRender :: Bool , lsSpinFirstRender :: Bool
@ -54,11 +54,19 @@ data LineState = LineState
, lsPrevEndTime :: Wen , lsPrevEndTime :: Wen
} }
data CurPos = CurPos
{ row :: Int
, col :: Int
}
-- | A record used in reading data from stdInput. -- | A record used in reading data from stdInput.
data ReadData = ReadData data ReadData = ReadData
{ rdBuf :: Ptr Word8 { rdBuf :: Ptr Word8
, rdEscape :: Bool , rdEscape :: Bool
, rdBracket :: Bool , rdBracket :: Bool
, rdMouse :: Bool
, rdMouseBut :: Word8
, rdMouseCol :: Word8
, rdUTF8 :: ByteString , rdUTF8 :: ByteString
, rdUTF8width :: Int , rdUTF8width :: Int
} }
@ -165,7 +173,8 @@ leftBracket, rightBracket :: Text
leftBracket = "«" leftBracket = "«"
rightBracket = "»" rightBracket = "»"
_spin_cool_us, _spin_warm_us, _spin_rate_us, _spin_idle_us :: Integral i => i _spin_fast_us, _spin_cool_us, _spin_warm_us, _spin_rate_us, _spin_idle_us :: Integral i => i
_spin_fast_us = 100000
_spin_cool_us = 500000 _spin_cool_us = 500000
_spin_warm_us = 50000 _spin_warm_us = 50000
_spin_rate_us = 250000 _spin_rate_us = 250000
@ -201,6 +210,9 @@ localClient doneSignal = fst <$> mkRAcquire start stop
-- to the muxing client. -- to the muxing client.
putTMVar tsSizeChange ts) putTMVar tsSizeChange ts)
-- start mouse reporting
putStr "\x1b[?9h"
pWriterThread <- asyncBound pWriterThread <- asyncBound
(writeTerminal tsWriteQueue spinnerMVar tsizeTVar) (writeTerminal tsWriteQueue spinnerMVar tsizeTVar)
@ -217,7 +229,7 @@ localClient doneSignal = fst <$> mkRAcquire start stop
tsReadQueue <- newTQueueIO tsReadQueue <- newTQueueIO
pReaderThread <- asyncBound pReaderThread <- asyncBound
(readTerminal tsReadQueue tsWriteQueue (bell tsWriteQueue)) (readTerminal tsReadQueue tsWriteQueue tsizeTVar (bell tsWriteQueue))
let client = Client { take = Just <$> asum let client = Client { take = Just <$> asum
[ readTQueue tsReadQueue <&> ClientTakeBelt, [ readTQueue tsReadQueue <&> ClientTakeBelt,
@ -238,6 +250,9 @@ localClient doneSignal = fst <$> mkRAcquire start stop
-- at shutdown, just leak the file descriptor. -- at shutdown, just leak the file descriptor.
cancel pWriterThread cancel pWriterThread
-- stop mouse reporting
putStr "\x1b[?9l"
-- inject one final newline, as we're usually on the prompt. -- inject one final newline, as we're usually on the prompt.
putStr "\r\n" putStr "\r\n"
@ -266,31 +281,50 @@ localClient doneSignal = fst <$> mkRAcquire start stop
-- Writes data to the terminal. Both the terminal reading, normal logging, -- Writes data to the terminal. Both the terminal reading, normal logging,
-- and effect handling can all emit bytes which go to the terminal. -- and effect handling can all emit bytes which go to the terminal.
--TODO blanks, traces and slogs should only be written into the default
-- terminal session.
writeTerminal :: TQueue [Term.Ev] -> TMVar () -> TVar TermSize -> RIO e () writeTerminal :: TQueue [Term.Ev] -> TMVar () -> TVar TermSize -> RIO e ()
writeTerminal q spinner termSizeVar = do writeTerminal q spinner termSizeVar = do
currentTime <- io $ now currentTime <- io $ now
loop (LineState "" 0 Nothing Nothing True 0 currentTime) loop
termSizeVar
(LineState [] (CurPos 0 0) Nothing Nothing True 0 currentTime)
where where
writeBlank :: LineState -> RIO e LineState writeBlank :: LineState -> RIO e LineState
writeBlank ls = putStr "\r\n" $> ls writeBlank ls = do
TermSize _ height <- readTVarIO termSizeVar
--NOTE hijack creates a blank line
T.hijack (fromIntegral height) $ pure ()
pure ls
writeTrace :: LineState -> Text -> RIO e LineState writeTrace :: LineState -> Text -> RIO e LineState
writeTrace ls p = do writeTrace ls p = do
putStr "\r" TermSize _ height <- readTVarIO termSizeVar
T.clearLine T.hijack (fromIntegral height) $ putStr p
putStr p pure ls
termRefreshLine ls
writeSlog :: LineState -> (Atom, Tank) -> RIO e LineState writeSlog :: LineState -> (Atom, Tank) -> RIO e LineState
writeSlog ls slog = do writeSlog ls slog = do
putStr "\r" TermSize width height <- readTVarIO termSizeVar
T.clearLine T.hijack (fromIntegral height) do
TermSize width _ <- atomically $ readTVar termSizeVar let lines = fmap (pref . unTape) $
-- TODO: Ignoring priority for now. Priority changes the color of, wash (WashCfg 0 width) $ tankTree $ snd slog
-- and adds a prefix of '>' to, the output. T.putCsi 'm' styl
let lines = fmap unTape $ wash (WashCfg 0 width) $ tankTree $ snd slog forM (intersperse "\n" lines) $ \line -> putStr line
forM lines $ \line -> putStr (line <> "\r\n") T.putCsi 'm' [0]
termRefreshLine ls pure ls
where
prio = fromIntegral $ fst slog
maxp = 3
styl
| prio == 3 = [31]
| prio == 2 = [33]
| prio == 1 = [32]
| otherwise = [90]
pref
| prio > 0 && prio <= maxp =
((replicate prio '>' ++ replicate (1 + maxp - prio) ' ') ++)
| otherwise = id
{- {-
Figure out how long to wait to show the spinner. When we Figure out how long to wait to show the spinner. When we
@ -305,7 +339,7 @@ localClient doneSignal = fst <$> mkRAcquire start stop
current <- io $ now current <- io $ now
delay <- pure $ case mTxt of delay <- pure $ case mTxt of
Nothing -> 0 Nothing -> _spin_fast_us
Just _ -> Just _ ->
if (gap current lsPrevEndTime ^. microSecs) < _spin_idle_us if (gap current lsPrevEndTime ^. microSecs) < _spin_idle_us
then _spin_warm_us then _spin_warm_us
@ -326,34 +360,41 @@ localClient doneSignal = fst <$> mkRAcquire start stop
maybe (pure ()) cancel lsSpinTimer maybe (pure ()) cancel lsSpinTimer
-- We do a final flush of the spinner mvar to ensure we don't -- We do a final flush of the spinner mvar to ensure we don't
-- have a lingering signal which will redisplay the spinner after -- have a lingering signal which will redisplay the spinner after
-- we call termRefreshLine below. -- we call termRestoreLine below.
atomically $ tryTakeTMVar spinner atomically $ tryTakeTMVar spinner
-- If we ever actually ran the spinner display callback, we need -- If we ever actually ran the spinner display callback, we need
-- to force a redisplay of the command prompt. -- to force a redisplay of the command prompt.
ls <- if not lsSpinFirstRender || True if not lsSpinFirstRender
then termRefreshLine ls then termRestoreLine ls termSizeVar
else pure ls else pure ()
endTime <- io $ now endTime <- io $ now
pure $ ls { lsSpinTimer = Nothing, lsPrevEndTime = endTime } pure $ ls { lsSpinTimer = Nothing, lsPrevEndTime = endTime }
execEv :: LineState -> Term.Ev -> RIO e LineState execEv :: LineState -> Term.Ev -> RIO e LineState
execEv ls = \case execEv ls = \case
Term.Blits bs -> foldM writeBlit ls bs Term.Blits bs -> foldM (writeBlit termSizeVar) ls bs
Term.Trace p -> writeTrace ls (unCord p) Term.Trace p -> writeTrace ls (unCord p)
Term.Slog s -> writeSlog ls s Term.Slog s -> writeSlog ls s
Term.Blank -> writeBlank ls Term.Blank -> writeBlank ls
Term.Spinr (Just txt) -> doSpin ls (unCord <$> txt) Term.Spinr (Just txt) -> doSpin ls (unCord <$> txt)
Term.Spinr Nothing -> unspin ls Term.Spinr Nothing -> unspin ls
-- TODO What does this do? spin :: TVar TermSize -> LineState -> RIO e LineState
spin :: LineState -> RIO e LineState spin ts ls@LineState{..} = do
spin ls@LineState{..} = do
let spinner = (spinners !! lsSpinFrame) ++ case lsSpinCause of let spinner = (spinners !! lsSpinFrame) ++ case lsSpinCause of
Nothing -> "" Nothing -> ""
Just str -> leftBracket ++ str ++ rightBracket Just str -> leftBracket ++ str ++ rightBracket
--NOTE even after first render, because cursor might have moved...
if row lsCurPos > 0
then do
TermSize _ h <- readTVarIO ts
T.cursorMove (fromIntegral h - 1) 0
else
T.cursorRestore
putStr (spinner <> pack (ANSI.cursorBackwardCode (length spinner))) putStr (spinner <> pack (ANSI.cursorBackwardCode (length spinner)))
let newFrame = (lsSpinFrame + 1) `mod` length spinners let newFrame = (lsSpinFrame + 1) `mod` length spinners
@ -362,28 +403,35 @@ localClient doneSignal = fst <$> mkRAcquire start stop
, lsSpinFrame = newFrame , lsSpinFrame = newFrame
} }
loop :: LineState -> RIO e () loop :: TVar TermSize -> LineState -> RIO e ()
loop ls = do loop ts ls = do
join $ atomically $ asum join $ atomically $ asum
[ readTQueue q >>= pure . (foldM execEv ls >=> loop) [ readTQueue q >>= pure . (foldM execEv ls >=> loop ts)
, takeTMVar spinner >> pure (spin ls >>= loop) , takeTMVar spinner >> pure (spin ts ls >>= loop ts)
] ]
-- Writes an individual blit to the screen -- Writes an individual blit to the screen
writeBlit :: LineState -> Blit -> RIO e LineState writeBlit :: TVar TermSize -> LineState -> Blit -> RIO e LineState
writeBlit ls = \case writeBlit ts ls = \case
Bel () -> T.soundBell $> ls Bel () -> T.soundBell $> ls
Clr () -> do T.clearScreen Clr () -> do T.clearScreen
termRefreshLine ls T.cursorRestore
Hop w -> termShowCursor ls (fromIntegral w) pure ls
Klr s -> do ls2 <- termShowClear ls Hop t -> case t of
termShowStub ls2 s Col c -> termShowCursor ls ts 0 (fromIntegral c)
Lin c -> do ls2 <- termShowClear ls Roc r c -> termShowCursor ls ts (fromIntegral r) (fromIntegral c)
termShowLine ls2 (pack c) Klr s -> termShowStub ls s
Mor () -> termShowMore ls Put c -> termShowLine ls (pack c)
Nel () -> termShowNewline ls
Sag path noun -> pure ls Sag path noun -> pure ls
Sav path atom -> pure ls Sav path atom -> pure ls
Url url -> pure ls Url url -> pure ls
Wyp () -> termShowClear ls
--
Lin c -> do termShowCursor ls ts 0 0
termShowClear ls
termShowLine ls (pack c)
Mor () -> termShowNewline ls
termRenderDeco :: Deco -> Char termRenderDeco :: Deco -> Char
termRenderDeco = \case termRenderDeco = \case
@ -428,55 +476,88 @@ localClient doneSignal = fst <$> mkRAcquire start stop
styled = mconcat [escape, styles, "m", tape, escape, "0m"] styled = mconcat [escape, styles, "m", tape, escape, "0m"]
-- Displays and sets styled text as the current line bareStub :: [Char] -> [(Stye, [Char])]
bareStub c = [(Stye (setToHoonSet mempty) TintNull TintNull, c)]
-- overwrite substring of base with put, starting at index
overwriteStub :: [(Stye, [Char])] -> Int -> [(Stye, [Char])] -> [(Stye, [Char])]
overwriteStub base index put =
scagStub index base
++ ( let l = lentStub base in
if index <= l then []
else bareStub $ take (index - l) [' ',' '..]
)
++ put
++ slagStub (index + lentStub put) base
where
lentStub :: [(Stye, [Char])] -> Int
lentStub s = sum $ map (length . snd) s
scagStub :: Int -> [(Stye, [Char])] -> [(Stye, [Char])]
scagStub 0 _ = []
scagStub _ [] = []
scagStub i ((y,c):s) =
(y, take i c) : scagStub (i - min i (length c)) s
slagStub :: Int -> [(Stye, [Char])] -> [(Stye, [Char])]
slagStub 0 s = s
slagStub _ [] = []
slagStub i ((y,c):s)
| i > l = slagStub (i - l) s
| otherwise = (y, drop i c) : s
where l = length c
-- Displays styled text at the cursor
termShowStub :: LineState -> Stub -> RIO e LineState termShowStub :: LineState -> Stub -> RIO e LineState
termShowStub ls (Stub s) = do termShowStub ls@LineState{lsCurPos, lsLine} (Stub s) = do
let visualLength = sum $ fmap (length . snd) s putStr $ pack $ mconcat $ fmap (uncurry termRenderStubSegment) s
let outText = pack $ mconcat $ fmap (uncurry termRenderStubSegment) s T.cursorRestore
putStr outText case row lsCurPos of
pure ls { lsLine = outText, lsCurPos = visualLength } 0 -> pure ls { lsLine = overwriteStub lsLine (col lsCurPos) s }
_ -> pure ls
-- Moves the cursor to the requested position -- Moves the cursor to the requested position
termShowCursor :: LineState -> Int -> RIO e LineState termShowCursor :: LineState -> TVar TermSize -> Int -> Int -> RIO e LineState
termShowCursor ls@LineState{..} {-line pos)-} newPos = do termShowCursor ls ts row col = do
if newPos < lsCurPos then do TermSize _ h <- readTVarIO ts
T.cursorLeft (lsCurPos - newPos) T.cursorMove (max 0 (fromIntegral h - row - 1)) col
pure ls { lsCurPos = newPos } T.cursorSave
else if newPos > lsCurPos then do pure ls { lsCurPos = CurPos row col }
T.cursorRight (newPos - lsCurPos)
pure ls { lsCurPos = newPos }
else
pure ls
-- Moves the cursor left without any mutation of the LineState. Used only
-- in cursor spinning.
_termSpinnerMoveLeft :: Int -> RIO e ()
_termSpinnerMoveLeft = T.cursorLeft
-- Displays and sets the current line -- Displays and sets the current line
termShowLine :: LineState -> Text -> RIO e LineState termShowLine :: LineState -> Text -> RIO e LineState
termShowLine ls newStr = do termShowLine ls@LineState{lsCurPos, lsLine} newStr = do
putStr newStr putStr newStr
pure ls { lsLine = newStr, lsCurPos = (length newStr) } T.cursorRestore
case row lsCurPos of
0 -> pure ls { lsLine = overwriteStub lsLine (col lsCurPos) (bareStub $ unpack newStr) }
_ -> pure ls
termShowClear :: LineState -> RIO e LineState termShowClear :: LineState -> RIO e LineState
termShowClear ls = do termShowClear ls@LineState{lsCurPos} = do
putStr "\r" putStr "\r"
T.clearLine T.clearLine
pure ls { lsLine = "", lsCurPos = 0 } T.cursorRestore
case row lsCurPos of
0 -> pure ls { lsLine = [] }
_ -> pure ls
-- New Current Line -- New Current Line
termShowMore :: LineState -> RIO e LineState termShowNewline :: LineState -> RIO e LineState
termShowMore ls = do termShowNewline ls@LineState{lsCurPos} = do
putStr "\r\n" putStr "\r\n"
pure ls { lsLine = "", lsCurPos = 0 } case row lsCurPos of
0 -> pure ls { lsLine = [], lsCurPos = lsCurPos { col = 0 } }
r -> pure ls { lsCurPos = CurPos (r-1) 0 }
-- Redraw the current LineState, maintaining the current curpos -- Redraw the bottom LineState, maintaining the current curpos
termRefreshLine :: LineState -> RIO e LineState termRestoreLine :: LineState -> TVar TermSize -> RIO e ()
termRefreshLine ls@LineState{lsCurPos,lsLine} = do termRestoreLine ls@LineState{lsLine} ts = do
ls <- termShowClear ls TermSize _ h <- readTVarIO ts
ls <- termShowLine ls lsLine T.cursorMove (fromIntegral h - 1) 0
termShowCursor ls lsCurPos T.clearLine
putStr $ pack $ mconcat $ fmap (uncurry termRenderStubSegment) lsLine
T.cursorRestore
-- ring my bell -- ring my bell
bell :: TQueue [Term.Ev] -> RIO e () bell :: TQueue [Term.Ev] -> RIO e ()
@ -491,9 +572,14 @@ localClient doneSignal = fst <$> mkRAcquire start stop
-- A better way to do this would be to get some sort of epoll on stdInput, -- A better way to do this would be to get some sort of epoll on stdInput,
-- since that's kinda closer to what libuv does? -- since that's kinda closer to what libuv does?
readTerminal :: forall e. HasLogFunc e readTerminal :: forall e. HasLogFunc e
=> TQueue Belt -> TQueue [Term.Ev] -> (RIO e ()) -> RIO e () => TQueue Belt
readTerminal rq wq bell = -> TQueue [Term.Ev]
rioAllocaBytes 1 $ \ buf -> loop (ReadData buf False False mempty 0) -> TVar TermSize
-> RIO e ()
-> RIO e ()
readTerminal rq wq ts bell =
rioAllocaBytes 1 $ \ buf
-> loop (ReadData buf False False False 0 0 mempty 0)
where where
loop :: ReadData -> RIO e () loop :: ReadData -> RIO e ()
loop rd@ReadData{..} = do loop rd@ReadData{..} = do
@ -513,26 +599,41 @@ localClient doneSignal = fst <$> mkRAcquire start stop
if rdEscape then if rdEscape then
if rdBracket then do if rdBracket then do
case c of case c of
'A' -> sendBelt $ Aro U 'A' -> sendBelt $ Bol $ Aro U
'B' -> sendBelt $ Aro D 'B' -> sendBelt $ Bol $ Aro D
'C' -> sendBelt $ Aro R 'C' -> sendBelt $ Bol $ Aro R
'D' -> sendBelt $ Aro L 'D' -> sendBelt $ Bol $ Aro L
'M' -> pure ()
_ -> bell _ -> bell
loop rd { rdEscape = False, rdBracket = False} rd <- case c of
'M' -> pure rd { rdMouse = True }
_ -> pure rd
loop rd { rdEscape = False, rdBracket = False }
else if isAsciiLower c then do else if isAsciiLower c then do
sendBelt $ Met $ Cord $ pack [c] sendBelt $ Mod Met $ Key c
loop rd { rdEscape = False }
else if c == '.' then do
sendBelt $ Met $ Cord "dot"
loop rd { rdEscape = False } loop rd { rdEscape = False }
else if w == 8 || w == 127 then do else if w == 8 || w == 127 then do
sendBelt $ Met $ Cord "bac" sendBelt $ Mod Met $ Bac ()
loop rd { rdEscape = False } loop rd { rdEscape = False }
else if c == '[' || c == '0' then do else if c == '[' || c == '0' then do
loop rd { rdBracket = True } loop rd { rdBracket = True }
else do else do
bell bell
loop rd { rdEscape = False } loop rd { rdEscape = False }
else if rdMouse then
if rdMouseBut == 0 then do
loop rd { rdMouseBut = w - 31 }
else if rdMouseCol == 0 then do
loop rd { rdMouseCol = w - 32 }
else do
if rdMouseBut == 1 then do
let rdMouseRow = w - 32
TermSize _ h <- readTVarIO ts
sendBelt $ Bol $ Hit
(fromIntegral h - fromIntegral rdMouseRow)
(fromIntegral rdMouseCol - 1)
else do pure ()
loop rd { rdMouse = False, rdMouseBut = 0, rdMouseCol = 0 }
else if rdUTF8width /= 0 then do else if rdUTF8width /= 0 then do
-- continue reading into the utf8 accumulation buffer -- continue reading into the utf8 accumulation buffer
rd@ReadData{..} <- pure rd { rdUTF8 = snoc rdUTF8 w } rd@ReadData{..} <- pure rd { rdUTF8 = snoc rdUTF8 w }
@ -543,31 +644,31 @@ localClient doneSignal = fst <$> mkRAcquire start stop
error "empty utf8 accumulation buffer" error "empty utf8 accumulation buffer"
Just (c, bytes) | bytes /= rdUTF8width -> Just (c, bytes) | bytes /= rdUTF8width ->
error "utf8 character size mismatch?!" error "utf8 character size mismatch?!"
Just (c, bytes) -> sendBelt $ Txt $ Tour $ [c] Just (c, bytes) -> sendBelt $ Bol $ Key c
loop rd { rdUTF8 = mempty, rdUTF8width = 0 } loop rd { rdUTF8 = mempty, rdUTF8width = 0 }
else if w >= 32 && w < 127 then do else if w >= 32 && w < 127 then do
sendBelt $ Txt $ Tour $ [c] sendBelt $ Bol $ Key c
loop rd loop rd
else if w == 0 then do else if w == 0 then do
bell bell
loop rd loop rd
else if w == 8 || w == 127 then do else if w == 8 || w == 127 then do
sendBelt $ Bac () sendBelt $ Bol $ Bac ()
loop rd loop rd
else if w == 13 then do else if w == 13 then do
sendBelt $ Ret () sendBelt $ Bol $ Ret ()
loop rd loop rd
else if w == 3 then do else if w == 3 then do
-- ETX (^C) -- ETX (^C)
logInfo $ "Ctrl-c interrupt" logInfo $ "Ctrl-c interrupt"
atomically $ do atomically $ do
writeTQueue wq [Term.Trace "interrupt\r\n"] writeTQueue wq [Term.Trace "interrupt"]
writeTQueue rq $ Ctl $ Cord "c" writeTQueue rq $ Mod Ctl $ Key 'c'
loop rd loop rd
else if w <= 26 then do else if w <= 26 then do
case pack [BS.w2c (w + 97 - 1)] of case BS.w2c (w + 97 - 1) of
"d" -> atomically doneSignal 'd' -> atomically doneSignal
c -> do sendBelt $ Ctl $ Cord c c -> do sendBelt $ Mod Ctl $ Key c
loop rd loop rd
else if w == 27 then do else if w == 27 then do
loop rd { rdEscape = True } loop rd { rdEscape = True }
@ -644,7 +745,7 @@ term env (tsize, Client{..}) plan stat serfSIGINT = runTerm
atomically take >>= \case atomically take >>= \case
Nothing -> pure () Nothing -> pure ()
Just (ClientTakeBelt b) -> do Just (ClientTakeBelt b) -> do
when (b == Ctl (Cord "c")) $ do when (b == Mod Ctl (Key 'c')) $ do
io serfSIGINT io serfSIGINT
let beltEv = EvBlip $ BlipEvTerm $ TermEvBelt (UD 1, ()) $ b let beltEv = EvBlip $ BlipEvTerm $ TermEvBelt (UD 1, ()) $ b
let beltFailed _ = pure () let beltFailed _ = pure ()

2
pkg/hs/urbit-king/lib/Urbit/Vere/Term/API.hs
View File

@ -22,7 +22,7 @@ import Urbit.TermSize
Input Event for terminal driver: Input Event for terminal driver:
%blits -- list of blits from arvo. %blits -- list of blits from arvo.
%trace -- stderr line from runtime. %trace -- stderr line from runtime (without trailing newline).
%slog -- nock worker logging with priority %slog -- nock worker logging with priority
%blank -- print a blank line %blank -- print a blank line
%spinr -- Start or stop the spinner %spinr -- Start or stop the spinner

61
pkg/hs/urbit-king/lib/Urbit/Vere/Term/Logic.hs
View File

@ -39,11 +39,11 @@ data Ev
= EvLine Text = EvLine Text
| EvSlog (Atom, Tank) | EvSlog (Atom, Tank)
| EvSpin SpinnerState | EvSpin SpinnerState
| EvMove Word | EvMove (Word, Word)
| EvBell | EvBell
| EvDraw | EvDraw
| EvEdit Text | EvEdit Text
| EvMore | EvNewl
deriving (Show) deriving (Show)
data Ef data Ef
@ -62,7 +62,7 @@ data History
data St = St data St = St
{ sHistory :: !(Seq History) { sHistory :: !(Seq History)
, sLine :: !Text , sLine :: !Text
, sCurPos :: !Word , sCurPos :: !(Word, Word)
, sSpinner :: !SpinnerState , sSpinner :: !SpinnerState
} }
deriving (Show) deriving (Show)
@ -70,10 +70,10 @@ data St = St
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
init :: St init :: St
init = St mempty "" 0 Nothing init = St mempty "" (0, 0) Nothing
{-| {-|
When we process `EvMore`, we need to append a newline to the end of When we process `EvNewl`, we need to append a newline to the end of
the current line. During normal play, the ENTER key inserts the the current line. During normal play, the ENTER key inserts the
newline for us, so we need to recreate that newline when we rebuild newline for us, so we need to recreate that newline when we rebuild
the state for a new terminal connection. the state for a new terminal connection.
@ -83,15 +83,17 @@ step st@St{..} = \case
EvLine t -> st & recordText t EvLine t -> st & recordText t
EvSlog s -> st & recordSlog s EvSlog s -> st & recordSlog s
EvSpin s -> st { sSpinner = s } EvSpin s -> st { sSpinner = s }
EvMove w -> st { sCurPos = min w (word $ length sLine) } EvMove p -> st { sCurPos = p }
EvEdit t -> st { sLine = t, sCurPos = word (length t) }
EvMore -> st { sLine = "", sCurPos = 0 } & recordText (sLine <> "\n")
EvBell -> st EvBell -> st
EvDraw -> st EvDraw -> st
EvEdit t | (0, _) <- sCurPos -> st { sLine = t }
| otherwise -> st
EvNewl | (0, _) <- sCurPos ->
st { sLine = "", sCurPos = (0, 0) }
& recordText (sLine <> "\n")
| otherwise ->
st { sCurPos = (fst sCurPos - 1, 0) }
where where
word :: Integral i => i -> Word
word = fromIntegral
recordText :: Text -> St -> St recordText :: Text -> St -> St
recordText !t st@St{..} = st { recordText !t st@St{..} = st {
sHistory = trim (sHistory |> (HistoryText t)) sHistory = trim (sHistory |> (HistoryText t))
@ -111,8 +113,10 @@ drawState :: St -> [Ev]
drawState St{..} = hist <> out <> cur <> spin drawState St{..} = hist <> out <> cur <> spin
where where
hist = drawHistory <$> toList sHistory hist = drawHistory <$> toList sHistory
out = if null sLine then [] else [EvEdit sLine] out | null sLine = []
cur = if 0 == sCurPos then [] else [EvMove $ fromIntegral $ sCurPos] | otherwise = [EvEdit sLine]
cur | (0, _) <- sCurPos = []
| otherwise = [EvMove sCurPos]
spin = maybe [] (singleton . EvSpin . Just) sSpinner spin = maybe [] (singleton . EvSpin . Just) sSpinner
drawHistory (HistoryText t) = EvLine t drawHistory (HistoryText t) = EvLine t
@ -123,12 +127,13 @@ drawState St{..} = hist <> out <> cur <> spin
fromBlit :: Arvo.Blit -> Maybe Ev fromBlit :: Arvo.Blit -> Maybe Ev
fromBlit = \case fromBlit = \case
Arvo.Hop w -> Just $ EvMove $ fromIntegral w Arvo.Hop (Arvo.Col c) -> Just $ EvMove (0, fromIntegral c)
Arvo.Bel () -> Just EvBell Arvo.Hop (Arvo.Roc r c) -> Just $ EvMove (fromIntegral r, fromIntegral c)
Arvo.Clr () -> Just EvDraw Arvo.Bel () -> Just EvBell
Arvo.Lin s -> Just $ EvEdit (pack s) Arvo.Clr () -> Just EvDraw
Arvo.Mor () -> Just EvMore Arvo.Put s -> Just $ EvEdit (pack s)
_ -> Nothing Arvo.Nel () -> Just EvNewl
_ -> Nothing
toCause :: Maybe Cord -> SpinnerCause toCause :: Maybe Cord -> SpinnerCause
toCause Nothing = User toCause Nothing = User
@ -148,12 +153,12 @@ fromTermEv = \case
toTermEv :: Ev -> Term.Ev toTermEv :: Ev -> Term.Ev
toTermEv = \case toTermEv = \case
EvLine "" -> Term.Blank EvLine "" -> Term.Blank
EvLine t -> Term.Trace (Cord t) EvLine t -> Term.Trace (Cord t)
EvSlog s -> Term.Slog s EvSlog s -> Term.Slog s
EvSpin s -> Term.Spinr (fromCause <$> s) EvSpin s -> Term.Spinr (fromCause <$> s)
EvMove w -> Term.Blits [Arvo.Hop $ fromIntegral w] EvMove (r, c) -> Term.Blits [Arvo.Hop $ Arvo.Roc (fromIntegral r) (fromIntegral c)]
EvBell -> Term.Blits [Arvo.Bel ()] EvBell -> Term.Blits [Arvo.Bel ()]
EvDraw -> Term.Blits [Arvo.Clr ()] EvDraw -> Term.Blits [Arvo.Clr ()]
EvEdit t -> Term.Blits [Arvo.Lin $ unpack t] EvEdit t -> Term.Blits [Arvo.Put $ unpack t]
EvMore -> Term.Blits [Arvo.Mor ()] EvNewl -> Term.Blits [Arvo.Nel ()]

34
pkg/hs/urbit-king/lib/Urbit/Vere/Term/Render.hs
View File

@ -4,9 +4,12 @@
module Urbit.Vere.Term.Render module Urbit.Vere.Term.Render
( clearScreen ( clearScreen
, clearLine , clearLine
, cursorRight
, cursorLeft
, soundBell , soundBell
, cursorMove
, cursorSave
, cursorRestore
, putCsi
, hijack
) where ) where
import ClassyPrelude import ClassyPrelude
@ -25,8 +28,27 @@ clearLine = liftIO $ ANSI.clearLine
soundBell :: MonadIO m => m () soundBell :: MonadIO m => m ()
soundBell = liftIO $ putStr "\a" soundBell = liftIO $ putStr "\a"
cursorLeft :: MonadIO m => Int -> m () --NOTE top-left-0-based coordinates
cursorLeft = liftIO . ANSI.cursorBackward cursorMove :: MonadIO m => Int -> Int -> m ()
cursorMove r c = liftIO $ ANSI.setCursorPosition r c
cursorRight :: MonadIO m => Int -> m () cursorSave :: MonadIO m => m ()
cursorRight = liftIO . ANSI.cursorForward cursorSave = liftIO ANSI.saveCursor
cursorRestore :: MonadIO m => m ()
cursorRestore = liftIO ANSI.restoreCursor
putCsi :: MonadIO m => Char -> [Int] -> m ()
putCsi c a = liftIO do
putStr "\x1b["
putStr $ pack $ mconcat $ intersperse ";" (fmap show a)
putStr $ pack [c]
hijack :: MonadIO m => Int -> IO () -> m ()
hijack h d = liftIO do
putCsi 'r' [1, h-1] -- set scroll region to exclude bottom line
putCsi 'S' [1] -- scroll up one line
cursorMove (h-2) 0 -- move cursor to empty space
d
putCsi 'r' [] -- reset scroll region
cursorRestore -- restory cursor position

57289
pkg/interface/package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

2
pkg/interface/package.json
View File

@ -53,6 +53,8 @@
"suncalc": "^1.8.0", "suncalc": "^1.8.0",
"unist-util-visit": "^3.0.0", "unist-util-visit": "^3.0.0",
"urbit-ob": "^5.0.1", "urbit-ob": "^5.0.1",
"xterm": "^4.10.0",
"xterm-addon-fit": "^0.5.0",
"workbox-core": "^6.0.2", "workbox-core": "^6.0.2",
"workbox-precaching": "^6.0.2", "workbox-precaching": "^6.0.2",
"workbox-recipes": "^6.0.2", "workbox-recipes": "^6.0.2",

1
pkg/interface/src/logic/lib/bel.js
View File

File diff suppressed because one or more lines are too long

1
pkg/interface/src/logic/lib/bel.ts Normal file
View File

File diff suppressed because one or more lines are too long

21
pkg/interface/src/logic/state/term.ts Normal file
View File

@ -0,0 +1,21 @@
import { Terminal } from 'xterm';
import { FitAddon } from 'xterm-addon-fit';
import { createState } from "./base";
type Session = { term: Terminal, fit: FitAddon };
type Sessions = { [id: string]: Session; }
export interface TermState {
sessions: Sessions,
selected: string,
slogstream: null | EventSource,
};
const useTermState = createState<TermState>('Term', {
sessions: {},
selected: '', // empty string is default session
slogstream: null,
}, ['sessions', 'slogstream']); //TODO consider persisting
export default useTermState;

50
pkg/interface/src/views/apps/term/api.tsx
View File

@ -1,50 +0,0 @@
import _ from 'lodash';
export default class Api {
ship: any;
channel: any;
bindPaths: any[];
constructor(ship, channel) {
this.ship = ship;
this.channel = channel;
this.bindPaths = [];
}
bind(path, method, ship = this.ship, appl = 'herm', success, fail) {
this.bindPaths = _.uniq([...this.bindPaths, path]);
(window as any).subscriptionId = this.channel.subscribe(ship, appl, path,
(err) => {
fail(err);
},
(event) => {
success({
data: event,
from: {
ship,
path
}
});
},
(err) => {
fail(err);
});
}
belt(belt) {
return this.action('herm', 'belt', belt);
}
action(appl, mark, data) {
return new Promise((resolve, reject) => {
this.channel.poke(window.ship, appl, mark, data,
(json) => {
resolve(json);
},
(err) => {
reject(err);
});
});
}
}

526
pkg/interface/src/views/apps/term/app.tsx
View File

@ -1,100 +1,444 @@
import { Box, Col } from '@tlon/indigo-react'; import React, {
import React, { Component } from 'react'; useEffect,
useRef,
useCallback
} from 'react';
import Helmet from 'react-helmet'; import Helmet from 'react-helmet';
import { Route } from 'react-router-dom';
import withState from '~/logic/lib/withState';
import useHarkState from '~/logic/state/hark';
import Api from './api';
import { History } from './components/history';
import { Input } from './components/input';
import './css/custom.css';
import Store from './store';
import Subscription from './subscription';
class TermApp extends Component<any, any> { import useTermState from '~/logic/state/term';
store: Store; import { useDark } from '~/logic/state/join';
api: any;
subscription: any;
constructor(props) {
super(props);
this.store = new Store();
this.store.setStateHandler(this.setState.bind(this));
this.state = this.store.state; import { Terminal, ITerminalOptions, ITheme } from 'xterm';
} import { FitAddon } from 'xterm-addon-fit';
import { saveAs } from 'file-saver';
resetControllers() { import { Box, Col } from '@tlon/indigo-react';
this.api = null;
this.subscription = null;
}
componentDidMount() { import '../../../../node_modules/xterm/css/xterm.css';
this.resetControllers(); import api from '~/logic/api/index';
// eslint-disable-next-line new-cap import {
const channel = new (window as any).channel(); Belt, Blit, Stye, Stub, Tint, Deco,
this.api = new Api(this.props.ship, channel); pokeTask, pokeBelt
this.store.api = this.api; } from '@urbit/api/term';
this.subscription = new Subscription(this.store, this.api, channel); import bel from '~/logic/lib/bel';
this.subscription.start();
}
componentWillUnmount() { type TermAppProps = {
this.subscription.delete(); ship: string;
this.store.clear(); notificationsCount: number;
this.resetControllers();
}
render() {
return (
<>
<Helmet defer={false}>
<title>{ this.props.notificationsCount ? `(${String(this.props.notificationsCount) }) `: '' }Landscape</title>
</Helmet>
<Box
height='100%'
>
<Route
exact
path="/~term/"
render={(props) => {
return (
<Box
width='100%'
height='100%'
display='flex'
>
<Col
p={3}
backgroundColor='white'
width='100%'
minHeight={0}
minWidth={0}
color='lightGray'
borderRadius={2}
mx={['0','3']}
mb={['0','3']}
border={['0','1']}
cursor='text'
>
{/* @ts-ignore declare props in later pass */}
<History log={this.state.lines.slice(0, -1)} />
<Input
ship={this.props.ship}
cursor={this.state.cursor}
api={this.api}
store={this.store}
line={this.state.lines.slice(-1)[0]}
/>
</Col>
</Box>
);
}}
/>
</Box>
</>
);
}
} }
export default withState(TermApp, [[useHarkState]]); const makeTheme = (dark: boolean): ITheme => {
let fg, bg: string;
if (dark) {
fg = 'white';
bg = 'black';
} else {
fg = 'black';
bg = 'white';
}
// TODO indigo colors.
// we can't pluck these from ThemeContext because they have transparency.
// technically xterm supports transparency, but it degrades performance.
return {
foreground: fg,
background: bg,
brightBlack: '#7f7f7f', // NOTE slogs
cursor: fg
};
};
const termConfig: ITerminalOptions = {
logLevel: 'warn',
//
convertEol: true,
//
rows: 24,
cols: 80,
scrollback: 10000,
//
fontFamily: '"Source Code Pro","Roboto mono","Courier New",monospace',
// NOTE theme colors configured dynamically
//
bellStyle: 'sound',
bellSound: bel,
//
// allows text selection by holding modifier (option, or shift)
macOptionClickForcesSelection: true
};
const csi = (cmd: string, ...args: number[]) => {
return '\x1b[' + args.join(';') + cmd;
};
const tint = (t: Tint) => {
switch (t) {
case null: return '9';
case 'k': return '0';
case 'r': return '1';
case 'g': return '2';
case 'y': return '3';
case 'b': return '4';
case 'm': return '5';
case 'c': return '6';
case 'w': return '7';
default: return `8;2;${t.r%256};${t.g%256};${t.b%256}`;
}
};
const stye = (s: Stye) => {
let out = '';
// text decorations
//
if (s.deco.length > 0) {
out += s.deco.reduce((decs: number[], deco: Deco) => {
/* eslint-disable max-statements-per-line */
switch (deco) {
case null: decs.push(0); return decs;
case 'br': decs.push(1); return decs;
case 'un': decs.push(4); return decs;
case 'bl': decs.push(5); return decs;
default: console.log('weird deco', deco); return decs;
}
}, []).join(';');
}
// background color
//
if (s.back !== null) {
if (out !== '') {
out += ';';
}
out += '4';
out += tint(s.back);
}
// foreground color
//
if (s.fore !== null) {
if (out !== '') {
out += ';';
}
out += '3';
out += tint(s.fore);
}
if (out === '') {
return out;
}
return '\x1b[' + out + 'm';
};
const showBlit = (term: Terminal, blit: Blit) => {
let out = '';
if ('bel' in blit) {
out += '\x07';
} else if ('clr' in blit) {
term.clear();
out += csi('u');
} else if ('hop' in blit) {
if (typeof blit.hop === 'number') {
out += csi('H', term.rows, blit.hop + 1);
} else {
out += csi('H', term.rows - blit.hop.r, blit.hop.c + 1);
}
out += csi('s'); // save cursor position
} else if ('put' in blit) {
out += blit.put.join('');
out += csi('u');
} else if ('klr' in blit) {
out += blit.klr.reduce((lin: string, p: Stub) => {
lin += stye(p.stye);
lin += p.text.join('');
lin += csi('m', 0);
return lin;
}, '');
out += csi('u');
} else if ('nel' in blit) {
out += '\n';
} else if ('sag' in blit || 'sav' in blit) {
const sav = ('sag' in blit) ? blit.sag : blit.sav;
const name = sav.path.split('/').slice(-2).join('.');
const buff = Buffer.from(sav.file, 'base64');
const blob = new Blob([buff], { type: 'application/octet-stream' });
saveAs(blob, name);
} else if ('url' in blit) {
window.open(blit.url);
} else if ('wyp' in blit) {
out += '\r' + csi('K');
out += csi('u');
} else {
console.log('weird blit', blit);
}
term.write(out);
};
// NOTE should generally only be passed the default terminal session
const showSlog = (term: Terminal, slog: string) => {
// set scroll region to exclude the bottom line,
// scroll up one line,
// move cursor to start of the newly created whitespace,
// set text to grey,
// print the slog,
// restore color, scroll region, and cursor.
//
term.write(csi('r', 1, term.rows - 1)
+ csi('S', 1)
+ csi('H', term.rows - 1, 1)
+ csi('m', 90)
+ slog
+ csi('m', 0)
+ csi('r')
+ csi('u'));
};
const readInput = (term: Terminal, e: string): Belt[] => {
const belts: Belt[] = [];
let strap = '';
while (e.length > 0) {
let c = e.charCodeAt(0);
// text input
//
if (c >= 32 && c !== 127) {
strap += e[0];
e = e.slice(1);
continue;
} else if ('' !== strap) {
belts.push({ txt: strap.split('') });
strap = '';
}
// special keys/characters
//
if (0 === c) {
term.write('\x07'); // bel
} else if (8 === c || 127 === c) {
belts.push({ bac: null });
} else if (13 === c) {
belts.push({ ret: null });
} else if (c <= 26) {
belts.push({ mod: { mod: 'ctl', key: String.fromCharCode(96 + c) } });
}
// escape sequences
//
if (27 === c) { // ESC
e = e.slice(1);
c = e.charCodeAt(0);
if (91 === c || 79 === c) { // [ or O
e = e.slice(1);
c = e.charCodeAt(0);
/* eslint-disable max-statements-per-line */
switch (c) {
case 65: belts.push({ aro: 'u' }); break;
case 66: belts.push({ aro: 'd' }); break;
case 67: belts.push({ aro: 'r' }); break;
case 68: belts.push({ aro: 'l' }); break;
//
case 77: {
const m = e.charCodeAt(1) - 31;
if (1 === m) {
const c = e.charCodeAt(2) - 32;
const r = e.charCodeAt(3) - 32;
belts.push({ hit: { r: term.rows - r, c: c - 1 } });
}
e = e.slice(3);
break;
}
//
default: term.write('\x07'); break; // bel
}
} else if (c >= 97 && c <= 122) { // a <= c <= z
belts.push({ mod: { mod: 'met', key: e[0] } });
} else if (c === 46) { // .
belts.push({ mod: { mod: 'met', key: '.' } });
} else if (c === 8 || c === 127) {
belts.push({ mod: { mod: 'met', key: { bac: null } } });
} else {
term.write('\x07'); break; // bel
}
}
e = e.slice(1);
}
if ('' !== strap) {
belts.push({ txt: strap.split('') });
strap = '';
}
return belts;
};
export default function TermApp(props: TermAppProps) {
const container = useRef<HTMLDivElement>(null);
// TODO allow switching of selected
const { sessions, selected, slogstream, set } = useTermState();
const session = sessions[selected];
const dark = useDark();
const setupSlog = useCallback(() => {
console.log('slog: setting up...');
let available = false;
const slog = new EventSource('/~_~/slog', { withCredentials: true });
slog.onopen = (e) => {
console.log('slog: opened stream');
available = true;
};
slog.onmessage = (e) => {
const session = useTermState.getState().sessions[''];
if (!session) {
console.log('default session mia!', 'slog:', slog);
return;
}
showSlog(session.term, e.data);
};
slog.onerror = (e) => {
console.error('slog: eventsource error:', e);
if (available) {
window.setTimeout(() => {
if (slog.readyState !== EventSource.CLOSED) {
return;
}
console.log('slog: reconnecting...');
setupSlog();
}, 10000);
}
};
set((state) => {
state.slogstream = slog;
});
}, [sessions]);
const onInput = useCallback((ses: string, e: string) => {
const term = useTermState.getState().sessions[ses].term;
const belts = readInput(term, e);
belts.map((b) => { // NOTE passing api.poke(pokeBelt makes `this` undefined!
api.poke(pokeBelt(ses, b));
});
}, [sessions]);
const onResize = useCallback(() => {
// TODO debounce, if it ever becomes a problem
session?.fit.fit();
}, [session]);
// on-init, open slogstream
//
useEffect(() => {
if (!slogstream) {
setupSlog();
}
window.addEventListener('resize', onResize);
return () => {
// TODO clean up subs?
window.removeEventListener('resize', onResize);
};
}, [onResize, setupSlog]);
// on dark mode change, change terminals' theme
//
useEffect(() => {
const theme = makeTheme(dark);
for (const ses in sessions) {
sessions[ses].term.setOption('theme', theme);
}
if (container.current) {
container.current.style.backgroundColor = theme.background || '';
}
}, [dark, sessions]);
// on selected change, maybe setup the term, or put it into the container
//
useEffect(() => {
let ses = session;
// initialize terminal
//
if (!ses) {
// set up terminal
//
const term = new Terminal(termConfig);
term.setOption('theme', makeTheme(dark));
const fit = new FitAddon();
term.loadAddon(fit);
// start mouse reporting
//
term.write(csi('?9h'));
// set up event handlers
//
term.onData(e => onInput(selected, e));
term.onBinary(e => onInput(selected, e));
term.onResize((e) => {
api.poke(pokeTask(selected, { blew: { w: e.cols, h: e.rows } }));
});
ses = { term, fit };
// open subscription
//
api.subscribe({ app: 'herm', path: '/session/'+selected,
event: (e) => {
const ses = useTermState.getState().sessions[selected];
if (!ses) {
console.log('on blit: no such session', selected, sessions, useTermState.getState().sessions);
return;
}
showBlit(ses.term, e);
},
quit: () => { // quit
// TODO show user a message
}
});
}
if (container.current && !container.current.contains(ses.term.element || null)) {
ses.term.open(container.current);
ses.fit.fit();
ses.term.focus();
}
set((state) => {
state.sessions[selected] = ses;
});
return () => {
// TODO unload term from container
// but term.dispose is too powerful? maybe just empty the container?
};
}, [set, session, container]);
return (
<>
<Helmet defer={false}>
<title>{ props.notificationsCount ? `(${String(props.notificationsCount) }) `: '' }Landscape</title>
</Helmet>
<Box
width='100%'
height='100%'
px={['0','3']}
pb={['0','3']}
display='flex'
>
<Col
width='100%'
minHeight='0'
color='washedGray'
borderRadius={['0','2']}
border={['0','1']}
p='1'
ref={container}
>
</Col>
</Box>
</>
);
}

35
pkg/interface/src/views/apps/term/components/history.tsx
View File

@ -1,35 +0,0 @@
import { Box } from '@tlon/indigo-react';
import React, { Component } from 'react';
import Line from './line';
export class History extends Component {
constructor(props) {
super(props);
}
render() {
return (
<Box
height='100%'
minHeight={0}
minWidth={0}
display='flex'
flexDirection='column-reverse'
overflowY='scroll'
style={{ resize: 'none' }}
>
<Box
mt='auto'
>
{/* @ts-ignore declare props in later pass */}
{this.props.log.map((line, i) => {
// @ts-ignore react memo not passing props
return <Line key={i} line={line} />;
})}
</Box>
</Box>
);
}
}
export default History;

66
pkg/interface/src/views/apps/term/components/line.tsx
View File

@ -1,66 +0,0 @@
import { Text } from '@tlon/indigo-react';
import React from 'react';
// @ts-ignore line isn't in props?
export default React.memo(({ line }) => {
// line body to jsx
// NOTE lines are lists of characters that might span multiple codepoints
//
let text = '';
if (line.lin) {
text = line.lin.join('');
} else if (line.klr) {
text = line.klr.map((part, i) => {
const prop = part.stye.deco.reduce((prop, deco) => {
switch (deco) {
case null: return prop;
case 'br': return { bold: true, ...prop };
case 'bl': return { className: 'blink', ...prop };
case 'un': return { style: { textDecoration: 'underline' }, ...prop };
default: console.log('weird deco', deco); return prop;
}
}, {});
switch (part.stye.fore) {
case null: break;
case 'r': prop.color = 'red'; break;
case 'g': prop.color = 'green'; break;
case 'b': prop.color = 'blue'; break;
case 'c': prop.color = 'cyan'; break;
case 'm': prop.color = 'purple'; break;
case 'y': prop.color = 'yellow'; break;
case 'k': prop.color = 'black'; break;
case 'w': prop.color = 'white'; break;
default: prop.color = '#' + part.stye.fore;
}
switch (part.stye.back) {
case null: break;
case 'r': prop.backgroundColor = 'red'; break;
case 'g': prop.backgroundColor = 'green'; break;
case 'b': prop.backgroundColor = 'blue'; break;
case 'c': prop.backgroundColor = 'cyan'; break;
case 'm': prop.backgroundColor = 'purple'; break;
case 'y': prop.backgroundColor = 'yellow'; break;
case 'k': prop.backgroundColor = 'black'; break;
case 'w': prop.backgroundColor = 'white'; break;
default: prop.backgroundColor = '#' + part.stye.back;
}
if (Object.keys(prop).length === 0) {
return part.text;
} else {
return (<Text mono fontSize='inherit' key={i} {...prop}>
{part.text.join('')}
</Text>);
}
});
}
// render line
//
return (
<Text mono display='flex'
fontSize={0}
style={{ overflowWrap: 'break-word', whiteSpace: 'pre-wrap' }}
>
{text}
</Text>
);
});

16
pkg/interface/src/views/apps/term/css/custom.css
View File

@ -1,16 +0,0 @@
input#term {
background-color: inherit;
color: inherit;
}
.blink {
animation: 4s ease-in-out infinite opacity_blink;
}
@keyframes opacity_blink {
0% { opacity: 0; }
10% { opacity: 1; }
80% { opacity: 1; }
90% { opacity: 0; }
100% { opacity: 0; }
}

94
pkg/interface/src/views/apps/term/store.tsx
View File

@ -1,94 +0,0 @@
import { saveAs } from 'file-saver';
import bel from '../../../logic/lib/bel';
export default class Store {
state: any;
api: any;
setState: any;
constructor() {
this.state = this.initialState();
}
initialState() {
return {
lines: [''],
cursor: 0
};
}
clear() {
this.setState(this.initialState());
}
handleEvent(data) {
// process slogs
//
if (data.slog) {
this.state.lines.splice(this.state.lines.length-1, 0, { lin: [data.slog] });
this.setState({ lines: this.state.lines });
return;
}
// process blits
//
const blit = data.data;
switch (Object.keys(blit)[0]) {
case 'bel':
bel.play();
break;
case 'clr':
this.state.lines = this.state.lines.slice(-1);
this.setState({ lines: this.state.lines });
break;
case 'hop':
// since lines are lists of characters that might span multiple
// codepoints, we need to calculate the byte-wise cursor position
// to avoid incorrect cursor rendering.
//
const line = this.state.lines[this.state.lines.length - 1];
let hops;
if (line.lin) {
hops = line.lin.slice(0, blit.hop);
} else if (line.klr) {
hops = line.klr.reduce((h, p) => {
if (h.length >= blit.hop)
return h;
return [...h, ...p.text.slice(0, blit.hop - h.length)];
}, []);
}
this.setState({ cursor: hops.join('').length });
break;
case 'lin':
this.state.lines[this.state.lines.length - 1] = blit;
this.setState({ lines: this.state.lines });
break;
case 'klr':
this.state.lines[this.state.lines.length - 1] = blit;
this.setState({ lines: this.state.lines });
break;
case 'mor':
this.state.lines.push('');
this.setState({ lines: this.state.lines });
break;
case 'sag':
blit.sav = blit.sag;
break;
case 'sav':
const name = blit.sav.path.split('/').slice(-2).join('.');
const buff = new Buffer(blit.sav.file, 'base64');
const blob = new Blob([buff], { type: 'application/octet-stream' });
saveAs(blob, name);
break;
case 'url':
// TODO too invasive? just print as <a>?
window.open(blit.url);
break;
default: console.log('weird blit', blit);
}
}
setStateHandler(setState) {
this.setState = setState;
}
}

87
pkg/interface/src/views/apps/term/subscription.tsx
View File

@ -1,87 +0,0 @@
export default class Subscription {
store: any;
api: any;
channel: any;
firstRoundComplete: boolean;
constructor(store, api, channel) {
this.store = store;
this.api = api;
this.channel = channel;
this.channel.setOnChannelError(this.onChannelError.bind(this));
this.firstRoundComplete = false;
}
start() {
if (this.api.ship) {
this.firstRound();
} else {
console.error('~~~ ERROR: Must set api.ship before operation ~~~');
}
this.setupSlog();
}
setupSlog() {
let available = false;
const slog = new EventSource('/~_~/slog', { withCredentials: true });
slog.onopen = (e) => {
console.log('slog: opened stream');
available = true;
};
slog.onmessage = (e) => {
this.handleEvent({ slog: e.data });
};
slog.onerror = (e) => {
console.error('slog: eventsource error:', e);
if (available) {
window.setTimeout(() => {
if (slog.readyState !== EventSource.CLOSED)
return;
console.log('slog: reconnecting...');
this.setupSlog();
}, 10000);
}
};
}
delete() {
this.channel.delete();
}
onChannelError(err) {
console.error('event source error: ', err);
console.log('initiating new channel');
this.firstRoundComplete = false;
setTimeout(() => {
this.store.handleEvent({
data: { clear : true }
});
this.start();
}, 2000);
}
subscribe(path, app) {
this.api.bind(path, 'PUT', this.api.ship, app,
this.handleEvent.bind(this),
(err) => {
console.log(err);
this.subscribe(path, app);
},
() => {
this.subscribe(path, app);
});
}
firstRound() {
this.subscribe('/session/', 'herm');
}
handleEvent(diff) {
this.store.handleEvent(diff);
}
}

2
pkg/npm/api/term/index.ts Normal file
View File

@ -0,0 +1,2 @@
export * from './types';
export * from './lib';

22
pkg/npm/api/term/lib.ts Normal file
View File

@ -0,0 +1,22 @@
import _ from 'lodash';
import { Scry } from '../lib'
import { Poke } from '../lib/types';
import { Belt, Task, SessionTask } from './types';
export const pokeTask = (session: string, task: Task): Poke<SessionTask> => ({
app: 'herm',
mark: 'herm-task',
json: { session, ...task }
});
export const pokeBelt = (
session: string,
belt: Belt
): Poke<SessionTask> => pokeTask(session, { belt });
//NOTE scry will return string[]
export const scrySessions = (): Scry => ({
app: 'herm',
path: `/sessions`
});

60
pkg/npm/api/term/types.ts Normal file
View File

@ -0,0 +1,60 @@
// outputs
//
export type TermUpdate =
| Blit;
export type Tint =
| null
| 'r' | 'g' | 'b' | 'c' | 'm' | 'y' | 'k' | 'w'
| { r: number, g: number, b: number };
export type Deco = null | 'br' | 'un' | 'bl';
export type Stye = {
deco: Deco[],
back: Tint,
fore: Tint
};
export type Stub = {
stye: Stye,
text: string[]
}
export type Blit =
| { bel: null } // make a noise
| { clr: null } // clear the screen
| { hop: number | { r: number, c: number } } // set cursor col/pos
| { klr: Stub[] } // put styled
| { put: string[] } // put text at cursor
| { nel: null } // newline
| { sag: { path: string, file: string } } // save to jamfile
| { sav: { path: string, file: string } } // save to file
| { url: string } // activate url
| { wyp: null } // wipe cursor line
// inputs
//
export type Bolt =
| string
| { aro: 'd' | 'l' | 'r' | 'u' }
| { bac: null }
| { del: null }
| { hit: { r: number, c: number } }
| { ret: null }
export type Belt =
| Bolt
| { mod: { mod: 'ctl' | 'met' | 'hyp', key: Bolt } }
| { txt: Array<string> };
export type Task =
| { belt: Belt }
| { blew: { w: number, h: number } }
| { flow: { term: string, apps: Array<{ who: string, app: string }> } }
| { hail: null }
| { hook: null }
export type SessionTask = { session: string } & Task

8
pkg/urbit/compat/mingw/ptty.c
View File

@ -126,10 +126,10 @@ u3_ptty_init(uv_loop_t* lup_u, const c3_c** err_c)
uty_u->wsz_f = _ttyf_get_winsize; uty_u->wsz_f = _ttyf_get_winsize;
} }
} else { } else {
if ( 0 == (e = uv_pipe_init(lup_u, &uty_u->pin_u.pop_u, 0)) && if ( 0 == (e = uv_pipe_init(lup_u, &uty_u->pin_u.pip_u, 0)) &&
0 == (e = uv_pipe_init(lup_u, &uty_u->pop_u.pop_u, 0)) && 0 == (e = uv_pipe_init(lup_u, &uty_u->pop_u.pip_u, 0)) &&
0 == (e = uv_pipe_open(&uty_u->pin_u.pop_u, 0)) && 0 == (e = uv_pipe_open(&uty_u->pin_u.pip_u, 0)) &&
0 == (e = uv_pipe_open(&uty_u->pop_u.pop_u, 1)) ) 0 == (e = uv_pipe_open(&uty_u->pop_u.pip_u, 1)) )
{ {
fprintf(stderr, "vere: running interactive in a terminal emulator is experimental\r\n" fprintf(stderr, "vere: running interactive in a terminal emulator is experimental\r\n"
" use -t to disable interactivity or use native Windows console\r\n") ; " use -t to disable interactivity or use native Windows console\r\n") ;

8
pkg/urbit/compat/mingw/uv.patch
View File

@ -15,6 +15,14 @@ index 0f2bb869b..f81245ec6 100644
if (err == ERROR_ACCESS_DENIED) { if (err == ERROR_ACCESS_DENIED) {
/* /*
* SetNamedPipeHandleState can fail if the handle doesn't have either * SetNamedPipeHandleState can fail if the handle doesn't have either
@@ -1054,7 +1054,6 @@ static DWORD WINAPI uv_pipe_writefile_thread_proc(void* parameter) {
assert(req != NULL);
assert(req->type == UV_WRITE);
assert(handle->type == UV_NAMED_PIPE);
- assert(req->write_buffer.base);
result = WriteFile(handle->handle,
req->write_buffer.base,
diff --git a/src/win/tty.c b/src/win/tty.c diff --git a/src/win/tty.c b/src/win/tty.c
index c359d5601..1b9d4f853 100644 index c359d5601..1b9d4f853 100644
--- a/src/win/tty.c --- a/src/win/tty.c

2
pkg/urbit/compat/poor-mans-nix-shell.sh
View File

@ -61,7 +61,7 @@ buildnixdep () {
narinfo="$cache/${hash}.narinfo" narinfo="$cache/${hash}.narinfo"
if curl -fLI "$narinfo" if curl -fLI "$narinfo"
then then
url="$cache/$(curl -fL -H "Accept: application/json" "$narinfo"|jq -r '.url')" url="$cache/$(curl -fL "$narinfo"|while IFS=: read k v; do if [ "$k" == "URL" ]; then echo $v; fi; done)"
echo Found $url echo Found $url
strip=0 strip=0
hash= hash=

11
pkg/urbit/compat/posix/ptty.c
View File

@ -147,10 +147,10 @@ u3_ptty_init(uv_loop_t* lup_u, const c3_c** err_c)
return NULL; return NULL;
} }
uv_pipe_init(lup_u, &uty_u->pin_u.pop_u, 0); uv_pipe_init(lup_u, &uty_u->pin_u.pip_u, 0);
uv_pipe_init(lup_u, &uty_u->pop_u.pop_u, 0); uv_pipe_init(lup_u, &uty_u->pop_u.pip_u, 0);
uv_pipe_open(&uty_u->pin_u.pop_u, 0); uv_pipe_open(&uty_u->pin_u.pip_u, 0);
uv_pipe_open(&uty_u->pop_u.pop_u, 1); uv_pipe_open(&uty_u->pop_u.pip_u, 1);
// Load old terminal state to restore. // Load old terminal state to restore.
// //
@ -167,6 +167,9 @@ u3_ptty_init(uv_loop_t* lup_u, const c3_c** err_c)
// Construct raw termios configuration. // Construct raw termios configuration.
// //
// makes input available per-character, does not echo input,
// disables special input pre-processing, output post-processing.
//
{ {
pty_u->raw_u = pty_u->bak_u; pty_u->raw_u = pty_u->bak_u;

2
pkg/urbit/configure vendored
View File

@ -195,7 +195,7 @@ for citem in $compat; do
done done
cat >config.mk <<EOF cat >config.mk <<EOF
CFLAGS := $CFLAGS -funsigned-char -ffast-math -fcommon -std=gnu99 CFLAGS := $CFLAGS -funsigned-char -ffast-math -fcommon -std=gnu99 -Wno-format-zero-length
LDFLAGS := $LDFLAGS LDFLAGS := $LDFLAGS
CC := ${CC-cc} CC := ${CC-cc}
compat := $compat compat := $compat

4
pkg/urbit/daemon/main.c
View File

@ -645,7 +645,7 @@ main(c3_i argc,
sigemptyset(&set); sigemptyset(&set);
sigaddset(&set, SIGPROF); sigaddset(&set, SIGPROF);
if ( 0 != pthread_sigmask(SIG_BLOCK, &set, NULL) ) { if ( 0 != pthread_sigmask(SIG_BLOCK, &set, NULL) ) {
u3l_log("boot: thread mask SIGPROF: %s\r\n", strerror(errno)); u3l_log("boot: thread mask SIGPROF: %s", strerror(errno));
exit(1); exit(1);
} }
} }
@ -782,7 +782,7 @@ main(c3_i argc,
// initialize curl // initialize curl
// //
if ( 0 != curl_global_init(CURL_GLOBAL_DEFAULT) ) { if ( 0 != curl_global_init(CURL_GLOBAL_DEFAULT) ) {
u3l_log("boot: curl initialization failed\r\n"); u3l_log("boot: curl initialization failed");
exit(1); exit(1);
} }

3
pkg/urbit/include/c/motes.h
View File

@ -603,6 +603,7 @@
# define c3__just c3_s4('j','u','s','t') # define c3__just c3_s4('j','u','s','t')
# define c3__keep c3_s4('k','e','e','p') # define c3__keep c3_s4('k','e','e','p')
# define c3__kern c3_s4('k','e','r','n') # define c3__kern c3_s4('k','e','r','n')
# define c3__key c3_s3('k','e','y')
# define c3__kgo c3_s3('k','g','o') # define c3__kgo c3_s3('k','g','o')
# define c3__kick c3_s4('k','i','c','k') # define c3__kick c3_s4('k','i','c','k')
# define c3__king c3_s4('k','i','n','g') # define c3__king c3_s4('k','i','n','g')
@ -770,6 +771,7 @@
# define c3__ne c3_s2('n','e') # define c3__ne c3_s2('n','e')
# define c3__need c3_s4('n','e','e','d') # define c3__need c3_s4('n','e','e','d')
# define c3__neft c3_s4('n','e','f','t') # define c3__neft c3_s4('n','e','f','t')
# define c3__nel c3_s3('n','e','l')
# define c3__nest c3_s4('n','e','s','t') # define c3__nest c3_s4('n','e','s','t')
# define c3__netd c3_s4('n','e','t','d') # define c3__netd c3_s4('n','e','t','d')
# define c3__new c3_s3('n','e','w') # define c3__new c3_s3('n','e','w')
@ -1268,6 +1270,7 @@
# define c3__wtsg c3_s4('w','t','s','g') # define c3__wtsg c3_s4('w','t','s','g')
# define c3__wtts c3_s4('w','t','t','s') # define c3__wtts c3_s4('w','t','t','s')
# define c3__wtzp c3_s4('w','t','z','p') # define c3__wtzp c3_s4('w','t','z','p')
# define c3__wyp c3_s3('w','y','p')
# define c3__wyrd c3_s4('w','y','r','d') # define c3__wyrd c3_s4('w','y','r','d')
# define c3__yew c3_s3('y','a','w') # define c3__yew c3_s3('y','a','w')
# define c3__yell c3_s4('y','e','l','l') # define c3__yell c3_s4('y','e','l','l')

6
pkg/urbit/include/ur/hashcons.h
View File

@ -40,7 +40,6 @@ typedef uint32_t ur_mug;
#define ur_pail_max 10 #define ur_pail_max 10
typedef struct ur_pail32_s { typedef struct ur_pail32_s {
uint8_t fill;
ur_nref refs[ur_pail_max]; ur_nref refs[ur_pail_max];
uint32_t vals[ur_pail_max]; uint32_t vals[ur_pail_max];
} ur_pail32_t; } ur_pail32_t;
@ -48,11 +47,11 @@ typedef struct ur_pail32_s {
typedef struct ur_dict32_s { typedef struct ur_dict32_s {
uint64_t prev; uint64_t prev;
uint64_t size; uint64_t size;
uint8_t *fills;
ur_pail32_t *buckets; ur_pail32_t *buckets;
} ur_dict32_t; } ur_dict32_t;
typedef struct ur_pail64_s { typedef struct ur_pail64_s {
uint8_t fill;
ur_nref refs[ur_pail_max]; ur_nref refs[ur_pail_max];
uint64_t vals[ur_pail_max]; uint64_t vals[ur_pail_max];
} ur_pail64_t; } ur_pail64_t;
@ -60,17 +59,18 @@ typedef struct ur_pail64_s {
typedef struct ur_dict64_s { typedef struct ur_dict64_s {
uint64_t prev; uint64_t prev;
uint64_t size; uint64_t size;
uint8_t *fills;
ur_pail64_t *buckets; ur_pail64_t *buckets;
} ur_dict64_t; } ur_dict64_t;
typedef struct ur_pail_s { typedef struct ur_pail_s {
uint8_t fill;
ur_nref refs[ur_pail_max]; ur_nref refs[ur_pail_max];
} ur_pail_t; } ur_pail_t;
typedef struct ur_dict_s { typedef struct ur_dict_s {
uint64_t prev; uint64_t prev;
uint64_t size; uint64_t size;
uint8_t *fills;
ur_pail_t *buckets; ur_pail_t *buckets;
} ur_dict_t; } ur_dict_t;

54
pkg/urbit/include/vere/vere.h
View File

@ -145,16 +145,17 @@
} siz; } siz;
struct { struct {
c3_y* lin_y; // current line (utf8) u3_noun lin; // bottom line (stub)
c3_w byt_w; // utf8 line-length c3_w rus_w; // cursor position (row)
c3_w wor_w; // utf32 line-length c3_w cus_w; // cursor position (column)
c3_w sap_w; // escape chars in line
c3_w cus_w; // cursor position
} mir; } mir;
struct { // escape code control struct { // escape code control
c3_o ape; // escape received c3_o ape; // escape received
c3_o bra; // bracket or O received c3_o bra; // bracket or O received
c3_o mou; // M (for mouse event) received
c3_y ton_y; // mouse button
c3_y col_y; // column coordinate
} esc; } esc;
struct { struct {
@ -180,30 +181,22 @@
struct _u3_usig* nex_u; struct _u3_usig* nex_u;
} u3_usig; } u3_usig;
/* u2_utfo: unix terminfo strings. /* u2_utfo: terminal escape sequences
*/ */
typedef struct { typedef struct {
// disabled, currently unused uv_buf_t mon_u; // mouse reporting on
uv_buf_t mof_u; // mouse reporting off
// //
// struct { uv_buf_t reg_u; // restore scroll region
// uv_buf_t kcuu1_u; // key_up //
// uv_buf_t kcud1_u; // key_down uv_buf_t suc_u; // save cursor position
// uv_buf_t kcub1_u; // key_back uv_buf_t ruc_u; // restore cursor position
// uv_buf_t kcuf1_u; // key_forward uv_buf_t cub_u; // move cursor left one column
// } inn; //
struct { uv_buf_t clr_u; // clear screen
uv_buf_t clear_u; // clear_screen uv_buf_t cel_u; // clear to end of line
uv_buf_t el_u; // clr_bol clear to beginning //
// uv_buf_t el1_u; // clr_eol clear to end uv_buf_t bel_u; // bel sound bell
uv_buf_t ed_u; // clear to end of screen
uv_buf_t bel_u; // bel sound bell
uv_buf_t cub1_u; // parm_left
uv_buf_t cuf1_u; // parm_right
uv_buf_t cuu1_u; // parm_up
uv_buf_t cud1_u; // parm_down
// uv_buf_t cub_u; // parm_left_cursor #num
// uv_buf_t cuf_u; // parm_right_cursor #num
} out;
} u3_utfo; } u3_utfo;
#if 0 #if 0
@ -229,9 +222,8 @@
/* u3_ustm: uv stream. /* u3_ustm: uv stream.
*/ */
typedef union _u3_ustm { typedef union _u3_ustm {
uv_pipe_t pop_u; uv_pipe_t pip_u;
uv_tcp_t wax_u; uv_tty_t tty_u;
uv_tty_t tty_u;
} u3_ustm; } u3_ustm;
/* u3_ttyf: simple unix tty function. /* u3_ttyf: simple unix tty function.
@ -254,7 +246,7 @@
c3_l* row_l); // return tty window size c3_l* row_l); // return tty window size
c3_i fid_i; // file descriptor c3_i fid_i; // file descriptor
c3_w tid_l; // terminal identity number c3_w tid_l; // terminal identity number
u3_utfo ufo_u; // terminfo strings u3_utfo ufo_u; // escape sequences
u3_utat tat_u; // control state u3_utat tat_u; // control state
struct _u3_auto* car_u; // driver hack struct _u3_auto* car_u; // driver hack
} u3_utty; } u3_utty;
@ -1114,7 +1106,7 @@
/* u3_term_io_loja(): release console from cooked print. /* u3_term_io_loja(): release console from cooked print.
*/ */
void void
u3_term_io_loja(int x); u3_term_io_loja(int x, FILE* f);
/* u3_term_log_init(): initialize terminal for logging /* u3_term_log_init(): initialize terminal for logging
*/ */

2
pkg/urbit/jets/c/rap.c
View File

@ -11,7 +11,7 @@
u3_noun b) u3_noun b)
{ {
if ( !_(u3a_is_cat(a)) || (a >= 32) ) { if ( !_(u3a_is_cat(a)) || (a >= 32) ) {
return u3m_bail(c3__exit); return u3m_bail(c3__fail);
} }
else { else {
c3_g a_g = a; c3_g a_g = a;

4
pkg/urbit/jets/c/rep.c
View File

@ -98,7 +98,7 @@ _block_rep(u3_atom a,
u3_noun b) u3_noun b)
{ {
if ( !_(u3a_is_cat(a)) || (a >= 32) ) { if ( !_(u3a_is_cat(a)) || (a >= 32) ) {
return u3m_bail(c3__exit); return u3m_bail(c3__fail);
} }
else { else {
c3_g a_g = a; c3_g a_g = a;
@ -169,7 +169,7 @@ u3qc_rep(u3_atom a,
return _bit_rep(b, c); return _bit_rep(b, c);
} }
u3l_log("rep: stub\r\n"); u3l_log("rep: stub");
return u3_none; return u3_none;
} }

2
pkg/urbit/jets/c/rip.c
View File

@ -159,7 +159,7 @@ u3qc_rip(u3_atom a,
return _bit_rip(b, c); return _bit_rip(b, c);
} }
u3l_log("rip: stub\r\n"); u3l_log("rip: stub");
return u3_none; return u3_none;
} }

2
pkg/urbit/jets/e/argon2.c
View File

@ -98,7 +98,7 @@
} }
else { else {
ret = u3_none; ret = u3_none;
u3l_log("argon2-error: %s\r\n", err_c); u3l_log("argon2-error: %s", err_c);
} }
u3a_free(out_y); u3a_free(out_y);

6
pkg/urbit/jets/e/jam.c
View File

@ -14,14 +14,14 @@ u3qe_jam(u3_atom a)
siz_w = u3a_count_noun(u3h(som)); siz_w = u3a_count_noun(u3h(som));
tot_w += siz_w; tot_w += siz_w;
if ( 0 == siz_w ) { if ( 0 == siz_w ) {
u3l_log("item: B/0\r\n"); u3l_log("item: B/0");
} }
else { else {
u3a_print_memory(stderr, "item", siz_w); u3a_print_memory(stderr, "item", siz_w);
} }
} }
if ( u3_blip != som ) { if ( u3_blip != som ) {
u3l_log("forgot to terminate list!\r\n"); u3l_log("forgot to terminate list!");
} }
c3_w mem_w = u3h_count(u3R->cax.har_p); c3_w mem_w = u3h_count(u3R->cax.har_p);
@ -31,7 +31,7 @@ u3qe_jam(u3_atom a)
u3a_print_memory(stderr, "total", tot_w); u3a_print_memory(stderr, "total", tot_w);
u3a_print_memory(stderr, "memoization cache", mem_w); u3a_print_memory(stderr, "memoization cache", mem_w);
u3h_root* har_u = u3to(u3h_root, u3R->cax.har_p); u3h_root* har_u = u3to(u3h_root, u3R->cax.har_p);
u3l_log("memoization entries: %d\r\n", har_u->use_w); u3l_log("memoization entries: %d", har_u->use_w);
u3a_print_memory(stderr, "unused free", u3a_open(u3R)); u3a_print_memory(stderr, "unused free", u3a_open(u3R));
return tot_w; return tot_w;
} }

2
pkg/urbit/jets/e/rub.c
View File

@ -31,7 +31,7 @@
// Sanity check: crash if decoding more bits than available // Sanity check: crash if decoding more bits than available
if ( c3y == u3qa_gth(x, m)) { if ( c3y == u3qa_gth(x, m)) {
// u3l_log("[%%rub-hard %d %d %d]\r\n", a, x, m); // u3l_log("[%%rub-hard %d %d %d]", a, x, m);
return u3m_bail(c3__exit); return u3m_bail(c3__exit);
} }

2
pkg/urbit/jets/e/secp.c
View File

@ -16,7 +16,7 @@ u3je_secp_init()
sec_u = malloc(urcrypt_secp_prealloc_size()); sec_u = malloc(urcrypt_secp_prealloc_size());
if ( 0 != urcrypt_secp_init(sec_u, ent_y) ) { if ( 0 != urcrypt_secp_init(sec_u, ent_y) ) {
u3l_log("u3e_secp_init failed\r\n"); u3l_log("u3e_secp_init failed");
abort(); abort();
} }
} }

2
pkg/urbit/jets/f/core.c
View File

@ -22,7 +22,7 @@
(u3_nul == u3h(hr_con)) && (u3_nul == u3h(hr_con)) &&
(u3_nul == u3t(hr_con)) ) (u3_nul == u3t(hr_con)) )
{ {
u3l_log("old core\r\n"); u3l_log("old core");
abort(); abort();
} }
} }

2
pkg/urbit/jets/f/look.c
View File

@ -20,7 +20,7 @@
u3r_trel(dab, &n_dab, &l_dab, &r_dab); u3r_trel(dab, &n_dab, &l_dab, &r_dab);
if ( c3n == u3du(n_dab) ) { if ( c3n == u3du(n_dab) ) {
// return u3m_bail(c3__fail); // return u3m_bail(c3__fail);
u3l_log("bad look\r\n"); u3l_log("bad look");
return u3m_bail(c3__exit) ; return u3m_bail(c3__exit) ;
} }
else { else {

16
pkg/urbit/noun/allocate.c
View File

@ -433,7 +433,7 @@ _ca_willoc(c3_w len_w, c3_w ald_w, c3_w alp_w)
sel_w += 1; sel_w += 1;
} }
// u3l_log("walloc %d: *pfr_p %x\n", len_w, u3R->all.fre_p[sel_w]); // u3l_log("walloc %d: *pfr_p %x", len_w, u3R->all.fre_p[sel_w]);
while ( 1 ) { while ( 1 ) {
u3p(u3a_fbox) *pfr_p = &u3R->all.fre_p[sel_w]; u3p(u3a_fbox) *pfr_p = &u3R->all.fre_p[sel_w];
@ -568,7 +568,7 @@ u3a_walloc(c3_w len_w)
u3a_botox(ptr_v) == (u3a_box*)(void *)0x200dfe3e4 ) { u3a_botox(ptr_v) == (u3a_box*)(void *)0x200dfe3e4 ) {
static int xuc_i; static int xuc_i;
u3l_log("xuc_i %d\r\n", xuc_i); u3l_log("xuc_i %d", xuc_i);
if ( 1 == xuc_i ) { if ( 1 == xuc_i ) {
u3a_box* box_u = u3a_botox(ptr_v); u3a_box* box_u = u3a_botox(ptr_v);
@ -684,7 +684,7 @@ u3a_malloc(size_t len_i)
if ( u3a_botox(out_w) == (u3a_box*)(void *)0x3bdd1c80) { if ( u3a_botox(out_w) == (u3a_box*)(void *)0x3bdd1c80) {
static int xuc_i = 0; static int xuc_i = 0;
u3l_log("xuc_i %d\r\n", xuc_i); u3l_log("xuc_i %d", xuc_i);
// if ( 1 == xuc_i ) { abort(); } // if ( 1 == xuc_i ) { abort(); }
xuc_i++; xuc_i++;
} }
@ -917,7 +917,7 @@ u3a_free(void* tox_v)
c3_w pad_w = tox_w[-1]; c3_w pad_w = tox_w[-1];
c3_w* org_w = tox_w - (pad_w + 1); c3_w* org_w = tox_w - (pad_w + 1);
// u3l_log("free %p %p\r\n", org_w, tox_w); // u3l_log("free %p %p", org_w, tox_w);
u3a_wfree(org_w); u3a_wfree(org_w);
} }
@ -1065,7 +1065,7 @@ _ca_take_atom(u3a_atom* old_u)
u3_noun new = u3a_to_pug(u3a_outa(new_u)); u3_noun new = u3a_to_pug(u3a_outa(new_u));
#ifdef VERBOSE_TAKE #ifdef VERBOSE_TAKE
u3l_log("%s: atom %p to %p\r\n", ( c3y == u3a_is_north(u3R) ) u3l_log("%s: atom %p to %p", ( c3y == u3a_is_north(u3R) )
? "north" ? "north"
: "south", : "south",
old_u, old_u,
@ -1103,7 +1103,7 @@ _ca_take_cell(u3a_cell* old_u, u3_noun hed, u3_noun tel)
u3_cell new = u3a_to_pom(u3a_outa(new_u)); u3_cell new = u3a_to_pom(u3a_outa(new_u));
#ifdef VERBOSE_TAKE #ifdef VERBOSE_TAKE
u3l_log("%s: cell %p to %p\r\n", ( c3y == u3a_is_north(u3R) ) u3l_log("%s: cell %p to %p", ( c3y == u3a_is_north(u3R) )
? "north" ? "north"
: "south", : "south",
old_u, old_u,
@ -1162,7 +1162,7 @@ _ca_take_next_north(u3a_pile* pil_u, u3_noun veb)
c3_assert( c3y == u3a_north_is_normal(u3R, nov) ); c3_assert( c3y == u3a_north_is_normal(u3R, nov) );
#ifdef VERBOSE_TAKE #ifdef VERBOSE_TAKE
u3l_log("north: %p is already %p\r\n", veb_u, u3a_to_ptr(nov)); u3l_log("north: %p is already %p", veb_u, u3a_to_ptr(nov));
#endif #endif
_me_gain_use(nov); // bypass branches in u3k() _me_gain_use(nov); // bypass branches in u3k()
@ -1218,7 +1218,7 @@ _ca_take_next_south(u3a_pile* pil_u, u3_noun veb)
c3_assert( c3y == u3a_south_is_normal(u3R, nov) ); c3_assert( c3y == u3a_south_is_normal(u3R, nov) );
#ifdef VERBOSE_TAKE #ifdef VERBOSE_TAKE
u3l_log("south: %p is already %p\r\n", veb_u, u3a_to_ptr(nov)); u3l_log("south: %p is already %p", veb_u, u3a_to_ptr(nov));
#endif #endif
_me_gain_use(nov); // bypass branches in u3k() _me_gain_use(nov); // bypass branches in u3k()

20
pkg/urbit/noun/events.c
View File

@ -63,7 +63,7 @@ u3e_check(c3_c* cap_c)
} }
sum_w += mug_w; sum_w += mug_w;
} }
u3l_log("%s: sum %x (%x, %x)\r\n", cap_c, sum_w, nor_w, sou_w); u3l_log("%s: sum %x (%x, %x)", cap_c, sum_w, nor_w, sou_w);
} }
} }
@ -136,7 +136,7 @@ u3e_fault(void* adr_v, c3_i ser_i)
#if 0 #if 0
if ( pag_w == 131041 ) { if ( pag_w == 131041 ) {
u3l_log("dirty page %d (at %p); unprotecting %p to %p\r\n", u3l_log("dirty page %d (at %p); unprotecting %p to %p",
pag_w, pag_w,
adr_v, adr_v,
(u3_Loom + (pag_w << u3a_page)), (u3_Loom + (pag_w << u3a_page)),
@ -341,7 +341,7 @@ _ce_patch_verify(u3_ce_patch* pat_u)
} }
#if 0 #if 0
else { else {
u3l_log("verify: patch %d/%d, %x\r\n", pag_w, i_w, mug_w); u3l_log("verify: patch %d/%d, %x", pag_w, i_w, mug_w);
} }
#endif #endif
} }
@ -458,7 +458,7 @@ _ce_patch_save_page(u3_ce_patch* pat_u,
(1 << u3a_page)); (1 << u3a_page));
#if 0 #if 0
u3l_log("protect a: page %d\r\n", pag_w); u3l_log("protect a: page %d", pag_w);
#endif #endif
_ce_patch_write_page(pat_u, pgc_w, mem_w); _ce_patch_write_page(pat_u, pgc_w, mem_w);
@ -484,7 +484,7 @@ _ce_patch_junk_page(u3_ce_patch* pat_u,
c3_w blk_w = (pag_w >> 5); c3_w blk_w = (pag_w >> 5);
c3_w bit_w = (pag_w & 31); c3_w bit_w = (pag_w & 31);
// u3l_log("protect b: page %d\r\n", pag_w); // u3l_log("protect b: page %d", pag_w);
if ( -1 == mprotect(u3_Loom + (pag_w << u3a_page), if ( -1 == mprotect(u3_Loom + (pag_w << u3a_page),
(1 << (u3a_page + 2)), (1 << (u3a_page + 2)),
PROT_READ) ) PROT_READ) )
@ -688,7 +688,7 @@ _ce_patch_apply(u3_ce_patch* pat_u)
} }
} }
#if 0 #if 0
u3l_log("apply: %d, %x\n", pag_w, u3r_mug_words(mem_w, (1 << u3a_page))); u3l_log("apply: %d, %x", pag_w, u3r_mug_words(mem_w, (1 << u3a_page)));
#endif #endif
} }
} }
@ -713,7 +713,7 @@ _ce_image_blit(u3e_image* img_u,
c3_w off_w = (ptr_w - u3_Loom); c3_w off_w = (ptr_w - u3_Loom);
c3_w pag_w = (off_w >> u3a_page); c3_w pag_w = (off_w >> u3a_page);
u3l_log("blit: page %d, mug %x\r\n", pag_w, u3l_log("blit: page %d, mug %x", pag_w,
u3r_mug_words(ptr_w, (1 << u3a_page))); u3r_mug_words(ptr_w, (1 << u3a_page)));
} }
#endif #endif
@ -868,17 +868,17 @@ u3e_live(c3_o nuu_o, c3_c* dir_c)
-(1 << u3a_page)); -(1 << u3a_page));
if ( 0 != mprotect((void *)u3_Loom, u3a_bytes, PROT_READ) ) { if ( 0 != mprotect((void *)u3_Loom, u3a_bytes, PROT_READ) ) {
u3l_log("loom: live mprotect: %s\r\n", strerror(errno)); u3l_log("loom: live mprotect: %s", strerror(errno));
c3_assert(0); c3_assert(0);
} }
u3l_log("boot: protected loom\r\n"); u3l_log("boot: protected loom");
} }
/* If the images were empty, we are logically booting. /* If the images were empty, we are logically booting.
*/ */
if ( (0 == u3P.nor_u.pgs_w) && (0 == u3P.sou_u.pgs_w) ) { if ( (0 == u3P.nor_u.pgs_w) && (0 == u3P.sou_u.pgs_w) ) {
u3l_log("live: logical boot\r\n"); u3l_log("live: logical boot");
nuu_o = c3y; nuu_o = c3y;
} }
else { else {

42
pkg/urbit/noun/jets.c
View File

@ -75,7 +75,7 @@ _cj_hash(c3_c* has_c)
{ {
c3_w i_w, len_w = strlen(has_c); c3_w i_w, len_w = strlen(has_c);
if ( 64 != len_w ) { if ( 64 != len_w ) {
u3l_log("bash not 64 characters: %s\r\n", has_c); u3l_log("bash not 64 characters: %s", has_c);
c3_assert(0); c3_assert(0);
} }
c3_assert( 64 == len_w ); c3_assert( 64 == len_w );
@ -236,18 +236,18 @@ _cj_axis(u3_noun fol)
(0 != p_fol) || (0 != p_fol) ||
(!_(u3a_is_cat(q_fol))) ) (!_(u3a_is_cat(q_fol))) )
{ {
u3l_log("axis: bad a\r\n"); u3l_log("axis: bad a");
return 0; return 0;
} }
return q_fol; return q_fol;
} }
else { else {
if ( 9 != p_fol ) if ( 9 != p_fol )
{ u3l_log("axis: bad b\r\n"); return 0; } { u3l_log("axis: bad b"); return 0; }
if ( !_(u3a_is_cat(q_fol)) ) if ( !_(u3a_is_cat(q_fol)) )
{ u3l_log("axis: bad c\r\n"); return 0; } { u3l_log("axis: bad c"); return 0; }
if ( !_(u3du(r_fol)) || (0 != u3h(r_fol)) || (1 != u3t(r_fol)) ) if ( !_(u3du(r_fol)) || (0 != u3h(r_fol)) || (1 != u3t(r_fol)) )
{ u3l_log("axis: bad d\r\n"); return 0; } { u3l_log("axis: bad d"); return 0; }
return q_fol; return q_fol;
} }
@ -278,7 +278,7 @@ _cj_warm_hump(c3_l jax_l, u3_noun huc)
((1 << 31) & (axe_l = (c3_w)axe_d)) || ((1 << 31) & (axe_l = (c3_w)axe_d)) ||
(axe_l < 2) ) (axe_l < 2) )
{ {
u3l_log("jets: activate: bad fcs %s\r\n", jet_u->fcs_c); u3l_log("jets: activate: bad fcs %s", jet_u->fcs_c);
} }
} }
else { else {
@ -286,7 +286,7 @@ _cj_warm_hump(c3_l jax_l, u3_noun huc)
u3_noun fol = u3kdb_get(u3k(huc), nam); u3_noun fol = u3kdb_get(u3k(huc), nam);
if ( u3_none == fol ) { if ( u3_none == fol ) {
u3l_log("jets: activate: bad fcs %s\r\n", jet_u->fcs_c); u3l_log("jets: activate: bad fcs %s", jet_u->fcs_c);
} }
else { else {
axe_l = _cj_axis(fol); axe_l = _cj_axis(fol);
@ -781,7 +781,7 @@ _cj_hot_mean(c3_l par_l, u3_noun nam)
while ( (cop_u = &dev_u[i_l])->cos_c ) { while ( (cop_u = &dev_u[i_l])->cos_c ) {
if ( _(u3r_sing_c(cop_u->cos_c, nam)) ) { if ( _(u3r_sing_c(cop_u->cos_c, nam)) ) {
#if 0 #if 0
u3l_log("hot: bound jet %d/%s/%s/\r\n", u3l_log("hot: bound jet %d/%s/%s/",
cop_u->jax_l, cop_u->jax_l,
cop_u->cos_c, cop_u->cos_c,
par_u ? par_u->cos_c : "~"); par_u ? par_u->cos_c : "~");
@ -893,7 +893,7 @@ _cj_kick_z(u3_noun cor, u3j_core* cop_u, u3j_harm* ham_u, u3_atom axe)
ham_u->liv = c3y; ham_u->liv = c3y;
if ( c3n == u3r_sing(ame, pro) ) { if ( c3n == u3r_sing(ame, pro) ) {
u3l_log("test: %s %s: mismatch: good %x, bad %x\r\n", u3l_log("test: %s %s: mismatch: good %x, bad %x",
cop_u->cos_c, cop_u->cos_c,
(!strcmp(".2", ham_u->fcs_c)) ? "$" : ham_u->fcs_c, (!strcmp(".2", ham_u->fcs_c)) ? "$" : ham_u->fcs_c,
u3r_mug(ame), u3r_mug(ame),
@ -905,7 +905,7 @@ _cj_kick_z(u3_noun cor, u3j_core* cop_u, u3j_harm* ham_u, u3_atom axe)
else { else {
#if 0 #if 0
u3l_log("test: %s %s\r\n", u3l_log("test: %s %s",
cop_u->cos_c, cop_u->cos_c,
(!strcmp(".2", ham_u->fcs_c)) ? "$" : ham_u->fcs_c); (!strcmp(".2", ham_u->fcs_c)) ? "$" : ham_u->fcs_c);
#endif #endif
@ -928,13 +928,13 @@ _cj_hook_in(u3_noun cor,
u3_noun roc, tem, got, pat, nam, huc; u3_noun roc, tem, got, pat, nam, huc;
if ( c3n == u3du(cor) ) { if ( c3n == u3du(cor) ) {
u3l_log("_cj_hook_in failure: c3n == u3du(cor)\r\n"); u3l_log("_cj_hook_in failure: c3n == u3du(cor)");
return u3m_bail(c3__fail); return u3m_bail(c3__fail);
} }
loc = _cj_spot(cor, NULL); loc = _cj_spot(cor, NULL);
if ( u3_none == loc ) { if ( u3_none == loc ) {
u3l_log("_cj_hook_in failure: u3_none == loc\r\n"); u3l_log("_cj_hook_in failure: u3_none == loc");
return u3m_bail(c3__fail); return u3m_bail(c3__fail);
} }
@ -999,7 +999,7 @@ _cj_hook_in(u3_noun cor,
else { else {
u3_noun sat = u3t(pat); u3_noun sat = u3t(pat);
if ( c3y == u3h(sat) ) { if ( c3y == u3h(sat) ) {
u3l_log("_cj_hook_in failure: c3y == u3h(sat)\r\n"); u3l_log("_cj_hook_in failure: c3y == u3h(sat)");
return u3m_bail(c3__fail); return u3m_bail(c3__fail);
} }
else { else {
@ -1687,7 +1687,7 @@ u3j_gate_prep(u3j_site* sit_u, u3_noun cor)
pay = u3qc_cap(pax), pay = u3qc_cap(pax),
pam = u3qc_mas(pax); pam = u3qc_mas(pax);
if ( 3 != pay || 2 == pam || (3 != pam && 3 != u3qc_cap(pam)) ) { if ( 3 != pay || 2 == pam || (3 != pam && 3 != u3qc_cap(pam)) ) {
u3l_log("u3j_gate_prep(): parent axis includes sample\r\n"); u3l_log("u3j_gate_prep(): parent axis includes sample");
u3m_p("axis", pax); u3m_p("axis", pax);
u3_weak act = _cj_find_warm(loc); u3_weak act = _cj_find_warm(loc);
c3_assert( u3_none != act ); c3_assert( u3_none != act );
@ -1758,12 +1758,12 @@ _cj_minx(u3_noun cey, u3_noun cor)
par = u3r_at(axe, cor); par = u3r_at(axe, cor);
if ( u3_none == par || c3n == u3du(par) ) { if ( u3_none == par || c3n == u3du(par) ) {
u3l_log("fund: %s is bogus\r\n", u3r_string(nam)); u3l_log("fund: %s is bogus", u3r_string(nam));
return u3_none; return u3_none;
} }
pel = _cj_spot(par, NULL); pel = _cj_spot(par, NULL);
if ( u3_none == pel ) { if ( u3_none == pel ) {
u3l_log("fund: in %s, parent %x not found at %d\r\n", u3l_log("fund: in %s, parent %x not found at %d",
u3r_string(nam), u3r_string(nam),
u3r_mug(u3h(par)), u3r_mug(u3h(par)),
axe); axe);
@ -1822,7 +1822,7 @@ _cj_mine(u3_noun cey, u3_noun cor, u3_noun bas)
jax_l = _cj_hot_mean(par_l, nam); jax_l = _cj_hot_mean(par_l, nam);
#if 0 #if 0
u3m_p("new jet", bal); u3m_p("new jet", bal);
u3l_log(" bat %x, jax %d\r\n", u3r_mug(bat), jax_l); u3l_log(" bat %x, jax %d", u3r_mug(bat), jax_l);
#endif #endif
if ( !(u3C.wag_w & u3o_hashless) ) { if ( !(u3C.wag_w & u3o_hashless) ) {
@ -1840,7 +1840,7 @@ _cj_mine(u3_noun cey, u3_noun cor, u3_noun bas)
for ( i_w = 32; i_w > 0; ) { for ( i_w = 32; i_w > 0; ) {
u3l_log("%02x", dig_y[--i_w]); u3l_log("%02x", dig_y[--i_w]);
} }
u3l_log("\r\n"); u3l_log("");
} }
} }
@ -1870,7 +1870,7 @@ _cj_mine(u3_noun cey, u3_noun cor, u3_noun bas)
if ( c3n == hav_o ) { if ( c3n == hav_o ) {
u3m_p("unregistered battery", bal); u3m_p("unregistered battery", bal);
u3l_log("hash: %x\r\n", bas); u3l_log("hash: %x", bas);
} }
u3z(bas); u3z(bas);
} }
@ -2093,7 +2093,7 @@ _cj_ream(u3_noun all)
act = u3nq(jax_l, hap, bal, _cj_jit(jax_l, bat)); act = u3nq(jax_l, hap, bal, _cj_jit(jax_l, bat));
#if 0 #if 0
u3m_p("old jet", bal); u3m_p("old jet", bal);
u3l_log(" bat %x, jax %d\r\n", u3r_mug(bat), jax_l); u3l_log(" bat %x, jax %d", u3r_mug(bat), jax_l);
#endif #endif
u3h_put(u3R->jed.war_p, loc, act); u3h_put(u3R->jed.war_p, loc, act);
} }
@ -2132,7 +2132,7 @@ _cj_ream(u3_noun all)
act = u3nq(jax_l, hap, bal, _cj_jit(jax_l, bat)); act = u3nq(jax_l, hap, bal, _cj_jit(jax_l, bat));
#if 0 #if 0
u3m_p("old jet", bal); u3m_p("old jet", bal);
u3l_log(" bat %x, jax %d\r\n", u3r_mug(bat), jax_l); u3l_log(" bat %x, jax %d", u3r_mug(bat), jax_l);
#endif #endif
u3h_put(u3R->jed.war_p, loc, act); u3h_put(u3R->jed.war_p, loc, act);
} }

2
pkg/urbit/noun/log.c
View File

@ -22,6 +22,8 @@ u3l_log(const char* format, ...)
// this process did not set a logging function, fallback to stderr // this process did not set a logging function, fallback to stderr
// //
vfprintf(stderr, format, myargs); vfprintf(stderr, format, myargs);
fprintf(stderr, "\r\n");
fflush(stderr);
} }
va_end(myargs); va_end(myargs);

36
pkg/urbit/noun/manage.c
View File

@ -318,7 +318,7 @@ _cm_signal_recover(c3_l sig_l, u3_noun arg)
while ( rod_u->kid_p ) { while ( rod_u->kid_p ) {
#if 0 #if 0
u3l_log("collecting %d frames\r\n", u3l_log("collecting %d frames",
u3kb_lent((u3to(u3_road, rod_u->kid_p)->bug.tax)); u3kb_lent((u3to(u3_road, rod_u->kid_p)->bug.tax));
#endif #endif
tax = u3kb_weld(_cm_stack_recover(u3to(u3_road, rod_u->kid_p)), tax); tax = u3kb_weld(_cm_stack_recover(u3to(u3_road, rod_u->kid_p)), tax);
@ -372,7 +372,7 @@ _cm_signal_deep(c3_w mil_w)
itm_u.it_value.tv_usec = 1000 * (mil_w % 1000); itm_u.it_value.tv_usec = 1000 * (mil_w % 1000);
if ( rsignal_setitimer(ITIMER_VIRTUAL, &itm_u, 0) ) { if ( rsignal_setitimer(ITIMER_VIRTUAL, &itm_u, 0) ) {
u3l_log("loom: set timer failed %s\r\n", strerror(errno)); u3l_log("loom: set timer failed %s", strerror(errno));
} }
else { else {
rsignal_install_handler(SIGVTALRM, _cm_signal_handle_alrm); rsignal_install_handler(SIGVTALRM, _cm_signal_handle_alrm);
@ -405,7 +405,7 @@ _cm_signal_done()
timerclear(&itm_u.it_value); timerclear(&itm_u.it_value);
if ( rsignal_setitimer(ITIMER_VIRTUAL, &itm_u, 0) ) { if ( rsignal_setitimer(ITIMER_VIRTUAL, &itm_u, 0) ) {
u3l_log("loom: clear timer failed %s\r\n", strerror(errno)); u3l_log("loom: clear timer failed %s", strerror(errno));
} }
} }
@ -437,7 +437,7 @@ u3m_file(c3_c* pas_c)
c3_y* pad_y; c3_y* pad_y;
if ( (fid_i < 0) || (fstat(fid_i, &buf_b) < 0) ) { if ( (fid_i < 0) || (fstat(fid_i, &buf_b) < 0) ) {
u3l_log("%s: %s\r\n", pas_c, strerror(errno)); u3l_log("%s: %s", pas_c, strerror(errno));
return u3m_bail(c3__fail); return u3m_bail(c3__fail);
} }
fln_w = buf_b.st_size; fln_w = buf_b.st_size;
@ -632,7 +632,7 @@ u3m_dump(void)
fre_u = fre_u->nex_u; fre_u = fre_u->nex_u;
} }
} }
u3l_log("dump: hat_w %x, fre_w %x, allocated %x\n", u3l_log("dump: hat_w %x, fre_w %x, allocated %x",
hat_w, fre_w, (hat_w - fre_w)); hat_w, fre_w, (hat_w - fre_w));
if ( 0 != (hat_w - fre_w) ) { if ( 0 != (hat_w - fre_w) ) {
@ -644,14 +644,14 @@ u3m_dump(void)
if ( 0 != box_u->use_w ) { if ( 0 != box_u->use_w ) {
#ifdef U3_MEMORY_DEBUG #ifdef U3_MEMORY_DEBUG
// u3l_log("live %d words, code %x\n", box_u->siz_w, box_u->cod_w); // u3l_log("live %d words, code %x", box_u->siz_w, box_u->cod_w);
#endif #endif
mem_w += box_u->siz_w; mem_w += box_u->siz_w;
} }
box_w += box_u->siz_w; box_w += box_u->siz_w;
} }
u3l_log("second count: %x\n", mem_w); u3l_log("second count: %x", mem_w);
} }
} }
#endif #endif
@ -1548,7 +1548,7 @@ u3m_p(const c3_c* cap_c, u3_noun som)
{ {
c3_c* pre_c = u3m_pretty(som); c3_c* pre_c = u3m_pretty(som);
u3l_log("%s: %s\r\n", cap_c, pre_c); u3l_log("%s: %s", cap_c, pre_c);
c3_free(pre_c); c3_free(pre_c);
} }
@ -1609,7 +1609,7 @@ _cm_limits(void)
rlm.rlim_cur = c3_min(rlm.rlim_max, (65536 << 10)); rlm.rlim_cur = c3_min(rlm.rlim_max, (65536 << 10));
if ( 0 != setrlimit(RLIMIT_STACK, &rlm) ) { if ( 0 != setrlimit(RLIMIT_STACK, &rlm) ) {
u3l_log("boot: stack size: %s\r\n", strerror(errno)); u3l_log("boot: stack size: %s", strerror(errno));
exit(1); exit(1);
} }
} }
@ -1628,7 +1628,7 @@ _cm_limits(void)
// no exit, not a critical limit // no exit, not a critical limit
// //
if ( 0 != setrlimit(RLIMIT_NOFILE, &rlm) ) { if ( 0 != setrlimit(RLIMIT_NOFILE, &rlm) ) {
u3l_log("boot: open file limit: %s\r\n", strerror(errno)); u3l_log("boot: open file limit: %s", strerror(errno));
} }
} }
@ -1642,7 +1642,7 @@ _cm_limits(void)
// no exit, not a critical limit // no exit, not a critical limit
// //
if ( 0 != setrlimit(RLIMIT_CORE, &rlm) ) { if ( 0 != setrlimit(RLIMIT_CORE, &rlm) ) {
u3l_log("boot: core limit: %s\r\n", strerror(errno)); u3l_log("boot: core limit: %s", strerror(errno));
} }
} }
# endif # endif
@ -1665,7 +1665,7 @@ _cm_signals(void)
// access and stack overflow exceptions. It calls u3e_fault directly. // access and stack overflow exceptions. It calls u3e_fault directly.
# else # else
if ( 0 != sigsegv_install_handler(u3e_fault) ) { if ( 0 != sigsegv_install_handler(u3e_fault) ) {
u3l_log("boot: sigsegv install failed\n"); u3l_log("boot: sigsegv install failed");
exit(1); exit(1);
} }
# endif # endif
@ -1681,7 +1681,7 @@ _cm_signals(void)
sigaddset(&set, SIGPROF); sigaddset(&set, SIGPROF);
if ( 0 != pthread_sigmask(SIG_BLOCK, &set, NULL) ) { if ( 0 != pthread_sigmask(SIG_BLOCK, &set, NULL) ) {
u3l_log("boot: thread mask SIGPROF: %s\r\n", strerror(errno)); u3l_log("boot: thread mask SIGPROF: %s", strerror(errno));
exit(1); exit(1);
} }
} }
@ -1737,17 +1737,17 @@ u3m_init(void)
MAP_ANON | MAP_PRIVATE, MAP_ANON | MAP_PRIVATE,
-1, 0); -1, 0);
u3l_log("boot: mapping %dMB failed\r\n", (len_w / (1024 * 1024))); u3l_log("boot: mapping %dMB failed", (len_w / (1024 * 1024)));
u3l_log("see urbit.org/using/install/#about-swap-space" u3l_log("see urbit.org/using/install/#about-swap-space"
" for adding swap space\r\n"); " for adding swap space\r\n");
if ( -1 != (c3_ps)dyn_v ) { if ( -1 != (c3_ps)map_v ) {
u3l_log("if porting to a new platform, try U3_OS_LoomBase %p\r\n", u3l_log("if porting to a new platform, try U3_OS_LoomBase %p",
dyn_v); dyn_v);
} }
exit(1); exit(1);
} }
u3l_log("loom: mapped %dMB\r\n", len_w >> 20); u3l_log("loom: mapped %dMB", len_w >> 20);
} }
} }
@ -1788,7 +1788,7 @@ u3m_boot(c3_c* dir_c)
*/ */
{ {
c3_w len_w = u3j_boot(nuu_o); c3_w len_w = u3j_boot(nuu_o);
u3l_log("boot: installed %d jets\r\n", len_w); u3l_log("boot: installed %d jets", len_w);
} }
/* Reactivate jets on old kernel. /* Reactivate jets on old kernel.

2
pkg/urbit/noun/nock.c
View File

@ -44,7 +44,7 @@ _n_hint(u3_noun zep,
low_i = 1; low_i = 1;
if ( 0 == (u3R->pro.nox_d % 65536ULL) ) { if ( 0 == (u3R->pro.nox_d % 65536ULL) ) {
if ( c3__spot == zep ) { if ( c3__spot == zep ) {
u3l_log("spot %d/%d : %d/%d\r\n", u3l_log("spot %d/%d : %d/%d",
u3h(u3h(u3t(hod))), u3h(u3h(u3t(hod))),
u3t(u3h(u3t(hod))), u3t(u3h(u3t(hod))),
u3h(u3t(u3t(hod))), u3h(u3t(u3t(hod))),

6
pkg/urbit/noun/trace.c
View File

@ -167,7 +167,7 @@ _t_samp_process(u3_road* rod_u)
pef = t_pef; pef = t_pef;
} }
// u3l_log("sample: stack length %d\r\n", u3kb_lent(u3k(pal))); // u3l_log("sample: stack length %d", u3kb_lent(u3k(pal)));
return pal; return pal;
} }
} }
@ -540,7 +540,7 @@ u3t_boot(void)
sigemptyset(&set); sigemptyset(&set);
sigaddset(&set, SIGPROF); sigaddset(&set, SIGPROF);
if ( 0 != pthread_sigmask(SIG_UNBLOCK, &set, NULL) ) { if ( 0 != pthread_sigmask(SIG_UNBLOCK, &set, NULL) ) {
u3l_log("trace: thread mask SIGPROF: %s\r\n", strerror(errno)); u3l_log("trace: thread mask SIGPROF: %s", strerror(errno));
} }
} }
@ -569,7 +569,7 @@ u3t_boff(void)
sigemptyset(&set); sigemptyset(&set);
sigaddset(&set, SIGPROF); sigaddset(&set, SIGPROF);
if ( 0 != pthread_sigmask(SIG_BLOCK, &set, NULL) ) { if ( 0 != pthread_sigmask(SIG_BLOCK, &set, NULL) ) {
u3l_log("trace: thread mask SIGPROF: %s\r\n", strerror(errno)); u3l_log("trace: thread mask SIGPROF: %s", strerror(errno));
} }
} }

8
pkg/urbit/noun/vortex.c
View File

@ -60,9 +60,9 @@ _cv_lite(u3_noun pil)
eve = tal; eve = tal;
} }
u3l_log("lite: arvo formula %x\r\n", u3r_mug(pil)); u3l_log("lite: arvo formula %x", u3r_mug(pil));
pro = u3v_life(u3k(eve)); pro = u3v_life(u3k(eve));
u3l_log("lite: core %x\r\n", u3r_mug(pro)); u3l_log("lite: core %x", u3r_mug(pro));
u3z(pil); u3z(pil);
return pro; return pro;
@ -89,7 +89,7 @@ u3v_boot_lite(u3_noun pil)
u3z(pro); u3z(pro);
} }
u3l_log("lite: final state %x\r\n", u3r_mug(u3A->roc)); u3l_log("lite: final state %x", u3r_mug(u3A->roc));
return c3y; return c3y;
} }
@ -209,7 +209,7 @@ _cv_mole(u3_noun fot,
(0 != q_uco) || (0 != q_uco) ||
(c3n == u3r_sing(fot, r_uco)) ) (c3n == u3r_sing(fot, r_uco)) )
{ {
u3l_log("strange mole %s\n", u3r_string(san))); u3l_log("strange mole %s", u3r_string(san)));
u3z(fot); u3z(uco); return c3n; u3z(fot); u3z(uco); return c3n;
} }

84
pkg/urbit/ur/hashcons.c
View File

@ -33,15 +33,17 @@ void
ur_dict32_grow(ur_root_t *r, ur_dict32_t *dict, uint64_t prev, uint64_t size) ur_dict32_grow(ur_root_t *r, ur_dict32_t *dict, uint64_t prev, uint64_t size)
{ {
ur_pail32_t *buckets, *old_buckets = dict->buckets; ur_pail32_t *buckets, *old_buckets = dict->buckets;
uint8_t *fills, *old_fills = dict->fills;
uint64_t old_size = dict->size; uint64_t old_size = dict->size;
uint64_t i, next = prev + size; uint64_t i, next = prev + size;
buckets = _oom("dict32_grow", calloc(next, sizeof(*buckets))); buckets = _oom("dict32_grow", calloc(next, sizeof(*buckets)));
fills = _oom("dict32_grow", calloc(next, sizeof(*fills)));
if ( old_buckets ) { if ( old_buckets ) {
for ( i = 0; i < old_size; i++ ) { for ( i = 0; i < old_size; i++ ) {
ur_pail32_t *old_bucket = &(old_buckets[i]); ur_pail32_t *old_bucket = &(old_buckets[i]);
uint8_t j, old_fill = old_bucket->fill; uint8_t j, old_fill = old_fills[i];
for ( j = 0; j < old_fill; j++ ) { for ( j = 0; j < old_fill; j++ ) {
uint32_t val = old_bucket->vals[j]; uint32_t val = old_bucket->vals[j];
@ -50,24 +52,27 @@ ur_dict32_grow(ur_root_t *r, ur_dict32_t *dict, uint64_t prev, uint64_t size)
uint64_t idx = ( mug % next ); uint64_t idx = ( mug % next );
ur_pail32_t *bucket = &(buckets[idx]); ur_pail32_t *bucket = &(buckets[idx]);
uint8_t new_fill = bucket->fill; uint8_t new_fill = fills[idx];
if ( ur_pail_max == new_fill ) { if ( ur_pail_max == new_fill ) {
free(buckets); free(buckets);
free(fills);
return ur_dict32_grow(r, dict, size, next); return ur_dict32_grow(r, dict, size, next);
} }
bucket->refs[new_fill] = ref; bucket->refs[new_fill] = ref;
bucket->vals[new_fill] = val; bucket->vals[new_fill] = val;
bucket->fill = 1 + new_fill; fills[idx] = 1 + new_fill;
} }
} }
free(old_buckets); free(old_buckets);
free(old_fills);
} }
dict->prev = size; dict->prev = size;
dict->size = next; dict->size = next;
dict->fills = fills;
dict->buckets = buckets; dict->buckets = buckets;
} }
@ -78,7 +83,7 @@ ur_dict32_get(ur_root_t *r, ur_dict32_t *dict, ur_nref ref, uint32_t *out)
uint64_t idx = ( mug % dict->size ); uint64_t idx = ( mug % dict->size );
ur_pail32_t *bucket = &(dict->buckets[idx]); ur_pail32_t *bucket = &(dict->buckets[idx]);
uint8_t i, fill = bucket->fill; uint8_t i, fill = dict->fills[idx];
for ( i = 0; i < fill; i++ ) { for ( i = 0; i < fill; i++ ) {
if ( ref == bucket->refs[i] ) { if ( ref == bucket->refs[i] ) {
@ -98,7 +103,7 @@ ur_dict32_put(ur_root_t *r, ur_dict32_t *dict, ur_nref ref, uint32_t val)
while ( 1 ) { while ( 1 ) {
uint64_t idx = ( mug % dict->size ); uint64_t idx = ( mug % dict->size );
ur_pail32_t *bucket = &(dict->buckets[idx]); ur_pail32_t *bucket = &(dict->buckets[idx]);
uint8_t i, fill = bucket->fill; uint8_t i, fill = dict->fills[idx];
for ( i = 0; i < fill; i++ ) { for ( i = 0; i < fill; i++ ) {
if ( ref == bucket->refs[i] ) { if ( ref == bucket->refs[i] ) {
@ -114,7 +119,7 @@ ur_dict32_put(ur_root_t *r, ur_dict32_t *dict, ur_nref ref, uint32_t val)
bucket->refs[fill] = ref; bucket->refs[fill] = ref;
bucket->vals[fill] = val; bucket->vals[fill] = val;
bucket->fill = 1 + fill; dict->fills[idx] = 1 + fill;
break; break;
} }
} }
@ -122,27 +127,27 @@ ur_dict32_put(ur_root_t *r, ur_dict32_t *dict, ur_nref ref, uint32_t val)
void void
ur_dict32_wipe(ur_dict32_t *dict) ur_dict32_wipe(ur_dict32_t *dict)
{ {
ur_pail32_t *buckets = dict->buckets; uint8_t *fills = dict->fills;
uint64_t i, size = dict->size; uint64_t size = dict->size;
for ( i = 0; i < size; i++ ) { memset(fills, 0, sizeof(*fills) * size);
buckets[i].fill = 0;
}
} }
void void
ur_dict64_grow(ur_root_t *r, ur_dict64_t *dict, uint64_t prev, uint64_t size) ur_dict64_grow(ur_root_t *r, ur_dict64_t *dict, uint64_t prev, uint64_t size)
{ {
ur_pail64_t *buckets, *old_buckets = dict->buckets; ur_pail64_t *buckets, *old_buckets = dict->buckets;
uint8_t *fills, *old_fills = dict->fills;
uint64_t old_size = dict->size; uint64_t old_size = dict->size;
uint64_t i, next = prev + size; uint64_t i, next = prev + size;
buckets = _oom("dict64_grow", calloc(next, sizeof(*buckets))); buckets = _oom("dict64_grow", calloc(next, sizeof(*buckets)));
fills = _oom("dict64_grow", calloc(next, sizeof(*fills)));
if ( old_buckets ) { if ( old_buckets ) {
for ( i = 0; i < old_size; i++ ) { for ( i = 0; i < old_size; i++ ) {
ur_pail64_t *old_bucket = &(old_buckets[i]); ur_pail64_t *old_bucket = &(old_buckets[i]);
uint8_t j, old_fill = old_bucket->fill; uint8_t j, old_fill = old_fills[i];
for ( j = 0; j < old_fill; j++ ) { for ( j = 0; j < old_fill; j++ ) {
uint64_t val = old_bucket->vals[j]; uint64_t val = old_bucket->vals[j];
@ -151,24 +156,27 @@ ur_dict64_grow(ur_root_t *r, ur_dict64_t *dict, uint64_t prev, uint64_t size)
uint64_t idx = ( mug % next ); uint64_t idx = ( mug % next );
ur_pail64_t *bucket = &(buckets[idx]); ur_pail64_t *bucket = &(buckets[idx]);
uint8_t new_fill = bucket->fill; uint8_t new_fill = fills[idx];
if ( ur_pail_max == new_fill ) { if ( ur_pail_max == new_fill ) {
free(buckets); free(buckets);
free(fills);
return ur_dict64_grow(r, dict, size, next); return ur_dict64_grow(r, dict, size, next);
} }
bucket->refs[new_fill] = ref; bucket->refs[new_fill] = ref;
bucket->vals[new_fill] = val; bucket->vals[new_fill] = val;
bucket->fill = 1 + new_fill; fills[idx] = 1 + new_fill;
} }
} }
free(old_buckets); free(old_buckets);
free(old_fills);
} }
dict->prev = size; dict->prev = size;
dict->size = next; dict->size = next;
dict->fills = fills;
dict->buckets = buckets; dict->buckets = buckets;
} }
@ -179,7 +187,7 @@ ur_dict64_get(ur_root_t *r, ur_dict64_t *dict, ur_nref ref, uint64_t *out)
uint64_t idx = ( mug % dict->size ); uint64_t idx = ( mug % dict->size );
ur_pail64_t *bucket = &(dict->buckets[idx]); ur_pail64_t *bucket = &(dict->buckets[idx]);
uint8_t i, fill = bucket->fill; uint8_t i, fill = dict->fills[idx];
for ( i = 0; i < fill; i++ ) { for ( i = 0; i < fill; i++ ) {
if ( ref == bucket->refs[i] ) { if ( ref == bucket->refs[i] ) {
@ -199,7 +207,7 @@ ur_dict64_put(ur_root_t *r, ur_dict64_t *dict, ur_nref ref, uint64_t val)
while ( 1 ) { while ( 1 ) {
uint64_t idx = ( mug % dict->size ); uint64_t idx = ( mug % dict->size );
ur_pail64_t *bucket = &(dict->buckets[idx]); ur_pail64_t *bucket = &(dict->buckets[idx]);
uint8_t i, fill = bucket->fill; uint8_t i, fill = dict->fills[idx];
for ( i = 0; i < fill; i++ ) { for ( i = 0; i < fill; i++ ) {
if ( ref == bucket->refs[i] ) { if ( ref == bucket->refs[i] ) {
@ -215,7 +223,7 @@ ur_dict64_put(ur_root_t *r, ur_dict64_t *dict, ur_nref ref, uint64_t val)
bucket->refs[fill] = ref; bucket->refs[fill] = ref;
bucket->vals[fill] = val; bucket->vals[fill] = val;
bucket->fill = 1 + fill; dict->fills[idx] = 1 + fill;
break; break;
} }
} }
@ -223,27 +231,27 @@ ur_dict64_put(ur_root_t *r, ur_dict64_t *dict, ur_nref ref, uint64_t val)
void void
ur_dict64_wipe(ur_dict64_t *dict) ur_dict64_wipe(ur_dict64_t *dict)
{ {
ur_pail64_t *buckets = dict->buckets; uint8_t *fills = dict->fills;
uint64_t i, size = dict->size; uint64_t size = dict->size;
for ( i = 0; i < size; i++ ) { memset(fills, 0, sizeof(*fills) * size);
buckets[i].fill = 0;
}
} }
void void
ur_dict_grow(ur_root_t *r, ur_dict_t *dict, uint64_t prev, uint64_t size) ur_dict_grow(ur_root_t *r, ur_dict_t *dict, uint64_t prev, uint64_t size)
{ {
ur_pail_t *buckets, *old_buckets = dict->buckets; ur_pail_t *buckets, *old_buckets = dict->buckets;
uint8_t *fills, *old_fills = dict->fills;
uint64_t old_size = dict->size; uint64_t old_size = dict->size;
uint64_t i, next = prev + size; uint64_t i, next = prev + size;
buckets = _oom("dict_grow", calloc(next, sizeof(*buckets))); buckets = _oom("dict_grow", calloc(next, sizeof(*buckets)));
fills = _oom("dict_grow", calloc(next, sizeof(*fills)));
if ( old_buckets ) { if ( old_buckets ) {
for ( i = 0; i < old_size; i++ ) { for ( i = 0; i < old_size; i++ ) {
ur_pail_t *old_bucket = &(old_buckets[i]); ur_pail_t *old_bucket = &(old_buckets[i]);
uint8_t j, old_fill = old_bucket->fill; uint8_t j, old_fill = old_fills[i];
for ( j = 0; j < old_fill; j++ ) { for ( j = 0; j < old_fill; j++ ) {
ur_nref ref = old_bucket->refs[j]; ur_nref ref = old_bucket->refs[j];
@ -251,23 +259,26 @@ ur_dict_grow(ur_root_t *r, ur_dict_t *dict, uint64_t prev, uint64_t size)
uint64_t idx = ( mug % next ); uint64_t idx = ( mug % next );
ur_pail_t *bucket = &(buckets[idx]); ur_pail_t *bucket = &(buckets[idx]);
uint8_t new_fill = bucket->fill; uint8_t new_fill = fills[idx];
if ( ur_pail_max == new_fill ) { if ( ur_pail_max == new_fill ) {
free(buckets); free(buckets);
free(fills);
return ur_dict_grow(r, dict, size, next); return ur_dict_grow(r, dict, size, next);
} }
bucket->refs[new_fill] = ref; bucket->refs[new_fill] = ref;
bucket->fill = 1 + new_fill; fills[idx] = 1 + new_fill;
} }
} }
free(old_buckets); free(old_buckets);
free(old_fills);
} }
dict->prev = size; dict->prev = size;
dict->size = next; dict->size = next;
dict->fills = fills;
dict->buckets = buckets; dict->buckets = buckets;
} }
@ -278,7 +289,7 @@ ur_dict_get(ur_root_t *r, ur_dict_t *dict, ur_nref ref)
uint64_t idx = ( mug % dict->size ); uint64_t idx = ( mug % dict->size );
ur_pail_t *bucket = &(dict->buckets[idx]); ur_pail_t *bucket = &(dict->buckets[idx]);
uint8_t i, fill = bucket->fill; uint8_t i, fill = dict->fills[idx];
for ( i = 0; i < fill; i++ ) { for ( i = 0; i < fill; i++ ) {
if ( ref == bucket->refs[i] ) { if ( ref == bucket->refs[i] ) {
@ -297,7 +308,7 @@ ur_dict_put(ur_root_t *r, ur_dict_t *dict, ur_nref ref)
while ( 1 ) { while ( 1 ) {
uint64_t idx = ( mug % dict->size ); uint64_t idx = ( mug % dict->size );
ur_pail_t *bucket = &(dict->buckets[idx]); ur_pail_t *bucket = &(dict->buckets[idx]);
uint8_t i, fill = bucket->fill; uint8_t i, fill = dict->fills[idx];
for ( i = 0; i < fill; i++ ) { for ( i = 0; i < fill; i++ ) {
if ( ref == bucket->refs[i] ) { if ( ref == bucket->refs[i] ) {
@ -311,7 +322,7 @@ ur_dict_put(ur_root_t *r, ur_dict_t *dict, ur_nref ref)
} }
bucket->refs[fill] = ref; bucket->refs[fill] = ref;
bucket->fill = 1 + fill; dict->fills[idx] = 1 + fill;
break; break;
} }
} }
@ -319,18 +330,17 @@ ur_dict_put(ur_root_t *r, ur_dict_t *dict, ur_nref ref)
void void
ur_dict_wipe(ur_dict_t *dict) ur_dict_wipe(ur_dict_t *dict)
{ {
ur_pail_t *buckets = dict->buckets; uint8_t *fills = dict -> fills;
uint64_t i, size = dict->size; uint64_t size = dict->size;
for ( i = 0; i < size; i++ ) { memset(fills, 0, sizeof(*fills) * size);
buckets[i].fill = 0;
}
} }
void void
ur_dict_free(ur_dict_t *dict) ur_dict_free(ur_dict_t *dict)
{ {
free(dict->buckets); free(dict->buckets);
free(dict->fills);
dict->buckets = 0; dict->buckets = 0;
} }
@ -613,7 +623,7 @@ ur_coin_bytes_unsafe(ur_root_t *r, uint64_t len, uint8_t *byt)
while ( 1 ) { while ( 1 ) {
uint64_t idx = ( mug % dict->size ); uint64_t idx = ( mug % dict->size );
ur_pail_t *bucket = &(dict->buckets[idx]); ur_pail_t *bucket = &(dict->buckets[idx]);
uint8_t i, b_fill = bucket->fill; uint8_t i, b_fill = dict->fills[idx];
ur_nref tom; ur_nref tom;
for ( i = 0; i < b_fill; i++ ) { for ( i = 0; i < b_fill; i++ ) {
@ -642,7 +652,7 @@ ur_coin_bytes_unsafe(ur_root_t *r, uint64_t len, uint8_t *byt)
tom = _coin_unsafe(atoms, mug, len, byt); tom = _coin_unsafe(atoms, mug, len, byt);
bucket->refs[b_fill] = tom; bucket->refs[b_fill] = tom;
bucket->fill = 1 + b_fill; dict->fills[idx] = 1 + b_fill;
return tom; return tom;
} }
@ -712,7 +722,7 @@ ur_cons(ur_root_t *r, ur_nref hed, ur_nref tal)
while ( 1 ) { while ( 1 ) {
uint64_t idx = ( mug % dict->size ); uint64_t idx = ( mug % dict->size );
ur_pail_t *bucket = &(dict->buckets[idx]); ur_pail_t *bucket = &(dict->buckets[idx]);
uint8_t i, b_fill = bucket->fill; uint8_t i, b_fill = dict->fills[idx];
ur_nref cel; ur_nref cel;
for ( i = 0; i < b_fill; i++ ) { for ( i = 0; i < b_fill; i++ ) {
@ -737,7 +747,7 @@ ur_cons(ur_root_t *r, ur_nref hed, ur_nref tal)
cel = _cons_unsafe(cells, mug, hed, tal); cel = _cons_unsafe(cells, mug, hed, tal);
bucket->refs[b_fill] = cel; bucket->refs[b_fill] = cel;
bucket->fill = 1 + b_fill; dict->fills[idx] = 1 + b_fill;
return cel; return cel;
} }

8
pkg/urbit/vere/auto.c
View File

@ -91,7 +91,7 @@ u3_auto_bail_slog(u3_ovum* egg_u, u3_noun lud)
c3_w len_w = 1; c3_w len_w = 1;
while ( u3_nul != dul ) { while ( u3_nul != dul ) {
u3l_log("%s: bail %u\r\n", car_c, len_w++); u3l_log("%s: bail %u", car_c, len_w++);
u3_pier_punt_goof(car_c, u3k(u3h(dul))); u3_pier_punt_goof(car_c, u3k(u3h(dul)));
dul = u3t(dul); dul = u3t(dul);
@ -240,7 +240,7 @@ _auto_kick_lost(u3_noun pax, u3_noun fav)
c3_c* tag_c = u3r_string(u3h(fav)); c3_c* tag_c = u3r_string(u3h(fav));
c3_c* pax_c = u3r_string(tox); c3_c* pax_c = u3r_string(tox);
u3l_log("kick: lost %%%s on %s\n", tag_c, pax_c); u3l_log("kick: lost %%%s on %s", tag_c, pax_c);
c3_free(pax_c); c3_free(pax_c);
c3_free(tag_c); c3_free(tag_c);
@ -360,12 +360,12 @@ u3_auto_info(u3_auto* car_u)
{ {
u3_auto* nex_u; u3_auto* nex_u;
u3l_log(" drivers:\n"); u3l_log(" drivers:");
while ( car_u ) { while ( car_u ) {
nex_u = car_u->nex_u; nex_u = car_u->nex_u;
u3l_log(" %.*s: live=%s, queue=%u\n", u3l_log(" %.*s: live=%s, queue=%u",
u3r_met(3, car_u->nam_m), u3r_met(3, car_u->nam_m),
(c3_c*)&car_u->nam_m, (c3_c*)&car_u->nam_m,
( c3y == car_u->liv_o ) ? "&" : "|", ( c3y == car_u->liv_o ) ? "&" : "|",

46
pkg/urbit/vere/dawn.c
View File

@ -71,7 +71,7 @@ _dawn_post_json(c3_c* url_c, uv_buf_t lod_u)
uv_buf_t buf_u = uv_buf_init(c3_malloc(1), 0); uv_buf_t buf_u = uv_buf_init(c3_malloc(1), 0);
if ( !(curl = curl_easy_init()) ) { if ( !(curl = curl_easy_init()) ) {
u3l_log("failed to initialize libcurl\n"); u3l_log("failed to initialize libcurl");
exit(1); exit(1);
} }
@ -95,12 +95,12 @@ _dawn_post_json(c3_c* url_c, uv_buf_t lod_u)
// XX retry? // XX retry?
if ( CURLE_OK != result ) { if ( CURLE_OK != result ) {
u3l_log("failed to fetch %s: %s\n", u3l_log("failed to fetch %s: %s",
url_c, curl_easy_strerror(result)); url_c, curl_easy_strerror(result));
exit(1); exit(1);
} }
if ( 300 <= cod_l ) { if ( 300 <= cod_l ) {
u3l_log("error fetching %s: HTTP %ld\n", url_c, cod_l); u3l_log("error fetching %s: HTTP %ld", url_c, cod_l);
exit(1); exit(1);
} }
@ -122,7 +122,7 @@ _dawn_get_jam(c3_c* url_c)
uv_buf_t buf_u = uv_buf_init(c3_malloc(1), 0); uv_buf_t buf_u = uv_buf_init(c3_malloc(1), 0);
if ( !(curl = curl_easy_init()) ) { if ( !(curl = curl_easy_init()) ) {
u3l_log("failed to initialize libcurl\n"); u3l_log("failed to initialize libcurl");
exit(1); exit(1);
} }
@ -138,12 +138,12 @@ _dawn_get_jam(c3_c* url_c)
// XX retry? // XX retry?
if ( CURLE_OK != result ) { if ( CURLE_OK != result ) {
u3l_log("failed to fetch %s: %s\n", u3l_log("failed to fetch %s: %s",
url_c, curl_easy_strerror(result)); url_c, curl_easy_strerror(result));
exit(1); exit(1);
} }
if ( 300 <= cod_l ) { if ( 300 <= cod_l ) {
u3l_log("error fetching %s: HTTP %ld\n", url_c, cod_l); u3l_log("error fetching %s: HTTP %ld", url_c, cod_l);
exit(1); exit(1);
} }
@ -207,7 +207,7 @@ _dawn_fail(u3_noun who, u3_noun rac, u3_noun sas)
} }
} }
u3l_log("boot: invalid keys for %s '%s'\r\n", rac_c, how_c); u3l_log("boot: invalid keys for %s '%s'", rac_c, how_c);
// XX deconstruct sas, print helpful error messages // XX deconstruct sas, print helpful error messages
while ( u3_nul != sas ) { while ( u3_nul != sas ) {
@ -226,7 +226,7 @@ static u3_noun
_dawn_need_unit(u3_noun nit, c3_c* msg_c) _dawn_need_unit(u3_noun nit, c3_c* msg_c)
{ {
if ( u3_nul == nit ) { if ( u3_nul == nit ) {
u3l_log("%s\r\n", msg_c); u3l_log("%s", msg_c);
exit(1); exit(1);
} }
else { else {
@ -245,7 +245,7 @@ _dawn_purl(u3_noun rac)
if ( 0 == u3_Host.ops_u.eth_c ) { if ( 0 == u3_Host.ops_u.eth_c ) {
if ( c3__czar == rac ) { if ( c3__czar == rac ) {
u3l_log("boot: galaxy requires ethereum gateway via -e\r\n"); u3l_log("boot: galaxy requires ethereum gateway via -e");
exit(1); exit(1);
} }
@ -260,7 +260,7 @@ _dawn_purl(u3_noun rac)
if ( u3_nul == rul ) { if ( u3_nul == rul ) {
if ( c3__czar == rac ) { if ( c3__czar == rac ) {
u3l_log("boot: galaxy requires ethereum gateway via -e\r\n"); u3l_log("boot: galaxy requires ethereum gateway via -e");
exit(1); exit(1);
} }
@ -292,11 +292,11 @@ _dawn_turf(c3_c* dns_c)
u3_noun rul = u3dc("rush", u3k(dns), u3k(par)); u3_noun rul = u3dc("rush", u3k(dns), u3k(par));
if ( (u3_nul == rul) || (c3n == u3h(u3t(rul))) ) { if ( (u3_nul == rul) || (c3n == u3h(u3t(rul))) ) {
u3l_log("boot: invalid domain specified with -H %s\r\n", dns_c); u3l_log("boot: invalid domain specified with -H %s", dns_c);
exit(1); exit(1);
} }
else { else {
u3l_log("boot: overriding network domains with %s\r\n", dns_c); u3l_log("boot: overriding network domains with %s", dns_c);
u3_noun dom = u3t(u3t(rul)); u3_noun dom = u3t(u3t(rul));
tuf = u3nc(u3k(dom), u3_nul); tuf = u3nc(u3k(dom), u3_nul);
} }
@ -345,7 +345,7 @@ u3_dawn_vent(u3_noun ship, u3_noun feed)
// pin block number // pin block number
// //
{ {
u3l_log("boot: retrieving latest block\r\n"); u3l_log("boot: retrieving latest block");
u3_noun oct = u3v_wish("bloq:give:dawn"); u3_noun oct = u3v_wish("bloq:give:dawn");
u3_noun kob = _dawn_eth_rpc(url_c, u3k(oct)); u3_noun kob = _dawn_eth_rpc(url_c, u3k(oct));
@ -369,7 +369,7 @@ u3_dawn_vent(u3_noun ship, u3_noun feed)
pot = u3v_wish("*point:azimuth"); pot = u3v_wish("*point:azimuth");
} }
else { else {
u3l_log("boot: retrieving %s's public keys\r\n", u3l_log("boot: retrieving %s's public keys",
u3_Host.ops_u.who_c); u3_Host.ops_u.who_c);
{ {
@ -388,7 +388,7 @@ u3_dawn_vent(u3_noun ship, u3_noun feed)
u3_noun liv = u3_nul; u3_noun liv = u3_nul;
// u3_noun liv = _dawn_get_json(parent, /some/url) // u3_noun liv = _dawn_get_json(parent, /some/url)
u3l_log("boot: verifying keys\r\n"); u3l_log("boot: verifying keys");
// (each seed (lest error=@tas)) // (each seed (lest error=@tas))
// //
@ -400,7 +400,7 @@ u3_dawn_vent(u3_noun ship, u3_noun feed)
return u3_none; return u3_none;
} }
u3l_log("boot: getting sponsor\r\n"); u3l_log("boot: getting sponsor");
pos = _dawn_sponsor(u3k(ship), u3k(rank), u3k(pot)); pos = _dawn_sponsor(u3k(ship), u3k(rank), u3k(pot));
u3z(pot); u3z(liv); u3z(pot); u3z(liv);
} }
@ -409,7 +409,7 @@ u3_dawn_vent(u3_noun ship, u3_noun feed)
// (map ship [=life =pass]): galaxy table // (map ship [=life =pass]): galaxy table
// //
{ {
u3l_log("boot: retrieving galaxy table\r\n"); u3l_log("boot: retrieving galaxy table");
u3_noun oct = u3do("czar:give:dawn", u3k(bok)); u3_noun oct = u3do("czar:give:dawn", u3k(bok));
u3_noun raz = _dawn_eth_rpc(url_c, u3k(oct)); u3_noun raz = _dawn_eth_rpc(url_c, u3k(oct));
@ -425,7 +425,7 @@ u3_dawn_vent(u3_noun ship, u3_noun feed)
tuf = _dawn_turf(u3_Host.ops_u.dns_c); tuf = _dawn_turf(u3_Host.ops_u.dns_c);
} }
else { else {
u3l_log("boot: retrieving network domains\r\n"); u3l_log("boot: retrieving network domains");
u3_noun oct = u3do("turf:give:dawn", u3k(bok)); u3_noun oct = u3do("turf:give:dawn", u3k(bok));
u3_noun fut = _dawn_eth_rpc(url_c, u3k(oct)); u3_noun fut = _dawn_eth_rpc(url_c, u3k(oct));
@ -443,7 +443,7 @@ u3_dawn_vent(u3_noun ship, u3_noun feed)
{ {
u3_noun who = u3dc("scot", 'p', u3k(pos)); u3_noun who = u3dc("scot", 'p', u3k(pos));
c3_c* who_c = u3r_string(who); c3_c* who_c = u3r_string(who);
u3l_log("boot: retrieving keys for sponsor %s\r\n", who_c); u3l_log("boot: retrieving keys for sponsor %s", who_c);
u3z(who); u3z(who);
c3_free(who_c); c3_free(who_c);
} }
@ -495,8 +495,8 @@ _dawn_come(u3_noun stars)
c3_rand(eny_w); c3_rand(eny_w);
eny = u3i_words(16, eny_w); eny = u3i_words(16, eny_w);
u3l_log("boot: mining a comet. May take up to an hour.\r\n"); u3l_log("boot: mining a comet. May take up to an hour.");
u3l_log("If you want to boot faster, get an Urbit identity.\r\n"); u3l_log("If you want to boot faster, get an Urbit identity.");
seed = u3dc("come:dawn", u3k(stars), u3k(eny)); seed = u3dc("come:dawn", u3k(stars), u3k(eny));
u3z(eny); u3z(eny);
@ -506,7 +506,7 @@ _dawn_come(u3_noun stars)
u3_noun who = u3dc("scot", 'p', u3k(u3h(seed))); u3_noun who = u3dc("scot", 'p', u3k(u3h(seed)));
c3_c* who_c = u3r_string(who); c3_c* who_c = u3r_string(who);
u3l_log("boot: found comet %s\r\n", who_c); u3l_log("boot: found comet %s", who_c);
// enable to print and save comet private key for future reuse // enable to print and save comet private key for future reuse
// //
@ -515,7 +515,7 @@ _dawn_come(u3_noun stars)
u3_noun key = u3dc("scot", c3__uw, u3qe_jam(seed)); u3_noun key = u3dc("scot", c3__uw, u3qe_jam(seed));
c3_c* key_c = u3r_string(key); c3_c* key_c = u3r_string(key);
u3l_log("boot: comet private key\n %s\n", key_c); u3l_log("boot: comet private key\n %s", key_c);
{ {
c3_c pat_c[64]; c3_c pat_c[64];

10
pkg/urbit/vere/disk.c
View File

@ -242,7 +242,7 @@ u3_disk_plan(u3_disk* log_u, u3_fact* tac_u)
{ {
c3_assert( (1ULL + log_u->sen_d) == tac_u->eve_d ); c3_assert( (1ULL + log_u->sen_d) == tac_u->eve_d );
log_u->sen_d++; log_u->sen_d++;
if ( !log_u->put_u.ent_u ) { if ( !log_u->put_u.ent_u ) {
c3_assert( !log_u->put_u.ext_u ); c3_assert( !log_u->put_u.ext_u );
log_u->put_u.ent_u = log_u->put_u.ext_u = tac_u; log_u->put_u.ent_u = log_u->put_u.ext_u = tac_u;
@ -649,7 +649,7 @@ u3_disk_exit(u3_disk* log_u)
void void
u3_disk_info(u3_disk* log_u) u3_disk_info(u3_disk* log_u)
{ {
u3l_log(" disk: live=%s, event=%" PRIu64 "\n", u3l_log(" disk: live=%s, event=%" PRIu64,
( c3y == log_u->liv_o ) ? "&" : "|", ( c3y == log_u->liv_o ) ? "&" : "|",
log_u->dun_d); log_u->dun_d);
@ -657,7 +657,7 @@ u3_disk_info(u3_disk* log_u)
u3_read* red_u = log_u->red_u; u3_read* red_u = log_u->red_u;
while ( red_u ) { while ( red_u ) {
u3l_log(" read: %" PRIu64 "-%" PRIu64 "\n", u3l_log(" read: %" PRIu64 "-%" PRIu64,
red_u->eve_d, red_u->eve_d,
(red_u->eve_d + red_u->len_d) - 1); (red_u->eve_d + red_u->len_d) - 1);
} }
@ -665,12 +665,12 @@ u3_disk_info(u3_disk* log_u)
if ( log_u->put_u.ext_u ) { if ( log_u->put_u.ext_u ) {
if ( log_u->put_u.ext_u != log_u->put_u.ent_u ) { if ( log_u->put_u.ext_u != log_u->put_u.ent_u ) {
u3l_log(" save: %" PRIu64 "-%" PRIu64 "\n", u3l_log(" save: %" PRIu64 "-%" PRIu64,
log_u->put_u.ext_u->eve_d, log_u->put_u.ext_u->eve_d,
log_u->put_u.ent_u->eve_d); log_u->put_u.ent_u->eve_d);
} }
else { else {
u3l_log(" save: %" PRIu64 "\n", log_u->put_u.ext_u->eve_d); u3l_log(" save: %" PRIu64, log_u->put_u.ext_u->eve_d);
} }
} }
} }

4
pkg/urbit/vere/foil.c
View File

@ -36,10 +36,10 @@ static void
_foil_fail(const c3_c* why_c, c3_i err_i) _foil_fail(const c3_c* why_c, c3_i err_i)
{ {
if ( err_i ) { if ( err_i ) {
u3l_log("%s: error: %s\r\n", why_c, uv_strerror(err_i)); u3l_log("%s: error: %s", why_c, uv_strerror(err_i));
c3_assert(0); c3_assert(0);
} else { } else {
u3l_log("%s: file error\r\n", why_c); u3l_log("%s: file error", why_c);
} }
exit(1); exit(1);
} }

96
pkg/urbit/vere/io/ames.c
View File

@ -340,7 +340,7 @@ _ames_send_cb(uv_udp_send_t* req_u, c3_i sas_i)
u3_ames* sam_u = pac_u->sam_u; u3_ames* sam_u = pac_u->sam_u;
if ( sas_i && (c3y == sam_u->fig_u.net_o) ) { if ( sas_i && (c3y == sam_u->fig_u.net_o) ) {
u3l_log("ames: send fail: %s\n", uv_strerror(sas_i)); u3l_log("ames: send fail: %s", uv_strerror(sas_i));
sam_u->fig_u.net_o = c3n; sam_u->fig_u.net_o = c3n;
} }
else { else {
@ -379,7 +379,7 @@ _ames_send(u3_pact* pac_u)
if ( sas_i ) { if ( sas_i ) {
if ( c3y == sam_u->fig_u.net_o ) { if ( c3y == sam_u->fig_u.net_o ) {
u3l_log("ames: send fail: %s\n", uv_strerror(sas_i)); u3l_log("ames: send fail: %s", uv_strerror(sas_i));
sam_u->fig_u.net_o = c3n; sam_u->fig_u.net_o = c3n;
} }
@ -516,7 +516,7 @@ _ames_czar_gone(u3_pact* pac_u, time_t now)
u3_ames* sam_u = pac_u->sam_u; u3_ames* sam_u = pac_u->sam_u;
if ( c3y == sam_u->imp_o[pac_u->imp_y] ) { if ( c3y == sam_u->imp_o[pac_u->imp_y] ) {
u3l_log("ames: czar at %s: not found (b)\n", pac_u->dns_c); u3l_log("ames: czar at %s: not found (b)", pac_u->dns_c);
sam_u->imp_o[pac_u->imp_y] = c3n; sam_u->imp_o[pac_u->imp_y] = c3n;
} }
@ -546,7 +546,7 @@ _ames_czar_here(u3_pact* pac_u, time_t now, struct sockaddr_in* add_u)
u3_noun nam = u3dc("scot", c3__if, u3i_word(pip_w)); u3_noun nam = u3dc("scot", c3__if, u3i_word(pip_w));
c3_c* nam_c = u3r_string(nam); c3_c* nam_c = u3r_string(nam);
u3l_log("ames: czar %s: ip %s\n", pac_u->dns_c, nam_c); u3l_log("ames: czar %s: ip %s", pac_u->dns_c, nam_c);
c3_free(nam_c); c3_free(nam_c);
u3z(nam); u3z(nam);
@ -611,7 +611,7 @@ _ames_czar(u3_pact* pac_u)
if ( !sam_u->dns_c ) { if ( !sam_u->dns_c ) {
u3_noun nam = u3dc("scot", 'p', pac_u->imp_y); u3_noun nam = u3dc("scot", 'p', pac_u->imp_y);
c3_c* nam_c = u3r_string(nam); c3_c* nam_c = u3r_string(nam);
u3l_log("ames: no galaxy domain for %s, no-op\r\n", nam_c); u3l_log("ames: no galaxy domain for %s, no-op", nam_c);
c3_free(nam_c); c3_free(nam_c);
u3z(nam); u3z(nam);
@ -656,7 +656,7 @@ _ames_czar(u3_pact* pac_u)
} }
if ( 255 <= sas_i ) { if ( 255 <= sas_i ) {
u3l_log("ames: czar: galaxy domain %s truncated\n", sam_u->dns_c); u3l_log("ames: czar: galaxy domain %s truncated", sam_u->dns_c);
_ames_pact_free(pac_u); _ames_pact_free(pac_u);
return; return;
} }
@ -669,7 +669,7 @@ _ames_czar(u3_pact* pac_u)
_ames_czar_cb, _ames_czar_cb,
pac_u->dns_c, 0, 0)) ) pac_u->dns_c, 0, 0)) )
{ {
u3l_log("ames: %s\n", uv_strerror(sas_i)); u3l_log("ames: %s", uv_strerror(sas_i));
_ames_czar_gone(pac_u, now); _ames_czar_gone(pac_u, now);
return; return;
} }
@ -684,7 +684,7 @@ static void
_ames_ef_send(u3_ames* sam_u, u3_noun lan, u3_noun pac) _ames_ef_send(u3_ames* sam_u, u3_noun lan, u3_noun pac)
{ {
if ( c3n == sam_u->car_u.liv_o ) { if ( c3n == sam_u->car_u.liv_o ) {
u3l_log("ames: not yet live, dropping outbound\r\n"); u3l_log("ames: not yet live, dropping outbound");
u3z(lan); u3z(pac); u3z(lan); u3z(pac);
return; return;
} }
@ -754,7 +754,7 @@ _ames_cap_queue(u3_ames* sam_u)
sam_u->sat_u.dop_d++; sam_u->sat_u.dop_d++;
if ( u3C.wag_w & u3o_verbose ) { if ( u3C.wag_w & u3o_verbose ) {
u3l_log("ames: packet dropped (%" PRIu64 " total)\n", sam_u->sat_u.dop_d); u3l_log("ames: packet dropped (%" PRIu64 " total)", sam_u->sat_u.dop_d);
} }
} }
@ -764,7 +764,7 @@ _ames_cap_queue(u3_ames* sam_u)
if ( (sam_u->sat_u.dop_d && (0 == (sam_u->sat_u.dop_d % 1000))) if ( (sam_u->sat_u.dop_d && (0 == (sam_u->sat_u.dop_d % 1000)))
&& !(u3C.wag_w & u3o_verbose) ) && !(u3C.wag_w & u3o_verbose) )
{ {
u3l_log("ames: packet dropped (%" PRIu64 " total)\n", sam_u->sat_u.dop_d); u3l_log("ames: packet dropped (%" PRIu64 " total)", sam_u->sat_u.dop_d);
} }
} }
@ -782,7 +782,7 @@ _ames_punt_goof(u3_noun lud)
c3_w len_w = 1; c3_w len_w = 1;
while ( u3_nul != dul ) { while ( u3_nul != dul ) {
u3l_log("ames: bail %u\r\n", len_w++); u3l_log("ames: bail %u", len_w++);
u3_pier_punt_goof("ames", u3k(u3h(dul))); u3_pier_punt_goof("ames", u3k(u3h(dul)));
dul = u3t(dul); dul = u3t(dul);
} }
@ -803,13 +803,13 @@ _ames_hear_bail(u3_ovum* egg_u, u3_noun lud)
|| (0 == (sam_u->sat_u.fal_d % 1000)) ) || (0 == (sam_u->sat_u.fal_d % 1000)) )
{ {
_ames_punt_goof(lud); _ames_punt_goof(lud);
u3l_log("ames: packet failed (%" PRIu64 " total)\n\n", sam_u->sat_u.fal_d); u3l_log("ames: packet failed (%" PRIu64 " total)", sam_u->sat_u.fal_d);
} }
else { else {
u3z(lud); u3z(lud);
if ( 0 == (sam_u->sat_u.fal_d % 1000) ) { if ( 0 == (sam_u->sat_u.fal_d % 1000) ) {
u3l_log("ames: packet failed (%" PRIu64 " total)\n\n", sam_u->sat_u.fal_d); u3l_log("ames: packet failed (%" PRIu64 " total)", sam_u->sat_u.fal_d);
} }
} }
@ -843,7 +843,7 @@ _ames_forward(u3_panc* pac_u, u3_noun las)
sam_u->sat_u.fow_d++; sam_u->sat_u.fow_d++;
if ( 0 == (sam_u->sat_u.fow_d % 1000000) ) { if ( 0 == (sam_u->sat_u.fow_d % 1000000) ) {
u3l_log("ames: forwarded %" PRIu64 " total\n", sam_u->sat_u.fow_d); u3l_log("ames: forwarded %" PRIu64 " total", sam_u->sat_u.fow_d);
} }
if ( u3C.wag_w & u3o_verbose ) { if ( u3C.wag_w & u3o_verbose ) {
@ -853,7 +853,7 @@ _ames_forward(u3_panc* pac_u, u3_noun las)
c3_c* rec_c = u3r_string(rec); c3_c* rec_c = u3r_string(rec);
c3_y* pip_y = (c3_y*)&pac_u->ore_u.pip_w; c3_y* pip_y = (c3_y*)&pac_u->ore_u.pip_w;
u3l_log("ames: forwarding for %s to %s from %d.%d.%d.%d:%d\n", u3l_log("ames: forwarding for %s to %s from %d.%d.%d.%d:%d",
sen_c, rec_c, sen_c, rec_c,
pip_y[0], pip_y[1], pip_y[2], pip_y[3], pip_y[0], pip_y[1], pip_y[2], pip_y[3],
pac_u->ore_u.por_s); pac_u->ore_u.por_s);
@ -872,7 +872,7 @@ _ames_forward(u3_panc* pac_u, u3_noun las)
// validate lane and skip self if galaxy // validate lane and skip self if galaxy
// //
if ( c3n == u3r_cell(lan, &tag, &dat) ) { if ( c3n == u3r_cell(lan, &tag, &dat) ) {
u3l_log("ames: bogus lane\n"); u3l_log("ames: bogus lane");
u3m_p("lan", lan); u3m_p("lan", lan);
} }
else { else {
@ -887,7 +887,7 @@ _ames_forward(u3_panc* pac_u, u3_noun las)
{ {
sen_o = c3n; sen_o = c3n;
if ( u3C.wag_w & u3o_verbose ) { if ( u3C.wag_w & u3o_verbose ) {
u3l_log("ames: forward skipping self\n"); u3l_log("ames: forward skipping self");
} }
} }
} }
@ -920,7 +920,7 @@ _ames_lane_scry_cb(void* vod_p, u3_noun nun)
// //
if ( u3_none == las ) { if ( u3_none == las ) {
if ( 5 < ++sam_u->sat_u.saw_d ) { if ( 5 < ++sam_u->sat_u.saw_d ) {
u3l_log("ames: giving up scry\n"); u3l_log("ames: giving up scry");
sam_u->fig_u.see_o = c3n; sam_u->fig_u.see_o = c3n;
} }
_ames_put_packet(sam_u, _ames_serialize_packet(pac_u, c3n), pac_u->ore_u); _ames_put_packet(sam_u, _ames_serialize_packet(pac_u, c3n), pac_u->ore_u);
@ -984,7 +984,7 @@ _ames_try_forward(u3_ames* sam_u,
if ( (u3_none == lac) && (1000 < sam_u->sat_u.foq_d) ) { if ( (u3_none == lac) && (1000 < sam_u->sat_u.foq_d) ) {
sam_u->sat_u.fod_d++; sam_u->sat_u.fod_d++;
if ( 0 == (sam_u->sat_u.fod_d % 10000) ) { if ( 0 == (sam_u->sat_u.fod_d % 10000) ) {
u3l_log("ames: dropped %" PRIu64 " forwards total\n", u3l_log("ames: dropped %" PRIu64 " forwards total",
sam_u->sat_u.fod_d); sam_u->sat_u.fod_d);
} }
@ -1088,7 +1088,7 @@ _ames_hear(u3_ames* sam_u,
{ {
sam_u->sat_u.hed_d++; sam_u->sat_u.hed_d++;
if ( 0 == (sam_u->sat_u.hed_d % 100000) ) { if ( 0 == (sam_u->sat_u.hed_d % 100000) ) {
u3l_log("ames: %" PRIu64 " dropped, failed to read header\n", u3l_log("ames: %" PRIu64 " dropped, failed to read header",
sam_u->sat_u.hed_d); sam_u->sat_u.hed_d);
} }
@ -1105,7 +1105,7 @@ _ames_hear(u3_ames* sam_u,
{ {
sam_u->sat_u.vet_d++; sam_u->sat_u.vet_d++;
if ( 0 == (sam_u->sat_u.vet_d % 100000) ) { if ( 0 == (sam_u->sat_u.vet_d % 100000) ) {
u3l_log("ames: %" PRIu64 " dropped for version mismatch\n", u3l_log("ames: %" PRIu64 " dropped for version mismatch",
sam_u->sat_u.vet_d); sam_u->sat_u.vet_d);
} }
@ -1122,7 +1122,7 @@ _ames_hear(u3_ames* sam_u,
if ( (c3n == _ames_sift_body(&hed_u, &bod_u, bod_w, bod_y)) ) { if ( (c3n == _ames_sift_body(&hed_u, &bod_u, bod_w, bod_y)) ) {
sam_u->sat_u.bod_d++; sam_u->sat_u.bod_d++;
if ( 0 == (sam_u->sat_u.bod_d % 100) ) { if ( 0 == (sam_u->sat_u.bod_d % 100) ) {
u3l_log("ames: %" PRIu64 " dropped, failed to read body\n", u3l_log("ames: %" PRIu64 " dropped, failed to read body",
sam_u->sat_u.bod_d); sam_u->sat_u.bod_d);
} }
@ -1135,7 +1135,7 @@ _ames_hear(u3_ames* sam_u,
if ( bod_u.mug_l != hed_u.mug_l ) { if ( bod_u.mug_l != hed_u.mug_l ) {
sam_u->sat_u.mut_d++; sam_u->sat_u.mut_d++;
if ( 0 == (sam_u->sat_u.mut_d % 100000) ) { if ( 0 == (sam_u->sat_u.mut_d % 100000) ) {
u3l_log("ames: %" PRIu64 " dropped for invalid mug\n", u3l_log("ames: %" PRIu64 " dropped for invalid mug",
sam_u->sat_u.mut_d); sam_u->sat_u.mut_d);
} }
@ -1183,7 +1183,7 @@ _ames_recv_cb(uv_udp_t* wax_u,
{ {
if ( 0 > nrd_i ) { if ( 0 > nrd_i ) {
if ( u3C.wag_w & u3o_verbose ) { if ( u3C.wag_w & u3o_verbose ) {
u3l_log("ames: recv: fail: %s\n", uv_strerror(nrd_i)); u3l_log("ames: recv: fail: %s", uv_strerror(nrd_i));
} }
c3_free(buf_u->base); c3_free(buf_u->base);
} }
@ -1192,7 +1192,7 @@ _ames_recv_cb(uv_udp_t* wax_u,
} }
else if ( flg_i & UV_UDP_PARTIAL ) { else if ( flg_i & UV_UDP_PARTIAL ) {
if ( u3C.wag_w & u3o_verbose ) { if ( u3C.wag_w & u3o_verbose ) {
u3l_log("ames: recv: fail: message truncated\n"); u3l_log("ames: recv: fail: message truncated");
} }
c3_free(buf_u->base); c3_free(buf_u->base);
} }
@ -1228,8 +1228,8 @@ _ames_io_start(u3_ames* sam_u)
por_s = zar_s; por_s = zar_s;
} }
else if ( por_s != zar_s ) { else if ( por_s != zar_s ) {
u3l_log("ames: czar: overriding port %d with -p %d\n", zar_s, por_s); u3l_log("ames: czar: overriding port %d with -p %d", zar_s, por_s);
u3l_log("ames: czar: WARNING: %d required for discoverability\n", zar_s); u3l_log("ames: czar: WARNING: %d required for discoverability", zar_s);
} }
} }
@ -1248,12 +1248,12 @@ _ames_io_start(u3_ames* sam_u)
if ( (ret_i = uv_udp_bind(&sam_u->wax_u, if ( (ret_i = uv_udp_bind(&sam_u->wax_u,
(const struct sockaddr*)&add_u, 0)) != 0 ) (const struct sockaddr*)&add_u, 0)) != 0 )
{ {
u3l_log("ames: bind: %s\n", uv_strerror(ret_i)); u3l_log("ames: bind: %s", uv_strerror(ret_i));
if ( (c3__czar == rac) && if ( (c3__czar == rac) &&
(UV_EADDRINUSE == ret_i) ) (UV_EADDRINUSE == ret_i) )
{ {
u3l_log(" ...perhaps you've got two copies of vere running?\n"); u3l_log(" ...perhaps you've got two copies of vere running?");
} }
// XX revise // XX revise
@ -1268,10 +1268,10 @@ _ames_io_start(u3_ames* sam_u)
} }
if ( c3y == u3_Host.ops_u.net ) { if ( c3y == u3_Host.ops_u.net ) {
u3l_log("ames: live on %d\n", sam_u->pir_u->por_s); u3l_log("ames: live on %d", sam_u->pir_u->por_s);
} }
else { else {
u3l_log("ames: live on %d (localhost only)\n", sam_u->pir_u->por_s); u3l_log("ames: live on %d (localhost only)", sam_u->pir_u->por_s);
} }
uv_udp_recv_start(&sam_u->wax_u, _ames_alloc, _ames_recv_cb); uv_udp_recv_start(&sam_u->wax_u, _ames_alloc, _ames_recv_cb);
@ -1302,7 +1302,7 @@ _ames_ef_turf(u3_ames* sam_u, u3_noun tuf)
u3z(tuf); u3z(tuf);
} }
else if ( (c3n == sam_u->pir_u->fak_o) && (0 == sam_u->dns_c) ) { else if ( (c3n == sam_u->pir_u->fak_o) && (0 == sam_u->dns_c) ) {
u3l_log("ames: turf: no domains\n"); u3l_log("ames: turf: no domains");
} }
// XX is this ever necessary? // XX is this ever necessary?
@ -1446,7 +1446,7 @@ _ames_io_kick(u3_auto* car_u, u3_noun wir, u3_noun cad)
ret_o = c3n; ret_o = c3n;
} }
else { else {
u3l_log("kick: strange send\r\n"); u3l_log("kick: strange send");
ret_o = _ames_kick_newt(sam_u, u3k(tag), u3k(dat)); ret_o = _ames_kick_newt(sam_u, u3k(tag), u3k(dat));
} }
} break; } break;
@ -1497,21 +1497,21 @@ _ames_io_info(u3_auto* car_u)
# define FLAG(a) ( (c3y == a) ? "&" : "|" ) # define FLAG(a) ( (c3y == a) ? "&" : "|" )
u3l_log(" config:\n"); u3l_log(" config:");
u3l_log(" filtering: %s\n", FLAG(sam_u->fig_u.fit_o)); u3l_log(" filtering: %s", FLAG(sam_u->fig_u.fit_o));
u3l_log(" can send: %s\n", FLAG(sam_u->fig_u.net_o)); u3l_log(" can send: %s", FLAG(sam_u->fig_u.net_o));
u3l_log(" can scry: %s\n", FLAG(sam_u->fig_u.see_o)); u3l_log(" can scry: %s", FLAG(sam_u->fig_u.see_o));
u3l_log(" counters:\n"); u3l_log(" counters:");
u3l_log(" dropped: %" PRIu64 "\n", sam_u->sat_u.dop_d); u3l_log(" dropped: %" PRIu64, sam_u->sat_u.dop_d);
u3l_log(" forwards dropped: %" PRIu64 "\n", sam_u->sat_u.fod_d); u3l_log(" forwards dropped: %" PRIu64, sam_u->sat_u.fod_d);
u3l_log(" forwards pending: %" PRIu64 "\n", sam_u->sat_u.foq_d); u3l_log(" forwards pending: %" PRIu64, sam_u->sat_u.foq_d);
u3l_log(" forwarded: %" PRIu64 "\n", sam_u->sat_u.fow_d); u3l_log(" forwarded: %" PRIu64, sam_u->sat_u.fow_d);
u3l_log(" filtered (hed): %" PRIu64 "\n", sam_u->sat_u.hed_d); u3l_log(" filtered (hed): %" PRIu64, sam_u->sat_u.hed_d);
u3l_log(" filtered (ver): %" PRIu64 "\n", sam_u->sat_u.vet_d); u3l_log(" filtered (ver): %" PRIu64, sam_u->sat_u.vet_d);
u3l_log(" filtered (mug): %" PRIu64 "\n", sam_u->sat_u.mut_d); u3l_log(" filtered (mug): %" PRIu64, sam_u->sat_u.mut_d);
u3l_log(" filtered (bod): %" PRIu64 "\n", sam_u->sat_u.bod_d); u3l_log(" filtered (bod): %" PRIu64, sam_u->sat_u.bod_d);
u3l_log(" crashed: %" PRIu64 "\n", sam_u->sat_u.fal_d); u3l_log(" crashed: %" PRIu64, sam_u->sat_u.fal_d);
u3l_log(" cached lanes: %u\n", u3h_wyt(sam_u->lax_p)); u3l_log(" cached lanes: %u", u3h_wyt(sam_u->lax_p));
} }
/* u3_ames_io_init(): initialize ames I/O. /* u3_ames_io_init(): initialize ames I/O.

4
pkg/urbit/vere/io/behn.c
View File

@ -48,7 +48,7 @@ _behn_wake_bail(u3_ovum* egg_u, u3_noun lud)
u3_auto_bail_slog(egg_u, lud); u3_auto_bail_slog(egg_u, lud);
u3_ovum_free(egg_u); u3_ovum_free(egg_u);
u3l_log("behn: timer failed; queue blocked\n"); u3l_log("behn: timer failed; queue blocked");
// XX review, add flag to continue? // XX review, add flag to continue?
// //
@ -149,7 +149,7 @@ _behn_born_bail(u3_ovum* egg_u, u3_noun lud)
u3_auto_bail_slog(egg_u, lud); u3_auto_bail_slog(egg_u, lud);
u3_ovum_free(egg_u); u3_ovum_free(egg_u);
u3l_log("behn: initialization failed\n"); u3l_log("behn: initialization failed");
// XX review, add flag to continue? // XX review, add flag to continue?
// //

10
pkg/urbit/vere/io/cttp.c
View File

@ -558,7 +558,7 @@ _cttp_creq_new(u3_cttp* ctp_u, c3_l num_l, u3_noun hes)
if ( c3n == u3r_du(unit_pul) ) { if ( c3n == u3r_du(unit_pul) ) {
c3_c* url_c = u3r_string(url); c3_c* url_c = u3r_string(url);
u3l_log("cttp: unable to parse url:\n %s\n", url_c); u3l_log("cttp: unable to parse url:\n %s", url_c);
c3_free(url_c); c3_free(url_c);
u3z(hes); u3z(hes);
return 0; return 0;
@ -735,7 +735,7 @@ _cttp_creq_fail(u3_creq* ceq_u, const c3_c* err_c)
// XX anything other than a 504? // XX anything other than a 504?
c3_w cod_w = 504; c3_w cod_w = 504;
u3l_log("http: fail (%d, %d): %s\r\n", ceq_u->num_l, cod_w, err_c); u3l_log("http: fail (%d, %d): %s", ceq_u->num_l, cod_w, err_c);
// XX include err_c as response body? // XX include err_c as response body?
_cttp_http_client_receive(ceq_u, cod_w, u3_nul, u3_nul); _cttp_http_client_receive(ceq_u, cod_w, u3_nul, u3_nul);
@ -1003,7 +1003,7 @@ _cttp_ef_http_client(u3_cttp* ctp_u, u3_noun tag, u3_noun dat)
if ( (c3n == u3r_cell(dat, &num, &req)) if ( (c3n == u3r_cell(dat, &num, &req))
|| (c3n == u3r_safe_word(num, &num_l)) ) || (c3n == u3r_safe_word(num, &num_l)) )
{ {
u3l_log("cttp: strange request\n"); u3l_log("cttp: strange request");
ret_o = c3n; ret_o = c3n;
} }
else if ( (ceq_u = _cttp_creq_new(ctp_u, num_l, u3k(req))) ) { else if ( (ceq_u = _cttp_creq_new(ctp_u, num_l, u3k(req))) ) {
@ -1018,7 +1018,7 @@ _cttp_ef_http_client(u3_cttp* ctp_u, u3_noun tag, u3_noun dat)
c3_l num_l; c3_l num_l;
if ( c3n == u3r_safe_word(dat, &num_l) ) { if ( c3n == u3r_safe_word(dat, &num_l) ) {
u3l_log("cttp: strange cancel-request\n"); u3l_log("cttp: strange cancel-request");
ret_o = c3n; ret_o = c3n;
} }
else if ( (ceq_u =_cttp_creq_find(ctp_u, num_l)) ) { else if ( (ceq_u =_cttp_creq_find(ctp_u, num_l)) ) {
@ -1032,7 +1032,7 @@ _cttp_ef_http_client(u3_cttp* ctp_u, u3_noun tag, u3_noun dat)
} }
} }
else { else {
u3l_log("cttp: strange effect (unknown type)\n"); u3l_log("cttp: strange effect (unknown type)");
ret_o = c3n; ret_o = c3n;
} }

14
pkg/urbit/vere/io/fore.c
View File

@ -10,7 +10,7 @@ static void
_fore_inject_bail(u3_ovum* egg_u, u3_noun lud) _fore_inject_bail(u3_ovum* egg_u, u3_noun lud)
{ {
u3_auto_bail_slog(egg_u, lud); u3_auto_bail_slog(egg_u, lud);
u3l_log("pier: injected event failed\n"); u3l_log("pier: injected event failed");
u3_ovum_free(egg_u); u3_ovum_free(egg_u);
} }
@ -21,7 +21,7 @@ static void
_fore_import_bail(u3_ovum* egg_u, u3_noun lud) _fore_import_bail(u3_ovum* egg_u, u3_noun lud)
{ {
u3_auto_bail_slog(egg_u, lud); u3_auto_bail_slog(egg_u, lud);
u3l_log("pier: import failed\n"); u3l_log("pier: import failed");
u3_ovum_free(egg_u); u3_ovum_free(egg_u);
} }
@ -37,20 +37,20 @@ _fore_inject(u3_auto* car_u, c3_c* pax_c)
u3_noun riw, cad, tar, wir; u3_noun riw, cad, tar, wir;
if ( c3n == u3r_cell(ovo, &riw, &cad) ) { if ( c3n == u3r_cell(ovo, &riw, &cad) ) {
u3l_log("pier: invalid ovum in -I\n"); u3l_log("pier: invalid ovum in -I");
} }
else if ( (c3n == u3a_is_cell(cad)) else if ( (c3n == u3a_is_cell(cad))
|| (c3n == u3a_is_atom(u3h(cad))) ) || (c3n == u3a_is_atom(u3h(cad))) )
{ {
u3l_log("pier: invalid card in -I ovum\n"); u3l_log("pier: invalid card in -I ovum");
} }
else if ( c3n == u3r_cell(riw, &tar, &wir) ) { else if ( c3n == u3r_cell(riw, &tar, &wir) ) {
u3l_log("pier: invalid wire in -I ovum\n"); u3l_log("pier: invalid wire in -I ovum");
} }
else if ( (c3n == u3a_is_atom(tar)) else if ( (c3n == u3a_is_atom(tar))
|| (1 < u3r_met(3, tar)) ) || (1 < u3r_met(3, tar)) )
{ {
u3l_log("pier: invalid target in -I wire\n"); u3l_log("pier: invalid target in -I wire");
} }
else { else {
{ {
@ -58,7 +58,7 @@ _fore_inject(u3_auto* car_u, c3_c* pax_c)
u3_noun ser = u3do("spat", u3k(riw)); u3_noun ser = u3do("spat", u3k(riw));
c3_c* wir_c = u3r_string(ser); c3_c* wir_c = u3r_string(ser);
u3l_log("pier: injecting %%%s event on %s\n", tag_c, wir_c); u3l_log("pier: injecting %%%s event on %s", tag_c, wir_c);
c3_free(tag_c); c3_free(tag_c);
c3_free(wir_c); c3_free(wir_c);

4
pkg/urbit/vere/io/hind.c
View File

@ -30,7 +30,7 @@ _hind_io_kick(u3_auto* car_u, u3_noun wir, u3_noun cad)
case c3__exit: { case c3__exit: {
ret_o = c3y; ret_o = c3y;
u3l_log("<<<goodbye>>>\n"); u3l_log("<<<goodbye>>>");
u3_pier_exit(car_u->pir_u); u3_pier_exit(car_u->pir_u);
} break; } break;
@ -44,7 +44,7 @@ _hind_io_kick(u3_auto* car_u, u3_noun wir, u3_noun cad)
case c3__vega: { case c3__vega: {
ret_o = c3y; ret_o = c3y;
u3l_log("<<<reset>>>\n"); u3l_log("<<<reset>>>");
} break; } break;
// NB: startup explicitly handled in pier.c // NB: startup explicitly handled in pier.c

74
pkg/urbit/vere/io/http.c
View File

@ -33,7 +33,7 @@ typedef struct _u3_h2o_serv {
void* gen_u; // response generator void* gen_u; // response generator
struct _u3_hcon* hon_u; // connection backlink struct _u3_hcon* hon_u; // connection backlink
struct _u3_hreq* nex_u; // next in connection's list struct _u3_hreq* nex_u; // next in connection's list
struct _u3_hreq* pre_u; // next in connection's list struct _u3_hreq* pre_u; // prev in connection's list
} u3_hreq; } u3_hreq;
/* u3_hcon: incoming http connection. /* u3_hcon: incoming http connection.
@ -48,7 +48,7 @@ typedef struct _u3_h2o_serv {
struct _u3_http* htp_u; // server backlink struct _u3_http* htp_u; // server backlink
struct _u3_hreq* req_u; // request list struct _u3_hreq* req_u; // request list
struct _u3_hcon* nex_u; // next in server's list struct _u3_hcon* nex_u; // next in server's list
struct _u3_hcon* pre_u; // next in server's list struct _u3_hcon* pre_u; // prev in server's list
} u3_hcon; } u3_hcon;
/* u3_http: http server. /* u3_http: http server.
@ -639,10 +639,10 @@ _http_start_respond(u3_hreq* req_u,
u3_noun data, u3_noun data,
u3_noun complete) u3_noun complete)
{ {
// u3l_log("start\n"); // u3l_log("start");
if ( u3_rsat_plan != req_u->sat_e ) { if ( u3_rsat_plan != req_u->sat_e ) {
//u3l_log("duplicate response\n"); //u3l_log("duplicate response");
return; return;
} }
@ -715,14 +715,14 @@ _http_continue_respond(u3_hreq* req_u,
u3_noun data, u3_noun data,
u3_noun complete) u3_noun complete)
{ {
// u3l_log("continue\n"); // u3l_log("continue");
// XX add sequence numbers for %continue effects? // XX add sequence numbers for %continue effects?
// Arvo does not (currently) guarantee effect idempotence!! // Arvo does not (currently) guarantee effect idempotence!!
// response has not yet been started // response has not yet been started
if ( u3_rsat_ripe != req_u->sat_e ) { if ( u3_rsat_ripe != req_u->sat_e ) {
// u3l_log("duplicate response\n"); // u3l_log("duplicate response");
return; return;
} }
@ -855,7 +855,7 @@ _http_seq_continue(void* vod_p, u3_noun nun)
_http_start_respond(req_u, 403, u3_nul, u3_nul, c3y); _http_start_respond(req_u, 403, u3_nul, u3_nul, c3y);
} }
else if ( u3_none == aut ) { else if ( u3_none == aut ) {
u3l_log("http: authentication scry failed\n"); u3l_log("http: authentication scry failed");
_http_start_respond(req_u, 500, u3_nul, u3_nul, c3y); _http_start_respond(req_u, 500, u3_nul, u3_nul, c3y);
} }
else { else {
@ -917,7 +917,7 @@ _http_rec_accept(h2o_handler_t* han_u, h2o_req_t* rec_u)
if ( u3_none == req ) { if ( u3_none == req ) {
if ( (u3C.wag_w & u3o_verbose) ) { if ( (u3C.wag_w & u3o_verbose) ) {
u3l_log("strange %.*s request\n", (int)rec_u->method.len, u3l_log("strange %.*s request", (int)rec_u->method.len,
rec_u->method.base); rec_u->method.base);
} }
c3_c* msg_c = "bad request"; c3_c* msg_c = "bad request";
@ -1007,7 +1007,7 @@ _http_conn_free(uv_handle_t* han_t)
noh_u = noh_u->nex_u; noh_u = noh_u->nex_u;
} }
u3l_log("http conn free %d of %u server %d\n", hon_u->coq_l, len_w, htp_u->sev_l); u3l_log("http conn free %d of %u server %d", hon_u->coq_l, len_w, htp_u->sev_l);
} }
#endif #endif
@ -1024,13 +1024,13 @@ _http_conn_free(uv_handle_t* han_t)
noh_u = noh_u->nex_u; noh_u = noh_u->nex_u;
} }
u3l_log("http conn free %u remaining\n", len_w); u3l_log("http conn free %u remaining", len_w);
} }
#endif #endif
if ( (0 == htp_u->hon_u) && (0 != h2o_u->ctx_u.shutdown_requested) ) { if ( (0 == htp_u->hon_u) && (0 != h2o_u->ctx_u.shutdown_requested) ) {
#if 0 #if 0
u3l_log("http conn free %d free server %d\n", hon_u->coq_l, htp_u->sev_l); u3l_log("http conn free %d free server %d", hon_u->coq_l, htp_u->sev_l);
#endif #endif
_http_serv_free(htp_u); _http_serv_free(htp_u);
} }
@ -1054,7 +1054,7 @@ _http_conn_new(u3_http* htp_u)
_http_conn_link(htp_u, hon_u); _http_conn_link(htp_u, hon_u);
#if 0 #if 0
u3l_log("http conn neww %d server %d\n", hon_u->coq_l, htp_u->sev_l); u3l_log("http conn neww %d server %d", hon_u->coq_l, htp_u->sev_l);
#endif #endif
return hon_u; return hon_u;
@ -1104,7 +1104,7 @@ _http_serv_unlink(u3_http* htp_u)
{ {
// XX link elsewhere initially, relink on start? // XX link elsewhere initially, relink on start?
#if 0 #if 0
u3l_log("http serv unlink %d\n", htp_u->sev_l); u3l_log("http serv unlink %d", htp_u->sev_l);
#endif #endif
u3_http* pre_u = htp_u->htd_u->htp_u; u3_http* pre_u = htp_u->htd_u->htp_u;
@ -1213,7 +1213,7 @@ http_serv_free_cb(uv_timer_t* tim_u)
u3_http* htp_u = tim_u->data; u3_http* htp_u = tim_u->data;
#if 0 #if 0
u3l_log("http serv free cb %d\n", htp_u->sev_l); u3l_log("http serv free cb %d", htp_u->sev_l);
#endif #endif
_http_serv_really_free(htp_u); _http_serv_really_free(htp_u);
@ -1227,7 +1227,7 @@ static void
_http_serv_free(u3_http* htp_u) _http_serv_free(u3_http* htp_u)
{ {
#if 0 #if 0
u3l_log("http serv free %d\n", htp_u->sev_l); u3l_log("http serv free %d", htp_u->sev_l);
#endif #endif
c3_assert( 0 == htp_u->hon_u ); c3_assert( 0 == htp_u->hon_u );
@ -1297,7 +1297,7 @@ _http_serv_close(u3_http* htp_u)
h2o_context_request_shutdown(&h2o_u->ctx_u); h2o_context_request_shutdown(&h2o_u->ctx_u);
#if 0 #if 0
u3l_log("http serv close %d %p\n", htp_u->sev_l, &htp_u->wax_u); u3l_log("http serv close %d %p", htp_u->sev_l, &htp_u->wax_u);
#endif #endif
uv_close((uv_handle_t*)&htp_u->wax_u, _http_serv_close_cb); uv_close((uv_handle_t*)&htp_u->wax_u, _http_serv_close_cb);
@ -1338,7 +1338,7 @@ _http_serv_accept(u3_http* htp_u)
if ( 0 != (sas_i = uv_accept((uv_stream_t*)&htp_u->wax_u, if ( 0 != (sas_i = uv_accept((uv_stream_t*)&htp_u->wax_u,
(uv_stream_t*)&hon_u->wax_u)) ) { (uv_stream_t*)&hon_u->wax_u)) ) {
if ( (u3C.wag_w & u3o_verbose) ) { if ( (u3C.wag_w & u3o_verbose) ) {
u3l_log("http: accept: %s\n", uv_strerror(sas_i)); u3l_log("http: accept: %s", uv_strerror(sas_i));
} }
uv_close((uv_handle_t*)&hon_u->wax_u, _http_conn_free); uv_close((uv_handle_t*)&hon_u->wax_u, _http_conn_free);
@ -1367,7 +1367,7 @@ _http_serv_listen_cb(uv_stream_t* str_u, c3_i sas_i)
u3_http* htp_u = (u3_http*)str_u; u3_http* htp_u = (u3_http*)str_u;
if ( 0 != sas_i ) { if ( 0 != sas_i ) {
u3l_log("http: listen_cb: %s\n", uv_strerror(sas_i)); u3l_log("http: listen_cb: %s", uv_strerror(sas_i));
} }
else { else {
_http_serv_accept(htp_u); _http_serv_accept(htp_u);
@ -1493,13 +1493,13 @@ _http_serv_start(u3_http* htp_u)
continue; continue;
} }
u3l_log("http: listen: %s\n", uv_strerror(sas_i)); u3l_log("http: listen: %s", uv_strerror(sas_i));
_http_serv_free(htp_u); _http_serv_free(htp_u);
return; return;
} }
u3l_log("http: %s live on %s://localhost:%d\n", u3l_log("http: %s live on %s://localhost:%d",
(c3y == htp_u->lop) ? "loopback" : "web interface", (c3y == htp_u->lop) ? "loopback" : "web interface",
(c3y == htp_u->sec) ? "https" : "http", (c3y == htp_u->sec) ? "https" : "http",
htp_u->por_s); htp_u->por_s);
@ -1557,9 +1557,10 @@ _http_init_tls(uv_buf_t key_u, uv_buf_t cer_u)
BIO_free(bio_u); BIO_free(bio_u);
if( 0 == sas_i ) { if( 0 == sas_i ) {
u3l_log("http: load private key failed:\n"); u3l_log("http: load private key failed:");
ERR_print_errors_fp(u3_term_io_hija()); FILE* fil_u = u3_term_io_hija();
u3_term_io_loja(1); ERR_print_errors_fp(fil_u);
u3_term_io_loja(1, fil_u);
SSL_CTX_free(tls_u); SSL_CTX_free(tls_u);
@ -1575,9 +1576,10 @@ _http_init_tls(uv_buf_t key_u, uv_buf_t cer_u)
X509_free(xer_u); X509_free(xer_u);
if( 0 == sas_i ) { if( 0 == sas_i ) {
u3l_log("http: load certificate failed:\n"); u3l_log("http: load certificate failed:");
ERR_print_errors_fp(u3_term_io_hija()); FILE* fil_u = u3_term_io_hija();
u3_term_io_loja(1); ERR_print_errors_fp(fil_u);
u3_term_io_loja(1,fil_u);
BIO_free(bio_u); BIO_free(bio_u);
SSL_CTX_free(tls_u); SSL_CTX_free(tls_u);
@ -1656,19 +1658,19 @@ _http_search_req(u3_httd* htd_u,
if ( !(htp_u = _http_serv_find(htd_u, sev_l)) ) { if ( !(htp_u = _http_serv_find(htd_u, sev_l)) ) {
if ( bug_w ) { if ( bug_w ) {
u3l_log("http: server not found: %x\r\n", sev_l); u3l_log("http: server not found: %x", sev_l);
} }
return 0; return 0;
} }
else if ( !(hon_u = _http_conn_find(htp_u, coq_l)) ) { else if ( !(hon_u = _http_conn_find(htp_u, coq_l)) ) {
if ( bug_w ) { if ( bug_w ) {
u3l_log("http: connection not found: %x/%d\r\n", sev_l, coq_l); u3l_log("http: connection not found: %x/%d", sev_l, coq_l);
} }
return 0; return 0;
} }
else if ( !(req_u = _http_req_find(hon_u, seq_l)) ) { else if ( !(req_u = _http_req_find(hon_u, seq_l)) ) {
if ( bug_w ) { if ( bug_w ) {
u3l_log("http: request not found: %x/%d/%d\r\n", u3l_log("http: request not found: %x/%d/%d",
sev_l, coq_l, seq_l); sev_l, coq_l, seq_l);
} }
return 0; return 0;
@ -1760,7 +1762,7 @@ _http_serv_restart(u3_httd* htd_u)
_http_serv_start_all(htd_u); _http_serv_start_all(htd_u);
} }
else { else {
u3l_log("http: restarting servers to apply configuration\n"); u3l_log("http: restarting servers to apply configuration");
while ( 0 != htp_u ) { while ( 0 != htp_u ) {
if ( c3y == htp_u->liv ) { if ( c3y == htp_u->liv ) {
@ -1812,7 +1814,7 @@ u3_http_ef_form(u3_httd* htd_u, u3_noun fig)
!( c3y == pro || c3n == pro ) || !( c3y == pro || c3n == pro ) ||
!( c3y == log || c3n == log ) || !( c3y == log || c3n == log ) ||
!( c3y == red || c3n == red ) ) { !( c3y == red || c3n == red ) ) {
u3l_log("http: form: invalid card\n"); u3l_log("http: form: invalid card");
u3z(fig); u3z(fig);
return; return;
} }
@ -1907,14 +1909,14 @@ _http_ef_http_server(u3_httd* htd_u,
_http_continue_respond(req_u, u3k(data), u3k(complete)); _http_continue_respond(req_u, u3k(data), u3k(complete));
} }
else if (c3y == u3r_sing_c("cancel", u3h(response))) { else if (c3y == u3r_sing_c("cancel", u3h(response))) {
u3l_log("http: %%cancel not handled yet\n"); u3l_log("http: %%cancel not handled yet");
} }
else { else {
u3l_log("http: strange response\n"); u3l_log("http: strange response");
} }
} }
else { else {
u3l_log("http: strange response\n"); u3l_log("http: strange response");
} }
} }
@ -2028,7 +2030,7 @@ _reck_mole(u3_noun fot,
if ( (c3n == u3r_cell(uco, &p_uco, &q_uco)) || if ( (c3n == u3r_cell(uco, &p_uco, &q_uco)) ||
(u3_nul != p_uco) ) (u3_nul != p_uco) )
{ {
u3l_log("strange mole %s\n", u3r_string(san)); u3l_log("strange mole %s", u3r_string(san));
u3z(fot); u3z(uco); return c3n; u3z(fot); u3z(uco); return c3n;
} }
@ -2166,7 +2168,7 @@ _http_io_info(u3_auto* car_u)
sec_y++; sec_y++;
seq_u = seq_u->nex_u; seq_u = seq_u->nex_u;
} }
u3l_log(" open slogstreams: %d\n", sec_y); u3l_log(" open slogstreams: %d", sec_y);
} }
/* u3_http_io_init(): initialize http I/O. /* u3_http_io_init(): initialize http I/O.

606
pkg/urbit/vere/io/term.c
View File

File diff suppressed because it is too large Load Diff

102
pkg/urbit/vere/io/unix.c
View File

@ -162,35 +162,35 @@ _unix_rm_r_cb(const c3_c* pax_c,
{ {
switch ( typeflag ) { switch ( typeflag ) {
default: default:
u3l_log("bad file type in rm_r: %s\r\n", pax_c); u3l_log("bad file type in rm_r: %s", pax_c);
break; break;
case FTW_F: case FTW_F:
if ( 0 != unlink(pax_c) && ENOENT != errno ) { if ( 0 != unlink(pax_c) && ENOENT != errno ) {
u3l_log("error unlinking (in rm_r) %s: %s\n", u3l_log("error unlinking (in rm_r) %s: %s",
pax_c, strerror(errno)); pax_c, strerror(errno));
c3_assert(0); c3_assert(0);
} }
break; break;
case FTW_D: case FTW_D:
u3l_log("shouldn't have gotten pure directory: %s\r\n", pax_c); u3l_log("shouldn't have gotten pure directory: %s", pax_c);
break; break;
case FTW_DNR: case FTW_DNR:
u3l_log("couldn't read directory: %s\r\n", pax_c); u3l_log("couldn't read directory: %s", pax_c);
break; break;
case FTW_NS: case FTW_NS:
u3l_log("couldn't stat path: %s\r\n", pax_c); u3l_log("couldn't stat path: %s", pax_c);
break; break;
case FTW_DP: case FTW_DP:
if ( 0 != rmdir(pax_c) && ENOENT != errno ) { if ( 0 != rmdir(pax_c) && ENOENT != errno ) {
u3l_log("error rmdiring %s: %s\n", pax_c, strerror(errno)); u3l_log("error rmdiring %s: %s", pax_c, strerror(errno));
c3_assert(0); c3_assert(0);
} }
break; break;
case FTW_SL: case FTW_SL:
u3l_log("got symbolic link: %s\r\n", pax_c); u3l_log("got symbolic link: %s", pax_c);
break; break;
case FTW_SLN: case FTW_SLN:
u3l_log("got nonexistent symbolic link: %s\r\n", pax_c); u3l_log("got nonexistent symbolic link: %s", pax_c);
break; break;
} }
@ -204,7 +204,7 @@ _unix_rm_r(c3_c* pax_c)
{ {
if ( 0 > nftw(pax_c, _unix_rm_r_cb, 100, FTW_DEPTH | FTW_PHYS ) if ( 0 > nftw(pax_c, _unix_rm_r_cb, 100, FTW_DEPTH | FTW_PHYS )
&& ENOENT != errno) { && ENOENT != errno) {
u3l_log("rm_r error on %s: %s\r\n", pax_c, strerror(errno)); u3l_log("rm_r error on %s: %s", pax_c, strerror(errno));
} }
} }
@ -214,7 +214,7 @@ static void
_unix_mkdir(c3_c* pax_c) _unix_mkdir(c3_c* pax_c)
{ {
if ( 0 != mkdir(pax_c, 0755) && EEXIST != errno) { if ( 0 != mkdir(pax_c, 0755) && EEXIST != errno) {
u3l_log("error mkdiring %s: %s\n", pax_c, strerror(errno)); u3l_log("error mkdiring %s: %s", pax_c, strerror(errno));
c3_assert(0); c3_assert(0);
} }
} }
@ -231,7 +231,7 @@ _unix_write_file_hard(c3_c* pax_c, u3_noun mim)
u3_noun dat = u3t(u3t(mim)); u3_noun dat = u3t(u3t(mim));
if ( fid_i < 0 ) { if ( fid_i < 0 ) {
u3l_log("error opening %s for writing: %s\r\n", u3l_log("error opening %s for writing: %s",
pax_c, strerror(errno)); pax_c, strerror(errno));
u3z(mim); u3z(mim);
return 0; return 0;
@ -247,7 +247,7 @@ _unix_write_file_hard(c3_c* pax_c, u3_noun mim)
rit_w = write(fid_i, dat_y, siz_w); rit_w = write(fid_i, dat_y, siz_w);
if ( rit_w != siz_w ) { if ( rit_w != siz_w ) {
u3l_log("error writing %s: %s\r\n", u3l_log("error writing %s: %s",
pax_c, strerror(errno)); pax_c, strerror(errno));
mug_w = 0; mug_w = 0;
} }
@ -277,7 +277,7 @@ _unix_write_file_soft(u3_ufil* fil_u, u3_noun mim)
goto _unix_write_file_soft_go; goto _unix_write_file_soft_go;
} }
else { else {
u3l_log("error opening file (soft) %s: %s\r\n", u3l_log("error opening file (soft) %s: %s",
fil_u->pax_c, strerror(errno)); fil_u->pax_c, strerror(errno));
u3z(mim); u3z(mim);
return; return;
@ -290,17 +290,17 @@ _unix_write_file_soft(u3_ufil* fil_u, u3_noun mim)
red_ws = read(fid_i, old_y, len_ws); red_ws = read(fid_i, old_y, len_ws);
if ( close(fid_i) < 0 ) { if ( close(fid_i) < 0 ) {
u3l_log("error closing file (soft) %s: %s\r\n", u3l_log("error closing file (soft) %s: %s",
fil_u->pax_c, strerror(errno)); fil_u->pax_c, strerror(errno));
} }
if ( len_ws != red_ws ) { if ( len_ws != red_ws ) {
if ( red_ws < 0 ) { if ( red_ws < 0 ) {
u3l_log("error reading file (soft) %s: %s\r\n", u3l_log("error reading file (soft) %s: %s",
fil_u->pax_c, strerror(errno)); fil_u->pax_c, strerror(errno));
} }
else { else {
u3l_log("wrong # of bytes read in file %s: %d %d\r\n", u3l_log("wrong # of bytes read in file %s: %d %d",
fil_u->pax_c, len_ws, red_ws); fil_u->pax_c, len_ws, red_ws);
} }
c3_free(old_y); c3_free(old_y);
@ -376,7 +376,7 @@ _unix_scan_mount_point(u3_unix* unx_u, u3_umon* mon_u)
{ {
DIR* rid_u = opendir(mon_u->dir_u.pax_c); DIR* rid_u = opendir(mon_u->dir_u.pax_c);
if ( !rid_u ) { if ( !rid_u ) {
u3l_log("error opening pier directory: %s: %s\r\n", u3l_log("error opening pier directory: %s: %s",
mon_u->dir_u.pax_c, strerror(errno)); mon_u->dir_u.pax_c, strerror(errno));
return; return;
} }
@ -389,7 +389,7 @@ _unix_scan_mount_point(u3_unix* unx_u, u3_umon* mon_u)
c3_w err_w; c3_w err_w;
if ( 0 != (err_w = u3_readdir_r(rid_u, &ent_u, &out_u)) ) { if ( 0 != (err_w = u3_readdir_r(rid_u, &ent_u, &out_u)) ) {
u3l_log("erroring loading pier directory %s: %s\r\n", u3l_log("erroring loading pier directory %s: %s",
mon_u->dir_u.pax_c, strerror(errno)); mon_u->dir_u.pax_c, strerror(errno));
c3_assert(0); c3_assert(0);
@ -409,7 +409,7 @@ _unix_scan_mount_point(u3_unix* unx_u, u3_umon* mon_u)
struct stat buf_u; struct stat buf_u;
if ( 0 != stat(pax_c, &buf_u) ) { if ( 0 != stat(pax_c, &buf_u) ) {
u3l_log("can't stat pier directory %s: %s\r\n", u3l_log("can't stat pier directory %s: %s",
mon_u->dir_u.pax_c, strerror(errno)); mon_u->dir_u.pax_c, strerror(errno));
c3_free(pax_c); c3_free(pax_c);
continue; continue;
@ -453,7 +453,7 @@ static void
_unix_free_file(u3_ufil *fil_u) _unix_free_file(u3_ufil *fil_u)
{ {
if ( 0 != unlink(fil_u->pax_c) && ENOENT != errno ) { if ( 0 != unlink(fil_u->pax_c) && ENOENT != errno ) {
u3l_log("error unlinking %s: %s\n", fil_u->pax_c, strerror(errno)); u3l_log("error unlinking %s: %s", fil_u->pax_c, strerror(errno));
c3_assert(0); c3_assert(0);
} }
@ -565,7 +565,7 @@ _unix_delete_mount_point(u3_unix* unx_u, u3_noun mon)
mon_u = unx_u->mon_u; mon_u = unx_u->mon_u;
if ( !mon_u ) { if ( !mon_u ) {
u3l_log("mount point already gone: %s\r\n", nam_c); u3l_log("mount point already gone: %s", nam_c);
goto _delete_mount_point_out; goto _delete_mount_point_out;
} }
if ( 0 == strcmp(nam_c, mon_u->nam_c) ) { if ( 0 == strcmp(nam_c, mon_u->nam_c) ) {
@ -581,7 +581,7 @@ _unix_delete_mount_point(u3_unix* unx_u, u3_noun mon)
} }
if ( !mon_u->nex_u ) { if ( !mon_u->nex_u ) {
u3l_log("mount point already gone: %s\r\n", nam_c); u3l_log("mount point already gone: %s", nam_c);
goto _delete_mount_point_out; goto _delete_mount_point_out;
} }
@ -699,7 +699,7 @@ _unix_update_file(u3_unix* unx_u, u3_ufil* fil_u)
return u3nc(u3nc(_unix_string_to_path(unx_u, fil_u->pax_c), u3_nul), u3_nul); return u3nc(u3nc(_unix_string_to_path(unx_u, fil_u->pax_c), u3_nul), u3_nul);
} }
else { else {
u3l_log("error opening file %s: %s\r\n", u3l_log("error opening file %s: %s",
fil_u->pax_c, strerror(errno)); fil_u->pax_c, strerror(errno));
return u3_nul; return u3_nul;
} }
@ -711,17 +711,17 @@ _unix_update_file(u3_unix* unx_u, u3_ufil* fil_u)
red_ws = read(fid_i, dat_y, len_ws); red_ws = read(fid_i, dat_y, len_ws);
if ( close(fid_i) < 0 ) { if ( close(fid_i) < 0 ) {
u3l_log("error closing file %s: %s\r\n", u3l_log("error closing file %s: %s",
fil_u->pax_c, strerror(errno)); fil_u->pax_c, strerror(errno));
} }
if ( len_ws != red_ws ) { if ( len_ws != red_ws ) {
if ( red_ws < 0 ) { if ( red_ws < 0 ) {
u3l_log("error reading file %s: %s\r\n", u3l_log("error reading file %s: %s",
fil_u->pax_c, strerror(errno)); fil_u->pax_c, strerror(errno));
} }
else { else {
u3l_log("wrong # of bytes read in file %s: %d %d\r\n", u3l_log("wrong # of bytes read in file %s: %d %d",
fil_u->pax_c, len_ws, red_ws); fil_u->pax_c, len_ws, red_ws);
} }
c3_free(dat_y); c3_free(dat_y);
@ -790,7 +790,7 @@ _unix_update_dir(u3_unix* unx_u, u3_udir* dir_u)
if ( (fid_i < 0) || (fstat(fid_i, &buf_u) < 0) ) { if ( (fid_i < 0) || (fstat(fid_i, &buf_u) < 0) ) {
if ( ENOENT != errno ) { if ( ENOENT != errno ) {
u3l_log("_unix_update_dir: error opening file %s: %s\r\n", u3l_log("_unix_update_dir: error opening file %s: %s",
nod_u->pax_c, strerror(errno)); nod_u->pax_c, strerror(errno));
} }
@ -800,7 +800,7 @@ _unix_update_dir(u3_unix* unx_u, u3_udir* dir_u)
} }
else { else {
if ( close(fid_i) < 0 ) { if ( close(fid_i) < 0 ) {
u3l_log("_unix_update_dir: error closing file %s: %s\r\n", u3l_log("_unix_update_dir: error closing file %s: %s",
nod_u->pax_c, strerror(errno)); nod_u->pax_c, strerror(errno));
} }
@ -815,7 +815,7 @@ _unix_update_dir(u3_unix* unx_u, u3_udir* dir_u)
DIR* rid_u = opendir(dir_u->pax_c); DIR* rid_u = opendir(dir_u->pax_c);
if ( !rid_u ) { if ( !rid_u ) {
u3l_log("error opening directory %s: %s\r\n", u3l_log("error opening directory %s: %s",
dir_u->pax_c, strerror(errno)); dir_u->pax_c, strerror(errno));
c3_assert(0); c3_assert(0);
} }
@ -827,7 +827,7 @@ _unix_update_dir(u3_unix* unx_u, u3_udir* dir_u)
if ( (err_w = u3_readdir_r(rid_u, &ent_u, &out_u)) != 0 ) { if ( (err_w = u3_readdir_r(rid_u, &ent_u, &out_u)) != 0 ) {
u3l_log("error loading directory %s: %s\r\n", u3l_log("error loading directory %s: %s",
dir_u->pax_c, strerror(err_w)); dir_u->pax_c, strerror(err_w));
c3_assert(0); c3_assert(0);
} }
@ -843,7 +843,7 @@ _unix_update_dir(u3_unix* unx_u, u3_udir* dir_u)
struct stat buf_u; struct stat buf_u;
if ( 0 != stat(pax_c, &buf_u) ) { if ( 0 != stat(pax_c, &buf_u) ) {
u3l_log("can't stat %s: %s\r\n", pax_c, strerror(errno)); u3l_log("can't stat %s: %s", pax_c, strerror(errno));
c3_free(pax_c); c3_free(pax_c);
continue; continue;
} }
@ -853,13 +853,13 @@ _unix_update_dir(u3_unix* unx_u, u3_udir* dir_u)
if ( 0 == strcmp(pax_c, nod_u->pax_c) ) { if ( 0 == strcmp(pax_c, nod_u->pax_c) ) {
if ( S_ISDIR(buf_u.st_mode) ) { if ( S_ISDIR(buf_u.st_mode) ) {
if ( c3n == nod_u->dir ) { if ( c3n == nod_u->dir ) {
u3l_log("not a directory: %s\r\n", nod_u->pax_c); u3l_log("not a directory: %s", nod_u->pax_c);
c3_assert(0); c3_assert(0);
} }
} }
else { else {
if ( c3y == nod_u->dir ) { if ( c3y == nod_u->dir ) {
u3l_log("not a file: %s\r\n", nod_u->pax_c); u3l_log("not a file: %s", nod_u->pax_c);
c3_assert(0); c3_assert(0);
} }
} }
@ -894,7 +894,7 @@ _unix_update_dir(u3_unix* unx_u, u3_udir* dir_u)
} }
if ( closedir(rid_u) < 0 ) { if ( closedir(rid_u) < 0 ) {
u3l_log("error closing directory %s: %s\r\n", u3l_log("error closing directory %s: %s",
dir_u->pax_c, strerror(errno)); dir_u->pax_c, strerror(errno));
} }
@ -965,7 +965,7 @@ _unix_initial_update_file(c3_c* pax_c, c3_c* bas_c)
return u3_nul; return u3_nul;
} }
else { else {
u3l_log("error opening initial file %s: %s\r\n", u3l_log("error opening initial file %s: %s",
pax_c, strerror(errno)); pax_c, strerror(errno));
return u3_nul; return u3_nul;
} }
@ -977,17 +977,17 @@ _unix_initial_update_file(c3_c* pax_c, c3_c* bas_c)
red_ws = read(fid_i, dat_y, len_ws); red_ws = read(fid_i, dat_y, len_ws);
if ( close(fid_i) < 0 ) { if ( close(fid_i) < 0 ) {
u3l_log("error closing initial file %s: %s\r\n", u3l_log("error closing initial file %s: %s",
pax_c, strerror(errno)); pax_c, strerror(errno));
} }
if ( len_ws != red_ws ) { if ( len_ws != red_ws ) {
if ( red_ws < 0 ) { if ( red_ws < 0 ) {
u3l_log("error reading initial file %s: %s\r\n", u3l_log("error reading initial file %s: %s",
pax_c, strerror(errno)); pax_c, strerror(errno));
} }
else { else {
u3l_log("wrong # of bytes read in initial file %s: %d %d\r\n", u3l_log("wrong # of bytes read in initial file %s: %d %d",
pax_c, len_ws, red_ws); pax_c, len_ws, red_ws);
} }
c3_free(dat_y); c3_free(dat_y);
@ -1015,7 +1015,7 @@ _unix_initial_update_dir(c3_c* pax_c, c3_c* bas_c)
DIR* rid_u = opendir(pax_c); DIR* rid_u = opendir(pax_c);
if ( !rid_u ) { if ( !rid_u ) {
u3l_log("error opening initial directory: %s: %s\r\n", u3l_log("error opening initial directory: %s: %s",
pax_c, strerror(errno)); pax_c, strerror(errno));
return u3_nul; return u3_nul;
} }
@ -1026,7 +1026,7 @@ _unix_initial_update_dir(c3_c* pax_c, c3_c* bas_c)
c3_w err_w; c3_w err_w;
if ( 0 != (err_w = u3_readdir_r(rid_u, &ent_u, &out_u)) ) { if ( 0 != (err_w = u3_readdir_r(rid_u, &ent_u, &out_u)) ) {
u3l_log("error loading initial directory %s: %s\r\n", u3l_log("error loading initial directory %s: %s",
pax_c, strerror(errno)); pax_c, strerror(errno));
c3_assert(0); c3_assert(0);
@ -1043,7 +1043,7 @@ _unix_initial_update_dir(c3_c* pax_c, c3_c* bas_c)
struct stat buf_u; struct stat buf_u;
if ( 0 != stat(pox_c, &buf_u) ) { if ( 0 != stat(pox_c, &buf_u) ) {
u3l_log("initial can't stat %s: %s\r\n", u3l_log("initial can't stat %s: %s",
pox_c, strerror(errno)); pox_c, strerror(errno));
c3_free(pox_c); c3_free(pox_c);
continue; continue;
@ -1061,7 +1061,7 @@ _unix_initial_update_dir(c3_c* pax_c, c3_c* bas_c)
} }
if ( closedir(rid_u) < 0 ) { if ( closedir(rid_u) < 0 ) {
u3l_log("error closing initial directory %s: %s\r\n", u3l_log("error closing initial directory %s: %s",
pax_c, strerror(errno)); pax_c, strerror(errno));
} }
@ -1152,16 +1152,16 @@ _unix_sync_change(u3_unix* unx_u, u3_udir* dir_u, u3_noun pax, u3_noun mim)
if ( c3n == u3du(pax) ) { if ( c3n == u3du(pax) ) {
if ( u3_nul == pax ) { if ( u3_nul == pax ) {
u3l_log("can't sync out file as top-level, strange\r\n"); u3l_log("can't sync out file as top-level, strange");
} }
else { else {
u3l_log("sync out: bad path\r\n"); u3l_log("sync out: bad path");
} }
u3z(pax); u3z(mim); u3z(pax); u3z(mim);
return; return;
} }
else if ( c3n == u3du(u3t(pax)) ) { else if ( c3n == u3du(u3t(pax)) ) {
u3l_log("can't sync out file as top-level, strangely\r\n"); u3l_log("can't sync out file as top-level, strangely");
u3z(pax); u3z(mim); u3z(pax); u3z(mim);
} }
else { else {
@ -1191,7 +1191,7 @@ _unix_sync_change(u3_unix* unx_u, u3_udir* dir_u, u3_noun pax, u3_noun mim)
} }
if ( c3n == nod_u->dir ) { if ( c3n == nod_u->dir ) {
u3l_log("weird, we got a file when we weren't expecting to\r\n"); u3l_log("weird, we got a file when we weren't expecting to");
c3_assert(0); c3_assert(0);
} }
@ -1274,7 +1274,7 @@ u3_unix_acquire(c3_c* pax_c)
if ( NULL != (loq_u = fopen(paf_c, "r")) ) { if ( NULL != (loq_u = fopen(paf_c, "r")) ) {
if ( 1 != fscanf(loq_u, "%" SCNu32, &pid_w) ) { if ( 1 != fscanf(loq_u, "%" SCNu32, &pid_w) ) {
u3l_log("lockfile %s is corrupt!\n", paf_c); u3l_log("lockfile %s is corrupt!", paf_c);
kill(getpid(), SIGTERM); kill(getpid(), SIGTERM);
sleep(1); c3_assert(0); sleep(1); c3_assert(0);
} }
@ -1282,7 +1282,7 @@ u3_unix_acquire(c3_c* pax_c)
c3_w i_w; c3_w i_w;
if ( -1 != kill(pid_w, SIGTERM) ) { if ( -1 != kill(pid_w, SIGTERM) ) {
u3l_log("unix: stopping process %d, live in %s...\n", u3l_log("unix: stopping process %d, live in %s...",
pid_w, pax_c); pid_w, pax_c);
for ( i_w = 0; i_w < 16; i_w++ ) { for ( i_w = 0; i_w < 16; i_w++ ) {
@ -1300,10 +1300,10 @@ u3_unix_acquire(c3_c* pax_c)
} }
} }
if ( 16 == i_w ) { if ( 16 == i_w ) {
u3l_log("unix: process %d seems unkillable!\n", pid_w); u3l_log("unix: process %d seems unkillable!", pid_w);
c3_assert(0); c3_assert(0);
} }
u3l_log("unix: stopped old process %u\n", pid_w); u3l_log("unix: stopped old process %u", pid_w);
} }
} }
fclose(loq_u); fclose(loq_u);
@ -1311,7 +1311,7 @@ u3_unix_acquire(c3_c* pax_c)
} }
if ( NULL == (loq_u = fopen(paf_c, "w")) ) { if ( NULL == (loq_u = fopen(paf_c, "w")) ) {
u3l_log("unix: unable to open %s\n", paf_c); u3l_log("unix: unable to open %s", paf_c);
c3_assert(0); c3_assert(0);
} }

46
pkg/urbit/vere/king.c
View File

@ -244,7 +244,7 @@ _king_get_atom(c3_c* url_c)
uv_buf_t buf_u = uv_buf_init(c3_malloc(1), 0); uv_buf_t buf_u = uv_buf_init(c3_malloc(1), 0);
if ( !(curl = curl_easy_init()) ) { if ( !(curl = curl_easy_init()) ) {
u3l_log("failed to initialize libcurl\n"); u3l_log("failed to initialize libcurl");
exit(1); exit(1);
} }
@ -259,13 +259,13 @@ _king_get_atom(c3_c* url_c)
// XX retry? // XX retry?
// //
if ( CURLE_OK != result ) { if ( CURLE_OK != result ) {
u3l_log("failed to fetch %s: %s\n", u3l_log("failed to fetch %s: %s",
url_c, curl_easy_strerror(result)); url_c, curl_easy_strerror(result));
u3_king_bail(); u3_king_bail();
exit(1); exit(1);
} }
if ( 300 <= cod_l ) { if ( 300 <= cod_l ) {
u3l_log("error fetching %s: HTTP %ld\n", url_c, cod_l); u3l_log("error fetching %s: HTTP %ld", url_c, cod_l);
u3_king_bail(); u3_king_bail();
exit(1); exit(1);
} }
@ -291,12 +291,12 @@ _get_cmd_output(c3_c *cmd_c, c3_c *out_c, c3_w len_c)
{ {
FILE *fp = popen(cmd_c, "r"); FILE *fp = popen(cmd_c, "r");
if ( NULL == fp ) { if ( NULL == fp ) {
u3l_log("'%s' failed\n", cmd_c); u3l_log("'%s' failed", cmd_c);
exit(1); exit(1);
} }
if ( NULL == fgets(out_c, len_c, fp) ) { if ( NULL == fgets(out_c, len_c, fp) ) {
u3l_log("'%s' produced no output\n", cmd_c); u3l_log("'%s' produced no output", cmd_c);
exit(1); exit(1);
} }
@ -329,7 +329,7 @@ _git_pill_url(c3_c *out_c, c3_c *arv_c)
assert(NULL != arv_c); assert(NULL != arv_c);
if ( 0 != system("which git >> /dev/null") ) { if ( 0 != system("which git >> /dev/null") ) {
u3l_log("boot: could not find git executable\r\n"); u3l_log("boot: could not find git executable");
exit(1); exit(1);
} }
@ -346,7 +346,7 @@ _boothack_pill(void)
u3_noun pil; u3_noun pil;
if ( 0 != u3_Host.ops_u.pil_c ) { if ( 0 != u3_Host.ops_u.pil_c ) {
u3l_log("boot: loading pill %s\r\n", u3_Host.ops_u.pil_c); u3l_log("boot: loading pill %s", u3_Host.ops_u.pil_c);
pil = u3m_file(u3_Host.ops_u.pil_c); pil = u3m_file(u3_Host.ops_u.pil_c);
} }
else { else {
@ -362,12 +362,12 @@ _boothack_pill(void)
strcpy(url_c, u3_Host.ops_u.url_c); strcpy(url_c, u3_Host.ops_u.url_c);
} }
u3l_log("boot: downloading pill %s\r\n", url_c); u3l_log("boot: downloading pill %s", url_c);
pil = _king_get_atom(url_c); pil = _king_get_atom(url_c);
} }
if ( 0 != u3_Host.ops_u.arv_c ) { if ( 0 != u3_Host.ops_u.arv_c ) {
u3l_log("boot: preparing filesystem from %s\r\n", u3l_log("boot: preparing filesystem from %s",
u3_Host.ops_u.arv_c); u3_Host.ops_u.arv_c);
arv = u3nc(u3_nul, u3_unix_initial_into_card(u3_Host.ops_u.arv_c)); arv = u3nc(u3_nul, u3_unix_initial_into_card(u3_Host.ops_u.arv_c));
} }
@ -388,7 +388,7 @@ _boothack_key(u3_noun kef)
if ( u3_nul == des ) { if ( u3_nul == des ) {
c3_c* kef_c = u3r_string(kef); c3_c* kef_c = u3r_string(kef);
u3l_log("dawn: invalid private keys: %s\r\n", kef_c); u3l_log("dawn: invalid private keys: %s", kef_c);
c3_free(kef_c); c3_free(kef_c);
exit(1); exit(1);
} }
@ -397,7 +397,7 @@ _boothack_key(u3_noun kef)
// //
u3_noun pro = u3m_soft(0, u3ke_cue, u3k(u3t(des))); u3_noun pro = u3m_soft(0, u3ke_cue, u3k(u3t(des)));
if ( u3_blip != u3h(pro) ) { if ( u3_blip != u3h(pro) ) {
u3l_log("dawn: unable to cue keyfile\r\n"); u3l_log("dawn: unable to cue keyfile");
exit(1); exit(1);
} }
seed = u3k(u3t(pro)); seed = u3k(u3t(pro));
@ -420,7 +420,7 @@ _boothack_key(u3_noun kef)
u3_noun whu = u3dc("slaw", 'p', u3k(woh)); u3_noun whu = u3dc("slaw", 'p', u3k(woh));
if ( u3_nul == whu ) { if ( u3_nul == whu ) {
u3l_log("dawn: invalid ship specified with -w %s\r\n", u3l_log("dawn: invalid ship specified with -w %s",
u3_Host.ops_u.who_c); u3_Host.ops_u.who_c);
exit(1); exit(1);
} }
@ -430,7 +430,7 @@ _boothack_key(u3_noun kef)
{ {
u3_noun how = u3dc("scot", 'p', u3k(ship)); u3_noun how = u3dc("scot", 'p', u3k(ship));
c3_c* how_c = u3r_string(u3k(how)); c3_c* how_c = u3r_string(u3k(how));
u3l_log("dawn: mismatch between -w %s and -K %s\r\n", u3l_log("dawn: mismatch between -w %s and -K %s",
u3_Host.ops_u.who_c, how_c); u3_Host.ops_u.who_c, how_c);
u3z(how); u3z(how);
@ -461,7 +461,7 @@ _boothack_doom(void)
u3_noun whu = u3dc("slaw", 'p', u3k(fak)); u3_noun whu = u3dc("slaw", 'p', u3k(fak));
if ( u3_nul == whu ) { if ( u3_nul == whu ) {
u3l_log("boot: malformed -F ship %s\r\n", u3_Host.ops_u.fak_c); u3l_log("boot: malformed -F ship %s", u3_Host.ops_u.fak_c);
exit(1); exit(1);
} }
@ -495,7 +495,7 @@ _boothack_doom(void)
kef = u3i_string(u3_Host.ops_u.gen_c); kef = u3i_string(u3_Host.ops_u.gen_c);
} }
else { else {
u3l_log("boot: must specify a key with -k or -G\r\n"); u3l_log("boot: must specify a key with -k or -G");
exit(1); exit(1);
} }
@ -590,7 +590,7 @@ _king_sign_cb(uv_signal_t* sil_u, c3_i num_i)
{ {
switch ( num_i ) { switch ( num_i ) {
default: { default: {
u3l_log("\r\nmysterious signal %d\r\n", num_i); u3l_log("\r\nmysterious signal %d", num_i);
break; break;
} }
@ -600,7 +600,7 @@ _king_sign_cb(uv_signal_t* sil_u, c3_i num_i)
} }
case SIGINT: { case SIGINT: {
u3l_log("\r\ninterrupt\r\n"); u3l_log("\r\ninterrupt");
u3_term_ef_ctlc(); u3_term_ef_ctlc();
#if defined(U3_OS_mingw) #if defined(U3_OS_mingw)
@ -703,7 +703,7 @@ _king_boot_ivory(void)
if ( u3_Host.ops_u.lit_c ) { if ( u3_Host.ops_u.lit_c ) {
if ( c3n == u3u_mmap_read("lite", u3_Host.ops_u.lit_c, &len_d, &byt_y) ) { if ( c3n == u3u_mmap_read("lite", u3_Host.ops_u.lit_c, &len_d, &byt_y) ) {
u3l_log("lite: unable to load ivory pill at %s\n", u3l_log("lite: unable to load ivory pill at %s",
u3_Host.ops_u.lit_c); u3_Host.ops_u.lit_c);
exit(1); exit(1);
} }
@ -718,21 +718,21 @@ _king_boot_ivory(void)
u3_weak pil; u3_weak pil;
if ( u3_none == (pil = u3s_cue_xeno_with(sil_u, len_d, byt_y)) ) { if ( u3_none == (pil = u3s_cue_xeno_with(sil_u, len_d, byt_y)) ) {
u3l_log("lite: unable to cue ivory pill\r\n"); u3l_log("lite: unable to cue ivory pill");
exit(1); exit(1);
} }
u3s_cue_xeno_done(sil_u); u3s_cue_xeno_done(sil_u);
if ( c3n == u3v_boot_lite(pil)) { if ( c3n == u3v_boot_lite(pil)) {
u3l_log("lite: boot failed\r\n"); u3l_log("lite: boot failed");
exit(1); exit(1);
} }
} }
if ( u3_Host.ops_u.lit_c ) { if ( u3_Host.ops_u.lit_c ) {
if ( c3n == u3u_munmap(len_d, byt_y) ) { if ( c3n == u3u_munmap(len_d, byt_y) ) {
u3l_log("lite: unable to unmap ivory pill at %s\n", u3l_log("lite: unable to unmap ivory pill at %s",
u3_Host.ops_u.lit_c); u3_Host.ops_u.lit_c);
exit(1); exit(1);
} }
@ -786,7 +786,7 @@ u3_king_commence()
rlm.rlim_cur = 0; rlm.rlim_cur = 0;
if ( 0 != setrlimit(RLIMIT_CORE, &rlm) ) { if ( 0 != setrlimit(RLIMIT_CORE, &rlm) ) {
u3l_log("king: unable to disable core dumps: %s\r\n", strerror(errno)); u3l_log("king: unable to disable core dumps: %s", strerror(errno));
exit(1); exit(1);
} }
} }
@ -954,7 +954,7 @@ u3_king_grab(void* vod_p)
} }
#else #else
{ {
u3_term_io_loja(0); u3_term_io_loja(0, fil_u);
} }
#endif #endif
} }

12
pkg/urbit/vere/lord.c
View File

@ -267,13 +267,13 @@ _lord_plea_live(u3_lord* god_u, u3_noun dat)
case u3_writ_meld: { case u3_writ_meld: {
// XX wire into cb // XX wire into cb
// //
u3l_log("pier: meld complete\n"); u3l_log("pier: meld complete");
} break; } break;
case u3_writ_pack: { case u3_writ_pack: {
// XX wire into cb // XX wire into cb
// //
u3l_log("pier: pack complete\n"); u3l_log("pier: pack complete");
} break; } break;
} }
@ -1098,10 +1098,10 @@ _lord_on_serf_bail(void* ptr_v,
u3_lord* god_u = ptr_v; u3_lord* god_u = ptr_v;
if ( UV_EOF == err_i ) { if ( UV_EOF == err_i ) {
u3l_log("pier: serf unexpectedly shut down\r\n"); u3l_log("pier: serf unexpectedly shut down");
} }
else { else {
u3l_log("pier: serf error: %s\r\n", err_c); u3l_log("pier: serf error: %s", err_c);
} }
_lord_bail(god_u); _lord_bail(god_u);
@ -1112,7 +1112,7 @@ _lord_on_serf_bail(void* ptr_v,
void void
u3_lord_info(u3_lord* god_u) u3_lord_info(u3_lord* god_u)
{ {
u3l_log(" lord: live=%s, event=%" PRIu64 ", mug=%x, queue=%u\n", u3l_log(" lord: live=%s, event=%" PRIu64 ", mug=%x, queue=%u",
( c3y == god_u->liv_o ) ? "&" : "|", ( c3y == god_u->liv_o ) ? "&" : "|",
god_u->eve_d, god_u->eve_d,
god_u->mug_l, god_u->mug_l,
@ -1148,7 +1148,7 @@ u3_lord_init(c3_c* pax_c, c3_w wag_w, c3_d key_d[4], u3_lord_cb cb_u)
c3_c cev_c[11]; c3_c cev_c[11];
c3_i err_i; c3_i err_i;
sprintf(key_c, "%" PRIx64 ":%" PRIx64 ":%" PRIx64 ":%" PRIx64 "", sprintf(key_c, "%" PRIx64 ":%" PRIx64 ":%" PRIx64 ":%" PRIx64,
god_u->key_d[0], god_u->key_d[0],
god_u->key_d[1], god_u->key_d[1],
god_u->key_d[2], god_u->key_d[2],

2
pkg/urbit/vere/newt.c
View File

@ -362,7 +362,7 @@ u3_newt_moat_info(u3_moat* mot_u)
} }
if ( len_w ) { if ( len_w ) {
u3l_log(" newt: %u inbound ipc messages pending\n", len_w); u3l_log(" newt: %u inbound ipc messages pending", len_w);
} }
} }

97
pkg/urbit/vere/pier.c
View File

@ -251,7 +251,7 @@ _pier_work(u3_work* wok_u)
// XX this is when "boot" is actually complete // XX this is when "boot" is actually complete
// XX even better would be after neighboring with our sponsor // XX even better would be after neighboring with our sponsor
// //
u3l_log("pier (%" PRIu64 "): live\r\n", pir_u->god_u->eve_d); u3l_log("pier (%" PRIu64 "): live", pir_u->god_u->eve_d);
// XX move callbacking to king // XX move callbacking to king
// //
@ -286,7 +286,7 @@ _pier_on_lord_work_spin(void* ptr_v, u3_atom pin, c3_o del_o)
u3_term_start_spinner(pin, del_o); u3_term_start_spinner(pin, del_o);
} }
/* _pier_on_lord_work_spin(): stop spinner /* _pier_on_lord_work_spun(): stop spinner
*/ */
static void static void
_pier_on_lord_work_spun(void* ptr_v) _pier_on_lord_work_spun(void* ptr_v)
@ -472,13 +472,13 @@ _pier_on_scry_done(void* ptr_v, u3_noun nun)
u3_weak res = u3r_at(7, nun); u3_weak res = u3r_at(7, nun);
if (u3_none == res) { if (u3_none == res) {
u3l_log("pier: scry failed\n"); u3l_log("pier: scry failed");
} }
else { else {
u3_weak out, pad; u3_weak out, pad;
c3_c *ext_c, *pac_c; c3_c *ext_c, *pac_c;
u3l_log("pier: scry succeeded\n"); u3l_log("pier: scry succeeded");
if ( u3_Host.ops_u.puk_c ) { if ( u3_Host.ops_u.puk_c ) {
pac_c = u3_Host.ops_u.puk_c; pac_c = u3_Host.ops_u.puk_c;
@ -531,11 +531,11 @@ _pier_on_scry_done(void* ptr_v, u3_noun nun)
pir_u->pax_c, pac_c+1, ext_c); pir_u->pax_c, pac_c+1, ext_c);
u3_walk_save(fil_c, 0, out, pir_u->pax_c, pad); u3_walk_save(fil_c, 0, out, pir_u->pax_c, pad);
u3l_log("pier: scry result in %s\n", fil_c); u3l_log("pier: scry result in %s", fil_c);
} }
} }
u3l_log("pier: exit\n"); u3l_log("pier: exit");
u3_pier_exit(pir_u); u3_pier_exit(pir_u);
u3z(nun); u3z(nun);
@ -614,7 +614,7 @@ _pier_work_init(u3_pier* pir_u)
} else { } else {
// run the requested scry, jam to disk, then exit // run the requested scry, jam to disk, then exit
// //
u3l_log("pier: scry\n"); u3l_log("pier: scry");
u3_pier_peek_last(pir_u, u3_nul, u3k(car), u3k(dek), u3k(pax), u3_pier_peek_last(pir_u, u3_nul, u3k(car), u3k(dek), u3k(pax),
pir_u, _pier_on_scry_done); pir_u, _pier_on_scry_done);
} }
@ -663,7 +663,7 @@ _pier_wyrd_fail(u3_pier* pir_u, u3_ovum* egg_u, u3_noun lud)
{ {
// XX version negotiation failed, print upgrade message // XX version negotiation failed, print upgrade message
// //
u3l_log("pier: version negotation failed\n\n"); u3l_log("pier: version negotation failed");
// XX only print trace with -v ? // XX only print trace with -v ?
// //
@ -749,7 +749,7 @@ _pier_on_lord_wyrd_done(void* ptr_v,
// XX messaging, cli argument to bypass // XX messaging, cli argument to bypass
// //
u3l_log("pier: version negotiation failed; downgrade\n"); u3l_log("pier: version negotiation failed; downgrade");
_pier_wyrd_fail(pir_u, egg_u, u3_nul); _pier_wyrd_fail(pir_u, egg_u, u3_nul);
} }
else { else {
@ -842,7 +842,7 @@ _pier_wyrd_init(u3_pier* pir_u)
pir_u->sat_e = u3_psat_wyrd; pir_u->sat_e = u3_psat_wyrd;
u3l_log("vere: checking version compatibility\n"); u3l_log("vere: checking version compatibility");
{ {
u3_lord* god_u = pir_u->god_u; u3_lord* god_u = pir_u->god_u;
@ -1031,11 +1031,11 @@ _pier_play(u3_play* pay_u)
if ( god_u->eve_d == pay_u->eve_d ) { if ( god_u->eve_d == pay_u->eve_d ) {
// XX should be play_cb // XX should be play_cb
// //
u3l_log("---------------- playback complete ----------------\r\n"); u3l_log("---------------- playback complete ----------------");
u3_term_stop_spinner(); u3_term_stop_spinner();
if ( pay_u->eve_d < log_u->dun_d ) { if ( pay_u->eve_d < log_u->dun_d ) {
// u3l_log("pier: replay barrier reached, shutting down\r\n"); // u3l_log("pier: replay barrier reached, shutting down");
// // XX graceful shutdown // // XX graceful shutdown
// // // //
// u3_lord_save(pir_u->god_u); // u3_lord_save(pir_u->god_u);
@ -1044,7 +1044,7 @@ _pier_play(u3_play* pay_u)
// XX temporary hack // XX temporary hack
// //
u3l_log("pier: replay barrier reached, cramming\r\n"); u3l_log("pier: replay barrier reached, cramming");
u3_pier_cram(pir_u); u3_pier_cram(pir_u);
} }
else if ( pay_u->eve_d == log_u->dun_d ) { else if ( pay_u->eve_d == log_u->dun_d ) {
@ -1070,12 +1070,12 @@ _pier_on_lord_play_done(void* ptr_v, u3_info fon_u, c3_l mug_l)
c3_assert( u3_psat_play == pir_u->sat_e ); c3_assert( u3_psat_play == pir_u->sat_e );
u3l_log("pier: (%" PRIu64 "): play: done\r\n", tac_u->eve_d); u3l_log("pier: (%" PRIu64 "): play: done", tac_u->eve_d);
// XX optional // XX optional
// //
if ( tac_u->mug_l && (tac_u->mug_l != mug_l) ) { if ( tac_u->mug_l && (tac_u->mug_l != mug_l) ) {
u3l_log("pier: (%" PRIu64 "): play: mug mismatch %x %x\r\n", u3l_log("pier: (%" PRIu64 "): play: mug mismatch %x %x",
tac_u->eve_d, tac_u->eve_d,
tac_u->mug_l, tac_u->mug_l,
mug_l); mug_l);
@ -1124,7 +1124,7 @@ _pier_on_lord_play_bail(void* ptr_v, u3_info fon_u,
// XX optional // XX optional
// //
if ( las_l && (las_l != mug_l) ) { if ( las_l && (las_l != mug_l) ) {
u3l_log("pier: (%" PRIu64 "): play bail: mug mismatch %x %x\r\n", u3l_log("pier: (%" PRIu64 "): play bail: mug mismatch %x %x",
(c3_d)(eve_d - 1ULL), (c3_d)(eve_d - 1ULL),
las_l, las_l,
mug_l); mug_l);
@ -1135,7 +1135,7 @@ _pier_on_lord_play_bail(void* ptr_v, u3_info fon_u,
// //
#if 0 #if 0
{ {
u3l_log("pier: (%" PRIu64 "): play: retry\r\n", eve_d); u3l_log("pier: (%" PRIu64 "): play: retry", eve_d);
fon_u.ext_u = tac_u; fon_u.ext_u = tac_u;
@ -1156,7 +1156,7 @@ _pier_on_lord_play_bail(void* ptr_v, u3_info fon_u,
} }
#else #else
{ {
u3l_log("pier: (%" PRIu64 "): play: bail\r\n", eve_d); u3l_log("pier: (%" PRIu64 "): play: bail", eve_d);
u3_pier_punt_goof("play", dud); u3_pier_punt_goof("play", dud);
{ {
u3_noun wir, tag; u3_noun wir, tag;
@ -1192,12 +1192,12 @@ _pier_play_init(u3_pier* pir_u, c3_d eve_d)
pay_u->eve_d = eve_d; pay_u->eve_d = eve_d;
pay_u->sen_d = god_u->eve_d; pay_u->sen_d = god_u->eve_d;
u3l_log("---------------- playback starting ----------------\r\n"); u3l_log("---------------- playback starting ----------------");
if ( (1ULL + god_u->eve_d) == eve_d ) { if ( (1ULL + god_u->eve_d) == eve_d ) {
u3l_log("pier: replaying event %" PRIu64 "\r\n", eve_d); u3l_log("pier: replaying event %" PRIu64, eve_d);
} }
else { else {
u3l_log("pier: replaying events %" PRIu64 "-%" PRIu64 "\r\n", u3l_log("pier: replaying events %" PRIu64 "-%" PRIu64,
(c3_d)(1ULL + god_u->eve_d), (c3_d)(1ULL + god_u->eve_d),
eve_d); eve_d);
} }
@ -1326,7 +1326,7 @@ _pier_on_lord_cram(void* ptr_v)
// XX temporary hack // XX temporary hack
// //
if ( u3_psat_play == pir_u->sat_e ) { if ( u3_psat_play == pir_u->sat_e ) {
u3l_log("pier: cram complete, shutting down\r\n"); u3l_log("pier: cram complete, shutting down");
u3_pier_bail(pir_u); u3_pier_bail(pir_u);
exit(0); exit(0);
} }
@ -1355,7 +1355,7 @@ _pier_on_lord_exit(void* ptr_v)
pir_u->god_u = 0; pir_u->god_u = 0;
if ( u3_psat_done != pir_u->sat_e ) { if ( u3_psat_done != pir_u->sat_e ) {
u3l_log("pier: serf shutdown unexpected\r\n"); u3l_log("pier: serf shutdown unexpected");
u3_pier_bail(pir_u); u3_pier_bail(pir_u);
} }
// if we made it all the way here, it's our jab to wrap up // if we made it all the way here, it's our jab to wrap up
@ -1416,10 +1416,10 @@ _pier_on_lord_live(void* ptr_v)
// //
if ( u3_Host.ops_u.til_c ) { if ( u3_Host.ops_u.til_c ) {
if ( 1 == sscanf(u3_Host.ops_u.til_c, "%" PRIu64 "", &eve_d) ) { if ( 1 == sscanf(u3_Host.ops_u.til_c, "%" PRIu64 "", &eve_d) ) {
u3l_log("pier: replay till %" PRIu64 "\r\n", eve_d); u3l_log("pier: replay till %" PRIu64, eve_d);
} }
else { else {
u3l_log("pier: ignoring invalid replay barrier '%s'\r\n", u3l_log("pier: ignoring invalid replay barrier '%s'",
u3_Host.ops_u.til_c); u3_Host.ops_u.til_c);
eve_d = log_u->dun_d; eve_d = log_u->dun_d;
} }
@ -1443,51 +1443,51 @@ u3_pier_info(u3_pier* pir_u)
{ {
switch ( pir_u->sat_e ) { switch ( pir_u->sat_e ) {
default: { default: {
u3l_log("pier: unknown state: %u\r\n", pir_u->sat_e); u3l_log("pier: unknown state: %u", pir_u->sat_e);
} break; } break;
case u3_psat_init: { case u3_psat_init: {
u3l_log("pier: init\n"); u3l_log("pier: init");
} break; } break;
case u3_psat_boot: { case u3_psat_boot: {
u3l_log("pier: boot\n"); u3l_log("pier: boot");
} break; } break;
case u3_psat_play: { case u3_psat_play: {
u3l_log("pier: play\n"); u3l_log("pier: play");
{ {
u3_play* pay_u = pir_u->pay_u; u3_play* pay_u = pir_u->pay_u;
u3l_log(" target: %" PRIu64 "\n", pay_u->eve_d); u3l_log(" target: %" PRIu64, pay_u->eve_d);
u3l_log(" sent: %" PRIu64 "\n", pay_u->sen_d); u3l_log(" sent: %" PRIu64, pay_u->sen_d);
u3l_log(" read: %" PRIu64 "\n", pay_u->req_d); u3l_log(" read: %" PRIu64, pay_u->req_d);
} }
} break; } break;
case u3_psat_work: { case u3_psat_work: {
u3l_log("pier: work\n"); u3l_log("pier: work");
{ {
u3_work* wok_u = pir_u->wok_u; u3_work* wok_u = pir_u->wok_u;
u3l_log(" effects: released=%" PRIu64 "\n", wok_u->fec_u.rel_d); u3l_log(" effects: released=%" PRIu64, wok_u->fec_u.rel_d);
if ( wok_u->fec_u.ext_u ) { if ( wok_u->fec_u.ext_u ) {
if ( wok_u->fec_u.ext_u != wok_u->fec_u.ent_u ) { if ( wok_u->fec_u.ext_u != wok_u->fec_u.ent_u ) {
u3l_log(" pending %" PRIu64 "-%" PRIu64 "\n", u3l_log(" pending %" PRIu64 "-%" PRIu64,
wok_u->fec_u.ext_u->eve_d, wok_u->fec_u.ext_u->eve_d,
wok_u->fec_u.ent_u->eve_d); wok_u->fec_u.ent_u->eve_d);
} }
else { else {
u3l_log(" pending %" PRIu64 "\n", wok_u->fec_u.ext_u->eve_d); u3l_log(" pending %" PRIu64, wok_u->fec_u.ext_u->eve_d);
} }
} }
if ( wok_u->wal_u ) { if ( wok_u->wal_u ) {
u3l_log(" wall: %" PRIu64 "\n", wok_u->wal_u->eve_d); u3l_log(" wall: %" PRIu64, wok_u->wal_u->eve_d);
} }
if ( wok_u->car_u ) { if ( wok_u->car_u ) {
@ -1497,7 +1497,7 @@ u3_pier_info(u3_pier* pir_u)
} break; } break;
case u3_psat_done: { case u3_psat_done: {
u3l_log("pier: done\n"); u3l_log("pier: done");
} break; } break;
} }
@ -1611,7 +1611,7 @@ u3_pier_stay(c3_w wag_w, u3_noun pax)
if ( c3y == u3_Host.ops_u.veb ) { if ( c3y == u3_Host.ops_u.veb ) {
FILE* fil_u = u3_term_io_hija(); FILE* fil_u = u3_term_io_hija();
u3_lmdb_stat(pir_u->log_u->mdb_u, fil_u); u3_lmdb_stat(pir_u->log_u->mdb_u, fil_u);
u3_term_io_loja(1); u3_term_io_loja(1, fil_u);
} }
u3z(pax); u3z(pax);
@ -2221,10 +2221,12 @@ _pier_dump_wall(FILE* fil_u, u3_noun wol)
while ( u3_nul != wal ) { while ( u3_nul != wal ) {
_pier_dump_tape(fil_u, u3k(u3h(wal))); _pier_dump_tape(fil_u, u3k(u3h(wal)));
putc(13, fil_u);
putc(10, fil_u);
wal = u3t(wal); wal = u3t(wal);
if ( u3_nul != wal ) {
putc(13, fil_u);
putc(10, fil_u);
}
} }
u3z(wol); u3z(wol);
@ -2250,6 +2252,7 @@ u3_pier_tank(c3_l tab_l, c3_w pri_w, u3_noun tac)
case 3: fprintf(fil_u, "\033[31m>>> "); break; case 3: fprintf(fil_u, "\033[31m>>> "); break;
case 2: fprintf(fil_u, "\033[33m>> "); break; case 2: fprintf(fil_u, "\033[33m>> "); break;
case 1: fprintf(fil_u, "\033[32m> "); break; case 1: fprintf(fil_u, "\033[32m> "); break;
case 0: fprintf(fil_u, "\033[90m" ); break;
} }
} }
else { else {
@ -2266,8 +2269,6 @@ u3_pier_tank(c3_l tab_l, c3_w pri_w, u3_noun tac)
if ( 0 == u3A->roc ) { if ( 0 == u3A->roc ) {
if ( c3__leaf == u3h(tac) ) { if ( c3__leaf == u3h(tac) ) {
_pier_dump_tape(fil_u, u3k(u3t(tac))); _pier_dump_tape(fil_u, u3k(u3t(tac)));
putc(13, fil_u);
putc(10, fil_u);
} }
} }
// We are calling nock here, but hopefully need no protection. // We are calling nock here, but hopefully need no protection.
@ -2284,7 +2285,7 @@ u3_pier_tank(c3_l tab_l, c3_w pri_w, u3_noun tac)
fflush(fil_u); fflush(fil_u);
u3_term_io_loja(0); u3_term_io_loja(0, fil_u);
u3z(blu); u3z(blu);
u3z(tac); u3z(tac);
} }
@ -2314,12 +2315,12 @@ u3_pier_punt_goof(const c3_c* cap_c, u3_noun dud)
u3x_cell(dud, &mot, &tan); u3x_cell(dud, &mot, &tan);
u3l_log("\n"); u3l_log("");
u3_pier_punt(0, u3qb_flop(tan)); u3_pier_punt(0, u3qb_flop(tan));
{ {
c3_c* mot_c = u3r_string(mot); c3_c* mot_c = u3r_string(mot);
u3l_log("%s: bail: %%%s\r\n", cap_c, mot_c); u3l_log("%s: bail: %%%s", cap_c, mot_c);
c3_free(mot_c); c3_free(mot_c);
} }
@ -2335,7 +2336,7 @@ u3_pier_punt_ovum(const c3_c* cap_c, u3_noun wir, u3_noun tag)
u3_noun riw = u3do("spat", wir); u3_noun riw = u3do("spat", wir);
c3_c* wir_c = u3r_string(riw); c3_c* wir_c = u3r_string(riw);
u3l_log("%s: %%%s event on %s failed\r\n\n", cap_c, tag_c, wir_c); u3l_log("%s: %%%s event on %s failed", cap_c, tag_c, wir_c);
c3_free(tag_c); c3_free(tag_c);
c3_free(wir_c); c3_free(wir_c);

2
pkg/urbit/vere/save.c
View File

@ -25,7 +25,7 @@ u3_save_ef_chld(u3_pier *pir_u)
/* modified for cases with no pid_w /* modified for cases with no pid_w
*/ */
u3l_log("checkpoint: complete %d\n", sav_u->pid_w); u3l_log("checkpoint: complete %d", sav_u->pid_w);
pid_w = wait(&loc_i); pid_w = wait(&loc_i);
if (0 != sav_u->pid_w) { if (0 != sav_u->pid_w) {
c3_assert(pid_w == sav_u->pid_w); c3_assert(pid_w == sav_u->pid_w);

14
pkg/urbit/vere/walk.c
View File

@ -37,7 +37,7 @@ u3_walk_safe(c3_c* pas_c)
c3_y* pad_y; c3_y* pad_y;
if ( (fid_i < 0) || (fstat(fid_i, &buf_b) < 0) ) { if ( (fid_i < 0) || (fstat(fid_i, &buf_b) < 0) ) {
// u3l_log("%s: %s\n", pas_c, strerror(errno)); // u3l_log("%s: %s", pas_c, strerror(errno));
return 0; return 0;
} }
fln_w = buf_b.st_size; fln_w = buf_b.st_size;
@ -69,7 +69,7 @@ u3_walk_load(c3_c* pas_c)
c3_y* pad_y; c3_y* pad_y;
if ( (fid_i < 0) || (fstat(fid_i, &buf_b) < 0) ) { if ( (fid_i < 0) || (fstat(fid_i, &buf_b) < 0) ) {
u3l_log("%s: %s\n", pas_c, strerror(errno)); u3l_log("%s: %s", pas_c, strerror(errno));
return u3m_bail(c3__fail); return u3m_bail(c3__fail);
} }
fln_w = buf_b.st_size; fln_w = buf_b.st_size;
@ -117,7 +117,7 @@ _walk_mkdirp(c3_c* bas_c, u3_noun pax)
pax_c[len_w] = '\0'; pax_c[len_w] = '\0';
if ( 0 != mkdir(pax_c, 0755) && EEXIST != errno ) { if ( 0 != mkdir(pax_c, 0755) && EEXIST != errno ) {
u3l_log("error mkdiring %s: %s\n", pax_c, strerror(errno)); u3l_log("error mkdiring %s: %s", pax_c, strerror(errno));
u3m_bail(c3__fail); u3m_bail(c3__fail);
} }
@ -140,7 +140,7 @@ u3_walk_save(c3_c* pas_c, u3_noun tim, u3_atom pad, c3_c* bas_c, u3_noun pax)
return u3_walk_save(pas_c, tim, pad, 0, u3_nul); return u3_walk_save(pas_c, tim, pad, 0, u3_nul);
} }
u3l_log("%s: %s\n", pas_c, strerror(errno)); u3l_log("%s: %s", pas_c, strerror(errno));
u3m_bail(c3__fail); u3m_bail(c3__fail);
} }
@ -155,7 +155,7 @@ u3_walk_save(c3_c* pas_c, u3_noun tim, u3_atom pad, c3_c* bas_c, u3_noun pax)
c3_free(pad_y); c3_free(pad_y);
if ( rit_w != fln_w ) { if ( rit_w != fln_w ) {
u3l_log("%s: %s\n", pas_c, strerror(errno)); u3l_log("%s: %s", pas_c, strerror(errno));
u3m_bail(c3__fail); u3m_bail(c3__fail);
} }
@ -185,7 +185,7 @@ _walk_in(const c3_c* dir_c, c3_w len_w)
struct dirent* out_n; struct dirent* out_n;
if ( u3_readdir_r(dir_d, &ent_n, &out_n) != 0 ) { if ( u3_readdir_r(dir_d, &ent_n, &out_n) != 0 ) {
u3l_log("%s: %s\n", dir_c, strerror(errno)); u3l_log("%s: %s", dir_c, strerror(errno));
break; break;
} }
else if ( !out_n ) { else if ( !out_n ) {
@ -267,7 +267,7 @@ u3_walk(const c3_c* dir_c, u3_noun old)
struct stat buf_b; struct stat buf_b;
if ( 0 != stat(dir_c, &buf_b) ) { if ( 0 != stat(dir_c, &buf_b) ) {
u3l_log("can't stat %s\n", dir_c); u3l_log("can't stat %s", dir_c);
// return u3m_bail(c3__fail); // return u3m_bail(c3__fail);
c3_assert(0); c3_assert(0);
} }

14
pkg/urbit/worker/serf.c
View File

@ -244,7 +244,7 @@ _serf_grab(u3_serf* sef_u)
u3z(sef_u->sac); u3z(sef_u->sac);
sef_u->sac = u3_nul; sef_u->sac = u3_nul;
u3l_log("\n"); u3l_log("");
} }
} }
@ -282,7 +282,7 @@ u3_serf_post(u3_serf* sef_u)
if ( c3y == sef_u->pac_o ) { if ( c3y == sef_u->pac_o ) {
u3a_print_memory(stderr, "serf: pack: gained", u3m_pack()); u3a_print_memory(stderr, "serf: pack: gained", u3m_pack());
u3l_log("\n"); u3l_log("");
sef_u->pac_o = c3n; sef_u->pac_o = c3n;
} }
} }
@ -464,7 +464,7 @@ _serf_poke(u3_serf* sef_u, c3_c* cap_c, c3_w mil_w, u3_noun job)
if ( (c3__belt != tag) if ( (c3__belt != tag)
&& (c3__crud != tag) ) && (c3__crud != tag) )
{ {
u3l_log("serf: %s (%" PRIu64 ") %s\r\n", cap_c, sef_u->sen_d, txt_c); u3l_log("serf: %s (%" PRIu64 ") %s", cap_c, sef_u->sen_d, txt_c);
} }
} }
#endif #endif
@ -484,7 +484,7 @@ _serf_poke(u3_serf* sef_u, c3_c* cap_c, c3_w mil_w, u3_noun job)
clr_w = ms_w > 1000 ? 1 : ms_w < 100 ? 2 : 3; // red, green, yellow clr_w = ms_w > 1000 ? 1 : ms_w < 100 ? 2 : 3; // red, green, yellow
if ( clr_w != 2 ) { if ( clr_w != 2 ) {
u3l_log("\x1b[3%dm%%%s (%" PRIu64 ") %4d.%02dms\x1b[0m\n", u3l_log("\x1b[3%dm%%%s (%" PRIu64 ") %4d.%02dms\x1b[0m",
clr_w, txt_c, sef_u->sen_d, ms_w, clr_w, txt_c, sef_u->sen_d, ms_w,
(int) (d0.tv_usec % 1000) / 10); (int) (d0.tv_usec % 1000) / 10);
} }
@ -523,7 +523,7 @@ _serf_work(u3_serf* sef_u, c3_w mil_w, u3_noun job)
// //
if ( u3_blip == u3h(gon) ) { if ( u3_blip == u3h(gon) ) {
u3_noun vir = _serf_sure(sef_u, pre_w, u3k(u3t(gon))); u3_noun vir = _serf_sure(sef_u, pre_w, u3k(u3t(gon)));
u3z(gon); u3z(job); u3z(gon); u3z(job);
return u3nc(c3__done, u3nt(u3i_chubs(1, &sef_u->dun_d), return u3nc(c3__done, u3nt(u3i_chubs(1, &sef_u->dun_d),
sef_u->mug_l, sef_u->mug_l,
@ -901,7 +901,7 @@ u3_serf_live(u3_serf* sef_u, u3_noun com, u3_noun* ret)
return c3n; return c3n;
} }
u3l_log("serf (%" PRIu64 "): saving rock\r\n", sef_u->dun_d); u3l_log("serf (%" PRIu64 "): saving rock", sef_u->dun_d);
if ( c3n == u3u_cram(sef_u->dir_c, eve_d) ) { if ( c3n == u3u_cram(sef_u->dir_c, eve_d) ) {
fprintf(stderr, "serf (%" PRIu64 "): unable to jam state\r\n", eve_d); fprintf(stderr, "serf (%" PRIu64 "): unable to jam state\r\n", eve_d);
@ -1045,7 +1045,7 @@ u3_serf_writ(u3_serf* sef_u, u3_noun wit, u3_noun* pel)
static u3_noun static u3_noun
_serf_ripe(u3_serf* sef_u) _serf_ripe(u3_serf* sef_u)
{ {
// u3l_log("serf: ripe %" PRIu64 "\r\n", sef_u->dun_d); // u3l_log("serf: ripe %" PRIu64, sef_u->dun_d);
sef_u->mug_l = ( 0 == sef_u->dun_d ) sef_u->mug_l = ( 0 == sef_u->dun_d )
? 0 ? 0