Index: /issm/trunk-jpl/src/c/ext/fmemopen/README.md =================================================================== --- /issm/trunk-jpl/src/c/ext/fmemopen/README.md (revision 25638) +++ /issm/trunk-jpl/src/c/ext/fmemopen/README.md (revision 25638) @@ -0,0 +1,49 @@ +fmemopen for Mac OS and iOS +=========================== + +Originally ported from [ingenuitas python-tesseract](https://github.com/ingenuitas/python-tesseract/blob/master/fmemopen.c). Ported by Jeff Verkoeyen under the Apache 2.0 License. + +From the fmemopen man page: + +> FILE *fmemopen(void *buf, size_t size, const char *mode); +> +> The fmemopen() function opens a stream that permits the access specified by mode. The stream +> allows I/O to be performed on the string or memory buffer pointed to by buf. This buffer must be +> at least size bytes long. + +Alas, this method does not exist on BSD operating systems (specifically Mac OS X and iOS). It is +possible to recreate this functionality using a BSD-specific method called `funopen`. + +From the funopen man page: + +> FILE * funopen(const void *cookie, int (*readfn)(void *, char *, int), +> int (*writefn)(void *, const char *, int), fpos_t (*seekfn)(void *, fpos_t, int), +> int (*closefn)(void *)); +> +> The funopen() function associates a stream with up to four ``I/O functions''. Either readfn or +> writefn must be specified; the others can be given as an appropriately-typed NULL pointer. These +> I/O functions will be used to read, write, seek and close the new stream. + +fmemopen.c provides a simple implementation of fmemopen using funopen so that you can create FILE +pointers to blocks of memory. + +Adding it to your Project +========================= + +Drag fmemopen.h and fmemopen.c to your project and add them to your target. `#include "fmemopen.h"` +wherever you need to use `fmemopen`. + +Examples +======== + +```obj-c +#import "fmemopen.h" + +NSString* string = @"fmemopen in Objective-C"; +const char* cstr = [string UTF8String]; +FILE* file = fmemopen((void *)cstr, sizeof(char) * (string.length + 1), "r"); + +// fread on file will now read the contents of the NSString + +fclose(file); +``` Index: /issm/trunk-jpl/src/c/ext/fmemopen/fmemopen.c =================================================================== --- /issm/trunk-jpl/src/c/ext/fmemopen/fmemopen.c (revision 25638) +++ /issm/trunk-jpl/src/c/ext/fmemopen/fmemopen.c (revision 25638) @@ -0,0 +1,78 @@ +/* + * fmem.c : fmemopen() on top of BSD's funopen() + * 20081017 AF + */ + +#define _GNU_SOURCE +#include +#include +#include + +#ifndef linux +struct fmem { + size_t pos; + size_t size; + char *buffer; +}; +typedef struct fmem fmem_t; + +static int readfn(void *handler, char *buf, int size) +{ + int count = 0; + fmem_t *mem = handler; + size_t available = mem->size - mem->pos; + + if(size > available) size = available; + for(count=0; count < size; mem->pos++, count++) + buf[count] = mem->buffer[mem->pos]; + + return count; +} + +static int writefn(void *handler, const char *buf, int size) +{ + int count = 0; + fmem_t *mem = handler; + size_t available = mem->size - mem->pos; + + if(size > available) size = available; + for(count=0; count < size; mem->pos++, count++) + mem->buffer[mem->pos] = buf[count]; + + return count; // ? count : size; +} + +static fpos_t seekfn(void *handler, fpos_t offset, int whence) +{ + size_t pos; + fmem_t *mem = handler; + + switch(whence) { + case SEEK_SET: pos = offset; break; + case SEEK_CUR: pos = mem->pos + offset; break; + case SEEK_END: pos = mem->size + offset; break; + default: return -1; + } + + if(pos < 0 || pos > mem->size) return -1; + + mem->pos = pos; + return (fpos_t) pos; +} + +static int closefn(void *handler) +{ + free(handler); + return 0; +} + +/* simple, but portable version of fmemopen for OS X / BSD */ +FILE *fmemopen(void *buf, size_t size, const char *mode) +{ + fmem_t *mem = (fmem_t *) malloc(sizeof(fmem_t)); + + memset(mem, 0, sizeof(fmem_t)); + mem->size = size, mem->buffer = buf; + return funopen(mem, readfn, writefn, seekfn, closefn); +} +#endif Index: /issm/trunk-jpl/src/c/ext/fmemopen/fmemopen.h =================================================================== --- /issm/trunk-jpl/src/c/ext/fmemopen/fmemopen.h (revision 25638) +++ /issm/trunk-jpl/src/c/ext/fmemopen/fmemopen.h (revision 25638) @@ -0,0 +1,52 @@ +// +// Copyright 2012 Jeff Verkoeyen +// Originally ported from https://github.com/ingenuitas/python-tesseract/blob/master/fmemopen.c +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef FMEMOPEN_H_ +#define FMEMOPEN_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif + +/** + * A BSD port of the fmemopen Linux method using funopen. + * + * man docs for fmemopen: + * http://linux.die.net/man/3/fmemopen + * + * man docs for funopen: + * https://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man3/funopen.3.html + * + * This method is ported from ingenuitas' python-tesseract project. + * + * You must call fclose on the returned file pointer or memory will be leaked. + * + * @param buf The data that will be used to back the FILE* methods. Must be at least + * @c size bytes. + * @param size The size of the @c buf data. + * @param mode The permitted stream operation modes. + * @returns A pointer that can be used in the fread/fwrite/fseek/fclose family of methods. + * If a failure occurred NULL will be returned. + */ +FILE *fmemopen(void *buf, size_t size, const char *mode); + +#ifdef __cplusplus +} +#endif + +#endif // #ifndef FMEMOPEN_H_ Index: /issm/trunk-jpl/src/c/ext/fmemopen/open_memstream.c =================================================================== --- /issm/trunk-jpl/src/c/ext/fmemopen/open_memstream.c (revision 25638) +++ /issm/trunk-jpl/src/c/ext/fmemopen/open_memstream.c (revision 25638) @@ -0,0 +1,130 @@ +/* Use funopen(3) to provide open_memstream(3) like functionality. */ + +#include +#include +#include +#include + +struct memstream { + char **cp; + size_t *lenp; + size_t offset; +}; + +static void +memstream_grow(struct memstream *ms, size_t newsize) +{ + char *buf; + + if (newsize > *ms->lenp) { + buf = realloc(*ms->cp, newsize + 1); + if (buf != NULL) { +#ifdef DEBUG + fprintf(stderr, "MS: %p growing from %zd to %zd\n", + ms, *ms->lenp, newsize); +#endif + memset(buf + *ms->lenp + 1, 0, newsize - *ms->lenp); + *ms->cp = buf; + *ms->lenp = newsize; + } + } +} + +static int +memstream_read(void *cookie, char *buf, int len) +{ + struct memstream *ms; + int tocopy; + + ms = cookie; + memstream_grow(ms, ms->offset + len); + tocopy = *ms->lenp - ms->offset; + if (len < tocopy) + tocopy = len; + memcpy(buf, *ms->cp + ms->offset, tocopy); + ms->offset += tocopy; +#ifdef DEBUG + fprintf(stderr, "MS: read(%p, %d) = %d\n", ms, len, tocopy); +#endif + return (tocopy); +} + +static int +memstream_write(void *cookie, const char *buf, int len) +{ + struct memstream *ms; + int tocopy; + + ms = cookie; + memstream_grow(ms, ms->offset + len); + tocopy = *ms->lenp - ms->offset; + if (len < tocopy) + tocopy = len; + memcpy(*ms->cp + ms->offset, buf, tocopy); + ms->offset += tocopy; +#ifdef DEBUG + fprintf(stderr, "MS: write(%p, %d) = %d\n", ms, len, tocopy); +#endif + return (tocopy); +} + +static fpos_t +memstream_seek(void *cookie, fpos_t pos, int whence) +{ + struct memstream *ms; +#ifdef DEBUG + size_t old; +#endif + + ms = cookie; +#ifdef DEBUG + old = ms->offset; +#endif + switch (whence) { + case SEEK_SET: + ms->offset = pos; + break; + case SEEK_CUR: + ms->offset += pos; + break; + case SEEK_END: + ms->offset = *ms->lenp + pos; + break; + } +#ifdef DEBUG + fprintf(stderr, "MS: seek(%p, %zd, %d) %zd -> %zd\n", ms, pos, whence, + old, ms->offset); +#endif + return (ms->offset); +} + +static int +memstream_close(void *cookie) +{ + + free(cookie); + return (0); +} + +FILE * +open_memstream(char **cp, size_t *lenp) +{ + struct memstream *ms; + int save_errno; + FILE *fp; + + *cp = NULL; + *lenp = 0; + ms = malloc(sizeof(*ms)); + ms->cp = cp; + ms->lenp = lenp; + ms->offset = 0; + fp = funopen(ms, memstream_read, memstream_write, memstream_seek, + memstream_close); + if (fp == NULL) { + save_errno = errno; + free(ms); + errno = save_errno; + } + return (fp); +} Index: /issm/trunk-jpl/src/c/ext/fmemopen/open_memstream.h =================================================================== --- /issm/trunk-jpl/src/c/ext/fmemopen/open_memstream.h (revision 25638) +++ /issm/trunk-jpl/src/c/ext/fmemopen/open_memstream.h (revision 25638) @@ -0,0 +1,15 @@ +#ifndef OPEN_MEMSTREAM_H_ +#define OPEN_MEMSTREAM_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif + +FILE *open_memstream(char **cp, size_t *lenp); + +#ifdef __cplusplus +} +#endif + +#endif // #ifndef FMEMOPEN_H_