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

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2006, 2007, 2008, 2010 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 <language/data-io/trim.h>
  20
  21 #include <stdlib.h>
  22
  23 #include <data/dictionary.h>
  24 #include <data/variable.h>
  25 #include <language/lexer/lexer.h>
  26 #include <language/lexer/variable-parser.h>
  27 #include <libpspp/message.h>
  28
  29 #include "xalloc.h"
  30
  31 #include "gettext.h"
  32 #define _(msgid) gettext (msgid)
  33
  34 /* Commands that read and write system files share a great deal
  35    of common syntactic structure for rearranging and dropping
  36    variables.  This function parses this syntax and modifies DICT
  37    appropriately.  Returns true on success, false on failure. */
  38 bool
  39 parse_dict_trim (struct lexer *lexer, struct dictionary *dict)
  40 {
  41   if (lex_match_id (lexer, "MAP"))
  42     {
  43       /* FIXME. */
  44       return true;
  45     }
  46   else if (lex_match_id (lexer, "DROP"))
  47     return parse_dict_drop (lexer, dict);
  48   else if (lex_match_id (lexer, "KEEP"))
  49     return parse_dict_keep (lexer, dict);
  50   else if (lex_match_id (lexer, "RENAME"))
  51     return parse_dict_rename (lexer, dict);
  52   else
  53     {
  54       lex_error (lexer, _("expecting a valid subcommand"));
  55       return false;
  56     }
  57 }
  58
  59 /* Parses and performs the RENAME subcommand of GET, SAVE, and
  60    related commands. */
  61 bool
  62 parse_dict_rename (struct lexer *lexer, struct dictionary *dict)
  63 {
  64   size_t i;
  65
  66   int success = 0;
  67
  68   struct variable **v;
  69   char **new_names;
  70   size_t nv, nn;
  71   char *err_name;
  72
  73   int group;
  74
  75   lex_match (lexer, '=');
  76   if (lex_token (lexer) != '(')
  77     {
  78       struct variable *v;
  79
  80       v = parse_variable (lexer, dict);
  81       if (v == NULL)
  82         return 0;
  83       if (!lex_force_match (lexer, '=')
  84           || !lex_force_id (lexer))
  85         return 0;
  86       if (dict_lookup_var (dict, lex_tokid (lexer)) != NULL)
  87         {
  88           msg (SE, _("Cannot rename %s as %s because there already exists "
  89                      "a variable named %s.  To rename variables with "
  90                      "overlapping names, use a single RENAME subcommand "
  91                      "such as `/RENAME (A=B)(B=C)(C=A)', or equivalently, "
  92                      "`/RENAME (A B C=B C A)'."),
  93                var_get_name (v), lex_tokid (lexer), lex_tokid (lexer));
  94           return 0;
  95         }
  96
  97       dict_rename_var (dict, v, lex_tokid (lexer));
  98       lex_get (lexer);
  99       return 1;
 100     }
 101
 102   nv = nn = 0;
 103   v = NULL;
 104   new_names = 0;
 105   group = 1;
 106   while (lex_match (lexer, '('))
 107     {
 108       size_t old_nv = nv;
 109
 110       if (!parse_variables (lexer, dict, &v, &nv, PV_NO_DUPLICATE | PV_APPEND))
 111         goto done;
 112       if (!lex_match (lexer, '='))
 113         {
 114           msg (SE, _("`=' expected after variable list."));
 115           goto done;
 116         }
 117       if (!parse_DATA_LIST_vars (lexer, &new_names, &nn,
 118                                  PV_APPEND | PV_NO_SCRATCH | PV_NO_DUPLICATE))
 119         goto done;
 120       if (nn != nv)
 121         {
 122           msg (SE, _("Number of variables on left side of `=' (%zu) does not "
 123                      "match number of variables on right side (%zu), in "
 124                      "parenthesized group %d of RENAME subcommand."),
 125                nv - old_nv, nn - old_nv, group);
 126           goto done;
 127         }
 128       if (!lex_force_match (lexer, ')'))
 129         goto done;
 130       group++;
 131     }
 132
 133   if (!dict_rename_vars (dict, v, new_names, nv, &err_name))
 134     {
 135       msg (SE, _("Requested renaming duplicates variable name %s."), err_name);
 136       goto done;
 137     }
 138   success = 1;
 139
 140  done:
 141   for (i = 0; i < nn; i++)
 142     free (new_names[i]);
 143   free (new_names);
 144   free (v);
 145
 146   return success;
 147 }
 148
 149 /* Parses and performs the DROP subcommand of GET, SAVE, and
 150    related commands.
 151    Returns true if successful, false on failure.*/
 152 bool
 153 parse_dict_drop (struct lexer *lexer, struct dictionary *dict)
 154 {
 155   struct variable **v;
 156   size_t nv;
 157
 158   lex_match (lexer, '=');
 159   if (!parse_variables (lexer, dict, &v, &nv, PV_NONE))
 160     return false;
 161   dict_delete_vars (dict, v, nv);
 162   free (v);
 163
 164   if (dict_get_var_cnt (dict) == 0)
 165     {
 166       msg (SE, _("Cannot DROP all variables from dictionary."));
 167       return false;
 168     }
 169   return true;
 170 }
 171
 172 /* Parses and performs the KEEP subcommand of GET, SAVE, and
 173    related commands.
 174    Returns true if successful, false on failure.*/
 175 bool
 176 parse_dict_keep (struct lexer *lexer, struct dictionary *dict)
 177 {
 178   struct variable **v;
 179   size_t nv;
 180   size_t i;
 181
 182   lex_match (lexer, '=');
 183   if (!parse_variables (lexer, dict, &v, &nv, PV_NONE))
 184     return false;
 185
 186   /* Move the specified variables to the beginning. */
 187   dict_reorder_vars (dict, v, nv);
 188
 189   /* Delete the remaining variables. */
 190   v = xnrealloc (v, dict_get_var_cnt (dict) - nv, sizeof *v);
 191   for (i = nv; i < dict_get_var_cnt (dict); i++)
 192     v[i - nv] = dict_get_var (dict, i);
 193   dict_delete_vars (dict, v, dict_get_var_cnt (dict) - nv);
 194   free (v);
 195
 196   return true;
 197 }