refactor: move out reprompting and runner handling to functions

makes codefactor happy hopefully. this commit includes
a fix to check if after reprompt the user hits ctrl d
and just exits cleanly

exec.go

@@ -101,9 +101,9 @@ func runInput(input string, priv bool) {
 					cmdFinish(0, input, priv)
 					return
 				}
-				input, exitCode, err, cont = handleSh(input)
+				input, exitCode, cont, err = handleSh(input)
 			case "hybridRev":
-				_, _, err, cont = handleSh(input)
+				_, _, _, err = handleSh(input)
 				if err == nil {
 					cmdFinish(0, input, priv)
 					return
@@ -112,17 +112,57 @@ func runInput(input string, priv bool) {
 			case "lua":
 				input, exitCode, err = handleLua(cmdString)
 			case "sh":
-				input, exitCode, err, cont = handleSh(input)
+				input, exitCode, cont, err = handleSh(input)
 		}
 	} else {
 		// can only be a string or function so
-		term := rt.NewTerminationWith(l.MainThread().CurrentCont(), 3, false)
-		err = rt.Call(l.MainThread(), currentRunner, []rt.Value{rt.StringValue(input)}, term)
+		input, exitCode, cont, err = runLuaRunner(currentRunner, input)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			cmdFinish(124, input, priv)
 			return
 		}
+	}
+
+	if cont {
+		input, err = reprompt(input)
+		if err == nil {
+			goto rerun
+		} else if err == io.EOF {
+			return
+		}
+	}
+
+	if err != nil {
+		if exErr, ok := isExecError(err); ok {
+			hooks.Em.Emit("command." + exErr.typ, exErr.cmd)
+			err = exErr.sprint()
+		}
+		fmt.Fprintln(os.Stderr, err)
+	}
+	cmdFinish(exitCode, input, priv)
+}
+
+func reprompt(input string) (string, error) {
+	for {
+		in, err := continuePrompt(strings.TrimSuffix(input, "\\"))
+		if err != nil {
+			return input, err
+		}
+
+		if strings.HasSuffix(in, "\\") {
+			continue
+		}
+		return in, nil
+	}
+}
+
+func runLuaRunner(runr rt.Value, userInput string) (input string, exitCode uint8, continued bool, err error) {
+	term := rt.NewTerminationWith(l.MainThread().CurrentCont(), 3, false)
+	err = rt.Call(l.MainThread(), runr, []rt.Value{rt.StringValue(userInput)}, term)
+	if err != nil {
+		return
+	}
 
 	var runner *rt.Table
 	var ok bool
@@ -144,31 +184,9 @@ func runInput(input string, priv bool) {
 	}
 
 	if c, ok := runner.Get(rt.StringValue("continue")).TryBool(); ok {
-			cont = c
+		continued = c
 	}
-	}
-
-	if cont {
-		for {
-			input, err = continuePrompt(strings.TrimSuffix(input, "\\"))
-			if err != nil {
-				break
-			}
-
-			if strings.HasSuffix(cmdString, "\\") {
-				continue
-			}
-			goto rerun
-		}
-	}
-	if err != nil {
-		if exErr, ok := isExecError(err); ok {
-			hooks.Em.Emit("command." + exErr.typ, exErr.cmd)
-			err = exErr.sprint()
-		}
-		fmt.Fprintln(os.Stderr, err)
-	}
-	cmdFinish(exitCode, input, priv)
+	return
 }
 
 func handleLua(cmdString string) (string, uint8, error) {
@@ -197,25 +215,25 @@ func handleLua(cmdString string) (string, uint8, error) {
 	return cmdString, 125, err
 }
 
-func handleSh(cmdString string) (string, uint8, error, bool) {
+func handleSh(cmdString string) (string, uint8, bool, error) {
 	_, _, err := execCommand(cmdString, true)
 	if err != nil {
 		// If input is incomplete, start multiline prompting
 		if syntax.IsIncomplete(err) {
 			if !interactive {
-				return cmdString, 126, err, false
+				return cmdString, 126, false, err
 			}
-			return cmdString, 126, err, true
+			return cmdString, 126, true, err
 		} else {
 			if code, ok := interp.IsExitStatus(err); ok {
-				return cmdString, code, nil, false
+				return cmdString, code, false, nil
 			} else {
-				return cmdString, 126, err, false
+				return cmdString, 126, false, err
 			}
 		}
 	}
 
-	return cmdString, 0, nil, false
+	return cmdString, 0, false, nil
 }
 
 // Run command in sh interpreter

runnermode.go

@@ -28,7 +28,7 @@ func shRunner(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 		return nil, err
 	}
 
-	input, exitCode, err, cont := handleSh(cmd)
+	input, exitCode, cont, err := handleSh(cmd)
 	var luaErr rt.Value = rt.NilValue
 	if err != nil {
 		luaErr = rt.StringValue(err.Error())