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);
}