Implement #IP1

app/main.go

 	"fmt"
 	"io"
 	"os"
+	"os/exec"
 	"strings"
 )
 
-func getenv(key string, fallback string) string {
-	value, ok := os.LookupEnv(key)
-	if ok {
-		return value
-	} else {
-		return fallback
-	}
-}
+type ExitStatus uint16
 
 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,
 	}
 }
 
 	if err != nil {
 		return makeCommandNone(), err
 	}
-	command, err := parseCommand(command_line, ctx.paths)
+	command, err := parseCommand(command_line)
 	// fmt.Printf("getCommand():command=%#v\n", command)
 	if err != nil {
 		fmt.Fprintln(ctx.stderr, err)
 	}
 }
 
-func parseCommand(command_line string, paths []string) (Command, error) {
+func parseCommand(command_line string) (Command, error) {
 	tokens := tokenize(command_line)
 	if len(tokens) == 0 {
 		return makeCommandNone(), nil
 	if tokens[0] == "type" {
 		return makeCommandBuiltin(CommandTypeBuiltinType, tokens), nil
 	}
-	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
+	exec_path, err := exec.LookPath(tokens[0])
+	if err != nil {
+		return makeCommandNone(), ParseCommandError{ParseCommandErrorCodeNotFound, tokens[0]}
 	}
-	return makeCommandNone(), ParseCommandError{ParseCommandErrorCodeNotFound, tokens[0]}
+	return makeCommandExternal(tokens, exec_path), nil
 }
 
-func handleCommand(ctx Context, command Command) {
+func handleCommand(ctx Context, command Command) ExitStatus {
 	// fmt.Printf("handleCommand():command=%#v\n", command)
 	switch command.command_type {
 	case CommandTypeNone:
-		return
+		return 0
 	case CommandTypeBuiltinExit:
 		os.Exit(0)
 	case CommandTypeBuiltinEcho:
 	case CommandTypeBuiltinType:
 		if len(command.tokens) != 2 {
 			fmt.Fprintln(ctx.stderr, "usage: type COMMAND")
-			return
+			return 2
 		}
-		parsed, err := parseCommand(command.tokens[1], ctx.paths)
+		parsed, err := parseCommand(command.tokens[1])
 		if err != nil {
 			fmt.Fprintln(ctx.stderr, err)
-			return
+			return 0
 		}
 		switch parsed.command_type {
 		case CommandTypeNone:
 		default:
 			fmt.Fprintf(ctx.stdout, "%s is a shell builtin\n", parsed.tokens[0])
 		}
+	case CommandTypeExternal:
+		cmd := exec.Command(command.exec_path, command.tokens[1:]...)
+		cmd.Args = command.tokens
+		cmd.Stdout = ctx.stdout
+		cmd.Stderr = ctx.stderr
+		cmd.Stdin = ctx.stdin
+		err := cmd.Run()
+		if err != nil {
+			if exiterr, ok := err.(*exec.ExitError); ok {
+				return ExitStatus(exiterr.ExitCode())
+				// fmt.Printf("handleCommand():exiterr=%#v\n", exiterr.ExitCode())
+			} else {
+				fmt.Printf("handleCommand():err=%#v\n", err)
+				return ExitStatus(65535)
+			}
+		}
+		return ExitStatus(0)
+	default:
+		panic("unknown command type")
 	}
+	return ExitStatus(65535)
 }
 
 func main() {
 			fmt.Fprintln(os.Stderr, "Error reading input: ", err)
 			os.Exit(1)
 		}
-		handleCommand(ctx, command)
+		_ = handleCommand(ctx, command)
 	}
 }