* configure: Added check to detect POSIX sleep function.

* eval.c (eval_init): Register new open_tail function as intrinsic.

* match.c (complex_snarf, complex_stream): Update calls to
make_stdio_stream and make_pipe_stream to take fewer arguments.
(match_files): Support a stream object as a data source specification
in place of a string.

* parser.l (parse_reset): Update call to make_stdio_stream to take
fewer arguments.

* stream.c: Inclusion of <unistd.h> made properly conditional.
(struct stdio_handle): pid member defined as pid_t only if we have fork
functionality, otherwise defined as int.
(tail_get_line, tail_get_char, tail_get_byte): New static functions.
(tail_ops): New static structure.
(make_stdio_stream_common): New static structure.
(make_stdio_stream, make_pipe_stream): These functions lose the input
and output parameters, which ended up never used. Reimplemented
in terms of new common function.
(make_tail_stream): New function.
(make_pipevp_stream): Reimplemented in terms of new common function.
(open_file, open_command): Simplified by removal of useless local
variables and their computation, which used to be extra arguments to
make_stdio_stream and make_pipe_stream.
(open_tail): New function.
(stream_init): Calls to make_stdio_stream updated.

* stream.h (make_stdio_stream, make_pipe_stream): Declarations updated.
(make_tail_stream, open_tail): Declared.

* txr.c (txr_main): Calls to make_stdio_stream updated.

1 files changed, 34 insertions, 26 deletions

diff --git a/match.c b/match.c
index c8517201..100089b7 100644
--- a/match.c
+++ b/match.c
@@ -1521,9 +1521,9 @@ static val complex_snarf(fpip_t fp, val name)
 {
   switch (fp.close) {
   case fpip_fclose:
-    return lazy_stream_cons(make_stdio_stream(fp.f, name, t, nil));
+    return lazy_stream_cons(make_stdio_stream(fp.f, name));
   case fpip_pclose:
-    return lazy_stream_cons(make_pipe_stream(fp.f, name, t, nil));
+    return lazy_stream_cons(make_pipe_stream(fp.f, name));
   case fpip_closedir:
     return lazy_stream_cons(make_dir_stream(fp.d));
   }
@@ -1535,9 +1535,9 @@ static val complex_stream(fpip_t fp, val name)
 {
   switch (fp.close) {
   case fpip_fclose:
-    return make_stdio_stream(fp.f, name, t, nil);
+    return make_stdio_stream(fp.f, name);
   case fpip_pclose:
-    return make_pipe_stream(fp.f, name, t, nil);
+    return make_pipe_stream(fp.f, name);
   case fpip_closedir:
     uw_throwf(query_error_s, lit("cannot output to directory: ~a"), name, nao);
   }
@@ -3650,37 +3650,45 @@ static val match_files(match_files_ctx c)
   gc_hint(c.data);
 
   if (listp(c.data)) { /* recursive call with lazy list */
-    ; /* no specia initialization */
+    ; /* no special initialization */
   } else if (c.files) { /* c.data == t: toplevel call with file list */
     val source_spec = first(c.files);
     val name = consp(source_spec) ? cdr(source_spec) : source_spec;
-    fpip_t fp = (errno = 0, complex_open(name, nil, nil));
-    spec_bind (specline, first_spec, c.spec);
 
-    if (consp(first_spec) && eq(first(first_spec), next_s) && !rest(specline)) {
-      debuglf(first_spec, lit("not opening source ~a "
-                                   "since query starts with next directive"), name, nao);
-    } else {
-      val spec = first(c.spec);
-      debuglf(spec, lit("opening data source ~a"), name, nao);
+    if (stringp(name)) {
+      fpip_t fp = (errno = 0, complex_open(name, nil, nil));
+      spec_bind (specline, first_spec, c.spec);
+
+      if (consp(first_spec) && eq(first(first_spec), next_s) && !rest(specline)) {
+        debuglf(first_spec, lit("not opening source ~a "
+                                     "since query starts with next directive"), name, nao);
+      } else {
+        val spec = first(c.spec);
+        debuglf(spec, lit("opening data source ~a"), name, nao);
 
-      if (complex_open_failed(fp)) {
-        if (consp(source_spec) && car(source_spec) == nothrow_k) {
-          debuglf(spec, lit("could not open ~a: "
-                            "treating as failed match due to nothrow"), name, nao);
+        if (complex_open_failed(fp)) {
+          if (consp(source_spec) && car(source_spec) == nothrow_k) {
+            debuglf(spec, lit("could not open ~a: "
+                              "treating as failed match due to nothrow"), name, nao);
+            debug_return (nil);
+          } else if (errno != 0)
+            file_err(spec, lit("could not open ~a (error ~a/~a)"), name,
+                     num(errno), string_utf8(strerror(errno)), nao);
+          else
+            file_err(spec, lit("could not open ~a"), name, nao);
           debug_return (nil);
-        } else if (errno != 0)
-          file_err(spec, lit("could not open ~a (error ~a/~a)"), name,
-                   num(errno), string_utf8(strerror(errno)), nao);
-        else
-          file_err(spec, lit("could not open ~a"), name, nao);
-        debug_return (nil);
-      }
+        }
 
-      c.files = cons(name, cdr(c.files)); /* Get rid of cons and nothrow */
+        c.files = cons(name, cdr(c.files)); /* Get rid of cons and nothrow */
 
-      if ((c.data = complex_snarf(fp, name)) != nil)
+        if ((c.data = complex_snarf(fp, name)) != nil)
+          c.data_lineno = num(1);
+      }
+    } else if (streamp(name)) {
+      if ((c.data = lazy_stream_cons(name)))
         c.data_lineno = num(1);
+    } else {
+      c.data = nil;
     }
   } else { /* toplevel call with no data or file list */
     c.data = nil;