Function Parse

parser/parser.go:89–135

Parse is the main function to parse a Makefile from a file path string to a Makefile struct. This function should be kept fairly small and ideally most of the heavy lifting will live in the specific parsing functions below that know how to deal with individual lines.

(filepath string)

// of the heavy lifting will live in the specific parsing functions below that
// know how to deal with individual lines.
func Parse(filepath string) (ret Makefile, err error) {
	ret.FileName = filepath
	var scanner *MakefileScanner
	scanner, err = NewMakefileScanner(filepath)
	if err != nil {
		return ret, err
	}

	for {
		switch {
		case strings.HasPrefix(scanner.Text(), "#"):
			// parse comments here, ignoring them for now
			scanner.Scan()
		case strings.HasPrefix(scanner.Text(), "."):
			if matches := reFindSpecialTarget.FindStringSubmatch(scanner.Text()); matches != nil {
				// Treat special targets like .PHONY or .DEFAULT_GOAL as rules, not variables
				specialRule := Rule{
					Target:       strings.TrimSpace(matches[1]),
					Dependencies: strings.Fields(strings.TrimSpace(matches[2])),
					Body:         nil,
					FileName:     filepath,
					LineNumber:   scanner.LineNumber,
				}
				ret.Rules = append(ret.Rules, specialRule)
			}
			scanner.Scan()
		default:
			// parse target or variable here, the function advances the scanner
			// itself to be able to detect rule bodies
			ruleOrVariable, parseError := parseRuleOrVariable(scanner)
			if parseError != nil {
				return ret, parseError
			}
			switch v := ruleOrVariable.(type) {
			case Rule:
				ret.Rules = append(ret.Rules, v)
			case Variable:
				ret.Variables = append(ret.Variables, v)
			}

		}

		if scanner.Finished {
			return
		}
	}
}

// parseRuleOrVariable gets the parsing scanner in a state where it resides on
// a line that could be a variable or a rule. The function parses the line and