Use XCALLOC / XZALLOC macros where reasonable

[pspp] / src / language / stats / reliability.c

diff --git a/src/language/stats/reliability.c b/src/language/stats/reliability.c
index e1c205f60f608c8667b51c140d1c2871dc405701..5816a2304ceba846425dab7bf1ab5af3d09ed785 100644 (file)
--- a/src/language/stats/reliability.c
+++ b/src/language/stats/reliability.c
@@ -32,7 +32,7 @@
 #include "libpspp/str.h"
 #include "math/moments.h"
 #include "output/pivot-table.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
 
 #include "gettext.h"
 #define _(msgid) gettext (msgid)
@@ -170,13 +170,13 @@ cmd_reliability (struct lexer *lexer, struct dataset *ds)
     /* Create a default Scale */
 
     reliability.n_sc = 1;
-    reliability.sc = xzalloc (sizeof (struct cronbach) * reliability.n_sc);
+    reliability.sc = xcalloc (reliability.n_sc, sizeof (struct cronbach));
 
     ds_assign_cstr (&reliability.scale_name, "ANY");
 
     c = &reliability.sc[0];
     c->n_items = reliability.n_variables;
-    c->items = xzalloc (sizeof (struct variable*) * c->n_items);
+    c->items = xcalloc (c->n_items, sizeof (struct variable*));
 
     for (i = 0 ; i < c->n_items ; ++i)
       c->items[i] = reliability.variables[i];
@@ -191,17 +191,17 @@ cmd_reliability (struct lexer *lexer, struct dataset *ds)
       if (lex_match_id (lexer, "SCALE"))
        {
          struct const_var_set *vs;
-         if ( ! lex_force_match (lexer, T_LPAREN))
+         if (! lex_force_match (lexer, T_LPAREN))
            goto error;
 
-         if ( ! lex_force_string (lexer) )
+         if (! lex_force_string (lexer))
            goto error;
 
          ds_assign_substring (&reliability.scale_name, lex_tokss (lexer));
 
          lex_get (lexer);
 
-         if ( ! lex_force_match (lexer, T_RPAREN))
+         if (! lex_force_match (lexer, T_RPAREN))
            goto error;
 
           lex_match (lexer, T_EQUALS);
@@ -229,7 +229,7 @@ cmd_reliability (struct lexer *lexer, struct dataset *ds)
              reliability.model = MODEL_SPLIT;
              reliability.split_point = -1;
 
-             if ( lex_match (lexer, T_LPAREN)
+             if (lex_match (lexer, T_LPAREN)
                   && lex_force_num (lexer))
                {
                  reliability.split_point = lex_number (lexer);
@@ -290,12 +290,12 @@ cmd_reliability (struct lexer *lexer, struct dataset *ds)
        }
     }
 
-  if ( reliability.model == MODEL_SPLIT)
+  if (reliability.model == MODEL_SPLIT)
     {
       int i;
       const struct cronbach *s;
 
-      if ( reliability.split_point >= reliability.n_variables)
+      if (reliability.split_point >= reliability.n_variables)
         {
           msg (ME, _("The split point must be less than the number of variables"));
           goto error;
@@ -310,11 +310,8 @@ cmd_reliability (struct lexer *lexer, struct dataset *ds)
        (reliability.split_point == -1) ? s->n_items / 2 : reliability.split_point;
 
       reliability.sc[2].n_items = s->n_items - reliability.sc[1].n_items;
-      reliability.sc[1].items = xzalloc (sizeof (struct variable *)
-                                * reliability.sc[1].n_items);
-
-      reliability.sc[2].items = xzalloc (sizeof (struct variable *) *
-                                reliability.sc[2].n_items);
+      reliability.sc[1].items = XCALLOC (reliability.sc[1].n_items, const struct variable *);
+      reliability.sc[2].items = XCALLOC (reliability.sc[2].n_items, const struct variable *);
 
       for  (i = 0; i < reliability.sc[1].n_items ; ++i)
        reliability.sc[1].items[i] = s->items[i];
@@ -326,7 +323,7 @@ cmd_reliability (struct lexer *lexer, struct dataset *ds)
        }
     }
 
-  if ( reliability.summary & SUMMARY_TOTAL)
+  if (reliability.summary & SUMMARY_TOTAL)
     {
       int i;
       const int base_sc = reliability.n_sc;
@@ -337,24 +334,24 @@ cmd_reliability (struct lexer *lexer, struct dataset *ds)
       reliability.sc = xrealloc (reliability.sc, sizeof (struct cronbach) * reliability.n_sc);
 
 
-      for (i = 0 ; i < reliability.sc[0].n_items; ++i )
+      for (i = 0 ; i < reliability.sc[0].n_items; ++i)
        {
          int v_src;
          int v_dest = 0;
          struct cronbach *s = &reliability.sc[i + base_sc];
 
          s->n_items = reliability.sc[0].n_items - 1;
-         s->items = xzalloc (sizeof (struct variable *) * s->n_items);
+         s->items = xcalloc (s->n_items, sizeof (struct variable *));
          for (v_src = 0 ; v_src < reliability.sc[0].n_items ; ++v_src)
            {
-             if ( v_src != i)
+             if (v_src != i)
                s->items[v_dest++] = reliability.sc[0].items[v_src];
            }
        }
     }
 
 
-  if ( ! run_reliability (ds, &reliability))
+  if (! run_reliability (ds, &reliability))
     goto error;
 
   reliability_destroy (&reliability);
@@ -391,10 +388,10 @@ run_reliability (struct dataset *ds, const struct reliability *reliability)
       struct cronbach *s = &reliability->sc[si];
       int i;
 
-      s->m = xzalloc (sizeof *s->m * s->n_items);
+      s->m = xcalloc (s->n_items, sizeof *s->m);
       s->total = moments1_create (MOMENT_VARIANCE);
 
-      for (i = 0 ; i < s->n_items ; ++i )
+      for (i = 0 ; i < s->n_items ; ++i)
        s->m[i] = moments1_create (MOMENT_VARIANCE);
     }
 
