X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fdata-out.c;h=10ca4ede77f9e4fbe742927ad80a9fce4471d444;hb=811c669032a18cfff53291a98e5803afdf39db36;hp=a30e7e703838a31bab2ca5b4eba1b7ecff1899f3;hpb=c41cd1fefc98bb4abed33754276d93db9ffe2e0e;p=pspp diff --git a/src/data/data-out.c b/src/data/data-out.c index a30e7e7038..10ca4ede77 100644 --- a/src/data/data-out.c +++ b/src/data/data-out.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 1997-9, 2000, 2006, 2009, 2011 Free Software Foundation, Inc. + Copyright (C) 1997-9, 2000, 2006, 2009, 2011, 2012 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,7 +16,7 @@ #include -#include "data-out.h" +#include "data/data-out.h" #include #include @@ -24,22 +24,23 @@ #include #include #include - -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "minmax.h" +#include + +#include "data/calendar.h" +#include "data/format.h" +#include "data/settings.h" +#include "data/value.h" +#include "libpspp/assertion.h" +#include "libpspp/cast.h" +#include "libpspp/float-format.h" +#include "libpspp/i18n.h" +#include "libpspp/integer-format.h" +#include "libpspp/message.h" +#include "libpspp/misc.h" +#include "libpspp/pool.h" +#include "libpspp/str.h" + +#include "gl/minmax.h" #include "gettext.h" #define _(msgid) gettext (msgid) @@ -92,56 +93,103 @@ static data_out_converter_func *const converters[FMT_NUMBER_OF_FORMATS] = #include "format.def" }; -/* Similar to data_out. Additionally recodes the output from - native form into the given legacy character ENCODING. - OUTPUT must be provided by the caller and must be at least - FORMAT->w long. No null terminator is appended to OUTPUT. -*/ +/* Converts the INPUT value, encoded in INPUT_ENCODING, according to format + specification FORMAT, appending the output to OUTPUT in OUTPUT_ENCODING. + However, binary formats (FMT_P, FMT_PK, FMT_IB, FMT_PIB, FMT_RB) yield the + binary results, which may not be properly encoded for OUTPUT_ENCODING. + + VALUE must be the correct width for FORMAT, that is, its width must be + fmt_var_width(FORMAT). + + INPUT_ENCODING can normally be obtained by calling dict_get_encoding() on + the dictionary with which INPUT is associated. ENCODING is only important + when FORMAT's type is FMT_A. */ void -data_out_legacy (const union value *input, const char *encoding, - const struct fmt_spec *format, char *output) +data_out_recode (const union value *input, const char *input_encoding, + const struct fmt_spec *format, + struct string *output, const char *output_encoding) { assert (fmt_check_output (format)); + if (format->type == FMT_A) + { + char *in = CHAR_CAST (char *, value_str (input, format->w)); + char *out = recode_string (output_encoding, input_encoding, + in, format->w); + ds_put_cstr (output, out); + free (out); + } + else if (fmt_get_category (format->type) == FMT_CAT_BINARY) + converters[format->type] (input, format, + ds_put_uninit (output, format->w)); + else + { + char *utf8_encoded = data_out (input, input_encoding, format); + char *output_encoded = recode_string (output_encoding, UTF8, + utf8_encoded, -1); + ds_put_cstr (output, output_encoded); + free (output_encoded); + free (utf8_encoded); + } +} + +static char * +binary_to_utf8 (const char *in, struct pool *pool) +{ + uint8_t *out = pool_alloc_unaligned (pool, strlen (in) * 2 + 1); + uint8_t *p = out; - converters[format->type] (input, format, output); - if (0 != strcmp (encoding, C_ENCODING) - && fmt_get_category (format->type) != FMT_CAT_BINARY) + while (*in != '\0') { - char *s = recode_string (encoding, C_ENCODING, output, format->w ); - memcpy (output, s, format->w); - free (s); + uint8_t byte = *in++; + int mblen = u8_uctomb (p, byte, 2); + assert (mblen > 0); + p += mblen; } + *p = '\0'; + + return CHAR_CAST (char *, out); } -/* Converts the INPUT value into a UTF8 encoded string, according - to format specification FORMAT. +/* Converts the INPUT value into a UTF-8 encoded string, according to format + specification FORMAT. - VALUE must be the correct width for FORMAT, that is, its - width must be fmt_var_width(FORMAT). + VALUE must be the correct width for FORMAT, that is, its width must be + fmt_var_width(FORMAT). - ENCODING must be the encoding of INPUT. Normally this can - be obtained by calling dict_get_encoding on the dictionary - with which INPUT is associated. + ENCODING must be the encoding of INPUT. Normally this can be obtained by + calling dict_get_encoding() on the dictionary with which INPUT is + associated. ENCODING is only important when FORMAT's type is FMT_A. - The return value is dynamically allocated, and must be freed - by the caller. If POOL is non-null, then the return value is - allocated on that pool. -*/ + The return value is dynamically allocated, and must be freed by the caller. + If POOL is non-null, then the return value is allocated on that pool. */ char * data_out_pool (const union value *input, const char *encoding, const struct fmt_spec *format, struct pool *pool) { - char *output; - char *t ; assert (fmt_check_output (format)); + if (format->type == FMT_A) + { + char *in = CHAR_CAST (char *, value_str (input, format->w)); + return recode_string_pool (UTF8, encoding, in, format->w, pool); + } + else if (fmt_get_category (format->type) == FMT_CAT_BINARY) + { + char tmp[16]; - output = xmalloc (format->w + 1); - - converters[format->type] (input, format, output); + assert (format->w + 1 <= sizeof tmp); + converters[format->type] (input, format, tmp); + return binary_to_utf8 (tmp, pool); + } + else + { + const struct fmt_number_style *style = settings_get_style (format->type); + size_t size = format->w + style->extra_bytes + 1; + char *output; - t = recode_string_pool (UTF8, encoding, output, format->w, pool); - free (output); - return t; + output = pool_alloc_unaligned (pool, size); + converters[format->type] (input, format, output); + return output; + } } char * @@ -214,11 +262,9 @@ output_Z (const union value *input, const struct fmt_spec *format, char buf[128]; if (input->f == SYSMIS) output_missing (format, output); - else if (fabs (number) >= power10 (format->w) - || sprintf (buf, "%0*.0f", format->w, - fabs (round (number))) != format->w) - output_overflow (format, output); - else + else if (fabs (number) < power10 (format->w) + && sprintf (buf, "%0*.0f", format->w, + fabs (round (number))) == format->w) { if (number < 0 && strspn (buf, "0") < format->w) { @@ -228,6 +274,8 @@ output_Z (const union value *input, const struct fmt_spec *format, memcpy (output, buf, format->w); output[format->w] = '\0'; } + else + output_overflow (format, output); } /* Outputs P format. */ @@ -339,14 +387,11 @@ output_date (const union value *input, const struct fmt_spec *format, double number = input->f; int year, month, day, yday; - const char *template = fmt_date_template (format->type); - size_t template_width = strlen (template); - int excess_width = format->w - template_width; + const char *template = fmt_date_template (format->type, format->w); char tmp[64]; char *p = tmp; - assert (format->w >= template_width); if (number == SYSMIS) goto missing; @@ -363,6 +408,8 @@ output_date (const union value *input, const struct fmt_spec *format, while (*template != '\0') { + int excess_width; + int ch = *template; int count = 1; while (template[count] == ch) @@ -391,7 +438,7 @@ output_date (const union value *input, const struct fmt_spec *format, } break; case 'y': - if (count >= 4 || excess_width >= 2) + if (count >= 4) { if (year <= 9999) p += sprintf (p, "%04d", year); @@ -451,10 +498,7 @@ output_date (const union value *input, const struct fmt_spec *format, } p += strlen (p); } - break; - case 'X': - *p++ = ' '; - break; + goto done; default: assert (count == 1); *p++ = ch; @@ -462,6 +506,7 @@ output_date (const union value *input, const struct fmt_spec *format, } } + done: buf_copy_lpad (output, format->w, tmp, p - tmp, ' '); output[format->w] = '\0'; return; @@ -528,11 +573,10 @@ output_MONTH (const union value *input, const struct fmt_spec *format, /* Outputs A format. */ static void -output_A (const union value *input, const struct fmt_spec *format, - char *output) +output_A (const union value *input UNUSED, + const struct fmt_spec *format UNUSED, char *output UNUSED) { - memcpy (output, value_str (input, format->w), format->w); - output[format->w] = '\0'; + NOT_REACHED (); } /* Outputs AHEX format. */ @@ -602,9 +646,9 @@ output_decimal (const struct rounder *r, const struct fmt_spec *format, the negative suffix, plus (if negative) the negative prefix. */ width = rounder_width (r, decimals, &integer_digits, &add_neg_prefix); - width += strlen (style->neg_suffix.s); + width += style->neg_suffix.width; if (add_neg_prefix) - width += strlen (style->neg_prefix.s); + width += style->neg_prefix.width; if (width > format->w) continue; @@ -659,8 +703,11 @@ output_decimal (const struct rounder *r, const struct fmt_spec *format, if (add_neg_prefix) p = stpcpy (p, style->neg_suffix.s); else - p = mempset (p, ' ', strlen (style->neg_suffix.s)); - assert (p == output + format->w); + p = mempset (p, ' ', style->neg_suffix.width); + + assert (p >= output + format->w); + assert (p <= output + format->w + style->extra_bytes); + *p = '\0'; return true; } @@ -678,12 +725,12 @@ output_scientific (double number, const struct fmt_spec *format, int width; int fraction_width; bool add_affixes; - char buf[64], *p; + char *p; /* Allocate minimum required space. */ - width = 6 + strlen (style->neg_suffix.s); + width = 6 + style->neg_suffix.width; if (number < 0) - width += strlen (style->neg_prefix.s); + width += style->neg_prefix.width; if (width > format->w) return false; @@ -702,7 +749,7 @@ output_scientific (double number, const struct fmt_spec *format, width += fraction_width; /* Format (except suffix). */ - p = buf; + p = output; if (width < format->w) p = mempset (p, ' ', format->w - width); if (number < 0) @@ -739,11 +786,11 @@ output_scientific (double number, const struct fmt_spec *format, if (number < 0) p = stpcpy (p, style->neg_suffix.s); else - p = mempset (p, ' ', strlen (style->neg_suffix.s)); + p = mempset (p, ' ', style->neg_suffix.width); - assert (p == buf + format->w); - memcpy (output, buf, format->w); - output[format->w] = '\0'; + assert (p >= output + format->w); + assert (p <= output + format->w + style->extra_bytes); + *p = '\0'; return true; } @@ -817,6 +864,7 @@ rounder_init (struct rounder *r, double number, int max_decimals) r->leading_zeros = strspn (r->string, "0."); r->leading_nines = strspn (r->string, "9."); r->integer_digits = strchr (r->string, '.') - r->string; + assert (r->integer_digits >= 0); r->negative = number < 0; }