Reading a line of text from file

[dnbsd]

I wrote a script mimicking the behavior of interactive programs by reading from stdin. The script:

for {
	printf("> ")
	line := string(os.stdin.read())

	switch line {
	case "generate":
		print("generate")
	case "exit":
		os.exit(0)
	default:
		printf("unknown command: %q\n", line)
	}
}

This has a major drawback of not recognizing the newline as the "stop" character. I wonder whether I am missing some information that I glazed over reading the documentation. In Go this would be implemented as such (taken from SO):

reader := bufio.NewReader(os.Stdin)
fmt.Print("Enter text: ")
text, _ := reader.ReadString('\n')
fmt.Println(text)

[mna]

It seems that os.stdin.read() without argument will read until the EOF, so it stops only after ctrl-D. This program seems to do what you want, passing a byte slice to read so that it fills it until a newline is found:

buf := byte_slice(10)

line := ""
for {
	printf("> ")

	line += string(os.stdin.read(buf))
	for {
		// interestingly, for !strings.contains(line, "\n") {...} does not work
		if strings.contains(line, "\n") {
			break
		} else {
			line += string(os.stdin.read(buf))
		}
	}
	parts := strings.split(line, "\n")
	cmd := switch len(parts) {
		case 0:
			line = ""
			""
		case 1:
			line = ""
			parts[0]
		case 2:
			line = parts[1]
			parts[0]
	}

	switch cmd {
	case "echo":
		print("echo")
	case "exit":
		os.exit(0)
	default:
		printf("unknown command: %q\n", cmd)
	}
}

[dnbsd]

Thank you, @mna. Your example does indeed solve my problem. Here's how I adapted the gist of your code to a function:

func readLine(f) {
	buf := byte_slice(255)
	for {
		printf("> ")
		line := string(f.read(buf))
		if !strings.contains(line, '\n') {
			continue
		}
		return line[:-1]
	}
}

What was the indication that read accepts a buffer? Even now, knowing that it exists, I can't find this mentioned anywhere in the documentation.

[mna]

What was the indication that read accepts a buffer? Even now, knowing that it exists, I can't find this mentioned anywhere in the documentation.

Yeah it doesn't seem like the File object is documented at the moment. I looked at the code and you can see in the File's attributes that read has various overloads:

risor/object/file.go

Lines 64 to 106 in b83ab51

	case "read":
	return NewBuiltin("file.read", func(ctx context.Context, args ...Object) Object {
	if len(args) > 1 {
	return NewArgsRangeError("file.read", 0, 1, len(args))
	}
	if len(args) == 0 {
	bytes, err := io.ReadAll(f.value)
	if err != nil {
	return NewError(err)
	}
	return NewByteSlice(bytes)
	}
	switch obj := args[0].(type) {
	case *ByteSlice:
	slice := obj.Value()
	n, ioErr := f.Read(slice)
	if ioErr != nil && ioErr != io.EOF {
	return NewError(ioErr)
	}
	if n == len(slice) {
	return obj
	}
	return NewByteSlice(slice[:n])
	case *Buffer:
	stat, err := f.value.Stat()
	if err != nil {
	return NewError(err)
	}
	size := stat.Size()
	if size > math.MaxInt32 {
	return NewError(errors.New("file.read: file size exceeds maximum int32"))
	}
	buf := obj.Value()
	buf.Grow(int(size)) // review: this can panic
	n, ioErr := f.Read(buf.Bytes())
	if ioErr != nil && ioErr != io.EOF {
	return NewError(ioErr)
	}
	return NewByteSlice(buf.Bytes()[:n])
	default:
	return Errorf("type error: file.read expects byte_slice or buffer (%s given)", obj.Type())
	}
	}), true

.