X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fdata-io%2Fdata-writer.c;h=5f87d0060ac589a27c0713ba8cfc38ca91329642;hb=db161068bfd5b6685f909f39b2a4701ed4941b03;hp=0680fc410d0533df8e78b43ea566fea134da8794;hpb=43b1296aafe7582e7dbe6c2b6a8b478d7d9b0fcf;p=pspp diff --git a/src/language/data-io/data-writer.c b/src/language/data-io/data-writer.c index 0680fc410d..5f87d0060a 100644 --- a/src/language/data-io/data-writer.c +++ b/src/language/data-io/data-writer.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 1997-2004, 2006 Free Software Foundation, Inc. + Copyright (C) 1997-2004, 2006, 2010, 2011, 2012, 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 @@ -16,61 +16,103 @@ #include -#include +#include "language/data-io/data-writer.h" #include #include +#include #include +#include -#include -#include -#include -#include -#include -#include +#include "data/file-name.h" +#include "data/make-file.h" +#include "language/data-io/file-handle.h" +#include "libpspp/assertion.h" +#include "libpspp/encoding-guesser.h" +#include "libpspp/integer-format.h" +#include "libpspp/i18n.h" +#include "libpspp/message.h" +#include "libpspp/str.h" -#include "minmax.h" +#include "gl/minmax.h" +#include "gl/xalloc.h" #include "gettext.h" #define _(msgid) gettext (msgid) +#define N_(msgid) (msgid) /* Data file writer. */ struct dfm_writer { struct file_handle *fh; /* File handle. */ + struct fh_lock *lock; /* Exclusive access to file. */ FILE *file; /* Associated file. */ + struct replace_file *rf; /* Atomic file replacement support. */ + char *encoding; /* Encoding. */ + enum fh_line_ends line_ends; /* Line ends for text files. */ + + int unit; /* Unit width, in bytes. */ + char cr[MAX_UNIT]; /* \r in encoding, 'unit' bytes long. */ + char lf[MAX_UNIT]; /* \n in encoding, 'unit' bytes long. */ + char spaces[32]; /* 32 bytes worth of ' ' in encoding. */ }; -/* Opens a file handle for writing as a data file. */ +/* Opens a file handle for writing as a data file. + + The encoding of the file written is by default that of FH itself. If + ENCODING is nonnull, then it overrides the default encoding. + + *However*: ENCODING directly affects only text strings written by the data + writer code itself, that is, new-lines in FH_MODE_TEXT and space padding in + FH_MODE_FIXED mode. The client must do its own encoding translation for the + data that it writes. (This is unavoidable because sometimes the data + written includes binary data that reencoding would mangle.) The client can + obtain the encoding to re-encode into with dfm_writer_get_encoding(). */ struct dfm_writer * -dfm_open_writer (struct file_handle *fh) +dfm_open_writer (struct file_handle *fh, const char *encoding) { + struct encoding_info ei; struct dfm_writer *w; - void **aux; + struct fh_lock *lock; + int ofs; - aux = fh_open (fh, FH_REF_FILE, "data file", "ws"); - if (aux == NULL) + lock = fh_lock (fh, FH_REF_FILE, N_("data file"), FH_ACC_WRITE, false); + if (lock == NULL) return NULL; - if (*aux != NULL) - return *aux; - - w = *aux = xmalloc (sizeof *w); - w->fh = fh; - w->file = fn_open (fh_get_file_name (w->fh), "wb"); - if (w->file == NULL) + w = fh_lock_get_aux (lock); + if (w != NULL) + return w; + + encoding = encoding_guess_parse_encoding (encoding != NULL + ? encoding + : fh_get_encoding (fh)); + get_encoding_info (&ei, encoding); + + w = xmalloc (sizeof *w); + w->fh = fh_ref (fh); + w->lock = lock; + w->rf = replace_file_start (fh_get_file_name (w->fh), "wb", 0666, + &w->file, NULL); + w->encoding = xstrdup (encoding); + w->line_ends = fh_get_line_ends (fh); + w->unit = ei.unit; + memcpy (w->cr, ei.cr, sizeof w->cr); + memcpy (w->lf, ei.lf, sizeof w->lf); + for (ofs = 0; ofs + ei.unit <= sizeof w->spaces; ofs += ei.unit) + memcpy (&w->spaces[ofs], ei.space, ei.unit); + + if (w->rf == NULL) { - msg (ME, _("An error occurred while opening \"%s\" for writing " + msg (ME, _("An error occurred while opening `%s' for writing " "as a data file: %s."), fh_get_file_name (w->fh), strerror (errno)); - goto error; + dfm_close_writer (w); + return NULL; } + fh_lock_set_aux (lock, w); return w; - - error: - dfm_close_writer (w); - return NULL; } /* Returns false if an I/O error occurred on WRITER, true otherwise. */ @@ -96,10 +138,12 @@ dfm_put_record (struct dfm_writer *w, const char *rec, size_t len) { case FH_MODE_TEXT: fwrite (rec, len, 1, w->file); - putc ('\n', w->file); + if (w->line_ends == FH_END_CRLF) + fwrite (w->cr, w->unit, 1, w->file); + fwrite (w->lf, w->unit, 1, w->file); break; - case FH_MODE_BINARY: + case FH_MODE_FIXED: { size_t record_width = fh_get_record_width (w->fh); size_t write_bytes = MIN (len, record_width); @@ -107,14 +151,52 @@ dfm_put_record (struct dfm_writer *w, const char *rec, size_t len) fwrite (rec, write_bytes, 1, w->file); while (pad_bytes > 0) { - static const char spaces[32] = " "; - size_t chunk = MIN (pad_bytes, sizeof spaces); - fwrite (spaces, chunk, 1, w->file); + size_t chunk = MIN (pad_bytes, sizeof w->spaces); + fwrite (w->spaces, chunk, 1, w->file); pad_bytes -= chunk; } } break; + case FH_MODE_VARIABLE: + { + uint32_t size = len; + integer_convert (INTEGER_NATIVE, &size, INTEGER_LSB_FIRST, &size, + sizeof size); + fwrite (&size, sizeof size, 1, w->file); + fwrite (rec, len, 1, w->file); + fwrite (&size, sizeof size, 1, w->file); + } + break; + + case FH_MODE_360_VARIABLE: + case FH_MODE_360_SPANNED: + { + size_t ofs = 0; + if (fh_get_mode (w->fh) == FH_MODE_360_VARIABLE) + len = MIN (65527, len); + while (ofs < len) + { + size_t chunk = MIN (65527, len - ofs); + uint32_t bdw = (chunk + 8) << 16; + int scc = (ofs == 0 && chunk == len ? 0 + : ofs == 0 ? 1 + : ofs + chunk == len ? 2 + : 3); + uint32_t rdw = ((chunk + 4) << 16) | (scc << 8); + + integer_convert (INTEGER_NATIVE, &bdw, INTEGER_MSB_FIRST, &bdw, + sizeof bdw); + integer_convert (INTEGER_NATIVE, &rdw, INTEGER_MSB_FIRST, &rdw, + sizeof rdw); + fwrite (&bdw, 1, sizeof bdw, w->file); + fwrite (&rdw, 1, sizeof rdw, w->file); + fwrite (rec + ofs, 1, chunk, w->file); + ofs += chunk; + } + } + break; + default: NOT_REACHED (); } @@ -126,28 +208,35 @@ dfm_put_record (struct dfm_writer *w, const char *rec, size_t len) bool dfm_close_writer (struct dfm_writer *w) { - char *file_name; bool ok; if (w == NULL) return true; - file_name = xstrdup (fh_get_name (w->fh)); - if (fh_close (w->fh, "data file", "ws")) - { - free (file_name); - return true; - } + if (fh_unlock (w->lock)) + return true; ok = true; if (w->file != NULL) { + const char *file_name = fh_get_file_name (w->fh); ok = !dfm_write_error (w) && !fn_close (file_name, w->file); if (!ok) - msg (ME, _("I/O error occurred writing data file \"%s\"."), file_name); + msg (ME, _("I/O error occurred writing data file `%s'."), file_name); + + if (ok ? !replace_file_commit (w->rf) : !replace_file_abort (w->rf)) + ok = false; } + fh_unref (w->fh); + free (w->encoding); free (w); - free (file_name); return ok; } + +/* Returns the encoding of data written to WRITER. */ +const char * +dfm_writer_get_encoding (const struct dfm_writer *writer) +{ + return writer->encoding; +}