2014-08-05 20:17:40 +00:00
|
|
|
// This package implements a parser and parse tree dumper for Dockerfiles.
|
|
|
|
package parser
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bufio"
|
|
|
|
"io"
|
|
|
|
"regexp"
|
|
|
|
"strings"
|
2014-10-02 23:58:53 +00:00
|
|
|
"unicode"
|
2014-08-05 20:17:40 +00:00
|
|
|
)
|
|
|
|
|
2014-08-07 05:56:44 +00:00
|
|
|
// Node is a structure used to represent a parse tree.
|
2014-08-05 20:17:40 +00:00
|
|
|
//
|
2014-08-07 05:56:44 +00:00
|
|
|
// In the node there are three fields, Value, Next, and Children. Value is the
|
|
|
|
// current token's string value. Next is always the next non-child token, and
|
|
|
|
// children contains all the children. Here's an example:
|
2014-08-05 20:17:40 +00:00
|
|
|
//
|
2014-08-07 05:56:44 +00:00
|
|
|
// (value next (child child-next child-next-next) next-next)
|
2014-08-05 20:17:40 +00:00
|
|
|
//
|
2014-08-07 05:56:44 +00:00
|
|
|
// This data structure is frankly pretty lousy for handling complex languages,
|
|
|
|
// but lucky for us the Dockerfile isn't very complicated. This structure
|
|
|
|
// works a little more effectively than a "proper" parse tree for our needs.
|
2014-08-05 20:17:40 +00:00
|
|
|
//
|
|
|
|
type Node struct {
|
2014-08-13 10:07:41 +00:00
|
|
|
Value string // actual content
|
|
|
|
Next *Node // the next item in the current sexp
|
|
|
|
Children []*Node // the children of this sexp
|
|
|
|
Attributes map[string]bool // special attributes for this node
|
2014-10-13 20:14:35 +00:00
|
|
|
Original string // original line used before parsing
|
2014-08-05 20:17:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
var (
|
2014-08-13 10:07:41 +00:00
|
|
|
dispatch map[string]func(string) (*Node, map[string]bool, error)
|
2014-08-05 22:41:09 +00:00
|
|
|
TOKEN_WHITESPACE = regexp.MustCompile(`[\t\v\f\r ]+`)
|
2014-10-15 03:08:04 +00:00
|
|
|
TOKEN_LINE_CONTINUATION = regexp.MustCompile(`\\\s*$`)
|
2014-08-05 20:17:40 +00:00
|
|
|
TOKEN_COMMENT = regexp.MustCompile(`^#.*$`)
|
|
|
|
)
|
|
|
|
|
|
|
|
func init() {
|
|
|
|
// Dispatch Table. see line_parsers.go for the parse functions.
|
|
|
|
// The command is parsed and mapped to the line parser. The line parser
|
|
|
|
// recieves the arguments but not the command, and returns an AST after
|
|
|
|
// reformulating the arguments according to the rules in the parser
|
|
|
|
// functions. Errors are propogated up by Parse() and the resulting AST can
|
|
|
|
// be incorporated directly into the existing AST as a next.
|
2014-08-13 10:07:41 +00:00
|
|
|
dispatch = map[string]func(string) (*Node, map[string]bool, error){
|
2014-10-07 03:24:43 +00:00
|
|
|
"user": parseString,
|
|
|
|
"onbuild": parseSubCommand,
|
|
|
|
"workdir": parseString,
|
|
|
|
"env": parseEnv,
|
|
|
|
"maintainer": parseString,
|
|
|
|
"from": parseString,
|
|
|
|
"add": parseStringsWhitespaceDelimited,
|
|
|
|
"copy": parseStringsWhitespaceDelimited,
|
|
|
|
"run": parseMaybeJSON,
|
|
|
|
"cmd": parseMaybeJSON,
|
|
|
|
"entrypoint": parseMaybeJSON,
|
|
|
|
"expose": parseStringsWhitespaceDelimited,
|
|
|
|
"volume": parseMaybeJSONToList,
|
|
|
|
"insert": parseIgnore,
|
2014-08-05 20:17:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-07 05:56:44 +00:00
|
|
|
// parse a line and return the remainder.
|
2014-08-05 20:17:40 +00:00
|
|
|
func parseLine(line string) (string, *Node, error) {
|
|
|
|
if line = stripComments(line); line == "" {
|
|
|
|
return "", nil, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if TOKEN_LINE_CONTINUATION.MatchString(line) {
|
|
|
|
line = TOKEN_LINE_CONTINUATION.ReplaceAllString(line, "")
|
|
|
|
return line, nil, nil
|
|
|
|
}
|
|
|
|
|
2014-10-15 03:33:11 +00:00
|
|
|
cmd, args, err := splitCommand(line)
|
|
|
|
if err != nil {
|
|
|
|
return "", nil, err
|
|
|
|
}
|
2014-08-05 20:17:40 +00:00
|
|
|
|
2014-08-10 11:01:10 +00:00
|
|
|
node := &Node{}
|
2014-08-05 20:17:40 +00:00
|
|
|
node.Value = cmd
|
|
|
|
|
2014-08-13 10:07:41 +00:00
|
|
|
sexp, attrs, err := fullDispatch(cmd, args)
|
2014-08-05 20:17:40 +00:00
|
|
|
if err != nil {
|
|
|
|
return "", nil, err
|
|
|
|
}
|
|
|
|
|
2014-08-29 20:04:34 +00:00
|
|
|
if sexp.Value != "" || sexp.Next != nil || sexp.Children != nil {
|
|
|
|
node.Next = sexp
|
|
|
|
}
|
2014-08-05 20:17:40 +00:00
|
|
|
|
2014-10-24 00:23:25 +00:00
|
|
|
node.Attributes = attrs
|
|
|
|
node.Original = line
|
|
|
|
|
2014-08-05 20:17:40 +00:00
|
|
|
return "", node, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// The main parse routine. Handles an io.ReadWriteCloser and returns the root
|
|
|
|
// of the AST.
|
|
|
|
func Parse(rwc io.Reader) (*Node, error) {
|
2014-08-10 11:01:10 +00:00
|
|
|
root := &Node{}
|
2014-08-05 20:17:40 +00:00
|
|
|
scanner := bufio.NewScanner(rwc)
|
|
|
|
|
|
|
|
for scanner.Scan() {
|
2014-10-15 08:44:14 +00:00
|
|
|
scannedLine := strings.TrimLeftFunc(scanner.Text(), unicode.IsSpace)
|
|
|
|
if stripComments(scannedLine) == "" {
|
2014-10-15 04:00:17 +00:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2014-10-15 08:44:14 +00:00
|
|
|
line, child, err := parseLine(scannedLine)
|
2014-08-05 20:17:40 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if line != "" && child == nil {
|
2014-08-19 11:14:21 +00:00
|
|
|
for scanner.Scan() {
|
2014-10-02 23:58:53 +00:00
|
|
|
newline := scanner.Text()
|
2014-08-05 20:17:40 +00:00
|
|
|
|
2014-10-15 08:44:14 +00:00
|
|
|
if stripComments(strings.TrimSpace(newline)) == "" {
|
2014-08-05 20:17:40 +00:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
line, child, err = parseLine(line + newline)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if child != nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if child != nil {
|
|
|
|
root.Children = append(root.Children, child)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return root, nil
|
|
|
|
}
|