stream.mx

这个是内存数据库中的一个管理工具

void
close_stream(stream *s)
{
	s->close(s);
	s->destroy(s);
}

stream *
stream_rstream(stream *s)
{
#ifdef STREAM_DEBUG
	printf("stream_rstream %s\n", s->name ? s->name : "<unnamed>");
#endif
	assert(s->access == ST_READ);
	s->type = ST_BIN;
	if (s->errnr == NO__ERROR)
		s->read(s, (void *) &s->byteorder, sizeof(s->byteorder), 1);
	return s;
}

stream *
stream_wstream(stream *s)
{
#ifdef STREAM_DEBUG
	printf("stream_wstream %s\n", s->name ? s->name : "<unnamed>");
#endif
	assert(s->access == ST_WRITE);
	s->type = ST_BIN;
	if (s->errnr == NO__ERROR)
		s->write(s, (void *) &s->byteorder, sizeof(s->byteorder), 1);
	return s;
}

#define EXT_LEN 4
static const char *
get_extention(const char *file)
{
	char *ext_start;

	return (ext_start = strrchr(file, '.')) != NULL ? ext_start + 1 : "";
}

static void
destroy(stream *s)
{
	free(s->name);
	free(s);
}

static char *
error(stream *s)
{
	char buf[BUFSIZ];

	switch (s->errnr) {
	case OPEN_ERROR:
		snprintf(buf, BUFSIZ, "error could not open file %s\n", s->name);
		return strdup(buf);
	case READ_ERROR:
		snprintf(buf, BUFSIZ, "error reading file %s\n", s->name);
		return strdup(buf);
	case WRITE_ERROR:
		snprintf(buf, BUFSIZ, "error writing file %s\n", s->name);
		return strdup(buf);
	}
	return strdup("Unknown error");
}

static stream *
create_stream(const char *name)
{
	stream *s;

	if ((s = (stream *) malloc(sizeof(*s))) == NULL)
		return NULL;
	s->byteorder = 1234;
	s->access = ST_READ;
	s->type = ST_ASCII;
	s->name = strdup(name);
	s->stream_data.p = NULL;
	s->errnr = NO__ERROR;
	s->stream_data.p = NULL;
	s->read = NULL;
	s->readline = NULL;
	s->write = NULL;
	s->close = NULL;
	s->error = error;
	s->destroy = destroy;
	s->flush = NULL;
	s->fsync = NULL;
#ifdef STREAM_DEBUG
	printf("create_stream %s -> " PTRFMT "\n", name ? name : "<unnamed>", PTRFMTCAST s);
#endif
	return s;
}

static ssize_t
file_read(stream *s, void *buf, size_t elmsize, size_t cnt)
{
	FILE *fp = (FILE *) s->stream_data.p;
	size_t rc = 0;

	if (!feof(fp)) {
		rc = fread(buf, elmsize, cnt, fp);
		if (ferror(fp))
			s->errnr = READ_ERROR;
	}
	return rc;
}

static ssize_t
file_write(stream *s, const void *buf, size_t elmsize, size_t cnt)
{
	if (elmsize && cnt) {
		size_t rc = fwrite(buf, elmsize, cnt, (FILE *) s->stream_data.p);

		if (rc < cnt)
			s->errnr = WRITE_ERROR;
		return (ssize_t) rc;
	}
	return cnt;
}

static void
file_close(stream *s)
{
	FILE *fp = (FILE *) s->stream_data.p;

	if (!fp)
		return;
	if (fp != stdin && fp != stdout && fp != stderr)
		fclose(fp);
	else if (s->access == ST_WRITE)
		fflush(fp);
	s->stream_data.p = NULL;
}

static int
file_flush(stream *s)
{
	FILE *fp = (FILE*)s->stream_data.p;

	if (s->access == ST_WRITE && fflush(fp) < 0){
		s->errnr = WRITE_ERROR;
		return 1;
	}
	return 0;
}

static int
file_fsync(stream *s)
{

	FILE *fp = (FILE*)s->stream_data.p;

	if (s->access == ST_WRITE &&
#ifdef NATIVE_WIN32
	    _commit(_fileno(fp)) < 0
#else
	    fsync(fileno(fp)) < 0
#endif
		){
		s->errnr = WRITE_ERROR;
		return 1;
	}
	return 0;
}

static stream *
open_stream(const char *filename, const char *flags)
{
	stream *s;
	FILE *fp;

	if ((s = create_stream(filename)) == NULL)
		return NULL;
	if ((fp = fopen(filename, flags)) == NULL)
		s->errnr = OPEN_ERROR;
	s->read = file_read;
	s->readline = NULL;
	s->write = file_write;
	s->close = file_close;
	s->flush = file_flush;
	s->fsync = file_fsync;
	s->stream_data.p = (void *) fp;
	return s;
}

