From a1ee3b30d3ab21f35975646cc12711478ca25574 Mon Sep 17 00:00:00 2001 From: Vitor Santos Costa Date: Tue, 27 Sep 2016 19:32:27 -0500 Subject: [PATCH] fix mess with memory streams --- os/CMakeLists.txt | 1 + os/charsio.c | 2 +- os/fmem.c | 332 ++++++++++++++++++++++++++++++++++++++++++++++ os/format.c | 130 +----------------- os/format.h | 25 ++++ os/mem.c | 168 ++++++++++++----------- os/stream.h | 10 +- 7 files changed, 449 insertions(+), 219 deletions(-) create mode 100644 os/fmem.c create mode 100644 os/format.h diff --git a/os/CMakeLists.txt b/os/CMakeLists.txt index c65a435a5..dd5e1c492 100644 --- a/os/CMakeLists.txt +++ b/os/CMakeLists.txt @@ -6,6 +6,7 @@ set (YAPOS_SOURCES chartypes.c console.c files.c + fmem.c fmemopen.c format.c iopreds.c diff --git a/os/charsio.c b/os/charsio.c index d3e9dd151..ff661abee 100644 --- a/os/charsio.c +++ b/os/charsio.c @@ -112,7 +112,7 @@ Int Yap_peek(int sno) { return ch; } #endif -#if !MAY_READ +#if !HAVE_FMEMOPEN if (s->status & InMemory_Stream_f ) { return Yap_MemPeekc( sno ); } diff --git a/os/fmem.c b/os/fmem.c new file mode 100644 index 000000000..e4e662cfb --- /dev/null +++ b/os/fmem.c @@ -0,0 +1,332 @@ +/************************************************************************* +* * +* YAP Prolog * +* * +* Yap Prolog was developed at NCCUP - Universidade do Porto * +* * +* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * +* * +************************************************************************** +* * +* File: mem.c * +* Last rev: 5/2/88 * +* mods: * +* comments: Input/Output C implemented predicates * +* * +*************************************************************************/ +#ifdef SCCS +static char SccsId[] = "%W% %G%"; +#endif + +/* + * This file includes the definition of a socket related IO. + * + */ + +#include "sysbits.h" +#include "format.h" + +#if HAVE_FMEMOPEN + + + + bool format_synch(int sno, int sno0, format_info *fg) { + int (*f_putc)(int, int); + const char *s; + int n; + if (sno == sno0) { +#if MAY_WRITE + fflush(GLOBAL_Stream[sno].file); +#endif + return true; + } + f_putc = GLOBAL_Stream[sno0].stream_putc; +#if MAY_WRITE + if (fflush(GLOBAL_Stream[sno].file) == 0) { + s = GLOBAL_Stream[sno].nbuf; + n = ftell(GLOBAL_Stream[sno].file); + fwrite(s, n, 1, GLOBAL_Stream[sno0].file); + rewind(GLOBAL_Stream[sno].file); + fflush(GLOBAL_Stream[sno0].file); + } else + return false; +#else + s = GLOBAL_Stream[sno].u.mem_string.buf; + n = GLOBAL_Stream[sno].u.mem_string.pos; +#endif +#if MAY_WRITE +#else + while (n--) { + f_putc(sno0, *s++); + } + GLOBAL_Stream[sno].u.mem_string.pos = 0; +#endif + GLOBAL_Stream[sno].linecount = 1; + GLOBAL_Stream[sno].linepos = 0; + GLOBAL_Stream[sno].charcount = 0; + fg->lstart = 0; + fg->phys_start = 0; + fg->gapi = 0; + return true; +} + + bool fill_pads(int sno, int sno0, int total, format_info *fg USES_REGS) +// uses directly the buffer in the memory stream. + { + int nfillers, fill_space, lfill_space, nchars; + int (*f_putc)(int, int); + const char *buf; + int phys_end; + + f_putc = GLOBAL_Stream[sno0].stream_putc; + if (fflush(GLOBAL_Stream[sno].file) == 0) { + buf = GLOBAL_Stream[sno].nbuf; + phys_end = ftell(GLOBAL_Stream[sno].file); + } else + return false; + if (fg->gapi == 0) { + fg->gap[0].phys = phys_end; + fg->gap[0].filler = ' '; + fg->gapi = 1; + } + nchars = total - GLOBAL_Stream[sno].linepos; + if (nchars < 0) + nchars = 0; /* ignore */ + nfillers = fg->gapi; + fill_space = nchars / nfillers; + lfill_space = nchars % nfillers; + + int i = fg->phys_start; + gap_t *padi = fg->gap; + while (i < phys_end) { + if (i == padi->phys) { + int j; + for (j = 0; j < fill_space; j++) + f_putc(sno0, padi->filler); + padi++; + /* last gap??*/ + if (padi - fg->gap == fg->gapi) { + for (j = 0; j < fill_space; j++) + f_putc(sno0, (padi - 1)->filler); + } + } + f_putc(sno0, buf[i++]); + } + // final gap + if (i == padi->phys) { + int j; + for (j = 0; j < fill_space + lfill_space; j++) + f_putc(sno0, padi->filler); + }; + + rewind(GLOBAL_Stream[sno].file); + fflush(GLOBAL_Stream[sno0].file); + GLOBAL_Stream[sno].linecount = 1; + GLOBAL_Stream[sno].linepos += nchars; + GLOBAL_Stream[sno].charcount = 0; + fg->phys_start = 0; + fg->lstart = GLOBAL_Stream[sno].linepos; + fg->gapi = 0; + return true; +} + + +bool Yap_set_stream_to_buf(StreamDesc *st, const char *buf, size_t nchars) { + FILE *f; + stream_flags_t flags; + + // like any file stream. + st->file = f = fmemopen((void *)buf, nchars, "r"); + flags = Input_Stream_f | InMemory_Stream_f | Seekable_Stream_f; + Yap_DefaultStreamOps(st); + return true; +} + +int Yap_open_buf_read_stream(const char *buf, size_t nchars, encoding_t *encp, + memBufSource src) { + CACHE_REGS + int sno; + StreamDesc *st; + FILE *f; + encoding_t encoding; + stream_flags_t flags; + + sno = GetFreeStreamD(); + if (sno < 0) + return (PlIOError(RESOURCE_ERROR_MAX_STREAMS, TermNil, + "new stream not available for open_mem_read_stream/1")); + st = GLOBAL_Stream + sno; + if (encp) + encoding = *encp; + else + encoding = LOCAL_encoding; + // like any file stream. + f = st->file = fmemopen((void *)buf, nchars, "r"); + flags = Input_Stream_f | InMemory_Stream_f | Seekable_Stream_f; + Yap_initStream(sno, f, NULL, TermNil, encoding, flags, AtomRead); +// like any file stream. + Yap_DefaultStreamOps(st); + UNLOCK(st->streamlock); + return sno; +} + +static Int +open_mem_read_stream(USES_REGS1) /* $open_mem_read_stream(+List,-Stream) */ +{ + Term t, ti; + int sno; + char buf0[YAP_FILENAME_MAX + 1]; + const char *buf; + + ti = Deref(ARG1); + buf = Yap_TextTermToText(ti, buf0, 0, LOCAL_encoding); + if (!buf) { + return false; + } + sno = Yap_open_buf_read_stream(buf, strlen(buf) + 1, &LOCAL_encoding, + MEM_BUF_MALLOC); + t = Yap_MkStream(sno); + return Yap_unify(ARG2, t); +} + +// open a buffer for writing, currently just ignores buf and nchars. + +int Yap_open_buf_write_stream(encoding_t enc, memBufSource src) { + CACHE_REGS + int sno; + StreamDesc *st; + + sno = GetFreeStreamD(); + if (sno < 0) + return -1; + st = GLOBAL_Stream + sno; + st->status = Output_Stream_f | InMemory_Stream_f | FreeOnClose_Stream_f; + st->linepos = 0; + st->charcount = 0; + st->linecount = 1; + st->encoding = enc; + Yap_DefaultStreamOps(st); +#if HAVE_OPEN_MEMSTREAM + st->file = open_memstream(&st->nbuf, &st->nsize); + // setbuf(st->file, NULL); + st->status |= Seekable_Stream_f; +#else + st->file = fmemopen((void *)buf, nchars, "w"); + st->nsize = nchars; + st->nbuf = buf; + if (!st->nbuf) { + return -1; + } +#endif + UNLOCK(st->streamlock); + return sno; +} + +int Yap_OpenBufWriteStream(USES_REGS1) { + + return Yap_open_buf_write_stream( + GLOBAL_Stream[LOCAL_c_output_stream].encoding, 0); +} + +static Int +open_mem_write_stream(USES_REGS1) /* $open_mem_write_stream(-Stream) */ +{ + Term t; + int sno; + + sno = Yap_OpenBufWriteStream(PASS_REGS1); + if (sno == -1) + return (PlIOError(SYSTEM_ERROR_INTERNAL, TermNil, + "new stream not available for open_mem_read_stream/1")); + t = Yap_MkStream(sno); + GLOBAL_Stream[sno].status |= InMemory_Stream_f; + return (Yap_unify(ARG1, t)); +} + +/** + * Yap_PeekMemwriteStream() shows the current buffer for a memory stream. + * + * @param sno, the in-memory stream + * + * @return temporary buffer, discarded by close and may be moved away + * by other writes.. + */ +char *Yap_MemExportStreamPtr(int sno) { + char *s; + if (fflush(GLOBAL_Stream[sno].file) == 0) { + s = GLOBAL_Stream[sno].nbuf; + // s[fseek(GLOBAL_Stream[sno].file, 0, SEEK_END)] = '\0'; + return s; + } + return NULL; +} + +static Int peek_mem_write_stream( + USES_REGS1) { /* '$peek_mem_write_stream'(+GLOBAL_Stream,?S0,?S) */ + Int sno = + Yap_CheckStream(ARG1, (Output_Stream_f | InMemory_Stream_f), "close/2"); + Int i; + Term tf = ARG2; + CELL *HI; + const char *ptr; + + if (sno < 0) + return (FALSE); +restart: + HI = HR; + if (fflush(GLOBAL_Stream[sno].file) == 0) { + i = fseek(GLOBAL_Stream[sno].file, 0, SEEK_END); + ptr = GLOBAL_Stream[sno].nbuf; + } + while (i > 0) { + --i; + tf = MkPairTerm(MkIntTerm(ptr[i]), tf); + if (HR + 1024 >= ASP) { + UNLOCK(GLOBAL_Stream[sno].streamlock); + HR = HI; + if (!Yap_gcl((ASP - HI) * sizeof(CELL), 3, ENV, Yap_gcP())) { + UNLOCK(GLOBAL_Stream[sno].streamlock); + Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage); + return (FALSE); + } + i = GLOBAL_Stream[sno].u.mem_string.pos; + tf = ARG2; + LOCK(GLOBAL_Stream[sno].streamlock); + goto restart; + } + } + UNLOCK(GLOBAL_Stream[sno].streamlock); + return (Yap_unify(ARG3, tf)); +} + +void Yap_MemOps(StreamDesc *st) { + st->stream_putc = FilePutc; + + st->stream_getc = PlGetc; + +} + +bool Yap_CloseMemoryStream(int sno) { + if ((GLOBAL_Stream[sno].status & Output_Stream_f)) { + fflush(GLOBAL_Stream[sno].file); + fclose(GLOBAL_Stream[sno].file); + if (GLOBAL_Stream[sno].status & FreeOnClose_Stream_f) + free(GLOBAL_Stream[sno].nbuf); + } else { + fclose(GLOBAL_Stream[sno].file); + if (GLOBAL_Stream[sno].status & FreeOnClose_Stream_f) + free(GLOBAL_Stream[sno].nbuf); + } + return true; +} + +void Yap_InitMems(void) { + CACHE_REGS + Yap_InitCPred("open_mem_read_stream", 2, open_mem_read_stream, SyncPredFlag); + Yap_InitCPred("open_mem_write_stream", 1, open_mem_write_stream, + SyncPredFlag); + Yap_InitCPred("peek_mem_write_stream", 3, peek_mem_write_stream, + SyncPredFlag); +} + +#endif diff --git a/os/format.c b/os/format.c index 2cb35e058..02c9d7827 100644 --- a/os/format.c +++ b/os/format.c @@ -265,133 +265,8 @@ output is directed to the stream used by format/2. #include "eval.h" #include "iopreds.h" +#include "format.h" -#define FORMAT_MAX_SIZE 1024 - -typedef struct { - Int filler; - /* character to dump */ - int phys; - /* position in buffer */ - int log; /* columnn as wide chsh */ -} gap_t; - -typedef struct format_status { - gap_t gap[16]; - // number of octets - int phys_start; - // number of characters - int lstart; - int gapi; -} format_info; - -static bool format_synch(int sno, int sno0, format_info *fg) { - int (*f_putc)(int, int); - const char *s; - int n; - if (sno == sno0) { -#if MAY_WRITE - fflush(GLOBAL_Stream[sno].file); -#endif - return true; - } - f_putc = GLOBAL_Stream[sno0].stream_putc; -#if MAY_WRITE - if (fflush(GLOBAL_Stream[sno].file) == 0) { - s = GLOBAL_Stream[sno].nbuf; - n = ftell(GLOBAL_Stream[sno].file); - fwrite(s, n, 1, GLOBAL_Stream[sno0].file); - rewind(GLOBAL_Stream[sno].file); - fflush(GLOBAL_Stream[sno0].file); - } else - return false; -#else - s = GLOBAL_Stream[sno].u.mem_string.buf; - n = GLOBAL_Stream[sno].u.mem_string.pos; -#endif -#if MAY_WRITE -#else - while (n--) { - f_putc(sno0, *s++); - } - GLOBAL_Stream[sno].u.mem_string.pos = 0; -#endif - GLOBAL_Stream[sno].linecount = 1; - GLOBAL_Stream[sno].linepos = 0; - GLOBAL_Stream[sno].charcount = 0; - fg->lstart = 0; - fg->phys_start = 0; - fg->gapi = 0; - return true; -} - -// uses directly the buffer in the memory stream. -static bool fill_pads(int sno, int sno0, int total, format_info *fg USES_REGS) { - int nfillers, fill_space, lfill_space, nchars; - int (*f_putc)(int, int); - const char *buf; - int phys_end; - - f_putc = GLOBAL_Stream[sno0].stream_putc; -#if MAY_WRITE - if (fflush(GLOBAL_Stream[sno].file) == 0) { - buf = GLOBAL_Stream[sno].nbuf; - phys_end = ftell(GLOBAL_Stream[sno].file); - } else - return false; -#else - buf = GLOBAL_Stream[sno].u.mem_string.buf; - phys_end = GLOBAL_Stream[sno].u.mem_string.pos; -#endif - if (fg->gapi == 0) { - fg->gap[0].phys = phys_end; - fg->gap[0].filler = ' '; - fg->gapi = 1; - } - nchars = total - GLOBAL_Stream[sno].linepos; - if (nchars < 0) - nchars = 0; /* ignore */ - nfillers = fg->gapi; - fill_space = nchars / nfillers; - lfill_space = nchars % nfillers; - - int i = fg->phys_start; - gap_t *padi = fg->gap; - while (i < phys_end) { - if (i == padi->phys) { - int j; - for (j = 0; j < fill_space; j++) - f_putc(sno0, padi->filler); - padi++; - /* last gap??*/ - if (padi - fg->gap == fg->gapi) { - for (j = 0; j < fill_space; j++) - f_putc(sno0, (padi - 1)->filler); - } - } - f_putc(sno0, buf[i++]); - } - // final gap - if (i == padi->phys) { - int j; - for (j = 0; j < fill_space + lfill_space; j++) - f_putc(sno0, padi->filler); - }; - -#if MAY_WRITE - rewind(GLOBAL_Stream[sno].file); - fflush(GLOBAL_Stream[sno0].file); -#else - GLOBAL_Stream[sno].u.mem_string.pos = 0; -#endif - GLOBAL_Stream[sno].linecount = 1; - GLOBAL_Stream[sno].linepos += nchars; - GLOBAL_Stream[sno].charcount = 0; - fg->phys_start = 0; - fg->lstart = GLOBAL_Stream[sno].linepos; - fg->gapi = 0; - return true; -} static int format_print_str(Int sno, Int size, Int has_size, Term args, int (*f_putc)(int, wchar_t)) { @@ -430,9 +305,6 @@ static int format_print_str(Int sno, Int size, Int has_size, Term args, return TRUE; } -#define FORMAT_COPY_ARGS_ERROR -1 -#define FORMAT_COPY_ARGS_OVERFLOW -2 - static Int format_copy_args(Term args, Term *targs, Int tsz) { Int n = 0; while (args != TermNil) { diff --git a/os/format.h b/os/format.h new file mode 100644 index 000000000..5333c7839 --- /dev/null +++ b/os/format.h @@ -0,0 +1,25 @@ + +#define FORMAT_MAX_SIZE 1024 + +typedef struct { + Int filler; + /* character to dump */ + int phys; + /* position in buffer */ + int log; /* columnn as wide chsh */ +} gap_t; + +typedef struct format_status { + gap_t gap[16]; + // number of octets + int phys_start; + // number of characters + int lstart; + int gapi; +} format_info; + +#define FORMAT_COPY_ARGS_ERROR -1 +#define FORMAT_COPY_ARGS_OVERFLOW -2 + +extern bool format_synch(int sno, int sno0, format_info *fg); +extern bool fill_pads(int sno, int sno0, int total, format_info *fg USES_REGS); \ No newline at end of file diff --git a/os/mem.c b/os/mem.c index f0b83cf13..3aee106d9 100644 --- a/os/mem.c +++ b/os/mem.c @@ -25,8 +25,89 @@ static char SccsId[] = "%W% %G%"; #include "sysbits.h" -#if !MAY_READ -static int MemGetc(int); + +#if !HAVE_FMEMOPEN || !defined(HAVE_FMEMOPEN) + + +#include "format.h" + + bool format_synch(int sno, int sno0, format_info *fg) { + int (*f_putc)(int, int); + const char *s; + int n; + if (sno == sno0) { + return true; + } + f_putc = GLOBAL_Stream[sno0].stream_putc; + s = GLOBAL_Stream[sno].u.mem_string.buf; + n = GLOBAL_Stream[sno].u.mem_string.pos; + while (n--) { + f_putc(sno0, *s++); + } + GLOBAL_Stream[sno].u.mem_string.pos = 0; + GLOBAL_Stream[sno].linecount = 1; + GLOBAL_Stream[sno].linepos = 0; + GLOBAL_Stream[sno].charcount = 0; + fg->lstart = 0; + fg->phys_start = 0; + fg->gapi = 0; + return true; +} + +// uses directly the buffer in the memory stream. + bool fill_pads(int sno, int sno0, int total, format_info *fg USES_REGS) { + int nfillers, fill_space, lfill_space, nchars; + int (*f_putc)(int, int); + const char *buf; + int phys_end; + + f_putc = GLOBAL_Stream[sno0].stream_putc; + buf = GLOBAL_Stream[sno].u.mem_string.buf; + phys_end = GLOBAL_Stream[sno].u.mem_string.pos; + if (fg->gapi == 0) { + fg->gap[0].phys = phys_end; + fg->gap[0].filler = ' '; + fg->gapi = 1; + } + nchars = total - GLOBAL_Stream[sno].linepos; + if (nchars < 0) + nchars = 0; /* ignore */ + nfillers = fg->gapi; + fill_space = nchars / nfillers; + lfill_space = nchars % nfillers; + + int i = fg->phys_start; + gap_t *padi = fg->gap; + while (i < phys_end) { + if (i == padi->phys) { + int j; + for (j = 0; j < fill_space; j++) + f_putc(sno0, padi->filler); + padi++; + /* last gap??*/ + if (padi - fg->gap == fg->gapi) { + for (j = 0; j < fill_space; j++) + f_putc(sno0, (padi - 1)->filler); + } + } + f_putc(sno0, buf[i++]); + } + // final gap + if (i == padi->phys) { + int j; + for (j = 0; j < fill_space + lfill_space; j++) + f_putc(sno0, padi->filler); + }; + + GLOBAL_Stream[sno].u.mem_string.pos = 0; + GLOBAL_Stream[sno].linecount = 1; + GLOBAL_Stream[sno].linepos += nchars; + GLOBAL_Stream[sno].charcount = 0; + fg->phys_start = 0; + fg->lstart = GLOBAL_Stream[sno].linepos; + fg->gapi = 0; + return true; +} /* read from memory */ static int MemGetc(int sno) { @@ -59,9 +140,6 @@ int Yap_MemPeekc(int sno) { return ch; } -#endif - -#if !MAY_WRITE static int MemPutc(int, int); /* static */ @@ -102,24 +180,15 @@ static int MemPutc(int sno, int ch) { return ((int)ch); } -#endif - bool Yap_set_stream_to_buf(StreamDesc *st, const char *buf, size_t nchars) { FILE *f; stream_flags_t flags; -#if MAY_READ - // like any file stream. - st->file = f = fmemopen((void *)buf, nchars, "r"); - flags = Input_Stream_f | InMemory_Stream_f | Seekable_Stream_f; -#else st->file = f = NULL; flags = Input_Stream_f | InMemory_Stream_f; -#endif Yap_initStream(st - GLOBAL_Stream, f, NULL, TermNil, LOCAL_encoding, flags, AtomRead); // like any file stream. -#if !MAY_READ /* currently these streams are not seekable */ st->status = Input_Stream_f | InMemory_Stream_f; st->u.mem_string.pos = 0; @@ -127,7 +196,6 @@ bool Yap_set_stream_to_buf(StreamDesc *st, const char *buf, size_t nchars) { st->u.mem_string.max_size = nchars; st->u.mem_string.error_handler = NULL; // st->u.mem_string.src = src; check new assets coode -#endif Yap_DefaultStreamOps(st); return true; } @@ -150,17 +218,10 @@ int Yap_open_buf_read_stream(const char *buf, size_t nchars, encoding_t *encp, encoding = *encp; else encoding = LOCAL_encoding; -#if MAY_READ - // like any file stream. - f = st->file = fmemopen((void *)buf, nchars, "r"); - flags = Input_Stream_f | InMemory_Stream_f | Seekable_Stream_f; -#else st->file = f = NULL; flags = Input_Stream_f | InMemory_Stream_f; -#endif Yap_initStream(sno, f, NULL, TermNil, encoding, flags, AtomRead); // like any file stream. -#if !MAY_READ /* currently these streams are not seekable */ st->status = Input_Stream_f | InMemory_Stream_f; st->u.mem_string.pos = 0; @@ -168,7 +229,6 @@ int Yap_open_buf_read_stream(const char *buf, size_t nchars, encoding_t *encp, st->u.mem_string.max_size = nchars; st->u.mem_string.error_handler = NULL; st->u.mem_string.src = src; -#endif Yap_DefaultStreamOps(st); UNLOCK(st->streamlock); return sno; @@ -210,26 +270,10 @@ int Yap_open_buf_write_stream(encoding_t enc, memBufSource src) { st->linecount = 1; st->encoding = enc; Yap_DefaultStreamOps(st); -#if MAY_WRITE -#if HAVE_OPEN_MEMSTREAM - st->file = open_memstream(&st->nbuf, &st->nsize); - // setbuf(st->file, NULL); - st->status |= Seekable_Stream_f; -#else - st->file = fmemopen((void *)buf, nchars, "w"); - st->nsize = nchars; - st->nbuf = buf; - if (!st->nbuf) { - return -1; - } -#endif -#else st->nbuf = st->u.mem_string.buf = malloc(PLGETC_BUF_SIZE); - st->u.mem_string.src == MEM_BUF_MALLOC; - st->u.mem_string.src = 1; + st->u.mem_string.src = MEM_BUF_MALLOC; st->u.mem_string.max_size = PLGETC_BUF_SIZE - 1; st->u.mem_string.pos = 0; -#endif UNLOCK(st->streamlock); return sno; } @@ -264,19 +308,10 @@ open_mem_write_stream(USES_REGS1) /* $open_mem_write_stream(-Stream) */ * by other writes.. */ char *Yap_MemExportStreamPtr(int sno) { -#if MAY_WRITE - char *s; - if (fflush(GLOBAL_Stream[sno].file) == 0) { - s = GLOBAL_Stream[sno].nbuf; - // s[fseek(GLOBAL_Stream[sno].file, 0, SEEK_END)] = '\0'; - return s; - } - return NULL; -#else + GLOBAL_Stream[sno].u.mem_string.buf[GLOBAL_Stream[sno].u.mem_string.pos] = '\0'; return GLOBAL_Stream[sno].u.mem_string.buf; -#endif } static Int peek_mem_write_stream( @@ -292,15 +327,8 @@ static Int peek_mem_write_stream( return (FALSE); restart: HI = HR; -#if MAY_WRITE - if (fflush(GLOBAL_Stream[sno].file) == 0) { - i = fseek(GLOBAL_Stream[sno].file, 0, SEEK_END); - ptr = GLOBAL_Stream[sno].nbuf; - } -#else ptr = GLOBAL_Stream[sno].u.mem_string.buf; i = GLOBAL_Stream[sno].u.mem_string.pos; -#endif while (i > 0) { --i; tf = MkPairTerm(MkIntTerm(ptr[i]), tf); @@ -323,41 +351,19 @@ restart: } void Yap_MemOps(StreamDesc *st) { -#if MAY_WRITE - st->stream_putc = FilePutc; -#else st->stream_putc = MemPutc; -#endif -#if MAY_READ - st->stream_getc = PlGetc; -#else - st->stream_getc = MemGetc; -#endif -} + st->stream_getc = MemGetc;} bool Yap_CloseMemoryStream(int sno) { if ((GLOBAL_Stream[sno].status & Output_Stream_f)) { -#if MAY_WRITE - fflush(GLOBAL_Stream[sno].file); - fclose(GLOBAL_Stream[sno].file); - if (GLOBAL_Stream[sno].status & FreeOnClose_Stream_f) - free(GLOBAL_Stream[sno].nbuf); -#else if (GLOBAL_Stream[sno].u.mem_string.src == MEM_BUF_MALLOC) { free(GLOBAL_Stream[sno].u.mem_string.buf); } -#endif } else { -#if MAY_READ - fclose(GLOBAL_Stream[sno].file); - if (GLOBAL_Stream[sno].status & FreeOnClose_Stream_f) - free(GLOBAL_Stream[sno].nbuf); -#else if (GLOBAL_Stream[sno].u.mem_string.src == MEM_BUF_MALLOC) { free(GLOBAL_Stream[sno].u.mem_string.buf); } -#endif } return true; } @@ -370,3 +376,5 @@ void Yap_InitMems(void) { Yap_InitCPred("peek_mem_write_stream", 3, peek_mem_write_stream, SyncPredFlag); } + +#endif \ No newline at end of file diff --git a/os/stream.h b/os/stream.h index 8d7ca1494..e2f9a74f8 100644 --- a/os/stream.h +++ b/os/stream.h @@ -15,15 +15,6 @@ static char SccsId[] = "%W% %G%"; #undef HAVE_OPEN_MEMSTREAM #endif -#if HAVE_FMEMOPEN -#define MAY_READ 1 -#endif - -#if HAVE_OPEN_MEMSTREAM -#define MAY_READ 1 -#define MAY_WRITE 1 -#endif - #if _WIN32 #undef MAY_WRITE #undef MAY_READ @@ -85,3 +76,4 @@ typedef struct stream_desc { from above if the ISO character conversion is on */ encoding_t encoding; /** current encoding for stream */ } StreamDesc; +