added automake.mk files in src/language
[pspp] / src / data / data-out.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., 51 Franklin Street, Fifth Floor, Boston, MA
18    02110-1301, USA. */
19
20 #include <config.h>
21 #include "message.h"
22 #include <ctype.h>
23 #include <math.h>
24 #include <float.h>
25 #include <stdlib.h>
26 #include <time.h>
27 #include "calendar.h"
28 #include "message.h"
29 #include "format.h"
30 #include "magic.h"
31 #include "misc.h"
32 #include "misc.h"
33 #include "settings.h"
34 #include "str.h"
35 #include "variable.h"
36
37 #include "gettext.h"
38 #define _(msgid) gettext (msgid)
39
40 #include "debug-print.h"
41 \f
42 /* Public functions. */
43
44 typedef int numeric_converter (char *, const struct fmt_spec *, double);
45 static numeric_converter convert_F, convert_N, convert_E, convert_F_plus;
46 static numeric_converter convert_Z, convert_IB, convert_P, convert_PIB;
47 static numeric_converter convert_PIBHEX, convert_PK, convert_RB;
48 static numeric_converter convert_RBHEX, convert_CCx, convert_date;
49 static numeric_converter convert_time, convert_WKDAY, convert_MONTH;
50
51 static numeric_converter try_F, convert_infinite;
52
53 typedef int string_converter (char *, const struct fmt_spec *, const char *);
54 static string_converter convert_A, convert_AHEX;
55
56 /* Converts binary value V into printable form in the exactly
57    FP->W character in buffer S according to format specification
58    FP.  No null terminator is appended to the buffer.  */
59 bool
60 data_out (char *s, const struct fmt_spec *fp, const union value *v)
61 {
62   int cat = formats[fp->type].cat;
63   int ok;
64
65   assert (check_output_specifier (fp, 0));
66   if (!(cat & FCAT_STRING)) 
67     {
68       /* Numeric formatting. */
69       double number = v->f;
70
71       /* Handle SYSMIS turning into blanks. */
72       if ((cat & FCAT_BLANKS_SYSMIS) && number == SYSMIS)
73         {
74           memset (s, ' ', fp->w);
75           s[fp->w - fp->d - 1] = '.';
76           return true;
77         }
78
79       /* Handle decimal shift. */
80       if ((cat & FCAT_SHIFT_DECIMAL) && number != SYSMIS && fp->d)
81         number *= pow (10.0, fp->d);
82
83       switch (fp->type) 
84         {
85         case FMT_F:
86           ok = convert_F (s, fp, number);
87           break;
88
89         case FMT_N:
90           ok = convert_N (s, fp, number);
91           break;
92
93         case FMT_E:
94           ok = convert_E (s, fp, number);
95           break;
96
97         case FMT_COMMA: case FMT_DOT: case FMT_DOLLAR: case FMT_PCT:
98           ok = convert_F_plus (s, fp, number);
99           break;
100
101         case FMT_Z:
102           ok = convert_Z (s, fp, number);
103           break;
104
105         case FMT_A:
106           assert (0);
107           abort ();
108
109         case FMT_AHEX:
110           assert (0);
111           abort ();
112
113         case FMT_IB:
114           ok = convert_IB (s, fp, number);
115           break;
116
117         case FMT_P:
118           ok = convert_P (s, fp, number);
119           break;
120
121         case FMT_PIB:
122           ok = convert_PIB (s, fp, number);
123           break;
124
125         case FMT_PIBHEX:
126           ok = convert_PIBHEX (s, fp, number);
127           break;
128
129         case FMT_PK:
130           ok = convert_PK (s, fp, number);
131           break;
132
133         case FMT_RB:
134           ok = convert_RB (s, fp, number);
135           break;
136
137         case FMT_RBHEX:
138           ok = convert_RBHEX (s, fp, number);
139           break;
140
141         case FMT_CCA: case FMT_CCB: case FMT_CCC: case FMT_CCD: case FMT_CCE:
142           ok = convert_CCx (s, fp, number);
143           break;
144
145         case FMT_DATE: case FMT_EDATE: case FMT_SDATE: case FMT_ADATE:
146         case FMT_JDATE: case FMT_QYR: case FMT_MOYR: case FMT_WKYR:
147         case FMT_DATETIME: 
148           ok = convert_date (s, fp, number);
149           break;
150
151         case FMT_TIME: case FMT_DTIME:
152           ok = convert_time (s, fp, number);
153           break;
154
155         case FMT_WKDAY:
156           ok = convert_WKDAY (s, fp, number);
157           break;
158
159         case FMT_MONTH:
160           ok = convert_MONTH (s, fp, number);
161           break;
162
163         default:
164           assert (0);
165           abort ();
166         }
167     }
168   else 
169     {
170       /* String formatting. */
171       const char *string = v->s;
172
173       switch (fp->type) 
174         {
175         case FMT_A:
176           ok = convert_A (s, fp, string);
177           break;
178
179         case FMT_AHEX:
180           ok = convert_AHEX (s, fp, string);
181           break;
182
183         default:
184           assert (0);
185           abort ();
186         }
187     }
188
189   /* Error handling. */
190   if (!ok)
191     strncpy (s, "ERROR", fp->w);
192   
193   return ok;
194 }
195
196 /* Converts V into S in F format with width W and D decimal places,
197    then deletes trailing zeros.  S is not null-terminated. */
198 void
199 num_to_string (double v, char *s, int w, int d)
200 {
201   struct fmt_spec f = make_output_format (FMT_F, w, d);
202   convert_F (s, &f, v);
203 }
204 \f
205 /* Main conversion functions. */
206
207 static void insert_commas (char *dst, const char *src,
208                            const struct fmt_spec *fp);
209 static int year4 (int year);
210 static int try_CCx (char *s, const struct fmt_spec *fp, double v);
211
212 #if FLT_RADIX!=2
213 #error Write your own floating-point output routines.
214 #endif
215
216 /* Converts a number between 0 and 15 inclusive to a `hexit'
217    [0-9A-F]. */
218 #define MAKE_HEXIT(X) ("0123456789ABCDEF"[X])
219
220 /* Table of powers of 10. */
221 static const double power10[] =
222   {
223     0,  /* Not used. */
224     1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09, 1e10,
225     1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20,
226     1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29, 1e30,
227     1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39, 1e40,
228   };
229
230 /* Handles F format. */
231 static int
232 convert_F (char *dst, const struct fmt_spec *fp, double number)
233 {
234   if (!try_F (dst, fp, number))
235     convert_E (dst, fp, number);
236   return 1;
237 }
238
239 /* Handles N format. */
240 static int
241 convert_N (char *dst, const struct fmt_spec *fp, double number)
242 {
243   double d = floor (number);
244
245   if (d < 0 || d == SYSMIS)
246     {
247       msg (ME, _("The N output format cannot be used to output a "
248                  "negative number or the system-missing value."));
249       return 0;
250     }
251   
252   if (d < power10[fp->w])
253     {
254       char buf[128];
255       sprintf (buf, "%0*.0f", fp->w, number);
256       memcpy (dst, buf, fp->w);
257     }
258   else
259     memset (dst, '*', fp->w);
260
261   return 1;
262 }
263
264 /* Handles E format.  Also operates as fallback for some other
265    formats. */
266 static int
267 convert_E (char *dst, const struct fmt_spec *fp, double number)
268 {
269   /* Temporary buffer. */
270   char buf[128];
271   
272   /* Ranged number of decimal places. */
273   int d;
274
275   if (!finite (number))
276     return convert_infinite (dst, fp, number);
277
278   /* Check that the format is wide enough.
279      Although PSPP generally checks this, convert_E() can be called as
280      a fallback from other formats which do not check. */
281   if (fp->w < 6)
282     {
283       memset (dst, '*', fp->w);
284       return 1;
285     }
286
287   /* Put decimal places in usable range. */
288   d = min (fp->d, fp->w - 6);
289   if (number < 0)
290     d--;
291   if (d < 0)
292     d = 0;
293   sprintf (buf, "%*.*E", fp->w, d, number);
294
295   /* What we do here is force the exponent part to have four
296      characters whenever possible.  That is, 1.00E+99 is okay (`E+99')
297      but 1.00E+100 (`E+100') must be coerced to 1.00+100 (`+100').  On
298      the other hand, 1.00E1000 (`E+100') cannot be canonicalized.
299      Note that ANSI C guarantees at least two digits in the
300      exponent. */
301   if (fabs (number) > 1e99)
302     {
303       /* Pointer to the `E' in buf. */
304       char *cp;
305
306       cp = strchr (buf, 'E');
307       if (cp)
308         {
309           /* Exponent better not be bigger than an int. */
310           int exp = atoi (cp + 1); 
311
312           if (abs (exp) > 99 && abs (exp) < 1000)
313             {
314               /* Shift everything left one place: 1.00e+100 -> 1.00+100. */
315               cp[0] = cp[1];
316               cp[1] = cp[2];
317               cp[2] = cp[3];
318               cp[3] = cp[4];
319             }
320           else if (abs (exp) >= 1000)
321             memset (buf, '*', fp->w);
322         }
323     }
324
325   /* The C locale always uses a period `.' as a decimal point.
326      Translate to comma if necessary. */
327   if ((get_decimal() == ',' && fp->type != FMT_DOT)
328       || (get_decimal() == '.' && fp->type == FMT_DOT))
329     {
330       char *cp = strchr (buf, '.');
331       if (cp)
332         *cp = ',';
333     }
334
335   memcpy (dst, buf, fp->w);
336   return 1;
337 }
338
339 /* Handles COMMA, DOT, DOLLAR, and PCT formats. */
340 static int
341 convert_F_plus (char *dst, const struct fmt_spec *fp, double number)
342 {
343   char buf[40];
344   
345   if (try_F (buf, fp, number))
346     insert_commas (dst, buf, fp);
347   else
348     convert_E (dst, fp, number);
349
350   return 1;
351 }
352
353 static int
354 convert_Z (char *dst, const struct fmt_spec *fp, double number)
355 {
356   static int warned = 0;
357
358   if (!warned)
359     {
360       msg (MW, 
361         _("Quality of zoned decimal (Z) output format code is "
362           "suspect.  Check your results. Report bugs to %s."),
363         PACKAGE_BUGREPORT);
364       warned = 1;
365     }
366
367   if (number == SYSMIS)
368     {
369       msg (ME, _("The system-missing value cannot be output as a zoned "
370                  "decimal number."));
371       return 0;
372     }
373   
374   {
375     char buf[41];
376     double d;
377     int i;
378     
379     d = fabs (floor (number));
380     if (d >= power10[fp->w])
381       {
382         msg (ME, _("Number %g too big to fit in field with format Z%d.%d."),
383              number, fp->w, fp->d);
384         return 0;
385       }
386
387     sprintf (buf, "%*.0f", fp->w, number);
388     for (i = 0; i < fp->w; i++)
389       dst[i] = (buf[i] - '0') | 0xf0;
390     if (number < 0)
391       dst[fp->w - 1] &= 0xdf;
392   }
393
394   return 1;
395 }
396
397 static int
398 convert_A (char *dst, const struct fmt_spec *fp, const char *string)
399 {
400   memcpy (dst, string, fp->w);
401   return 1;
402 }
403
404 static int
405 convert_AHEX (char *dst, const struct fmt_spec *fp, const char *string)
406 {
407   int i;
408
409   for (i = 0; i < fp->w / 2; i++)
410     {
411       *dst++ = MAKE_HEXIT ((string[i]) >> 4);
412       *dst++ = MAKE_HEXIT ((string[i]) & 0xf);
413     }
414
415   return 1;
416 }
417
418 static int
419 convert_IB (char *dst, const struct fmt_spec *fp, double number)
420 {
421   /* Strategy: Basically the same as convert_PIBHEX() but with
422      base 256. Then negate the two's-complement result if number
423      is negative. */
424
425   /* Used for constructing the two's-complement result. */
426   unsigned temp[8];
427
428   /* Fraction (mantissa). */
429   double frac;
430
431   /* Exponent. */
432   int exp;
433
434   /* Difference between exponent and (-8*fp->w-1). */
435   int diff;
436
437   /* Counter. */
438   int i;
439
440   /* Make the exponent (-8*fp->w-1). */
441   frac = frexp (fabs (number), &exp);
442   diff = exp - (-8 * fp->w - 1);
443   exp -= diff;
444   frac *= ldexp (1.0, diff);
445
446   /* Extract each base-256 digit. */
447   for (i = 0; i < fp->w; i++)
448     {
449       modf (frac, &frac);
450       frac *= 256.0;
451       temp[i] = floor (frac);
452     }
453
454   /* Perform two's-complement negation if number is negative. */
455   if (number < 0)
456     {
457       /* Perform NOT operation. */
458       for (i = 0; i < fp->w; i++)
459         temp[i] = ~temp[i];
460       /* Add 1 to the whole number. */
461       for (i = fp->w - 1; i >= 0; i--)
462         {
463           temp[i]++;
464           if (temp[i])
465             break;
466         }
467     }
468   memcpy (dst, temp, fp->w);
469 #ifndef WORDS_BIGENDIAN
470   buf_reverse (dst, fp->w);
471 #endif
472
473   return 1;
474 }
475
476 static int
477 convert_P (char *dst, const struct fmt_spec *fp, double number)
478 {
479   /* Buffer for fp->w*2-1 characters + a decimal point if library is
480      not quite compliant + a null. */
481   char buf[17];
482
483   /* Counter. */
484   int i;
485
486   /* Main extraction. */
487   sprintf (buf, "%0*.0f", fp->w * 2 - 1, floor (fabs (number)));
488
489   for (i = 0; i < fp->w; i++)
490     ((unsigned char *) dst)[i]
491       = ((buf[i * 2] - '0') << 4) + buf[i * 2 + 1] - '0';
492
493   /* Set sign. */
494   dst[fp->w - 1] &= 0xf0;
495   if (number >= 0.0)
496     dst[fp->w - 1] |= 0xf;
497   else
498     dst[fp->w - 1] |= 0xd;
499
500   return 1;
501 }
502
503 static int
504 convert_PIB (char *dst, const struct fmt_spec *fp, double number)
505 {
506   /* Strategy: Basically the same as convert_IB(). */
507
508   /* Fraction (mantissa). */
509   double frac;
510
511   /* Exponent. */
512   int exp;
513
514   /* Difference between exponent and (-8*fp->w). */
515   int diff;
516
517   /* Counter. */
518   int i;
519
520   /* Make the exponent (-8*fp->w). */
521   frac = frexp (fabs (number), &exp);
522   diff = exp - (-8 * fp->w);
523   exp -= diff;
524   frac *= ldexp (1.0, diff);
525
526   /* Extract each base-256 digit. */
527   for (i = 0; i < fp->w; i++)
528     {
529       modf (frac, &frac);
530       frac *= 256.0;
531       ((unsigned char *) dst)[i] = floor (frac);
532     }
533 #ifndef WORDS_BIGENDIAN
534   buf_reverse (dst, fp->w);
535 #endif
536
537   return 1;
538 }
539
540 static int
541 convert_PIBHEX (char *dst, const struct fmt_spec *fp, double number)
542 {
543   /* Strategy: Use frexp() to create a normalized result (but mostly
544      to find the base-2 exponent), then change the base-2 exponent to
545      (-4*fp->w) using multiplication and division by powers of two.
546      Extract each hexit by multiplying by 16. */
547
548   /* Fraction (mantissa). */
549   double frac;
550
551   /* Exponent. */
552   int exp;
553
554   /* Difference between exponent and (-4*fp->w). */
555   int diff;
556
557   /* Counter. */
558   int i;
559
560   /* Make the exponent (-4*fp->w). */
561   frac = frexp (fabs (number), &exp);
562   diff = exp - (-4 * fp->w);
563   exp -= diff;
564   frac *= ldexp (1.0, diff);
565
566   /* Extract each hexit. */
567   for (i = 0; i < fp->w; i++)
568     {
569       modf (frac, &frac);
570       frac *= 16.0;
571       *dst++ = MAKE_HEXIT ((int) floor (frac));
572     }
573
574   return 1;
575 }
576
577 static int
578 convert_PK (char *dst, const struct fmt_spec *fp, double number)
579 {
580   /* Buffer for fp->w*2 characters + a decimal point if library is not
581      quite compliant + a null. */
582   char buf[18];
583
584   /* Counter. */
585   int i;
586
587   /* Main extraction. */
588   sprintf (buf, "%0*.0f", fp->w * 2, floor (fabs (number)));
589
590   for (i = 0; i < fp->w; i++)
591     ((unsigned char *) dst)[i]
592       = ((buf[i * 2] - '0') << 4) + buf[i * 2 + 1] - '0';
593
594   return 1;
595 }
596
597 static int
598 convert_RB (char *dst, const struct fmt_spec *fp, double number)
599 {
600   union
601     {
602       double d;
603       char c[8];
604     }
605   u;
606
607   u.d = number;
608   memcpy (dst, u.c, fp->w);
609
610   return 1;
611 }
612
613 static int
614 convert_RBHEX (char *dst, const struct fmt_spec *fp, double number)
615 {
616   union
617   {
618     double d;
619     char c[8];
620   }
621   u;
622
623   int i;
624
625   u.d = number;
626   for (i = 0; i < fp->w / 2; i++)
627     {
628       *dst++ = MAKE_HEXIT (u.c[i] >> 4);
629       *dst++ = MAKE_HEXIT (u.c[i] & 15);
630     }
631
632   return 1;
633 }
634
635 static int
636 convert_CCx (char *dst, const struct fmt_spec *fp, double number)
637 {
638   if (try_CCx (dst, fp, number))
639     return 1;
640   else
641     {
642       struct fmt_spec f;
643       
644       f.type = FMT_COMMA;
645       f.w = fp->w;
646       f.d = fp->d;
647   
648       return convert_F_plus (dst, &f, number);
649     }
650 }
651
652 static int
653 convert_date (char *dst, const struct fmt_spec *fp, double number)
654 {
655   static const char *months[12] =
656     {
657       "JAN", "FEB", "MAR", "APR", "MAY", "JUN",
658       "JUL", "AUG", "SEP", "OCT", "NOV", "DEC",
659     };
660
661   char buf[64] = {0};
662   int ofs = number / 86400.;
663   int month, day, year;
664
665   if (ofs < 1)
666     return 0;
667
668   calendar_offset_to_gregorian (ofs, &year, &month, &day);
669   switch (fp->type)
670     {
671     case FMT_DATE:
672       if (fp->w >= 11)
673         sprintf (buf, "%02d-%s-%04d", day, months[month - 1], year);
674       else
675         sprintf (buf, "%02d-%s-%02d", day, months[month - 1], year % 100);
676       break;
677     case FMT_EDATE:
678       if (fp->w >= 10)
679         sprintf (buf, "%02d.%02d.%04d", day, month, year);
680       else
681         sprintf (buf, "%02d.%02d.%02d", day, month, year % 100);
682       break;
683     case FMT_SDATE:
684       if (fp->w >= 10)
685         sprintf (buf, "%04d/%02d/%02d", year, month, day);
686       else
687         sprintf (buf, "%02d/%02d/%02d", year % 100, month, day);
688       break;
689     case FMT_ADATE:
690       if (fp->w >= 10)
691         sprintf (buf, "%02d/%02d/%04d", month, day, year);
692       else
693         sprintf (buf, "%02d/%02d/%02d", month, day, year % 100);
694       break;
695     case FMT_JDATE:
696       {
697         int yday = calendar_offset_to_yday (ofs);
698         
699         if (fp->w < 7)
700           sprintf (buf, "%02d%03d", year % 100, yday); 
701         else if (year4 (year))
702           sprintf (buf, "%04d%03d", year, yday);
703         else
704         break;
705       }
706     case FMT_QYR:
707       if (fp->w >= 8)
708         sprintf (buf, "%d Q% 04d", (month - 1) / 3 + 1, year);
709       else
710         sprintf (buf, "%d Q% 02d", (month - 1) / 3 + 1, year % 100);
711       break;
712     case FMT_MOYR:
713       if (fp->w >= 8)
714         sprintf (buf, "%s% 04d", months[month - 1], year);
715       else
716         sprintf (buf, "%s% 02d", months[month - 1], year % 100);
717       break;
718     case FMT_WKYR:
719       {
720         int yday = calendar_offset_to_yday (ofs);
721         
722         if (fp->w >= 10)
723           sprintf (buf, "%02d WK% 04d", (yday - 1) / 7 + 1, year);
724         else
725           sprintf (buf, "%02d WK% 02d", (yday - 1) / 7 + 1, year % 100);
726       }
727       break;
728     case FMT_DATETIME:
729       {
730         char *cp;
731
732         cp = spprintf (buf, "%02d-%s-%04d %02d:%02d",
733                        day, months[month - 1], year,
734                        (int) fmod (floor (number / 60. / 60.), 24.),
735                        (int) fmod (floor (number / 60.), 60.));
736         if (fp->w >= 20)
737           {
738             int w, d;
739
740             if (fp->w >= 22 && fp->d > 0)
741               {
742                 d = min (fp->d, fp->w - 21);
743                 w = 3 + d;
744               }
745             else
746               {
747                 w = 2;
748                 d = 0;
749               }
750
751             cp = spprintf (cp, ":%0*.*f", w, d, fmod (number, 60.));
752           }
753       }
754       break;
755     default:
756       assert (0);
757     }
758
759   if (buf[0] == 0)
760     return 0;
761   buf_copy_str_rpad (dst, fp->w, buf);
762   return 1;
763 }
764
765 static int
766 convert_time (char *dst, const struct fmt_spec *fp, double number)
767 {
768   char temp_buf[40];
769   char *cp;
770
771   double time;
772   int width;
773
774   if (fabs (number) > 1e20)
775     {
776       msg (ME, _("Time value %g too large in magnitude to convert to "
777            "alphanumeric time."), number);
778       return 0;
779     }
780
781   time = number;
782   width = fp->w;
783   cp = temp_buf;
784   if (time < 0)
785     *cp++ = '-', time = -time;
786   if (fp->type == FMT_DTIME)
787     {
788       double days = floor (time / 60. / 60. / 24.);
789       cp = spprintf (temp_buf, "%02.0f ", days);
790       time = time - days * 60. * 60. * 24.;
791       width -= 3;
792     }
793   else
794     cp = temp_buf;
795
796   cp = spprintf (cp, "%02.0f:%02.0f",
797                  fmod (floor (time / 60. / 60.), 24.),
798                  fmod (floor (time / 60.), 60.));
799
800   if (width >= 8)
801     {
802       int w, d;
803
804       if (width >= 10 && fp->d >= 0 && fp->d != 0)
805         d = min (fp->d, width - 9), w = 3 + d;
806       else
807         w = 2, d = 0;
808
809       cp = spprintf (cp, ":%0*.*f", w, d, fmod (time, 60.));
810     }
811   buf_copy_str_rpad (dst, fp->w, temp_buf);
812
813   return 1;
814 }
815
816 static int
817 convert_WKDAY (char *dst, const struct fmt_spec *fp, double wkday)
818 {
819   static const char *weekdays[7] =
820     {
821       "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY",
822       "THURSDAY", "FRIDAY", "SATURDAY",
823     };
824
825   if (wkday < 1 || wkday > 7)
826     {
827       msg (ME, _("Weekday index %f does not lie between 1 and 7."),
828            (double) wkday);
829       return 0;
830     }
831   buf_copy_str_rpad (dst, fp->w, weekdays[(int) wkday - 1]);
832
833   return 1;
834 }
835
836 static int
837 convert_MONTH (char *dst, const struct fmt_spec *fp, double month)
838 {
839   static const char *months[12] =
840     {
841       "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY", "JUNE",
842       "JULY", "AUGUST", "SEPTEMBER", "OCTOBER", "NOVEMBER", "DECEMBER",
843     };
844
845   if (month < 1 || month > 12)
846     {
847       msg (ME, _("Month index %f does not lie between 1 and 12."),
848            month);
849       return 0;
850     }
851   
852   buf_copy_str_rpad (dst, fp->w, months[(int) month - 1]);
853
854   return 1;
855 }
856 \f
857 /* Helper functions. */
858
859 /* Copies SRC to DST, inserting commas and dollar signs as appropriate
860    for format spec *FP.  */
861 static void
862 insert_commas (char *dst, const char *src, const struct fmt_spec *fp)
863 {
864   /* Number of leading spaces in the number.  This is the amount of
865      room we have for inserting commas and dollar signs. */
866   int n_spaces;
867
868   /* Number of digits before the decimal point.  This is used to
869      determine the Number of commas to insert. */
870   int n_digits;
871
872   /* Number of commas to insert. */
873   int n_commas;
874
875   /* Number of items ,%$ to insert. */
876   int n_items;
877
878   /* Number of n_items items not to use for commas. */
879   int n_reserved;
880
881   /* Digit iterator. */
882   int i;
883
884   /* Source pointer. */
885   const char *sp;
886
887   /* Count spaces and digits. */
888   sp = src;
889   while (sp < src + fp->w && *sp == ' ')
890     sp++;
891   n_spaces = sp - src;
892   sp = src + n_spaces;
893   if (*sp == '-')
894     sp++;
895   n_digits = 0;
896   while (sp + n_digits < src + fp->w && isdigit ((unsigned char) sp[n_digits]))
897     n_digits++;
898   n_commas = (n_digits - 1) / 3;
899   n_items = n_commas + (fp->type == FMT_DOLLAR || fp->type == FMT_PCT);
900
901   /* Check whether we have enough space to do insertions. */
902   if (!n_spaces || !n_items)
903     {
904       memcpy (dst, src, fp->w);
905       return;
906     }
907   if (n_items > n_spaces)
908     {
909       n_items -= n_commas;
910       if (!n_items)
911         {
912           memcpy (dst, src, fp->w);
913           return;
914         }
915     }
916
917   /* Put spaces at the beginning if there's extra room. */
918   if (n_spaces > n_items)
919     {
920       memset (dst, ' ', n_spaces - n_items);
921       dst += n_spaces - n_items;
922     }
923
924   /* Insert $ and reserve space for %. */
925   n_reserved = 0;
926   if (fp->type == FMT_DOLLAR)
927     {
928       *dst++ = '$';
929       n_items--;
930     }
931   else if (fp->type == FMT_PCT)
932     n_reserved = 1;
933
934   /* Copy negative sign and digits, inserting commas. */
935   if (sp - src > n_spaces)
936     *dst++ = '-';
937   for (i = n_digits; i; i--)
938     {
939       if (i % 3 == 0 && n_digits > i && n_items > n_reserved)
940         {
941           n_items--;
942           *dst++ = fp->type == FMT_COMMA ? get_grouping() : get_decimal();
943         }
944       *dst++ = *sp++;
945     }
946
947   /* Copy decimal places and insert % if necessary. */
948   memcpy (dst, sp, fp->w - (sp - src));
949   if (fp->type == FMT_PCT && n_items > 0)
950     dst[fp->w - (sp - src)] = '%';
951 }
952
953 /* Returns 1 if YEAR (i.e., 1987) can be represented in four digits, 0
954    otherwise. */
955 static int
956 year4 (int year)
957 {
958   if (year >= 1 && year <= 9999)
959     return 1;
960   msg (ME, _("Year %d cannot be represented in four digits for "
961              "output formatting purposes."), year);
962   return 0;
963 }
964
965 static int
966 try_CCx (char *dst, const struct fmt_spec *fp, double number)
967 {
968   const struct custom_currency *cc = get_cc(fp->type - FMT_CCA);
969
970   struct fmt_spec f;
971
972   char buf[64];
973   char buf2[64];
974   char *cp;
975
976   /* Determine length available, decimal character for number
977      proper. */
978   f.type = cc->decimal == get_decimal () ? FMT_COMMA : FMT_DOT;
979   f.w = fp->w - strlen (cc->prefix) - strlen (cc->suffix);
980   if (number < 0)
981     f.w -= strlen (cc->neg_prefix) + strlen (cc->neg_suffix) - 1;
982   else
983     /* Convert -0 to +0. */
984     number = fabs (number);
985   f.d = fp->d;
986
987   if (f.w <= 0)
988     return 0;
989
990   /* There's room for all that currency crap.  Let's do the F
991      conversion first. */
992   if (!convert_F (buf, &f, number) || *buf == '*')
993     return 0;
994   insert_commas (buf2, buf, &f);
995
996   /* Postprocess back into buf. */
997   cp = buf;
998   if (number < 0)
999     cp = stpcpy (cp, cc->neg_prefix);
1000   cp = stpcpy (cp, cc->prefix);
1001   {
1002     char *bp = buf2;
1003     while (*bp == ' ')
1004       bp++;
1005
1006     assert ((number >= 0) ^ (*bp == '-'));
1007     if (number < 0)
1008       bp++;
1009
1010     memcpy (cp, bp, f.w - (bp - buf2));
1011     cp += f.w - (bp - buf2);
1012   }
1013   cp = stpcpy (cp, cc->suffix);
1014   if (number < 0)
1015     cp = stpcpy (cp, cc->neg_suffix);
1016
1017   /* Copy into dst. */
1018   assert (cp - buf <= fp->w);
1019   if (cp - buf < fp->w)
1020     {
1021       memcpy (&dst[fp->w - (cp - buf)], buf, cp - buf);
1022       memset (dst, ' ', fp->w - (cp - buf));
1023     }
1024   else
1025     memcpy (dst, buf, fp->w);
1026
1027   return 1;
1028 }
1029
1030 static int
1031 format_and_round (char *dst, double number, const struct fmt_spec *fp,
1032                   int decimals);
1033
1034 /* Tries to format NUMBER into DST as the F format specified in
1035    *FP.  Return true if successful, false on failure. */
1036 static int
1037 try_F (char *dst, const struct fmt_spec *fp, double number)
1038 {
1039   assert (fp->w <= 40);
1040   if (finite (number)) 
1041     {
1042       if (fabs (number) < power10[fp->w])
1043         {
1044           /* The value may fit in the field. */
1045           if (fp->d == 0) 
1046             {
1047               /* There are no decimal places, so there's no way
1048                  that the value can be shortened.  Either it fits
1049                  or it doesn't. */
1050               char buf[41];
1051               sprintf (buf, "%*.0f", fp->w, number);
1052               if (strlen (buf) <= fp->w) 
1053                 {
1054                   buf_copy_str_lpad (dst, fp->w, buf);
1055                   return true; 
1056                 }
1057               else 
1058                 return false;
1059             }
1060           else 
1061             {
1062               /* First try to format it with 2 extra decimal
1063                  places.  This gives us a good chance of not
1064                  needing even more decimal places, but it also
1065                  avoids wasting too much time formatting more
1066                  decimal places on the first try. */
1067               int result = format_and_round (dst, number, fp, fp->d + 2);
1068               if (result >= 0)
1069                 return result;
1070
1071               /* 2 extra decimal places weren't enough to
1072                  correctly round.  Try again with the maximum
1073                  number of places. */
1074               return format_and_round (dst, number, fp, LDBL_DIG + 1);
1075             }
1076         }
1077       else 
1078         {
1079           /* The value is too big to fit in the field. */
1080           return false;
1081         }
1082     }
1083   else
1084     return convert_infinite (dst, fp, number);
1085 }
1086
1087 /* Tries to compose NUMBER into DST in format FP by first
1088    formatting it with DECIMALS decimal places, then rounding off
1089    to as many decimal places will fit or the number specified in
1090    FP, whichever is fewer.
1091
1092    Returns 1 if conversion succeeds, 0 if this try at conversion
1093    failed and so will any other tries (because the integer part
1094    of the number is too long), or -1 if this try failed but
1095    another with higher DECIMALS might succeed (because we'd be
1096    able to properly round). */
1097 static int
1098 format_and_round (char *dst, double number, const struct fmt_spec *fp,
1099                   int decimals)
1100 {
1101   /* Number of characters before the decimal point,
1102      which includes digits and possibly a minus sign. */
1103   int predot_chars;
1104
1105   /* Number of digits in the output fraction,
1106      which may be smaller than fp->d if there's not enough room. */
1107   int fraction_digits;
1108
1109   /* Points to last digit that will remain in the fraction after
1110      rounding. */
1111   char *final_frac_dig;
1112
1113   /* Round up? */
1114   bool round_up;
1115   
1116   char buf[128];
1117   
1118   assert (decimals > fp->d);
1119   if (decimals > LDBL_DIG)
1120     decimals = LDBL_DIG + 1;
1121
1122   sprintf (buf, "%.*f", decimals, number);
1123
1124   /* Omit integer part if it's 0. */
1125   if (!memcmp (buf, "0.", 2))
1126     memmove (buf, buf + 1, strlen (buf));
1127   else if (!memcmp (buf, "-0.", 3))
1128     memmove (buf + 1, buf + 2, strlen (buf + 1));
1129
1130   predot_chars = strcspn (buf, ".");
1131   if (predot_chars > fp->w) 
1132     {
1133       /* Can't possibly fit. */
1134       return 0; 
1135     }
1136   else if (predot_chars == fp->w)
1137     {
1138       /* Exact fit for integer part and sign. */
1139       memcpy (dst, buf, fp->w);
1140       return 1;
1141     }
1142   else if (predot_chars + 1 == fp->w) 
1143     {
1144       /* There's room for the decimal point, but not for any
1145          digits of the fraction.
1146          Right-justify the integer part and sign. */
1147       dst[0] = ' ';
1148       memcpy (dst + 1, buf, fp->w);
1149       return 1;
1150     }
1151
1152   /* It looks like we have room for at least one digit of the
1153      fraction.  Figure out how many. */
1154   fraction_digits = fp->w - predot_chars - 1;
1155   if (fraction_digits > fp->d)
1156     fraction_digits = fp->d;
1157   final_frac_dig = buf + predot_chars + fraction_digits;
1158
1159   /* Decide rounding direction and truncate string. */
1160   if (final_frac_dig[1] == '5'
1161       && strspn (final_frac_dig + 2, "0") == strlen (final_frac_dig + 2)) 
1162     {
1163       /* Exactly 1/2. */
1164       if (decimals <= LDBL_DIG)
1165         {
1166           /* Don't have enough fractional digits to know which way to
1167              round.  We can format with more decimal places, so go
1168              around again. */
1169           return -1;
1170         }
1171       else 
1172         {
1173           /* We used up all our fractional digits and still don't
1174              know.  Round to even. */
1175           round_up = (final_frac_dig[0] - '0') % 2 != 0;
1176         }
1177     }
1178   else
1179     round_up = final_frac_dig[1] >= '5';
1180   final_frac_dig[1] = '\0';
1181
1182   /* Do rounding. */
1183   if (round_up) 
1184     {
1185       char *cp = final_frac_dig;
1186       for (;;) 
1187         {
1188           if (*cp >= '0' && *cp <= '8')
1189             {
1190               (*cp)++;
1191               break; 
1192             }
1193           else if (*cp == '9') 
1194             *cp = '0';
1195           else
1196             assert (*cp == '.');
1197
1198           if (cp == buf || *--cp == '-')
1199             {
1200               size_t length;
1201               
1202               /* Tried to go past the leftmost digit.  Insert a 1. */
1203               memmove (cp + 1, cp, strlen (cp) + 1);
1204               *cp = '1';
1205
1206               length = strlen (buf);
1207               if (length > fp->w) 
1208                 {
1209                   /* Inserting the `1' overflowed our space.
1210                      Drop a decimal place. */
1211                   buf[--length] = '\0';
1212
1213                   /* If that was the last decimal place, drop the
1214                      decimal point too. */
1215                   if (buf[length - 1] == '.')
1216                     buf[length - 1] = '\0';
1217                 }
1218               
1219               break;
1220             }
1221         }
1222     }
1223
1224   /* Omit `-' if value output is zero. */
1225   if (buf[0] == '-' && buf[strspn (buf, "-.0")] == '\0')
1226     memmove (buf, buf + 1, strlen (buf));
1227
1228   buf_copy_str_lpad (dst, fp->w, buf);
1229   return 1;
1230 }
1231
1232 /* Formats non-finite NUMBER into DST according to the width
1233    given in FP. */
1234 static int
1235 convert_infinite (char *dst, const struct fmt_spec *fp, double number)
1236 {
1237   assert (!finite (number));
1238   
1239   if (fp->w >= 3)
1240     {
1241       const char *s;
1242
1243       if (isnan (number))
1244         s = "NaN";
1245       else if (isinf (number))
1246         s = number > 0 ? "+Infinity" : "-Infinity";
1247       else
1248         s = "Unknown";
1249
1250       buf_copy_str_lpad (dst, fp->w, s);
1251     }
1252   else 
1253     memset (dst, '*', fp->w);
1254
1255   return true;
1256 }