dockerfile: update imports

Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com>

frontend/dockerfile/command/command.go

@@ -1,5 +1,5 @@
 // Package command contains the set of Dockerfile commands.
-package command // import "github.com/docker/docker/builder/dockerfile/command"
+package command
 
 // Define constants for the command strings
 const (

frontend/dockerfile/dockerfile2llb/convert.go

@@ -13,13 +13,13 @@ import (
 	"strings"
 
 	"github.com/docker/distribution/reference"
-	"github.com/docker/docker/builder/dockerfile/instructions"
-	"github.com/docker/docker/builder/dockerfile/parser"
-	"github.com/docker/docker/builder/dockerfile/shell"
 	"github.com/docker/docker/pkg/signal"
 	"github.com/docker/go-connections/nat"
 	"github.com/moby/buildkit/client/llb"
 	"github.com/moby/buildkit/client/llb/imagemetaresolver"
+	"github.com/moby/buildkit/frontend/dockerfile/instructions"
+	"github.com/moby/buildkit/frontend/dockerfile/parser"
+	"github.com/moby/buildkit/frontend/dockerfile/shell"
 	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
 	"github.com/pkg/errors"
 	"golang.org/x/sync/errgroup"

frontend/dockerfile/instructions/bflag.go

@@ -1,4 +1,4 @@
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
+package instructions
 
 import (
 	"fmt"

frontend/dockerfile/instructions/bflag_test.go

@@ -1,4 +1,4 @@
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
+package instructions
 
 import (
 	"testing"

frontend/dockerfile/instructions/commands.go

@@ -1,4 +1,4 @@
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
+package instructions
 
 import (
 	"errors"

frontend/dockerfile/instructions/errors_unix.go

@@ -1,6 +1,6 @@
 // +build !windows
 
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
+package instructions
 
 import "fmt"
 

frontend/dockerfile/instructions/errors_windows.go

@@ -1,4 +1,4 @@
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
+package instructions
 
 import (
 	"fmt"

frontend/dockerfile/instructions/parse.go

@@ -1,4 +1,4 @@
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
+package instructions
 
 import (
 	"fmt"
@@ -10,9 +10,9 @@ import (
 
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/strslice"
-	"github.com/docker/docker/builder/dockerfile/command"
-	"github.com/docker/docker/builder/dockerfile/parser"
 	"github.com/docker/docker/pkg/system"
+	"github.com/moby/buildkit/frontend/dockerfile/command"
+	"github.com/moby/buildkit/frontend/dockerfile/parser"
 	"github.com/pkg/errors"
 )
 

frontend/dockerfile/instructions/parse_test.go

@@ -1,13 +1,13 @@
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
+package instructions
 
 import (
 	"strings"
 	"testing"
 
-	"github.com/docker/docker/builder/dockerfile/command"
-	"github.com/docker/docker/builder/dockerfile/parser"
 	"github.com/gotestyourself/gotestyourself/assert"
 	is "github.com/gotestyourself/gotestyourself/assert/cmp"
+	"github.com/moby/buildkit/frontend/dockerfile/command"
+	"github.com/moby/buildkit/frontend/dockerfile/parser"
 )
 
 func TestCommandsExactlyOneArgument(t *testing.T) {

frontend/dockerfile/instructions/support.go

@@ -1,4 +1,4 @@
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
+package instructions
 
 import "strings"
 

frontend/dockerfile/instructions/support_test.go

@@ -1,4 +1,4 @@
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
+package instructions
 
 import "testing"
 

frontend/dockerfile/parser/dumper/main.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/docker/docker/builder/dockerfile/parser"
+	"github.com/moby/buildkit/frontend/dockerfile/parser"
 )
 
 func main() {

frontend/dockerfile/parser/json_test.go

@@ -1,4 +1,4 @@
-package parser // import "github.com/docker/docker/builder/dockerfile/parser"
+package parser
 
 import (
 	"testing"

frontend/dockerfile/parser/line_parsers.go

@@ -1,4 +1,4 @@
-package parser // import "github.com/docker/docker/builder/dockerfile/parser"
+package parser
 
 // line parsers are dispatch calls that parse a single unit of text into a
 // Node object which contains the whole statement. Dockerfiles have varied

frontend/dockerfile/parser/line_parsers_test.go

@@ -1,4 +1,4 @@
-package parser // import "github.com/docker/docker/builder/dockerfile/parser"
+package parser
 
 import (
 	"testing"

frontend/dockerfile/parser/parser.go

@@ -1,5 +1,5 @@
 // Package parser implements a parser and parse tree dumper for Dockerfiles.
-package parser // import "github.com/docker/docker/builder/dockerfile/parser"
+package parser
 
 import (
 	"bufio"
@@ -11,7 +11,7 @@ import (
 	"strings"
 	"unicode"
 
-	"github.com/docker/docker/builder/dockerfile/command"
+	"github.com/moby/buildkit/frontend/dockerfile/command"
 	"github.com/pkg/errors"
 )
 

frontend/dockerfile/parser/parser_test.go

@@ -1,4 +1,4 @@
-package parser // import "github.com/docker/docker/builder/dockerfile/parser"
+package parser
 
 import (
 	"bufio"

frontend/dockerfile/parser/split_command.go

@@ -1,4 +1,4 @@
-package parser // import "github.com/docker/docker/builder/dockerfile/parser"
+package parser
 
 import (
 	"strings"

frontend/dockerfile/shell/equal_env_unix.go

@@ -1,6 +1,6 @@
 // +build !windows
 
-package shell // import "github.com/docker/docker/builder/dockerfile/shell"
+package shell
 
 // EqualEnvKeys compare two strings and returns true if they are equal. On
 // Windows this comparison is case insensitive.

frontend/dockerfile/shell/equal_env_windows.go

@@ -1,4 +1,4 @@
-package shell // import "github.com/docker/docker/builder/dockerfile/shell"
+package shell
 
 import "strings"
 

frontend/dockerfile/shell/lex.go

@@ -1,4 +1,4 @@
-package shell // import "github.com/docker/docker/builder/dockerfile/shell"
+package shell
 
 import (
 	"bytes"

frontend/dockerfile/shell/lex_test.go

@@ -1,4 +1,4 @@
-package shell // import "github.com/docker/docker/builder/dockerfile/shell"
+package shell
 
 import (
 	"bufio"

vendor/github.com/docker/docker/builder/dockerfile/command/command.go

@@ -1,46 +0,0 @@
-// Package command contains the set of Dockerfile commands.
-package command // import "github.com/docker/docker/builder/dockerfile/command"
-
-// Define constants for the command strings
-const (
-	Add         = "add"
-	Arg         = "arg"
-	Cmd         = "cmd"
-	Copy        = "copy"
-	Entrypoint  = "entrypoint"
-	Env         = "env"
-	Expose      = "expose"
-	From        = "from"
-	Healthcheck = "healthcheck"
-	Label       = "label"
-	Maintainer  = "maintainer"
-	Onbuild     = "onbuild"
-	Run         = "run"
-	Shell       = "shell"
-	StopSignal  = "stopsignal"
-	User        = "user"
-	Volume      = "volume"
-	Workdir     = "workdir"
-)
-
-// Commands is list of all Dockerfile commands
-var Commands = map[string]struct{}{
-	Add:         {},
-	Arg:         {},
-	Cmd:         {},
-	Copy:        {},
-	Entrypoint:  {},
-	Env:         {},
-	Expose:      {},
-	From:        {},
-	Healthcheck: {},
-	Label:       {},
-	Maintainer:  {},
-	Onbuild:     {},
-	Run:         {},
-	Shell:       {},
-	StopSignal:  {},
-	User:        {},
-	Volume:      {},
-	Workdir:     {},
-}

vendor/github.com/docker/docker/builder/dockerfile/instructions/bflag.go

@@ -1,183 +0,0 @@
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
-
-import (
-	"fmt"
-	"strings"
-)
-
-// FlagType is the type of the build flag
-type FlagType int
-
-const (
-	boolType FlagType = iota
-	stringType
-)
-
-// BFlags contains all flags information for the builder
-type BFlags struct {
-	Args  []string // actual flags/args from cmd line
-	flags map[string]*Flag
-	used  map[string]*Flag
-	Err   error
-}
-
-// Flag contains all information for a flag
-type Flag struct {
-	bf       *BFlags
-	name     string
-	flagType FlagType
-	Value    string
-}
-
-// NewBFlags returns the new BFlags struct
-func NewBFlags() *BFlags {
-	return &BFlags{
-		flags: make(map[string]*Flag),
-		used:  make(map[string]*Flag),
-	}
-}
-
-// NewBFlagsWithArgs returns the new BFlags struct with Args set to args
-func NewBFlagsWithArgs(args []string) *BFlags {
-	flags := NewBFlags()
-	flags.Args = args
-	return flags
-}
-
-// AddBool adds a bool flag to BFlags
-// Note, any error will be generated when Parse() is called (see Parse).
-func (bf *BFlags) AddBool(name string, def bool) *Flag {
-	flag := bf.addFlag(name, boolType)
-	if flag == nil {
-		return nil
-	}
-	if def {
-		flag.Value = "true"
-	} else {
-		flag.Value = "false"
-	}
-	return flag
-}
-
-// AddString adds a string flag to BFlags
-// Note, any error will be generated when Parse() is called (see Parse).
-func (bf *BFlags) AddString(name string, def string) *Flag {
-	flag := bf.addFlag(name, stringType)
-	if flag == nil {
-		return nil
-	}
-	flag.Value = def
-	return flag
-}
-
-// addFlag is a generic func used by the other AddXXX() func
-// to add a new flag to the BFlags struct.
-// Note, any error will be generated when Parse() is called (see Parse).
-func (bf *BFlags) addFlag(name string, flagType FlagType) *Flag {
-	if _, ok := bf.flags[name]; ok {
-		bf.Err = fmt.Errorf("Duplicate flag defined: %s", name)
-		return nil
-	}
-
-	newFlag := &Flag{
-		bf:       bf,
-		name:     name,
-		flagType: flagType,
-	}
-	bf.flags[name] = newFlag
-
-	return newFlag
-}
-
-// IsUsed checks if the flag is used
-func (fl *Flag) IsUsed() bool {
-	if _, ok := fl.bf.used[fl.name]; ok {
-		return true
-	}
-	return false
-}
-
-// IsTrue checks if a bool flag is true
-func (fl *Flag) IsTrue() bool {
-	if fl.flagType != boolType {
-		// Should never get here
-		panic(fmt.Errorf("Trying to use IsTrue on a non-boolean: %s", fl.name))
-	}
-	return fl.Value == "true"
-}
-
-// Parse parses and checks if the BFlags is valid.
-// Any error noticed during the AddXXX() funcs will be generated/returned
-// here.  We do this because an error during AddXXX() is more like a
-// compile time error so it doesn't matter too much when we stop our
-// processing as long as we do stop it, so this allows the code
-// around AddXXX() to be just:
-//     defFlag := AddString("description", "")
-// w/o needing to add an if-statement around each one.
-func (bf *BFlags) Parse() error {
-	// If there was an error while defining the possible flags
-	// go ahead and bubble it back up here since we didn't do it
-	// earlier in the processing
-	if bf.Err != nil {
-		return fmt.Errorf("Error setting up flags: %s", bf.Err)
-	}
-
-	for _, arg := range bf.Args {
-		if !strings.HasPrefix(arg, "--") {
-			return fmt.Errorf("Arg should start with -- : %s", arg)
-		}
-
-		if arg == "--" {
-			return nil
-		}
-
-		arg = arg[2:]
-		value := ""
-
-		index := strings.Index(arg, "=")
-		if index >= 0 {
-			value = arg[index+1:]
-			arg = arg[:index]
-		}
-
-		flag, ok := bf.flags[arg]
-		if !ok {
-			return fmt.Errorf("Unknown flag: %s", arg)
-		}
-
-		if _, ok = bf.used[arg]; ok {
-			return fmt.Errorf("Duplicate flag specified: %s", arg)
-		}
-
-		bf.used[arg] = flag
-
-		switch flag.flagType {
-		case boolType:
-			// value == "" is only ok if no "=" was specified
-			if index >= 0 && value == "" {
-				return fmt.Errorf("Missing a value on flag: %s", arg)
-			}
-
-			lower := strings.ToLower(value)
-			if lower == "" {
-				flag.Value = "true"
-			} else if lower == "true" || lower == "false" {
-				flag.Value = lower
-			} else {
-				return fmt.Errorf("Expecting boolean value for flag %s, not: %s", arg, value)
-			}
-
-		case stringType:
-			if index < 0 {
-				return fmt.Errorf("Missing a value on flag: %s", arg)
-			}
-			flag.Value = value
-
-		default:
-			panic("No idea what kind of flag we have! Should never get here!")
-		}
-
-	}
-
-	return nil
-}

vendor/github.com/docker/docker/builder/dockerfile/instructions/commands.go

@@ -1,418 +0,0 @@
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
-
-import (
-	"errors"
-	"strings"
-
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/strslice"
-	specs "github.com/opencontainers/image-spec/specs-go/v1"
-)
-
-// KeyValuePair represent an arbitrary named value (useful in slice instead of map[string] string to preserve ordering)
-type KeyValuePair struct {
-	Key   string
-	Value string
-}
-
-func (kvp *KeyValuePair) String() string {
-	return kvp.Key + "=" + kvp.Value
-}
-
-// Command is implemented by every command present in a dockerfile
-type Command interface {
-	Name() string
-}
-
-// KeyValuePairs is a slice of KeyValuePair
-type KeyValuePairs []KeyValuePair
-
-// withNameAndCode is the base of every command in a Dockerfile (String() returns its source code)
-type withNameAndCode struct {
-	code string
-	name string
-}
-
-func (c *withNameAndCode) String() string {
-	return c.code
-}
-
-// Name of the command
-func (c *withNameAndCode) Name() string {
-	return c.name
-}
-
-func newWithNameAndCode(req parseRequest) withNameAndCode {
-	return withNameAndCode{code: strings.TrimSpace(req.original), name: req.command}
-}
-
-// SingleWordExpander is a provider for variable expansion where 1 word => 1 output
-type SingleWordExpander func(word string) (string, error)
-
-// SupportsSingleWordExpansion interface marks a command as supporting variable expansion
-type SupportsSingleWordExpansion interface {
-	Expand(expander SingleWordExpander) error
-}
-
-// PlatformSpecific adds platform checks to a command
-type PlatformSpecific interface {
-	CheckPlatform(platform string) error
-}
-
-func expandKvp(kvp KeyValuePair, expander SingleWordExpander) (KeyValuePair, error) {
-	key, err := expander(kvp.Key)
-	if err != nil {
-		return KeyValuePair{}, err
-	}
-	value, err := expander(kvp.Value)
-	if err != nil {
-		return KeyValuePair{}, err
-	}
-	return KeyValuePair{Key: key, Value: value}, nil
-}
-func expandKvpsInPlace(kvps KeyValuePairs, expander SingleWordExpander) error {
-	for i, kvp := range kvps {
-		newKvp, err := expandKvp(kvp, expander)
-		if err != nil {
-			return err
-		}
-		kvps[i] = newKvp
-	}
-	return nil
-}
-
-func expandSliceInPlace(values []string, expander SingleWordExpander) error {
-	for i, v := range values {
-		newValue, err := expander(v)
-		if err != nil {
-			return err
-		}
-		values[i] = newValue
-	}
-	return nil
-}
-
-// EnvCommand : ENV key1 value1 [keyN valueN...]
-type EnvCommand struct {
-	withNameAndCode
-	Env KeyValuePairs // kvp slice instead of map to preserve ordering
-}
-
-// Expand variables
-func (c *EnvCommand) Expand(expander SingleWordExpander) error {
-	return expandKvpsInPlace(c.Env, expander)
-}
-
-// MaintainerCommand : MAINTAINER maintainer_name
-type MaintainerCommand struct {
-	withNameAndCode
-	Maintainer string
-}
-
-// NewLabelCommand creates a new 'LABEL' command
-func NewLabelCommand(k string, v string, NoExp bool) *LabelCommand {
-	kvp := KeyValuePair{Key: k, Value: v}
-	c := "LABEL "
-	c += kvp.String()
-	nc := withNameAndCode{code: c, name: "label"}
-	cmd := &LabelCommand{
-		withNameAndCode: nc,
-		Labels: KeyValuePairs{
-			kvp,
-		},
-		noExpand: NoExp,
-	}
-	return cmd
-}
-
-// LabelCommand : LABEL some json data describing the image
-//
-// Sets the Label variable foo to bar,
-//
-type LabelCommand struct {
-	withNameAndCode
-	Labels   KeyValuePairs // kvp slice instead of map to preserve ordering
-	noExpand bool
-}
-
-// Expand variables
-func (c *LabelCommand) Expand(expander SingleWordExpander) error {
-	if c.noExpand {
-		return nil
-	}
-	return expandKvpsInPlace(c.Labels, expander)
-}
-
-// SourcesAndDest represent a list of source files and a destination
-type SourcesAndDest []string
-
-// Sources list the source paths
-func (s SourcesAndDest) Sources() []string {
-	res := make([]string, len(s)-1)
-	copy(res, s[:len(s)-1])
-	return res
-}
-
-// Dest path of the operation
-func (s SourcesAndDest) Dest() string {
-	return s[len(s)-1]
-}
-
-// AddCommand : ADD foo /path
-//
-// Add the file 'foo' to '/path'. Tarball and Remote URL (git, http) handling
-// exist here. If you do not wish to have this automatic handling, use COPY.
-//
-type AddCommand struct {
-	withNameAndCode
-	SourcesAndDest
-	Chown string
-}
-
-// Expand variables
-func (c *AddCommand) Expand(expander SingleWordExpander) error {
-	return expandSliceInPlace(c.SourcesAndDest, expander)
-}
-
-// CopyCommand : COPY foo /path
-//
-// Same as 'ADD' but without the tar and remote url handling.
-//
-type CopyCommand struct {
-	withNameAndCode
-	SourcesAndDest
-	From  string
-	Chown string
-}
-
-// Expand variables
-func (c *CopyCommand) Expand(expander SingleWordExpander) error {
-	return expandSliceInPlace(c.SourcesAndDest, expander)
-}
-
-// OnbuildCommand : ONBUILD <some other command>
-type OnbuildCommand struct {
-	withNameAndCode
-	Expression string
-}
-
-// WorkdirCommand : WORKDIR /tmp
-//
-// Set the working directory for future RUN/CMD/etc statements.
-//
-type WorkdirCommand struct {
-	withNameAndCode
-	Path string
-}
-
-// Expand variables
-func (c *WorkdirCommand) Expand(expander SingleWordExpander) error {
-	p, err := expander(c.Path)
-	if err != nil {
-		return err
-	}
-	c.Path = p
-	return nil
-}
-
-// ShellDependantCmdLine represents a cmdline optionally prepended with the shell
-type ShellDependantCmdLine struct {
-	CmdLine      strslice.StrSlice
-	PrependShell bool
-}
-
-// RunCommand : RUN some command yo
-//
-// run a command and commit the image. Args are automatically prepended with
-// the current SHELL which defaults to 'sh -c' under linux or 'cmd /S /C' under
-// Windows, in the event there is only one argument The difference in processing:
-//
-// RUN echo hi          # sh -c echo hi       (Linux)
-// RUN echo hi          # cmd /S /C echo hi   (Windows)
-// RUN [ "echo", "hi" ] # echo hi
-//
-type RunCommand struct {
-	withNameAndCode
-	ShellDependantCmdLine
-}
-
-// CmdCommand : CMD foo
-//
-// Set the default command to run in the container (which may be empty).
-// Argument handling is the same as RUN.
-//
-type CmdCommand struct {
-	withNameAndCode
-	ShellDependantCmdLine
-}
-
-// HealthCheckCommand : HEALTHCHECK foo
-//
-// Set the default healthcheck command to run in the container (which may be empty).
-// Argument handling is the same as RUN.
-//
-type HealthCheckCommand struct {
-	withNameAndCode
-	Health *container.HealthConfig
-}
-
-// EntrypointCommand : ENTRYPOINT /usr/sbin/nginx
-//
-// Set the entrypoint to /usr/sbin/nginx. Will accept the CMD as the arguments
-// to /usr/sbin/nginx. Uses the default shell if not in JSON format.
-//
-// Handles command processing similar to CMD and RUN, only req.runConfig.Entrypoint
-// is initialized at newBuilder time instead of through argument parsing.
-//
-type EntrypointCommand struct {
-	withNameAndCode
-	ShellDependantCmdLine
-}
-
-// ExposeCommand : EXPOSE 6667/tcp 7000/tcp
-//
-// Expose ports for links and port mappings. This all ends up in
-// req.runConfig.ExposedPorts for runconfig.
-//
-type ExposeCommand struct {
-	withNameAndCode
-	Ports []string
-}
-
-// UserCommand : USER foo
-//
-// Set the user to 'foo' for future commands and when running the
-// ENTRYPOINT/CMD at container run time.
-//
-type UserCommand struct {
-	withNameAndCode
-	User string
-}
-
-// Expand variables
-func (c *UserCommand) Expand(expander SingleWordExpander) error {
-	p, err := expander(c.User)
-	if err != nil {
-		return err
-	}
-	c.User = p
-	return nil
-}
-
-// VolumeCommand : VOLUME /foo
-//
-// Expose the volume /foo for use. Will also accept the JSON array form.
-//
-type VolumeCommand struct {
-	withNameAndCode
-	Volumes []string
-}
-
-// Expand variables
-func (c *VolumeCommand) Expand(expander SingleWordExpander) error {
-	return expandSliceInPlace(c.Volumes, expander)
-}
-
-// StopSignalCommand : STOPSIGNAL signal
-//
-// Set the signal that will be used to kill the container.
-type StopSignalCommand struct {
-	withNameAndCode
-	Signal string
-}
-
-// Expand variables
-func (c *StopSignalCommand) Expand(expander SingleWordExpander) error {
-	p, err := expander(c.Signal)
-	if err != nil {
-		return err
-	}
-	c.Signal = p
-	return nil
-}
-
-// CheckPlatform checks that the command is supported in the target platform
-func (c *StopSignalCommand) CheckPlatform(platform string) error {
-	if platform == "windows" {
-		return errors.New("The daemon on this platform does not support the command stopsignal")
-	}
-	return nil
-}
-
-// ArgCommand : ARG name[=value]
-//
-// Adds the variable foo to the trusted list of variables that can be passed
-// to builder using the --build-arg flag for expansion/substitution or passing to 'run'.
-// Dockerfile author may optionally set a default value of this variable.
-type ArgCommand struct {
-	withNameAndCode
-	Key   string
-	Value *string
-}
-
-// Expand variables
-func (c *ArgCommand) Expand(expander SingleWordExpander) error {
-	p, err := expander(c.Key)
-	if err != nil {
-		return err
-	}
-	c.Key = p
-	if c.Value != nil {
-		p, err = expander(*c.Value)
-		if err != nil {
-			return err
-		}
-		c.Value = &p
-	}
-	return nil
-}
-
-// ShellCommand : SHELL powershell -command
-//
-// Set the non-default shell to use.
-type ShellCommand struct {
-	withNameAndCode
-	Shell strslice.StrSlice
-}
-
-// Stage represents a single stage in a multi-stage build
-type Stage struct {
-	Name       string
-	Commands   []Command
-	BaseName   string
-	SourceCode string
-	Platform   specs.Platform
-}
-
-// AddCommand to the stage
-func (s *Stage) AddCommand(cmd Command) {
-	// todo: validate cmd type
-	s.Commands = append(s.Commands, cmd)
-}
-
-// IsCurrentStage check if the stage name is the current stage
-func IsCurrentStage(s []Stage, name string) bool {
-	if len(s) == 0 {
-		return false
-	}
-	return s[len(s)-1].Name == name
-}
-
-// CurrentStage return the last stage in a slice
-func CurrentStage(s []Stage) (*Stage, error) {
-	if len(s) == 0 {
-		return nil, errors.New("No build stage in current context")
-	}
-	return &s[len(s)-1], nil
-}
-
-// HasStage looks for the presence of a given stage name
-func HasStage(s []Stage, name string) (int, bool) {
-	for i, stage := range s {
-		// Stage name is case-insensitive by design
-		if strings.EqualFold(stage.Name, name) {
-			return i, true
-		}
-	}
-	return -1, false
-}

vendor/github.com/docker/docker/builder/dockerfile/instructions/errors_unix.go

@@ -1,9 +0,0 @@
-// +build !windows
-
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
-
-import "fmt"
-
-func errNotJSON(command, _ string) error {
-	return fmt.Errorf("%s requires the arguments to be in JSON form", command)
-}

vendor/github.com/docker/docker/builder/dockerfile/instructions/errors_windows.go

@@ -1,27 +0,0 @@
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
-
-import (
-	"fmt"
-	"path/filepath"
-	"regexp"
-	"strings"
-)
-
-func errNotJSON(command, original string) error {
-	// For Windows users, give a hint if it looks like it might contain
-	// a path which hasn't been escaped such as ["c:\windows\system32\prog.exe", "-param"],
-	// as JSON must be escaped. Unfortunate...
-	//
-	// Specifically looking for quote-driveletter-colon-backslash, there's no
-	// double backslash and a [] pair. No, this is not perfect, but it doesn't
-	// have to be. It's simply a hint to make life a little easier.
-	extra := ""
-	original = filepath.FromSlash(strings.ToLower(strings.Replace(strings.ToLower(original), strings.ToLower(command)+" ", "", -1)))
-	if len(regexp.MustCompile(`"[a-z]:\\.*`).FindStringSubmatch(original)) > 0 &&
-		!strings.Contains(original, `\\`) &&
-		strings.Contains(original, "[") &&
-		strings.Contains(original, "]") {
-		extra = fmt.Sprintf(`. It looks like '%s' includes a file path without an escaped back-slash. JSON requires back-slashes to be escaped such as ["c:\\path\\to\\file.exe", "/parameter"]`, original)
-	}
-	return fmt.Errorf("%s requires the arguments to be in JSON form%s", command, extra)
-}

vendor/github.com/docker/docker/builder/dockerfile/instructions/parse.go

@@ -1,637 +0,0 @@
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
-
-import (
-	"fmt"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/strslice"
-	"github.com/docker/docker/builder/dockerfile/command"
-	"github.com/docker/docker/builder/dockerfile/parser"
-	"github.com/docker/docker/pkg/system"
-	"github.com/pkg/errors"
-)
-
-type parseRequest struct {
-	command    string
-	args       []string
-	attributes map[string]bool
-	flags      *BFlags
-	original   string
-}
-
-func nodeArgs(node *parser.Node) []string {
-	result := []string{}
-	for ; node.Next != nil; node = node.Next {
-		arg := node.Next
-		if len(arg.Children) == 0 {
-			result = append(result, arg.Value)
-		} else if len(arg.Children) == 1 {
-			//sub command
-			result = append(result, arg.Children[0].Value)
-			result = append(result, nodeArgs(arg.Children[0])...)
-		}
-	}
-	return result
-}
-
-func newParseRequestFromNode(node *parser.Node) parseRequest {
-	return parseRequest{
-		command:    node.Value,
-		args:       nodeArgs(node),
-		attributes: node.Attributes,
-		original:   node.Original,
-		flags:      NewBFlagsWithArgs(node.Flags),
-	}
-}
-
-// ParseInstruction converts an AST to a typed instruction (either a command or a build stage beginning when encountering a `FROM` statement)
-func ParseInstruction(node *parser.Node) (interface{}, error) {
-	req := newParseRequestFromNode(node)
-	switch node.Value {
-	case command.Env:
-		return parseEnv(req)
-	case command.Maintainer:
-		return parseMaintainer(req)
-	case command.Label:
-		return parseLabel(req)
-	case command.Add:
-		return parseAdd(req)
-	case command.Copy:
-		return parseCopy(req)
-	case command.From:
-		return parseFrom(req)
-	case command.Onbuild:
-		return parseOnBuild(req)
-	case command.Workdir:
-		return parseWorkdir(req)
-	case command.Run:
-		return parseRun(req)
-	case command.Cmd:
-		return parseCmd(req)
-	case command.Healthcheck:
-		return parseHealthcheck(req)
-	case command.Entrypoint:
-		return parseEntrypoint(req)
-	case command.Expose:
-		return parseExpose(req)
-	case command.User:
-		return parseUser(req)
-	case command.Volume:
-		return parseVolume(req)
-	case command.StopSignal:
-		return parseStopSignal(req)
-	case command.Arg:
-		return parseArg(req)
-	case command.Shell:
-		return parseShell(req)
-	}
-
-	return nil, &UnknownInstruction{Instruction: node.Value, Line: node.StartLine}
-}
-
-// ParseCommand converts an AST to a typed Command
-func ParseCommand(node *parser.Node) (Command, error) {
-	s, err := ParseInstruction(node)
-	if err != nil {
-		return nil, err
-	}
-	if c, ok := s.(Command); ok {
-		return c, nil
-	}
-	return nil, errors.Errorf("%T is not a command type", s)
-}
-
-// UnknownInstruction represents an error occurring when a command is unresolvable
-type UnknownInstruction struct {
-	Line        int
-	Instruction string
-}
-
-func (e *UnknownInstruction) Error() string {
-	return fmt.Sprintf("unknown instruction: %s", strings.ToUpper(e.Instruction))
-}
-
-// IsUnknownInstruction checks if the error is an UnknownInstruction or a parseError containing an UnknownInstruction
-func IsUnknownInstruction(err error) bool {
-	_, ok := err.(*UnknownInstruction)
-	if !ok {
-		var pe *parseError
-		if pe, ok = err.(*parseError); ok {
-			_, ok = pe.inner.(*UnknownInstruction)
-		}
-	}
-	return ok
-}
-
-type parseError struct {
-	inner error
-	node  *parser.Node
-}
-
-func (e *parseError) Error() string {
-	return fmt.Sprintf("Dockerfile parse error line %d: %v", e.node.StartLine, e.inner.Error())
-}
-
-// Parse a docker file into a collection of buildable stages
-func Parse(ast *parser.Node) (stages []Stage, metaArgs []ArgCommand, err error) {
-	for _, n := range ast.Children {
-		cmd, err := ParseInstruction(n)
-		if err != nil {
-			return nil, nil, &parseError{inner: err, node: n}
-		}
-		if len(stages) == 0 {
-			// meta arg case
-			if a, isArg := cmd.(*ArgCommand); isArg {
-				metaArgs = append(metaArgs, *a)
-				continue
-			}
-		}
-		switch c := cmd.(type) {
-		case *Stage:
-			stages = append(stages, *c)
-		case Command:
-			stage, err := CurrentStage(stages)
-			if err != nil {
-				return nil, nil, err
-			}
-			stage.AddCommand(c)
-		default:
-			return nil, nil, errors.Errorf("%T is not a command type", cmd)
-		}
-
-	}
-	return stages, metaArgs, nil
-}
-
-func parseKvps(args []string, cmdName string) (KeyValuePairs, error) {
-	if len(args) == 0 {
-		return nil, errAtLeastOneArgument(cmdName)
-	}
-	if len(args)%2 != 0 {
-		// should never get here, but just in case
-		return nil, errTooManyArguments(cmdName)
-	}
-	var res KeyValuePairs
-	for j := 0; j < len(args); j += 2 {
-		if len(args[j]) == 0 {
-			return nil, errBlankCommandNames(cmdName)
-		}
-		name := args[j]
-		value := args[j+1]
-		res = append(res, KeyValuePair{Key: name, Value: value})
-	}
-	return res, nil
-}
-
-func parseEnv(req parseRequest) (*EnvCommand, error) {
-
-	if err := req.flags.Parse(); err != nil {
-		return nil, err
-	}
-	envs, err := parseKvps(req.args, "ENV")
-	if err != nil {
-		return nil, err
-	}
-	return &EnvCommand{
-		Env:             envs,
-		withNameAndCode: newWithNameAndCode(req),
-	}, nil
-}
-
-func parseMaintainer(req parseRequest) (*MaintainerCommand, error) {
-	if len(req.args) != 1 {
-		return nil, errExactlyOneArgument("MAINTAINER")
-	}
-
-	if err := req.flags.Parse(); err != nil {
-		return nil, err
-	}
-	return &MaintainerCommand{
-		Maintainer:      req.args[0],
-		withNameAndCode: newWithNameAndCode(req),
-	}, nil
-}
-
-func parseLabel(req parseRequest) (*LabelCommand, error) {
-
-	if err := req.flags.Parse(); err != nil {
-		return nil, err
-	}
-
-	labels, err := parseKvps(req.args, "LABEL")
-	if err != nil {
-		return nil, err
-	}
-
-	return &LabelCommand{
-		Labels:          labels,
-		withNameAndCode: newWithNameAndCode(req),
-	}, nil
-}
-
-func parseAdd(req parseRequest) (*AddCommand, error) {
-	if len(req.args) < 2 {
-		return nil, errNoDestinationArgument("ADD")
-	}
-	flChown := req.flags.AddString("chown", "")
-	if err := req.flags.Parse(); err != nil {
-		return nil, err
-	}
-	return &AddCommand{
-		SourcesAndDest:  SourcesAndDest(req.args),
-		withNameAndCode: newWithNameAndCode(req),
-		Chown:           flChown.Value,
-	}, nil
-}
-
-func parseCopy(req parseRequest) (*CopyCommand, error) {
-	if len(req.args) < 2 {
-		return nil, errNoDestinationArgument("COPY")
-	}
-	flChown := req.flags.AddString("chown", "")
-	flFrom := req.flags.AddString("from", "")
-	if err := req.flags.Parse(); err != nil {
-		return nil, err
-	}
-	return &CopyCommand{
-		SourcesAndDest:  SourcesAndDest(req.args),
-		From:            flFrom.Value,
-		withNameAndCode: newWithNameAndCode(req),
-		Chown:           flChown.Value,
-	}, nil
-}
-
-func parseFrom(req parseRequest) (*Stage, error) {
-	stageName, err := parseBuildStageName(req.args)
-	if err != nil {
-		return nil, err
-	}
-
-	flPlatform := req.flags.AddString("platform", "")
-	if err := req.flags.Parse(); err != nil {
-		return nil, err
-	}
-	code := strings.TrimSpace(req.original)
-	return &Stage{
-		BaseName:   req.args[0],
-		Name:       stageName,
-		SourceCode: code,
-		Commands:   []Command{},
-		Platform:   *system.ParsePlatform(flPlatform.Value),
-	}, nil
-
-}
-
-func parseBuildStageName(args []string) (string, error) {
-	stageName := ""
-	switch {
-	case len(args) == 3 && strings.EqualFold(args[1], "as"):
-		stageName = strings.ToLower(args[2])
-		if ok, _ := regexp.MatchString("^[a-z][a-z0-9-_\\.]*$", stageName); !ok {
-			return "", errors.Errorf("invalid name for build stage: %q, name can't start with a number or contain symbols", stageName)
-		}
-	case len(args) != 1:
-		return "", errors.New("FROM requires either one or three arguments")
-	}
-
-	return stageName, nil
-}
-
-func parseOnBuild(req parseRequest) (*OnbuildCommand, error) {
-	if len(req.args) == 0 {
-		return nil, errAtLeastOneArgument("ONBUILD")
-	}
-	if err := req.flags.Parse(); err != nil {
-		return nil, err
-	}
-
-	triggerInstruction := strings.ToUpper(strings.TrimSpace(req.args[0]))
-	switch strings.ToUpper(triggerInstruction) {
-	case "ONBUILD":
-		return nil, errors.New("Chaining ONBUILD via `ONBUILD ONBUILD` isn't allowed")
-	case "MAINTAINER", "FROM":
-		return nil, fmt.Errorf("%s isn't allowed as an ONBUILD trigger", triggerInstruction)
-	}
-
-	original := regexp.MustCompile(`(?i)^\s*ONBUILD\s*`).ReplaceAllString(req.original, "")
-	return &OnbuildCommand{
-		Expression:      original,
-		withNameAndCode: newWithNameAndCode(req),
-	}, nil
-
-}
-
-func parseWorkdir(req parseRequest) (*WorkdirCommand, error) {
-	if len(req.args) != 1 {
-		return nil, errExactlyOneArgument("WORKDIR")
-	}
-
-	err := req.flags.Parse()
-	if err != nil {
-		return nil, err
-	}
-	return &WorkdirCommand{
-		Path:            req.args[0],
-		withNameAndCode: newWithNameAndCode(req),
-	}, nil
-
-}
-
-func parseShellDependentCommand(req parseRequest, emptyAsNil bool) ShellDependantCmdLine {
-	args := handleJSONArgs(req.args, req.attributes)
-	cmd := strslice.StrSlice(args)
-	if emptyAsNil && len(cmd) == 0 {
-		cmd = nil
-	}
-	return ShellDependantCmdLine{
-		CmdLine:      cmd,
-		PrependShell: !req.attributes["json"],
-	}
-}
-
-func parseRun(req parseRequest) (*RunCommand, error) {
-
-	if err := req.flags.Parse(); err != nil {
-		return nil, err
-	}
-	return &RunCommand{
-		ShellDependantCmdLine: parseShellDependentCommand(req, false),
-		withNameAndCode:       newWithNameAndCode(req),
-	}, nil
-
-}
-
-func parseCmd(req parseRequest) (*CmdCommand, error) {
-	if err := req.flags.Parse(); err != nil {
-		return nil, err
-	}
-	return &CmdCommand{
-		ShellDependantCmdLine: parseShellDependentCommand(req, false),
-		withNameAndCode:       newWithNameAndCode(req),
-	}, nil
-
-}
-
-func parseEntrypoint(req parseRequest) (*EntrypointCommand, error) {
-	if err := req.flags.Parse(); err != nil {
-		return nil, err
-	}
-
-	cmd := &EntrypointCommand{
-		ShellDependantCmdLine: parseShellDependentCommand(req, true),
-		withNameAndCode:       newWithNameAndCode(req),
-	}
-
-	return cmd, nil
-}
-
-// parseOptInterval(flag) is the duration of flag.Value, or 0 if
-// empty. An error is reported if the value is given and less than minimum duration.
-func parseOptInterval(f *Flag) (time.Duration, error) {
-	s := f.Value
-	if s == "" {
-		return 0, nil
-	}
-	d, err := time.ParseDuration(s)
-	if err != nil {
-		return 0, err
-	}
-	if d < container.MinimumDuration {
-		return 0, fmt.Errorf("Interval %#v cannot be less than %s", f.name, container.MinimumDuration)
-	}
-	return d, nil
-}
-func parseHealthcheck(req parseRequest) (*HealthCheckCommand, error) {
-	if len(req.args) == 0 {
-		return nil, errAtLeastOneArgument("HEALTHCHECK")
-	}
-	cmd := &HealthCheckCommand{
-		withNameAndCode: newWithNameAndCode(req),
-	}
-
-	typ := strings.ToUpper(req.args[0])
-	args := req.args[1:]
-	if typ == "NONE" {
-		if len(args) != 0 {
-			return nil, errors.New("HEALTHCHECK NONE takes no arguments")
-		}
-		test := strslice.StrSlice{typ}
-		cmd.Health = &container.HealthConfig{
-			Test: test,
-		}
-	} else {
-
-		healthcheck := container.HealthConfig{}
-
-		flInterval := req.flags.AddString("interval", "")
-		flTimeout := req.flags.AddString("timeout", "")
-		flStartPeriod := req.flags.AddString("start-period", "")
-		flRetries := req.flags.AddString("retries", "")
-
-		if err := req.flags.Parse(); err != nil {
-			return nil, err
-		}
-
-		switch typ {
-		case "CMD":
-			cmdSlice := handleJSONArgs(args, req.attributes)
-			if len(cmdSlice) == 0 {
-				return nil, errors.New("Missing command after HEALTHCHECK CMD")
-			}
-
-			if !req.attributes["json"] {
-				typ = "CMD-SHELL"
-			}
-
-			healthcheck.Test = strslice.StrSlice(append([]string{typ}, cmdSlice...))
-		default:
-			return nil, fmt.Errorf("Unknown type %#v in HEALTHCHECK (try CMD)", typ)
-		}
-
-		interval, err := parseOptInterval(flInterval)
-		if err != nil {
-			return nil, err
-		}
-		healthcheck.Interval = interval
-
-		timeout, err := parseOptInterval(flTimeout)
-		if err != nil {
-			return nil, err
-		}
-		healthcheck.Timeout = timeout
-
-		startPeriod, err := parseOptInterval(flStartPeriod)
-		if err != nil {
-			return nil, err
-		}
-		healthcheck.StartPeriod = startPeriod
-
-		if flRetries.Value != "" {
-			retries, err := strconv.ParseInt(flRetries.Value, 10, 32)
-			if err != nil {
-				return nil, err
-			}
-			if retries < 1 {
-				return nil, fmt.Errorf("--retries must be at least 1 (not %d)", retries)
-			}
-			healthcheck.Retries = int(retries)
-		} else {
-			healthcheck.Retries = 0
-		}
-
-		cmd.Health = &healthcheck
-	}
-	return cmd, nil
-}
-
-func parseExpose(req parseRequest) (*ExposeCommand, error) {
-	portsTab := req.args
-
-	if len(req.args) == 0 {
-		return nil, errAtLeastOneArgument("EXPOSE")
-	}
-
-	if err := req.flags.Parse(); err != nil {
-		return nil, err
-	}
-
-	sort.Strings(portsTab)
-	return &ExposeCommand{
-		Ports:           portsTab,
-		withNameAndCode: newWithNameAndCode(req),
-	}, nil
-}
-
-func parseUser(req parseRequest) (*UserCommand, error) {
-	if len(req.args) != 1 {
-		return nil, errExactlyOneArgument("USER")
-	}
-
-	if err := req.flags.Parse(); err != nil {
-		return nil, err
-	}
-	return &UserCommand{
-		User:            req.args[0],
-		withNameAndCode: newWithNameAndCode(req),
-	}, nil
-}
-
-func parseVolume(req parseRequest) (*VolumeCommand, error) {
-	if len(req.args) == 0 {
-		return nil, errAtLeastOneArgument("VOLUME")
-	}
-
-	if err := req.flags.Parse(); err != nil {
-		return nil, err
-	}
-
-	cmd := &VolumeCommand{
-		withNameAndCode: newWithNameAndCode(req),
-	}
-
-	for _, v := range req.args {
-		v = strings.TrimSpace(v)
-		if v == "" {
-			return nil, errors.New("VOLUME specified can not be an empty string")
-		}
-		cmd.Volumes = append(cmd.Volumes, v)
-	}
-	return cmd, nil
-
-}
-
-func parseStopSignal(req parseRequest) (*StopSignalCommand, error) {
-	if len(req.args) != 1 {
-		return nil, errExactlyOneArgument("STOPSIGNAL")
-	}
-	sig := req.args[0]
-
-	cmd := &StopSignalCommand{
-		Signal:          sig,
-		withNameAndCode: newWithNameAndCode(req),
-	}
-	return cmd, nil
-
-}
-
-func parseArg(req parseRequest) (*ArgCommand, error) {
-	if len(req.args) != 1 {
-		return nil, errExactlyOneArgument("ARG")
-	}
-
-	var (
-		name     string
-		newValue *string
-	)
-
-	arg := req.args[0]
-	// 'arg' can just be a name or name-value pair. Note that this is different
-	// from 'env' that handles the split of name and value at the parser level.
-	// The reason for doing it differently for 'arg' is that we support just
-	// defining an arg and not assign it a value (while 'env' always expects a
-	// name-value pair). If possible, it will be good to harmonize the two.
-	if strings.Contains(arg, "=") {
-		parts := strings.SplitN(arg, "=", 2)
-		if len(parts[0]) == 0 {
-			return nil, errBlankCommandNames("ARG")
-		}
-
-		name = parts[0]
-		newValue = &parts[1]
-	} else {
-		name = arg
-	}
-
-	return &ArgCommand{
-		Key:             name,
-		Value:           newValue,
-		withNameAndCode: newWithNameAndCode(req),
-	}, nil
-}
-
-func parseShell(req parseRequest) (*ShellCommand, error) {
-	if err := req.flags.Parse(); err != nil {
-		return nil, err
-	}
-	shellSlice := handleJSONArgs(req.args, req.attributes)
-	switch {
-	case len(shellSlice) == 0:
-		// SHELL []
-		return nil, errAtLeastOneArgument("SHELL")
-	case req.attributes["json"]:
-		// SHELL ["powershell", "-command"]
-
-		return &ShellCommand{
-			Shell:           strslice.StrSlice(shellSlice),
-			withNameAndCode: newWithNameAndCode(req),
-		}, nil
-	default:
-		// SHELL powershell -command - not JSON
-		return nil, errNotJSON("SHELL", req.original)
-	}
-}
-
-func errAtLeastOneArgument(command string) error {
-	return errors.Errorf("%s requires at least one argument", command)
-}
-
-func errExactlyOneArgument(command string) error {
-	return errors.Errorf("%s requires exactly one argument", command)
-}
-
-func errNoDestinationArgument(command string) error {
-	return errors.Errorf("%s requires at least two arguments, but only one was provided. Destination could not be determined.", command)
-}
-
-func errBlankCommandNames(command string) error {
-	return errors.Errorf("%s names can not be blank", command)
-}
-
-func errTooManyArguments(command string) error {
-	return errors.Errorf("Bad input to %s, too many arguments", command)
-}

vendor/github.com/docker/docker/builder/dockerfile/instructions/support.go

@@ -1,19 +0,0 @@
-package instructions // import "github.com/docker/docker/builder/dockerfile/instructions"
-
-import "strings"
-
-// handleJSONArgs parses command passed to CMD, ENTRYPOINT, RUN and SHELL instruction in Dockerfile
-// for exec form it returns untouched args slice
-// for shell form it returns concatenated args as the first element of a slice
-func handleJSONArgs(args []string, attributes map[string]bool) []string {
-	if len(args) == 0 {
-		return []string{}
-	}
-
-	if attributes != nil && attributes["json"] {
-		return args
-	}
-
-	// literal string command, not an exec array
-	return []string{strings.Join(args, " ")}
-}

vendor/github.com/docker/docker/builder/dockerfile/parser/line_parsers.go

@@ -1,368 +0,0 @@
-package parser // import "github.com/docker/docker/builder/dockerfile/parser"
-
-// line parsers are dispatch calls that parse a single unit of text into a
-// Node object which contains the whole statement. Dockerfiles have varied
-// (but not usually unique, see ONBUILD for a unique example) parsing rules
-// per-command, and these unify the processing in a way that makes it
-// manageable.
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-)
-
-var (
-	errDockerfileNotStringArray = errors.New("when using JSON array syntax, arrays must be comprised of strings only")
-)
-
-const (
-	commandLabel = "LABEL"
-)
-
-// ignore the current argument. This will still leave a command parsed, but
-// will not incorporate the arguments into the ast.
-func parseIgnore(rest string, d *Directive) (*Node, map[string]bool, error) {
-	return &Node{}, nil, nil
-}
-
-// used for onbuild. Could potentially be used for anything that represents a
-// statement with sub-statements.
-//
-// ONBUILD RUN foo bar -> (onbuild (run foo bar))
-//
-func parseSubCommand(rest string, d *Directive) (*Node, map[string]bool, error) {
-	if rest == "" {
-		return nil, nil, nil
-	}
-
-	child, err := newNodeFromLine(rest, d)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return &Node{Children: []*Node{child}}, nil, nil
-}
-
-// helper to parse words (i.e space delimited or quoted strings) in a statement.
-// The quotes are preserved as part of this function and they are stripped later
-// as part of processWords().
-func parseWords(rest string, d *Directive) []string {
-	const (
-		inSpaces = iota // looking for start of a word
-		inWord
-		inQuote
-	)
-
-	words := []string{}
-	phase := inSpaces
-	word := ""
-	quote := '\000'
-	blankOK := false
-	var ch rune
-	var chWidth int
-
-	for pos := 0; pos <= len(rest); pos += chWidth {
-		if pos != len(rest) {
-			ch, chWidth = utf8.DecodeRuneInString(rest[pos:])
-		}
-
-		if phase == inSpaces { // Looking for start of word
-			if pos == len(rest) { // end of input
-				break
-			}
-			if unicode.IsSpace(ch) { // skip spaces
-				continue
-			}
-			phase = inWord // found it, fall through
-		}
-		if (phase == inWord || phase == inQuote) && (pos == len(rest)) {
-			if blankOK || len(word) > 0 {
-				words = append(words, word)
-			}
-			break
-		}
-		if phase == inWord {
-			if unicode.IsSpace(ch) {
-				phase = inSpaces
-				if blankOK || len(word) > 0 {
-					words = append(words, word)
-				}
-				word = ""
-				blankOK = false
-				continue
-			}
-			if ch == '\'' || ch == '"' {
-				quote = ch
-				blankOK = true
-				phase = inQuote
-			}
-			if ch == d.escapeToken {
-				if pos+chWidth == len(rest) {
-					continue // just skip an escape token at end of line
-				}
-				// If we're not quoted and we see an escape token, then always just
-				// add the escape token plus the char to the word, even if the char
-				// is a quote.
-				word += string(ch)
-				pos += chWidth
-				ch, chWidth = utf8.DecodeRuneInString(rest[pos:])
-			}
-			word += string(ch)
-			continue
-		}
-		if phase == inQuote {
-			if ch == quote {
-				phase = inWord
-			}
-			// The escape token is special except for ' quotes - can't escape anything for '
-			if ch == d.escapeToken && quote != '\'' {
-				if pos+chWidth == len(rest) {
-					phase = inWord
-					continue // just skip the escape token at end
-				}
-				pos += chWidth
-				word += string(ch)
-				ch, chWidth = utf8.DecodeRuneInString(rest[pos:])
-			}
-			word += string(ch)
-		}
-	}
-
-	return words
-}
-
-// parse environment like statements. Note that this does *not* handle
-// variable interpolation, which will be handled in the evaluator.
-func parseNameVal(rest string, key string, d *Directive) (*Node, error) {
-	// This is kind of tricky because we need to support the old
-	// variant:   KEY name value
-	// as well as the new one:    KEY name=value ...
-	// The trigger to know which one is being used will be whether we hit
-	// a space or = first.  space ==> old, "=" ==> new
-
-	words := parseWords(rest, d)
-	if len(words) == 0 {
-		return nil, nil
-	}
-
-	// Old format (KEY name value)
-	if !strings.Contains(words[0], "=") {
-		parts := tokenWhitespace.Split(rest, 2)
-		if len(parts) < 2 {
-			return nil, fmt.Errorf(key + " must have two arguments")
-		}
-		return newKeyValueNode(parts[0], parts[1]), nil
-	}
-
-	var rootNode *Node
-	var prevNode *Node
-	for _, word := range words {
-		if !strings.Contains(word, "=") {
-			return nil, fmt.Errorf("Syntax error - can't find = in %q. Must be of the form: name=value", word)
-		}
-
-		parts := strings.SplitN(word, "=", 2)
-		node := newKeyValueNode(parts[0], parts[1])
-		rootNode, prevNode = appendKeyValueNode(node, rootNode, prevNode)
-	}
-
-	return rootNode, nil
-}
-
-func newKeyValueNode(key, value string) *Node {
-	return &Node{
-		Value: key,
-		Next:  &Node{Value: value},
-	}
-}
-
-func appendKeyValueNode(node, rootNode, prevNode *Node) (*Node, *Node) {
-	if rootNode == nil {
-		rootNode = node
-	}
-	if prevNode != nil {
-		prevNode.Next = node
-	}
-
-	prevNode = node.Next
-	return rootNode, prevNode
-}
-
-func parseEnv(rest string, d *Directive) (*Node, map[string]bool, error) {
-	node, err := parseNameVal(rest, "ENV", d)
-	return node, nil, err
-}
-
-func parseLabel(rest string, d *Directive) (*Node, map[string]bool, error) {
-	node, err := parseNameVal(rest, commandLabel, d)
-	return node, nil, err
-}
-
-// parses a statement containing one or more keyword definition(s) and/or
-// value assignments, like `name1 name2= name3="" name4=value`.
-// Note that this is a stricter format than the old format of assignment,
-// allowed by parseNameVal(), in a way that this only allows assignment of the
-// form `keyword=[<value>]` like  `name2=`, `name3=""`, and `name4=value` above.
-// In addition, a keyword definition alone is of the form `keyword` like `name1`
-// above. And the assignments `name2=` and `name3=""` are equivalent and
-// assign an empty value to the respective keywords.
-func parseNameOrNameVal(rest string, d *Directive) (*Node, map[string]bool, error) {
-	words := parseWords(rest, d)
-	if len(words) == 0 {
-		return nil, nil, nil
-	}
-
-	var (
-		rootnode *Node
-		prevNode *Node
-	)
-	for i, word := range words {
-		node := &Node{}
-		node.Value = word
-		if i == 0 {
-			rootnode = node
-		} else {
-			prevNode.Next = node
-		}
-		prevNode = node
-	}
-
-	return rootnode, nil, nil
-}
-
-// parses a whitespace-delimited set of arguments. The result is effectively a
-// linked list of string arguments.
-func parseStringsWhitespaceDelimited(rest string, d *Directive) (*Node, map[string]bool, error) {
-	if rest == "" {
-		return nil, nil, nil
-	}
-
-	node := &Node{}
-	rootnode := node
-	prevnode := node
-	for _, str := range tokenWhitespace.Split(rest, -1) { // use regexp
-		prevnode = node
-		node.Value = str
-		node.Next = &Node{}
-		node = node.Next
-	}
-
-	// XXX to get around regexp.Split *always* providing an empty string at the
-	// end due to how our loop is constructed, nil out the last node in the
-	// chain.
-	prevnode.Next = nil
-
-	return rootnode, nil, nil
-}
-
-// parseString just wraps the string in quotes and returns a working node.
-func parseString(rest string, d *Directive) (*Node, map[string]bool, error) {
-	if rest == "" {
-		return nil, nil, nil
-	}
-	n := &Node{}
-	n.Value = rest
-	return n, nil, nil
-}
-
-// parseJSON converts JSON arrays to an AST.
-func parseJSON(rest string, d *Directive) (*Node, map[string]bool, error) {
-	rest = strings.TrimLeftFunc(rest, unicode.IsSpace)
-	if !strings.HasPrefix(rest, "[") {
-		return nil, nil, fmt.Errorf(`Error parsing "%s" as a JSON array`, rest)
-	}
-
-	var myJSON []interface{}
-	if err := json.NewDecoder(strings.NewReader(rest)).Decode(&myJSON); err != nil {
-		return nil, nil, err
-	}
-
-	var top, prev *Node
-	for _, str := range myJSON {
-		s, ok := str.(string)
-		if !ok {
-			return nil, nil, errDockerfileNotStringArray
-		}
-
-		node := &Node{Value: s}
-		if prev == nil {
-			top = node
-		} else {
-			prev.Next = node
-		}
-		prev = node
-	}
-
-	return top, map[string]bool{"json": true}, nil
-}
-
-// parseMaybeJSON determines if the argument appears to be a JSON array. If
-// so, passes to parseJSON; if not, quotes the result and returns a single
-// node.
-func parseMaybeJSON(rest string, d *Directive) (*Node, map[string]bool, error) {
-	if rest == "" {
-		return nil, nil, nil
-	}
-
-	node, attrs, err := parseJSON(rest, d)
-
-	if err == nil {
-		return node, attrs, nil
-	}
-	if err == errDockerfileNotStringArray {
-		return nil, nil, err
-	}
-
-	node = &Node{}
-	node.Value = rest
-	return node, nil, nil
-}
-
-// parseMaybeJSONToList determines if the argument appears to be a JSON array. If
-// so, passes to parseJSON; if not, attempts to parse it as a whitespace
-// delimited string.
-func parseMaybeJSONToList(rest string, d *Directive) (*Node, map[string]bool, error) {
-	node, attrs, err := parseJSON(rest, d)
-
-	if err == nil {
-		return node, attrs, nil
-	}
-	if err == errDockerfileNotStringArray {
-		return nil, nil, err
-	}
-
-	return parseStringsWhitespaceDelimited(rest, d)
-}
-
-// The HEALTHCHECK command is like parseMaybeJSON, but has an extra type argument.
-func parseHealthConfig(rest string, d *Directive) (*Node, map[string]bool, error) {
-	// Find end of first argument
-	var sep int
-	for ; sep < len(rest); sep++ {
-		if unicode.IsSpace(rune(rest[sep])) {
-			break
-		}
-	}
-	next := sep
-	for ; next < len(rest); next++ {
-		if !unicode.IsSpace(rune(rest[next])) {
-			break
-		}
-	}
-
-	if sep == 0 {
-		return nil, nil, nil
-	}
-
-	typ := rest[:sep]
-	cmd, attrs, err := parseMaybeJSON(rest[next:], d)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return &Node{Value: typ, Next: cmd}, attrs, err
-}

vendor/github.com/docker/docker/builder/dockerfile/parser/parser.go

@@ -1,327 +0,0 @@
-// Package parser implements a parser and parse tree dumper for Dockerfiles.
-package parser // import "github.com/docker/docker/builder/dockerfile/parser"
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"io"
-	"regexp"
-	"strconv"
-	"strings"
-	"unicode"
-
-	"github.com/docker/docker/builder/dockerfile/command"
-	"github.com/pkg/errors"
-)
-
-// Node is a structure used to represent a parse tree.
-//
-// 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:
-//
-// (value next (child child-next child-next-next) next-next)
-//
-// 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.
-//
-type Node struct {
-	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
-	Original   string          // original line used before parsing
-	Flags      []string        // only top Node should have this set
-	StartLine  int             // the line in the original dockerfile where the node begins
-	endLine    int             // the line in the original dockerfile where the node ends
-}
-
-// Dump dumps the AST defined by `node` as a list of sexps.
-// Returns a string suitable for printing.
-func (node *Node) Dump() string {
-	str := ""
-	str += node.Value
-
-	if len(node.Flags) > 0 {
-		str += fmt.Sprintf(" %q", node.Flags)
-	}
-
-	for _, n := range node.Children {
-		str += "(" + n.Dump() + ")\n"
-	}
-
-	for n := node.Next; n != nil; n = n.Next {
-		if len(n.Children) > 0 {
-			str += " " + n.Dump()
-		} else {
-			str += " " + strconv.Quote(n.Value)
-		}
-	}
-
-	return strings.TrimSpace(str)
-}
-
-func (node *Node) lines(start, end int) {
-	node.StartLine = start
-	node.endLine = end
-}
-
-// AddChild adds a new child node, and updates line information
-func (node *Node) AddChild(child *Node, startLine, endLine int) {
-	child.lines(startLine, endLine)
-	if node.StartLine < 0 {
-		node.StartLine = startLine
-	}
-	node.endLine = endLine
-	node.Children = append(node.Children, child)
-}
-
-var (
-	dispatch           map[string]func(string, *Directive) (*Node, map[string]bool, error)
-	tokenWhitespace    = regexp.MustCompile(`[\t\v\f\r ]+`)
-	tokenEscapeCommand = regexp.MustCompile(`^#[ \t]*escape[ \t]*=[ \t]*(?P<escapechar>.).*$`)
-	tokenComment       = regexp.MustCompile(`^#.*$`)
-)
-
-// DefaultEscapeToken is the default escape token
-const DefaultEscapeToken = '\\'
-
-// Directive is the structure used during a build run to hold the state of
-// parsing directives.
-type Directive struct {
-	escapeToken           rune           // Current escape token
-	lineContinuationRegex *regexp.Regexp // Current line continuation regex
-	processingComplete    bool           // Whether we are done looking for directives
-	escapeSeen            bool           // Whether the escape directive has been seen
-}
-
-// setEscapeToken sets the default token for escaping characters in a Dockerfile.
-func (d *Directive) setEscapeToken(s string) error {
-	if s != "`" && s != "\\" {
-		return fmt.Errorf("invalid ESCAPE '%s'. Must be ` or \\", s)
-	}
-	d.escapeToken = rune(s[0])
-	d.lineContinuationRegex = regexp.MustCompile(`\` + s + `[ \t]*$`)
-	return nil
-}
-
-// possibleParserDirective looks for parser directives, eg '# escapeToken=<char>'.
-// Parser directives must precede any builder instruction or other comments,
-// and cannot be repeated.
-func (d *Directive) possibleParserDirective(line string) error {
-	if d.processingComplete {
-		return nil
-	}
-
-	tecMatch := tokenEscapeCommand.FindStringSubmatch(strings.ToLower(line))
-	if len(tecMatch) != 0 {
-		for i, n := range tokenEscapeCommand.SubexpNames() {
-			if n == "escapechar" {
-				if d.escapeSeen {
-					return errors.New("only one escape parser directive can be used")
-				}
-				d.escapeSeen = true
-				return d.setEscapeToken(tecMatch[i])
-			}
-		}
-	}
-
-	d.processingComplete = true
-	return nil
-}
-
-// NewDefaultDirective returns a new Directive with the default escapeToken token
-func NewDefaultDirective() *Directive {
-	directive := Directive{}
-	directive.setEscapeToken(string(DefaultEscapeToken))
-	return &directive
-}
-
-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
-	// receives the arguments but not the command, and returns an AST after
-	// reformulating the arguments according to the rules in the parser
-	// functions. Errors are propagated up by Parse() and the resulting AST can
-	// be incorporated directly into the existing AST as a next.
-	dispatch = map[string]func(string, *Directive) (*Node, map[string]bool, error){
-		command.Add:         parseMaybeJSONToList,
-		command.Arg:         parseNameOrNameVal,
-		command.Cmd:         parseMaybeJSON,
-		command.Copy:        parseMaybeJSONToList,
-		command.Entrypoint:  parseMaybeJSON,
-		command.Env:         parseEnv,
-		command.Expose:      parseStringsWhitespaceDelimited,
-		command.From:        parseStringsWhitespaceDelimited,
-		command.Healthcheck: parseHealthConfig,
-		command.Label:       parseLabel,
-		command.Maintainer:  parseString,
-		command.Onbuild:     parseSubCommand,
-		command.Run:         parseMaybeJSON,
-		command.Shell:       parseMaybeJSON,
-		command.StopSignal:  parseString,
-		command.User:        parseString,
-		command.Volume:      parseMaybeJSONToList,
-		command.Workdir:     parseString,
-	}
-}
-
-// newNodeFromLine splits the line into parts, and dispatches to a function
-// based on the command and command arguments. A Node is created from the
-// result of the dispatch.
-func newNodeFromLine(line string, directive *Directive) (*Node, error) {
-	cmd, flags, args, err := splitCommand(line)
-	if err != nil {
-		return nil, err
-	}
-
-	fn := dispatch[cmd]
-	// Ignore invalid Dockerfile instructions
-	if fn == nil {
-		fn = parseIgnore
-	}
-	next, attrs, err := fn(args, directive)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Node{
-		Value:      cmd,
-		Original:   line,
-		Flags:      flags,
-		Next:       next,
-		Attributes: attrs,
-	}, nil
-}
-
-// Result is the result of parsing a Dockerfile
-type Result struct {
-	AST         *Node
-	EscapeToken rune
-	Warnings    []string
-}
-
-// PrintWarnings to the writer
-func (r *Result) PrintWarnings(out io.Writer) {
-	if len(r.Warnings) == 0 {
-		return
-	}
-	fmt.Fprintf(out, strings.Join(r.Warnings, "\n")+"\n")
-}
-
-// Parse reads lines from a Reader, parses the lines into an AST and returns
-// the AST and escape token
-func Parse(rwc io.Reader) (*Result, error) {
-	d := NewDefaultDirective()
-	currentLine := 0
-	root := &Node{StartLine: -1}
-	scanner := bufio.NewScanner(rwc)
-	warnings := []string{}
-
-	var err error
-	for scanner.Scan() {
-		bytesRead := scanner.Bytes()
-		if currentLine == 0 {
-			// First line, strip the byte-order-marker if present
-			bytesRead = bytes.TrimPrefix(bytesRead, utf8bom)
-		}
-		bytesRead, err = processLine(d, bytesRead, true)
-		if err != nil {
-			return nil, err
-		}
-		currentLine++
-
-		startLine := currentLine
-		line, isEndOfLine := trimContinuationCharacter(string(bytesRead), d)
-		if isEndOfLine && line == "" {
-			continue
-		}
-
-		var hasEmptyContinuationLine bool
-		for !isEndOfLine && scanner.Scan() {
-			bytesRead, err := processLine(d, scanner.Bytes(), false)
-			if err != nil {
-				return nil, err
-			}
-			currentLine++
-
-			if isComment(scanner.Bytes()) {
-				// original line was a comment (processLine strips comments)
-				continue
-			}
-			if isEmptyContinuationLine(bytesRead) {
-				hasEmptyContinuationLine = true
-				continue
-			}
-
-			continuationLine := string(bytesRead)
-			continuationLine, isEndOfLine = trimContinuationCharacter(continuationLine, d)
-			line += continuationLine
-		}
-
-		if hasEmptyContinuationLine {
-			warnings = append(warnings, "[WARNING]: Empty continuation line found in:\n    "+line)
-		}
-
-		child, err := newNodeFromLine(line, d)
-		if err != nil {
-			return nil, err
-		}
-		root.AddChild(child, startLine, currentLine)
-	}
-
-	if len(warnings) > 0 {
-		warnings = append(warnings, "[WARNING]: Empty continuation lines will become errors in a future release.")
-	}
-	return &Result{
-		AST:         root,
-		Warnings:    warnings,
-		EscapeToken: d.escapeToken,
-	}, handleScannerError(scanner.Err())
-}
-
-func trimComments(src []byte) []byte {
-	return tokenComment.ReplaceAll(src, []byte{})
-}
-
-func trimWhitespace(src []byte) []byte {
-	return bytes.TrimLeftFunc(src, unicode.IsSpace)
-}
-
-func isComment(line []byte) bool {
-	return tokenComment.Match(trimWhitespace(line))
-}
-
-func isEmptyContinuationLine(line []byte) bool {
-	return len(trimWhitespace(line)) == 0
-}
-
-var utf8bom = []byte{0xEF, 0xBB, 0xBF}
-
-func trimContinuationCharacter(line string, d *Directive) (string, bool) {
-	if d.lineContinuationRegex.MatchString(line) {
-		line = d.lineContinuationRegex.ReplaceAllString(line, "")
-		return line, false
-	}
-	return line, true
-}
-
-// TODO: remove stripLeftWhitespace after deprecation period. It seems silly
-// to preserve whitespace on continuation lines. Why is that done?
-func processLine(d *Directive, token []byte, stripLeftWhitespace bool) ([]byte, error) {
-	if stripLeftWhitespace {
-		token = trimWhitespace(token)
-	}
-	return trimComments(token), d.possibleParserDirective(string(token))
-}
-
-func handleScannerError(err error) error {
-	switch err {
-	case bufio.ErrTooLong:
-		return errors.Errorf("dockerfile line greater than max allowed size of %d", bufio.MaxScanTokenSize-1)
-	default:
-		return err
-	}
-}

vendor/github.com/docker/docker/builder/dockerfile/parser/split_command.go

@@ -1,118 +0,0 @@
-package parser // import "github.com/docker/docker/builder/dockerfile/parser"
-
-import (
-	"strings"
-	"unicode"
-)
-
-// splitCommand takes a single line of text and parses out the cmd and args,
-// which are used for dispatching to more exact parsing functions.
-func splitCommand(line string) (string, []string, string, error) {
-	var args string
-	var flags []string
-
-	// Make sure we get the same results irrespective of leading/trailing spaces
-	cmdline := tokenWhitespace.Split(strings.TrimSpace(line), 2)
-	cmd := strings.ToLower(cmdline[0])
-
-	if len(cmdline) == 2 {
-		var err error
-		args, flags, err = extractBuilderFlags(cmdline[1])
-		if err != nil {
-			return "", nil, "", err
-		}
-	}
-
-	return cmd, flags, strings.TrimSpace(args), nil
-}
-
-func extractBuilderFlags(line string) (string, []string, error) {
-	// Parses the BuilderFlags and returns the remaining part of the line
-
-	const (
-		inSpaces = iota // looking for start of a word
-		inWord
-		inQuote
-	)
-
-	words := []string{}
-	phase := inSpaces
-	word := ""
-	quote := '\000'
-	blankOK := false
-	var ch rune
-
-	for pos := 0; pos <= len(line); pos++ {
-		if pos != len(line) {
-			ch = rune(line[pos])
-		}
-
-		if phase == inSpaces { // Looking for start of word
-			if pos == len(line) { // end of input
-				break
-			}
-			if unicode.IsSpace(ch) { // skip spaces
-				continue
-			}
-
-			// Only keep going if the next word starts with --
-			if ch != '-' || pos+1 == len(line) || rune(line[pos+1]) != '-' {
-				return line[pos:], words, nil
-			}
-
-			phase = inWord // found something with "--", fall through
-		}
-		if (phase == inWord || phase == inQuote) && (pos == len(line)) {
-			if word != "--" && (blankOK || len(word) > 0) {
-				words = append(words, word)
-			}
-			break
-		}
-		if phase == inWord {
-			if unicode.IsSpace(ch) {
-				phase = inSpaces
-				if word == "--" {
-					return line[pos:], words, nil
-				}
-				if blankOK || len(word) > 0 {
-					words = append(words, word)
-				}
-				word = ""
-				blankOK = false
-				continue
-			}
-			if ch == '\'' || ch == '"' {
-				quote = ch
-				blankOK = true
-				phase = inQuote
-				continue
-			}
-			if ch == '\\' {
-				if pos+1 == len(line) {
-					continue // just skip \ at end
-				}
-				pos++
-				ch = rune(line[pos])
-			}
-			word += string(ch)
-			continue
-		}
-		if phase == inQuote {
-			if ch == quote {
-				phase = inWord
-				continue
-			}
-			if ch == '\\' {
-				if pos+1 == len(line) {
-					phase = inWord
-					continue // just skip \ at end
-				}
-				pos++
-				ch = rune(line[pos])
-			}
-			word += string(ch)
-		}
-	}
-
-	return "", words, nil
-}

vendor/github.com/docker/docker/builder/dockerfile/shell/equal_env_unix.go

@@ -1,9 +0,0 @@
-// +build !windows
-
-package shell // import "github.com/docker/docker/builder/dockerfile/shell"
-
-// EqualEnvKeys compare two strings and returns true if they are equal. On
-// Windows this comparison is case insensitive.
-func EqualEnvKeys(from, to string) bool {
-	return from == to
-}

vendor/github.com/docker/docker/builder/dockerfile/shell/equal_env_windows.go

@@ -1,9 +0,0 @@
-package shell // import "github.com/docker/docker/builder/dockerfile/shell"
-
-import "strings"
-
-// EqualEnvKeys compare two strings and returns true if they are equal. On
-// Windows this comparison is case insensitive.
-func EqualEnvKeys(from, to string) bool {
-	return strings.ToUpper(from) == strings.ToUpper(to)
-}

vendor/github.com/docker/docker/builder/dockerfile/shell/lex.go

@@ -1,373 +0,0 @@
-package shell // import "github.com/docker/docker/builder/dockerfile/shell"
-
-import (
-	"bytes"
-	"strings"
-	"text/scanner"
-	"unicode"
-
-	"github.com/pkg/errors"
-)
-
-// Lex performs shell word splitting and variable expansion.
-//
-// Lex takes a string and an array of env variables and
-// process all quotes (" and ') as well as $xxx and ${xxx} env variable
-// tokens.  Tries to mimic bash shell process.
-// It doesn't support all flavors of ${xx:...} formats but new ones can
-// be added by adding code to the "special ${} format processing" section
-type Lex struct {
-	escapeToken rune
-}
-
-// NewLex creates a new Lex which uses escapeToken to escape quotes.
-func NewLex(escapeToken rune) *Lex {
-	return &Lex{escapeToken: escapeToken}
-}
-
-// ProcessWord will use the 'env' list of environment variables,
-// and replace any env var references in 'word'.
-func (s *Lex) ProcessWord(word string, env []string) (string, error) {
-	word, _, err := s.process(word, env)
-	return word, err
-}
-
-// ProcessWords will use the 'env' list of environment variables,
-// and replace any env var references in 'word' then it will also
-// return a slice of strings which represents the 'word'
-// split up based on spaces - taking into account quotes.  Note that
-// this splitting is done **after** the env var substitutions are done.
-// Note, each one is trimmed to remove leading and trailing spaces (unless
-// they are quoted", but ProcessWord retains spaces between words.
-func (s *Lex) ProcessWords(word string, env []string) ([]string, error) {
-	_, words, err := s.process(word, env)
-	return words, err
-}
-
-func (s *Lex) process(word string, env []string) (string, []string, error) {
-	sw := &shellWord{
-		envs:        env,
-		escapeToken: s.escapeToken,
-	}
-	sw.scanner.Init(strings.NewReader(word))
-	return sw.process(word)
-}
-
-type shellWord struct {
-	scanner     scanner.Scanner
-	envs        []string
-	escapeToken rune
-}
-
-func (sw *shellWord) process(source string) (string, []string, error) {
-	word, words, err := sw.processStopOn(scanner.EOF)
-	if err != nil {
-		err = errors.Wrapf(err, "failed to process %q", source)
-	}
-	return word, words, err
-}
-
-type wordsStruct struct {
-	word   string
-	words  []string
-	inWord bool
-}
-
-func (w *wordsStruct) addChar(ch rune) {
-	if unicode.IsSpace(ch) && w.inWord {
-		if len(w.word) != 0 {
-			w.words = append(w.words, w.word)
-			w.word = ""
-			w.inWord = false
-		}
-	} else if !unicode.IsSpace(ch) {
-		w.addRawChar(ch)
-	}
-}
-
-func (w *wordsStruct) addRawChar(ch rune) {
-	w.word += string(ch)
-	w.inWord = true
-}
-
-func (w *wordsStruct) addString(str string) {
-	var scan scanner.Scanner
-	scan.Init(strings.NewReader(str))
-	for scan.Peek() != scanner.EOF {
-		w.addChar(scan.Next())
-	}
-}
-
-func (w *wordsStruct) addRawString(str string) {
-	w.word += str
-	w.inWord = true
-}
-
-func (w *wordsStruct) getWords() []string {
-	if len(w.word) > 0 {
-		w.words = append(w.words, w.word)
-
-		// Just in case we're called again by mistake
-		w.word = ""
-		w.inWord = false
-	}
-	return w.words
-}
-
-// Process the word, starting at 'pos', and stop when we get to the
-// end of the word or the 'stopChar' character
-func (sw *shellWord) processStopOn(stopChar rune) (string, []string, error) {
-	var result bytes.Buffer
-	var words wordsStruct
-
-	var charFuncMapping = map[rune]func() (string, error){
-		'\'': sw.processSingleQuote,
-		'"':  sw.processDoubleQuote,
-		'$':  sw.processDollar,
-	}
-
-	for sw.scanner.Peek() != scanner.EOF {
-		ch := sw.scanner.Peek()
-
-		if stopChar != scanner.EOF && ch == stopChar {
-			sw.scanner.Next()
-			return result.String(), words.getWords(), nil
-		}
-		if fn, ok := charFuncMapping[ch]; ok {
-			// Call special processing func for certain chars
-			tmp, err := fn()
-			if err != nil {
-				return "", []string{}, err
-			}
-			result.WriteString(tmp)
-
-			if ch == rune('$') {
-				words.addString(tmp)
-			} else {
-				words.addRawString(tmp)
-			}
-		} else {
-			// Not special, just add it to the result
-			ch = sw.scanner.Next()
-
-			if ch == sw.escapeToken {
-				// '\' (default escape token, but ` allowed) escapes, except end of line
-				ch = sw.scanner.Next()
-
-				if ch == scanner.EOF {
-					break
-				}
-
-				words.addRawChar(ch)
-			} else {
-				words.addChar(ch)
-			}
-
-			result.WriteRune(ch)
-		}
-	}
-	if stopChar != scanner.EOF {
-		return "", []string{}, errors.Errorf("unexpected end of statement while looking for matching %s", string(stopChar))
-	}
-	return result.String(), words.getWords(), nil
-}
-
-func (sw *shellWord) processSingleQuote() (string, error) {
-	// All chars between single quotes are taken as-is
-	// Note, you can't escape '
-	//
-	// From the "sh" man page:
-	// Single Quotes
-	//   Enclosing characters in single quotes preserves the literal meaning of
-	//   all the characters (except single quotes, making it impossible to put
-	//   single-quotes in a single-quoted string).
-
-	var result bytes.Buffer
-
-	sw.scanner.Next()
-
-	for {
-		ch := sw.scanner.Next()
-		switch ch {
-		case scanner.EOF:
-			return "", errors.New("unexpected end of statement while looking for matching single-quote")
-		case '\'':
-			return result.String(), nil
-		}
-		result.WriteRune(ch)
-	}
-}
-
-func (sw *shellWord) processDoubleQuote() (string, error) {
-	// All chars up to the next " are taken as-is, even ', except any $ chars
-	// But you can escape " with a \ (or ` if escape token set accordingly)
-	//
-	// From the "sh" man page:
-	// Double Quotes
-	//  Enclosing characters within double quotes preserves the literal meaning
-	//  of all characters except dollarsign ($), backquote (`), and backslash
-	//  (\).  The backslash inside double quotes is historically weird, and
-	//  serves to quote only the following characters:
-	//    $ ` " \ <newline>.
-	//  Otherwise it remains literal.
-
-	var result bytes.Buffer
-
-	sw.scanner.Next()
-
-	for {
-		switch sw.scanner.Peek() {
-		case scanner.EOF:
-			return "", errors.New("unexpected end of statement while looking for matching double-quote")
-		case '"':
-			sw.scanner.Next()
-			return result.String(), nil
-		case '$':
-			value, err := sw.processDollar()
-			if err != nil {
-				return "", err
-			}
-			result.WriteString(value)
-		default:
-			ch := sw.scanner.Next()
-			if ch == sw.escapeToken {
-				switch sw.scanner.Peek() {
-				case scanner.EOF:
-					// Ignore \ at end of word
-					continue
-				case '"', '$', sw.escapeToken:
-					// These chars can be escaped, all other \'s are left as-is
-					// Note: for now don't do anything special with ` chars.
-					// Not sure what to do with them anyway since we're not going
-					// to execute the text in there (not now anyway).
-					ch = sw.scanner.Next()
-				}
-			}
-			result.WriteRune(ch)
-		}
-	}
-}
-
-func (sw *shellWord) processDollar() (string, error) {
-	sw.scanner.Next()
-
-	// $xxx case
-	if sw.scanner.Peek() != '{' {
-		name := sw.processName()
-		if name == "" {
-			return "$", nil
-		}
-		return sw.getEnv(name), nil
-	}
-
-	sw.scanner.Next()
-	switch sw.scanner.Peek() {
-	case scanner.EOF:
-		return "", errors.New("syntax error: missing '}'")
-	case '{', '}', ':':
-		// Invalid ${{xx}, ${:xx}, ${:}. ${} case
-		return "", errors.New("syntax error: bad substitution")
-	}
-	name := sw.processName()
-	ch := sw.scanner.Next()
-	switch ch {
-	case '}':
-		// Normal ${xx} case
-		return sw.getEnv(name), nil
-	case ':':
-		// Special ${xx:...} format processing
-		// Yes it allows for recursive $'s in the ... spot
-		modifier := sw.scanner.Next()
-
-		word, _, err := sw.processStopOn('}')
-		if err != nil {
-			if sw.scanner.Peek() == scanner.EOF {
-				return "", errors.New("syntax error: missing '}'")
-			}
-			return "", err
-		}
-
-		// Grab the current value of the variable in question so we
-		// can use to to determine what to do based on the modifier
-		newValue := sw.getEnv(name)
-
-		switch modifier {
-		case '+':
-			if newValue != "" {
-				newValue = word
-			}
-			return newValue, nil
-
-		case '-':
-			if newValue == "" {
-				newValue = word
-			}
-			return newValue, nil
-
-		default:
-			return "", errors.Errorf("unsupported modifier (%c) in substitution", modifier)
-		}
-	}
-	return "", errors.Errorf("missing ':' in substitution")
-}
-
-func (sw *shellWord) processName() string {
-	// Read in a name (alphanumeric or _)
-	// If it starts with a numeric then just return $#
-	var name bytes.Buffer
-
-	for sw.scanner.Peek() != scanner.EOF {
-		ch := sw.scanner.Peek()
-		if name.Len() == 0 && unicode.IsDigit(ch) {
-			for sw.scanner.Peek() != scanner.EOF && unicode.IsDigit(sw.scanner.Peek()) {
-				// Keep reading until the first non-digit character, or EOF
-				ch = sw.scanner.Next()
-				name.WriteRune(ch)
-			}
-			return name.String()
-		}
-		if name.Len() == 0 && isSpecialParam(ch) {
-			ch = sw.scanner.Next()
-			return string(ch)
-		}
-		if !unicode.IsLetter(ch) && !unicode.IsDigit(ch) && ch != '_' {
-			break
-		}
-		ch = sw.scanner.Next()
-		name.WriteRune(ch)
-	}
-
-	return name.String()
-}
-
-// isSpecialParam checks if the provided character is a special parameters,
-// as defined in http://pubs.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_05_02
-func isSpecialParam(char rune) bool {
-	switch char {
-	case '@', '*', '#', '?', '-', '$', '!', '0':
-		// Special parameters
-		// http://pubs.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_05_02
-		return true
-	}
-	return false
-}
-
-func (sw *shellWord) getEnv(name string) string {
-	for _, env := range sw.envs {
-		i := strings.Index(env, "=")
-		if i < 0 {
-			if EqualEnvKeys(name, env) {
-				// Should probably never get here, but just in case treat
-				// it like "var" and "var=" are the same
-				return ""
-			}
-			continue
-		}
-		compareName := env[:i]
-		if !EqualEnvKeys(name, compareName) {
-			continue
-		}
-		return env[i+1:]
-	}
-	return ""
-}