treewide: Replace <name>_cnt by n_<name>s and <name>_cap by allocated_<name>.

[pspp] / src / data / casereader-translator.c

diff --git a/src/data/casereader-translator.c b/src/data/casereader-translator.c
index f0411d1fa1430a75903e8e4e3f4317cb6b5ad3fa..7dc344e3b8baf84a6000ddec4a27a4ab75aa2668 100644 (file)
--- a/src/data/casereader-translator.c
+++ b/src/data/casereader-translator.c
@@ -75,7 +75,7 @@ casereader_create_translator (struct casereader *subreader,
   ct->destroy = destroy;
   ct->aux = aux;
   reader = casereader_create_sequential (
   ct->destroy = destroy;
   ct->aux = aux;
   reader = casereader_create_sequential (

-    NULL, output_proto, casereader_get_case_cnt (ct->subreader),
+    NULL, output_proto, casereader_get_n_cases (ct->subreader),

     &casereader_translator_class, ct);
   taint_propagate (casereader_get_taint (ct->subreader),
                    casereader_get_taint (reader));
     &casereader_translator_class, ct);
   taint_propagate (casereader_get_taint (ct->subreader),
                    casereader_get_taint (reader));


@@ -170,7 +170,7 @@ casereader_translate_stateless (
   cst->destroy = destroy;
   cst->aux = aux;
   reader = casereader_create_random (
   cst->destroy = destroy;
   cst->aux = aux;
   reader = casereader_create_random (

-    output_proto, casereader_get_case_cnt (cst->subreader),
+    output_proto, casereader_get_n_cases (cst->subreader),

     &casereader_stateless_translator_class, cst);
   taint_propagate (casereader_get_taint (cst->subreader),
                    casereader_get_taint (reader));
     &casereader_stateless_translator_class, cst);
   taint_propagate (casereader_get_taint (cst->subreader),
                    casereader_get_taint (reader));


@@ -264,7 +264,7 @@ can_translate (struct ccase *c, void *can_)
   struct casereader_append_numeric *can = can_;
   double new_value = can->func (c, can->n++, can->aux);
   c = case_unshare_and_resize (c, can->proto);
   struct casereader_append_numeric *can = can_;
   double new_value = can->func (c, can->n++, can->aux);
   c = case_unshare_and_resize (c, can->proto);

-  case_data_rw_idx (c, caseproto_get_n_widths (can->proto) - 1)->f = new_value;
+  *case_num_rw_idx (c, caseproto_get_n_widths (can->proto) - 1) = new_value;

   return c;
 }
 
   return c;
 }
 


