X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fcase.c;h=cec6f21e1be8ae94ccd7dcbc2284841e91ec9cab;hb=9a04fda196e392d456f034e1fc2ad744a20d22b4;hp=98de9ec6a1eab70fdd6bd1f52d7558e9ffee842a;hpb=6492b3b49661963dc6d78201a1eb3927fdf54b68;p=pspp-builds.git diff --git a/src/data/case.c b/src/data/case.c index 98de9ec6..cec6f21e 100644 --- a/src/data/case.c +++ b/src/data/case.c @@ -1,159 +1,158 @@ -/* PSPP - computes sample statistics. - Copyright (C) 2004 Free Software Foundation, Inc. - Written by Ben Pfaff . +/* PSPP - a program for statistical analysis. + Copyright (C) 2004, 2007 Free Software Foundation, Inc. - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License as - published by the Free Software Foundation; either version 2 of the - License, or (at your option) any later version. + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - This program is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA - 02110-1301, USA. */ + along with this program. If not, see . */ #include -#include "case.h" + +#include + +#include #include #include -#include "value.h" -#include + +#include +#include #include -#include "variable.h" -#ifdef DEBUGGING -#undef NDEBUG -#else -#ifndef NDEBUG -#define NDEBUG -#endif -#endif -#include +#include "minmax.h" +#include "xalloc.h" -/* Changes C not to share data with any other case. - C must be a case with a reference count greater than 1. - There should be no reason for external code to call this - function explicitly. It will be called automatically when - needed. */ -void -case_unshare (struct ccase *c) -{ - struct case_data *cd; - - assert (c->case_data->ref_cnt > 1); +/* Reference-counted case implementation. */ +struct case_data + { + size_t value_cnt; /* Number of values. */ + unsigned ref_cnt; /* Reference count. */ + union value values[1]; /* Values. */ + }; - cd = c->case_data; - cd->ref_cnt--; - case_create (c, c->case_data->value_cnt); - memcpy (c->case_data->values, cd->values, - sizeof *cd->values * cd->value_cnt); +/* Ensures that C does not share data with any other case. */ +static void +case_unshare (struct ccase *c) +{ + if (c->case_data->ref_cnt > 1) + { + struct case_data *cd = c->case_data; + cd->ref_cnt--; + case_create (c, cd->value_cnt); + memcpy (c->case_data->values, cd->values, + sizeof *cd->values * cd->value_cnt); + } } /* Returns the number of bytes needed by a case with VALUE_CNT values. */ -static inline size_t -case_size (size_t value_cnt) +static size_t +case_size (size_t value_cnt) { return (offsetof (struct case_data, values) + value_cnt * sizeof (union value)); } -#ifdef DEBUGGING /* Initializes C as a null case. */ void -case_nullify (struct ccase *c) +case_nullify (struct ccase *c) { c->case_data = NULL; } -#endif /* DEBUGGING */ -#ifdef DEBUGGING /* Returns true iff C is a null case. */ -int -case_is_null (const struct ccase *c) +bool +case_is_null (const struct ccase *c) { return c->case_data == NULL; } -#endif /* DEBUGGING */ /* Initializes C as a new case that can store VALUE_CNT values. The values have indeterminate contents until explicitly written. */ void -case_create (struct ccase *c, size_t value_cnt) +case_create (struct ccase *c, size_t value_cnt) { if (!case_try_create (c, value_cnt)) xalloc_die (); } -#ifdef DEBUGGING /* Initializes CLONE as a copy of ORIG. */ void case_clone (struct ccase *clone, const struct ccase *orig) { assert (orig->case_data->ref_cnt > 0); - if (clone != orig) + if (clone != orig) *clone = *orig; orig->case_data->ref_cnt++; +#ifdef DEBUGGING + case_unshare (clone); +#endif } -#endif /* DEBUGGING */ -#ifdef DEBUGGING /* Replaces DST by SRC and nullifies SRC. DST and SRC must be initialized cases at entry. */ void -case_move (struct ccase *dst, struct ccase *src) +case_move (struct ccase *dst, struct ccase *src) { assert (src->case_data->ref_cnt > 0); - - if (dst != src) + + if (dst != src) { *dst = *src; - case_nullify (src); + case_nullify (src); } } -#endif /* DEBUGGING */ -#ifdef DEBUGGING /* Destroys case C. */ void -case_destroy (struct ccase *c) +case_destroy (struct ccase *c) { struct case_data *cd; - - assert (c != NULL); cd = c->case_data; - if (cd != NULL && --cd->ref_cnt == 0) + if (cd != NULL && --cd->ref_cnt == 0) { memset (cd->values, 0xcc, sizeof *cd->values * cd->value_cnt); cd->value_cnt = 0xdeadbeef; - free (cd); + free (cd); } } -#endif /* DEBUGGING */ -/* Resizes case C from OLD_CNT to NEW_CNT values. */ +/* Returns the number of union values in C. */ +size_t +case_get_value_cnt (const struct ccase *c) +{ + return c->case_data->value_cnt; +} + +/* Resizes case C to NEW_CNT union values. */ void -case_resize (struct ccase *c, size_t old_cnt, size_t new_cnt) +case_resize (struct ccase *c, size_t new_cnt) { - struct ccase new; + size_t old_cnt = case_get_value_cnt (c); + if (old_cnt != new_cnt) + { + struct ccase new; - case_create (&new, new_cnt); - case_copy (&new, 0, c, 0, old_cnt < new_cnt ? old_cnt : new_cnt); - case_swap (&new, c); - case_destroy (&new); + case_create (&new, new_cnt); + case_copy (&new, 0, c, 0, MIN (old_cnt, new_cnt)); + case_swap (&new, c); + case_destroy (&new); + } } /* Swaps cases A and B. */ void -case_swap (struct ccase *a, struct ccase *b) +case_swap (struct ccase *a, struct ccase *b) { struct case_data *t = a->case_data; a->case_data = b->case_data; @@ -161,33 +160,32 @@ case_swap (struct ccase *a, struct ccase *b) } /* Attempts to create C as a new case that holds VALUE_CNT - values. Returns nonzero if successful, zero if memory + values. Returns true if successful, false if memory allocation failed. */ -int -case_try_create (struct ccase *c, size_t value_cnt) +bool +case_try_create (struct ccase *c, size_t value_cnt) { c->case_data = malloc (case_size (value_cnt)); - if (c->case_data != NULL) + if (c->case_data != NULL) { c->case_data->value_cnt = value_cnt; c->case_data->ref_cnt = 1; - return 1; + return true; } - else - return 0; + + return false; } /* Tries to initialize CLONE as a copy of ORIG. - Returns nonzero if successful, zero if memory allocation + Returns true if successful, false if memory allocation failed. */ -int -case_try_clone (struct ccase *clone, const struct ccase *orig) +bool +case_try_clone (struct ccase *clone, const struct ccase *orig) { case_clone (clone, orig); - return 1; + return true; } -#ifdef DEBUGGING /* Copies VALUE_CNT values from SRC (starting at SRC_IDX) to DST (starting at DST_IDX). */ void @@ -201,126 +199,138 @@ case_copy (struct ccase *dst, size_t dst_idx, assert (src->case_data->ref_cnt > 0); assert (src_idx + value_cnt <= src->case_data->value_cnt); - if (dst->case_data != src->case_data || dst_idx != src_idx) + if (dst->case_data != src->case_data || dst_idx != src_idx) { - if (dst->case_data->ref_cnt > 1) - case_unshare (dst); + case_unshare (dst); memmove (dst->case_data->values + dst_idx, src->case_data->values + src_idx, - sizeof *dst->case_data->values * value_cnt); + sizeof *dst->case_data->values * value_cnt); } } -#endif /* DEBUGGING */ -#ifdef DEBUGGING -/* Copies case C to OUTPUT. - OUTPUT_SIZE is the number of `union values' in OUTPUT, - which must match the number of `union values' in C. */ +/* Copies VALUE_CNT values out of case C to VALUES, starting at + the given START_IDX. */ void -case_to_values (const struct ccase *c, union value *output, - size_t output_size UNUSED) +case_copy_out (const struct ccase *c, + size_t start_idx, union value *values, size_t value_cnt) { assert (c->case_data->ref_cnt > 0); - assert (output_size == c->case_data->value_cnt); - assert (output != NULL || output_size == 0); + assert (value_cnt <= c->case_data->value_cnt); + assert (start_idx + value_cnt <= c->case_data->value_cnt); - memcpy (output, c->case_data->values, - c->case_data->value_cnt * sizeof *output); + memcpy (values, c->case_data->values + start_idx, + value_cnt * sizeof *values); } -#endif /* DEBUGGING */ -#ifdef DEBUGGING -/* Copies INPUT into case C. - INPUT_SIZE is the number of `union values' in INPUT, - which must match the number of `union values' in C. */ +/* Copies VALUE_CNT values from VALUES into case C, staring at + the given START_IDX. */ void -case_from_values (struct ccase *c, const union value *input, - size_t input_size UNUSED) +case_copy_in (struct ccase *c, + size_t start_idx, const union value *values, size_t value_cnt) { - assert (c != NULL); - assert (c->case_data != NULL); assert (c->case_data->ref_cnt > 0); - assert (input_size == c->case_data->value_cnt); - assert (input != NULL || input_size == 0); + assert (value_cnt <= c->case_data->value_cnt); + assert (start_idx + value_cnt <= c->case_data->value_cnt); - if (c->case_data->ref_cnt > 1) - case_unshare (c); - memcpy (c->case_data->values, input, - c->case_data->value_cnt * sizeof *input); + case_unshare (c); + memcpy (c->case_data->values + start_idx, values, + value_cnt * sizeof *values); +} + +/* Returns a pointer to the `union value' used for the + element of C for variable V. + Case C must be drawn from V's dictionary. + The caller must not modify the returned data. */ +const union value * +case_data (const struct ccase *c, const struct variable *v) +{ + return case_data_idx (c, var_get_case_index (v)); +} + +/* Returns the numeric value of the `union value' in C for + variable V. + Case C must be drawn from V's dictionary. */ +double +case_num (const struct ccase *c, const struct variable *v) +{ + return case_num_idx (c, var_get_case_index (v)); +} + +/* Returns the string value of the `union value' in C for + variable V. + Case C must be drawn from V's dictionary. + (Note that the value is not null-terminated.) + The caller must not modify the return value. */ +const char * +case_str (const struct ccase *c, const struct variable *v) +{ + return case_str_idx (c, var_get_case_index (v)); +} + +/* Returns a pointer to the `union value' used for the + element of C for variable V. + Case C must be drawn from V's dictionary. + The caller is allowed to modify the returned data. */ +union value * +case_data_rw (struct ccase *c, const struct variable *v) +{ + return case_data_rw_idx (c, var_get_case_index (v)); } -#endif /* DEBUGGING */ -#ifdef DEBUGGING /* Returns a pointer to the `union value' used for the element of C numbered IDX. The caller must not modify the returned data. */ const union value * -case_data (const struct ccase *c, size_t idx) +case_data_idx (const struct ccase *c, size_t idx) { - assert (c != NULL); - assert (c->case_data != NULL); assert (c->case_data->ref_cnt > 0); assert (idx < c->case_data->value_cnt); return &c->case_data->values[idx]; } -#endif /* DEBUGGING */ -#ifdef DEBUGGING /* Returns the numeric value of the `union value' in C numbered IDX. */ double -case_num (const struct ccase *c, size_t idx) +case_num_idx (const struct ccase *c, size_t idx) { - assert (c != NULL); - assert (c->case_data != NULL); assert (c->case_data->ref_cnt > 0); assert (idx < c->case_data->value_cnt); return c->case_data->values[idx].f; } -#endif /* DEBUGGING */ -#ifdef DEBUGGING /* Returns the string value of the `union value' in C numbered IDX. (Note that the value is not null-terminated.) The caller must not modify the return value. */ const char * -case_str (const struct ccase *c, size_t idx) +case_str_idx (const struct ccase *c, size_t idx) { - assert (c != NULL); - assert (c->case_data != NULL); assert (c->case_data->ref_cnt > 0); assert (idx < c->case_data->value_cnt); return c->case_data->values[idx].s; } -#endif /* DEBUGGING */ -#ifdef DEBUGGING /* Returns a pointer to the `union value' used for the element of C numbered IDX. The caller is allowed to modify the returned data. */ union value * -case_data_rw (struct ccase *c, size_t idx) +case_data_rw_idx (struct ccase *c, size_t idx) { - assert (c != NULL); - assert (c->case_data != NULL); assert (c->case_data->ref_cnt > 0); assert (idx < c->case_data->value_cnt); - if (c->case_data->ref_cnt > 1) - case_unshare (c); + case_unshare (c); return &c->case_data->values[idx]; } -#endif /* DEBUGGING */ /* Compares the values of the VAR_CNT variables in VP in cases A and B and returns a strcmp()-type result. */ int case_compare (const struct ccase *a, const struct ccase *b, - struct variable *const *vp, size_t var_cnt) + const struct variable *const *vp, size_t var_cnt) { return case_compare_2dict (a, b, vp, vp, var_cnt); } @@ -330,30 +340,30 @@ case_compare (const struct ccase *a, const struct ccase *b, and returns a strcmp()-type result. */ int case_compare_2dict (const struct ccase *ca, const struct ccase *cb, - struct variable *const *vap, struct variable *const *vbp, - size_t var_cnt) + const struct variable *const *vap, + const struct variable *const *vbp, + size_t var_cnt) { - for (; var_cnt-- > 0; vap++, vbp++) + for (; var_cnt-- > 0; vap++, vbp++) { const struct variable *va = *vap; const struct variable *vb = *vbp; - assert (va->type == vb->type); - assert (va->width == vb->width); - - if (va->width == 0) + assert (var_get_width (va) == var_get_width (vb)); + + if (var_get_width (va) == 0) { - double af = case_num (ca, va->fv); - double bf = case_num (cb, vb->fv); + double af = case_num (ca, va); + double bf = case_num (cb, vb); - if (af != bf) + if (af != bf) return af > bf ? 1 : -1; } - else + else { - const char *as = case_str (ca, va->fv); - const char *bs = case_str (cb, vb->fv); - int cmp = memcmp (as, bs, va->width); + const char *as = case_str (ca, va); + const char *bs = case_str (cb, vb); + int cmp = memcmp (as, bs, var_get_width (va)); if (cmp != 0) return cmp; @@ -368,10 +378,8 @@ case_compare_2dict (const struct ccase *ca, const struct ccase *cb, NOTE: This function breaks the case abstraction. It should *not* be used often. Prefer the other case functions. */ const union value * -case_data_all (const struct ccase *c) +case_data_all (const struct ccase *c) { - assert (c != NULL); - assert (c->case_data != NULL); assert (c->case_data->ref_cnt > 0); return c->case_data->values; @@ -383,13 +391,10 @@ case_data_all (const struct ccase *c) NOTE: This function breaks the case abstraction. It should *not* be used often. Prefer the other case functions. */ union value * -case_data_all_rw (struct ccase *c) +case_data_all_rw (struct ccase *c) { - assert (c != NULL); - assert (c->case_data != NULL); assert (c->case_data->ref_cnt > 0); - if (c->case_data->ref_cnt > 1) - case_unshare (c); + case_unshare (c); return c->case_data->values; }