New iread function.

The read function no longer works like it used to on an
interactive terminal because of the support for .. and .
syntax on a top-level expression.

The iread function is provided which uses a modified syntax
that doesn't support these operators on a top-level
expression. The parser thus doesn't look one token ahead,
and so iread can return immediately.

* eval.c (eval_init): Register iread intrinsic function.

* parser.c (prime_parser):  Only push back the recently seen
token when priming for a regular Lisp read. Handle
the prime_interactive method by preparing a SECRET_ESCAPE_I
token.
(lisp_parse_impl): New static function, formed from previous
lisp_parse. Takes a boolean argument indicating interactive
mode.
(prime_parser_post): New function.
(lisp_parse): Now a wrapper for lisp_parse_impl which
passes a nil to indicate noninteractive read.
(iread): New function.

* parser.h (enum prime_parser): New member, prime_interactive.
(scrub_scanner, iread, prime_parser_post): Declared.

* parser.l (prime_scanner): Handle the prime_interactive case
the same way as prime_lisp.
(scrub_scanner): New function.

* parser.y (SECRET_ESCAPE_I): New token type.
(i_expr): New nonterminal symbol. Like n_expr, but doesn't
support dot or dotdot operators, except in nested
subexpressions.
(spec): Handle SECRET_ESCAPE_I by way of i_expr.
(sym_helper): Before freeing the token lexeme, call
scrub_scanner. If the token is registered as the scanner's
most recently seen token, the scanner must forget that
registration, because it is no longer valid.
(parse): Call prime_parser_post.

* txr.1: Documented iread.

1 files changed, 5 insertions, 1 deletions

diff --git a/parser.h b/parser.h
index 95b9e4f7..46da0d16 100644
--- a/parser.h
+++ b/parser.h
@@ -55,7 +55,7 @@ struct parser {
 };
 #endif
 
-enum prime_parser { prime_lisp, prime_regex };
+enum prime_parser { prime_lisp, prime_interactive, prime_regex };
 
 extern const int have_yydebug;
 extern const wchar_t *spec_file;
@@ -80,7 +80,9 @@ void yyset_hold_char(yyscan_t, int);
 void parser_l_init(void);
 void open_txr_file(val spec_file, val *txr_lisp_p, val *name, val *stream);
 void prime_parser(parser_t *, val name, enum prime_parser);
+void prime_parser_post(parser_t *, enum prime_parser);
 void prime_scanner(scanner_t *, enum prime_parser);
+void scrub_scanner(scanner_t *, int yy_char, wchar_t *lexeme);
 int parse_once(val stream, val name, parser_t *parser);
 int parse(parser_t *parser, val name, enum prime_parser);
 val source_loc(val form);
@@ -95,6 +97,8 @@ val rlcp_tree(val to, val from);
 val regex_parse(val string, val error_stream);
 val lisp_parse(val source_in, val error_stream, val error_return_val,
                val name_in, val lineno);
+val iread(val source_in, val error_stream, val error_return_val,
+          val name_in, val lineno);
 val read_eval_stream(val stream, val error_stream, val hash_bang_support);
 #if HAVE_TERMIOS
 val repl(val bindings, val in_stream, val out_stream);