ref: 3efb5bbb4061056e523858b134c555949591efe2
dir: /appl/cmd/mash/misc.b/
#
# Miscellaneous routines.
#
Cmd.cmd1(op: int, l: ref Cmd): ref Cmd
{
return ref Cmd(op, nil, l, nil, nil, nil, nil, 0);
}
Cmd.cmd2(op: int, l, r: ref Cmd): ref Cmd
{
return ref Cmd(op, nil, l, r, nil, nil, nil, 0);
}
Cmd.cmd1i(op: int, l: ref Cmd, i: ref Item): ref Cmd
{
return ref Cmd(op, nil, l, nil, i, nil, nil, 0);
}
Cmd.cmd1w(op: int, l: ref Cmd, w: list of ref Item): ref Cmd
{
return ref Cmd(op, w, l, nil, nil, nil, nil, 0);
}
Cmd.cmde(c: self ref Cmd, op: int, l, r: ref Cmd): ref Cmd
{
c.op = op;
c.left = l;
c.right = r;
return c;
}
Cmd.cmdiw(op: int, i: ref Item, w: list of ref Item): ref Cmd
{
return ref Cmd(op, revitems(w), nil, nil, i, nil, nil, 0);
}
Pin, Pout: con 1 << iota;
rdmap := array[] of
{
Rin => Pin,
Rout or Rappend => Pout,
Rinout => Pin | Pout,
};
rdsymbs := array[] of
{
Rin => "<",
Rout => ">",
Rappend => ">>",
Rinout => "<>",
};
ionames := array[] of
{
Pin => "input",
Pout => "ouput",
Pin | Pout => "input/output",
};
#
# Check a pipeline for ambiguities.
#
Cmd.checkpipe(c: self ref Cmd, e: ref Env, f: int): int
{
if (c.error)
return 0;
if (c.op == Cpipe) {
if (!c.left.checkpipe(e, f | Pout))
return 0;
if (!c.right.checkpipe(e, f | Pin))
return 0;
}
if (f) {
t := 0;
for (l := c.redirs; l != nil; l = tl l)
t |= rdmap[(hd l).op];
f &= t;
if (f) {
e.report(sys->sprint("%s redirection conflicts with pipe", ionames[f]));
return 0;
}
}
return 1;
}
#
# Update a command with another redirection.
#
Cmd.cmdio(c: self ref Cmd, e: ref Env, i: ref Item)
{
f := 0;
for (l := c.redirs; l != nil; l = tl l)
f |= rdmap[(hd l).op];
r := i.redir;
f &= rdmap[r.op];
if (f != 0) {
e.report(sys->sprint("repeat %s redirection", ionames[f]));
c.error = 1;
}
c.redirs = r :: c.redirs;
}
#
# Make a basic command.
#
Cmd.mkcmd(c: self ref Cmd, e: ref Env, async: int): ref Cmd
{
if (!c.checkpipe(e, 0))
return nil;
if (async)
return ref Cmd(Casync, nil, c, nil, nil, nil, nil, 0);
else
return c;
}
#
# Rotate parse tree of cases.
#
Cmd.rotcases(c: self ref Cmd): ref Cmd
{
l := c;
c = nil;
while (l != nil) {
t := l.right;
l.right = c;
c = l;
l = l.left;
c.left = t;
}
return c;
}
Item.item1(op: int, l: ref Item): ref Item
{
return ref Item(op, nil, l, nil, nil, nil);
}
Item.item2(op: int, l, r: ref Item): ref Item
{
return ref Item(op, nil, l, r, nil, nil);
}
Item.itemc(op: int, c: ref Cmd): ref Item
{
return ref Item(op, nil, nil, nil, c, nil);
}
#
# Make an item from a list of strings.
#
Item.iteml(l: list of string): ref Item
{
if (l != nil && tl l == nil)
return Item.itemw(hd l);
r: list of string;
while (l != nil) {
r = (hd l) :: r;
l = tl l;
}
c := ref Cmd;
c.op = Clist;
c.value = revstrs(r);
return Item.itemc(Iexpr, c);
}
Item.itemr(op: int, i: ref Item): ref Item
{
return ref Item(Iredir, nil, nil, nil, nil, ref Redir(op, i));
}
qword: Word = (nil, Wquoted, (0, nil));
Item.itemw(s: string): ref Item
{
w := ref qword;
w.text = s;
return ref Item(Iword, w, nil, nil, nil, nil);
}
revitems(l: list of ref Item): list of ref Item
{
r: list of ref Item;
while (l != nil) {
r = (hd l) :: r;
l = tl l;
}
return r;
}
revstrs(l: list of string): list of string
{
r: list of string;
while (l != nil) {
r = (hd l) :: r;
l = tl l;
}
return r;
}
prepend(l: list of string, r: list of string): list of string
{
while (r != nil) {
l = (hd r) :: l;
r = tl r;
}
return l;
}
concat(l: list of string): string
{
s := hd l;
for (;;) {
l = tl l;
if (l == nil)
return s;
s += " ";
s += hd l;
}
}
#
# Make an item list, no redirections allowed.
#
Env.mklist(e: self ref Env, l: list of ref Item): list of ref Item
{
r: list of ref Item;
while (l != nil) {
i := hd l;
if (i.op == Iredir)
e.report("redirection in list");
else
r = i :: r;
l = tl l;
}
return r;
}
#
# Make a simple command.
#
Env.mksimple(e: self ref Env, l: list of ref Item): ref Cmd
{
r: list of ref Item;
c := ref Cmd;
c.op = Csimple;
c.error = 0;
while (l != nil) {
i := hd l;
if (i.op == Iredir)
c.cmdio(e, i);
else
r = i :: r;
l = tl l;
}
c.words = r;
return c;
}
Env.diag(e: self ref Env, s: string): string
{
return where(e) + s;
}
Env.usage(e: self ref Env, s: string)
{
e.report("usage: " + s);
}
Env.report(e: self ref Env, s: string)
{
sys->fprint(e.stderr, "%s\n", e.diag(s));
if (e.flags & ERaise)
exits("error");
}
Env.error(e: self ref Env, s: string)
{
e.report(s);
cleanup();
}
panic(s: string)
{
raise "panic: " + s;
}
prprompt(n: int)
{
case n {
0 =>
sys->print("%s", prompt);
1 =>
sys->print("%s", contin);
}
}
Env.couldnot(e: self ref Env, what, who: string)
{
sys->fprint(e.stderr, "could not %s %s: %r\n", what, who);
exits("system error");
}
cleanup()
{
exit;
}
exits(s: string)
{
raise "fail: mash " + s;
}