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/tab.h"
  40 #include "output/table-item.h"
  41
  42 #include "gl/intprops.h"
  43 #include "gl/minmax.h"
  44 #include "gl/xalloc.h"
  45 #include "gl/xmalloca.h"
  46
  47 #include "gettext.h"
  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 *ccase;
  88       struct table *t = NULL;
  89
  90       ccase = casereader_peek (group, 0);
  91       if (ccase != NULL)
  92         {
  93           output_split_file_values (ds, ccase);
  94           case_unref (ccase);
  95         }
  96
  97       group = casereader_project (group, &sc);
  98       if (lcmd->numbering == format_numbered)
  99         group = casereader_create_arithmetic_sequence (group, 1, 1);
 100       group = casereader_select (group, lcmd->first - 1,
 101                                  (lcmd->last != LONG_MAX ? lcmd->last
 102                                   : CASENUMBER_MAX), lcmd->step);
 103
 104       if (lcmd->numbering == format_numbered)
 105         {
 106           struct fmt_spec fmt;
 107           size_t col;
 108           int width;
 109
 110           width = lcmd->last == LONG_MAX ? 5 : intlog10 (lcmd->last);
 111           fmt = fmt_for_output (FMT_F, width, 0);
 112           col = caseproto_get_n_widths (casereader_get_proto (group)) - 1;
 113
 114           t = table_from_casereader (group, col, _("Case Number"), &fmt);
 115         }
 116       else
 117         t = NULL;
 118
 119       for (i = 0; i < lcmd->n_variables; i++)
 120         {
 121           const struct variable *var = lcmd->v_variables[i];
 122           struct table *c;
 123
 124           c = table_from_casereader (group, i, var_get_name (var),
 125                                      var_get_print_format (var));
 126           t = table_hpaste (t, c);
 127         }
 128
 129       casereader_destroy (group);
 130
 131       if (t)
 132         table_item_submit (table_item_create (t, "Data List", NULL));
 133     }
 134   ok = casegrouper_destroy (grouper);
 135   ok = proc_commit (ds) && ok;
 136
 137   subcase_destroy (&sc);
 138   free (lcmd->v_variables);
 139
 140   return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
 141 }
 142
 143
 144 /* Parses and executes the LIST procedure. */
 145 int
 146 cmd_list (struct lexer *lexer, struct dataset *ds)
 147 {
 148   struct lst_cmd cmd;
 149   const struct dictionary *dict = dataset_dict (ds);
 150
 151   /* Fill in defaults. */
 152   cmd.step = 1;
 153   cmd.first = 1;
 154   cmd.last = LONG_MAX;
 155   cmd.n_variables = 0;
 156   cmd.v_variables = NULL;
 157   cmd.numbering = format_unnumbered;
 158
 159
 160   while (lex_token (lexer) != T_ENDCMD)
 161     {
 162       lex_match (lexer, T_SLASH);
 163       if (lex_match_id (lexer, "VARIABLES") )
 164         {
 165           lex_match (lexer, T_EQUALS);
 166           if (! parse_variables_const (lexer, dict, &cmd.v_variables, &cmd.n_variables, 0 ))
 167             {
 168               msg (SE, _("No variables specified."));
 169               return CMD_FAILURE;
 170             }
 171         }
 172       else if (lex_match_id (lexer, "FORMAT") )
 173         {
 174           lex_match (lexer, T_EQUALS);
 175           if (lex_match_id (lexer, "NUMBERED") )
 176             {
 177               cmd.numbering = format_numbered;
 178             }
 179           else if (lex_match_id (lexer, "UNNUMBERED") )
 180             {
 181               cmd.numbering = format_unnumbered;
 182             }
 183           else
 184             {
 185               lex_error (lexer, NULL);
 186               goto error;
 187             }
 188         }
 189       /* example: LIST /CASES=FROM 1 TO 25 BY 5. */
 190       else if (lex_match_id (lexer, "CASES"))
 191         {
 192           lex_match (lexer, T_EQUALS);
 193           if (lex_match_id (lexer, "FROM") && lex_force_int (lexer))
 194             {
 195               cmd.first = lex_integer (lexer);
 196               lex_get (lexer);
 197             }
 198
 199           if ((lex_match (lexer, T_TO) && lex_force_int (lexer))
 200               || lex_is_integer (lexer))
 201             {
 202               cmd.last = lex_integer (lexer);
 203               lex_get (lexer);
 204             }
 205
 206           if (lex_match (lexer, T_BY) && lex_force_int (lexer))
 207             {
 208               cmd.step = lex_integer (lexer);
 209               lex_get (lexer);
 210             }
 211         }
 212       else if (! parse_variables_const (lexer, dict, &cmd.v_variables, &cmd.n_variables, 0 ))
 213         {
 214           return CMD_FAILURE;
 215         }
 216     }
 217
 218
 219   /* Verify arguments. */
 220   if (cmd.first > cmd.last)
 221     {
 222       int t;
 223       msg (SW, _("The first case (%ld) specified precedes the last case (%ld) "
 224                  "specified.  The values will be swapped."), cmd.first, cmd.last);
 225       t = cmd.first;
 226       cmd.first = cmd.last;
 227       cmd.last = t;
 228     }
 229
 230   if (cmd.first < 1)
 231     {
 232       msg (SW, _("The first case (%ld) to list is numbered less than 1.  "
 233                  "The value is being reset to 1."), cmd.first);
 234       cmd.first = 1;
 235     }
 236
 237   if (cmd.last < 1)
 238     {
 239       msg (SW, _("The last case (%ld) to list is numbered less than 1.  "
 240                  "The value is being reset to 1."), cmd.last);
 241       cmd.last = 1;
 242     }
 243
 244   if (cmd.step < 1)
 245     {
 246       msg (SW, _("The step value %ld is less than 1.  The value is being "
 247                  "reset to 1."), cmd.step);
 248       cmd.step = 1;
 249     }
 250
 251   /* If no variables were explicitly provided, then default to ALL */
 252   if (cmd.n_variables == 0)
 253     dict_get_vars (dict, &cmd.v_variables, &cmd.n_variables,
 254                    DC_SYSTEM | DC_SCRATCH);
 255
 256   return list_execute (&cmd, ds);
 257
 258  error:
 259   free (cmd.v_variables);
 260   return CMD_FAILURE;
 261 }
 262