* Case Weight Variable Record::
* Variable Records::
* Value Label Records::
+* Portable File Document Record::
* Portable File Data::
@end menu
@node Portable File Characters
@section Portable File Characters
-Portable files are arranged as a series of lines of exactly 80
+Portable files are arranged as a series of lines of 80
characters each. Each line is terminated by a carriage-return,
-line-feed sequence ``new-lines''). New-lines are only used to avoid
+line-feed sequence (``new-lines''). New-lines are only used to avoid
line length limits imposed by some OSes; they are not meaningful.
+Most lines in portable files are exactly 80 characters long. The only
+exception is a line that ends in one or more spaces, in which the
+spaces may optionally be omitted. Thus, a portable file reader must
+act as though a line shorter than 80 characters is padded to that
+length with spaces.
+
The file must be terminated with a @samp{Z} character. In addition, if
the final line in the file does not have exactly 80 characters, then it
is padded on the right with @samp{Z} characters. (The file contents may
@item
Value labels (optional).
+@item
+Documents (optional).
+
@item
Data.
@end itemize
@item
Name (string). 1--8 characters long. Must be in all capitals.
+A few portable files that contain duplicate variable names have been
+spotted in the wild. PSPP handles these by renaming the duplicates
+with numeric extensions: @code{@var{var}_1}, @code{@var{var}_2}, and
+so on.
+
@item
Print format. This is a set of three integer fields:
Number of decimal places. 1--40.
@end itemize
+A few portable files with invalid format types or formats that are not
+of the appropriate width for their variables have been spotted in the
+wild. PSPP assigns a default F or A format to a variable with an
+invalid format.
+
@item
Write format. Same structure as the print format described above.
@end itemize
@item
List of variables (strings). The variable count specifies the number in
the list. Variables are specified by their names. All variables must
-be of the same type (numeric or string).
+be of the same type (numeric or string), but string variables do not
+necessarily have the same width.
@item
Label count (integer).
appropriate to the variables, followed by a label (string).
@end itemize
+A few portable files that specify duplicate value labels, that is, two
+different labels for a single value of a single variable, have been
+spotted in the wild. PSPP uses the last value label specified in
+these cases.
+
+@node Portable File Document Record
+@section Document Record
+
+One document record may optionally follow the value label record. The
+document record consists of tag code @samp{E}, following by the number
+of document lines as an integer, followed by that number of strings,
+each of which represents one document line. Document lines must be 80
+bytes long or shorter.
+
@node Portable File Data
@section Portable File Data
struct file_handle *fh; /* File handle. */
FILE *file; /* File stream. */
+ int line_length; /* Number of characters so far on this line. */
char cc; /* Current character. */
char *trans; /* 256-byte character set translation table. */
int var_cnt; /* Number of variables. */
va_list args;
ds_init_empty (&text);
- ds_put_format (&text, _("portable file %s corrupt at offset %ld: "),
+ ds_put_format (&text, _("portable file %s corrupt at offset 0x%lx: "),
fh_get_file_name (r->fh), ftell (r->file));
va_start (args, msg);
ds_put_vformat (&text, msg, args);
longjmp (r->bail_out, 1);
}
+/* Displays MSG as an warning for the current position in
+ portable file reader R. */
+static void
+warning (struct pfm_reader *r, const char *msg, ...)
+{
+ struct msg m;
+ struct string text;
+ va_list args;
+
+ ds_init_empty (&text);
+ ds_put_format (&text, _("reading portable file %s at offset 0x%lx: "),
+ fh_get_file_name (r->fh), ftell (r->file));
+ va_start (args, msg);
+ ds_put_vformat (&text, msg, args);
+ va_end (args);
+
+ m.category = MSG_GENERAL;
+ m.severity = MSG_WARNING;
+ m.where.file_name = NULL;
+ m.where.line_number = 0;
+ m.text = ds_cstr (&text);
+
+ msg_emit (&m);
+}
+
/* Closes portable file reader R, after we're done with it. */
static void
por_file_casereader_destroy (struct casereader *reader UNUSED, void *r_)
{
int c;
- while ((c = getc (r->file)) == '\r' || c == '\n')
- continue;
+ /* Read the next character from the file.
+ Ignore carriage returns entirely.
+ Mostly ignore new-lines, but if a new-line occurs before the
+ line has reached 80 bytes in length, then treat the
+ "missing" bytes as spaces. */
+ for (;;)
+ {
+ while ((c = getc (r->file)) == '\r')
+ continue;
+ if (c != '\n')
+ break;
+
+ if (r->line_length < 80)
+ {
+ c = ' ';
+ ungetc ('\n', r->file);
+ break;
+ }
+ r->line_length = 0;
+ }
if (c == EOF)
error (r, _("unexpected end of file"));
if (r->trans != NULL)
c = r->trans[c];
r->cc = c;
+ r->line_length++;
}
/* Skip a single character if present, and return whether it was
static void read_version_data (struct pfm_reader *, struct pfm_read_info *);
static void read_variables (struct pfm_reader *, struct dictionary *);
static void read_value_label (struct pfm_reader *, struct dictionary *);
-void dump_dictionary (struct dictionary *);
+static void read_documents (struct pfm_reader *, struct dictionary *);
/* Reads the dictionary from file with handle H, and returns it in a
dictionary structure. This dictionary may be modified in order to
goto error;
r->fh = fh;
r->file = pool_fopen (r->pool, fh_get_file_name (r->fh), "rb");
+ r->line_length = 0;
r->weight_index = -1;
r->trans = NULL;
r->var_cnt = 0;
while (match (r, 'D'))
read_value_label (r, *dict);
+ /* Read documents. */
+ if (match (r, 'E'))
+ read_documents (r, *dict);
+
/* Check that we've made it to the data. */
if (!match (r, 'F'))
error (r, _("Data record expected."));
checking that the format is appropriate for variable V. */
static struct fmt_spec
convert_format (struct pfm_reader *r, const int portable_format[3],
- struct variable *v)
+ struct variable *v, bool *report_error)
{
struct fmt_spec format;
bool ok;
if (!fmt_from_io (portable_format[0], &format.type))
- error (r, _("%s: Bad format specifier byte (%d)."),
- var_get_name (v), portable_format[0]);
+ {
+ if (*report_error)
+ warning (r, _("%s: Bad format specifier byte (%d). Variable "
+ "will be assigned a default format."),
+ var_get_name (v), portable_format[0]);
+ goto assign_default;
+ }
+
format.w = portable_format[1];
format.d = portable_format[2];
if (!ok)
{
- char fmt_string[FMT_STRING_LEN_MAX + 1];
- error (r, _("%s variable %s has invalid format specifier %s."),
- var_is_numeric (v) ? _("Numeric") : _("String"),
- var_get_name (v), fmt_to_string (&format, fmt_string));
- format = fmt_default_for_width (var_get_width (v));
+ if (*report_error)
+ {
+ char fmt_string[FMT_STRING_LEN_MAX + 1];
+ fmt_to_string (&format, fmt_string);
+ if (var_is_numeric (v))
+ warning (r, _("Numeric variable %s has invalid format "
+ "specifier %s."),
+ var_get_name (v), fmt_string);
+ else
+ warning (r, _("String variable %s with width %d has "
+ "invalid format specifier %s."),
+ var_get_name (v), var_get_width (v), fmt_string);
+ }
+ goto assign_default;
}
return format;
+
+assign_default:
+ *report_error = false;
+ return fmt_default_for_width (var_get_width (v));
}
static union value parse_value (struct pfm_reader *, struct variable *);
struct variable *v;
struct missing_values miss;
struct fmt_spec print, write;
+ bool report_error = true;
int j;
if (!match (r, '7'))
fmt[j] = read_int (r);
if (!var_is_valid_name (name, false) || *name == '#' || *name == '$')
- error (r, _("position %d: Invalid variable name `%s'."), i, name);
+ error (r, _("Invalid variable name `%s' in position %d."), name, i);
str_uppercase (name);
if (width < 0 || width > 255)
v = dict_create_var (dict, name, width);
if (v == NULL)
- error (r, _("Duplicate variable name %s."), name);
+ {
+ int i;
+ for (i = 1; i < 100000; i++)
+ {
+ char try_name[LONG_NAME_LEN + 1];
+ sprintf (try_name, "%.*s_%d", LONG_NAME_LEN - 6, name, i);
+ v = dict_create_var (dict, try_name, width);
+ if (v != NULL)
+ break;
+ }
+ if (v == NULL)
+ error (r, _("Duplicate variable name %s in position %d."), name, i);
+ warning (r, _("Duplicate variable name %s in position %d renamed "
+ "to %s."), name, i, var_get_name (v));
+ }
- print = convert_format (r, &fmt[0], v);
- write = convert_format (r, &fmt[3], v);
+ print = convert_format (r, &fmt[0], v, &report_error);
+ write = convert_format (r, &fmt[3], v, &report_error);
var_set_print_format (v, &print);
var_set_write_format (v, &write);
if (v[i] == NULL)
error (r, _("Unknown variable %s while parsing value labels."), name);
- if (var_get_width (v[0]) != var_get_width (v[i]))
+ if (var_get_type (v[0]) != var_get_type (v[i]))
error (r, _("Cannot assign value labels to %s and %s, which "
- "have different variable types or widths."),
+ "have different variable types."),
var_get_name (v[0]), var_get_name (v[i]));
}
val = parse_value (r, v[0]);
read_string (r, label);
- /* Assign the value_label's to each variable. */
+ /* Assign the value label to each variable. */
for (j = 0; j < nv; j++)
{
struct variable *var = v[j];
- if (!var_add_value_label (var, &val, label))
- continue;
-
- if (var_is_numeric (var))
- error (r, _("Duplicate label for value %g for variable %s."),
- val.f, var_get_name (var));
- else
- error (r, _("Duplicate label for value `%.*s' for variable %s."),
- var_get_width (var), val.s, var_get_name (var));
+ if (!var_is_long_string (var))
+ var_replace_value_label (var, &val, label);
}
}
}
+/* Reads a set of documents from portable file R into DICT. */
+static void
+read_documents (struct pfm_reader *r, struct dictionary *dict)
+{
+ int line_cnt;
+ int i;
+
+ line_cnt = read_int (r);
+ for (i = 0; i < line_cnt; i++)
+ {
+ char line[256];
+ read_string (r, line);
+ dict_add_document_line (dict, line);
+ }
+}
+
/* Reads one case from portable file R into C. */
static bool
por_file_casereader_read (struct casereader *reader, void *r_, struct ccase *c)
projects / pspp-builds.git / commitdiff