src/language/data-io/trim.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2006, 2007, 2008 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, PV_APPEND | PV_NO_SCRATCH))
 118         goto done;
 119       if (nn != nv)
 120         {
 121           msg (SE, _("Number of variables on left side of `=' (%zu) does not "
 122                      "match number of variables on right side (%zu), in "
 123                      "parenthesized group %d of RENAME subcommand."),
 124                nv - old_nv, nn - old_nv, group);
 125           goto done;
 126         }
 127       if (!lex_force_match (lexer, ')'))
 128         goto done;
 129       group++;
 130     }
 131
 132   if (!dict_rename_vars (dict, v, new_names, nv, &err_name))
 133     {
 134       msg (SE, _("Requested renaming duplicates variable name %s."), err_name);
 135       goto done;
 136     }
 137   success = 1;
 138
 139  done:
 140   for (i = 0; i < nn; i++)
 141     free (new_names[i]);
 142   free (new_names);
 143   free (v);
 144
 145   return success;
 146 }
 147
 148 /* Parses and performs the DROP subcommand of GET, SAVE, and
 149    related commands.
 150    Returns true if successful, false on failure.*/
 151 bool
 152 parse_dict_drop (struct lexer *lexer, struct dictionary *dict)
 153 {
 154   struct variable **v;
 155   size_t nv;
 156
 157   lex_match (lexer, '=');
 158   if (!parse_variables (lexer, dict, &v, &nv, PV_NONE))
 159     return false;
 160   dict_delete_vars (dict, v, nv);
 161   free (v);
 162
 163   if (dict_get_var_cnt (dict) == 0)
 164     {
 165       msg (SE, _("Cannot DROP all variables from dictionary."));
 166       return false;
 167     }
 168   return true;
 169 }
 170
 171 /* Parses and performs the KEEP subcommand of GET, SAVE, and
 172    related commands.
 173    Returns true if successful, false on failure.*/
 174 bool
 175 parse_dict_keep (struct lexer *lexer, struct dictionary *dict)
 176 {
 177   struct variable **v;
 178   size_t nv;
 179   size_t i;
 180
 181   lex_match (lexer, '=');
 182   if (!parse_variables (lexer, dict, &v, &nv, PV_NONE))
 183     return false;
 184
 185   /* Move the specified variables to the beginning. */
 186   dict_reorder_vars (dict, v, nv);
 187
 188   /* Delete the remaining variables. */
 189   v = xnrealloc (v, dict_get_var_cnt (dict) - nv, sizeof *v);
 190   for (i = nv; i < dict_get_var_cnt (dict); i++)
 191     v[i - nv] = dict_get_var (dict, i);
 192   dict_delete_vars (dict, v, dict_get_var_cnt (dict) - nv);
 193   free (v);
 194
 195   return true;
 196 }