ruleset.go -> rules.go

ruleset.go

@@ -1,179 +0,0 @@
-// Mkfiles are parsed into ruleSets, which as the name suggests, are sets of
-// rules with accompanying recipes, as well as assigned variables which are
-// expanding when evaluating rules and recipes.
-
-package main
-
-import (
-	"fmt"
-	"regexp"
-	"sync"
-	"unicode/utf8"
-)
-
-type attribSet struct {
-	delFailed       bool // delete targets when the recipe fails
-	nonstop         bool // don't stop if the recipe fails
-	forcedTimestamp bool // update timestamp whether the recipe does or not
-	nonvirtual      bool // a meta-rule that will only match files
-	quiet           bool // don't print the recipe
-	regex           bool // regular expression meta-rule
-	update          bool // treat the targets as if they were updated
-	virtual         bool // rule is virtual (does not match files)
-}
-
-// Error parsing an attribute
-type attribError struct {
-	found rune
-}
-
-// target and rereq patterns
-type pattern struct {
-	issuffix bool           // is a suffix '%' rule, so we should define $stem.
-	spat     string         // simple string pattern
-	rpat     *regexp.Regexp // non-nil if this is a regexp pattern
-}
-
-// Match a pattern, returning an array of submatches, or nil if it doesn'm
-// match.
-func (p *pattern) match(target string) []string {
-	if p.rpat != nil {
-		return p.rpat.FindStringSubmatch(target)
-	}
-
-	if target == p.spat {
-		return make([]string, 0)
-	}
-
-	return nil
-}
-
-// A single rule.
-type rule struct {
-	targets    []pattern  // non-empty array of targets
-	attributes attribSet  // rule attributes
-	prereqs    []string   // possibly empty prerequesites
-	shell      []string   // command used to execute the recipe
-	recipe     string     // recipe source
-	command    []string   // command attribute
-	ismeta     bool       // is this a meta rule
-	mutex      sync.Mutex // prevent the rule from being executed multiple times
-}
-
-// A set of rules.
-type ruleSet struct {
-	vars  map[string][]string
-	rules []rule
-	// map a target to an array of indexes into rules
-	targetrules map[string][]int
-}
-
-// Read attributes for an array of strings, updating the rule.
-func (r *rule) parseAttribs(inputs []string) *attribError {
-	for i := 0; i < len(inputs); i++ {
-		input := inputs[i]
-		pos := 0
-		for pos < len(input) {
-			c, w := utf8.DecodeRuneInString(input[pos:])
-			switch c {
-			case 'D':
-				r.attributes.delFailed = true
-			case 'E':
-				r.attributes.nonstop = true
-			case 'N':
-				r.attributes.forcedTimestamp = true
-			case 'n':
-				r.attributes.nonvirtual = true
-			case 'Q':
-				r.attributes.quiet = true
-			case 'R':
-				r.attributes.regex = true
-			case 'U':
-				r.attributes.update = true
-			case 'V':
-				r.attributes.virtual = true
-			case 'P':
-				if pos+w < len(input) {
-					r.command = append(r.command, input[pos+w:])
-				}
-				r.command = append(r.command, inputs[i+1:]...)
-				return nil
-
-			case 'S':
-				if pos+w < len(input) {
-					r.shell = append(r.shell, input[pos+w:])
-				}
-				r.shell = append(r.shell, inputs[i+1:]...)
-				return nil
-
-			default:
-				return &attribError{c}
-			}
-
-			pos += w
-		}
-	}
-
-	return nil
-}
-
-// Add a rule to the rule set.
-func (rs *ruleSet) add(r rule) {
-	rs.rules = append(rs.rules, r)
-	k := len(rs.rules) - 1
-	for i := range r.targets {
-		if r.targets[i].rpat == nil {
-			rs.targetrules[r.targets[i].spat] =
-				append(rs.targetrules[r.targets[i].spat], k)
-		}
-	}
-}
-
-func isValidVarName(v string) bool {
-	for i := 0; i < len(v); {
-		c, w := utf8.DecodeRuneInString(v[i:])
-		if i == 0 && !(isalpha(c) || c == '_') {
-			return false
-		} else if !(isalnum(c) || c == '_') {
-			return false
-		}
-		i += w
-	}
-	return true
-}
-
-func isdigit(c rune) bool {
-	return '0' <= c && c <= '9'
-}
-
-func isalpha(c rune) bool {
-	return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')
-}
-
-func isalnum(c rune) bool {
-	return isalpha(c) || isdigit(c)
-}
-
-type assignmentError struct {
-	what  string
-	where token
-}
-
-// Parse and execute assignment operation.
-func (rs *ruleSet) executeAssignment(ts []token) *assignmentError {
-	assignee := ts[0].val
-	if !isValidVarName(assignee) {
-		return &assignmentError{
-			fmt.Sprintf("target of assignment is not a valid variable name: \"%s\"", assignee),
-			ts[0]}
-	}
-
-	// expanded variables
-	vals := make([]string, 0)
-	for i := 1; i < len(ts); i++ {
-		vals = append(vals, expand(ts[i].val, rs.vars, true)...)
-	}
-
-	rs.vars[assignee] = vals
-	return nil
-}