#include "alloc.h"
#include "case.h"
#include "error.h"
+#include "full-read.h"
+#include "full-write.h"
#include "misc.h"
#include "mkfile.h"
#include "settings.h"
#include "var.h"
+#include "gettext.h"
+#define _(msgid) gettext (msgid)
+
#define IO_BUF_SIZE (8192 / sizeof (union value))
/* A casefile represents a sequentially accessible stream of
independent position in the casefile.
Casereaders may only move forward. They cannot move
- backward to arbitrary records or seek randomly. (In the
- future, the concept of a "casemark" will be introduced
- to allow a limited form of backward seek, but this has
- not yet been implemented.)
-
- Cloning casereaders is possible, but no one has had a
- need for it yet, so it is not implemented.
+ backward to arbitrary records or seek randomly.
+ Cloning casereaders is possible, but it is not yet
+ implemented.
Use casefile_get_reader() to create a casereader for
- use in phase 2. This also transitions from phase 2 to
- phase 3. Calling casefile_mode_reader() makes the same
+ use in phase 2. This also transitions from phase 1 to
+ phase 2. Calling casefile_mode_reader() makes the same
transition, without creating a casereader.
Use casereader_read(), casereader_read_xfer(), or
also read with casereaders in this phase, but the
ability to create new casereaders is curtailed.
- In this phase, casereaders could still be cloned, and
- casemarks could still be used to seek backward (given
- that we eventually implement these functionalities).
+ In this phase, casereaders could still be cloned (once
+ we eventually implement cloning).
To transition from phase 1 or 2 to phase 3 and create a
casereader, call casefile_get_destructive_reader().
more casereaders may be created with
casefile_get_reader() or
casefile_get_destructive_reader(). (If cloning of
- casereaders or casemarks were implemented, they would
- still be possible.)
+ casereaders were implemented, it would still be
+ possible.)
The purpose of the limitations applied to casereaders
in phase 3 is to allow in-memory casefiles to fully
static int safe_open (const char *filename, int flags);
static int safe_close (int fd);
-static int full_read (int fd, void *buffer, size_t size);
-static int full_write (int fd, const void *buffer, size_t size);
/* Creates and returns a casefile to store cases of VALUE_CNT
`union value's each. */
/* Try memory first. */
if (cf->storage == MEMORY)
{
- if (case_bytes < get_max_workspace ())
+ if (case_bytes < get_workspace ())
{
size_t block_idx = cf->case_cnt / CASES_PER_BLOCK;
size_t case_idx = cf->case_cnt % CASES_PER_BLOCK;
if ((block_idx & (block_idx - 1)) == 0)
{
size_t block_cap = block_idx == 0 ? 1 : block_idx * 2;
- cf->cases = xrealloc (cf->cases,
- sizeof *cf->cases * block_cap);
+ cf->cases = xnrealloc (cf->cases,
+ block_cap, sizeof *cf->cases);
}
- cf->cases[block_idx] = xmalloc (sizeof **cf->cases
- * CASES_PER_BLOCK);
+ cf->cases[block_idx] = xnmalloc (CASES_PER_BLOCK,
+ sizeof **cf->cases);
}
case_move (&cf->cases[block_idx][case_idx], &new_case);
cf->storage = DISK;
if (!make_temp_file (&cf->fd, &cf->filename))
err_failure ();
- cf->buffer = xmalloc (cf->buffer_size * sizeof *cf->buffer);
+ cf->buffer = xnmalloc (cf->buffer_size, sizeof *cf->buffer);
memset (cf->buffer, 0, cf->buffer_size * sizeof *cf->buffer);
case_bytes -= cf->case_cnt * cf->case_acct_size;
}
else
{
- reader->buffer = xmalloc (cf->buffer_size * sizeof *cf->buffer);
+ reader->buffer = xnmalloc (cf->buffer_size, sizeof *cf->buffer);
memset (reader->buffer, 0, cf->buffer_size * sizeof *cf->buffer);
}
return retval;
}
-/* Calls read(), passing FD, BUFFER, and SIZE, repeating as
- necessary to deal with interrupted calls. */
-static int
-full_read (int fd, void *buffer_, size_t size)
-{
- char *buffer = buffer_;
- size_t bytes_read = 0;
-
- while (bytes_read < size)
- {
- int retval = read (fd, buffer + bytes_read, size - bytes_read);
- if (retval > 0)
- bytes_read += retval;
- else if (retval == 0)
- return bytes_read;
- else if (errno != EINTR)
- return -1;
- }
-
- return bytes_read;
-}
-
-/* Calls write(), passing FD, BUFFER, and SIZE, repeating as
- necessary to deal with interrupted calls. */
-static int
-full_write (int fd, const void *buffer_, size_t size)
-{
- const char *buffer = buffer_;
- size_t bytes_written = 0;
-
- while (bytes_written < size)
- {
- int retval = write (fd, buffer + bytes_written, size - bytes_written);
- if (retval >= 0)
- bytes_written += retval;
- else if (errno != EINTR)
- return -1;
- }
-
- return bytes_written;
-}
-
-
/* Registers our exit handler with atexit() if it has not already
been registered. */
static void