better tests
[pspp] / src / data / sys-file-writer.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 1997-2000, 2006-2014 Free Software Foundation, Inc.
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
16
17 #include <config.h>
18
19 #include "data/sys-file-writer.h"
20 #include "data/sys-file-private.h"
21
22 #include <ctype.h>
23 #include <errno.h>
24 #include <stdint.h>
25 #include <stdlib.h>
26 #include <sys/stat.h>
27 #include <time.h>
28 #include <zlib.h>
29
30 #include "data/attributes.h"
31 #include "data/case.h"
32 #include "data/casewriter-provider.h"
33 #include "data/casewriter.h"
34 #include "data/dictionary.h"
35 #include "data/file-handle-def.h"
36 #include "data/format.h"
37 #include "data/make-file.h"
38 #include "data/missing-values.h"
39 #include "data/mrset.h"
40 #include "data/settings.h"
41 #include "data/short-names.h"
42 #include "data/value-labels.h"
43 #include "data/variable.h"
44 #include "libpspp/float-format.h"
45 #include "libpspp/i18n.h"
46 #include "libpspp/integer-format.h"
47 #include "libpspp/message.h"
48 #include "libpspp/misc.h"
49 #include "libpspp/str.h"
50 #include "libpspp/string-array.h"
51 #include "libpspp/version.h"
52
53 #include "gl/xmemdup0.h"
54 #include "gl/minmax.h"
55 #include "gl/unlocked-io.h"
56 #include "gl/xalloc.h"
57
58 #include "gettext.h"
59 #define _(msgid) gettext (msgid)
60 #define N_(msgid) (msgid)
61
62 /* Compression bias used by PSPP.  Values between (1 -
63    COMPRESSION_BIAS) and (251 - COMPRESSION_BIAS) inclusive can be
64    compressed. */
65 #define COMPRESSION_BIAS 100
66
67 /* System file writer. */
68 struct sfm_writer
69   {
70     struct file_handle *fh;     /* File handle. */
71     struct fh_lock *lock;       /* Mutual exclusion for file. */
72     FILE *file;                 /* File stream. */
73     struct replace_file *rf;    /* Ticket for replacing output file. */
74
75     enum any_compression compression;
76     casenumber n_cases;         /* Number of cases written so far. */
77     uint8_t space;              /* ' ' in the file's character encoding. */
78
79     /* Simple compression buffering.
80
81        Compressed data is output as a series of 8-byte elements, with 1 to 9
82        such elements clustered together.  The first element in a cluster is 8
83        1-byte opcodes.  Some opcodes call for an additional element in the
84        cluster (hence, if there are eight such opcodes, then the cluster
85        contains a full 9 elements).
86
87        cbuf[] holds a cluster at a time. */
88     uint8_t cbuf[9][8];
89     int n_opcodes;              /* Number of opcodes in cbuf[0] so far. */
90     int n_elements;             /* Number of elements in cbuf[] so far. */
91
92     /* ZLIB compression. */
93     z_stream zstream;           /* ZLIB deflater. */
94     off_t zstart;
95     struct zblock *blocks;
96     size_t n_blocks, allocated_blocks;
97
98     /* Variables. */
99     struct sfm_var *sfm_vars;   /* Variables. */
100     size_t sfm_n_vars;          /* Number of variables. */
101     size_t n_segments;          /* Number of variables including extra segments
102                                    for long string variables. */
103   };
104
105 struct zblock
106   {
107     unsigned int uncompressed_size;
108     unsigned int compressed_size;
109   };
110
111 static const struct casewriter_class sys_file_casewriter_class;
112
113 static void write_header (struct sfm_writer *, const struct dictionary *);
114 static void write_variable (struct sfm_writer *, const struct variable *);
115 static void write_value_labels (struct sfm_writer *,
116                                 const struct dictionary *);
117 static void write_integer_info_record (struct sfm_writer *,
118                                        const struct dictionary *);
119 static void write_float_info_record (struct sfm_writer *);
120
121 static void write_longvar_table (struct sfm_writer *w,
122                                  const struct dictionary *dict);
123
124 static void write_encoding_record (struct sfm_writer *w,
125                                    const struct dictionary *);
126
127 static void write_vls_length_table (struct sfm_writer *w,
128                               const struct dictionary *dict);
129
130 static void write_long_string_value_labels (struct sfm_writer *,
131                                             const struct dictionary *);
132 static void write_long_string_missing_values (struct sfm_writer *,
133                                               const struct dictionary *);
134
135 static void write_mrsets (struct sfm_writer *, const struct dictionary *,
136                           bool pre_v14);
137
138 static void write_variable_display_parameters (struct sfm_writer *w,
139                                                const struct dictionary *dict);
140
141 static void write_documents (struct sfm_writer *, const struct dictionary *);
142
143 static void write_data_file_attributes (struct sfm_writer *,
144                                         const struct dictionary *);
145 static void write_variable_attributes (struct sfm_writer *,
146                                        const struct dictionary *);
147
148 static void write_int (struct sfm_writer *, int32_t);
149 static void write_int64 (struct sfm_writer *, int64_t);
150 static inline void convert_double_to_output_format (double, uint8_t[8]);
151 static void write_float (struct sfm_writer *, double);
152 static void write_string (struct sfm_writer *, const char *, size_t);
153 static void write_utf8_string (struct sfm_writer *, const char *encoding,
154                                const char *string, size_t width);
155 static void write_utf8_record (struct sfm_writer *, const char *encoding,
156                                const struct string *content, int subtype);
157 static void write_string_record (struct sfm_writer *,
158                                  const struct substring content, int subtype);
159 static void write_bytes (struct sfm_writer *, const void *, size_t);
160 static void write_zeros (struct sfm_writer *, size_t);
161 static void write_spaces (struct sfm_writer *, size_t);
162 static void write_value (struct sfm_writer *, const union value *, int width);
163
164 static void write_case_uncompressed (struct sfm_writer *,
165                                      const struct ccase *);
166 static void write_case_compressed (struct sfm_writer *, const struct ccase *);
167 static void flush_compressed (struct sfm_writer *);
168 static void put_cmp_opcode (struct sfm_writer *, uint8_t);
169 static void put_cmp_number (struct sfm_writer *, double);
170 static void put_cmp_string (struct sfm_writer *, const void *, size_t);
171
172 static bool start_zstream (struct sfm_writer *);
173 static void finish_zstream (struct sfm_writer *);
174 static void write_ztrailer (struct sfm_writer *);
175
176 static bool write_error (const struct sfm_writer *);
177 static bool close_writer (struct sfm_writer *);
178
179 /* Returns default options for writing a system file. */
180 struct sfm_write_options
181 sfm_writer_default_options (void)
182 {
183   struct sfm_write_options opts;
184   opts.compression = (settings_get_scompression ()
185                       ? ANY_COMP_SIMPLE
186                       : ANY_COMP_NONE);
187   opts.create_writeable = true;
188   opts.version = 3;
189   return opts;
190 }
191
192 /* Opens the system file designated by file handle FH for writing
193    cases from dictionary D according to the given OPTS.
194
195    No reference to D is retained, so it may be modified or
196    destroyed at will after this function returns.  D is not
197    modified by this function, except to assign short names. */
198 struct casewriter *
199 sfm_open_writer (struct file_handle *fh, struct dictionary *d,
200                  struct sfm_write_options opts)
201 {
202   struct encoding_info encoding_info;
203   mode_t mode;
204   int i;
205
206   /* Check version. */
207   if (opts.version != 2 && opts.version != 3)
208     {
209       msg (ME, _("Unknown system file version %d. Treating as version %d."),
210            opts.version, 3);
211       opts.version = 3;
212     }
213
214   /* Create and initialize writer. */
215   struct sfm_writer *w = XZALLOC (struct sfm_writer);
216   w->fh = fh_ref (fh);
217   w->lock = NULL;
218   w->file = NULL;
219   w->rf = NULL;
220
221   /* Use the requested compression, except that no EBCDIC-based ZLIB compressed
222      files have been observed, so drop back to simple compression for those
223      files. */
224   w->compression = opts.compression;
225   if (w->compression == ANY_COMP_ZLIB
226       && is_encoding_ebcdic_compatible (dict_get_encoding (d)))
227     w->compression = ANY_COMP_SIMPLE;
228
229   w->n_cases = 0;
230
231   w->n_opcodes = w->n_elements = 0;
232   memset (w->cbuf[0], 0, 8);
233
234   /* Figure out how to map in-memory case data to on-disk case
235      data.  Also count the number of segments.  Very long strings
236      occupy multiple segments, otherwise each variable only takes
237      one segment. */
238   w->n_segments = sfm_dictionary_to_sfm_vars (d, &w->sfm_vars, &w->sfm_n_vars);
239
240   /* Open file handle as an exclusive writer. */
241   /* TRANSLATORS: this fragment will be interpolated into
242      messages in fh_lock() that identify types of files. */
243   w->lock = fh_lock (fh, FH_REF_FILE, N_("system file"), FH_ACC_WRITE, true);
244   if (w->lock == NULL)
245     goto error;
246
247   /* Create the file on disk. */
248   mode = 0444;
249   if (opts.create_writeable)
250     mode |= 0222;
251   w->rf = replace_file_start (fh, "wb", mode, &w->file);
252   if (w->rf == NULL)
253     {
254       msg (ME, _("Error opening `%s' for writing as a system file: %s."),
255            fh_get_file_name (fh), strerror (errno));
256       goto error;
257     }
258
259   get_encoding_info (&encoding_info, dict_get_encoding (d));
260   w->space = encoding_info.space[0];
261
262   /* Write the file header. */
263   write_header (w, d);
264
265   /* Write basic variable info. */
266   short_names_assign (d);
267   for (i = 0; i < dict_get_n_vars (d); i++)
268     write_variable (w, dict_get_var (d, i));
269
270   write_value_labels (w, d);
271
272   if (dict_get_document_n_lines (d) > 0)
273     write_documents (w, d);
274
275   write_integer_info_record (w, d);
276   write_float_info_record (w);
277
278   write_mrsets (w, d, true);
279
280   write_variable_display_parameters (w, d);
281
282   if (opts.version >= 3)
283     write_longvar_table (w, d);
284
285   write_vls_length_table (w, d);
286
287   write_long_string_value_labels (w, d);
288   write_long_string_missing_values (w, d);
289
290   if (opts.version >= 3)
291     {
292       if (attrset_count (dict_get_attributes (d)))
293         write_data_file_attributes (w, d);
294       write_variable_attributes (w, d);
295     }
296
297   write_mrsets (w, d, false);
298
299   write_encoding_record (w, d);
300
301   /* Write end-of-headers record. */
302   write_int (w, 999);
303   write_int (w, 0);
304
305   if (w->compression == ANY_COMP_ZLIB)
306     {
307       w->zstream.zalloc = Z_NULL;
308       w->zstream.zfree = Z_NULL;
309       w->zstream.opaque = Z_NULL;
310       w->zstart = ftello (w->file);
311
312       write_int64 (w, w->zstart);
313       write_int64 (w, 0);
314       write_int64 (w, 0);
315
316       start_zstream (w);
317     }
318
319   if (write_error (w))
320     goto error;
321
322   return casewriter_create (dict_get_proto (d), &sys_file_casewriter_class, w);
323
324 error:
325   close_writer (w);
326   return NULL;
327 }
328
329 /* Returns value of X truncated to two least-significant digits. */
330 static int
331 rerange (int x)
332 {
333   if (x < 0)
334     x = -x;
335   if (x >= 100)
336     x %= 100;
337   return x;
338 }
339
340 /* Calculates the offset of data for TARGET_VAR from the
341    beginning of each case's data for dictionary D.  The return
342    value is in "octs" (8-byte units). */
343 static int
344 calc_oct_idx (const struct dictionary *d, struct variable *target_var)
345 {
346   int oct_idx;
347   int i;
348
349   oct_idx = 0;
350   for (i = 0; i < dict_get_n_vars (d); i++)
351     {
352       struct variable *var = dict_get_var (d, i);
353       if (var == target_var)
354         break;
355       oct_idx += sfm_width_to_octs (var_get_width (var));
356     }
357   return oct_idx;
358 }
359
360 /* Write the sysfile_header header to system file W. */
361 static void
362 write_header (struct sfm_writer *w, const struct dictionary *d)
363 {
364   const char *dict_encoding = dict_get_encoding (d);
365   char prod_name[61];
366   const char *file_label;
367   struct variable *weight;
368
369   time_t t;
370
371   /* Record-type code. */
372   if (is_encoding_ebcdic_compatible (dict_encoding))
373     write_string (w, EBCDIC_MAGIC, 4);
374   else if (w->compression == ANY_COMP_ZLIB)
375     write_string (w, ASCII_ZMAGIC, 4);
376   else
377     write_string (w, ASCII_MAGIC, 4);
378
379   /* Product identification. */
380   snprintf (prod_name, sizeof prod_name, "@(#) SPSS DATA FILE %s - %s",
381             version, host_system);
382   write_utf8_string (w, dict_encoding, prod_name, 60);
383
384   /* Layout code. */
385   write_int (w, 2);
386
387   /* Number of `union value's per case. */
388   write_int (w, calc_oct_idx (d, NULL));
389
390   /* Compressed? */
391   write_int (w, (w->compression == ANY_COMP_NONE ? 0
392                  : w->compression == ANY_COMP_SIMPLE ? 1
393                  : 2));
394
395   /* Weight variable. */
396   weight = dict_get_weight (d);
397   write_int (w, weight != NULL ? calc_oct_idx (d, weight) + 1 : 0);
398
399   /* Number of cases.  We don't know this in advance, so we write
400      -1 to indicate an unknown number of cases.  Later we can
401      come back and overwrite it with the true value. */
402   write_int (w, -1);
403
404   /* Compression bias. */
405   write_float (w, COMPRESSION_BIAS);
406
407   /* Creation date and time. */
408   char *creation_date, *creation_time;
409   if (time (&t) == (time_t) -1)
410     {
411       creation_date = xstrdup ("01 Jan 70");
412       creation_time = xstrdup ("00:00:00");
413     }
414   else
415     {
416       static const char *const month_name[12] =
417         {
418           "Jan", "Feb", "Mar", "Apr", "May", "Jun",
419           "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
420         };
421       struct tm *tmp = localtime (&t);
422       int day = rerange (tmp->tm_mday);
423       int mon = rerange (tmp->tm_mon + 1);
424       int year = rerange (tmp->tm_year);
425       int hour = rerange (tmp->tm_hour + 1);
426       int min = rerange (tmp->tm_min + 1);
427       int sec = rerange (tmp->tm_sec + 1);
428
429       creation_date = xasprintf ("%02d %s %02d",
430                                  day, month_name[mon - 1], year);
431       creation_time = xasprintf ("%02d:%02d:%02d", hour - 1, min - 1, sec - 1);
432     }
433   write_utf8_string (w, dict_encoding, creation_date, 9);
434   write_utf8_string (w, dict_encoding, creation_time, 8);
435   free (creation_time);
436   free (creation_date);
437
438   /* File label. */
439   file_label = dict_get_label (d);
440   if (file_label == NULL)
441     file_label = "";
442   write_utf8_string (w, dict_encoding, file_label, 64);
443
444   /* Padding. */
445   write_zeros (w, 3);
446 }
447
448 /* Write format spec FMT to W, after adjusting it to be
449    compatible with the given WIDTH. */
450 static void
451 write_format (struct sfm_writer *w, struct fmt_spec fmt, int width)
452 {
453   assert (fmt_check_output (&fmt));
454   assert (sfm_width_to_segments (width) == 1);
455
456   if (width > 0)
457     fmt_resize (&fmt, width);
458   write_int (w, (fmt_to_io (fmt.type) << 16) | (fmt.w << 8) | fmt.d);
459 }
460
461 /* Write a string continuation variable record for each 8-byte
462    section beyond the initial 8 bytes, for a variable of the
463    given WIDTH. */
464 static void
465 write_variable_continuation_records (struct sfm_writer *w, int width)
466 {
467   int position;
468
469   assert (sfm_width_to_segments (width) == 1);
470   for (position = 8; position < width; position += 8)
471     {
472       write_int (w, 2);   /* Record type. */
473       write_int (w, -1);  /* Width. */
474       write_int (w, 0);   /* No variable label. */
475       write_int (w, 0);   /* No missing values. */
476       write_int (w, 0);   /* Print format. */
477       write_int (w, 0);   /* Write format. */
478       write_zeros (w, 8);   /* Name. */
479     }
480 }
481
482 /* Write the variable record(s) for variable V to system file
483    W. */
484 static void
485 write_variable (struct sfm_writer *w, const struct variable *v)
486 {
487   int width = var_get_width (v);
488   int n_segments = sfm_width_to_segments (width);
489   int seg0_width = sfm_segment_alloc_width (width, 0);
490   const char *encoding = var_get_encoding (v);
491   int i;
492
493   /* Record type. */
494   write_int (w, 2);
495
496   /* Width. */
497   write_int (w, seg0_width);
498
499   /* Variable has a variable label? */
500   write_int (w, var_has_label (v));
501
502   /* Number of missing values.  If there is a range, then the
503      range counts as 2 missing values and causes the number to be
504      negated.
505
506      Missing values for long string variables are written in a separate
507      record. */
508   enum { MAX_SHORT_STRING = 8 };
509   if (width <= MAX_SHORT_STRING)
510     {
511       const struct missing_values *mv = var_get_missing_values (v);
512       if (mv_has_range (mv))
513         write_int (w, -2 - mv_n_values (mv));
514       else
515         write_int (w, mv_n_values (mv));
516     }
517   else
518     write_int (w, 0);
519
520   /* Print and write formats. */
521   write_format (w, *var_get_print_format (v), seg0_width);
522   write_format (w, *var_get_write_format (v), seg0_width);
523
524   /* Short name.
525      The full name is in a translation table written
526      separately. */
527   write_utf8_string (w, encoding, var_get_short_name (v, 0), 8);
528
529   /* Value label. */
530   if (var_has_label (v))
531     {
532       char *label = recode_string (encoding, UTF8, var_get_label (v), -1);
533       size_t label_len = MIN (strlen (label), 255);
534       size_t padded_len = ROUND_UP (label_len, 4);
535       write_int (w, label_len);
536       write_string (w, label, padded_len);
537       free (label);
538     }
539
540   /* Write the missing values, if any, range first. */
541   if (width <= MAX_SHORT_STRING)
542     {
543       const struct missing_values *mv = var_get_missing_values (v);
544       if (mv_has_range (mv))
545         {
546           double x, y;
547           mv_get_range (mv, &x, &y);
548           write_float (w, x);
549           write_float (w, y);
550         }
551       for (i = 0; i < mv_n_values (mv); i++)
552         write_value (w, mv_get_value (mv, i), width);
553     }
554
555   write_variable_continuation_records (w, seg0_width);
556
557   /* Write additional segments for very long string variables. */
558   for (i = 1; i < n_segments; i++)
559     {
560       int seg_width = sfm_segment_alloc_width (width, i);
561       struct fmt_spec fmt = fmt_for_output (FMT_A, MAX (seg_width, 1), 0);
562
563       write_int (w, 2);           /* Variable record. */
564       write_int (w, seg_width);   /* Width. */
565       write_int (w, 0);           /* No variable label. */
566       write_int (w, 0);           /* No missing values. */
567       write_format (w, fmt, seg_width); /* Print format. */
568       write_format (w, fmt, seg_width); /* Write format. */
569       write_utf8_string (w, encoding, var_get_short_name (v, i), 8);
570
571       write_variable_continuation_records (w, seg_width);
572     }
573 }
574
575 /* Writes the value labels to system file W.
576
577    Value labels for long string variables are written separately,
578    by write_long_string_value_labels. */
579 static void
580 write_value_labels (struct sfm_writer *w, const struct dictionary *d)
581 {
582   struct label_set
583     {
584       struct hmap_node hmap_node;
585       const struct val_labs *val_labs;
586       int *indexes;
587       size_t n_indexes, allocated_indexes;
588     };
589
590   size_t n_sets, allocated_sets;
591   struct label_set **sets;
592   struct hmap same_sets;
593   size_t i;
594   int idx;
595
596   n_sets = allocated_sets = 0;
597   sets = NULL;
598   hmap_init (&same_sets);
599
600   idx = 0;
601   for (i = 0; i < dict_get_n_vars (d); i++)
602     {
603       struct variable *v = dict_get_var (d, i);
604
605       if (var_has_value_labels (v) && var_get_width (v) <= 8)
606         {
607           const struct val_labs *val_labs = var_get_value_labels (v);
608           unsigned int hash = val_labs_hash (val_labs, 0);
609           struct label_set *set;
610
611           HMAP_FOR_EACH_WITH_HASH (set, struct label_set, hmap_node,
612                                    hash, &same_sets)
613             {
614               if (val_labs_equal (set->val_labs, val_labs))
615                 {
616                   if (set->n_indexes >= set->allocated_indexes)
617                     set->indexes = x2nrealloc (set->indexes,
618                                                &set->allocated_indexes,
619                                                sizeof *set->indexes);
620                   set->indexes[set->n_indexes++] = idx;
621                   goto next_var;
622                 }
623             }
624
625           set = xmalloc (sizeof *set);
626           set->val_labs = val_labs;
627           set->indexes = xmalloc (sizeof *set->indexes);
628           set->indexes[0] = idx;
629           set->n_indexes = 1;
630           set->allocated_indexes = 1;
631           hmap_insert (&same_sets, &set->hmap_node, hash);
632
633           if (n_sets >= allocated_sets)
634             sets = x2nrealloc (sets, &allocated_sets, sizeof *sets);
635           sets[n_sets++] = set;
636         }
637
638     next_var:
639       idx += sfm_width_to_octs (var_get_width (v));
640     }
641
642   for (i = 0; i < n_sets; i++)
643     {
644       const struct label_set *set = sets[i];
645       const struct val_labs *val_labs = set->val_labs;
646       size_t n_labels = val_labs_count (val_labs);
647       int width = val_labs_get_width (val_labs);
648       const struct val_lab **labels;
649       size_t j;
650
651       /* Value label record. */
652       write_int (w, 3);             /* Record type. */
653       write_int (w, n_labels);
654       labels = val_labs_sorted (val_labs);
655       for (j = 0; j < n_labels; j++)
656         {
657           const struct val_lab *vl = labels[j];
658           char *label = recode_string (dict_get_encoding (d), UTF8,
659                                        val_lab_get_escaped_label (vl), -1);
660           uint8_t len = MIN (strlen (label), 255);
661
662           write_value (w, val_lab_get_value (vl), width);
663           write_bytes (w, &len, 1);
664           write_bytes (w, label, len);
665           write_zeros (w, REM_RND_UP (len + 1, 8));
666           free (label);
667         }
668       free (labels);
669
670       /* Value label variable record. */
671       write_int (w, 4);              /* Record type. */
672       write_int (w, set->n_indexes);
673       for (j = 0; j < set->n_indexes; j++)
674         write_int (w, set->indexes[j] + 1);
675     }
676
677   for (i = 0; i < n_sets; i++)
678     {
679       struct label_set *set = sets[i];
680
681       free (set->indexes);
682       free (set);
683     }
684   free (sets);
685   hmap_destroy (&same_sets);
686 }
687
688 /* Writes record type 6, document record. */
689 static void
690 write_documents (struct sfm_writer *w, const struct dictionary *d)
691 {
692   const struct string_array *docs = dict_get_documents (d);
693   const char *enc = dict_get_encoding (d);
694   size_t i;
695
696   write_int (w, 6);             /* Record type. */
697   write_int (w, docs->n);
698   for (i = 0; i < docs->n; i++)
699     {
700       char *s = recode_string (enc, "UTF-8", docs->strings[i], -1);
701       size_t s_len = strlen (s);
702       size_t write_len = MIN (s_len, DOC_LINE_LENGTH);
703
704       write_bytes (w, s, write_len);
705       write_spaces (w, DOC_LINE_LENGTH - write_len);
706       free (s);
707     }
708 }
709
710 static void
711 put_attrset (struct string *string, const struct attrset *attrs)
712 {
713   const struct attribute *attr;
714   struct attrset_iterator i;
715
716   for (attr = attrset_first (attrs, &i); attr != NULL;
717        attr = attrset_next (attrs, &i))
718     {
719       size_t n_values = attribute_get_n_values (attr);
720       size_t j;
721
722       ds_put_cstr (string, attribute_get_name (attr));
723       ds_put_byte (string, '(');
724       for (j = 0; j < n_values; j++)
725         ds_put_format (string, "'%s'\n", attribute_get_value (attr, j));
726       ds_put_byte (string, ')');
727     }
728 }
729
730 static void
731 write_data_file_attributes (struct sfm_writer *w,
732                             const struct dictionary *d)
733 {
734   struct string s = DS_EMPTY_INITIALIZER;
735   put_attrset (&s, dict_get_attributes (d));
736   write_utf8_record (w, dict_get_encoding (d), &s, 17);
737   ds_destroy (&s);
738 }
739
740 static void
741 add_role_attribute (enum var_role role, struct attrset *attrs)
742 {
743   struct attribute *attr;
744   const char *s;
745
746   switch (role)
747     {
748     case ROLE_INPUT:
749     default:
750       s = "0";
751       break;
752
753     case ROLE_TARGET:
754       s = "1";
755       break;
756
757     case ROLE_BOTH:
758       s = "2";
759       break;
760
761     case ROLE_NONE:
762       s = "3";
763       break;
764
765     case ROLE_PARTITION:
766       s = "4";
767       break;
768
769     case ROLE_SPLIT:
770       s = "5";
771       break;
772     }
773   attrset_delete (attrs, "$@Role");
774
775   attr = attribute_create ("$@Role");
776   attribute_add_value (attr, s);
777   attrset_add (attrs, attr);
778 }
779
780 static void
781 write_variable_attributes (struct sfm_writer *w, const struct dictionary *d)
782 {
783   struct string s = DS_EMPTY_INITIALIZER;
784   size_t n_vars = dict_get_n_vars (d);
785   size_t n_attrsets = 0;
786   size_t i;
787
788   for (i = 0; i < n_vars; i++)
789     {
790       struct variable *v = dict_get_var (d, i);
791       struct attrset attrs;
792
793       attrset_clone (&attrs, var_get_attributes (v));
794
795       add_role_attribute (var_get_role (v), &attrs);
796       if (n_attrsets++)
797         ds_put_byte (&s, '/');
798       ds_put_format (&s, "%s:", var_get_name (v));
799       put_attrset (&s, &attrs);
800       attrset_destroy (&attrs);
801     }
802   if (n_attrsets)
803     write_utf8_record (w, dict_get_encoding (d), &s, 18);
804   ds_destroy (&s);
805 }
806
807 /* Write multiple response sets.  If PRE_V14 is true, writes sets supported by
808    SPSS before release 14, otherwise writes sets supported only by later
809    versions. */
810 static void
811 write_mrsets (struct sfm_writer *w, const struct dictionary *dict,
812               bool pre_v14)
813 {
814   const char *encoding = dict_get_encoding (dict);
815   struct string s = DS_EMPTY_INITIALIZER;
816   size_t n_mrsets;
817   size_t i;
818
819   if (is_encoding_ebcdic_compatible (encoding))
820     {
821       /* FIXME. */
822       return;
823     }
824
825   n_mrsets = dict_get_n_mrsets (dict);
826   if (n_mrsets == 0)
827     return;
828
829   for (i = 0; i < n_mrsets; i++)
830     {
831       const struct mrset *mrset = dict_get_mrset (dict, i);
832       char *name;
833       size_t j;
834
835       if ((mrset->type != MRSET_MD || mrset->cat_source != MRSET_COUNTEDVALUES)
836           != pre_v14)
837         continue;
838
839       name = recode_string (encoding, "UTF-8", mrset->name, -1);
840       ds_put_format (&s, "%s=", name);
841       free (name);
842
843       if (mrset->type == MRSET_MD)
844         {
845           char *counted;
846
847           if (mrset->cat_source == MRSET_COUNTEDVALUES)
848             ds_put_format (&s, "E %d ", mrset->label_from_var_label ? 11 : 1);
849           else
850             ds_put_byte (&s, 'D');
851
852           if (mrset->width == 0)
853             counted = xasprintf ("%.0f", mrset->counted.f);
854           else
855             counted = xmemdup0 (mrset->counted.s, mrset->width);
856           ds_put_format (&s, "%zu %s", strlen (counted), counted);
857           free (counted);
858         }
859       else
860         ds_put_byte (&s, 'C');
861       ds_put_byte (&s, ' ');
862
863       if (mrset->label && !mrset->label_from_var_label)
864         {
865           char *label = recode_string (encoding, "UTF-8", mrset->label, -1);
866           ds_put_format (&s, "%zu %s", strlen (label), label);
867           free (label);
868         }
869       else
870         ds_put_cstr (&s, "0 ");
871
872       for (j = 0; j < mrset->n_vars; j++)
873         {
874           const char *short_name_utf8 = var_get_short_name (mrset->vars[j], 0);
875           char *lower_name_utf8 = utf8_to_lower (short_name_utf8);
876           char *short_name = recode_string (encoding, "UTF-8",
877                                             lower_name_utf8, -1);
878           ds_put_format (&s, " %s", short_name);
879           free (short_name);
880           free (lower_name_utf8);
881         }
882       ds_put_byte (&s, '\n');
883     }
884
885   if (!ds_is_empty (&s))
886     write_string_record (w, ds_ss (&s), pre_v14 ? 7 : 19);
887   ds_destroy (&s);
888 }
889
890 /* Write the alignment, width and scale values. */
891 static void
892 write_variable_display_parameters (struct sfm_writer *w,
893                                    const struct dictionary *dict)
894 {
895   int i;
896
897   write_int (w, 7);             /* Record type. */
898   write_int (w, 11);            /* Record subtype. */
899   write_int (w, 4);             /* Data item (int32) size. */
900   write_int (w, w->n_segments * 3); /* Number of data items. */
901
902   for (i = 0; i < dict_get_n_vars (dict); ++i)
903     {
904       struct variable *v = dict_get_var (dict, i);
905       int width = var_get_width (v);
906       int n_segments = sfm_width_to_segments (width);
907       int measure = (var_get_measure (v) == MEASURE_NOMINAL ? 1
908                      : var_get_measure (v) == MEASURE_ORDINAL ? 2
909                      : 3);
910       int alignment = (var_get_alignment (v) == ALIGN_LEFT ? 0
911                        : var_get_alignment (v) == ALIGN_RIGHT ? 1
912                        : 2);
913       int i;
914
915       for (i = 0; i < n_segments; i++)
916         {
917           int width_left = width - sfm_segment_effective_offset (width, i);
918           write_int (w, measure);
919           write_int (w, (i == 0 ? var_get_display_width (v)
920                          : var_default_display_width (width_left)));
921           write_int (w, alignment);
922         }
923     }
924 }
925
926 /* Writes the table of lengths for very long string variables. */
927 static void
928 write_vls_length_table (struct sfm_writer *w,
929                         const struct dictionary *dict)
930 {
931   struct string map;
932   int i;
933
934   ds_init_empty (&map);
935   for (i = 0; i < dict_get_n_vars (dict); ++i)
936     {
937       const struct variable *v = dict_get_var (dict, i);
938       if (sfm_width_to_segments (var_get_width (v)) > 1)
939         ds_put_format (&map, "%s=%05d%c\t",
940                        var_get_short_name (v, 0), var_get_width (v), 0);
941     }
942   if (!ds_is_empty (&map))
943     write_utf8_record (w, dict_get_encoding (dict), &map, 14);
944   ds_destroy (&map);
945 }
946
947 static void
948 write_long_string_value_labels (struct sfm_writer *w,
949                                 const struct dictionary *dict)
950 {
951   const char *encoding = dict_get_encoding (dict);
952   size_t n_vars = dict_get_n_vars (dict);
953   size_t size, i;
954
955   /* Figure out the size in advance. */
956   size = 0;
957   for (i = 0; i < n_vars; i++)
958     {
959       struct variable *var = dict_get_var (dict, i);
960       const struct val_labs *val_labs = var_get_value_labels (var);
961       int width = var_get_width (var);
962       const struct val_lab *val_lab;
963
964       if (val_labs_count (val_labs) == 0 || width < 9)
965         continue;
966
967       size += 12;
968       size += recode_string_len (encoding, "UTF-8", var_get_name (var), -1);
969       for (val_lab = val_labs_first (val_labs); val_lab != NULL;
970            val_lab = val_labs_next (val_labs, val_lab))
971         {
972           size += 8 + width;
973           size += recode_string_len (encoding, "UTF-8",
974                                      val_lab_get_escaped_label (val_lab), -1);
975         }
976     }
977   if (size == 0)
978     return;
979
980   write_int (w, 7);             /* Record type. */
981   write_int (w, 21);            /* Record subtype */
982   write_int (w, 1);             /* Data item (byte) size. */
983   write_int (w, size);          /* Number of data items. */
984
985   for (i = 0; i < n_vars; i++)
986     {
987       struct variable *var = dict_get_var (dict, i);
988       const struct val_labs *val_labs = var_get_value_labels (var);
989       int width = var_get_width (var);
990       const struct val_lab *val_lab;
991       char *var_name;
992
993       if (val_labs_count (val_labs) == 0 || width < 9)
994         continue;
995
996       var_name = recode_string (encoding, "UTF-8", var_get_name (var), -1);
997       write_int (w, strlen (var_name));
998       write_bytes (w, var_name, strlen (var_name));
999       free (var_name);
1000
1001       write_int (w, width);
1002       write_int (w, val_labs_count (val_labs));
1003       for (val_lab = val_labs_first (val_labs); val_lab != NULL;
1004            val_lab = val_labs_next (val_labs, val_lab))
1005         {
1006           char *label;
1007           size_t len;
1008
1009           write_int (w, width);
1010           write_bytes (w, val_lab_get_value (val_lab)->s, width);
1011
1012           label = recode_string (var_get_encoding (var), "UTF-8",
1013                                  val_lab_get_escaped_label (val_lab), -1);
1014           len = strlen (label);
1015           write_int (w, len);
1016           write_bytes (w, label, len);
1017           free (label);
1018         }
1019     }
1020 }
1021
1022 static void
1023 write_long_string_missing_values (struct sfm_writer *w,
1024                                   const struct dictionary *dict)
1025 {
1026   const char *encoding = dict_get_encoding (dict);
1027   size_t n_vars = dict_get_n_vars (dict);
1028   size_t size, i;
1029
1030   /* Figure out the size in advance. */
1031   size = 0;
1032   for (i = 0; i < n_vars; i++)
1033     {
1034       struct variable *var = dict_get_var (dict, i);
1035       const struct missing_values *mv = var_get_missing_values (var);
1036       int width = var_get_width (var);
1037
1038       if (mv_is_empty (mv) || width < 9)
1039         continue;
1040
1041       size += 4;
1042       size += recode_string_len (encoding, "UTF-8", var_get_name (var), -1);
1043       size += 1;
1044       size += mv_n_values (mv) * (4 + 8);
1045     }
1046   if (size == 0)
1047     return;
1048
1049   write_int (w, 7);             /* Record type. */
1050   write_int (w, 22);            /* Record subtype */
1051   write_int (w, 1);             /* Data item (byte) size. */
1052   write_int (w, size);          /* Number of data items. */
1053
1054   for (i = 0; i < n_vars; i++)
1055     {
1056       struct variable *var = dict_get_var (dict, i);
1057       const struct missing_values *mv = var_get_missing_values (var);
1058       int width = var_get_width (var);
1059       uint8_t n_missing_values;
1060       char *var_name;
1061       int j;
1062
1063       if (mv_is_empty (mv) || width < 9)
1064         continue;
1065
1066       var_name = recode_string (encoding, "UTF-8", var_get_name (var), -1);
1067       write_int (w, strlen (var_name));
1068       write_bytes (w, var_name, strlen (var_name));
1069       free (var_name);
1070
1071       n_missing_values = mv_n_values (mv);
1072       write_bytes (w, &n_missing_values, 1);
1073
1074       for (j = 0; j < n_missing_values; j++)
1075         {
1076           const union value *value = mv_get_value (mv, j);
1077
1078           write_int (w, 8);
1079           write_bytes (w, value->s, 8);
1080         }
1081     }
1082 }
1083
1084 static void
1085 write_encoding_record (struct sfm_writer *w,
1086                        const struct dictionary *d)
1087 {
1088   /* IANA says "...character set names may be up to 40 characters taken
1089      from the printable characters of US-ASCII," so character set names
1090      don't need to be recoded to be in UTF-8.
1091
1092      We convert encoding names to uppercase because SPSS writes encoding
1093      names in uppercase. */
1094   char *encoding = xstrdup (dict_get_encoding (d));
1095   str_uppercase (encoding);
1096   write_string_record (w, ss_cstr (encoding), 20);
1097   free (encoding);
1098 }
1099
1100 /* Writes the long variable name table. */
1101 static void
1102 write_longvar_table (struct sfm_writer *w, const struct dictionary *dict)
1103 {
1104   struct string map;
1105   size_t i;
1106
1107   ds_init_empty (&map);
1108   for (i = 0; i < dict_get_n_vars (dict); i++)
1109     {
1110       struct variable *v = dict_get_var (dict, i);
1111       if (i)
1112         ds_put_byte (&map, '\t');
1113       ds_put_format (&map, "%s=%s",
1114                      var_get_short_name (v, 0), var_get_name (v));
1115     }
1116   write_utf8_record (w, dict_get_encoding (dict), &map, 13);
1117   ds_destroy (&map);
1118 }
1119
1120 /* Write integer information record. */
1121 static void
1122 write_integer_info_record (struct sfm_writer *w,
1123                            const struct dictionary *d)
1124 {
1125   const char *dict_encoding = dict_get_encoding (d);
1126   int version_component[3];
1127   int float_format;
1128   int codepage;
1129
1130   /* Parse the version string. */
1131   memset (version_component, 0, sizeof version_component);
1132   sscanf (bare_version, "%d.%d.%d",
1133           &version_component[0], &version_component[1], &version_component[2]);
1134
1135   /* Figure out the floating-point format. */
1136   if (FLOAT_NATIVE_64_BIT == FLOAT_IEEE_DOUBLE_LE
1137       || FLOAT_NATIVE_64_BIT == FLOAT_IEEE_DOUBLE_BE)
1138     float_format = 1;
1139   else if (FLOAT_NATIVE_64_BIT == FLOAT_Z_LONG)
1140     float_format = 2;
1141   else if (FLOAT_NATIVE_64_BIT == FLOAT_VAX_D)
1142     float_format = 3;
1143   else
1144     abort ();
1145
1146   /* Choose codepage. */
1147   codepage = sys_get_codepage_from_encoding (dict_encoding);
1148   if (codepage == 0)
1149     {
1150       /* The codepage is unknown.  Choose a default.
1151
1152          For an EBCDIC-compatible encoding, use the value for EBCDIC.
1153
1154          For an ASCII-compatible encoding, default to "7-bit ASCII", because
1155          many files use this codepage number regardless of their actual
1156          encoding.
1157       */
1158       if (is_encoding_ascii_compatible (dict_encoding))
1159         codepage = 2;
1160       else if (is_encoding_ebcdic_compatible (dict_encoding))
1161         codepage = 1;
1162     }
1163
1164   /* Write record. */
1165   write_int (w, 7);             /* Record type. */
1166   write_int (w, 3);             /* Record subtype. */
1167   write_int (w, 4);             /* Data item (int32) size. */
1168   write_int (w, 8);             /* Number of data items. */
1169   write_int (w, version_component[0]);
1170   write_int (w, version_component[1]);
1171   write_int (w, version_component[2]);
1172   write_int (w, -1);          /* Machine code. */
1173   write_int (w, float_format);
1174   write_int (w, 1);           /* Compression code. */
1175   write_int (w, INTEGER_NATIVE == INTEGER_MSB_FIRST ? 1 : 2);
1176   write_int (w, codepage);
1177 }
1178
1179 /* Write floating-point information record. */
1180 static void
1181 write_float_info_record (struct sfm_writer *w)
1182 {
1183   write_int (w, 7);             /* Record type. */
1184   write_int (w, 4);             /* Record subtype. */
1185   write_int (w, 8);             /* Data item (flt64) size. */
1186   write_int (w, 3);             /* Number of data items. */
1187   write_float (w, SYSMIS);      /* System-missing value. */
1188   write_float (w, HIGHEST);     /* Value used for HIGHEST in missing values. */
1189   write_float (w, LOWEST);      /* Value used for LOWEST in missing values. */
1190 }
1191 \f
1192 /* Writes case C to system file W. */
1193 static void
1194 sys_file_casewriter_write (struct casewriter *writer, void *w_,
1195                            struct ccase *c)
1196 {
1197   struct sfm_writer *w = w_;
1198
1199   if (ferror (w->file))
1200     {
1201       casewriter_force_error (writer);
1202       case_unref (c);
1203       return;
1204     }
1205
1206   w->n_cases++;
1207
1208   if (w->compression == ANY_COMP_NONE)
1209     write_case_uncompressed (w, c);
1210   else
1211     write_case_compressed (w, c);
1212
1213   case_unref (c);
1214 }
1215
1216 /* Destroys system file writer W. */
1217 static void
1218 sys_file_casewriter_destroy (struct casewriter *writer, void *w_)
1219 {
1220   struct sfm_writer *w = w_;
1221   if (!close_writer (w))
1222     casewriter_force_error (writer);
1223 }
1224
1225 /* Returns true if an I/O error has occurred on WRITER, false otherwise. */
1226 static bool
1227 write_error (const struct sfm_writer *writer)
1228 {
1229   return ferror (writer->file);
1230 }
1231
1232 /* Closes a system file after we're done with it.
1233    Returns true if successful, false if an I/O error occurred. */
1234 static bool
1235 close_writer (struct sfm_writer *w)
1236 {
1237   bool ok;
1238
1239   if (w == NULL)
1240     return true;
1241
1242   ok = true;
1243   if (w->file != NULL)
1244     {
1245       /* Flush buffer. */
1246       flush_compressed (w);
1247       if (w->compression == ANY_COMP_ZLIB)
1248         {
1249           finish_zstream (w);
1250           write_ztrailer (w);
1251         }
1252       fflush (w->file);
1253
1254       ok = !write_error (w);
1255
1256       /* Seek back to the beginning and update the number of cases.
1257          This is just a courtesy to later readers, so there's no need
1258          to check return values or report errors. */
1259       if (ok && w->n_cases <= INT32_MAX && !fseeko (w->file, 80, SEEK_SET))
1260         {
1261           write_int (w, w->n_cases);
1262           clearerr (w->file);
1263         }
1264
1265       if (fclose (w->file) == EOF)
1266         ok = false;
1267
1268       if (!ok)
1269         msg (ME, _("An I/O error occurred writing system file `%s'."),
1270              fh_get_file_name (w->fh));
1271
1272       if (ok ? !replace_file_commit (w->rf) : !replace_file_abort (w->rf))
1273         ok = false;
1274     }
1275
1276   free (w->blocks);
1277
1278   fh_unlock (w->lock);
1279   fh_unref (w->fh);
1280
1281   free (w->sfm_vars);
1282   free (w);
1283
1284   return ok;
1285 }
1286
1287 /* System file writer casewriter class. */
1288 static const struct casewriter_class sys_file_casewriter_class =
1289   {
1290     sys_file_casewriter_write,
1291     sys_file_casewriter_destroy,
1292     NULL,
1293   };
1294 \f
1295 /* Writes case C to system file W, without compressing it. */
1296 static void
1297 write_case_uncompressed (struct sfm_writer *w, const struct ccase *c)
1298 {
1299   size_t i;
1300
1301   for (i = 0; i < w->sfm_n_vars; i++)
1302     {
1303       struct sfm_var *v = &w->sfm_vars[i];
1304
1305       if (v->var_width == 0)
1306         write_float (w, case_num_idx (c, v->case_index));
1307       else
1308         {
1309           write_bytes (w, case_str_idx (c, v->case_index) + v->offset,
1310                        v->segment_width);
1311           write_spaces (w, v->padding);
1312         }
1313     }
1314 }
1315
1316 /* Writes case C to system file W, with compression. */
1317 static void
1318 write_case_compressed (struct sfm_writer *w, const struct ccase *c)
1319 {
1320   size_t i;
1321
1322   for (i = 0; i < w->sfm_n_vars; i++)
1323     {
1324       struct sfm_var *v = &w->sfm_vars[i];
1325
1326       if (v->var_width == 0)
1327         {
1328           double d = case_num_idx (c, v->case_index);
1329           if (d == SYSMIS)
1330             put_cmp_opcode (w, 255);
1331           else if (d >= 1 - COMPRESSION_BIAS
1332                    && d <= 251 - COMPRESSION_BIAS
1333                    && d == (int) d)
1334             put_cmp_opcode (w, (int) d + COMPRESSION_BIAS);
1335           else
1336             put_cmp_number (w, d);
1337         }
1338       else
1339         {
1340           int offset = v->offset;
1341           int width, padding;
1342
1343           /* This code properly deals with a width that is not a
1344              multiple of 8, by ensuring that the final partial
1345              oct (8 byte unit) is treated as padded with spaces
1346              on the right. */
1347           for (width = v->segment_width; width > 0; width -= 8, offset += 8)
1348             {
1349               const void *data = case_str_idx (c, v->case_index) + offset;
1350               int chunk_size = MIN (width, 8);
1351               if (!memcmp (data, "        ", chunk_size))
1352                 put_cmp_opcode (w, 254);
1353               else
1354                 put_cmp_string (w, data, chunk_size);
1355             }
1356
1357           /* This code deals properly with padding that is not a
1358              multiple of 8 bytes, by discarding the remainder,
1359              which was already effectively padded with spaces in
1360              the previous loop.  (Note that v->width + v->padding
1361              is always a multiple of 8.) */
1362           for (padding = v->padding / 8; padding > 0; padding--)
1363             put_cmp_opcode (w, 254);
1364         }
1365     }
1366 }
1367
1368 static bool
1369 start_zstream (struct sfm_writer *w)
1370 {
1371   int error;
1372
1373   error = deflateInit (&w->zstream, 1);
1374   if (error != Z_OK)
1375     {
1376       msg (ME, _("Failed to initialize ZLIB for compression (%s)."),
1377            w->zstream.msg);
1378       return false;
1379     }
1380   return true;
1381 }
1382
1383 static void
1384 finish_zstream (struct sfm_writer *w)
1385 {
1386   struct zblock *block;
1387   int error;
1388
1389   assert (w->zstream.total_in <= ZBLOCK_SIZE);
1390
1391   w->zstream.next_in = NULL;
1392   w->zstream.avail_in = 0;
1393   do
1394     {
1395       uint8_t buf[4096];
1396
1397       w->zstream.next_out = buf;
1398       w->zstream.avail_out = sizeof buf;
1399       error = deflate (&w->zstream, Z_FINISH);
1400       write_bytes (w, buf, w->zstream.next_out - buf);
1401     }
1402   while (error == Z_OK);
1403
1404   if (error != Z_STREAM_END)
1405     msg (ME, _("Failed to complete ZLIB stream compression (%s)."),
1406          w->zstream.msg);
1407
1408   if (w->n_blocks >= w->allocated_blocks)
1409     w->blocks = x2nrealloc (w->blocks, &w->allocated_blocks,
1410                             sizeof *w->blocks);
1411   block = &w->blocks[w->n_blocks++];
1412   block->uncompressed_size = w->zstream.total_in;
1413   block->compressed_size = w->zstream.total_out;
1414   deflateEnd (&w->zstream);
1415 }
1416
1417 static void
1418 write_zlib (struct sfm_writer *w, const void *data_, unsigned int n)
1419 {
1420   const uint8_t *data = data_;
1421
1422   while (n > 0)
1423     {
1424       unsigned int chunk;
1425
1426       if (w->zstream.total_in >= ZBLOCK_SIZE)
1427         {
1428           finish_zstream (w);
1429           start_zstream (w);
1430         }
1431
1432       chunk = MIN (n, ZBLOCK_SIZE - w->zstream.total_in);
1433
1434       w->zstream.next_in = CONST_CAST (uint8_t *, data);
1435       w->zstream.avail_in = chunk;
1436       do
1437         {
1438           uint8_t buf[4096];
1439           int error;
1440
1441           w->zstream.next_out = buf;
1442           w->zstream.avail_out = sizeof buf;
1443           error = deflate (&w->zstream, Z_NO_FLUSH);
1444           write_bytes (w, buf, w->zstream.next_out - buf);
1445           if (error != Z_OK)
1446             {
1447               msg (ME, _("ZLIB stream compression failed (%s)."),
1448                    w->zstream.msg);
1449               return;
1450             }
1451         }
1452       while (w->zstream.avail_in > 0 || w->zstream.avail_out == 0);
1453       data += chunk;
1454       n -= chunk;
1455     }
1456 }
1457
1458 static void
1459 write_ztrailer (struct sfm_writer *w)
1460 {
1461   long long int uncompressed_ofs;
1462   long long int compressed_ofs;
1463   const struct zblock *block;
1464
1465   write_int64 (w, -COMPRESSION_BIAS);
1466   write_int64 (w, 0);
1467   write_int (w, ZBLOCK_SIZE);
1468   write_int (w, w->n_blocks);
1469
1470   uncompressed_ofs = w->zstart;
1471   compressed_ofs = w->zstart + 24;
1472   for (block = w->blocks; block < &w->blocks[w->n_blocks]; block++)
1473     {
1474       write_int64 (w, uncompressed_ofs);
1475       write_int64 (w, compressed_ofs);
1476       write_int (w, block->uncompressed_size);
1477       write_int (w, block->compressed_size);
1478
1479       uncompressed_ofs += block->uncompressed_size;
1480       compressed_ofs += block->compressed_size;
1481     }
1482
1483   if (!fseeko (w->file, w->zstart + 8, SEEK_SET))
1484     {
1485       write_int64 (w, compressed_ofs);
1486       write_int64 (w, 24 + (w->n_blocks * 24));
1487     }
1488   else
1489     msg (ME, _("%s: Seek failed (%s)."),
1490          fh_get_file_name (w->fh), strerror (errno));
1491 }
1492
1493 /* Flushes buffered compressed opcodes and data to W. */
1494 static void
1495 flush_compressed (struct sfm_writer *w)
1496 {
1497   if (w->n_opcodes)
1498     {
1499       unsigned int n = 8 * (1 + w->n_elements);
1500       if (w->compression == ANY_COMP_SIMPLE)
1501         write_bytes (w, w->cbuf, n);
1502       else
1503         write_zlib (w, w->cbuf, n);
1504
1505       w->n_opcodes = w->n_elements = 0;
1506       memset (w->cbuf[0], 0, 8);
1507     }
1508 }
1509
1510 /* Appends OPCODE to the buffered set of compression opcodes in
1511    W.  Flushes the compression buffer beforehand if necessary. */
1512 static void
1513 put_cmp_opcode (struct sfm_writer *w, uint8_t opcode)
1514 {
1515   if (w->n_opcodes >= 8)
1516     flush_compressed (w);
1517
1518   w->cbuf[0][w->n_opcodes++] = opcode;
1519 }
1520
1521 /* Appends NUMBER to the buffered compression data in W. */
1522 static void
1523 put_cmp_number (struct sfm_writer *w, double number)
1524 {
1525   put_cmp_opcode (w, 253);
1526   convert_double_to_output_format (number, w->cbuf[++w->n_elements]);
1527 }
1528
1529 /* Appends SIZE bytes of DATA to the buffered compression data in
1530    W, followed by enough spaces to pad the output data to exactly
1531    8 bytes (thus, SIZE must be no greater than 8). */
1532 static void
1533 put_cmp_string (struct sfm_writer *w, const void *data, size_t size)
1534 {
1535   assert (size <= 8);
1536
1537   put_cmp_opcode (w, 253);
1538   w->n_elements++;
1539   memset (w->cbuf[w->n_elements], w->space, 8);
1540   memcpy (w->cbuf[w->n_elements], data, size);
1541 }
1542 \f
1543 /* Writes 32-bit integer X to the output file for writer W. */
1544 static void
1545 write_int (struct sfm_writer *w, int32_t x)
1546 {
1547   write_bytes (w, &x, sizeof x);
1548 }
1549
1550 /* Writes 64-bit integer X to the output file for writer W. */
1551 static void
1552 write_int64 (struct sfm_writer *w, int64_t x)
1553 {
1554   write_bytes (w, &x, sizeof x);
1555 }
1556
1557 /* Converts NATIVE to the 64-bit format used in output files in
1558    OUTPUT. */
1559 static inline void
1560 convert_double_to_output_format (double native, uint8_t output[8])
1561 {
1562   /* If "double" is not a 64-bit type, then convert it to a
1563      64-bit type.  Otherwise just copy it. */
1564   if (FLOAT_NATIVE_DOUBLE != FLOAT_NATIVE_64_BIT)
1565     float_convert (FLOAT_NATIVE_DOUBLE, &native, FLOAT_NATIVE_64_BIT, output);
1566   else
1567     memcpy (output, &native, sizeof native);
1568 }
1569
1570 /* Writes floating-point number X to the output file for writer
1571    W. */
1572 static void
1573 write_float (struct sfm_writer *w, double x)
1574 {
1575   uint8_t output[8];
1576   convert_double_to_output_format (x, output);
1577   write_bytes (w, output, sizeof output);
1578 }
1579
1580 /* Writes contents of VALUE with the given WIDTH to W, padding
1581    with zeros to a multiple of 8 bytes.
1582    To avoid a branch, and because we don't actually need to
1583    support it, WIDTH must be no bigger than 8. */
1584 static void
1585 write_value (struct sfm_writer *w, const union value *value, int width)
1586 {
1587   assert (width <= 8);
1588   if (width == 0)
1589     write_float (w, value->f);
1590   else
1591     {
1592       write_bytes (w, value->s, width);
1593       write_zeros (w, 8 - width);
1594     }
1595 }
1596
1597 /* Writes null-terminated STRING in a field of the given WIDTH to W.  If STRING
1598    is longer than WIDTH, it is truncated; if STRING is shorter than WIDTH, it
1599    is padded on the right with spaces. */
1600 static void
1601 write_string (struct sfm_writer *w, const char *string, size_t width)
1602 {
1603   size_t data_bytes = MIN (strlen (string), width);
1604   size_t pad_bytes = width - data_bytes;
1605   write_bytes (w, string, data_bytes);
1606   while (pad_bytes-- > 0)
1607     putc (w->space, w->file);
1608 }
1609
1610 /* Recodes null-terminated UTF-8 encoded STRING into ENCODING, and writes the
1611    recoded version in a field of the given WIDTH to W.  The string is truncated
1612    or padded on the right with spaces to exactly WIDTH bytes. */
1613 static void
1614 write_utf8_string (struct sfm_writer *w, const char *encoding,
1615                    const char *string, size_t width)
1616 {
1617   char *s = recode_string (encoding, "UTF-8", string, -1);
1618   write_string (w, s, width);
1619   free (s);
1620 }
1621
1622 /* Writes a record with type 7, subtype SUBTYPE that contains CONTENT recoded
1623    from UTF-8 encoded into ENCODING. */
1624 static void
1625 write_utf8_record (struct sfm_writer *w, const char *encoding,
1626                    const struct string *content, int subtype)
1627 {
1628   struct substring s;
1629
1630   s = recode_substring_pool (encoding, "UTF-8", ds_ss (content), NULL);
1631   write_string_record (w, s, subtype);
1632   ss_dealloc (&s);
1633 }
1634
1635 /* Writes a record with type 7, subtype SUBTYPE that contains the string
1636    CONTENT. */
1637 static void
1638 write_string_record (struct sfm_writer *w,
1639                      const struct substring content, int subtype)
1640 {
1641   write_int (w, 7);
1642   write_int (w, subtype);
1643   write_int (w, 1);
1644   write_int (w, ss_length (content));
1645   write_bytes (w, ss_data (content), ss_length (content));
1646 }
1647
1648 /* Writes SIZE bytes of DATA to W's output file. */
1649 static void
1650 write_bytes (struct sfm_writer *w, const void *data, size_t size)
1651 {
1652   fwrite (data, 1, size, w->file);
1653 }
1654
1655 /* Writes N zeros to W's output file. */
1656 static void
1657 write_zeros (struct sfm_writer *w, size_t n)
1658 {
1659   while (n-- > 0)
1660     putc (0, w->file);
1661 }
1662
1663 /* Writes N spaces to W's output file. */
1664 static void
1665 write_spaces (struct sfm_writer *w, size_t n)
1666 {
1667   while (n-- > 0)
1668     putc (w->space, w->file);
1669 }