Implement raw_input() (#233)

Author: corona10

runtime/builtin_types.go

@@ -18,6 +18,7 @@ import (
 	"fmt"
 	"math"
 	"math/big"
+	"strings"
 	"unicode"
 )
 
@@ -110,6 +111,7 @@ var builtinTypes = map[*Type]*builtinTypeInfo{
 	EllipsisType:                  {init: initEllipsisType, global: true},
 	enumerateType:                 {init: initEnumerateType, global: true},
 	EnvironmentErrorType:          {global: true},
+	EOFErrorType:                  {global: true},
 	ExceptionType:                 {global: true},
 	FileType:                      {init: initFileType, global: true},
 	FloatType:                     {init: initFloatType, global: true},
@@ -559,6 +561,37 @@ func builtinRange(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseException)
 	return ListType.Call(f, []*Object{r}, nil)
 }
 
+func builtinRawInput(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseException) {
+	if len(args) > 1 {
+		msg := fmt.Sprintf("[raw_]input expcted at most 1 arguments, got %d", len(args))
+		return nil, f.RaiseType(TypeErrorType, msg)
+	}
+
+	if Stdin == nil {
+		msg := fmt.Sprintf("[raw_]input: lost sys.stdin")
+		return nil, f.RaiseType(RuntimeErrorType, msg)
+	}
+
+	if Stdout == nil {
+		msg := fmt.Sprintf("[raw_]input: lost sys.stdout")
+		return nil, f.RaiseType(RuntimeErrorType, msg)
+	}
+
+	if len(args) == 1 {
+		err := pyPrint(f, args, "", "", Stdout)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	line, err := Stdin.reader.ReadString('\n')
+	if err != nil {
+		return nil, f.RaiseType(EOFErrorType, "EOF when reading a line")
+	}
+	line = strings.TrimRight(line, "\n")
+	return NewStr(line).ToObject(), nil
+}
+
 func builtinRepr(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseException) {
 	if raised := checkFunctionArgs(f, "repr", args, ObjectType); raised != nil {
 		return nil, raised
@@ -693,6 +726,7 @@ func init() {
 		"ord":            newBuiltinFunction("ord", builtinOrd).ToObject(),
 		"print":          newBuiltinFunction("print", builtinPrint).ToObject(),
 		"range":          newBuiltinFunction("range", builtinRange).ToObject(),
+		"raw_input":      newBuiltinFunction("raw_input", builtinRawInput).ToObject(),
 		"repr":           newBuiltinFunction("repr", builtinRepr).ToObject(),
 		"round":          newBuiltinFunction("round", builtinRound).ToObject(),
 		"setattr":        newBuiltinFunction("setattr", builtinSetAttr).ToObject(),

runtime/builtin_types_test.go

@@ -425,6 +425,60 @@ func TestBuiltinSetAttr(t *testing.T) {
 	}
 }
 
+func TestRawInput(t *testing.T) {
+	fun := wrapFuncForTest(func(f *Frame, s string, args ...*Object) (*Object, *BaseException) {
+		// Create a fake Stdin for input test.
+		stdinFile, w, err := os.Pipe()
+		if err != nil {
+			return nil, f.RaiseType(RuntimeErrorType, fmt.Sprintf("failed to open pipe: %v", err))
+		}
+
+		go func() {
+			w.Write([]byte(s))
+			w.Close()
+		}()
+
+		oldStdin := Stdin
+		Stdin = NewFileFromFD(stdinFile.Fd())
+		defer func() {
+			Stdin = oldStdin
+			stdinFile.Close()
+		}()
+
+		var input *Object
+		output, raised := captureStdout(f, func() *BaseException {
+			in, raised := builtinRawInput(f, args, nil)
+			input = in
+			return raised
+		})
+
+		if raised != nil {
+			return nil, raised
+		}
+
+		return newTestTuple(input, output).ToObject(), nil
+	})
+
+	cases := []invokeTestCase{
+		{args: wrapArgs("HelloGrumpy\n", ""), want: newTestTuple("HelloGrumpy", "").ToObject()},
+		{args: wrapArgs("HelloGrumpy\n", "ShouldBeShown\nShouldBeShown\t"), want: newTestTuple("HelloGrumpy", "ShouldBeShown\nShouldBeShown\t").ToObject()},
+		{args: wrapArgs("HelloGrumpy\n", 5, 4), wantExc: mustCreateException(TypeErrorType, "[raw_]input expcted at most 1 arguments, got 2")},
+		{args: wrapArgs("HelloGrumpy\nHelloGrumpy\n", ""), want: newTestTuple("HelloGrumpy", "").ToObject()},
+		{args: wrapArgs("HelloGrumpy\nHelloGrumpy\n", "ShouldBeShown\nShouldBeShown\t"), want: newTestTuple("HelloGrumpy", "ShouldBeShown\nShouldBeShown\t").ToObject()},
+		{args: wrapArgs("HelloGrumpy\nHelloGrumpy\n", 5, 4), wantExc: mustCreateException(TypeErrorType, "[raw_]input expcted at most 1 arguments, got 2")},
+		{args: wrapArgs("", ""), wantExc: mustCreateException(EOFErrorType, "EOF when reading a line")},
+		{args: wrapArgs("", "ShouldBeShown\nShouldBeShown\t"), wantExc: mustCreateException(EOFErrorType, "EOF when reading a line")},
+		{args: wrapArgs("", 5, 4), wantExc: mustCreateException(TypeErrorType, "[raw_]input expcted at most 1 arguments, got 2")},
+	}
+
+	for _, cas := range cases {
+		if err := runInvokeTestCase(fun, &cas); err != "" {
+			t.Error(err)
+		}
+	}
+
+}
+
 func newTestIndexObject(index int) *Object {
 	indexType := newTestClass("Index", []*Type{ObjectType}, newStringDict(map[string]*Object{
 		"__index__": newBuiltinFunction("__index__", func(f *Frame, _ Args, _ KWArgs) (*Object, *BaseException) {

runtime/exceptions.go

@@ -28,6 +28,8 @@ var (
 	// EnvironmentErrorType corresponds to the Python type
 	// 'EnvironmentError'.
 	EnvironmentErrorType = newSimpleType("EnvironmentError", StandardErrorType)
+	// EOFErrorType corresponds to the Python type 'EOFError'.
+	EOFErrorType = newSimpleType("EOFError", StandardErrorType)
 	// ExceptionType corresponds to the Python type 'Exception'.
 	ExceptionType = newSimpleType("Exception", BaseExceptionType)
 	// FutureWarningType corresponds to the Python type 'FutureWarning'.

runtime/file.go

@@ -361,6 +361,6 @@ var (
 	Stdin = NewFileFromFD(os.Stdin.Fd())
 	// Stdout is an alias for sys.stdout.
 	Stdout = NewFileFromFD(os.Stdout.Fd())
-	// Stderr is an aliaas for sys.stderr.
+	// Stderr is an alias for sys.stderr.
 	Stderr = NewFileFromFD(os.Stderr.Fd())
 )