ref: 3efb5bbb4061056e523858b134c555949591efe2
dir: /appl/lib/plumbing.b/
implement Plumbing;
include "sys.m";
sys: Sys;
include "regex.m";
regex: Regex;
include "plumbing.m";
init(regexmod: Regex, args: list of string): (list of ref Rule, string)
{
sys = load Sys Sys->PATH;
regex = regexmod;
if(args == nil){
user := readfile("/dev/user");
if(user == nil)
return (nil, sys->sprint("can't read /dev/user: %r"));
filename := "/usr/"+user+"/plumbing";
(rc, nil) := sys->stat(filename);
if(rc < 0)
filename = "/usr/"+user+"/lib/plumbing";
args = filename :: nil;
}
r, rules: list of ref Rule;
err: string;
while(args != nil){
filename := hd args;
args = tl args;
file := readfile(filename);
if(file == nil)
return (nil, sys->sprint("can't read %s: %r", filename));
(r, err) = parse(filename, file);
if(err != nil)
return (nil, err);
while(r != nil){
rules = hd r :: rules;
r = tl r;
}
}
# reverse the rules
r = nil;
while(rules != nil){
r = hd rules :: r;
rules = tl rules;
}
return (r, nil);
}
readfile(filename: string): string
{
fd := sys->open(filename, Sys->OREAD);
if(fd == nil)
return nil;
(ok, dir) := sys->fstat(fd);
if(ok < 0)
return nil;
size := int dir.length;
if(size == 0) # devices have length 0 sometimes
size = 1000;
b := array[size] of byte;
n := sys->read(fd, b, len b);
if(n <= 0)
return nil;
return string b[0:n];
}
parse(filename, file: string): (list of ref Rule, string)
{
line: string;
lineno := 0;
i := 0;
pats: list of ref Pattern;
rules: list of ref Rule;
while(i < len file){
lineno++;
(line, i) = nextline(file, i);
(pat, err) := pattern(line);
if(err != nil)
return (nil, sys->sprint("%s:%d: %s", filename, lineno, err));
if(pat == nil){
if(pats==nil || !blank(line)) # comment line
continue;
(rul, err1) := rule(pats);
if(err1 != nil)
return (nil, sys->sprint("%s:%d: %s", filename, lineno-1, err1));
rules = rul :: rules;
pats = nil;
}else
pats = pat :: pats;
}
if(pats != nil){
(rul, err1) := rule(pats);
if(err1 != nil)
return (nil, sys->sprint("%s:%d: %s", filename, lineno-1, err1));
rules = rul :: rules;
}
# reverse the rules
r: list of ref Rule;
while(rules != nil){
r = hd rules :: r;
rules = tl rules;
}
return (r, nil);
}
nextline(file: string, i: int): (string, int)
{
for(j:=i; j<len file; j++)
if(file[j] == '\n')
return (file[i:j], j+1);
return (file[i:], len file);
}
blank(line: string): int
{
for(i:=0; i<len line; i++)
if(line[i]!=' ' && line[i]!='\t')
return 0;
return 1;
}
pattern(line: string): (ref Pattern, string)
{
expand := 0;
for(i:=0; i<len line; i++)
if(line[i] == '$'){
expand = 1;
break;
}
(w, err) := words(line);
if(err != nil)
return (nil, err);
if(w == nil)
return (nil, nil);
if(len w < 3)
return (nil, "syntax error: too few words on line");
pat := ref Pattern;
pat.field = hd w;
pat.pred = hd tl w;
pat.arg = hd tl tl w;
pat.extra = tl tl tl w;
pat.expand = expand;
return (pat, nil);
}
rule(pats: list of ref Pattern): (ref Rule, string)
{
# pats is in reverse order on arrival
actionpred := list of {"alwaysstart", "start", "to"};
patternpred := list of {"is", "isdir", "isfile", "matches", "set"};
npats := 0;
nacts := 0;
haveto := 0;
for(l:=pats; l!=nil; l=tl l){
pat := hd l;
pred := pat.pred;
noextra := 1;
case pat.field {
"plumb" =>
nacts++;
if(!oneof(pred, actionpred))
return (nil, "illegal predicate "+pred+" in action");
case pred {
"to" or "alwaysstart" =>
if(len pat.arg == 0)
return (nil, "\"plumb "+pred+"\" must have non-empty target");
haveto = 1;
"start" =>
noextra = 0;
}
if(npats != 0)
return (nil, "actions must follow patterns in rule");
"src" or "dst" or "dir" or "kind" or "attr" or "data" =>
if(!oneof(pred, patternpred))
return (nil, "illegal predicate "+pred+" in pattern");
if(pred == "matches"){
(pat.regex, nil) = regex->compile(pat.arg, 1);
if(pat.regex == nil)
return (nil, sys->sprint("error in regular expression '%s'", pat.arg));
}
npats++;
}
if(noextra && pat.extra != nil)
return (nil, sys->sprint("too many words in '%s' pattern", pat.field));
}
if(haveto == 0)
return (nil, "rule must have \"plumb to\" action");
rule := ref Rule;
rule.action = array[nacts] of ref Pattern;
for(i:=nacts; --i>=0; ){
rule.action[i] = hd pats;
pats = tl pats;
}
rule.pattern = array[npats] of ref Pattern;
for(i=npats; --i>=0; ){
rule.pattern[i] = hd pats;
pats = tl pats;
}
return (rule, nil);
}
oneof(word: string, words: list of string): int
{
while(words != nil){
if(word == hd words)
return 1;
words = tl words;
}
return 0;
}
words(line: string): (list of string, string)
{
ws: list of string;
i := 0;
for(;;){
# not in word; find beginning of word
while(i<len line && (line[i]==' ' || line[i]=='\t'))
i++;
if(i==len line || line[i]=='#')
break;
# i is first character of word; is it quoted?
if(line[i] == '\''){
word := "";
i++;
while(i < len line){
c := line[i++];
if(c=='\''){
if(i==len line || line[i]!='\'')
break;
# else it's a literal quote
if(i < len line)
i++;
}
word[len word] = c;
}
ws = word :: ws;
continue;
}
# regular word; continue until white space or end
start := i;
while(i<len line && (line[i]!=' ' && line[i]!='\t'))
i++;
ws = line[start:i] :: ws;
}
r: list of string;
while(ws != nil){
r = hd ws :: r;
ws = tl ws;
}
return (r, nil);
}