#ifdef HAVE_LIBZ
static ssize_t
stream_gzread(stream *s, void *buf, size_t elmsize, size_t cnt)
{
	gzFile *fp = (gzFile *) s->stream_data.p;
	int size = (int) (elmsize * cnt);

	if (!gzeof(fp)) {
		size = gzread(fp, buf, size);
		if (size)
			return size / elmsize;
	}
	return 0;
}

static ssize_t
stream_gzwrite(stream *s, const void *buf, size_t elmsize, size_t cnt)
{
	int size = (int) (elmsize * cnt);

	if (size) {
		size = gzwrite((gzFile *) s->stream_data.p, (void *) buf, size);
		return size / elmsize;
	}
	return cnt;
}

static void
stream_gzclose(stream *s)
{
	if (s->stream_data.p)
		gzclose((gzFile *) s->stream_data.p);
	s->stream_data.p = NULL;
}

static int
stream_gzflush(stream *s)
{
	if (s->access == ST_WRITE)
		gzflush((gzFile *) s->stream_data.p, Z_SYNC_FLUSH);
	return 0;
}

static stream *
open_gzstream(const char *filename, const char *flags)
{
	stream *s;
	gzFile *fp;

	if ((s = create_stream(filename)) == NULL)
		return NULL;
	if ((fp = gzopen(filename, flags)) == NULL)
		s->errnr = OPEN_ERROR;
	s->read = stream_gzread;
	s->write = stream_gzwrite;
	s->close = stream_gzclose;
	s->flush = stream_gzflush;
	s->stream_data.p = (void *) fp;
	return s;
}

stream *
open_gzrstream(const char *filename)
{
	stream *s;

	if ((s = open_gzstream(filename, "rb")) == NULL)
		return NULL;
	s->type = ST_BIN;
	if (s->errnr == NO__ERROR)
		gzread((gzFile *) s->stream_data.p, (void *) &s->byteorder, sizeof(s->byteorder));
	return s;
}

static stream *
open_gzwstream_(const char *filename, const char *mode)
{
	stream *s;

	if ((s = open_gzstream(filename, mode)) == NULL)
		return NULL;
	s->access = ST_WRITE;
	s->type = ST_BIN;
	if (s->errnr == NO__ERROR)
		gzwrite((gzFile *) s->stream_data.p, (void *) &s->byteorder, sizeof(s->byteorder));
	return s;
}

stream *
open_gzwstream(const char *filename)
{
	return open_gzwstream_(filename, "wb");
}

stream *
open_gzrastream(const char *filename)
{
	stream *s;

	if ((s = open_gzstream(filename, "rb")) == NULL)
		return NULL;
	s->type = ST_ASCII;
	return s;
}

static stream *
open_gzwastream_(const char *filename, const char *mode)
{
	stream *s;

	if ((s = open_gzstream(filename, mode)) == NULL)
		return NULL;
	s->access = ST_WRITE;
	s->type = ST_ASCII;
	return s;
}

stream *
open_gzwastream(const char *filename)
{
	return open_gzwastream_(filename, "wb");
}
#endif

#ifdef HAVE_LIBBZ2
static ssize_t
stream_bzread(stream *s, void *buf, size_t elmsize, size_t cnt)
{
	int size = (int) (elmsize * cnt);

	size = BZ2_bzread((BZFILE *) s->stream_data.p, buf, size);
	if (size)
		return size / elmsize;
	return 0;
}

static ssize_t
stream_bzwrite(stream *s, const void *buf, size_t elmsize, size_t cnt)
{
	int size = (int) (elmsize * cnt);

	if (size) {
		size = BZ2_bzwrite((BZFILE *) s->stream_data.p, (void *) buf, size);
		return size / elmsize;
	}
	return cnt;
}

static void
stream_bzclose(stream *s)
{
	if (s->stream_data.p)
		BZ2_bzclose((BZFILE *) s->stream_data.p);
	s->stream_data.p = NULL;
}

static int
stream_bzflush(stream *s)
{
	if (s->access == ST_WRITE)
		BZ2_bzflush((BZFILE *) s->stream_data.p);
	return 0;
}

static stream *
open_bzstream(const char *filename, const char *flags)
{
	stream *s;
	BZFILE *fp;

	if ((s = create_stream(filename)) == NULL)
		return NULL;
	if ((fp = BZ2_bzopen(filename, flags)) == NULL)
		s->errnr = OPEN_ERROR;
	s->read = stream_bzread;
	s->write = stream_bzwrite;
	s->close = stream_bzclose;
	s->flush = stream_bzflush;
	s->stream_data.p = (void *) fp;
	return s;
}

stream *
open_bzrstream(const char *filename)
{
	stream *s;

	if ((s = open_bzstream(filename, "rb")) == NULL)
		return NULL;
	s->type = ST_BIN;
	if (s->errnr == NO__ERROR)
		BZ2_bzread((BZFILE *) s->stream_data.p, (void *) &s->byteorder, sizeof(s->byteorder));
	return s;
}

