Fixed assignment of the intercept

[pspp-builds.git] / src / crosstabs.q

diff --git a/src/crosstabs.q b/src/crosstabs.q
index 62ba0a3a4c42c304b1d779897fbbfe1267c327b7..7d9f334f9a5e7c6f39fe234ba54390dfc273a954 100644 (file)
--- a/src/crosstabs.q
+++ b/src/crosstabs.q
@@ -53,6 +53,10 @@
 #include "var.h"
 #include "vfm.h"
 
+#include "gettext.h"
+#define _(msgid) gettext (msgid)
+#define N_(msgid) msgid
+
 /* (headers) */
 
 #include "debug-print.h"
@@ -298,8 +302,8 @@ crs_custom_tables (struct cmd_crosstabs *cmd UNUSED)
   struct var_set *var_set;
   int n_by;
   struct variable ***by = NULL;
-  int *by_nvar = NULL;
-  int nx = 1;
+  size_t *by_nvar = NULL;
+  size_t nx = 1;
   int success = 0;
 
   /* Ensure that this is a TABLES subcommand. */
@@ -317,17 +321,22 @@ crs_custom_tables (struct cmd_crosstabs *cmd UNUSED)
   
   for (n_by = 0; ;)
     {
-      by = xrealloc (by, sizeof *by * (n_by + 1));
-      by_nvar = xrealloc (by_nvar, sizeof *by_nvar * (n_by + 1));
+      by = xnrealloc (by, n_by + 1, sizeof *by);
+      by_nvar = xnrealloc (by_nvar, n_by + 1, sizeof *by_nvar);
       if (!parse_var_set_vars (var_set, &by[n_by], &by_nvar[n_by],
                                PV_NO_DUPLICATE | PV_NO_SCRATCH))
        goto done;
+      if (xalloc_oversized (nx, by_nvar[n_by])) 
+        {
+          msg (SE, _("Too many crosstabulation variables or dimensions."));
+          goto done;
+        }
       nx *= by_nvar[n_by];
       n_by++;
 
       if (!lex_match (T_BY))
        {
-         if (n_by < 1)
+         if (n_by < 2)
            {
              lex_error (_("expecting BY"));
              goto done;
@@ -341,7 +350,7 @@ crs_custom_tables (struct cmd_crosstabs *cmd UNUSED)
     int *by_iter = xcalloc (n_by, sizeof *by_iter);
     int i;
 
-    xtab = xrealloc (xtab, sizeof *xtab * (nxtab + nx));
+    xtab = xnrealloc (xtab, nxtab + nx, sizeof *xtab);
     for (i = 0; i < nx; i++)
       {
        struct crosstab *x;
@@ -404,8 +413,8 @@ crs_custom_variables (struct cmd_crosstabs *cmd UNUSED)
   
   for (;;)
     {
-      int orig_nv = variables_cnt;
-      int i;
+      size_t orig_nv = variables_cnt;
+      size_t i;
 
       long min, max;
       
@@ -500,8 +509,8 @@ precalc (void *aux UNUSED)
          for (j = 2; j < x->nvar; j++) 
             count *= get_var_range (x->vars[j - 2])->count;
           
-         sorted_tab = xrealloc (sorted_tab,
-                                sizeof *sorted_tab * (n_sorted_tab + count));
+         sorted_tab = xnrealloc (sorted_tab,
+                                  n_sorted_tab + count, sizeof *sorted_tab);
          v = local_alloc (sizeof *v * x->nvar);
          for (j = 2; j < x->nvar; j++) 
             v[j] = get_var_range (x->vars[j])->min; 
@@ -520,7 +529,7 @@ precalc (void *aux UNUSED)
                const int mat_size = row_cnt * col_cnt;
                int m;
                
-               te->u.data = xmalloc (sizeof *te->u.data * mat_size);
+               te->u.data = xnmalloc (mat_size, sizeof *te->u.data);
                for (m = 0; m < mat_size; m++)
                  te->u.data[m] = 0.;
              }
@@ -539,8 +548,8 @@ precalc (void *aux UNUSED)
          local_free (v);
        }
 
-      sorted_tab = xrealloc (sorted_tab,
-                            sizeof *sorted_tab * (n_sorted_tab + 1));
+      sorted_tab = xnrealloc (sorted_tab,
+                              n_sorted_tab + 1, sizeof *sorted_tab);
       sorted_tab[n_sorted_tab] = NULL;
     }
 }
@@ -572,11 +581,11 @@ calc_general (struct ccase *c, void *aux UNUSED)
        assert (x != NULL);
        for (j = 0; j < x->nvar; j++)
          {
-           if ((cmd.miss == CRS_TABLE
-                && is_missing (case_data (c, x->vars[j]->fv), x->vars[j]))
+            const union value *v = case_data (c, x->vars[j]->fv);
+            const struct missing_values *mv = &x->vars[j]->miss;
+           if ((cmd.miss == CRS_TABLE && mv_is_value_missing (mv, v))
                || (cmd.miss == CRS_INCLUDE
-                   && is_system_missing (case_data (c, x->vars[j]->fv),
-                                          x->vars[j])))
+                   && mv_is_value_system_missing (mv, v)))
              {
                x->missing += weight;
                goto next_crosstab;
@@ -646,7 +655,8 @@ calc_integer (struct ccase *c, void *aux UNUSED)
          
          /* Note that the first test also rules out SYSMIS. */
          if ((value < vr->min || value >= vr->max)
-             || (cmd.miss == CRS_TABLE && is_num_user_missing (value, v)))
+             || (cmd.miss == CRS_TABLE
+                  && mv_is_num_user_missing (&v->miss, value)))
            {
              x->missing += weight;
              goto next_crosstab;
@@ -1187,13 +1197,13 @@ output_pivot_table (struct table_entry **pb, struct table_entry **pe,
       /* Allocate memory space for the column and row totals. */
       if (n_rows > *maxrows)
        {
-         *row_totp = xrealloc (*row_totp, sizeof **row_totp * n_rows);
+         *row_totp = xnrealloc (*row_totp, n_rows, sizeof **row_totp);
          row_tot = *row_totp;
          *maxrows = n_rows;
        }
       if (n_cols > *maxcols)
        {
-         *col_totp = xrealloc (*col_totp, sizeof **col_totp * n_cols);
+         *col_totp = xnrealloc (*col_totp, n_cols, sizeof **col_totp);
          col_tot = *col_totp;
          *maxcols = n_cols;
        }
@@ -1209,7 +1219,7 @@ output_pivot_table (struct table_entry **pb, struct table_entry **pe,
          /* Allocate memory space for the matrix. */
          if (n_cols * n_rows > *maxcells)
            {
-             *matp = xrealloc (*matp, sizeof **matp * n_cols * n_rows);
+             *matp = xnrealloc (*matp, n_cols * n_rows, sizeof **matp);
              *maxcells = n_cols * n_rows;
            }
          
@@ -1406,7 +1416,7 @@ delete_missing (void)
     int r;
 
     for (r = 0; r < n_rows; r++)
-      if (is_num_user_missing (rows[r].f, x->vars[ROW_VAR]))
+      if (mv_is_num_user_missing (&x->vars[ROW_VAR]->miss, rows[r].f))
        {
          int c;
 
@@ -1420,7 +1430,7 @@ delete_missing (void)
     int c;
 
     for (c = 0; c < n_cols; c++)
-      if (is_num_user_missing (cols[c].f, x->vars[COL_VAR]))
+      if (mv_is_num_user_missing (&x->vars[COL_VAR]->miss, cols[c].f))
        {
          int r;
 
@@ -1615,7 +1625,7 @@ enum_var_values (struct table_entry **entries, int entry_cnt, int var_idx,
       int width = v->width;
       int i;
 
-      *values = xmalloc (sizeof **values * entry_cnt);
+      *values = xnmalloc (entry_cnt, sizeof **values);
       for (i = 0; i < entry_cnt; i++)
         (*values)[i] = entries[i]->values[var_idx];
       *value_cnt = sort_unique (*values, entry_cnt, sizeof **values,
@@ -1627,7 +1637,7 @@ enum_var_values (struct table_entry **entries, int entry_cnt, int var_idx,
       int i;
       
       assert (mode == INTEGER);
-      *values = xmalloc (sizeof **values * vr->count);
+      *values = xnmalloc (vr->count, sizeof **values);
       for (i = 0; i < vr->count; i++)
        (*values)[i].f = i + vr->min;
       *value_cnt = vr->count;
@@ -1653,7 +1663,7 @@ table_value_missing (struct tab_table *table, int c, int r, unsigned char opt,
   s.string = tab_alloc (table, var->print.w);
   format_short (s.string, &var->print, v);
   s.length = strlen (s.string);
-  if (cmd.miss == CRS_REPORT && is_num_user_missing (v->f, var))
+  if (cmd.miss == CRS_REPORT && mv_is_num_user_missing (&var->miss, v->f))
     s.string[s.length++] = 'M';
   while (s.length && *s.string == ' ')
     {
@@ -1736,8 +1746,9 @@ display_crosstabulation (void)
             int mark_missing = 0;
             double expected_value = row_tot[r] * col_tot[c] / W;
             if (cmd.miss == CRS_REPORT
-                && (is_num_user_missing (cols[c].f, x->vars[COL_VAR])
-                    || is_num_user_missing (rows[r].f, x->vars[ROW_VAR])))
+                && (mv_is_num_user_missing (&x->vars[COL_VAR]->miss, cols[c].f)
+                    || mv_is_num_user_missing (&x->vars[ROW_VAR]->miss,
+                                               rows[r].f)))
               mark_missing = 1;
            for (i = 0; i < num_cells; i++)
              {
@@ -1802,7 +1813,7 @@ display_crosstabulation (void)
         int mark_missing = 0;
 
         if (cmd.miss == CRS_REPORT
-            && is_num_user_missing (rows[r].f, x->vars[ROW_VAR]))
+            && mv_is_num_user_missing (&x->vars[ROW_VAR]->miss, rows[r].f))
           mark_missing = 1;
 
         for (i = 0; i < num_cells; i++)
@@ -1858,7 +1869,7 @@ display_crosstabulation (void)
         int i;
            
         if (cmd.miss == CRS_REPORT && c < n_cols 
-            && is_num_user_missing (cols[c].f, x->vars[COL_VAR]))
+            && mv_is_num_user_missing (&x->vars[COL_VAR]->miss, cols[c].f))
           mark_missing = 1;
 
         for (i = 0; i < num_cells; i++)
@@ -2509,7 +2520,7 @@ calc_symmetric (double v[N_SYMMETRIC], double ase[N_SYMMETRIC],
       {
        int r, c;
 
-       cum = xmalloc (sizeof *cum * n_cols * n_rows);
+       cum = xnmalloc (n_cols * n_rows, sizeof *cum);
        for (c = 0; c < n_cols; c++)
          {
            double ct = 0.;
@@ -2852,10 +2863,10 @@ calc_directional (double v[N_DIRECTIONAL], double ase[N_DIRECTIONAL],
   /* Lambda. */
   if (cmd.a_statistics[CRS_ST_LAMBDA])
     {
-      double *fim = xmalloc (sizeof *fim * n_rows);
-      int *fim_index = xmalloc (sizeof *fim_index * n_rows);
-      double *fmj = xmalloc (sizeof *fmj * n_cols);
-      int *fmj_index = xmalloc (sizeof *fmj_index * n_cols);
+      double *fim = xnmalloc (n_rows, sizeof *fim);
+      int *fim_index = xnmalloc (n_rows, sizeof *fim_index);
+      double *fmj = xnmalloc (n_cols, sizeof *fmj);
+      int *fmj_index = xnmalloc (n_cols, sizeof *fmj_index);
       double sum_fim, sum_fmj;
       double rm, cm;
       int rm_index, cm_index;