/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000, 2006, 2007 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2006, 2007, 2009 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 <libpspp/message.h>
#include <libpspp/misc.h>
#include <libpspp/str.h>
+#include <libpspp/i18n.h>
#include <libpspp/version.h>
#include <data/attributes.h>
static const struct casewriter_class sys_file_casewriter_class;
static void write_header (struct sfm_writer *, const struct dictionary *);
-static void write_variable (struct sfm_writer *, const struct variable *);
+static void write_variable (struct sfm_writer *, const struct variable *, const struct dictionary *);
static void write_value_labels (struct sfm_writer *,
- struct variable *, int idx);
+ struct variable *, int idx, const struct dictionary *);
static void write_integer_info_record (struct sfm_writer *);
static void write_float_info_record (struct sfm_writer *);
static void write_longvar_table (struct sfm_writer *w,
const struct dictionary *dict);
+static void write_encoding_record (struct sfm_writer *w,
+ const struct dictionary *);
+
static void write_vls_length_table (struct sfm_writer *w,
const struct dictionary *dict);
+static void write_long_string_value_labels (struct sfm_writer *,
+ const struct dictionary *);
static void write_variable_display_parameters (struct sfm_writer *w,
const struct dictionary *dict);
static void write_spaces (struct sfm_writer *, size_t);
static void write_value (struct sfm_writer *, const union value *, int width);
-static void write_case_uncompressed (struct sfm_writer *, struct ccase *);
-static void write_case_compressed (struct sfm_writer *, struct ccase *);
+static void write_case_uncompressed (struct sfm_writer *,
+ const struct ccase *);
+static void write_case_compressed (struct sfm_writer *, const struct ccase *);
static void flush_compressed (struct sfm_writer *);
static void put_cmp_opcode (struct sfm_writer *, uint8_t);
static void put_cmp_number (struct sfm_writer *, double);
/* Write basic variable info. */
short_names_assign (d);
for (i = 0; i < dict_get_var_cnt (d); i++)
- write_variable (w, dict_get_var (d, i));
+ write_variable (w, dict_get_var (d, i), d);
/* Write out value labels. */
idx = 0;
{
struct variable *v = dict_get_var (d, i);
- write_value_labels (w, v, idx);
+ write_value_labels (w, v, idx, d);
idx += sfm_width_to_octs (var_get_width (v));
}
write_vls_length_table (w, d);
+ write_long_string_value_labels (w, d);
+
if (attrset_count (dict_get_attributes (d)))
write_data_file_attributes (w, d);
write_variable_attributes (w, d);
+ write_encoding_record (w, d);
+
/* Write end-of-headers record. */
write_int (w, 999);
write_int (w, 0);
return NULL;
}
- return casewriter_create (dict_get_next_value_idx (d),
- &sys_file_casewriter_class, w);
+ return casewriter_create (dict_get_proto (d), &sys_file_casewriter_class, w);
error:
close_writer (w);
/* Write the variable record(s) for variable V to system file
W. */
static void
-write_variable (struct sfm_writer *w, const struct variable *v)
+write_variable (struct sfm_writer *w, const struct variable *v, const struct dictionary *dict)
{
int width = var_get_width (v);
int segment_cnt = sfm_width_to_segments (width);
int seg0_width = sfm_segment_alloc_width (width, 0);
- const struct missing_values *mv = var_get_missing_values (v);
+ struct missing_values mv;
int i;
/* Record type. */
/* Number of missing values. If there is a range, then the
range counts as 2 missing values and causes the number to be
negated. */
- write_int (w, mv_has_range (mv) ? -2 - mv_n_values (mv) : mv_n_values (mv));
+ mv_copy (&mv, var_get_missing_values (v));
+ if (mv_get_width (&mv) > 8)
+ mv_resize (&mv, 8);
+ if (mv_has_range (&mv))
+ write_int (w, -2 - mv_n_values (&mv));
+ else
+ write_int (w, mv_n_values (&mv));
/* Print and write formats. */
write_format (w, *var_get_print_format (v), seg0_width);
if (var_has_label (v))
{
const char *label = var_get_label (v);
- size_t padded_len = ROUND_UP (MIN (strlen (label), 255), 4);
+ char *l = recode_string (dict_get_encoding (dict), UTF8, label, -1);
+ size_t padded_len = ROUND_UP (MIN (strlen (l), 255), 4);
write_int (w, padded_len);
- write_string (w, label, padded_len);
+ write_string (w, l, padded_len);
+ free (l);
}
/* Write the missing values, if any, range first. */
- if (mv_has_range (mv))
+ if (mv_has_range (&mv))
{
double x, y;
- mv_get_range (mv, &x, &y);
+ mv_get_range (&mv, &x, &y);
write_float (w, x);
write_float (w, y);
}
- for (i = 0; i < mv_n_values (mv); i++)
- {
- union value value;
- mv_get_value (mv, &value, i);
- write_value (w, &value, seg0_width);
- }
+ for (i = 0; i < mv_n_values (&mv); i++)
+ write_value (w, mv_get_value (&mv, i), mv_get_width (&mv));
write_variable_continuation_records (w, seg0_width);
write_variable_continuation_records (w, seg_width);
}
+
+ mv_destroy (&mv);
}
/* Writes the value labels for variable V having system file
- variable index IDX to system file W. */
+ variable index IDX to system file W.
+
+ Value labels for long string variables are written separately,
+ by write_long_string_value_labels. */
static void
-write_value_labels (struct sfm_writer *w, struct variable *v, int idx)
+write_value_labels (struct sfm_writer *w, struct variable *v, int idx, const struct dictionary *dict)
{
const struct val_labs *val_labs;
- struct val_labs_iterator *i;
- struct val_lab *vl;
+ const struct val_lab **labels;
+ size_t n_labels;
+ size_t i;
val_labs = var_get_value_labels (v);
- if (val_labs == NULL)
+ n_labels = val_labs_count (val_labs);
+ if (n_labels == 0 || var_get_width (v) > 8)
return;
/* Value label record. */
write_int (w, 3); /* Record type. */
write_int (w, val_labs_count (val_labs));
- for (vl = val_labs_first_sorted (val_labs, &i); vl != NULL;
- vl = val_labs_next (val_labs, &i))
+ labels = val_labs_sorted (val_labs);
+ for (i = 0; i < n_labels; i++)
{
- uint8_t len = MIN (strlen (vl->label), 255);
+ const struct val_lab *vl = labels[i];
+ char *label = recode_string (dict_get_encoding (dict), UTF8, val_lab_get_label (vl), -1);
+ uint8_t len = MIN (strlen (label), 255);
- write_value (w, &vl->value, var_get_width (v));
+ write_value (w, val_lab_get_value (vl), var_get_width (v));
write_bytes (w, &len, 1);
- write_bytes (w, vl->label, len);
+ write_bytes (w, label, len);
write_zeros (w, REM_RND_UP (len + 1, 8));
+ free (label);
}
+ free (labels);
/* Value label variable record. */
write_int (w, 4); /* Record type. */
ds_destroy (&map);
}
+
+static void
+write_long_string_value_labels (struct sfm_writer *w,
+ const struct dictionary *dict)
+{
+ size_t n_vars = dict_get_var_cnt (dict);
+ size_t size, i;
+ off_t start UNUSED;
+
+ /* Figure out the size in advance. */
+ size = 0;
+ for (i = 0; i < n_vars; i++)
+ {
+ struct variable *var = dict_get_var (dict, i);
+ const struct val_labs *val_labs = var_get_value_labels (var);
+ int width = var_get_width (var);
+ const struct val_lab *val_lab;
+
+ if (val_labs_count (val_labs) == 0 || width < 9)
+ continue;
+
+ size += 12 + strlen (var_get_name (var));
+ for (val_lab = val_labs_first (val_labs); val_lab != NULL;
+ val_lab = val_labs_next (val_labs, val_lab))
+ size += 8 + width + strlen (val_lab_get_label (val_lab));
+ }
+ if (size == 0)
+ return;
+
+ write_int (w, 7); /* Record type. */
+ write_int (w, 21); /* Record subtype */
+ write_int (w, 1); /* Data item (byte) size. */
+ write_int (w, size); /* Number of data items. */
+
+ start = ftello (w->file);
+ for (i = 0; i < n_vars; i++)
+ {
+ struct variable *var = dict_get_var (dict, i);
+ const struct val_labs *val_labs = var_get_value_labels (var);
+ const char *var_name = var_get_name (var);
+ int width = var_get_width (var);
+ const struct val_lab *val_lab;
+
+ if (val_labs_count (val_labs) == 0 || width < 9)
+ continue;
+
+ write_int (w, strlen (var_name));
+ write_bytes (w, var_name, strlen (var_name));
+ write_int (w, width);
+ write_int (w, val_labs_count (val_labs));
+ for (val_lab = val_labs_first (val_labs); val_lab != NULL;
+ val_lab = val_labs_next (val_labs, val_lab))
+ {
+ const char *label = val_lab_get_label (val_lab);
+ size_t label_length = strlen (label);
+
+ write_int (w, width);
+ write_bytes (w, value_str (val_lab_get_value (val_lab), width),
+ width);
+ write_int (w, label_length);
+ write_bytes (w, label, label_length);
+ }
+ }
+ assert (ftello (w->file) == start + size);
+}
+
+static void
+write_encoding_record (struct sfm_writer *w,
+ const struct dictionary *d)
+{
+ const char *enc = dict_get_encoding (d);
+
+ if ( NULL == enc)
+ return;
+
+ write_int (w, 7); /* Record type. */
+ write_int (w, 20); /* Record subtype. */
+ write_int (w, 1); /* Data item (char) size. */
+ write_int (w, strlen (enc)); /* Number of data items. */
+ write_string (w, enc, strlen (enc));
+}
+
+
/* Writes the long variable name table. */
static void
write_longvar_table (struct sfm_writer *w, const struct dictionary *dict)
for (i = 0; i < dict_get_var_cnt (dict); i++)
{
struct variable *v = dict_get_var (dict, i);
+ char *longname = recode_string (dict_get_encoding (dict), UTF8, var_get_name (v), -1);
if (i)
ds_put_char (&map, '\t');
ds_put_format (&map, "%s=%s",
- var_get_short_name (v, 0), var_get_name (v));
+ var_get_short_name (v, 0), longname);
+ free (longname);
}
write_int (w, 7); /* Record type. */
if (ferror (w->file))
{
casewriter_force_error (writer);
- case_destroy (c);
+ case_unref (c);
return;
}
else
write_case_compressed (w, c);
- case_destroy (c);
+ case_unref (c);
}
/* Destroys system file writer W. */
\f
/* Writes case C to system file W, without compressing it. */
static void
-write_case_uncompressed (struct sfm_writer *w, struct ccase *c)
+write_case_uncompressed (struct sfm_writer *w, const struct ccase *c)
{
size_t i;
{
struct sfm_var *v = &w->sfm_vars[i];
- if (v->width == 0)
+ if (v->var_width == 0)
write_float (w, case_num_idx (c, v->case_index));
else
{
write_bytes (w, case_str_idx (c, v->case_index) + v->offset,
- v->width);
+ v->segment_width);
write_spaces (w, v->padding);
}
}
/* Writes case C to system file W, with compression. */
static void
-write_case_compressed (struct sfm_writer *w, struct ccase *c)
+write_case_compressed (struct sfm_writer *w, const struct ccase *c)
{
size_t i;
{
struct sfm_var *v = &w->sfm_vars[i];
- if (v->width == 0)
+ if (v->var_width == 0)
{
double d = case_num_idx (c, v->case_index);
if (d == SYSMIS)
multiple of 8, by ensuring that the final partial
oct (8 byte unit) is treated as padded with spaces
on the right. */
- for (width = v->width; width > 0; width -= 8, offset += 8)
+ for (width = v->segment_width; width > 0; width -= 8, offset += 8)
{
const void *data = case_str_idx (c, v->case_index) + offset;
int chunk_size = MIN (width, 8);
write_float (w, value->f);
else
{
- write_bytes (w, value->s, width);
+ write_bytes (w, value_str (value, width), width);
write_zeros (w, 8 - width);
}
}
/* Writes null-terminated STRING in a field of the given WIDTH to
- W. If WIDTH is longer than WIDTH, it is truncated; if WIDTH
+ W. If STRING is longer than WIDTH, it is truncated; if WIDTH
is narrowed, it is padded on the right with spaces. */
static void
write_string (struct sfm_writer *w, const char *string, size_t width)
projects / pspp-builds.git / blobdiff