static stream *
open_bzwstream_(const char *filename, const char *mode)
{
	stream *s;

	if ((s = open_bzstream(filename, mode)) == NULL)
		return NULL;
	s->access = ST_WRITE;
	s->type = ST_BIN;
	if (s->errnr == NO__ERROR)
		BZ2_bzwrite((BZFILE *) s->stream_data.p, (void *) &s->byteorder, sizeof(s->byteorder));
	return s;
}

stream *
open_bzwstream(const char *filename)
{
	return open_bzwstream_(filename, "wb");
}

stream *
open_bzrastream(const char *filename)
{
	stream *s;

	if ((s = open_bzstream(filename, "rb")) == NULL)
		return NULL;
	s->type = ST_ASCII;
	return s;
}

static stream *
open_bzwastream_(const char *filename, const char *mode)
{
	stream *s;

	if ((s = open_bzstream(filename, mode)) == NULL)
		return NULL;
	s->access = ST_WRITE;
	s->type = ST_ASCII;
	return s;
}

stream *
open_bzwastream(const char *filename)
{
	return open_bzwastream_(filename, "wb");
}
#endif

stream *
open_rstream(const char *filename)
{
	stream *s;
	const char *ext;

#ifdef STREAM_DEBUG
	printf("open_rstream %s\n", filename);
#endif
	ext = get_extention(filename);

	if (strcmp(ext, "gz") == 0) {
#ifdef HAVE_LIBZ
		return open_gzrstream(filename);
#else
		if ((s = create_stream(filename)) != NULL)
			s->errnr = OPEN_ERROR;
		return s;
#endif
	}
	if (strcmp(ext, "bz2") == 0) {
#ifdef HAVE_LIBBZ2
		return open_bzrstream(filename);
#else
		if ((s = create_stream(filename)) != NULL)
			s->errnr = OPEN_ERROR;
		return s;
#endif
	}
	if ((s = open_stream(filename, "rb")) == NULL)
		return NULL;
	s->type = ST_BIN;
	if (s->errnr == NO__ERROR) {
		fread((void *) &s->byteorder, sizeof(s->byteorder), 1, (FILE *) s->stream_data.p);
		if (ferror((FILE *) s->stream_data.p))
			s->errnr = OPEN_ERROR;
	}
	return s;
}

static stream *
open_wstream_(const char *filename, char *mode)
{
	stream *s;
	const char *ext;

#ifdef STREAM_DEBUG
	printf("open_wstream %s\n", filename);
#endif
	ext = get_extention(filename);

	if (strcmp(ext, "gz") == 0) {
#ifdef HAVE_LIBZ
		return open_gzwstream_(filename, mode);
#else
		if ((s = create_stream(filename)) != NULL)
			s->errnr = OPEN_ERROR;
		return s;
#endif
	}
	if (strcmp(ext, "bz2") == 0) {
#ifdef HAVE_LIBBZ2
		return open_bzwstream_(filename, mode);
#else
		if ((s = create_stream(filename)) != NULL)
			s->errnr = OPEN_ERROR;
		return s;
#endif
	}
	if ((s = open_stream(filename, mode)) == NULL)
		return NULL;
	s->access = ST_WRITE;
	s->type = ST_BIN;
	if (s->errnr == NO__ERROR)
		fwrite((void *) &s->byteorder, sizeof(s->byteorder), 1, (FILE *) s->stream_data.p);
	return s;
}

stream *
open_wstream(const char *filename)
{
	return open_wstream_(filename, "wb");
}

stream *
append_wstream(const char *filename)
{
	return open_wstream_(filename, "ab");
}

stream *
open_rastream(const char *filename)
{
	stream *s;
	const char *ext;

#ifdef STREAM_DEBUG
	printf("open_rastream %s\n", filename);
#endif
	ext = get_extention(filename);

	if (strcmp(ext, "gz") == 0) {
#ifdef HAVE_LIBZ
		return open_gzrastream(filename);
#else
		if ((s = create_stream(filename)) != NULL)
			s->errnr = OPEN_ERROR;
		return s;
#endif
	}
	if (strcmp(ext, "bz2") == 0) {
#ifdef HAVE_LIBBZ2
		return open_bzrastream(filename);
#else
		if ((s = create_stream(filename)) != NULL)
			s->errnr = OPEN_ERROR;
		return s;
#endif
	}
	if ((s = open_stream(filename, "r")) == NULL)
		return NULL;
	s->type = ST_ASCII;
	return s;
}

static stream *
open_wastream_(const char *filename, char *mode)
{
	stream *s;
	const char *ext;

#ifdef STREAM_DEBUG
	printf("open_wastream %s\n", filename);
#endif
	ext = get_extention(filename);