/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 1997-2000, 2006-2007, 2009-2013 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "data/file-handle-def.h"
#include "data/file-name.h"
#include "data/format.h"
+#include "data/identifier.h"
#include "data/missing-values.h"
#include "data/mrset.h"
#include "data/short-names.h"
#include "libpspp/array.h"
#include "libpspp/assertion.h"
#include "libpspp/compiler.h"
-#include "libpspp/hash.h"
#include "libpspp/i18n.h"
#include "libpspp/message.h"
#include "libpspp/misc.h"
#include "libpspp/str.h"
#include "libpspp/stringi-set.h"
+#include "gl/c-strtod.h"
#include "gl/c-ctype.h"
#include "gl/inttostr.h"
+#include "gl/localcharset.h"
#include "gl/minmax.h"
#include "gl/unlocked-io.h"
#include "gl/xalloc.h"
#define _(msgid) gettext (msgid)
#define N_(msgid) (msgid)
+enum
+ {
+ /* subtypes 0-2 unknown */
+ EXT_INTEGER = 3, /* Machine integer info. */
+ EXT_FLOAT = 4, /* Machine floating-point info. */
+ EXT_VAR_SETS = 5, /* Variable sets. */
+ EXT_DATE = 6, /* DATE. */
+ EXT_MRSETS = 7, /* Multiple response sets. */
+ EXT_DATA_ENTRY = 8, /* SPSS Data Entry. */
+ /* subtype 9 unknown */
+ EXT_PRODUCT_INFO = 10, /* Extra product info text. */
+ EXT_DISPLAY = 11, /* Variable display parameters. */
+ /* subtype 12 unknown */
+ EXT_LONG_NAMES = 13, /* Long variable names. */
+ EXT_LONG_STRINGS = 14, /* Long strings. */
+ /* subtype 15 unknown */
+ EXT_NCASES = 16, /* Extended number of cases. */
+ EXT_FILE_ATTRS = 17, /* Data file attributes. */
+ EXT_VAR_ATTRS = 18, /* Variable attributes. */
+ EXT_MRSETS2 = 19, /* Multiple response sets (extended). */
+ EXT_ENCODING = 20, /* Character encoding. */
+ EXT_LONG_LABELS = 21, /* Value labels for long strings. */
+ EXT_LONG_MISSING = 22, /* Missing values for long strings. */
+ EXT_DATAVIEW = 24 /* "Format properties in dataview table". */
+ };
+
+/* Fields from the top-level header record. */
+struct sfm_header_record
+ {
+ char magic[5]; /* First 4 bytes of file, then null. */
+ int weight_idx; /* 0 if unweighted, otherwise a var index. */
+ int nominal_case_size; /* Number of var positions. */
+
+ /* These correspond to the members of struct sfm_file_info or a dictionary
+ but in the system file's encoding rather than ASCII. */
+ char creation_date[10]; /* "dd mmm yy". */
+ char creation_time[9]; /* "hh:mm:ss". */
+ char eye_catcher[61]; /* Eye-catcher string, then product name. */
+ char file_label[65]; /* File label. */
+ };
+
+struct sfm_var_record
+ {
+ off_t pos;
+ int width;
+ char name[8];
+ int print_format;
+ int write_format;
+ int missing_value_code;
+ uint8_t missing[24];
+ char *label;
+ struct variable *var;
+ };
+
+struct sfm_value_label
+ {
+ uint8_t value[8];
+ char *label;
+ };
+
+struct sfm_value_label_record
+ {
+ off_t pos;
+ struct sfm_value_label *labels;
+ size_t n_labels;
+
+ int *vars;
+ size_t n_vars;
+ };
+
+struct sfm_document_record
+ {
+ off_t pos;
+ char *documents;
+ size_t n_lines;
+ };
+
+struct sfm_extension_record
+ {
+ int subtype; /* Record subtype. */
+ off_t pos; /* Starting offset in file. */
+ size_t size; /* Size of data elements. */
+ size_t count; /* Number of data elements. */
+ void *data; /* Contents. */
+ };
+
/* System file reader. */
struct sfm_reader
{
struct file_handle *fh; /* File handle. */
struct fh_lock *lock; /* Mutual exclusion for file handle. */
FILE *file; /* File stream. */
+ off_t pos; /* Position in file. */
bool error; /* I/O or corruption error? */
struct caseproto *proto; /* Format of output cases. */
/* File format. */
enum integer_format integer_format; /* On-disk integer format. */
enum float_format float_format; /* On-disk floating point format. */
- int oct_cnt; /* Number of 8-byte units per case. */
struct sfm_var *sfm_vars; /* Variables. */
size_t sfm_var_cnt; /* Number of variables. */
casenumber case_cnt; /* Number of cases */
- bool has_long_var_names; /* File has a long variable name map */
+ const char *encoding; /* String encoding. */
/* Decompression. */
bool compressed; /* File is compressed? */
static bool close_reader (struct sfm_reader *);
-static struct variable **make_var_by_value_idx (struct sfm_reader *,
- struct dictionary *);
-static struct variable *lookup_var_by_value_idx (struct sfm_reader *,
- struct variable **,
- int value_idx);
-static struct variable *lookup_var_by_short_name (struct dictionary *,
- const char *short_name);
+static struct variable *lookup_var_by_index (struct sfm_reader *, off_t,
+ const struct sfm_var_record *,
+ size_t n, int idx);
-static void sys_msg (struct sfm_reader *r, int class,
+static void sys_msg (struct sfm_reader *r, off_t, int class,
const char *format, va_list args)
- PRINTF_FORMAT (3, 0);
-static void sys_warn (struct sfm_reader *, const char *, ...)
- PRINTF_FORMAT (2, 3);
-static void sys_error (struct sfm_reader *, const char *, ...)
- PRINTF_FORMAT (2, 3)
+ PRINTF_FORMAT (4, 0);
+static void sys_warn (struct sfm_reader *, off_t, const char *, ...)
+ PRINTF_FORMAT (3, 4);
+static void sys_error (struct sfm_reader *, off_t, const char *, ...)
+ PRINTF_FORMAT (3, 4)
NO_RETURN;
static void read_bytes (struct sfm_reader *, void *, size_t);
static void read_string (struct sfm_reader *, char *, size_t);
static void skip_bytes (struct sfm_reader *, size_t);
-static struct text_record *open_text_record (struct sfm_reader *, size_t size);
-static void close_text_record (struct sfm_reader *r,
+static char *fix_line_ends (const char *);
+
+static int parse_int (struct sfm_reader *, const void *data, size_t ofs);
+static double parse_float (struct sfm_reader *, const void *data, size_t ofs);
+
+static void read_variable_record (struct sfm_reader *,
+ struct sfm_var_record *);
+static void read_value_label_record (struct sfm_reader *,
+ struct sfm_value_label_record *,
+ size_t n_vars);
+static struct sfm_document_record *read_document_record (struct sfm_reader *);
+static struct sfm_extension_record *read_extension_record (
+ struct sfm_reader *, int subtype);
+static void skip_extension_record (struct sfm_reader *, int subtype);
+
+static const char *choose_encoding (
+ struct sfm_reader *,
+ const struct sfm_header_record *,
+ const struct sfm_extension_record *ext_integer,
+ const struct sfm_extension_record *ext_encoding);
+
+static struct text_record *open_text_record (
+ struct sfm_reader *, const struct sfm_extension_record *,
+ bool recode_to_utf8);
+static void close_text_record (struct sfm_reader *,
struct text_record *);
static bool read_variable_to_value_pair (struct sfm_reader *,
struct dictionary *,
static char *text_get_token (struct text_record *,
struct substring delimiters, char *delimiter);
static bool text_match (struct text_record *, char c);
+static bool text_read_variable_name (struct sfm_reader *, struct dictionary *,
+ struct text_record *,
+ struct substring delimiters,
+ struct variable **);
static bool text_read_short_name (struct sfm_reader *, struct dictionary *,
struct text_record *,
struct substring delimiters,
static const char *text_parse_counted_string (struct sfm_reader *,
struct text_record *);
static size_t text_pos (const struct text_record *);
+static const char *text_get_all (const struct text_record *);
static bool close_reader (struct sfm_reader *r);
\f
WRITE_FORMAT
};
-static void read_header (struct sfm_reader *, struct dictionary *,
- int *weight_idx, int *claimed_oct_cnt,
- struct sfm_read_info *);
-static void read_variable_record (struct sfm_reader *, struct dictionary *,
- int *format_warning_cnt);
-static void parse_format_spec (struct sfm_reader *, unsigned int,
- enum which_format, struct variable *,
- int *format_warning_cnt);
-static void setup_weight (struct sfm_reader *, int weight_idx,
- struct variable **var_by_value_idx,
+static void read_header (struct sfm_reader *, struct sfm_read_info *,
+ struct sfm_header_record *);
+static void parse_header (struct sfm_reader *,
+ const struct sfm_header_record *,
+ struct sfm_read_info *, struct dictionary *);
+static void parse_variable_records (struct sfm_reader *, struct dictionary *,
+ struct sfm_var_record *, size_t n);
+static void parse_format_spec (struct sfm_reader *, off_t pos,
+ unsigned int format, enum which_format,
+ struct variable *, int *format_warning_cnt);
+static void parse_document (struct dictionary *, struct sfm_document_record *);
+static void parse_display_parameters (struct sfm_reader *,
+ const struct sfm_extension_record *,
+ struct dictionary *);
+static void parse_machine_integer_info (struct sfm_reader *,
+ const struct sfm_extension_record *,
+ struct sfm_read_info *);
+static void parse_machine_float_info (struct sfm_reader *,
+ const struct sfm_extension_record *);
+static void parse_extra_product_info (struct sfm_reader *,
+ const struct sfm_extension_record *,
+ struct sfm_read_info *);
+static void parse_mrsets (struct sfm_reader *,
+ const struct sfm_extension_record *,
struct dictionary *);
-static void read_documents (struct sfm_reader *, struct dictionary *);
-static void read_value_labels (struct sfm_reader *, struct dictionary *,
- struct variable **var_by_value_idx);
-
-static void read_extension_record (struct sfm_reader *, struct dictionary *,
- struct sfm_read_info *);
-static void read_machine_integer_info (struct sfm_reader *,
- size_t size, size_t count,
- struct sfm_read_info *,
- struct dictionary *
- );
-static void read_machine_float_info (struct sfm_reader *,
- size_t size, size_t count);
-static void read_mrsets (struct sfm_reader *, size_t size, size_t count,
- struct dictionary *);
-static void read_display_parameters (struct sfm_reader *,
- size_t size, size_t count,
+static void parse_long_var_name_map (struct sfm_reader *,
+ const struct sfm_extension_record *,
struct dictionary *);
-static void read_long_var_name_map (struct sfm_reader *,
- size_t size, size_t count,
- struct dictionary *);
-static void read_long_string_map (struct sfm_reader *,
- size_t size, size_t count,
- struct dictionary *);
-static void read_data_file_attributes (struct sfm_reader *,
- size_t size, size_t count,
+static void parse_long_string_map (struct sfm_reader *,
+ const struct sfm_extension_record *,
+ struct dictionary *);
+static void parse_value_labels (struct sfm_reader *, struct dictionary *,
+ const struct sfm_var_record *,
+ size_t n_var_recs,
+ const struct sfm_value_label_record *);
+static void parse_data_file_attributes (struct sfm_reader *,
+ const struct sfm_extension_record *,
+ struct dictionary *);
+static void parse_variable_attributes (struct sfm_reader *,
+ const struct sfm_extension_record *,
struct dictionary *);
-static void read_variable_attributes (struct sfm_reader *,
- size_t size, size_t count,
- struct dictionary *);
-static void read_long_string_value_labels (struct sfm_reader *,
- size_t size, size_t count,
- struct dictionary *);
-
-/* Convert all the strings in DICT from the dict encoding to UTF8 */
-static void
-recode_strings (struct dictionary *dict)
+static void assign_variable_roles (struct sfm_reader *, struct dictionary *);
+static void parse_long_string_value_labels (struct sfm_reader *,
+ const struct sfm_extension_record *,
+ struct dictionary *);
+static void parse_long_string_missing_values (struct sfm_reader *,
+ const struct sfm_extension_record *,
+ struct dictionary *);
+
+/* Frees the strings inside INFO. */
+void
+sfm_read_info_destroy (struct sfm_read_info *info)
{
- int i;
-
- const char *enc = dict_get_encoding (dict);
-
- if ( NULL == enc)
- enc = get_default_encoding ();
-
- for (i = 0 ; i < dict_get_var_cnt (dict); ++i)
+ if (info)
{
- /* Convert the long variable name */
- struct variable *var = dict_get_var (dict, i);
- const char *native_name = var_get_name (var);
- char *utf8_name = recode_string (UTF8, enc, native_name, -1);
- if ( 0 != strcmp (utf8_name, native_name))
- {
- if ( NULL == dict_lookup_var (dict, utf8_name))
- dict_rename_var (dict, var, utf8_name);
- else
- msg (MW,
- _("Recoded variable name duplicates an existing `%s' within system file."), utf8_name);
+ free (info->creation_date);
+ free (info->creation_time);
+ free (info->product);
+ free (info->product_ext);
}
+}
- free (utf8_name);
+/* Opens the system file designated by file handle FH for reading. Reads the
+ system file's dictionary into *DICT.
- /* Convert the variable label */
- if (var_has_label (var))
- {
- char *utf8_label = recode_string (UTF8, enc, var_get_label (var), -1);
- var_set_label (var, utf8_label);
- free (utf8_label);
- }
+ Ordinarily the reader attempts to automatically detect the character
+ encoding based on the file's contents. This isn't always possible,
+ especially for files written by old versions of SPSS or PSPP, so specifying
+ a nonnull ENCODING overrides the choice of character encoding.
- if (var_has_value_labels (var))
- {
- const struct val_lab *vl = NULL;
- const struct val_labs *vlabs = var_get_value_labels (var);
+ If INFO is non-null, then it receives additional info about the system file,
+ which the caller must eventually free with sfm_read_info_destroy() when it
+ is no longer needed. */
+struct casereader *
+sfm_open_reader (struct file_handle *fh, const char *volatile encoding,
+ struct dictionary **dictp, struct sfm_read_info *infop)
+{
+ struct sfm_reader *volatile r = NULL;
+ struct sfm_read_info *volatile info;
- for (vl = val_labs_first (vlabs); vl != NULL; vl = val_labs_next (vlabs, vl))
- {
- const union value *val = val_lab_get_value (vl);
- const char *label = val_lab_get_label (vl);
- char *new_label = NULL;
+ struct sfm_header_record header;
- new_label = recode_string (UTF8, enc, label, -1);
+ struct sfm_var_record *vars;
+ size_t n_vars, allocated_vars;
- var_replace_value_label (var, val, new_label);
- free (new_label);
- }
- }
- }
-}
+ struct sfm_value_label_record *labels;
+ size_t n_labels, allocated_labels;
-/* Opens the system file designated by file handle FH for
- reading. Reads the system file's dictionary into *DICT.
- If INFO is non-null, then it receives additional info about the
- system file. */
-struct casereader *
-sfm_open_reader (struct file_handle *fh, struct dictionary **dict,
- struct sfm_read_info *volatile info)
-{
- struct sfm_reader *volatile r = NULL;
- struct variable **var_by_value_idx;
- struct sfm_read_info local_info;
- int format_warning_cnt = 0;
- int weight_idx;
- int claimed_oct_cnt;
- int rec_type;
+ struct sfm_document_record *document;
- *dict = dict_create ();
+ struct sfm_extension_record *extensions[32];
+
+ struct dictionary *volatile dict = NULL;
+ size_t i;
/* Create and initialize reader. */
r = pool_create_container (struct sfm_reader, pool);
r->fh = fh_ref (fh);
r->lock = NULL;
r->file = NULL;
+ r->pos = 0;
r->error = false;
- r->oct_cnt = 0;
- r->has_long_var_names = false;
r->opcode_idx = sizeof r->opcodes;
r->corruption_warning = false;
+ info = infop ? infop : xmalloc (sizeof *info);
+ memset (info, 0, sizeof *info);
+
/* TRANSLATORS: this fragment will be interpolated into
messages in fh_lock() that identify types of files. */
r->lock = fh_lock (fh, FH_REF_FILE, N_("system file"), FH_ACC_READ, false);
r->file = fn_open (fh_get_file_name (fh), "rb");
if (r->file == NULL)
{
- msg (ME, _("Error opening \"%s\" for reading as a system file: %s."),
+ msg (ME, _("Error opening `%s' for reading as a system file: %s."),
fh_get_file_name (r->fh), strerror (errno));
goto error;
}
- /* Initialize info. */
- if (info == NULL)
- info = &local_info;
- memset (info, 0, sizeof *info);
-
if (setjmp (r->bail_out))
goto error;
-
/* Read header. */
- read_header (r, *dict, &weight_idx, &claimed_oct_cnt, info);
+ read_header (r, info, &header);
- /* Read all the variable definition records. */
- rec_type = read_int (r);
- while (rec_type == 2)
- {
- read_variable_record (r, *dict, &format_warning_cnt);
- rec_type = read_int (r);
- }
+ vars = NULL;
+ n_vars = allocated_vars = 0;
+
+ labels = NULL;
+ n_labels = allocated_labels = 0;
+
+ document = NULL;
- /* Figure out the case format. */
- var_by_value_idx = make_var_by_value_idx (r, *dict);
- setup_weight (r, weight_idx, var_by_value_idx, *dict);
+ memset (extensions, 0, sizeof extensions);
- /* Read all the rest of the dictionary records. */
- while (rec_type != 999)
+ for (;;)
{
- switch (rec_type)
+ int subtype;
+ int type;
+
+ type = read_int (r);
+ if (type == 999)
{
+ read_int (r); /* Skip filler. */
+ break;
+ }
+
+ switch (type)
+ {
+ case 2:
+ if (n_vars >= allocated_vars)
+ vars = pool_2nrealloc (r->pool, vars, &allocated_vars,
+ sizeof *vars);
+ read_variable_record (r, &vars[n_vars++]);
+ break;
+
case 3:
- read_value_labels (r, *dict, var_by_value_idx);
+ if (n_labels >= allocated_labels)
+ labels = pool_2nrealloc (r->pool, labels, &allocated_labels,
+ sizeof *labels);
+ read_value_label_record (r, &labels[n_labels++], n_vars);
break;
case 4:
- sys_error (r, _("Misplaced type 4 record."));
+ /* A Type 4 record is always immediately after a type 3 record,
+ so the code for type 3 records reads the type 4 record too. */
+ sys_error (r, r->pos, _("Misplaced type 4 record."));
case 6:
- read_documents (r, *dict);
+ if (document != NULL)
+ sys_error (r, r->pos, _("Duplicate type 6 (document) record."));
+ document = read_document_record (r);
break;
case 7:
- read_extension_record (r, *dict, info);
+ subtype = read_int (r);
+ if (subtype < 0 || subtype >= sizeof extensions / sizeof *extensions)
+ {
+ sys_warn (r, r->pos,
+ _("Unrecognized record type 7, subtype %d. Please "
+ "send a copy of this file, and the syntax which "
+ "created it to %s."),
+ subtype, PACKAGE_BUGREPORT);
+ skip_extension_record (r, subtype);
+ }
+ else if (extensions[subtype] != NULL)
+ {
+ sys_warn (r, r->pos,
+ _("Record type 7, subtype %d found here has the same "
+ "type as the record found near offset 0x%llx. "
+ "Please send a copy of this file, and the syntax "
+ "which created it to %s."),
+ subtype, (long long int) extensions[subtype]->pos,
+ PACKAGE_BUGREPORT);
+ skip_extension_record (r, subtype);
+ }
+ else
+ extensions[subtype] = read_extension_record (r, subtype);
break;
default:
- sys_error (r, _("Unrecognized record type %d."), rec_type);
+ sys_error (r, r->pos, _("Unrecognized record type %d."), type);
+ goto error;
}
- rec_type = read_int (r);
}
+ /* Now actually parse what we read.
- if ( ! r->has_long_var_names )
- {
- int i;
- for (i = 0; i < dict_get_var_cnt (*dict); i++)
- {
- struct variable *var = dict_get_var (*dict, i);
- char short_name[SHORT_NAME_LEN + 1];
- char long_name[SHORT_NAME_LEN + 1];
+ First, figure out the correct character encoding, because this determines
+ how the rest of the header data is to be interpreted. */
+ dict = dict_create (encoding
+ ? encoding
+ : choose_encoding (r, &header, extensions[EXT_INTEGER],
+ extensions[EXT_ENCODING]));
+ r->encoding = dict_get_encoding (dict);
- strcpy (short_name, var_get_name (var));
+ /* These records don't use variables at all. */
+ if (document != NULL)
+ parse_document (dict, document);
- strcpy (long_name, short_name);
- str_lowercase (long_name);
+ if (extensions[EXT_INTEGER] != NULL)
+ parse_machine_integer_info (r, extensions[EXT_INTEGER], info);
- /* Set long name. Renaming a variable may clear the short
- name, but we want to retain it, so re-set it
- explicitly. */
- dict_rename_var (*dict, var, long_name);
- var_set_short_name (var, 0, short_name);
- }
+ if (extensions[EXT_FLOAT] != NULL)
+ parse_machine_float_info (r, extensions[EXT_FLOAT]);
+
+ if (extensions[EXT_PRODUCT_INFO] != NULL)
+ parse_extra_product_info (r, extensions[EXT_PRODUCT_INFO], info);
+
+ if (extensions[EXT_FILE_ATTRS] != NULL)
+ parse_data_file_attributes (r, extensions[EXT_FILE_ATTRS], dict);
+
+ parse_header (r, &header, info, dict);
+
+ /* Parse the variable records, the basis of almost everything else. */
+ parse_variable_records (r, dict, vars, n_vars);
- r->has_long_var_names = true;
+ /* Parse value labels and the weight variable immediately after the variable
+ records. These records use indexes into var_recs[], so we must parse them
+ before those indexes become invalidated by very long string variables. */
+ for (i = 0; i < n_labels; i++)
+ parse_value_labels (r, dict, vars, n_vars, &labels[i]);
+ if (header.weight_idx != 0)
+ {
+ struct variable *weight_var;
+
+ weight_var = lookup_var_by_index (r, 76, vars, n_vars,
+ header.weight_idx);
+ if (var_is_numeric (weight_var))
+ dict_set_weight (dict, weight_var);
+ else
+ sys_error (r, -1, _("Weighting variable must be numeric "
+ "(not string variable `%s')."),
+ var_get_name (weight_var));
}
- recode_strings (*dict);
+ if (extensions[EXT_DISPLAY] != NULL)
+ parse_display_parameters (r, extensions[EXT_DISPLAY], dict);
+
+ /* The following records use short names, so they need to be parsed before
+ parse_long_var_name_map() changes short names to long names. */
+ if (extensions[EXT_MRSETS] != NULL)
+ parse_mrsets (r, extensions[EXT_MRSETS], dict);
+
+ if (extensions[EXT_MRSETS2] != NULL)
+ parse_mrsets (r, extensions[EXT_MRSETS2], dict);
- /* Read record 999 data, which is just filler. */
- read_int (r);
+ if (extensions[EXT_LONG_STRINGS] != NULL)
+ parse_long_string_map (r, extensions[EXT_LONG_STRINGS], dict);
+
+ /* Now rename variables to their long names. */
+ parse_long_var_name_map (r, extensions[EXT_LONG_NAMES], dict);
+
+ /* The following records use long names, so they need to follow renaming. */
+ if (extensions[EXT_VAR_ATTRS] != NULL)
+ {
+ parse_variable_attributes (r, extensions[EXT_VAR_ATTRS], dict);
+
+ /* Roles use the $@Role attribute. */
+ assign_variable_roles (r, dict);
+ }
+
+ if (extensions[EXT_LONG_LABELS] != NULL)
+ parse_long_string_value_labels (r, extensions[EXT_LONG_LABELS], dict);
+ if (extensions[EXT_LONG_MISSING] != NULL)
+ parse_long_string_missing_values (r, extensions[EXT_LONG_MISSING], dict);
/* Warn if the actual amount of data per case differs from the
amount that the header claims. SPSS version 13 gets this
wrong when very long strings are involved, so don't warn in
that case. */
- if (claimed_oct_cnt != -1 && claimed_oct_cnt != r->oct_cnt
+ if (header.nominal_case_size != -1 && header.nominal_case_size != n_vars
&& info->version_major != 13)
- sys_warn (r, _("File header claims %d variable positions but "
- "%d were read from file."),
- claimed_oct_cnt, r->oct_cnt);
+ sys_warn (r, -1, _("File header claims %d variable positions but "
+ "%zu were read from file."),
+ header.nominal_case_size, n_vars);
/* Create an index of dictionary variable widths for
sfm_read_case to use. We cannot use the `struct variable's
from the dictionary we created, because the caller owns the
dictionary and may destroy or modify its variables. */
- sfm_dictionary_to_sfm_vars (*dict, &r->sfm_vars, &r->sfm_var_cnt);
+ sfm_dictionary_to_sfm_vars (dict, &r->sfm_vars, &r->sfm_var_cnt);
pool_register (r->pool, free, r->sfm_vars);
- r->proto = caseproto_ref_pool (dict_get_proto (*dict), r->pool);
+ r->proto = caseproto_ref_pool (dict_get_proto (dict), r->pool);
+
+ *dictp = dict;
+ if (infop != info)
+ {
+ sfm_read_info_destroy (info);
+ free (info);
+ }
- pool_free (r->pool, var_by_value_idx);
return casereader_create_sequential
(NULL, r->proto,
r->case_cnt == -1 ? CASENUMBER_MAX: r->case_cnt,
&sys_file_casereader_class, r);
error:
+ if (infop != info)
+ {
+ sfm_read_info_destroy (info);
+ free (info);
+ }
+
close_reader (r);
- dict_destroy (*dict);
- *dict = NULL;
+ dict_destroy (dict);
+ *dictp = NULL;
return NULL;
}
{
if (fn_close (fh_get_file_name (r->fh), r->file) == EOF)
{
- msg (ME, _("Error closing system file \"%s\": %s."),
+ msg (ME, _("Error closing system file `%s': %s."),
fh_get_file_name (r->fh), strerror (errno));
r->error = true;
}
bool
sfm_detect (FILE *file)
{
- char rec_type[5];
+ char magic[5];
- if (fread (rec_type, 4, 1, file) != 1)
+ if (fread (magic, 4, 1, file) != 1)
return false;
- rec_type[4] = '\0';
+ magic[4] = '\0';
- return !strcmp ("$FL2", rec_type);
+ return !strcmp (ASCII_MAGIC, magic) || !strcmp (EBCDIC_MAGIC, magic);
}
\f
-/* Reads the global header of the system file.
- Sets DICT's file label to the system file's label.
- Sets *WEIGHT_IDX to 0 if the system file is unweighted,
- or to the value index of the weight variable otherwise.
- Sets *CLAIMED_OCT_CNT to the number of "octs" (8-byte units)
- per case that the file claims to have (although it is not
- always correct).
- Initializes INFO with header information. */
+/* Reads the global header of the system file. Initializes *HEADER and *INFO,
+ except for the string fields in *INFO, which parse_header() will initialize
+ later once the file's encoding is known. */
static void
-read_header (struct sfm_reader *r, struct dictionary *dict,
- int *weight_idx, int *claimed_oct_cnt,
- struct sfm_read_info *info)
+read_header (struct sfm_reader *r, struct sfm_read_info *info,
+ struct sfm_header_record *header)
{
- char rec_type[5];
- char eye_catcher[61];
uint8_t raw_layout_code[4];
uint8_t raw_bias[8];
- char creation_date[10];
- char creation_time[9];
- char file_label[65];
- struct substring file_label_ss;
- struct substring product;
- read_string (r, rec_type, sizeof rec_type);
- read_string (r, eye_catcher, sizeof eye_catcher);
+ read_string (r, header->magic, sizeof header->magic);
+ read_string (r, header->eye_catcher, sizeof header->eye_catcher);
- if (strcmp ("$FL2", rec_type) != 0)
- sys_error (r, _("This is not an SPSS system file."));
+ if (strcmp (ASCII_MAGIC, header->magic)
+ && strcmp (EBCDIC_MAGIC, header->magic))
+ sys_error (r, 0, _("This is not an SPSS system file."));
/* Identify integer format. */
read_bytes (r, raw_layout_code, sizeof raw_layout_code);
&r->integer_format))
|| (r->integer_format != INTEGER_MSB_FIRST
&& r->integer_format != INTEGER_LSB_FIRST))
- sys_error (r, _("This is not an SPSS system file."));
+ sys_error (r, 64, _("This is not an SPSS system file."));
- *claimed_oct_cnt = read_int (r);
- if (*claimed_oct_cnt < 0 || *claimed_oct_cnt > INT_MAX / 16)
- *claimed_oct_cnt = -1;
+ header->nominal_case_size = read_int (r);
+ if (header->nominal_case_size < 0
+ || header->nominal_case_size > INT_MAX / 16)
+ header->nominal_case_size = -1;
r->compressed = read_int (r) != 0;
- *weight_idx = read_int (r);
+ header->weight_idx = read_int (r);
r->case_cnt = read_int (r);
if ( r->case_cnt > INT_MAX / 2)
r->case_cnt = -1;
-
/* Identify floating-point format and obtain compression bias. */
read_bytes (r, raw_bias, sizeof raw_bias);
if (float_identify (100.0, raw_bias, sizeof raw_bias, &r->float_format) == 0)
uint8_t zero_bias[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
if (memcmp (raw_bias, zero_bias, 8))
- sys_warn (r, _("Compression bias is not the usual "
- "value of 100, or system file uses unrecognized "
- "floating-point format."));
+ sys_warn (r, r->pos - 8,
+ _("Compression bias is not the usual "
+ "value of 100, or system file uses unrecognized "
+ "floating-point format."));
else
{
/* Some software is known to write all-zeros to this
}
float_convert (r->float_format, raw_bias, FLOAT_NATIVE_DOUBLE, &r->bias);
- read_string (r, creation_date, sizeof creation_date);
- read_string (r, creation_time, sizeof creation_time);
- read_string (r, file_label, sizeof file_label);
+ read_string (r, header->creation_date, sizeof header->creation_date);
+ read_string (r, header->creation_time, sizeof header->creation_time);
+ read_string (r, header->file_label, sizeof header->file_label);
skip_bytes (r, 3);
- file_label_ss = ss_cstr (file_label);
- ss_trim (&file_label_ss, ss_cstr (" "));
- if (!ss_is_empty (file_label_ss))
- {
- ss_data (file_label_ss)[ss_length (file_label_ss)] = '\0';
- dict_set_label (dict, ss_data (file_label_ss));
- }
-
- strcpy (info->creation_date, creation_date);
- strcpy (info->creation_time, creation_time);
info->integer_format = r->integer_format;
info->float_format = r->float_format;
info->compressed = r->compressed;
info->case_cnt = r->case_cnt;
-
- product = ss_cstr (eye_catcher);
- ss_match_string (&product, ss_cstr ("@(#) SPSS DATA FILE"));
- ss_trim (&product, ss_cstr (" "));
- str_copy_buf_trunc (info->product, sizeof info->product,
- ss_data (product), ss_length (product));
}
-/* Reads a variable (type 2) record from R and adds the
- corresponding variable to DICT.
- Also skips past additional variable records for long string
- variables. */
+/* Reads a variable (type 2) record from R into RECORD. */
static void
-read_variable_record (struct sfm_reader *r, struct dictionary *dict,
- int *format_warning_cnt)
+read_variable_record (struct sfm_reader *r, struct sfm_var_record *record)
{
- int width;
int has_variable_label;
- int missing_value_code;
- int print_format;
- int write_format;
- char name[9];
- struct variable *var;
- int nv;
+ memset (record, 0, sizeof *record);
- width = read_int (r);
+ record->pos = r->pos;
+ record->width = read_int (r);
has_variable_label = read_int (r);
- missing_value_code = read_int (r);
- print_format = read_int (r);
- write_format = read_int (r);
- read_string (r, name, sizeof name);
- name[strcspn (name, " ")] = '\0';
-
- /* Check variable name. */
- if (name[0] == '$' || name[0] == '#')
- sys_error (r, "Variable name begins with invalid character `%c'.",
- name[0]);
- if (!var_is_plausible_name (name, false))
- sys_error (r, _("Invalid variable name `%s'."), name);
-
- /* Create variable. */
- if (width < 0 || width > 255)
- sys_error (r, _("Bad width %d for variable %s."), width, name);
- var = dict_create_var (dict, name, width);
- if (var == NULL)
- sys_error (r,
- _("Duplicate variable name `%s' within system file."),
- name);
-
- /* Set the short name the same as the long name. */
- var_set_short_name (var, 0, var_get_name (var));
-
- /* Get variable label, if any. */
- if (has_variable_label != 0 && has_variable_label != 1)
- sys_error (r, _("Variable label indicator field is not 0 or 1."));
+ record->missing_value_code = read_int (r);
+ record->print_format = read_int (r);
+ record->write_format = read_int (r);
+ read_bytes (r, record->name, sizeof record->name);
+
if (has_variable_label == 1)
{
+ enum { MAX_LABEL_LEN = 255 };
size_t len, read_len;
- char label[255 + 1];
len = read_int (r);
- /* Read up to 255 bytes of label. */
- read_len = MIN (sizeof label - 1, len);
- read_string (r, label, read_len + 1);
- var_set_label (var, label);
+ /* Read up to MAX_LABEL_LEN bytes of label. */
+ read_len = MIN (MAX_LABEL_LEN, len);
+ record->label = pool_malloc (r->pool, read_len + 1);
+ read_string (r, record->label, read_len + 1);
/* Skip unread label bytes. */
skip_bytes (r, len - read_len);
/* Skip label padding up to multiple of 4 bytes. */
skip_bytes (r, ROUND_UP (len, 4) - len);
}
+ else if (has_variable_label != 0)
+ sys_error (r, record->pos,
+ _("Variable label indicator field is not 0 or 1."));
/* Set missing values. */
- if (missing_value_code != 0)
+ if (record->missing_value_code != 0)
{
- struct missing_values mv;
- int i;
-
- mv_init_pool (r->pool, &mv, var_get_width (var));
- if (var_is_numeric (var))
+ int code = record->missing_value_code;
+ if (record->width == 0)
{
- if (missing_value_code < -3 || missing_value_code > 3
- || missing_value_code == -1)
- sys_error (r, _("Numeric missing value indicator field is not "
- "-3, -2, 0, 1, 2, or 3."));
- if (missing_value_code < 0)
- {
- double low = read_float (r);
- double high = read_float (r);
- mv_add_range (&mv, low, high);
- missing_value_code = -missing_value_code - 2;
- }
- for (i = 0; i < missing_value_code; i++)
- mv_add_num (&mv, read_float (r));
+ if (code < -3 || code > 3 || code == -1)
+ sys_error (r, record->pos,
+ _("Numeric missing value indicator field is not "
+ "-3, -2, 0, 1, 2, or 3."));
}
else
{
- int mv_width = MAX (width, 8);
- union value value;
+ if (code < 1 || code > 3)
+ sys_error (r, record->pos,
+ _("String missing value indicator field is not "
+ "0, 1, 2, or 3."));
+ }
+
+ read_bytes (r, record->missing, 8 * abs (code));
+ }
+}
- if (missing_value_code < 1 || missing_value_code > 3)
- sys_error (r, _("String missing value indicator field is not "
- "0, 1, 2, or 3."));
+/* Reads value labels from R into RECORD. */
+static void
+read_value_label_record (struct sfm_reader *r,
+ struct sfm_value_label_record *record,
+ size_t n_vars)
+{
+ size_t i;
- value_init (&value, mv_width);
- value_set_missing (&value, mv_width);
- for (i = 0; i < missing_value_code; i++)
- {
- uint8_t *s = value_str_rw (&value, mv_width);
- read_bytes (r, s, 8);
- mv_add_str (&mv, s);
- }
- value_destroy (&value, mv_width);
- }
- var_set_missing_values (var, &mv);
+ /* Read type 3 record. */
+ record->pos = r->pos;
+ record->n_labels = read_int (r);
+ if (record->n_labels > SIZE_MAX / sizeof *record->labels)
+ sys_error (r, r->pos - 4, _("Invalid number of labels %zu."),
+ record->n_labels);
+ record->labels = pool_nmalloc (r->pool, record->n_labels,
+ sizeof *record->labels);
+ for (i = 0; i < record->n_labels; i++)
+ {
+ struct sfm_value_label *label = &record->labels[i];
+ unsigned char label_len;
+ size_t padded_len;
+
+ read_bytes (r, label->value, sizeof label->value);
+
+ /* Read label length. */
+ read_bytes (r, &label_len, sizeof label_len);
+ padded_len = ROUND_UP (label_len + 1, 8);
+
+ /* Read label, padding. */
+ label->label = pool_malloc (r->pool, padded_len + 1);
+ read_bytes (r, label->label, padded_len - 1);
+ label->label[label_len] = '\0';
}
- /* Set formats. */
- parse_format_spec (r, print_format, PRINT_FORMAT, var, format_warning_cnt);
- parse_format_spec (r, write_format, WRITE_FORMAT, var, format_warning_cnt);
+ /* Read record type of type 4 record. */
+ if (read_int (r) != 4)
+ sys_error (r, r->pos - 4,
+ _("Variable index record (type 4) does not immediately "
+ "follow value label record (type 3) as it should."));
+
+ /* Read number of variables associated with value label from type 4
+ record. */
+ record->n_vars = read_int (r);
+ if (record->n_vars < 1 || record->n_vars > n_vars)
+ sys_error (r, r->pos - 4,
+ _("Number of variables associated with a value label (%zu) "
+ "is not between 1 and the number of variables (%zu)."),
+ record->n_vars, n_vars);
+ record->vars = pool_nmalloc (r->pool, record->n_vars, sizeof *record->vars);
+ for (i = 0; i < record->n_vars; i++)
+ record->vars[i] = read_int (r);
+}
+
+/* Reads a document record from R and returns it. */
+static struct sfm_document_record *
+read_document_record (struct sfm_reader *r)
+{
+ struct sfm_document_record *record;
+ int n_lines;
+
+ record = pool_malloc (r->pool, sizeof *record);
+ record->pos = r->pos;
+
+ n_lines = read_int (r);
+ if (n_lines <= 0 || n_lines >= INT_MAX / DOC_LINE_LENGTH)
+ sys_error (r, record->pos,
+ _("Number of document lines (%d) "
+ "must be greater than 0 and less than %d."),
+ n_lines, INT_MAX / DOC_LINE_LENGTH);
+
+ record->n_lines = n_lines;
+ record->documents = pool_malloc (r->pool, DOC_LINE_LENGTH * n_lines);
+ read_bytes (r, record->documents, DOC_LINE_LENGTH * n_lines);
+
+ return record;
+}
+
+static void
+read_extension_record_header (struct sfm_reader *r, int subtype,
+ struct sfm_extension_record *record)
+{
+ record->subtype = subtype;
+ record->pos = r->pos;
+ record->size = read_int (r);
+ record->count = read_int (r);
+
+ /* Check that SIZE * COUNT + 1 doesn't overflow. Adding 1
+ allows an extra byte for a null terminator, used by some
+ extension processing routines. */
+ if (record->size != 0
+ && size_overflow_p (xsum (1, xtimes (record->count, record->size))))
+ sys_error (r, record->pos, "Record type 7 subtype %d too large.", subtype);
+}
- /* Account for values.
- Skip long string continuation records, if any. */
- nv = width == 0 ? 1 : DIV_RND_UP (width, 8);
- r->oct_cnt += nv;
- if (width > 8)
+/* Reads an extension record from R into RECORD. */
+static struct sfm_extension_record *
+read_extension_record (struct sfm_reader *r, int subtype)
+{
+ struct extension_record_type
{
- int i;
+ int subtype;
+ int size;
+ int count;
+ };
+
+ static const struct extension_record_type types[] =
+ {
+ /* Implemented record types. */
+ { EXT_INTEGER, 4, 8 },
+ { EXT_FLOAT, 8, 3 },
+ { EXT_MRSETS, 1, 0 },
+ { EXT_PRODUCT_INFO, 1, 0 },
+ { EXT_DISPLAY, 4, 0 },
+ { EXT_LONG_NAMES, 1, 0 },
+ { EXT_LONG_STRINGS, 1, 0 },
+ { EXT_NCASES, 8, 2 },
+ { EXT_FILE_ATTRS, 1, 0 },
+ { EXT_VAR_ATTRS, 1, 0 },
+ { EXT_MRSETS2, 1, 0 },
+ { EXT_ENCODING, 1, 0 },
+ { EXT_LONG_LABELS, 1, 0 },
+ { EXT_LONG_MISSING, 1, 0 },
+
+ /* Ignored record types. */
+ { EXT_VAR_SETS, 0, 0 },
+ { EXT_DATE, 0, 0 },
+ { EXT_DATA_ENTRY, 0, 0 },
+ { EXT_DATAVIEW, 0, 0 },
+ };
+
+ const struct extension_record_type *type;
+ struct sfm_extension_record *record;
+ size_t n_bytes;
+
+ record = pool_malloc (r->pool, sizeof *record);
+ read_extension_record_header (r, subtype, record);
+ n_bytes = record->count * record->size;
+
+ for (type = types; type < &types[sizeof types / sizeof *types]; type++)
+ if (subtype == type->subtype)
+ {
+ if (type->size > 0 && record->size != type->size)
+ sys_warn (r, record->pos,
+ _("Record type 7, subtype %d has bad size %zu "
+ "(expected %d)."), subtype, record->size, type->size);
+ else if (type->count > 0 && record->count != type->count)
+ sys_warn (r, record->pos,
+ _("Record type 7, subtype %d has bad count %zu "
+ "(expected %d)."), subtype, record->count, type->count);
+ else if (type->count == 0 && type->size == 0)
+ {
+ /* Ignore this record. */
+ }
+ else
+ {
+ char *data = pool_malloc (r->pool, n_bytes + 1);
+ data[n_bytes] = '\0';
+
+ record->data = data;
+ read_bytes (r, record->data, n_bytes);
+ return record;
+ }
+
+ goto skip;
+ }
+
+ sys_warn (r, record->pos,
+ _("Unrecognized record type 7, subtype %d. Please send a "
+ "copy of this file, and the syntax which created it to %s."),
+ subtype, PACKAGE_BUGREPORT);
+
+skip:
+ skip_bytes (r, n_bytes);
+ return NULL;
+}
+
+static void
+skip_extension_record (struct sfm_reader *r, int subtype)
+{
+ struct sfm_extension_record record;
+
+ read_extension_record_header (r, subtype, &record);
+ skip_bytes (r, record.count * record.size);
+}
+
+static void
+parse_header (struct sfm_reader *r, const struct sfm_header_record *header,
+ struct sfm_read_info *info, struct dictionary *dict)
+{
+ const char *dict_encoding = dict_get_encoding (dict);
+ struct substring product;
+ struct substring label;
+ char *fixed_label;
+
+ /* Convert file label to UTF-8 and put it into DICT. */
+ label = recode_substring_pool ("UTF-8", dict_encoding,
+ ss_cstr (header->file_label), r->pool);
+ ss_trim (&label, ss_cstr (" "));
+ label.string[label.length] = '\0';
+ fixed_label = fix_line_ends (label.string);
+ dict_set_label (dict, fixed_label);
+ free (fixed_label);
+
+ /* Put creation date and time in UTF-8 into INFO. */
+ info->creation_date = recode_string ("UTF-8", dict_encoding,
+ header->creation_date, -1);
+ info->creation_time = recode_string ("UTF-8", dict_encoding,
+ header->creation_time, -1);
+
+ /* Put product name into INFO, dropping eye-catcher string if present. */
+ product = recode_substring_pool ("UTF-8", dict_encoding,
+ ss_cstr (header->eye_catcher), r->pool);
+ ss_match_string (&product, ss_cstr ("@(#) SPSS DATA FILE"));
+ ss_trim (&product, ss_cstr (" "));
+ info->product = ss_xstrdup (product);
+}
+
+/* Reads a variable (type 2) record from R and adds the
+ corresponding variable to DICT.
+ Also skips past additional variable records for long string
+ variables. */
+static void
+parse_variable_records (struct sfm_reader *r, struct dictionary *dict,
+ struct sfm_var_record *var_recs, size_t n_var_recs)
+{
+ const char *dict_encoding = dict_get_encoding (dict);
+ struct sfm_var_record *rec;
+ int n_warnings = 0;
+
+ for (rec = var_recs; rec < &var_recs[n_var_recs]; )
+ {
+ struct variable *var;
+ size_t n_values;
+ char *name;
+ size_t i;
+
+ name = recode_string_pool ("UTF-8", dict_encoding,
+ rec->name, 8, r->pool);
+ name[strcspn (name, " ")] = '\0';
- for (i = 1; i < nv; i++)
+ if (!dict_id_is_valid (dict, name, false)
+ || name[0] == '$' || name[0] == '#')
+ sys_error (r, rec->pos, _("Invalid variable name `%s'."), name);
+
+ if (rec->width < 0 || rec->width > 255)
+ sys_error (r, rec->pos,
+ _("Bad width %d for variable %s."), rec->width, name);
+
+ var = rec->var = dict_create_var (dict, name, rec->width);
+ if (var == NULL)
+ sys_error (r, rec->pos, _("Duplicate variable name `%s'."), name);
+
+ /* Set the short name the same as the long name. */
+ var_set_short_name (var, 0, name);
+
+ /* Get variable label, if any. */
+ if (rec->label)
{
- /* Check for record type 2 and width -1. */
- if (read_int (r) != 2 || read_int (r) != -1)
- sys_error (r, _("Missing string continuation record."));
-
- /* Skip and ignore remaining continuation data. */
- has_variable_label = read_int (r);
- missing_value_code = read_int (r);
- print_format = read_int (r);
- write_format = read_int (r);
- read_string (r, name, sizeof name);
-
- /* Variable label fields on continuation records have
- been spotted in system files created by "SPSS Power
- Macintosh Release 6.1". */
- if (has_variable_label)
- skip_bytes (r, ROUND_UP (read_int (r), 4));
+ char *utf8_label;
+
+ utf8_label = recode_string_pool ("UTF-8", dict_encoding,
+ rec->label, -1, r->pool);
+ var_set_label (var, utf8_label, false);
}
+
+ /* Set missing values. */
+ if (rec->missing_value_code != 0)
+ {
+ int width = var_get_width (var);
+ struct missing_values mv;
+
+ mv_init_pool (r->pool, &mv, width);
+ if (var_is_numeric (var))
+ {
+ bool has_range = rec->missing_value_code < 0;
+ int n_discrete = (has_range
+ ? rec->missing_value_code == -3
+ : rec->missing_value_code);
+ int ofs = 0;
+
+ if (has_range)
+ {
+ double low = parse_float (r, rec->missing, 0);
+ double high = parse_float (r, rec->missing, 8);
+
+ /* Deal with SPSS 21 change in representation. */
+ if (low == SYSMIS)
+ low = LOWEST;
+
+ mv_add_range (&mv, low, high);
+ ofs += 16;
+ }
+
+ for (i = 0; i < n_discrete; i++)
+ {
+ mv_add_num (&mv, parse_float (r, rec->missing, ofs));
+ ofs += 8;
+ }
+ }
+ else
+ {
+ union value value;
+
+ value_init_pool (r->pool, &value, width);
+ value_set_missing (&value, width);
+ for (i = 0; i < rec->missing_value_code; i++)
+ mv_add_str (&mv, rec->missing + 8 * i, MIN (width, 8));
+ }
+ var_set_missing_values (var, &mv);
+ }
+
+ /* Set formats. */
+ parse_format_spec (r, rec->pos + 12, rec->print_format,
+ PRINT_FORMAT, var, &n_warnings);
+ parse_format_spec (r, rec->pos + 16, rec->write_format,
+ WRITE_FORMAT, var, &n_warnings);
+
+ /* Account for values.
+ Skip long string continuation records, if any. */
+ n_values = rec->width == 0 ? 1 : DIV_RND_UP (rec->width, 8);
+ for (i = 1; i < n_values; i++)
+ if (i + (rec - var_recs) >= n_var_recs || rec[i].width != -1)
+ sys_error (r, rec->pos, _("Missing string continuation record."));
+ rec += n_values;
}
}
/* Translates the format spec from sysfile format to internal
format. */
static void
-parse_format_spec (struct sfm_reader *r, unsigned int s,
+parse_format_spec (struct sfm_reader *r, off_t pos, unsigned int format,
enum which_format which, struct variable *v,
- int *format_warning_cnt)
+ int *n_warnings)
{
- const int max_format_warnings = 8;
+ const int max_warnings = 8;
+ uint8_t raw_type = format >> 16;
+ uint8_t w = format >> 8;
+ uint8_t d = format;
struct fmt_spec f;
- uint8_t raw_type = s >> 16;
- uint8_t w = s >> 8;
- uint8_t d = s;
-
bool ok;
- if (!fmt_from_io (raw_type, &f.type))
- sys_error (r, _("Unknown variable format %"PRIu8"."), raw_type);
f.w = w;
f.d = d;
msg_disable ();
- ok = fmt_check_output (&f) && fmt_check_width_compat (&f, var_get_width (v));
+ ok = (fmt_from_io (raw_type, &f.type)
+ && fmt_check_output (&f)
+ && fmt_check_width_compat (&f, var_get_width (v)));
msg_enable ();
if (ok)
else
var_set_write_format (v, &f);
}
- else if (*++format_warning_cnt <= max_format_warnings)
+ else if (format == 0)
{
- char fmt_string[FMT_STRING_LEN_MAX + 1];
- sys_warn (r, _("%s variable %s has invalid %s format %s."),
- var_is_numeric (v) ? _("Numeric") : _("String"),
- var_get_name (v),
- which == PRINT_FORMAT ? _("print") : _("write"),
- fmt_to_string (&f, fmt_string));
-
- if (*format_warning_cnt == max_format_warnings)
- sys_warn (r, _("Suppressing further invalid format warnings."));
+ /* Actually observed in the wild. No point in warning about it. */
}
-}
-
-/* Sets the weighting variable in DICT to the variable
- corresponding to the given 1-based VALUE_IDX, if VALUE_IDX is
- nonzero. */
-static void
-setup_weight (struct sfm_reader *r, int weight_idx,
- struct variable **var_by_value_idx, struct dictionary *dict)
-{
- if (weight_idx != 0)
+ else if (++*n_warnings <= max_warnings)
{
- struct variable *weight_var
- = lookup_var_by_value_idx (r, var_by_value_idx, weight_idx);
- if (var_is_numeric (weight_var))
- dict_set_weight (dict, weight_var);
+ if (which == PRINT_FORMAT)
+ sys_warn (r, pos, _("Variable %s with width %d has invalid print "
+ "format 0x%x."),
+ var_get_name (v), var_get_width (v), format);
else
- sys_error (r, _("Weighting variable must be numeric."));
- }
-}
+ sys_warn (r, pos, _("Variable %s with width %d has invalid write "
+ "format 0x%x."),
+ var_get_name (v), var_get_width (v), format);
-/* Reads a document record, type 6, from system file R, and sets up
- the documents and n_documents fields in the associated
- dictionary. */
-static void
-read_documents (struct sfm_reader *r, struct dictionary *dict)
-{
- int line_cnt;
- char *documents;
-
- if (dict_get_documents (dict) != NULL)
- sys_error (r, _("Multiple type 6 (document) records."));
-
- line_cnt = read_int (r);
- if (line_cnt <= 0)
- sys_error (r, _("Number of document lines (%d) "
- "must be greater than 0."), line_cnt);
-
- documents = pool_nmalloc (r->pool, line_cnt + 1, DOC_LINE_LENGTH);
- read_string (r, documents, DOC_LINE_LENGTH * line_cnt + 1);
- if (strlen (documents) == DOC_LINE_LENGTH * line_cnt)
- dict_set_documents (dict, documents);
- else
- sys_error (r, _("Document line contains null byte."));
- pool_free (r->pool, documents);
+ if (*n_warnings == max_warnings)
+ sys_warn (r, -1, _("Suppressing further invalid format warnings."));
+ }
}
-/* Read a type 7 extension record. */
static void
-read_extension_record (struct sfm_reader *r, struct dictionary *dict,
- struct sfm_read_info *info)
+parse_document (struct dictionary *dict, struct sfm_document_record *record)
{
- int subtype = read_int (r);
- size_t size = read_int (r);
- size_t count = read_int (r);
- size_t bytes = size * count;
+ const char *p;
- /* Check that SIZE * COUNT + 1 doesn't overflow. Adding 1
- allows an extra byte for a null terminator, used by some
- extension processing routines. */
- if (size != 0 && size_overflow_p (xsum (1, xtimes (count, size))))
- sys_error (r, "Record type 7 subtype %d too large.", subtype);
-
- switch (subtype)
+ for (p = record->documents;
+ p < record->documents + DOC_LINE_LENGTH * record->n_lines;
+ p += DOC_LINE_LENGTH)
{
- case 3:
- read_machine_integer_info (r, size, count, info, dict);
- return;
+ struct substring line;
- case 4:
- read_machine_float_info (r, size, count);
- return;
+ line = recode_substring_pool ("UTF-8", dict_get_encoding (dict),
+ ss_buffer (p, DOC_LINE_LENGTH), NULL);
+ ss_rtrim (&line, ss_cstr (" "));
+ line.string[line.length] = '\0';
- case 5:
- /* Variable sets information. We don't use these yet.
- They only apply to GUIs; see VARSETS on the APPLY
- DICTIONARY command in SPSS documentation. */
- break;
-
- case 6:
- /* DATE variable information. We don't use it yet, but we
- should. */
- break;
+ dict_add_document_line (dict, line.string, false);
- case 7:
- case 19:
- read_mrsets (r, size, count, dict);
- return;
-
- case 8:
- /* Used by the SPSS Data Entry software. */
- break;
-
- case 11:
- read_display_parameters (r, size, count, dict);
- return;
-
- case 13:
- read_long_var_name_map (r, size, count, dict);
- return;
-
- case 14:
- read_long_string_map (r, size, count, dict);
- return;
-
- case 16:
- /* Extended number of cases. Not important. */
- break;
-
- case 17:
- read_data_file_attributes (r, size, count, dict);
- return;
-
- case 18:
- read_variable_attributes (r, size, count, dict);
- return;
-
- case 20:
- /* New in SPSS 16. Contains a single string that describes
- the character encoding, e.g. "windows-1252". */
- {
- char *encoding = pool_calloc (r->pool, size, count + 1);
- read_string (r, encoding, count + 1);
- dict_set_encoding (dict, encoding);
- return;
- }
-
- case 21:
- /* New in SPSS 16. Encodes value labels for long string
- variables. */
- read_long_string_value_labels (r, size, count, dict);
- return;
-
- default:
- sys_warn (r, _("Unrecognized record type 7, subtype %d. Please send a copy of this file, and the syntax which created it to %s"),
- subtype, PACKAGE_BUGREPORT);
- break;
+ ss_dealloc (&line);
}
-
- skip_bytes (r, bytes);
}
-/* Read record type 7, subtype 3. */
+/* Parses record type 7, subtype 3. */
static void
-read_machine_integer_info (struct sfm_reader *r, size_t size, size_t count,
- struct sfm_read_info *info,
- struct dictionary *dict)
-{
- int version_major = read_int (r);
- int version_minor = read_int (r);
- int version_revision = read_int (r);
- int machine_code UNUSED = read_int (r);
- int float_representation = read_int (r);
- int compression_code UNUSED = read_int (r);
- int integer_representation = read_int (r);
- int character_code = read_int (r);
-
- int expected_float_format;
- int expected_integer_format;
-
- if (size != 4 || count != 8)
- sys_error (r, _("Bad size (%zu) or count (%zu) field on record type 7, "
- "subtype 3."),
- size, count);
+parse_machine_integer_info (struct sfm_reader *r,
+ const struct sfm_extension_record *record,
+ struct sfm_read_info *info)
+{
+ int float_representation, expected_float_format;
+ int integer_representation, expected_integer_format;
/* Save version info. */
- info->version_major = version_major;
- info->version_minor = version_minor;
- info->version_revision = version_revision;
+ info->version_major = parse_int (r, record->data, 0);
+ info->version_minor = parse_int (r, record->data, 4);
+ info->version_revision = parse_int (r, record->data, 8);
/* Check floating point format. */
+ float_representation = parse_int (r, record->data, 16);
if (r->float_format == FLOAT_IEEE_DOUBLE_BE
|| r->float_format == FLOAT_IEEE_DOUBLE_LE)
expected_float_format = 1;
else
NOT_REACHED ();
if (float_representation != expected_float_format)
- sys_error (r, _("Floating-point representation indicated by "
- "system file (%d) differs from expected (%d)."),
- r->float_format, expected_float_format);
+ sys_error (r, record->pos, _("Floating-point representation indicated by "
+ "system file (%d) differs from expected (%d)."),
+ float_representation, expected_float_format);
/* Check integer format. */
+ integer_representation = parse_int (r, record->data, 24);
if (r->integer_format == INTEGER_MSB_FIRST)
expected_integer_format = 1;
else if (r->integer_format == INTEGER_LSB_FIRST)
else
NOT_REACHED ();
if (integer_representation != expected_integer_format)
- {
- static const char *const endian[] = {N_("Little Endian"), N_("Big Endian")};
- sys_warn (r, _("Integer format indicated by system file (%s) "
- "differs from expected (%s)."),
- gettext (endian[integer_representation == 1]),
- gettext (endian[expected_integer_format == 1]));
- }
+ sys_warn (r, record->pos,
+ _("Integer format indicated by system file (%d) "
+ "differs from expected (%d)."),
+ integer_representation, expected_integer_format);
+
+}
+static const char *
+choose_encoding (struct sfm_reader *r,
+ const struct sfm_header_record *header,
+ const struct sfm_extension_record *ext_integer,
+ const struct sfm_extension_record *ext_encoding)
+{
+ /* The EXT_ENCODING record is a more reliable way to determine dictionary
+ encoding. */
+ if (ext_encoding)
+ return ext_encoding->data;
- /*
- Record 7 (20) provides a much more reliable way of
- setting the encoding.
- The character_code is used as a fallback only.
- */
- if ( NULL == dict_get_encoding (dict))
+ /* But EXT_INTEGER is better than nothing as a fallback. */
+ if (ext_integer)
{
- switch (character_code)
- {
- case 1:
- dict_set_encoding (dict, "EBCDIC-US");
- break;
- case 2:
- case 3:
- /* These ostensibly mean "7-bit ASCII" and "8-bit ASCII"[sic]
- respectively. However, there are known to be many files
- in the wild with character code 2, yet have data which are
- clearly not ascii.
- Therefore we ignore these values.
- */
- return;
- case 4:
- dict_set_encoding (dict, "MS_KANJI");
- break;
- case 65000:
- dict_set_encoding (dict, "UTF-7");
- break;
- case 65001:
- dict_set_encoding (dict, "UTF-8");
- break;
- default:
- {
- char enc[100];
- snprintf (enc, 100, "CP%d", character_code);
- dict_set_encoding (dict, enc);
- }
- break;
- };
+ int codepage = parse_int (r, ext_integer->data, 7 * 4);
+ const char *encoding;
+
+ switch (codepage)
+ {
+ case 1:
+ return "EBCDIC-US";
+
+ case 2:
+ case 3:
+ /* These ostensibly mean "7-bit ASCII" and "8-bit ASCII"[sic]
+ respectively. However, there are known to be many files in the wild
+ with character code 2, yet have data which are clearly not ASCII.
+ Therefore we ignore these values. */
+ break;
+
+ case 4:
+ return "MS_KANJI";
+
+ default:
+ encoding = sys_get_encoding_from_codepage (codepage);
+ if (encoding != NULL)
+ return encoding;
+ break;
+ }
}
+
+ /* If the file magic number is EBCDIC then its character data is too. */
+ if (!strcmp (header->magic, EBCDIC_MAGIC))
+ return "EBCDIC-US";
+
+ return locale_charset ();
}
-/* Read record type 7, subtype 4. */
+/* Parses record type 7, subtype 4. */
static void
-read_machine_float_info (struct sfm_reader *r, size_t size, size_t count)
+parse_machine_float_info (struct sfm_reader *r,
+ const struct sfm_extension_record *record)
{
- double sysmis = read_float (r);
- double highest = read_float (r);
- double lowest = read_float (r);
-
- if (size != 8 || count != 3)
- sys_error (r, _("Bad size (%zu) or count (%zu) on extension 4."),
- size, count);
+ double sysmis = parse_float (r, record->data, 0);
+ double highest = parse_float (r, record->data, 8);
+ double lowest = parse_float (r, record->data, 16);
if (sysmis != SYSMIS)
- sys_warn (r, _("File specifies unexpected value %g as %s."),
- sysmis, "SYSMIS");
+ sys_warn (r, record->pos,
+ _("File specifies unexpected value %g (%a) as %s, "
+ "instead of %g (%a)."),
+ sysmis, sysmis, "SYSMIS", SYSMIS, SYSMIS);
if (highest != HIGHEST)
- sys_warn (r, _("File specifies unexpected value %g as %s."),
- highest, "HIGHEST");
+ sys_warn (r, record->pos,
+ _("File specifies unexpected value %g (%a) as %s, "
+ "instead of %g (%a)."),
+ highest, highest, "HIGHEST", HIGHEST, HIGHEST);
+
+ /* SPSS before version 21 used a unique value just bigger than SYSMIS as
+ LOWEST. SPSS 21 uses SYSMIS for LOWEST, which is OK because LOWEST only
+ appears in a context (missing values) where SYSMIS cannot. */
+ if (lowest != LOWEST && lowest != SYSMIS)
+ sys_warn (r, record->pos,
+ _("File specifies unexpected value %g (%a) as %s, "
+ "instead of %g (%a) or %g (%a)."),
+ lowest, lowest, "LOWEST", LOWEST, LOWEST, SYSMIS, SYSMIS);
+}
+
+/* Parses record type 7, subtype 10. */
+static void
+parse_extra_product_info (struct sfm_reader *r,
+ const struct sfm_extension_record *record,
+ struct sfm_read_info *info)
+{
+ struct text_record *text;
- if (lowest != LOWEST)
- sys_warn (r, _("File specifies unexpected value %g as %s."),
- lowest, "LOWEST");
+ text = open_text_record (r, record, true);
+ info->product_ext = fix_line_ends (text_get_all (text));
+ close_text_record (r, text);
}
-/* Read record type 7, subtype 7 or 19. */
+/* Parses record type 7, subtype 7 or 19. */
static void
-read_mrsets (struct sfm_reader *r, size_t size, size_t count,
- struct dictionary *dict)
+parse_mrsets (struct sfm_reader *r, const struct sfm_extension_record *record,
+ struct dictionary *dict)
{
struct text_record *text;
struct mrset *mrset;
- text = open_text_record (r, size * count);
+ text = open_text_record (r, record, false);
for (;;)
{
- const char *name, *label, *counted;
+ const char *counted = NULL;
+ const char *name;
+ const char *label;
struct stringi_set var_names;
size_t allocated_vars;
char delimiter;
name = text_get_token (text, ss_cstr ("="), NULL);
if (name == NULL)
break;
- mrset->name = xstrdup (name);
+ mrset->name = recode_string ("UTF-8", r->encoding, name, -1);
+
+ if (mrset->name[0] != '$')
+ {
+ sys_warn (r, record->pos,
+ _("`%s' does not begin with `$' at offset %zu "
+ "in MRSETS record."), mrset->name, text_pos (text));
+ break;
+ }
if (text_match (text, 'C'))
{
mrset->type = MRSET_MC;
if (!text_match (text, ' '))
{
- sys_warn (r, _("Missing space following 'C' at offset %zu "
- "in MRSETS record"), text_pos (text));
+ sys_warn (r, record->pos,
+ _("Missing space following `%c' at offset %zu "
+ "in MRSETS record."), 'C', text_pos (text));
break;
}
}
mrset->cat_source = MRSET_COUNTEDVALUES;
if (!text_match (text, ' '))
{
- sys_warn (r, _("Missing space following 'E' at offset %zu "
- "in MRSETS record"), text_pos (text));
+ sys_warn (r, record->pos,
+ _("Missing space following `%c' at offset %zu "
+ "in MRSETS record."), 'E', text_pos (text));
break;
}
if (!strcmp (number, "11"))
mrset->label_from_var_label = true;
else if (strcmp (number, "1"))
- sys_warn (r, _("Unexpected label source value \"%s\" "
- "following 'E' at offset %zu in MRSETS record"),
+ sys_warn (r, record->pos,
+ _("Unexpected label source value `%s' following `E' "
+ "at offset %zu in MRSETS record."),
number, text_pos (text));
}
else
{
- sys_warn (r, _("Missing 'C', 'D', or 'E' at offset %zu "
- "in MRSETS record."),
+ sys_warn (r, record->pos,
+ _("Missing `C', `D', or `E' at offset %zu "
+ "in MRSETS record."),
text_pos (text));
break;
}
label = text_parse_counted_string (r, text);
if (label == NULL)
break;
- mrset->label = label[0] != '\0' ? xstrdup (label) : NULL;
+ if (label[0] != '\0')
+ mrset->label = recode_string ("UTF-8", r->encoding, label, -1);
stringi_set_init (&var_names);
allocated_vars = 0;
width = INT_MAX;
do
{
+ const char *raw_var_name;
struct variable *var;
- const char *var_name;
+ char *var_name;
- var_name = text_get_token (text, ss_cstr (" \n"), &delimiter);
- if (var_name == NULL)
+ raw_var_name = text_get_token (text, ss_cstr (" \n"), &delimiter);
+ if (raw_var_name == NULL)
{
- sys_warn (r, _("Missing new-line parsing variable names "
- "at offset %zu in MRSETS record."),
+ sys_warn (r, record->pos,
+ _("Missing new-line parsing variable names "
+ "at offset %zu in MRSETS record."),
text_pos (text));
break;
}
+ var_name = recode_string ("UTF-8", r->encoding, raw_var_name, -1);
- var = lookup_var_by_short_name (dict, var_name);
+ var = dict_lookup_var (dict, var_name);
if (var == NULL)
- continue;
+ {
+ free (var_name);
+ continue;
+ }
if (!stringi_set_insert (&var_names, var_name))
{
- sys_warn (r, _("Duplicate variable name %s "
- "at offset %zu in MRSETS record."),
+ sys_warn (r, record->pos,
+ _("Duplicate variable name %s "
+ "at offset %zu in MRSETS record."),
var_name, text_pos (text));
+ free (var_name);
continue;
}
+ free (var_name);
if (mrset->label == NULL && mrset->label_from_var_label
&& var_has_label (var))
if (mrset->n_vars
&& var_get_type (var) != var_get_type (mrset->vars[0]))
{
- sys_warn (r, _("MRSET %s contains both string and "
- "numeric variables."), name);
+ sys_warn (r, record->pos,
+ _("MRSET %s contains both string and "
+ "numeric variables."), name);
continue;
}
width = MIN (width, var_get_width (var));
if (mrset->n_vars < 2)
{
- sys_warn (r, _("MRSET %s has only %zu variables."), mrset->name,
+ sys_warn (r, record->pos,
+ _("MRSET %s has only %zu variables."), mrset->name,
mrset->n_vars);
mrset_destroy (mrset);
+ stringi_set_destroy (&var_names);
continue;
}
mrset->width = width;
value_init (&mrset->counted, width);
if (width == 0)
- mrset->counted.f = strtod (counted, NULL);
+ mrset->counted.f = c_strtod (counted, NULL);
else
value_copy_str_rpad (&mrset->counted, width,
(const uint8_t *) counted, ' ');
dict_add_mrset (dict, mrset);
mrset = NULL;
+ stringi_set_destroy (&var_names);
}
mrset_destroy (mrset);
close_text_record (r, text);
/* Read record type 7, subtype 11, which specifies how variables
should be displayed in GUI environments. */
static void
-read_display_parameters (struct sfm_reader *r, size_t size, size_t count,
+parse_display_parameters (struct sfm_reader *r,
+ const struct sfm_extension_record *record,
struct dictionary *dict)
{
- size_t n_vars;
bool includes_width;
bool warned = false;
+ size_t n_vars;
+ size_t ofs;
size_t i;
- if (size != 4)
- {
- sys_warn (r, _("Bad size %zu on extension 11."), size);
- skip_bytes (r, size * count);
- return;
- }
-
n_vars = dict_get_var_cnt (dict);
- if (count == 3 * n_vars)
+ if (record->count == 3 * n_vars)
includes_width = true;
- else if (count == 2 * n_vars)
+ else if (record->count == 2 * n_vars)
includes_width = false;
else
{
- sys_warn (r, _("Extension 11 has bad count %zu (for %zu variables)."),
- count, n_vars);
- skip_bytes (r, size * count);
+ sys_warn (r, record->pos,
+ _("Extension 11 has bad count %zu (for %zu variables)."),
+ record->count, n_vars);
return;
}
+ ofs = 0;
for (i = 0; i < n_vars; ++i)
{
struct variable *v = dict_get_var (dict, i);
- int measure = read_int (r);
- int width = includes_width ? read_int (r) : 0;
- int align = read_int (r);
+ int measure, width, align;
- /* SPSS 14 sometimes seems to set string variables' measure
- to zero. */
- if (0 == measure && var_is_alpha (v))
+ measure = parse_int (r, record->data, ofs);
+ ofs += 4;
+
+ if (includes_width)
+ {
+ width = parse_int (r, record->data, ofs);
+ ofs += 4;
+ }
+ else
+ width = 0;
+
+ align = parse_int (r, record->data, ofs);
+ ofs += 4;
+
+ /* SPSS sometimes seems to set variables' measure to zero. */
+ if (0 == measure)
measure = 1;
if (measure < 1 || measure > 3 || align < 0 || align > 2)
{
if (!warned)
- sys_warn (r, _("Invalid variable display parameters "
- "for variable %zu (%s). "
- "Default parameters substituted."),
+ sys_warn (r, record->pos,
+ _("Invalid variable display parameters for variable "
+ "%zu (%s). Default parameters substituted."),
i, var_get_name (v));
warned = true;
continue;
}
}
-/* Reads record type 7, subtype 13, which gives the long name
- that corresponds to each short name. Modifies variable names
- in DICT accordingly. */
static void
-read_long_var_name_map (struct sfm_reader *r, size_t size, size_t count,
- struct dictionary *dict)
+rename_var_and_save_short_names (struct dictionary *dict, struct variable *var,
+ const char *new_name)
+{
+ size_t n_short_names;
+ char **short_names;
+ size_t i;
+
+ /* Renaming a variable may clear its short names, but we
+ want to retain them, so we save them and re-set them
+ afterward. */
+ n_short_names = var_get_short_name_cnt (var);
+ short_names = xnmalloc (n_short_names, sizeof *short_names);
+ for (i = 0; i < n_short_names; i++)
+ {
+ const char *s = var_get_short_name (var, i);
+ short_names[i] = s != NULL ? xstrdup (s) : NULL;
+ }
+
+ /* Set long name. */
+ dict_rename_var (dict, var, new_name);
+
+ /* Restore short names. */
+ for (i = 0; i < n_short_names; i++)
+ {
+ var_set_short_name (var, i, short_names[i]);
+ free (short_names[i]);
+ }
+ free (short_names);
+}
+
+/* Parses record type 7, subtype 13, which gives the long name that corresponds
+ to each short name. Modifies variable names in DICT accordingly. */
+static void
+parse_long_var_name_map (struct sfm_reader *r,
+ const struct sfm_extension_record *record,
+ struct dictionary *dict)
{
struct text_record *text;
struct variable *var;
char *long_name;
- text = open_text_record (r, size * count);
- while (read_variable_to_value_pair (r, dict, text, &var, &long_name))
+ if (record == NULL)
{
- char **short_names;
- size_t short_name_cnt;
+ /* There are no long variable names. Use the short variable names,
+ converted to lowercase, as the long variable names. */
size_t i;
+ for (i = 0; i < dict_get_var_cnt (dict); i++)
+ {
+ struct variable *var = dict_get_var (dict, i);
+ char *new_name;
+
+ new_name = utf8_to_lower (var_get_name (var));
+ rename_var_and_save_short_names (dict, var, new_name);
+ free (new_name);
+ }
+
+ return;
+ }
+
+ /* Rename each of the variables, one by one. (In a correctly constructed
+ system file, this cannot create any intermediate duplicate variable names,
+ because all of the new variable names are longer than any of the old
+ variable names and thus there cannot be any overlaps.) */
+ text = open_text_record (r, record, true);
+ while (read_variable_to_value_pair (r, dict, text, &var, &long_name))
+ {
/* Validate long name. */
- if (!var_is_valid_name (long_name, false))
+ if (!dict_id_is_valid (dict, long_name, false))
{
- sys_warn (r, _("Long variable mapping from %s to invalid "
- "variable name `%s'."),
+ sys_warn (r, record->pos,
+ _("Long variable mapping from %s to invalid "
+ "variable name `%s'."),
var_get_name (var), long_name);
continue;
}
/* Identify any duplicates. */
- if (strcasecmp (var_get_short_name (var, 0), long_name)
+ if (utf8_strcasecmp (var_get_short_name (var, 0), long_name)
&& dict_lookup_var (dict, long_name) != NULL)
{
- sys_warn (r, _("Duplicate long variable name `%s' "
- "within system file."), long_name);
+ sys_warn (r, record->pos,
+ _("Duplicate long variable name `%s'."), long_name);
continue;
}
- /* Renaming a variable may clear its short names, but we
- want to retain them, so we save them and re-set them
- afterward. */
- short_name_cnt = var_get_short_name_cnt (var);
- short_names = xnmalloc (short_name_cnt, sizeof *short_names);
- for (i = 0; i < short_name_cnt; i++)
- {
- const char *s = var_get_short_name (var, i);
- short_names[i] = s != NULL ? xstrdup (s) : NULL;
- }
-
- /* Set long name. */
- dict_rename_var (dict, var, long_name);
-
- /* Restore short names. */
- for (i = 0; i < short_name_cnt; i++)
- {
- var_set_short_name (var, i, short_names[i]);
- free (short_names[i]);
- }
- free (short_names);
+ rename_var_and_save_short_names (dict, var, long_name);
}
close_text_record (r, text);
- r->has_long_var_names = true;
}
/* Reads record type 7, subtype 14, which gives the real length
of each very long string. Rearranges DICT accordingly. */
static void
-read_long_string_map (struct sfm_reader *r, size_t size, size_t count,
- struct dictionary *dict)
+parse_long_string_map (struct sfm_reader *r,
+ const struct sfm_extension_record *record,
+ struct dictionary *dict)
{
struct text_record *text;
struct variable *var;
char *length_s;
- text = open_text_record (r, size * count);
+ text = open_text_record (r, record, true);
while (read_variable_to_value_pair (r, dict, text, &var, &length_s))
{
size_t idx = var_get_dict_index (var);
length = strtol (length_s, NULL, 10);
if (length < 1 || length > MAX_STRING)
{
- sys_warn (r, _("%s listed as string of invalid length %s "
- "in very length string record."),
+ sys_warn (r, record->pos,
+ _("%s listed as string of invalid length %s "
+ "in very long string record."),
var_get_name (var), length_s);
continue;
}
segment_cnt = sfm_width_to_segments (length);
if (segment_cnt == 1)
{
- sys_warn (r, _("%s listed in very long string record with width %s, "
- "which requires only one segment."),
+ sys_warn (r, record->pos,
+ _("%s listed in very long string record with width %s, "
+ "which requires only one segment."),
var_get_name (var), length_s);
continue;
}
if (idx + segment_cnt > dict_get_var_cnt (dict))
- sys_error (r, _("Very long string %s overflows dictionary."),
+ sys_error (r, record->pos,
+ _("Very long string %s overflows dictionary."),
var_get_name (var));
/* Get the short names from the segments and check their
if (i > 0)
var_set_short_name (var, i, var_get_short_name (seg, 0));
if (ROUND_UP (width, 8) != ROUND_UP (alloc_width, 8))
- sys_error (r, _("Very long string with width %ld has segment %d "
- "of width %d (expected %d)"),
+ sys_error (r, record->pos,
+ _("Very long string with width %ld has segment %d "
+ "of width %d (expected %d)."),
length, i, width, alloc_width);
}
dict_delete_consecutive_vars (dict, idx + 1, segment_cnt - 1);
dict_compact_values (dict);
}
-/* Reads value labels from sysfile H and inserts them into the
- associated dictionary. */
static void
-read_value_labels (struct sfm_reader *r,
- struct dictionary *dict, struct variable **var_by_value_idx)
+parse_value_labels (struct sfm_reader *r, struct dictionary *dict,
+ const struct sfm_var_record *var_recs, size_t n_var_recs,
+ const struct sfm_value_label_record *record)
{
- struct pool *subpool;
+ struct variable **vars;
+ char **utf8_labels;
+ size_t i;
- struct label
+ utf8_labels = pool_nmalloc (r->pool, record->n_labels, sizeof *utf8_labels);
+ for (i = 0; i < record->n_labels; i++)
+ utf8_labels[i] = recode_string_pool ("UTF-8", dict_get_encoding (dict),
+ record->labels[i].label, -1,
+ r->pool);
+
+ vars = pool_nmalloc (r->pool, record->n_vars, sizeof *vars);
+ for (i = 0; i < record->n_vars; i++)
+ vars[i] = lookup_var_by_index (r, record->pos,
+ var_recs, n_var_recs, record->vars[i]);
+
+ for (i = 1; i < record->n_vars; i++)
+ if (var_get_type (vars[i]) != var_get_type (vars[0]))
+ sys_error (r, record->pos,
+ _("Variables associated with value label are not all of "
+ "identical type. Variable %s is %s, but variable "
+ "%s is %s."),
+ var_get_name (vars[0]),
+ var_is_numeric (vars[0]) ? _("numeric") : _("string"),
+ var_get_name (vars[i]),
+ var_is_numeric (vars[i]) ? _("numeric") : _("string"));
+
+ for (i = 0; i < record->n_vars; i++)
{
- uint8_t raw_value[8]; /* Value as uninterpreted bytes. */
- union value value; /* Value. */
- char *label; /* Null-terminated label string. */
- };
-
- struct label *labels = NULL;
- int label_cnt; /* Number of labels. */
-
- struct variable **var = NULL; /* Associated variables. */
- int var_cnt; /* Number of associated variables. */
- int max_width; /* Maximum width of string variables. */
-
- int i;
-
- subpool = pool_create_subpool (r->pool);
-
- /* Read the type 3 record and record its contents. We can't do
- much with the data yet because we don't know whether it is
- of numeric or string type. */
-
- /* Read number of labels. */
- label_cnt = read_int (r);
+ struct variable *var = vars[i];
+ int width;
+ size_t j;
- if (size_overflow_p (xtimes (label_cnt, sizeof *labels)))
- {
- sys_warn (r, _("Invalid number of labels: %d. Ignoring labels."),
- label_cnt);
- label_cnt = 0;
- }
+ width = var_get_width (var);
+ if (width > 8)
+ sys_error (r, record->pos,
+ _("Value labels may not be added to long string "
+ "variables (e.g. %s) using records types 3 and 4."),
+ var_get_name (var));
- /* Read each value/label tuple into labels[]. */
- labels = pool_nalloc (subpool, label_cnt, sizeof *labels);
- for (i = 0; i < label_cnt; i++)
- {
- struct label *label = labels + i;
- unsigned char label_len;
- size_t padded_len;
+ for (j = 0; j < record->n_labels; j++)
+ {
+ struct sfm_value_label *label = &record->labels[j];
+ union value value;
- /* Read value. */
- read_bytes (r, label->raw_value, sizeof label->raw_value);
+ value_init (&value, width);
+ if (width == 0)
+ value.f = parse_float (r, label->value, 0);
+ else
+ memcpy (value_str_rw (&value, width), label->value, width);
- /* Read label length. */
- read_bytes (r, &label_len, sizeof label_len);
- padded_len = ROUND_UP (label_len + 1, 8);
+ if (!var_add_value_label (var, &value, utf8_labels[j]))
+ {
+ if (var_is_numeric (var))
+ sys_warn (r, record->pos,
+ _("Duplicate value label for %g on %s."),
+ value.f, var_get_name (var));
+ else
+ sys_warn (r, record->pos,
+ _("Duplicate value label for `%.*s' on %s."),
+ width, value_str (&value, width),
+ var_get_name (var));
+ }
- /* Read label, padding. */
- label->label = pool_alloc (subpool, padded_len + 1);
- read_bytes (r, label->label, padded_len - 1);
- label->label[label_len] = 0;
+ value_destroy (&value, width);
+ }
}
- /* Now, read the type 4 record that has the list of variables
- to which the value labels are to be applied. */
-
- /* Read record type of type 4 record. */
- if (read_int (r) != 4)
- sys_error (r, _("Variable index record (type 4) does not immediately "
- "follow value label record (type 3) as it should."));
+ pool_free (r->pool, vars);
+ for (i = 0; i < record->n_labels; i++)
+ pool_free (r->pool, utf8_labels[i]);
+ pool_free (r->pool, utf8_labels);
+}
- /* Read number of variables associated with value label from type 4
- record. */
- var_cnt = read_int (r);
- if (var_cnt < 1 || var_cnt > dict_get_var_cnt (dict))
- sys_error (r, _("Number of variables associated with a value label (%d) "
- "is not between 1 and the number of variables (%zu)."),
- var_cnt, dict_get_var_cnt (dict));
-
- /* Read the list of variables. */
- var = pool_nalloc (subpool, var_cnt, sizeof *var);
- max_width = 0;
- for (i = 0; i < var_cnt; i++)
- {
- var[i] = lookup_var_by_value_idx (r, var_by_value_idx, read_int (r));
- if (var_get_width (var[i]) > 8)
- sys_error (r, _("Value labels may not be added to long string "
- "variables (e.g. %s) using records types 3 and 4."),
- var_get_name (var[i]));
- max_width = MAX (max_width, var_get_width (var[i]));
- }
+static struct variable *
+lookup_var_by_index (struct sfm_reader *r, off_t offset,
+ const struct sfm_var_record *var_recs, size_t n_var_recs,
+ int idx)
+{
+ const struct sfm_var_record *rec;
- /* Type check the variables. */
- for (i = 1; i < var_cnt; i++)
- if (var_get_type (var[i]) != var_get_type (var[0]))
- sys_error (r, _("Variables associated with value label are not all of "
- "identical type. Variable %s is %s, but variable "
- "%s is %s."),
- var_get_name (var[0]),
- var_is_numeric (var[0]) ? _("numeric") : _("string"),
- var_get_name (var[i]),
- var_is_numeric (var[i]) ? _("numeric") : _("string"));
-
- /* Fill in labels[].value, now that we know the desired type. */
- for (i = 0; i < label_cnt; i++)
+ if (idx < 1 || idx > n_var_recs)
{
- struct label *label = labels + i;
-
- value_init_pool (subpool, &label->value, max_width);
- if (var_is_alpha (var[0]))
- u8_buf_copy_rpad (value_str_rw (&label->value, max_width), max_width,
- label->raw_value, sizeof label->raw_value, ' ');
- else
- label->value.f = float_get_double (r->float_format, label->raw_value);
+ sys_error (r, offset,
+ _("Variable index %d not in valid range 1...%zu."),
+ idx, n_var_recs);
+ return NULL;
}
- /* Assign the `value_label's to each variable. */
- for (i = 0; i < var_cnt; i++)
+ rec = &var_recs[idx - 1];
+ if (rec->var == NULL)
{
- struct variable *v = var[i];
- int j;
-
- /* Add each label to the variable. */
- for (j = 0; j < label_cnt; j++)
- {
- struct label *label = &labels[j];
- if (!var_add_value_label (v, &label->value, label->label))
- {
- if (var_is_numeric (var[0]))
- sys_warn (r, _("Duplicate value label for %g on %s."),
- label->value.f, var_get_name (v));
- else
- sys_warn (r, _("Duplicate value label for \"%.*s\" on %s."),
- max_width, value_str (&label->value, max_width),
- var_get_name (v));
- }
- }
+ sys_error (r, offset,
+ _("Variable index %d refers to long string continuation."),
+ idx);
+ return NULL;
}
- pool_destroy (subpool);
+ return rec->var;
}
-/* Reads a set of custom attributes from TEXT into ATTRS.
+/* Parses a set of custom attributes from TEXT into ATTRS.
ATTRS may be a null pointer, in which case the attributes are
read but discarded. */
static void
-read_attributes (struct sfm_reader *r, struct text_record *text,
- struct attrset *attrs)
+parse_attributes (struct sfm_reader *r, struct text_record *text,
+ struct attrset *attrs)
{
do
{
value = text_get_token (text, ss_cstr ("\n"), NULL);
if (value == NULL)
{
- text_warn (r, text, _("Error parsing attribute value %s[%d]"),
+ text_warn (r, text, _("Error parsing attribute value %s[%d]."),
key, index);
break;
}
else
{
text_warn (r, text,
- _("Attribute value %s[%d] is not quoted: %s"),
+ _("Attribute value %s[%d] is not quoted: %s."),
key, index, value);
attribute_add_value (attr, value);
}
/* Reads record type 7, subtype 17, which lists custom
attributes on the data file. */
static void
-read_data_file_attributes (struct sfm_reader *r,
- size_t size, size_t count,
+parse_data_file_attributes (struct sfm_reader *r,
+ const struct sfm_extension_record *record,
+ struct dictionary *dict)
+{
+ struct text_record *text = open_text_record (r, record, true);
+ parse_attributes (r, text, dict_get_attributes (dict));
+ close_text_record (r, text);
+}
+
+/* Parses record type 7, subtype 18, which lists custom
+ attributes on individual variables. */
+static void
+parse_variable_attributes (struct sfm_reader *r,
+ const struct sfm_extension_record *record,
struct dictionary *dict)
{
- struct text_record *text = open_text_record (r, size * count);
- read_attributes (r, text, dict_get_attributes (dict));
+ struct text_record *text;
+ struct variable *var;
+
+ text = open_text_record (r, record, true);
+ while (text_read_variable_name (r, dict, text, ss_cstr (":"), &var))
+ parse_attributes (r, text, var != NULL ? var_get_attributes (var) : NULL);
close_text_record (r, text);
}
static void
-skip_long_string_value_labels (struct sfm_reader *r, size_t n_labels)
+assign_variable_roles (struct sfm_reader *r, struct dictionary *dict)
{
+ size_t n_warnings = 0;
size_t i;
- for (i = 0; i < n_labels; i++)
+ for (i = 0; i < dict_get_var_cnt (dict); i++)
{
- size_t value_length, label_length;
+ struct variable *var = dict_get_var (dict, i);
+ struct attrset *attrs = var_get_attributes (var);
+ const struct attribute *attr = attrset_lookup (attrs, "$@Role");
+ if (attr != NULL)
+ {
+ int value = atoi (attribute_get_value (attr, 0));
+ enum var_role role;
+
+ switch (value)
+ {
+ case 0:
+ role = ROLE_INPUT;
+ break;
+
+ case 1:
+ role = ROLE_TARGET;
+ break;
+
+ case 2:
+ role = ROLE_BOTH;
+ break;
- value_length = read_int (r);
- skip_bytes (r, value_length);
- label_length = read_int (r);
- skip_bytes (r, label_length);
+ case 3:
+ role = ROLE_NONE;
+ break;
+
+ case 4:
+ role = ROLE_PARTITION;
+ break;
+
+ case 5:
+ role = ROLE_SPLIT;
+ break;
+
+ default:
+ role = ROLE_INPUT;
+ if (n_warnings++ == 0)
+ sys_warn (r, -1, _("Invalid role for variable %s."),
+ var_get_name (var));
+ }
+
+ var_set_role (var, role);
+ }
}
+
+ if (n_warnings > 1)
+ sys_warn (r, -1, _("%zu other variables had invalid roles."),
+ n_warnings - 1);
+}
+
+static void
+check_overflow (struct sfm_reader *r,
+ const struct sfm_extension_record *record,
+ size_t ofs, size_t length)
+{
+ size_t end = record->size * record->count;
+ if (length >= end || ofs + length > end)
+ sys_error (r, record->pos + end,
+ _("Extension record subtype %d ends unexpectedly."),
+ record->subtype);
}
static void
-read_long_string_value_labels (struct sfm_reader *r,
- size_t size, size_t count,
- struct dictionary *d)
+parse_long_string_value_labels (struct sfm_reader *r,
+ const struct sfm_extension_record *record,
+ struct dictionary *dict)
{
- const off_t start = ftello (r->file);
- while (ftello (r->file) - start < size * count)
+ const char *dict_encoding = dict_get_encoding (dict);
+ size_t end = record->size * record->count;
+ size_t ofs = 0;
+
+ while (ofs < end)
{
- char var_name[VAR_NAME_LEN + 1];
+ char *var_name;
size_t n_labels, i;
- struct variable *v;
+ struct variable *var;
union value value;
int var_name_len;
int width;
- /* Read header. */
- var_name_len = read_int (r);
- if (var_name_len > VAR_NAME_LEN)
- sys_error (r, _("Variable name length in long string value label "
- "record (%d) exceeds %d-byte limit."),
- var_name_len, VAR_NAME_LEN);
- read_string (r, var_name, var_name_len + 1);
- width = read_int (r);
- n_labels = read_int (r);
-
- v = dict_lookup_var (d, var_name);
- if (v == NULL)
+ /* Parse variable name length. */
+ check_overflow (r, record, ofs, 4);
+ var_name_len = parse_int (r, record->data, ofs);
+ ofs += 4;
+
+ /* Parse variable name, width, and number of labels. */
+ check_overflow (r, record, ofs, var_name_len + 8);
+ var_name = recode_string_pool ("UTF-8", dict_encoding,
+ (const char *) record->data + ofs,
+ var_name_len, r->pool);
+ width = parse_int (r, record->data, ofs + var_name_len);
+ n_labels = parse_int (r, record->data, ofs + var_name_len + 4);
+ ofs += var_name_len + 8;
+
+ /* Look up 'var' and validate. */
+ var = dict_lookup_var (dict, var_name);
+ if (var == NULL)
+ sys_warn (r, record->pos + ofs,
+ _("Ignoring long string value label record for "
+ "unknown variable %s."), var_name);
+ else if (var_is_numeric (var))
{
- sys_warn (r, _("Ignoring long string value record for "
- "unknown variable %s."), var_name);
- skip_long_string_value_labels (r, n_labels);
- continue;
- }
- if (var_is_numeric (v))
- {
- sys_warn (r, _("Ignoring long string value record for "
- "numeric variable %s."), var_name);
- skip_long_string_value_labels (r, n_labels);
- continue;
+ sys_warn (r, record->pos + ofs,
+ _("Ignoring long string value label record for "
+ "numeric variable %s."), var_name);
+ var = NULL;
}
- if (width != var_get_width (v))
+ else if (width != var_get_width (var))
{
- sys_warn (r, _("Ignoring long string value record for variable %s "
- "because the record's width (%d) does not match the "
- "variable's width (%d)"),
- var_name, width, var_get_width (v));
- skip_long_string_value_labels (r, n_labels);
- continue;
+ sys_warn (r, record->pos + ofs,
+ _("Ignoring long string value label record for variable "
+ "%s because the record's width (%d) does not match the "
+ "variable's width (%d)."),
+ var_name, width, var_get_width (var));
+ var = NULL;
}
- /* Read values. */
+ /* Parse values. */
value_init_pool (r->pool, &value, width);
for (i = 0; i < n_labels; i++)
{
size_t value_length, label_length;
- char label[256];
- bool skip = false;
+ bool skip = var == NULL;
- /* Read value. */
- value_length = read_int (r);
- if (value_length == width)
- read_bytes (r, value_str_rw (&value, width), width);
- else
+ /* Parse value length. */
+ check_overflow (r, record, ofs, 4);
+ value_length = parse_int (r, record->data, ofs);
+ ofs += 4;
+
+ /* Parse value. */
+ check_overflow (r, record, ofs, value_length);
+ if (!skip)
{
- sys_warn (r, _("Ignoring long string value %zu for variable %s, "
- "with width %d, that has bad value width %zu."),
- i, var_get_name (v), width, value_length);
- skip_bytes (r, value_length);
- skip = true;
+ if (value_length == width)
+ memcpy (value_str_rw (&value, width),
+ (const uint8_t *) record->data + ofs, width);
+ else
+ {
+ sys_warn (r, record->pos + ofs,
+ _("Ignoring long string value label %zu for "
+ "variable %s, with width %d, that has bad value "
+ "width %zu."),
+ i, var_get_name (var), width, value_length);
+ skip = true;
+ }
}
+ ofs += value_length;
- /* Read label. */
- label_length = read_int (r);
- read_string (r, label, MIN (sizeof label, label_length + 1));
- if (label_length >= sizeof label)
+ /* Parse label length. */
+ check_overflow (r, record, ofs, 4);
+ label_length = parse_int (r, record->data, ofs);
+ ofs += 4;
+
+ /* Parse label. */
+ check_overflow (r, record, ofs, label_length);
+ if (!skip)
{
- /* Skip and silently ignore label text after the
- first 255 bytes. The maximum documented length
- of a label is 120 bytes so this is more than
- generous. */
- skip_bytes (r, sizeof label - (label_length + 1));
+ char *label;
+
+ label = recode_string_pool ("UTF-8", dict_encoding,
+ (const char *) record->data + ofs,
+ label_length, r->pool);
+ if (!var_add_value_label (var, &value, label))
+ sys_warn (r, record->pos + ofs,
+ _("Duplicate value label for `%.*s' on %s."),
+ width, value_str (&value, width),
+ var_get_name (var));
+ pool_free (r->pool, label);
}
-
- if (!skip && !var_add_value_label (v, &value, label))
- sys_warn (r, _("Duplicate value label for \"%.*s\" on %s."),
- width, value_str (&value, width), var_get_name (v));
+ ofs += label_length;
}
}
}
-
-/* Reads record type 7, subtype 18, which lists custom
- attributes on individual variables. */
static void
-read_variable_attributes (struct sfm_reader *r,
- size_t size, size_t count,
- struct dictionary *dict)
+parse_long_string_missing_values (struct sfm_reader *r,
+ const struct sfm_extension_record *record,
+ struct dictionary *dict)
{
- struct text_record *text = open_text_record (r, size * count);
- for (;;)
+ const char *dict_encoding = dict_get_encoding (dict);
+ size_t end = record->size * record->count;
+ size_t ofs = 0;
+
+ while (ofs < end)
{
+ struct missing_values mv;
+ char *var_name;
struct variable *var;
- if (!text_read_short_name (r, dict, text, ss_cstr (":"), &var))
- break;
- read_attributes (r, text, var != NULL ? var_get_attributes (var) : NULL);
+ int n_missing_values;
+ int var_name_len;
+ size_t i;
+
+ /* Parse variable name length. */
+ check_overflow (r, record, ofs, 4);
+ var_name_len = parse_int (r, record->data, ofs);
+ ofs += 4;
+
+ /* Parse variable name. */
+ check_overflow (r, record, ofs, var_name_len + 1);
+ var_name = recode_string_pool ("UTF-8", dict_encoding,
+ (const char *) record->data + ofs,
+ var_name_len, r->pool);
+ ofs += var_name_len;
+
+ /* Parse number of missing values. */
+ n_missing_values = ((const uint8_t *) record->data)[ofs];
+ if (n_missing_values < 1 || n_missing_values > 3)
+ sys_warn (r, record->pos + ofs,
+ _("Long string missing values record says variable %s "
+ "has %d missing values, but only 1 to 3 missing values "
+ "are allowed."),
+ var_name, n_missing_values);
+ ofs++;
+
+ /* Look up 'var' and validate. */
+ var = dict_lookup_var (dict, var_name);
+ if (var == NULL)
+ sys_warn (r, record->pos + ofs,
+ _("Ignoring long string missing value record for "
+ "unknown variable %s."), var_name);
+ else if (var_is_numeric (var))
+ {
+ sys_warn (r, record->pos + ofs,
+ _("Ignoring long string missing value record for "
+ "numeric variable %s."), var_name);
+ var = NULL;
+ }
+
+ /* Parse values. */
+ mv_init_pool (r->pool, &mv, var ? var_get_width (var) : 8);
+ for (i = 0; i < n_missing_values; i++)
+ {
+ size_t value_length;
+
+ /* Parse value length. */
+ check_overflow (r, record, ofs, 4);
+ value_length = parse_int (r, record->data, ofs);
+ ofs += 4;
+
+ /* Parse value. */
+ check_overflow (r, record, ofs, value_length);
+ if (var != NULL
+ && i < 3
+ && !mv_add_str (&mv, (const uint8_t *) record->data + ofs,
+ value_length))
+ sys_warn (r, record->pos + ofs,
+ _("Ignoring long string missing value %zu for variable "
+ "%s, with width %d, that has bad value width %zu."),
+ i, var_get_name (var), var_get_width (var),
+ value_length);
+ ofs += value_length;
+ }
+ if (var != NULL)
+ var_set_missing_values (var, &mv);
}
- close_text_record (r, text);
}
-
\f
/* Case reader. */
return c;
eof:
- case_unref (c);
if (i != 0)
partial_record (r);
if (r->case_cnt != -1)
read_error (reader, r);
+ case_unref (c);
return NULL;
}
static void
partial_record (struct sfm_reader *r)
{
- sys_error (r, _("File ends in partial case."));
+ sys_error (r, r->pos, _("File ends in partial case."));
}
/* Issues an error that an unspecified error occurred SFM, and
if (!r->corruption_warning)
{
r->corruption_warning = true;
- sys_warn (r, _("Possible compressed data corruption: "
- "compressed spaces appear in numeric field."));
+ sys_warn (r, r->pos,
+ _("Possible compressed data corruption: "
+ "compressed spaces appear in numeric field."));
}
break;
else if (!r->corruption_warning)
{
r->corruption_warning = true;
- sys_warn (r, _("Possible compressed data corruption: "
- "string contains compressed integer (opcode %d)"),
+ sys_warn (r, r->pos,
+ _("Possible compressed data corruption: "
+ "string contains compressed integer (opcode %d)."),
opcode);
}
}
return read_whole_strings (r, buffer, length);
}
\f
-/* Creates and returns a table that can be used for translating a value
- index into a case to a "struct variable *" for DICT. Multiple
- system file fields reference variables this way.
-
- This table must be created before processing the very long
- string extension record, because that record causes some
- values to be deleted from the case and the dictionary to be
- compacted. */
-static struct variable **
-make_var_by_value_idx (struct sfm_reader *r, struct dictionary *dict)
-{
- struct variable **var_by_value_idx;
- int value_idx = 0;
- int i;
-
- var_by_value_idx = pool_nmalloc (r->pool,
- r->oct_cnt, sizeof *var_by_value_idx);
- for (i = 0; i < dict_get_var_cnt (dict); i++)
- {
- struct variable *v = dict_get_var (dict, i);
- int nv = var_is_numeric (v) ? 1 : DIV_RND_UP (var_get_width (v), 8);
- int j;
-
- var_by_value_idx[value_idx++] = v;
- for (j = 1; j < nv; j++)
- var_by_value_idx[value_idx++] = NULL;
- }
- assert (value_idx == r->oct_cnt);
-
- return var_by_value_idx;
-}
-
-/* Returns the "struct variable" corresponding to the given
- 1-basd VALUE_IDX in VAR_BY_VALUE_IDX. Verifies that the index
- is valid. */
-static struct variable *
-lookup_var_by_value_idx (struct sfm_reader *r,
- struct variable **var_by_value_idx, int value_idx)
-{
- struct variable *var;
-
- if (value_idx < 1 || value_idx > r->oct_cnt)
- sys_error (r, _("Variable index %d not in valid range 1...%d."),
- value_idx, r->oct_cnt);
-
- var = var_by_value_idx[value_idx - 1];
- if (var == NULL)
- sys_error (r, _("Variable index %d refers to long string "
- "continuation."),
- value_idx);
-
- return var;
-}
-
-/* Returns the variable in D with the given SHORT_NAME,
- or a null pointer if there is none. */
-static struct variable *
-lookup_var_by_short_name (struct dictionary *d, const char *short_name)
-{
- struct variable *var;
- size_t var_cnt;
- size_t i;
-
- /* First try looking up by full name. This often succeeds. */
- var = dict_lookup_var (d, short_name);
- if (var != NULL && !strcasecmp (var_get_short_name (var, 0), short_name))
- return var;
-
- /* Iterate through the whole dictionary as a fallback. */
- var_cnt = dict_get_var_cnt (d);
- for (i = 0; i < var_cnt; i++)
- {
- var = dict_get_var (d, i);
- if (!strcasecmp (var_get_short_name (var, 0), short_name))
- return var;
- }
-
- return NULL;
-}
-\f
/* Helpers for reading records that contain structured text
strings. */
struct text_record
{
struct substring buffer; /* Record contents. */
+ off_t start; /* Starting offset in file. */
size_t pos; /* Current position in buffer. */
int n_warnings; /* Number of warnings issued or suppressed. */
+ bool recoded; /* Recoded into UTF-8? */
};
-/* Reads SIZE bytes into a text record for R,
- and returns the new text record. */
static struct text_record *
-open_text_record (struct sfm_reader *r, size_t size)
+open_text_record (struct sfm_reader *r,
+ const struct sfm_extension_record *record,
+ bool recode_to_utf8)
{
- struct text_record *text = pool_alloc (r->pool, sizeof *text);
- char *buffer = pool_malloc (r->pool, size + 1);
- read_bytes (r, buffer, size);
- text->buffer = ss_buffer (buffer, size);
+ struct text_record *text;
+ struct substring raw;
+
+ text = pool_alloc (r->pool, sizeof *text);
+ raw = ss_buffer (record->data, record->size * record->count);
+ text->start = record->pos;
+ text->buffer = (recode_to_utf8
+ ? recode_substring_pool ("UTF-8", r->encoding, raw, r->pool)
+ : raw);
text->pos = 0;
text->n_warnings = 0;
+ text->recoded = recode_to_utf8;
+
return text;
}
close_text_record (struct sfm_reader *r, struct text_record *text)
{
if (text->n_warnings > MAX_TEXT_WARNINGS)
- sys_warn (r, _("Suppressed %d additional related warnings."),
+ sys_warn (r, -1, _("Suppressed %d additional related warnings."),
text->n_warnings - MAX_TEXT_WARNINGS);
- pool_free (r->pool, ss_data (text->buffer));
+ if (text->recoded)
+ pool_free (r->pool, ss_data (text->buffer));
}
/* Reads a variable=value pair from TEXT.
}
}
+static bool
+text_read_variable_name (struct sfm_reader *r, struct dictionary *dict,
+ struct text_record *text, struct substring delimiters,
+ struct variable **var)
+{
+ char *name;
+
+ name = text_get_token (text, delimiters, NULL);
+ if (name == NULL)
+ return false;
+
+ *var = dict_lookup_var (dict, name);
+ if (*var != NULL)
+ return true;
+
+ text_warn (r, text, _("Dictionary record refers to unknown variable %s."),
+ name);
+ return false;
+}
+
+
static bool
text_read_short_name (struct sfm_reader *r, struct dictionary *dict,
struct text_record *text, struct substring delimiters,
if (short_name == NULL)
return false;
- *var = lookup_var_by_short_name (dict, short_name);
+ *var = dict_lookup_var (dict, short_name);
if (*var == NULL)
text_warn (r, text, _("Dictionary record refers to unknown variable %s."),
short_name);
va_list args;
va_start (args, format);
- sys_msg (r, MW, format, args);
+ sys_msg (r, text->start + text->pos, MW, format, args);
va_end (args);
}
}
start = text->pos;
n = 0;
- for (;;)
+ while (text->pos < text->buffer.length)
{
int c = text->buffer.string[text->pos];
if (c < '0' || c > '9')
n = (n * 10) + (c - '0');
text->pos++;
}
- if (start == text->pos)
+ if (text->pos >= text->buffer.length || start == text->pos)
{
- sys_warn (r, _("Expecting digit at offset %zu in MRSETS record."),
- text->pos);
+ sys_warn (r, text->start,
+ _("Expecting digit at offset %zu in MRSETS record."),
+ text->pos);
return NULL;
}
if (!text_match (text, ' '))
{
- sys_warn (r, _("Expecting space at offset %zu in MRSETS record."),
+ sys_warn (r, text->start,
+ _("Expecting space at offset %zu in MRSETS record."),
text->pos);
return NULL;
}
if (text->pos + n > text->buffer.length)
{
- sys_warn (r, _("%zu-byte string starting at offset %zu "
- "exceeds record length %zu."),
+ sys_warn (r, text->start,
+ _("%zu-byte string starting at offset %zu "
+ "exceeds record length %zu."),
n, text->pos, text->buffer.length);
return NULL;
}
s = &text->buffer.string[text->pos];
if (s[n] != ' ')
{
- sys_warn (r,
+ sys_warn (r, text->start,
_("Expecting space at offset %zu following %zu-byte string."),
text->pos + n, n);
return NULL;
return false;
}
-/* Returns the current byte offset inside the TEXT's string. */
+/* Returns the current byte offset (as converted to UTF-8, if it was converted)
+ inside the TEXT's string. */
static size_t
text_pos (const struct text_record *text)
{
return text->pos;
}
+
+static const char *
+text_get_all (const struct text_record *text)
+{
+ return text->buffer.string;
+}
\f
/* Messages. */
/* Displays a corruption message. */
static void
-sys_msg (struct sfm_reader *r, int class, const char *format, va_list args)
+sys_msg (struct sfm_reader *r, off_t offset,
+ int class, const char *format, va_list args)
{
struct msg m;
struct string text;
ds_init_empty (&text);
- ds_put_format (&text, "\"%s\" near offset 0x%llx: ",
- fh_get_file_name (r->fh), (long long int) ftello (r->file));
+ if (offset >= 0)
+ ds_put_format (&text, _("`%s' near offset 0x%llx: "),
+ fh_get_file_name (r->fh), (long long int) offset);
+ else
+ ds_put_format (&text, _("`%s': "), fh_get_file_name (r->fh));
ds_put_vformat (&text, format, args);
m.category = msg_class_to_category (class);
m.severity = msg_class_to_severity (class);
- m.where.file_name = NULL;
- m.where.line_number = 0;
+ m.file_name = NULL;
+ m.first_line = 0;
+ m.last_line = 0;
+ m.first_column = 0;
+ m.last_column = 0;
m.text = ds_cstr (&text);
msg_emit (&m);
}
-/* Displays a warning for the current file position. */
+/* Displays a warning for offset OFFSET in the file. */
static void
-sys_warn (struct sfm_reader *r, const char *format, ...)
+sys_warn (struct sfm_reader *r, off_t offset, const char *format, ...)
{
va_list args;
va_start (args, format);
- sys_msg (r, MW, format, args);
+ sys_msg (r, offset, MW, format, args);
va_end (args);
}
marks it as in an error state,
and aborts reading it using longjmp. */
static void
-sys_error (struct sfm_reader *r, const char *format, ...)
+sys_error (struct sfm_reader *r, off_t offset, const char *format, ...)
{
va_list args;
va_start (args, format);
- sys_msg (r, ME, format, args);
+ sys_msg (r, offset, ME, format, args);
va_end (args);
r->error = true;
void *buf, size_t byte_cnt)
{
size_t bytes_read = fread (buf, 1, byte_cnt, r->file);
+ r->pos += bytes_read;
if (bytes_read == byte_cnt)
return true;
else if (ferror (r->file))
- sys_error (r, _("System error: %s."), strerror (errno));
+ sys_error (r, r->pos, _("System error: %s."), strerror (errno));
else if (!eof_is_ok || bytes_read != 0)
- sys_error (r, _("Unexpected end of file."));
+ sys_error (r, r->pos, _("Unexpected end of file."));
else
return false;
}
return float_get_double (r->float_format, number);
}
+static int
+parse_int (struct sfm_reader *r, const void *data, size_t ofs)
+{
+ return integer_get (r->integer_format, (const uint8_t *) data + ofs, 4);
+}
+
+static double
+parse_float (struct sfm_reader *r, const void *data, size_t ofs)
+{
+ return float_get_double (r->float_format, (const uint8_t *) data + ofs);
+}
+
/* Reads exactly SIZE - 1 bytes into BUFFER
and stores a null byte into BUFFER[SIZE - 1]. */
static void
bytes -= chunk;
}
}
+
+/* Returns a malloc()'d copy of S in which all lone CRs and CR LF pairs have
+ been replaced by LFs.
+
+ (A product that identifies itself as VOXCO INTERVIEWER 4.3 produces system
+ files that use CR-only line ends in the file label and extra product
+ info.) */
+static char *
+fix_line_ends (const char *s)
+{
+ char *dst, *d;
+
+ d = dst = xmalloc (strlen (s) + 1);
+ while (*s != '\0')
+ {
+ if (*s == '\r')
+ {
+ s++;
+ if (*s == '\n')
+ s++;
+ *d++ = '\n';
+ }
+ else
+ *d++ = *s++;
+ }
+ *d = '\0';
+
+ return dst;
+}
\f
static const struct casereader_class sys_file_casereader_class =
{