#include <stdlib.h>
#include <string.h>
#include <unistd.h>
-#include "alloc.h"
+#include <libpspp/alloc.h>
#include "case.h"
-#include "compiler.h"
-#include "message.h"
+#include <libpspp/compiler.h>
+#include <libpspp/message.h>
#include "full-read.h"
#include "full-write.h"
-#include "misc.h"
+#include <libpspp/misc.h>
#include "make-file.h"
#include "settings.h"
#include "variable.h"
casefile_destroy(). This function will also destroy any
remaining casereaders. */
+/* FIXME: should we implement compression? */
+
/* In-memory cases are arranged in an array of arrays. The top
level is variable size and the size of each bottom level array
is fixed at the number of cases defined here. */
enum { MEMORY, DISK } storage; /* Where cases are stored. */
enum { WRITE, READ } mode; /* Is writing or reading allowed? */
struct casereader *readers; /* List of our readers. */
- int being_destroyed; /* Does a destructive reader exist? */
+ bool being_destroyed; /* Does a destructive reader exist? */
bool ok; /* False after I/O error. */
/* Memory storage. */
/* Disk storage. */
int fd; /* File descriptor, -1 if none. */
- char *filename; /* Filename. */
+ char *file_name; /* File name. */
union value *buffer; /* I/O buffer, NULL if none. */
size_t buffer_used; /* Number of values used in buffer. */
size_t buffer_size; /* Buffer size in values. */
struct casereader *next, *prev; /* Next, prev in casefile's list. */
struct casefile *cf; /* Our casefile. */
unsigned long case_idx; /* Case number of current case. */
- int destructive; /* Is this a destructive reader? */
+ bool destructive; /* Is this a destructive reader? */
/* Disk storage. */
int fd; /* File descriptor. */
static void io_error (struct casefile *, const char *, ...)
PRINTF_FORMAT (2, 3);
-static int safe_open (const char *filename, int flags);
+static int safe_open (const char *file_name, int flags);
static int safe_close (int fd);
/* Creates and returns a casefile to store cases of VALUE_CNT
cf->ok = true;
cf->cases = NULL;
cf->fd = -1;
- cf->filename = NULL;
+ cf->file_name = NULL;
cf->buffer = NULL;
cf->buffer_size = ROUND_UP (cf->value_cnt, IO_BUF_SIZE);
if (cf->value_cnt > 0 && cf->buffer_size % cf->value_cnt > 64)
if (cf->fd != -1)
safe_close (cf->fd);
- if (cf->filename != NULL && remove (cf->filename) == -1)
+ if (cf->file_name != NULL && remove (cf->file_name) == -1)
io_error (cf, _("%s: Removing temporary file: %s."),
- cf->filename, strerror (errno));
- free (cf->filename);
+ cf->file_name, strerror (errno));
+ free (cf->file_name);
free (cf->buffer);
return !cf->ok;
}
-/* Returns nonzero only if casefile CF is stored in memory (instead of on
- disk). */
-int
+/* Returns true only if casefile CF is stored in memory (instead of on
+ disk), false otherwise. */
+bool
casefile_in_core (const struct casefile *cf)
{
assert (cf != NULL);
{
size_t idx, block_cnt;
- assert (cf->filename == NULL);
+ assert (cf->file_name == NULL);
assert (cf->fd == -1);
assert (cf->buffer_used == 0);
- if (!make_temp_file (&cf->fd, &cf->filename))
+ if (!make_temp_file (&cf->fd, &cf->file_name))
{
cf->ok = false;
return false;
}
else
{
- reader->fd = safe_open (cf->filename, O_RDONLY);
+ reader->fd = safe_open (cf->file_name, O_RDONLY);
if (reader->fd < 0)
io_error (cf, _("%s: Opening temporary file: %s."),
- cf->filename, strerror (errno));
+ cf->file_name, strerror (errno));
}
if (cf->buffer != NULL)
file_ofs = 0;
if (lseek (reader->fd, file_ofs, SEEK_SET) != file_ofs)
io_error (cf, _("%s: Seeking temporary file: %s."),
- cf->filename, strerror (errno));
+ cf->file_name, strerror (errno));
if (cf->case_cnt > 0 && cf->value_cnt > 0)
fill_buffer (reader);
reader->cf->buffer_size * sizeof *reader->buffer);
if (bytes < 0)
io_error (reader->cf, _("%s: Reading temporary file: %s."),
- reader->cf->filename, strerror (errno));
+ reader->cf->file_name, strerror (errno));
else if (bytes != reader->cf->buffer_size * sizeof *reader->buffer)
io_error (reader->cf, _("%s: Temporary file ended unexpectedly."),
- reader->cf->filename);
+ reader->cf->file_name);
}
return reader->cf->ok;
}
/* Reads a copy of the next case from READER into C.
Caller is responsible for destroying C.
Returns true if successful, false at end of file. */
-int
+bool
casereader_read (struct casereader *reader, struct ccase *c)
{
assert (reader != NULL);
if (!reader->cf->ok || reader->case_idx >= reader->cf->case_cnt)
- return 0;
+ return false;
if (reader->cf->storage == MEMORY)
{
case_clone (c, &reader->cf->cases[block_idx][case_idx]);
reader->case_idx++;
- return 1;
+ return true;
}
else
{
if (reader->buffer_pos + reader->cf->value_cnt > reader->cf->buffer_size)
{
if (!fill_buffer (reader))
- return 0;
+ return false;
reader->buffer_pos = 0;
}
reader->case_idx++;
case_clone (c, &reader->c);
- return 1;
+ return true;
}
}
to the caller. Caller is responsible for destroying C.
Returns true if successful, false at end of file or on I/O
error. */
-int
+bool
casereader_read_xfer (struct casereader *reader, struct ccase *c)
{
assert (reader != NULL);
case_move (c, read_case);
reader->case_idx++;
- return 1;
+ return true;
}
}
{
if (cf->ok)
{
- struct error e;
+ struct msg m;
va_list args;
- e.class = ME;
- e.where.filename = NULL;
- e.where.line_number = -1;
- e.title = NULL;
-
+ m.category = MSG_GENERAL;
+ m.severity = MSG_ERROR;
+ m.where.file_name = NULL;
+ m.where.line_number = -1;
va_start (args, format);
- err_vmsg (&e, format, args);
+ m.text = xvasprintf (format, args);
va_end (args);
+
+ msg_emit (&m);
}
cf->ok = false;
}
-/* Calls open(), passing FILENAME and FLAGS, repeating as necessary
+/* Calls open(), passing FILE_NAME and FLAGS, repeating as necessary
to deal with interrupted calls. */
static int
-safe_open (const char *filename, int flags)
+safe_open (const char *file_name, int flags)
{
int fd;
do
{
- fd = open (filename, flags);
+ fd = open (file_name, flags);
}
while (fd == -1 && errno == EINTR);
static void
register_atexit (void)
{
- static int registered = 0;
+ static bool registered = false;
if (!registered)
{
- registered = 1;
+ registered = true;
atexit (exit_handler);
}
}
-
-
/* atexit() handler that closes and deletes our temporary
files. */
static void
projects / pspp-builds.git / blobdiff