pintos-os.org Git - pspp/blob - src/language/data-io/list.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2006, 2009-2011, 2013, 2014, 2016 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #include <config.h>
  18
  19 #include <stdint.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22
  23 #include "data/casegrouper.h"
  24 #include "data/casereader.h"
  25 #include "data/dataset.h"
  26 #include "data/dictionary.h"
  27 #include "data/data-out.h"
  28 #include "data/format.h"
  29 #include "data/subcase.h"
  30 #include "data/variable.h"
  31 #include "language/command.h"
  32 #include "language/dictionary/split-file.h"
  33 #include "language/lexer/lexer.h"
  34 #include "language/lexer/variable-parser.h"
  35 #include "libpspp/compiler.h"
  36 #include "libpspp/ll.h"
  37 #include "libpspp/message.h"
  38 #include "libpspp/misc.h"
  39 #include "output/pivot-table.h"
  40
  41 #include "gl/intprops.h"
  42 #include "gl/minmax.h"
  43 #include "gl/xalloc.h"
  44 #include "gl/xmalloca.h"
  45
  46 #include "gettext.h"
  47 #define N_(msgid) msgid
  48 #define _(msgid) gettext (msgid)
  49
  50 enum numbering
  51   {
  52     format_unnumbered,
  53     format_numbered
  54   };
  55
  56
  57 struct lst_cmd
  58 {
  59   long first;
  60   long last;
  61   long step;
  62   const struct variable **v_variables;
  63   size_t n_variables;
  64   enum numbering numbering;
  65 };
  66
  67
  68 static int
  69 list_execute (const struct lst_cmd *lcmd, struct dataset *ds)
  70 {
  71   const struct dictionary *dict = dataset_dict (ds);
  72
  73   bool ok;
  74   int i;
  75   struct casegrouper *grouper;
  76   struct casereader *group;
  77   struct subcase sc;
  78
  79   subcase_init_empty (&sc);
  80   for (i = 0; i < lcmd->n_variables; i++)
  81     subcase_add_var (&sc, lcmd->v_variables[i], SC_ASCEND);
  82
  83
  84   grouper = casegrouper_create_splits (proc_open (ds), dict);
  85   while (casegrouper_get_next_group (grouper, &group))
  86     {
  87       struct ccase *c = casereader_peek (group, 0);
  88       if (c != NULL)
  89         {
  90           output_split_file_values (ds, c);
  91           case_unref (c);
  92         }
  93
  94       group = casereader_project (group, &sc);
  95       group = casereader_select (group, lcmd->first - 1,
  96                                  (lcmd->last != LONG_MAX ? lcmd->last
  97                                   : CASENUMBER_MAX), lcmd->step);
  98
  99       struct pivot_table *table = pivot_table_create (N_("Data List"));
 100       table->show_values = table->show_variables = SETTINGS_VALUE_SHOW_VALUE;
 101
 102       struct pivot_dimension *variables = pivot_dimension_create (
 103         table, PIVOT_AXIS_COLUMN, N_("Variables"));
 104       for (int i = 0; i < lcmd->n_variables; i++)
 105         pivot_category_create_leaf (
 106           variables->root, pivot_value_new_variable (lcmd->v_variables[i]));
 107
 108       struct pivot_dimension *cases = pivot_dimension_create (
 109         table, PIVOT_AXIS_ROW, N_("Case Number"));
 110       if (lcmd->numbering == format_numbered)
 111         cases->root->show_label = true;
 112       else
 113         cases->hide_all_labels = true;
 114
 115       casenumber case_num = lcmd->first;
 116       for (; (c = casereader_read (group)) != NULL; case_unref (c))
 117         {
 118           int case_idx = pivot_category_create_leaf (
 119             cases->root, pivot_value_new_integer (case_num));
 120           case_num += lcmd->step;
 121
 122           for (int i = 0; i < lcmd->n_variables; i++)
 123             pivot_table_put2 (table, i, case_idx,
 124                               pivot_value_new_var_value (
 125                                 lcmd->v_variables[i], case_data_idx (c, i)));
 126         }
 127       casereader_destroy (group);
 128
 129       pivot_table_submit (table);
 130     }
 131   ok = casegrouper_destroy (grouper);
 132   ok = proc_commit (ds) && ok;
 133
 134   subcase_uninit (&sc);
 135   free (lcmd->v_variables);
 136
 137   return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
 138 }
 139
 140
 141 /* Parses and executes the LIST procedure. */
 142 int
 143 cmd_list (struct lexer *lexer, struct dataset *ds)
 144 {
 145   struct lst_cmd cmd;
 146   const struct dictionary *dict = dataset_dict (ds);
 147
 148   /* Fill in defaults. */
 149   cmd.step = 1;
 150   cmd.first = 1;
 151   cmd.last = LONG_MAX;
 152   cmd.n_variables = 0;
 153   cmd.v_variables = NULL;
 154   cmd.numbering = format_unnumbered;
 155
 156
 157   while (lex_token (lexer) != T_ENDCMD)
 158     {
 159       lex_match (lexer, T_SLASH);
 160       if (lex_match_id (lexer, "VARIABLES"))
 161         {
 162           lex_match (lexer, T_EQUALS);
 163           if (! parse_variables_const (lexer, dict, &cmd.v_variables, &cmd.n_variables, 0))
 164             {
 165               msg (SE, _("No variables specified."));
 166               return CMD_FAILURE;
 167             }
 168         }
 169       else if (lex_match_id (lexer, "FORMAT"))
 170         {
 171           lex_match (lexer, T_EQUALS);
 172           if (lex_match_id (lexer, "NUMBERED"))
 173             {
 174               cmd.numbering = format_numbered;
 175             }
 176           else if (lex_match_id (lexer, "UNNUMBERED"))
 177             {
 178               cmd.numbering = format_unnumbered;
 179             }
 180           else
 181             {
 182               lex_error (lexer, NULL);
 183               goto error;
 184             }
 185         }
 186       /* example: LIST /CASES=FROM 1 TO 25 BY 5. */
 187       else if (lex_match_id (lexer, "CASES"))
 188         {
 189           lex_match (lexer, T_EQUALS);
 190           if (lex_match_id (lexer, "FROM") && lex_force_int (lexer))
 191             {
 192               cmd.first = lex_integer (lexer);
 193               lex_get (lexer);
 194             }
 195
 196           if ((lex_match (lexer, T_TO) && lex_force_int (lexer))
 197               || lex_is_integer (lexer))
 198             {
 199               cmd.last = lex_integer (lexer);
 200               lex_get (lexer);
 201             }
 202
 203           if (lex_match (lexer, T_BY) && lex_force_int (lexer))
 204             {
 205               cmd.step = lex_integer (lexer);
 206               lex_get (lexer);
 207             }
 208         }
 209       else if (! parse_variables_const (lexer, dict, &cmd.v_variables, &cmd.n_variables, 0))
 210         {
 211           return CMD_FAILURE;
 212         }
 213     }
 214
 215
 216   /* Verify arguments. */
 217   if (cmd.first > cmd.last)
 218     {
 219       int t;
 220       msg (SW, _("The first case (%ld) specified precedes the last case (%ld) "
 221                  "specified.  The values will be swapped."), cmd.first, cmd.last);
 222       t = cmd.first;
 223       cmd.first = cmd.last;
 224       cmd.last = t;
 225     }
 226
 227   if (cmd.first < 1)
 228     {
 229       msg (SW, _("The first case (%ld) to list is numbered less than 1.  "
 230                  "The value is being reset to 1."), cmd.first);
 231       cmd.first = 1;
 232     }
 233
 234   if (cmd.last < 1)
 235     {
 236       msg (SW, _("The last case (%ld) to list is numbered less than 1.  "
 237                  "The value is being reset to 1."), cmd.last);
 238       cmd.last = 1;
 239     }
 240
 241   if (cmd.step < 1)
 242     {
 243       msg (SW, _("The step value %ld is less than 1.  The value is being "
 244                  "reset to 1."), cmd.step);
 245       cmd.step = 1;
 246     }
 247
 248   /* If no variables were explicitly provided, then default to ALL */
 249   if (cmd.n_variables == 0)
 250     dict_get_vars (dict, &cmd.v_variables, &cmd.n_variables,
 251                    DC_SYSTEM | DC_SCRATCH);
 252
 253   return list_execute (&cmd, ds);
 254
 255  error:
 256   free (cmd.v_variables);
 257   return CMD_FAILURE;
 258 }
 259