@@ -405,7 +402,7 @@ run_reliability (struct dataset *ds, const struct reliability *reliability)
 
       reliability_statistics (reliability);
 
-      if (reliability->summary & SUMMARY_TOTAL )
+      if (reliability->summary & SUMMARY_TOTAL)
        reliability_summary_total (reliability);
     }
 
@@ -426,11 +423,8 @@ append_sum (const struct ccase *c, casenumber n UNUSED, void *aux)
   double sum = 0;
   const struct cronbach *s = aux;
 
-  int v;
-  for (v = 0 ; v < s->n_items; ++v)
-    {
-      sum += case_data (c, s->items[v])->f;
-    }
+  for (int v = 0 ; v < s->n_items; ++v)
+    sum += case_num (c, s->items[v]);
 
   return sum;
 };
@@ -443,7 +437,7 @@ case_processing_summary (casenumber n_valid, casenumber n_missing,
 static double
 alpha (int k, double sum_of_variances, double variance_of_sums)
 {
-  return k / ( k - 1.0) * ( 1 - sum_of_variances / variance_of_sums);
+  return k / (k - 1.0) * (1 - sum_of_variances / variance_of_sums);
 }
 
 static void
@@ -463,7 +457,7 @@ do_reliability (struct casereader *input, struct dataset *ds,
 
       moments1_clear (s->total);
 
-      for (i = 0 ; i < s->n_items ; ++i )
+      for (i = 0 ; i < s->n_items ; ++i)
         moments1_clear (s->m[i]);
     }
 
@@ -494,10 +488,10 @@ do_reliability (struct casereader *input, struct dataset *ds,
        {
          struct cronbach *s = &rel->sc[si];
 
-         for (i = 0 ; i < s->n_items ; ++i )
-           moments1_add (s->m[i], case_data (c, s->items[i])->f, weight);
+         for (i = 0 ; i < s->n_items ; ++i)
+           moments1_add (s->m[i], case_num (c, s->items[i]), weight);
 
-         moments1_add (s->total, case_data_idx (c, s->totals_idx)->f, weight);
+         moments1_add (s->total, case_num_idx (c, s->totals_idx), weight);
        }
     }
   casereader_destroy (input);
@@ -507,7 +501,7 @@ do_reliability (struct casereader *input, struct dataset *ds,
       struct cronbach *s = &rel->sc[si];
 
       s->sum_of_variances = 0;
-      for (i = 0 ; i < s->n_items ; ++i )
+      for (i = 0 ; i < s->n_items ; ++i)
        {
          double weight, mean, variance;
          moments1_calculate (s->m[i], &weight, &mean, &variance, NULL, NULL);
@@ -522,8 +516,10 @@ do_reliability (struct casereader *input, struct dataset *ds,
        alpha (s->n_items, s->sum_of_variances, s->variance_of_sums);
     }
 
-  text_item_submit (text_item_create_format (TEXT_ITEM_TITLE, _("Scale: %s"),
-                                             ds_cstr (&rel->scale_name)));
+  output_item_submit (text_item_create_nocopy (
+                        TEXT_ITEM_TITLE,
+                        xasprintf (_("Scale: %s"), ds_cstr (&rel->scale_name)),
+                        NULL));
 
   case_processing_summary (n_valid, n_missing, dataset_dict (ds));
 }
@@ -685,7 +681,7 @@ reliability_statistics (const struct reliability *rel)
         rel->sc[1].n_items + rel->sc[2].n_items,
         r1,
         2 * r1 / (1.0 + r1),
-        (sqrt ( pow4 (r1) + 4 * pow2 (r1) * tmp) - pow2 (r1)) / (2 * tmp),
+        (sqrt (pow4 (r1) + 4 * pow2 (r1) * tmp) - pow2 (r1)) / (2 * tmp),
         g,
       };
       for (size_t i = 0; i < sizeof entries / sizeof *entries; i++)