@@ -309,7 +309,7 @@ struct casereader *
 casereader_create_arithmetic_sequence (struct casereader *subreader,
                                        double first, double increment)
 {
 casereader_create_arithmetic_sequence (struct casereader *subreader,
                                        double first, double increment)
 {

-  struct arithmetic_sequence *as = xzalloc (sizeof *as);
+  struct arithmetic_sequence *as = XZALLOC (struct arithmetic_sequence);

   as->first = first;
   as->increment = increment;
   return casereader_create_append_numeric (subreader, next_arithmetic,
   as->first = first;
   as->increment = increment;
   return casereader_create_append_numeric (subreader, next_arithmetic,


@@ -357,7 +357,7 @@ static struct ccase *car_translate (struct ccase *input, void *car_);
 
    If DISTINCT_CALLBACK is non-null, then  it will be called exactly
    once for every case containing a distinct value of V.  AUX is
 
    If DISTINCT_CALLBACK is non-null, then  it will be called exactly
    once for every case containing a distinct value of V.  AUX is

-   an auxilliary pointer passed to DISTINCT_CALLBACK.
+   an auxiliary pointer passed to DISTINCT_CALLBACK.

 
    After this function is called, SUBREADER must not ever again
    be referenced directly.  It will be destroyed automatically
 
    After this function is called, SUBREADER must not ever again
    be referenced directly.  It will be destroyed automatically


@@ -369,7 +369,7 @@ casereader_create_append_rank (struct casereader *subreader,
                               enum rank_error *err,
                               distinct_func *distinct_callback,
                               void *aux
                               enum rank_error *err,
                               distinct_func *distinct_callback,
                               void *aux

-                              )
+                       )

 {
   struct casereader_append_rank *car = xmalloc (sizeof *car);
   car->proto = caseproto_ref (casereader_get_proto (subreader));
 {
   struct casereader_append_rank *car = xmalloc (sizeof *car);
   car->proto = caseproto_ref (casereader_get_proto (subreader));


@@ -405,23 +405,23 @@ car_translate (struct ccase *input, void *car_)
 {
   struct casereader_append_rank *car = car_;
 
 {
   struct casereader_append_rank *car = car_;
 

-  const double value = case_data (input, car->var)->f;
+  const double value = case_num (input, car->var);

 
 

-  if ( car->prev_value != SYSMIS)
+  if (car->prev_value != SYSMIS)

     {
       if (car->err && value < car->prev_value)
        *car->err |= RANK_ERR_UNSORTED;
     }
 
     {
       if (car->err && value < car->prev_value)
        *car->err |= RANK_ERR_UNSORTED;
     }
 

-  if ( car->n_common == 1)
+  if (car->n_common == 1)

     {
       double vxx = SYSMIS;
       casenumber k = 0;
       double weight = 1.0;
       if (car->weight)
        {
     {
       double vxx = SYSMIS;
       casenumber k = 0;
       double weight = 1.0;
       if (car->weight)
        {

-         weight = case_data (input, car->weight)->f;
-         if ( car->err && weight < 0 )
+         weight = case_num (input, car->weight);
+         if (car->err && weight < 0)

            *car->err |= RANK_ERR_NEGATIVE_WEIGHT;
        }
 
            *car->err |= RANK_ERR_NEGATIVE_WEIGHT;
        }
 


@@ -430,15 +430,15 @@ car_translate (struct ccase *input, void *car_)
          struct ccase *c = casereader_peek (car->clone, car->n + ++k);
          if (c == NULL)
            break;
          struct ccase *c = casereader_peek (car->clone, car->n + ++k);
          if (c == NULL)
            break;

-         vxx = case_data (c, car->var)->f;
+         vxx = case_num (c, car->var);

 
 

-         if ( vxx == value)
+         if (vxx == value)

            {
              if (car->weight)
                {
            {
              if (car->weight)
                {

-                 double w = case_data (c, car->weight)->f;
+                 double w = case_num (c, car->weight);

 
 

-                 if ( car->err && w < 0 )
+                 if (car->err && w < 0)

                    *car->err |= RANK_ERR_NEGATIVE_WEIGHT;
 
                  weight += w;
                    *car->err |= RANK_ERR_NEGATIVE_WEIGHT;
 
                  weight += w;


@@ -462,7 +462,7 @@ car_translate (struct ccase *input, void *car_)
   car->n++;
 
   input = case_unshare_and_resize (input, car->proto);
   car->n++;
 
   input = case_unshare_and_resize (input, car->proto);

-  case_data_rw_idx (input, caseproto_get_n_widths (car->proto) - 1)->f
+  *case_num_rw_idx (input, caseproto_get_n_widths (car->proto) - 1)

     = car->mean_rank;
   car->prev_value = value;
   return input;
     = car->mean_rank;
   car->prev_value = value;
   return input;


@@ -490,20 +490,25 @@ uniquify (const struct ccase *c, void *aux)
   struct consolidator *cdr = aux;
   const union value *current_value = case_data (c, cdr->key);
   const int key_width = var_get_width (cdr->key);
   struct consolidator *cdr = aux;
   const union value *current_value = case_data (c, cdr->key);
   const int key_width = var_get_width (cdr->key);

-  const double weight = cdr->weight ? case_data (c, cdr->weight)->f : 1.0;
+  const double weight = cdr->weight ? case_num (c, cdr->weight) : 1.0;

   struct ccase *next_case = casereader_peek (cdr->clone, cdr->n + 1);
   int dir = 0;
 
   cdr->n ++;
   cdr->cc += weight;
 
   struct ccase *next_case = casereader_peek (cdr->clone, cdr->n + 1);
   int dir = 0;
 
   cdr->n ++;
   cdr->cc += weight;
 

-  if ( NULL == next_case)
+  if (NULL == next_case)

       goto end;
 
   dir = value_compare_3way (case_data (next_case, cdr->key),
                            current_value, key_width);
       goto end;
 
   dir = value_compare_3way (case_data (next_case, cdr->key),
                            current_value, key_width);

+  if (dir > 0)
+    dir = 1;
+  if (dir < 0)
+    dir = -1;
+      

   case_unref (next_case);
   case_unref (next_case);

-  if ( dir != 0 )
+  if (dir != 0)

     {
       /* Insist that the data are sorted */
       assert (cdr->direction == 0 || dir == cdr->direction);
     {
       /* Insist that the data are sorted */
       assert (cdr->direction == 0 || dir == cdr->direction);


@@ -530,12 +535,12 @@ consolodate_weight (struct ccase *input, void *aux)
   if (cdr->weight)
     {
       c = case_unshare (input);
   if (cdr->weight)
     {
       c = case_unshare (input);

-      case_data_rw (c, cdr->weight)->f = cdr->prev_cc;
+      *case_num_rw (c, cdr->weight) = cdr->prev_cc;

     }
   else
     {
       c = case_unshare_and_resize (input, cdr->proto);
     }
   else
     {
       c = case_unshare_and_resize (input, cdr->proto);

-      case_data_rw_idx (c, caseproto_get_n_widths (cdr->proto) - 1)->f = cdr->prev_cc;
+      *case_num_rw_idx (c, caseproto_get_n_widths (cdr->proto) - 1) = cdr->prev_cc;

     }
 
   return c;
     }
 
   return c;


@@ -582,7 +587,7 @@ casereader_create_distinct (struct casereader *input,
   cdr->clone = casereader_clone (input);
   cdr->direction = 0;
 
   cdr->clone = casereader_clone (input);
   cdr->direction = 0;
 

-  if ( NULL == cdr->weight )
+  if (NULL == cdr->weight)

     output_proto = caseproto_add_width (output_proto, 0);
 
   cdr->proto = output_proto;
     output_proto = caseproto_add_width (output_proto, 0);
 
   cdr->proto = output_proto;