{
struct taint *taint; /* Corrupted? */
struct caseproto *proto; /* Format of contained cases. */
- casenumber case_cnt; /* Number of cases,
+ casenumber n_cases; /* Number of cases,
CASENUMBER_MAX if unknown. */
const struct casereader_class *class; /* Class. */
void *aux; /* Auxiliary data for class. */
struct ccase *
casereader_read (struct casereader *reader)
{
- if (reader->case_cnt != 0)
+ if (reader->n_cases != 0)
{
/* ->read may use casereader_swap to replace itself by
another reader and then delegate to that reader by
ever will.
To allow this to work, however, we must decrement
- case_cnt before calling ->read. If we decremented
- case_cnt after calling ->read, then this would actually
- drop two cases from case_cnt instead of one, and we'd
+ n_cases before calling ->read. If we decremented
+ n_cases after calling ->read, then this would actually
+ drop two cases from n_cases instead of one, and we'd
lose the last case in the casereader. */
struct ccase *c;
- if (reader->case_cnt != CASENUMBER_MAX)
- reader->case_cnt--;
+ if (reader->n_cases != CASENUMBER_MAX)
+ reader->n_cases--;
c = reader->class->read (reader, reader->aux);
if (c != NULL)
{
size_t n_widths UNUSED = caseproto_get_n_widths (reader->proto);
- assert (case_get_value_cnt (c) >= n_widths);
+ assert (case_get_n_values (c) >= n_widths);
expensive_assert (caseproto_equal (case_get_proto (c), 0,
reader->proto, 0, n_widths));
return c;
}
}
- reader->case_cnt = 0;
+ reader->n_cases = 0;
return NULL;
}
bool ok = true;
if (reader != NULL)
{
- // reader->class->destroy (reader, reader->aux);
- // ok = taint_destroy (reader->taint);
- // caseproto_unref (reader->proto);
- // free (reader);
+ reader->class->destroy (reader, reader->aux);
+ ok = taint_destroy (reader->taint);
+ caseproto_unref (reader->proto);
+ free (reader);
}
return ok;
}
{
struct casereader *reader = CONST_CAST (struct casereader *, reader_);
struct casereader *clone;
- if ( reader == NULL )
+ if (reader == NULL)
return NULL;
if (reader->class->clone == NULL)
struct ccase *
casereader_peek (struct casereader *reader, casenumber idx)
{
- if (idx < reader->case_cnt)
+ if (idx < reader->n_cases)
{
struct ccase *c;
if (reader->class->peek == NULL)
if (c != NULL)
return c;
else if (casereader_error (reader))
- reader->case_cnt = 0;
+ reader->n_cases = 0;
}
- if (reader->case_cnt > idx)
- reader->case_cnt = idx;
+ if (reader->n_cases > idx)
+ reader->n_cases = idx;
return NULL;
}
bool
casereader_is_empty (struct casereader *reader)
{
- if (reader->case_cnt == 0)
+ if (reader->n_cases == 0)
return true;
else
{
actual number of cases in such a casereader, use
casereader_count_cases. */
casenumber
-casereader_get_case_cnt (struct casereader *reader)
+casereader_get_n_cases (struct casereader *reader)
{
- return reader->case_cnt;
+ return reader->n_cases;
}
static casenumber
casereader_count_cases__ (const struct casereader *reader,
casenumber max_cases)
{
- struct casereader *clone = casereader_clone (reader);
- casenumber n_cases = casereader_advance (clone, max_cases);
-#if (__GNUC__ == 4 ) && (__GNUC_MINOR__ == 4)
- // volatile int x = 1;
-#endif
- // casereader_destroy (clone);
+ struct casereader *clone;
+ casenumber n_cases;
+
+ clone = casereader_clone (reader);
+ n_cases = casereader_advance (clone, max_cases);
+ casereader_destroy (clone);
+
return n_cases;
}
casenumber
casereader_count_cases (const struct casereader *reader)
{
- if (reader->case_cnt == CASENUMBER_MAX)
+ if (reader->n_cases == CASENUMBER_MAX)
{
struct casereader *reader_rw = CONST_CAST (struct casereader *, reader);
- reader_rw->case_cnt = casereader_count_cases__ (reader, CASENUMBER_MAX);
+ reader_rw->n_cases = casereader_count_cases__ (reader, CASENUMBER_MAX);
}
- return reader->case_cnt;
+ return reader->n_cases;
}
/* Truncates READER to at most N cases. */
"max_cases" member to struct casereader. We could also add a "truncate"
function to the casereader implementation, to allow the casereader to
throw away data that cannot ever be read. */
- if (reader->case_cnt == CASENUMBER_MAX)
- reader->case_cnt = casereader_count_cases__ (reader, n);
- if (reader->case_cnt > n)
- reader->case_cnt = n;
+ if (reader->n_cases == CASENUMBER_MAX)
+ reader->n_cases = casereader_count_cases__ (reader, n);
+ if (reader->n_cases > n)
+ reader->n_cases = n;
}
/* Returns the prototype for the cases in READER. The caller
struct casereader *
casereader_create_sequential (const struct taint *taint,
const struct caseproto *proto,
- casenumber case_cnt,
+ casenumber n_cases,
const struct casereader_class *class, void *aux)
{
struct casereader *reader = xmalloc (sizeof *reader);
reader->taint = taint != NULL ? taint_clone (taint) : taint_create ();
reader->proto = caseproto_ref (proto);
- reader->case_cnt = case_cnt;
+ reader->n_cases = n_cases;
reader->class = class;
reader->aux = aux;
return reader;
member functions and auxiliary data to pass to those member
functions, respectively. */
struct casereader *
-casereader_create_random (const struct caseproto *proto, casenumber case_cnt,
+casereader_create_random (const struct caseproto *proto, casenumber n_cases,
const struct casereader_random_class *class,
void *aux)
{
shared->class = class;
shared->aux = aux;
shared->min_offset = 0;
- return casereader_create_sequential (NULL, proto, case_cnt,
+ return casereader_create_sequential (NULL, proto, n_cases,
&random_reader_casereader_class,
make_random_reader (shared, 0));
}
struct random_reader_shared *shared = br->shared;
return casereader_create_sequential (casereader_get_taint (reader),
reader->proto,
- casereader_get_case_cnt (reader),
+ casereader_get_n_cases (reader),
&random_reader_casereader_class,
make_random_reader (shared,
br->offset));