Implement #MG5

app/main.go

 	"strings"
 )
 
+func getenv(key string, fallback string) string {
+	value, ok := os.LookupEnv(key)
+	if ok {
+		return value
+	} else {
+		return fallback
+	}
+}
+
 type Context struct {
 	stdout io.Writer
 	stderr io.Writer
 	stdin  io.Reader
+	paths  []string
+}
+
+func makeContext() Context {
+	path_str := getenv("PATH", "")
+	paths := make([]string, 0)
+	for elem := range strings.SplitSeq(path_str, ":") {
+		if elem == "" {
+			continue
+		}
+		if !strings.HasPrefix(elem, "/") {
+			continue
+		}
+		paths = append(paths, elem)
+	}
+	return Context{
+		stdout: os.Stdout,
+		stderr: os.Stderr,
+		stdin:  os.Stdin,
+		paths:  paths,
+	}
 }
 
 type GetCommandResult int
 type Command struct {
 	command_type CommandType
 	tokens       []string
+	exec_path    string
 }
 
 func makeCommandNone() Command {
 	return Command{
 		command_type: CommandTypeNone,
 		tokens:       nil,
+		exec_path:    "",
 	}
 }
 
-func makeCommand(command_type CommandType, tokens []string) Command {
-	if command_type == CommandTypeNone {
-		return Command{
-			command_type: command_type,
-			tokens:       nil,
-		}
-	} else {
+func makeCommandBuiltin(command_type CommandType, tokens []string) Command {
+	switch command_type {
+	case CommandTypeNone:
+		panic("invalid usage")
+	case CommandTypeExternal:
+		panic("invalid usage")
+	default:
 		return Command{
 			command_type: command_type,
 			tokens:       tokens,
 	}
 }
 
+func makeCommandExternal(tokens []string, exec_path string) Command {
+	return Command{
+		command_type: CommandTypeExternal,
+		tokens:       tokens,
+		exec_path:    exec_path,
+	}
+}
+
 type CommandType int
 
 const (
 	if err != nil {
 		return makeCommandNone(), err
 	}
-	command, err := parseCommand(command_line)
+	command, err := parseCommand(command_line, ctx.paths)
+	// fmt.Printf("getCommand():command=%#v\n", command)
 	if err != nil {
 		fmt.Fprintln(ctx.stderr, err)
 		return makeCommandNone(), nil
 	return tokens
 }
 
-func parseCommand(command_line string) (Command, error) {
+type ParseCommandError struct {
+	code  ParseCommandErrorCode
+	value string
+}
+type ParseCommandErrorCode int
+
+const (
+	ParseCommandErrorCodeNotFound ParseCommandErrorCode = iota
+)
+
+func (e ParseCommandError) Error() string {
+	switch e.code {
+	case ParseCommandErrorCodeNotFound:
+		return fmt.Sprintf("%s: not found", e.value)
+	default:
+		return fmt.Sprintf("unknown ParseCommandErrorCode code: %d .value=%q", e.code, e.value)
+	}
+}
+
+func parseCommand(command_line string, paths []string) (Command, error) {
 	tokens := tokenize(command_line)
 	if len(tokens) == 0 {
 		return makeCommandNone(), nil
 	}
 	if tokens[0] == "exit" {
-		return makeCommand(CommandTypeBuiltinExit, tokens), nil
+		return makeCommandBuiltin(CommandTypeBuiltinExit, tokens), nil
 	}
 	if tokens[0] == "echo" {
-		return makeCommand(CommandTypeBuiltinEcho, tokens), nil
+		return makeCommandBuiltin(CommandTypeBuiltinEcho, tokens), nil
 	}
 	if tokens[0] == "type" {
-		return makeCommand(CommandTypeBuiltinType, tokens), nil
+		return makeCommandBuiltin(CommandTypeBuiltinType, tokens), nil
 	}
-	return makeCommandNone(), fmt.Errorf("%s: not found", tokens[0])
+	for _, path := range paths {
+		full_path := fmt.Sprintf("%s/%s", path, tokens[0])
+		// fmt.Printf("parseCommand():full_path=%#v\n", full_path)
+		stat, err := os.Stat(full_path)
+		if err != nil {
+			continue
+		}
+		if stat.IsDir() {
+			continue
+		}
+		if stat.Mode()&0100 == 0 {
+			continue
+		}
+		return makeCommandExternal(tokens, full_path), nil
+	}
+	return makeCommandNone(), ParseCommandError{ParseCommandErrorCodeNotFound, tokens[0]}
 }
 
 func handleCommand(ctx Context, command Command) {
 			fmt.Fprintln(ctx.stderr, "usage: type COMMAND")
 			return
 		}
-		parsed, err := parseCommand(command.tokens[1])
+		parsed, err := parseCommand(command.tokens[1], ctx.paths)
 		if err != nil {
 			fmt.Fprintln(ctx.stderr, err)
 			return
 		case CommandTypeNone:
 			panic("impossible parseCommand() result")
 		case CommandTypeExternal:
-			fmt.Fprintf(ctx.stdout, "%s is an external command\n", parsed.tokens[0])
+			fmt.Fprintf(ctx.stdout, "%s is %s\n", parsed.tokens[0], parsed.exec_path)
 		default:
 			fmt.Fprintf(ctx.stdout, "%s is a shell builtin\n", parsed.tokens[0])
 		}
 }
 
 func main() {
-	ctx := Context{
-		stdout: os.Stdout,
-		stderr: os.Stderr,
-		stdin:  os.Stdin,
-	}
+	ctx := makeContext()
 	for {
 		command, err := getCommand(&ctx)
 		if err != nil {