ref: 6b84c3a6548f1c577948763b0a09a7b6e2460e04
dir: /appl/alphabet/alphabet.shmod.b/
implement Alphabetsh, Shellbuiltin;
include "sys.m";
sys: Sys;
include "draw.m";
include "sh.m";
sh: Sh;
Context, Listnode: import sh;
n_WORD: import sh;
include "alphabet/reports.m";
reports: Reports;
report, Report: import reports;
include "readdir.m";
readdir: Readdir;
include "alphabet.m";
alphabet: Alphabet;
Value, CHECK, ONDEMAND: import alphabet;
include "alphabet/abc.m";
Alphabetsh: module {};
myself: Shellbuiltin;
initbuiltin(ctxt: ref Sh->Context, shmod: Sh): string
{
sys = load Sys Sys->PATH;
myself = load Shellbuiltin "$self";
sh = shmod;
if (myself == nil)
ctxt.fail("bad module", sys->sprint("file2chan: cannot load self: %r"));
alphabet = load Alphabet Alphabet->PATH;
if(alphabet == nil)
ctxt.fail("bad module", sys->sprint("alphabet: cannot load %q: %r", Alphabet->PATH));
reports = load Reports Reports->PATH;
if(reports == nil)
ctxt.fail("bad module", sys->sprint("alphabet: cannot load %q: %r", Reports->PATH));
readdir = load Readdir Readdir->PATH;
if(readdir == nil)
ctxt.fail("bad module", sys->sprint("alphabet: cannot load %q: %r", Readdir->PATH));
alphabet->init();
alphabet->setautodeclare(1);
if((decls := ctxt.get("autodeclares")) != nil){
for(; decls != nil; decls = tl decls){
d := hd decls;
if(d.cmd == nil){
err: string;
(d.cmd, err) = sh->parse(d.word);
if(err != nil){
sys->fprint(sys->fildes(2), "alphabet: warning: bad autodeclaration: %s\n", err);
continue;
}
}
{
declares(ctxt, nil::d::nil);
}exception{
"fail:*" =>
;
}
}
}
ctxt.addbuiltin("declare", myself);
ctxt.addbuiltin("declares", myself);
ctxt.addbuiltin("undeclare", myself);
ctxt.addbuiltin("define", myself);
ctxt.addbuiltin("import", myself);
ctxt.addbuiltin("autodeclare", myself);
ctxt.addbuiltin("type", myself);
ctxt.addbuiltin("typeset", myself);
ctxt.addbuiltin("autoconvert", myself);
ctxt.addbuiltin("-", myself);
ctxt.addbuiltin("info", myself);
ctxt.addbuiltin("clear", myself);
# ctxt.addsbuiltin("-", myself);
ctxt.addsbuiltin("rewrite", myself);
ctxt.addsbuiltin("modules", myself);
ctxt.addsbuiltin("types", myself);
ctxt.addsbuiltin("usage", myself);
return nil;
}
runbuiltin(c: ref Sh->Context, nil: Sh,
cmd: list of ref Listnode, nil: int): string
{
case (hd cmd).word {
"declare" =>
return declare(c, cmd);
"declares" =>
return declares(c, cmd);
"undeclare" =>
return undeclare(c, cmd);
"define" =>
return define(c, cmd);
"import" =>
return importf(c, cmd);
"type" =>
return importtype(c, cmd);
"typeset" =>
return typeset(c, cmd);
"autoconvert" =>
return autoconvert(c, cmd);
"autodeclare" =>
if(len cmd != 2)
usage(c, "usage: autodeclare 0/1");
alphabet->setautodeclare(int word(hd tl cmd));
"info" =>
return info(c, cmd);
"clear" =>
a := load Alphabet Alphabet->PATH;
if(a == nil)
c.fail("bad module", sys->sprint("alphabet: cannot load %q: %r", Alphabet->PATH));
alphabet->quit();
alphabet = a;
alphabet->init();
alphabet->setautodeclare(1);
"-" =>
return eval(c, cmd);
}
return nil;
}
whatis(nil: ref Sh->Context, nil: Sh, mod: string, wtype: int): string
{
if(wtype == OTHER){
(qname, sig, def) := alphabet->getmodule(mod);
if(qname == nil)
return nil;
s := sys->sprint("declare %q %q", qname, sig);
if(def != nil){
for(i := len sig-1; i >= 0; i--){
if(sig[i] == '>'){
sig = sig[0:i-1];
break;
}
}
s += sys->sprint("; define %q {(%s); %s}", qname, sig, sh->cmd2string(def));
}
return s;
}
return nil;
}
getself(): Shellbuiltin
{
return myself;
}
runsbuiltin(ctxt: ref Context, nil: Sh,
argv: list of ref Listnode): list of ref Listnode
{
case (hd argv).word {
"rewrite" =>
return rewrite(ctxt, argv);
"modules" =>
return sh->stringlist2list(alphabet->getmodules());
"types" =>
ts := "";
if(tl argv != nil)
ts = word(hd tl argv);
r := sh->stringlist2list(alphabet->gettypes(ts));
if(r == nil)
ctxt.fail("error", sys->sprint("unknown typeset %q", ts));
return r;
"usage" =>
if(len argv != 2)
usage(ctxt, "usage qname");
(qname, u, nil) := alphabet->getmodule(word(hd tl argv));
if(qname == nil)
ctxt.fail("error", "module not declared");
return ref Listnode(nil, u) :: nil;
}
return nil;
}
usage(ctxt: ref Context, s: string)
{
ctxt.fail("usage", "usage: " + s);
}
declares(ctxt: ref Sh->Context, argv: list of ref Listnode): string
{
argv = tl argv;
if(argv == nil || (hd argv).cmd == nil)
ctxt.fail("usage", "usage: declares decls");
decls := (hd argv).cmd;
declares := load Declares Declares->PATH;
if(declares == nil)
ctxt.fail("bad module", sys->sprint("alphabet: cannot load %q: %r", Declares->PATH));
{
declares->init();
} exception e {
"fail:*" =>
ctxt.fail("declares init", e[5:]);
}
spawn printerrors(errorc := chan of string);
e := declares->declares(alphabet, decls, errorc, nil);
declares->quit();
if(e != nil)
ctxt.fail("bad declaration", sys->sprint("alphabet: declaration failed: %s", e));
return nil;
}
rewrite(ctxt: ref Sh->Context, argv: list of ref Listnode): list of ref Listnode
{
argv = tl argv;
n := len argv;
if(n != 1 && n != 2 || (hd argv).cmd == nil)
usage(ctxt, "rewrite {expr} [desttype]");
spawn printerrors(errorc := chan of string);
desttype := "";
if(n == 2)
desttype = word(hd tl argv);
(c, usage) := alphabet->rewrite((hd argv).cmd, desttype, errorc);
errorc <-= nil;
if(c == nil)
raise "fail:bad expression";
return (ref Listnode(c, nil) :: ref Listnode(nil, usage) :: nil);
}
# XXX add support for optional ONDEMAND and CHECK flags
declare(ctxt: ref Sh->Context, argv: list of ref Listnode): string
{
argv = tl argv;
n := len argv;
if(n < 1 || n > 2)
usage(ctxt, "declare qname [type]");
decltype := "";
if(n == 2)
decltype = word(hd tl argv);
e := alphabet->declare(word(hd argv), decltype, 0);
if(e != nil)
ctxt.fail("error", sys->sprint("cannot declare %s: %s", word(hd argv), e));
return nil;
}
undeclare(ctxt: ref Sh->Context, argv: list of ref Listnode): string
{
argv = tl argv;
if(argv == nil)
usage(ctxt, "undeclare name...");
for(; argv != nil; argv = tl argv){
if((e := alphabet->undeclare(word(hd argv))) != nil)
sys->fprint(sys->fildes(2), "alphabet: cannot undeclare %q: %s\n", word(hd argv), e);
}
return nil;
}
# usage define name expr
define(ctxt: ref Sh->Context, argv: list of ref Listnode): string
{
argv = tl argv;
if(len argv != 2 || (hd tl argv).cmd == nil)
usage(ctxt, "define name {expr}");
spawn printerrors(errorc := chan of string);
err := alphabet->define((hd argv).word, (hd tl argv).cmd, errorc);
errorc <-= nil;
if(err != nil)
raise "fail:bad define: "+err;
return nil;
}
importf(ctxt: ref Sh->Context, argv: list of ref Listnode): string
{
argv = tl argv;
if(argv == nil)
usage(ctxt, "import qname...");
errs := 0;
for(; argv != nil; argv = tl argv){
e := alphabet->importmodule(word(hd argv));
if(e != nil){
sys->fprint(sys->fildes(2), "alphabet: cannot import %s: %s\n", word(hd argv), e);
errs++;
}
}
if(errs)
raise "fail:import error";
return nil;
}
importtype(ctxt: ref Sh->Context, argv: list of ref Listnode): string
{
argv = tl argv;
if(argv == nil)
usage(ctxt, "type qname...");
errs := 0;
for(; argv != nil; argv = tl argv){
e := alphabet->importtype(word(hd argv));
if(e != nil){
sys->fprint(sys->fildes(2), "alphabet: cannot import type %s: %s\n", word(hd argv), e);
errs++;
}
}
if(errs)
raise "fail:type declare error";
return nil;
}
typeset(ctxt: ref Sh->Context, argv: list of ref Listnode): string
{
argv = tl argv;
if(len argv != 1)
usage(ctxt, "typeset qname");
spawn printerrors(errorc := chan of string);
e := alphabet->loadtypeset(word(hd argv), nil, errorc); # XXX errorc?
errorc <-= nil;
if(e != nil)
ctxt.fail("error", sys->sprint("cannot load typeset %q: %s", word(hd argv), e));
return nil;
}
autoconvert(ctxt: ref Sh->Context, argv: list of ref Listnode): string
{
argv = tl argv;
if(len argv != 3)
usage(ctxt, "autoconvert src dst fn");
src := word(hd argv);
dst := word(hd tl argv);
expr := (hd tl tl argv).cmd;
if(expr == nil)
expr = ref Sh->Cmd(Sh->n_WORD, nil, nil, (hd tl tl argv).word, nil);
spawn printerrors(errorc := chan of string);
e := alphabet->autoconvert(src, dst, expr, errorc);
errorc <-= nil;
if(e != nil)
ctxt.fail("error", sys->sprint("cannot autoconvert %s to %s via %s: %s",
src, dst, word(hd tl tl argv), e));
return nil;
}
info(ctxt: ref Sh->Context, argv: list of ref Listnode): string
{
first := 1;
if(tl argv != nil)
usage(ctxt, "info");
for(tsl := alphabet->gettypesets(); tsl != nil; tsl = tl tsl){
ts := hd tsl;
r := alphabet->gettypesetmodules(ts);
if(r == nil)
continue;
if(first == 0)
sys->print("\n");
sys->print("typeset %s\n", ts);
while((mod := <-r) != nil){
(qname, u, nil) := alphabet->getmodule(ts+"/"+mod);
if(qname != nil)
sys->print("%s %s\n", qname, u);
}
first = 0;
}
acl := alphabet->getautoconversions();
if(acl != nil)
sys->print("\n");
for(; acl != nil; acl = tl acl){
(src, dst, via) := hd acl;
sys->print("autoconvert %q %q %s\n", src, dst, sh->cmd2string(via));
}
return nil;
}
eval(ctxt: ref Sh->Context, argv: list of ref Listnode): string
{
argv = tl argv;
if(argv == nil || (hd argv).cmd == nil)
usage(ctxt, "- {expr} [arg...]");
c := (hd argv).cmd;
if(c == nil)
c = mkw((hd argv).word);
args: list of ref Value;
for(argv = tl argv; argv != nil; argv = tl argv){
if((hd argv).cmd != nil)
args = ref Value.Vc((hd argv).cmd) :: args;
else
args = ref Value.Vs((hd argv).word) :: args;
}
return alphabet->eval(c, ctxt.drawcontext, rev(args));
}
rev[T](x: list of T): list of T
{
l: list of T;
for(; x != nil; x = tl x)
l = hd x :: l;
return l;
}
word(n: ref Listnode): string
{
if (n.word != nil)
return n.word;
if (n.cmd != nil)
n.word = sh->cmd2string(n.cmd);
return n.word;
}
printerrors(c: chan of string)
{
while((s := <-c) != nil)
sys->fprint(sys->fildes(2), "e: %s\n", s);
}
mkw(w: string): ref Sh->Cmd
{
return ref Sh->Cmd(n_WORD, nil, nil, w, nil);
}