Add support for "getline lvalue" (#85)

Parsing getline is tricky, and I needed to add a PeekByte function to
the lexer so the parser can tell the difference between "getline foo"
and "getline foo()".

There are still a few arcane forms not supported by GoAWK (see
commented-out interp tests), but most forms are supported now.

Also ensure data returned by getline is treated as numeric string.

Author: benhoyt

goawk_test.go

@@ -218,11 +218,10 @@ func sortedLines(data []byte) []byte {
 
 func TestGAWK(t *testing.T) {
 	skip := map[string]bool{ // TODO: fix these
-		"inputred": true, // getInputScanner errors
-
 		"getline":  true, // getline syntax issues (may be okay, see grammar notes at http://pubs.opengroup.org/onlinepubs/007904975/utilities/awk.html#tag_04_06_13_14)
 		"getline3": true, // getline syntax issues (similar to above)
 		"getline5": true, // getline syntax issues (similar to above)
+		"inputred": true, // getline syntax issues (similar to above)
 
 		"gsubtst7":     true, // something wrong with gsub or field split/join
 		"splitwht":     true, // other awks handle split(s, a, " ") differently from split(s, a, / /)

internal/ast/ast.go

@@ -299,7 +299,7 @@ func (e *MultiExpr) String() string {
 // GetlineExpr is an expression read from file or pipe input.
 type GetlineExpr struct {
 	Command Expr
-	Var     *VarExpr
+	Target  Expr
 	File    Expr
 }
 
@@ -309,8 +309,8 @@ func (e *GetlineExpr) String() string {
 		s += e.Command.String() + " |"
 	}
 	s += "getline"
-	if e.Var != nil {
-		s += " " + e.Var.String()
+	if e.Target != nil {
+		s += " " + e.Target.String()
 	}
 	if e.File != nil {
 		s += " <" + e.File.String()

interp/interp.go

@@ -910,8 +910,8 @@ func (p *interp) eval(expr Expr) (value, error) {
 				return num(-1), nil
 			}
 		}
-		if e.Var != nil {
-			err := p.setVar(e.Var.Scope, e.Var.Index, str(line))
+		if e.Target != nil {
+			err := p.assign(e.Target, numStr(line))
 			if err != nil {
 				return null(), err
 			}

interp/interp_test.go

@@ -596,18 +596,36 @@ BEGIN { foo(5); bar(10) }
 		"", "", `parse error at 1:46: global var "foo" can't also be a function`, "function"},
 	{`function f(x) { print x, x(); }  BEGIN { f() }`, "", "", `parse error at 1:27: can't call local variable "x" as function`, "function"},
 
-	// Redirected I/O (we give explicit errors, awk and gawk don't)
-	{`BEGIN { print >"out"; getline <"out" }  # !awk !gawk`, "", "", "can't read from writer stream", ""},
-	{`BEGIN { print |"out"; getline <"out" }  # !awk !gawk`, "", "", "can't read from writer stream", ""},
-	{`BEGIN { print >"out"; close("out"); getline <"out"; print >"out" }  # !awk !gawk`, "", "", "can't write to reader stream", ""},
-	{`BEGIN { print >"out"; close("out"); getline <"out"; print |"out" }  # !awk !gawk`, "", "", "can't write to reader stream", ""},
-	// TODO: currently we support "getline var" but not "getline lvalue"
-	// {`BEGIN { getline a[1]; print a[1] }`, "foo", "foo\n", "", ""},
-	// {`BEGIN { getline $1; print $1 }`, "foo", "foo\n", "", ""},
+	// Redirected I/O
+	{`BEGIN { getline a[1]; print a[1] }`, "foo", "foo\n", "", ""},
+	{`BEGIN { getline $1; print $1 }`, "foo", "foo\n", "", ""},
+	{`BEGIN { "echo foo" | getline a[1]; print a[1] }`, "", "foo\n", "", ""},
+	{`BEGIN { "echo foo" | getline $1; print $1 }`, "", "foo\n", "", ""},
 	{`BEGIN { print "foo" |"sort"; print "bar" |"sort" }  # !fuzz`, "", "bar\nfoo\n", "", ""},
 	{`BEGIN { print "foo" |">&2 echo error" }  # !gawk !fuzz`, "", "error\n", "", ""},
 	{`BEGIN { "cat" | getline; print }  # !fuzz`, "bar", "bar\n", "", ""},
 	{`BEGIN { print getline x < "/no/such/file" }  # !fuzz`, "", "-1\n", "", ""},
+	{`BEGIN { print getline "z"; print $0 }`, "foo", "1z\nfoo\n", "", ""},
+	{`BEGIN { print getline x+1; print x }`, "foo", "2\nfoo\n", "", ""},
+	{`BEGIN { print getline (x+1); print $0 }`, "foo", "11\nfoo\n", "", ""},
+	{`BEGIN { print getline foo(); print $0 } function foo() { print "z" }`, "foo", "z\n1\nfoo\n", "", ""},
+	// TODO: these forms don't yet work under GoAWK
+	//{`BEGIN { print("echo foo" | getline x+1); print x }`, "", "2\nfoo\n", "", ""},
+	//{`BEGIN { print("echo foo" | getline $0+1); print }`, "", "2\nfoo\n", "", ""},
+	//{`BEGIN { print("echo foo" | getline ($0+1)); print }`, "", "11\nfoo\n", "", ""},
+	//{`BEGIN { print("echo foo" | getline foo()); print } function foo() { print "z" }`, "", "z\n1\nfoo\n", "", ""},
+
+	// Ensure data returned by getline (in various forms) is treated as numeric string
+	{`BEGIN { getline; print($0==0) }`, "0.0", "1\n", "", ""},
+	{`BEGIN { getline x; print(x==0) }`, "0.0", "1\n", "", ""},
+	{`BEGIN { "echo 0.0" | getline; print($0==0) }`, "", "1\n", "", ""},
+	{`BEGIN { "echo 0.0" | getline x; print(x==0) }`, "", "1\n", "", ""},
+
+	// Redirected I/O errors (we give explicit errors, awk and gawk don't)
+	{`BEGIN { print >"out"; getline <"out" }  # !awk !gawk`, "", "", "can't read from writer stream", ""},
+	{`BEGIN { print |"out"; getline <"out" }  # !awk !gawk`, "", "", "can't read from writer stream", ""},
+	{`BEGIN { print >"out"; close("out"); getline <"out"; print >"out" }  # !awk !gawk`, "", "", "can't write to reader stream", ""},
+	{`BEGIN { print >"out"; close("out"); getline <"out"; print |"out" }  # !awk !gawk`, "", "", "can't write to reader stream", ""},
 
 	// Redirecting to or from a filename of "-" means write to stdout or read from stdin
 	{`BEGIN { print getline x < "-"; print x }`, "a\nb\n", "1\na\n", "", ""},

lexer/lexer.go

@@ -453,3 +453,9 @@ func (l *Lexer) choice(ch byte, one, two Token) Token {
 	}
 	return one
 }
+
+// PeekByte returns the next unscanned byte; used when parsing
+// "getline lvalue" expressions. Returns 0 at end of input.
+func (l *Lexer) PeekByte() byte {
+	return l.ch
+}

lexer/lexer_test.go

@@ -151,6 +151,34 @@ func TestHadSpace(t *testing.T) {
 	}
 }
 
+func TestPeekByte(t *testing.T) {
+	l := NewLexer([]byte("foo()"))
+	b := l.PeekByte()
+	if b != 'f' {
+		t.Errorf("expected 'f', got %q", b)
+	}
+	_, tok, _ := l.Scan()
+	if tok != NAME {
+		t.Errorf("expected name, got %s", tok)
+	}
+	b = l.PeekByte()
+	if b != '(' {
+		t.Errorf("expected '(', got %q", b)
+	}
+	_, tok, _ = l.Scan()
+	if tok != LPAREN {
+		t.Errorf("expected (, got %s", tok)
+	}
+	_, tok, _ = l.Scan()
+	if tok != RPAREN {
+		t.Errorf("expected ), got %s", tok)
+	}
+	b = l.PeekByte()
+	if b != 0 {
+		t.Errorf("expected 0, got %q", b)
+	}
+}
+
 func TestKeywordToken(t *testing.T) {
 	tests := []struct {
 		name string