Fix assertion for proper Huffman merge pattern: 0 == 1 modulo 1.
[pspp] / src / pfm-write.c
1 /* PSPP - computes sample statistics.
2    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
3    Written by Ben Pfaff <blp@gnu.org>.
4
5    This program is free software; you can redistribute it and/or
6    modify it under the terms of the GNU General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    This program is distributed in the hope that it will be useful, but
11    WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software
17    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
18    02111-1307, USA. */
19
20 #include <config.h>
21 #include "pfm-write.h"
22 #include "error.h"
23 #include <ctype.h>
24 #include <errno.h>
25 #include <float.h>
26 #include <math.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <time.h>
30 #include "alloc.h"
31 #include "case.h"
32 #include "dictionary.h"
33 #include "error.h"
34 #include "file-handle.h"
35 #include "gmp.h"
36 #include "hash.h"
37 #include "magic.h"
38 #include "str.h"
39 #include "value-labels.h"
40 #include "var.h"
41 #include "version.h"
42
43 #include "debug-print.h"
44
45 /* Portable file writer. */
46 struct pfm_writer
47   {
48     struct file_handle *fh;     /* File handle. */
49     FILE *file;                 /* File stream. */
50
51     int lc;                     /* Number of characters on this line so far. */
52
53     size_t var_cnt;             /* Number of variables. */
54     struct pfm_var *vars;       /* Variables. */
55   };
56
57 /* A variable to write to the portable file. */
58 struct pfm_var 
59   {
60     int width;                  /* 0=numeric, otherwise string var width. */
61     int fv;                     /* Starting case index. */
62   };
63
64 static int buf_write (struct pfm_writer *, const void *, size_t);
65 static int write_header (struct pfm_writer *);
66 static int write_version_data (struct pfm_writer *);
67 static int write_variables (struct pfm_writer *, const struct dictionary *);
68 static int write_value_labels (struct pfm_writer *, const struct dictionary *);
69
70 /* Writes the dictionary DICT to portable file HANDLE.  Returns
71    nonzero only if successful. */
72 struct pfm_writer *
73 pfm_open_writer (struct file_handle *fh, const struct dictionary *dict)
74 {
75   struct pfm_writer *w = NULL;
76   size_t i;
77
78   if (!fh_open (fh, "portable file", "we"))
79     goto error;
80   
81   /* Open the physical disk file. */
82   w = xmalloc (sizeof *w);
83   w->fh = fh;
84   w->file = fopen (handle_get_filename (fh), "wb");
85   w->lc = 0;
86   w->var_cnt = 0;
87   w->vars = NULL;
88   
89   /* Check that file create succeeded. */
90   if (w->file == NULL)
91     {
92       msg (ME, _("An error occurred while opening \"%s\" for writing "
93            "as a portable file: %s."),
94            handle_get_filename (fh), strerror (errno));
95       err_cond_fail ();
96       goto error;
97     }
98   
99   w->var_cnt = dict_get_var_cnt (dict);
100   w->vars = xmalloc (sizeof *w->vars * w->var_cnt);
101   for (i = 0; i < w->var_cnt; i++) 
102     {
103       const struct variable *dv = dict_get_var (dict, i);
104       struct pfm_var *pv = &w->vars[i];
105       pv->width = dv->width;
106       pv->fv = dv->fv;
107     }
108
109   /* Write file header. */
110   if (!write_header (w)
111       || !write_version_data (w)
112       || !write_variables (w, dict)
113       || !write_value_labels (w, dict)
114       || !buf_write (w, "F", 1))
115     goto error;
116
117   return w;
118
119 error:
120   pfm_close_writer (w);
121   return NULL;
122 }
123 \f  
124 /* Write NBYTES starting at BUF to the portable file represented by
125    H.  Break lines properly every 80 characters.  */
126 static int
127 buf_write (struct pfm_writer *w, const void *buf_, size_t nbytes)
128 {
129   const char *buf = buf_;
130
131   assert (buf != NULL);
132   while (nbytes + w->lc >= 80)
133     {
134       size_t n = 80 - w->lc;
135       
136       if (n && fwrite (buf, n, 1, w->file) != 1)
137         goto error;
138       
139       if (fwrite ("\r\n", 2, 1, w->file) != 1)
140         goto error;
141
142       nbytes -= n;
143       buf += n;
144       w->lc = 0;
145     }
146
147   if (nbytes && 1 != fwrite (buf, nbytes, 1, w->file))
148     goto error;
149   w->lc += nbytes;
150   
151   return 1;
152
153  error:
154   msg (ME, _("%s: Writing portable file: %s."),
155        handle_get_filename (w->fh), strerror (errno));
156   return 0;
157 }
158
159 /* Write D to the portable file as a floating-point field, and return
160    success. */
161 static int
162 write_float (struct pfm_writer *w, double d)
163 {
164   int neg = 0;
165   char *mantissa;
166   int mantissa_len;
167   mp_exp_t exponent;
168   char *buf, *cp;
169   int success;
170
171   if (d < 0.)
172     {
173       d = -d;
174       neg = 1;
175     }
176   
177   if (d == fabs (SYSMIS) || d == HUGE_VAL)
178     return buf_write (w, "*.", 2);
179   
180   /* Use GNU libgmp2 to convert D into base-30. */
181   {
182     mpf_t f;
183     
184     mpf_init_set_d (f, d);
185     mantissa = mpf_get_str (NULL, &exponent, 30, 0, f);
186     mpf_clear (f);
187
188     for (cp = mantissa; *cp; cp++)
189       *cp = toupper (*cp);
190   }
191   
192   /* Choose standard or scientific notation. */
193   mantissa_len = (int) strlen (mantissa);
194   cp = buf = local_alloc (mantissa_len + 32);
195   if (neg)
196     *cp++ = '-';
197   if (mantissa_len == 0)
198     *cp++ = '0';
199   else if (exponent < -4 || exponent > (mp_exp_t) mantissa_len)
200     {
201       /* Scientific notation. */
202       *cp++ = mantissa[0];
203       *cp++ = '.';
204       cp = stpcpy (cp, &mantissa[1]);
205       cp = spprintf (cp, "%+ld", (long) (exponent - 1));
206     }
207   else if (exponent <= 0)
208     {
209       /* Standard notation, D <= 1. */
210       *cp++ = '.';
211       memset (cp, '0', -exponent);
212       cp += -exponent;
213       cp = stpcpy (cp, mantissa);
214     }
215   else 
216     {
217       /* Standard notation, D > 1. */
218       memcpy (cp, mantissa, exponent);
219       cp += exponent;
220       *cp++ = '.';
221       cp = stpcpy (cp, &mantissa[exponent]);
222     }
223   *cp++ = '/';
224   
225   success = buf_write (w, buf, cp - buf);
226   local_free (buf);
227   free (mantissa);
228   return success;
229 }
230
231 /* Write N to the portable file as an integer field, and return success. */
232 static int
233 write_int (struct pfm_writer *w, int n)
234 {
235   char buf[64];
236   char *bp = &buf[64];
237   int neg = 0;
238
239   *--bp = '/';
240   
241   if (n < 0)
242     {
243       n = -n;
244       neg = 1;
245     }
246   
247   do
248     {
249       int r = n % 30;
250
251       /* PORTME: character codes. */
252       if (r < 10)
253         *--bp = r + '0';
254       else
255         *--bp = r - 10 + 'A';
256
257       n /= 30;
258     }
259   while (n > 0);
260
261   if (neg)
262     *--bp = '-';
263
264   return buf_write (w, bp, &buf[64] - bp);
265 }
266
267 /* Write S to the portable file as a string field. */
268 static int
269 write_string (struct pfm_writer *w, const char *s)
270 {
271   size_t n = strlen (s);
272   return write_int (w, (int) n) && buf_write (w, s, n);
273 }
274 \f
275 /* Write file header. */
276 static int
277 write_header (struct pfm_writer *w)
278 {
279   /* PORTME. */
280   {
281     int i;
282
283     for (i = 0; i < 5; i++)
284       if (!buf_write (w, "ASCII SPSS PORT FILE                    ", 40))
285         return 0;
286   }
287   
288   {
289     /* PORTME: Translation table from SPSS character code to this
290        computer's native character code (which is probably ASCII). */
291     static const unsigned char spss2ascii[256] =
292       {
293         "0000000000000000000000000000000000000000000000000000000000000000"
294         "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ."
295         "<(+|&[]!$*);^-/|,%_>?`:$@'=\"000000~-0000123456789000-()0{}\\00000"
296         "0000000000000000000000000000000000000000000000000000000000000000"
297       };
298
299     if (!buf_write (w, spss2ascii, 256))
300       return 0;
301   }
302
303   if (!buf_write (w, "SPSSPORT", 8))
304     return 0;
305
306   return 1;
307 }
308
309 /* Writes version, date, and identification records. */
310 static int
311 write_version_data (struct pfm_writer *w)
312 {
313   if (!buf_write (w, "A", 1))
314     return 0;
315   
316   {
317     char date_str[9];
318     char time_str[7];
319     time_t t;
320     struct tm tm;
321     struct tm *tmp;
322
323     if ((time_t) -1 == time (&t))
324       {
325         tm.tm_sec = tm.tm_min = tm.tm_hour = tm.tm_mon = tm.tm_year = 0;
326         tm.tm_mday = 1;
327         tmp = &tm;
328       }
329     else 
330       tmp = localtime (&t);
331     
332     sprintf (date_str, "%04d%02d%02d",
333              tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday);
334     sprintf (time_str, "%02d%02d%02d", tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
335     if (!write_string (w, date_str) || !write_string (w, time_str))
336       return 0;
337   }
338
339   /* Product identification. */
340   if (!buf_write (w, "1", 1) || !write_string (w, version))
341     return 0;
342
343   /* Subproduct identification. */
344   if (!buf_write (w, "3", 1) || !write_string (w, host_system))
345     return 0;
346
347   return 1;
348 }
349
350 /* Write format F to file H, and return success. */
351 static int
352 write_format (struct pfm_writer *w, struct fmt_spec *f)
353 {
354   return (write_int (w, formats[f->type].spss)
355           && write_int (w, f->w)
356           && write_int (w, f->d));
357 }
358
359 /* Write value V for variable VV to file H, and return success. */
360 static int
361 write_value (struct pfm_writer *w, union value *v, struct variable *vv)
362 {
363   if (vv->type == NUMERIC)
364     return write_float (w, v->f);
365   else
366     return write_int (w, vv->width) && buf_write (w, v->s, vv->width);
367 }
368
369 /* Write variable records, and return success. */
370 static int
371 write_variables (struct pfm_writer *w, const struct dictionary *dict)
372 {
373   int i;
374   
375   if (!buf_write (w, "4", 1) || !write_int (w, dict_get_var_cnt (dict))
376       || !write_int (w, 161))
377     return 0;
378
379   for (i = 0; i < dict_get_var_cnt (dict); i++)
380     {
381       static const char *miss_types[MISSING_COUNT] =
382         {
383           "", "8", "88", "888", "B ", "9", "A", "B 8", "98", "A8",
384         };
385
386       const char *m;
387       int j;
388
389       struct variable *v = dict_get_var (dict, i);
390       
391       if (!buf_write (w, "7", 1) || !write_int (w, v->width)
392           || !write_string (w, v->name)
393           || !write_format (w, &v->print) || !write_format (w, &v->write))
394         return 0;
395
396       for (m = miss_types[v->miss_type], j = 0; j < (int) strlen (m); j++)
397         if ((m[j] != ' ' && !buf_write (w, &m[j], 1))
398             || !write_value (w, &v->missing[j], v))
399           return 0;
400
401       if (v->label && (!buf_write (w, "C", 1) || !write_string (w, v->label)))
402         return 0;
403     }
404
405   return 1;
406 }
407
408 /* Write value labels to disk.  FIXME: Inefficient. */
409 static int
410 write_value_labels (struct pfm_writer *w, const struct dictionary *dict)
411 {
412   int i;
413
414   for (i = 0; i < dict_get_var_cnt (dict); i++)
415     {
416       struct val_labs_iterator *j;
417       struct variable *v = dict_get_var (dict, i);
418       struct val_lab *vl;
419
420       if (!val_labs_count (v->val_labs))
421         continue;
422
423       if (!buf_write (w, "D", 1)
424           || !write_int (w, 1)
425           || !write_string (w, v->name)
426           || !write_int (w, val_labs_count (v->val_labs)))
427         return 0;
428
429       for (vl = val_labs_first_sorted (v->val_labs, &j); vl != NULL;
430            vl = val_labs_next (v->val_labs, &j)) 
431         if (!write_value (w, &vl->value, v)
432             || !write_string (w, vl->label)) 
433           {
434             val_labs_done (&j);
435             return 0; 
436           }
437     }
438
439   return 1;
440 }
441
442 /* Writes case ELEM to the portable file represented by H.  Returns
443    success. */
444 int 
445 pfm_write_case (struct pfm_writer *w, struct ccase *c)
446 {
447   int i;
448   
449   for (i = 0; i < w->var_cnt; i++)
450     {
451       struct pfm_var *v = &w->vars[i];
452       
453       if (v->width == 0)
454         {
455           if (!write_float (w, case_num (c, v->fv)))
456             return 0;
457         }
458       else
459         {
460           if (!write_int (w, v->width)
461               || !buf_write (w, case_str (c, v->fv), v->width))
462             return 0;
463         }
464     }
465
466   return 1;
467 }
468
469 /* Closes a portable file after we're done with it. */
470 void
471 pfm_close_writer (struct pfm_writer *w)
472 {
473   if (w == NULL)
474     return;
475
476   fh_close (w->fh, "portable file", "we");
477   
478   if (w->file != NULL)
479     {
480       char buf[80];
481     
482       int n = 80 - w->lc;
483       if (n == 0)
484         n = 80;
485
486       memset (buf, 'Z', n);
487       buf_write (w, buf, n);
488
489       if (fclose (w->file) == EOF)
490         msg (ME, _("%s: Closing portable file: %s."),
491              handle_get_filename (w->fh), strerror (errno));
492     }
493
494   free (w->vars);
495   free (w);
496 }