src/language/data-io/file-handle.q

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2006, 2010, 2011 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 <limits.h>
  20 #include <errno.h>
  21 #include <stdlib.h>
  22
  23 #include "data/file-name.h"
  24 #include "data/session.h"
  25 #include "language/command.h"
  26 #include "language/data-io/file-handle.h"
  27 #include "language/lexer/lexer.h"
  28 #include "libpspp/assertion.h"
  29 #include "libpspp/message.h"
  30 #include "libpspp/str.h"
  31 #include "data/variable.h"
  32 #include "data/file-handle-def.h"
  33
  34 #include "gl/xalloc.h"
  35
  36 #include "gettext.h"
  37 #define _(msgid) gettext (msgid)
  38
  39 /* (headers) */
  40
  41
  42 /* (specification)
  43    "FILE HANDLE" (fh_):
  44      name=string;
  45      lrecl=integer;
  46      tabwidth=integer "x>=0" "%s must be nonnegative";
  47      mode=mode:!character/binary/image/360;
  48      recform=recform:fixed/f/variable/v/spanned/vs.
  49 */
  50 /* (declarations) */
  51 /* (functions) */
  52
  53 int
  54 cmd_file_handle (struct lexer *lexer, struct dataset *ds)
  55 {
  56   struct fh_properties properties;
  57   struct cmd_file_handle cmd;
  58   struct file_handle *handle;
  59   enum cmd_result result;
  60   char *handle_name;
  61
  62   result = CMD_CASCADING_FAILURE;
  63   if (!lex_force_id (lexer))
  64     goto exit;
  65
  66   handle_name = xstrdup (lex_tokcstr (lexer));
  67   handle = fh_from_id (handle_name);
  68   if (handle != NULL)
  69     {
  70       msg (SE, _("File handle %s is already defined.  "
  71                  "Use CLOSE FILE HANDLE before redefining a file handle."),
  72            handle_name);
  73       goto exit_free_handle_name;
  74     }
  75
  76   lex_get (lexer);
  77   if (!lex_force_match (lexer, T_SLASH))
  78     goto exit_free_handle_name;
  79
  80   if (!parse_file_handle (lexer, ds, &cmd, NULL))
  81     goto exit_free_handle_name;
  82
  83   if (lex_end_of_command (lexer) != CMD_SUCCESS)
  84     goto exit_free_cmd;
  85
  86   properties = *fh_default_properties ();
  87   if (cmd.s_name == NULL)
  88     {
  89       lex_sbc_missing (lexer, "NAME");
  90       goto exit_free_cmd;
  91     }
  92
  93   switch (cmd.mode)
  94     {
  95     case FH_CHARACTER:
  96       properties.mode = FH_MODE_TEXT;
  97       if (cmd.sbc_tabwidth)
  98         properties.tab_width = cmd.n_tabwidth[0];
  99       break;
 100     case FH_IMAGE:
 101       properties.mode = FH_MODE_FIXED;
 102       break;
 103     case FH_BINARY:
 104       properties.mode = FH_MODE_VARIABLE;
 105       break;
 106     case FH_360:
 107       properties.encoding = "EBCDIC-US";
 108       if (cmd.recform == FH_FIXED || cmd.recform == FH_F)
 109         properties.mode = FH_MODE_FIXED;
 110       else if (cmd.recform == FH_VARIABLE || cmd.recform == FH_V)
 111         {
 112           properties.mode = FH_MODE_360_VARIABLE;
 113           properties.record_width = 8192;
 114         }
 115       else if (cmd.recform == FH_SPANNED || cmd.recform == FH_VS)
 116         {
 117           properties.mode = FH_MODE_360_SPANNED;
 118           properties.record_width = 8192;
 119         }
 120       else
 121         {
 122           msg (SE, _("RECFORM must be specified with MODE=360."));
 123           goto exit_free_cmd;
 124         }
 125       break;
 126     default:
 127       NOT_REACHED ();
 128     }
 129
 130   if (properties.mode == FH_MODE_FIXED || cmd.n_lrecl[0] != LONG_MIN)
 131     {
 132       if (cmd.n_lrecl[0] == LONG_MIN)
 133         msg (SE, _("The specified file mode requires LRECL.  "
 134                    "Assuming %zu-character records."),
 135              properties.record_width);
 136       else if (cmd.n_lrecl[0] < 1 || cmd.n_lrecl[0] >= (1UL << 31))
 137         msg (SE, _("Record length (%ld) must be between 1 and %lu bytes.  "
 138                    "Assuming %zu-character records."),
 139              cmd.n_lrecl[0], (1UL << 31) - 1, properties.record_width);
 140       else
 141         properties.record_width = cmd.n_lrecl[0];
 142     }
 143
 144   fh_create_file (handle_name, cmd.s_name, &properties);
 145
 146   result = CMD_SUCCESS;
 147
 148 exit_free_cmd:
 149   free_file_handle (&cmd);
 150 exit_free_handle_name:
 151   free (handle_name);
 152 exit:
 153   return result;
 154 }
 155
 156 int
 157 cmd_close_file_handle (struct lexer *lexer, struct dataset *ds UNUSED)
 158 {
 159   struct file_handle *handle;
 160
 161   if (!lex_force_id (lexer))
 162     return CMD_CASCADING_FAILURE;
 163   handle = fh_from_id (lex_tokcstr (lexer));
 164   if (handle == NULL)
 165     return CMD_CASCADING_FAILURE;
 166
 167   fh_unname (handle);
 168   return CMD_SUCCESS;
 169 }
 170
 171 /* Returns the name for REFERENT. */
 172 static const char *
 173 referent_name (enum fh_referent referent)
 174 {
 175   switch (referent)
 176     {
 177     case FH_REF_FILE:
 178       return _("file");
 179     case FH_REF_INLINE:
 180       return _("inline file");
 181     case FH_REF_DATASET:
 182       return _("dataset");
 183     default:
 184       NOT_REACHED ();
 185     }
 186 }
 187
 188 /* Parses a file handle name:
 189
 190       - If SESSION is nonnull, then the parsed syntax may be the name of a
 191         dataset within SESSION.  Dataset names take precedence over file handle
 192         names.
 193
 194       - If REFERENT_MASK includes FH_REF_FILE, the parsed syntax may be a file
 195         name as a string or a file handle name as an identifier.
 196
 197       - If REFERENT_MASK includes FH_REF_INLINE, the parsed syntax may be the
 198         identifier INLINE to represent inline data.
 199
 200    Returns the file handle when successful, a null pointer on failure.
 201
 202    The caller is responsible for fh_unref()'ing the returned file handle when
 203    it is no longer needed. */
 204 struct file_handle *
 205 fh_parse (struct lexer *lexer, enum fh_referent referent_mask,
 206           struct session *session)
 207 {
 208   struct file_handle *handle;
 209
 210   if (session != NULL && lex_token (lexer) == T_ID)
 211     {
 212       struct dataset *ds;
 213
 214       ds = session_lookup_dataset (session, lex_tokcstr (lexer));
 215       if (ds != NULL)
 216         {
 217           lex_get (lexer);
 218           return fh_create_dataset (ds);
 219         }
 220     }
 221
 222   if (lex_match_id (lexer, "INLINE"))
 223     handle = fh_inline_file ();
 224   else
 225     {
 226       if (lex_token (lexer) != T_ID && !lex_is_string (lexer))
 227         {
 228           lex_error (lexer, _("expecting a file name or handle name"));
 229           return NULL;
 230         }
 231
 232       handle = NULL;
 233       if (lex_token (lexer) == T_ID)
 234         handle = fh_from_id (lex_tokcstr (lexer));
 235       if (handle == NULL)
 236             handle = fh_create_file (NULL, lex_tokcstr (lexer),
 237                                      fh_default_properties ());
 238       lex_get (lexer);
 239     }
 240
 241   if (!(fh_get_referent (handle) & referent_mask))
 242     {
 243       msg (SE, _("Handle for %s not allowed here."),
 244            referent_name (fh_get_referent (handle)));
 245       fh_unref (handle);
 246       return NULL;
 247     }
 248
 249   return handle;
 250 }
 251
 252 /*
 253    Local variables:
 254    mode: c
 255    End:
 256 */