Better EOF check in read-eval stream function.

This makes a difference if we read from a TTY.
Without this fix, two Ctrl-D's have to be issued
before the code registers EOF and returns.

The trick is that we know, after calling the
parser, whether it hit EOF, because we have
the recent token. If its value is zero, that's
the EOF token. We can bail out of the loop
instead of calling the parser again which will
require another EOF (because prime_parser
will not push an EOF token!)

* parser.h (parser_eof): Declared.

* parser.c (read_eval_stream): After lisp_parse
and eval, check for EOF with the parser_eof
function, and bail if so.
(parser_eof): New function.

2 files changed, 11 insertions, 1 deletions

diff --git a/parser.c b/parser.c
index 5d24fcb0..d232e588 100644
--- a/parser.c
+++ b/parser.c
@@ -351,14 +351,17 @@ val read_eval_stream(val stream, val error_stream, val hash_bang_support)
 
   for (;;) {
     val form = lisp_parse(stream, error_stream, error_val, name, colon_k);
+    val parser = get_parser(stream);
 
     if (form == error_val) {
-      if (parser_errors(get_parser(stream)) == zero)
+      if (parser_errors(parser) == zero)
         break;
       return nil;
     }
 
     (void) eval_intrinsic(form, nil);
+    if (parser_eof(parser))
+      break;
   }
 
   return t;
@@ -638,6 +641,12 @@ val parser_errors(val parser)
   return num(p->errors);
 }
 
+val parser_eof(val parser)
+{
+  parser_t *p = coerce(parser_t *, cobj_handle(parser, parser_s));
+  return tnil(p->recent_tok.yy_char == 0);
+}
+
 void parse_init(void)
 {
   parser_s = intern(lit("parser"), user_package);
diff --git a/parser.h b/parser.h
index efbaa351..95b9e4f7 100644
--- a/parser.h
+++ b/parser.h
@@ -104,4 +104,5 @@ void parser_cleanup(parser_t *);
 val parser(val stream, val lineno);
 val get_parser(val stream);
 val parser_errors(val parser);
+val parser_eof(val parser);
 void parse_init(void);