/[cvs]/ccvs/lib/strftime.c
ViewVC logotype

Diff of /ccvs/lib/strftime.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.9 by dprice, Sun Sep 4 05:58:56 2005 UTC revision 1.10 by dprice, Tue Oct 4 02:34:54 2005 UTC
# Line 155  extern char *tzname[]; Line 155  extern char *tzname[];
155  #endif  #endif
156    
157    
158  #ifdef COMPILE_WIDE  #ifndef FPRINTFTIME
159    # define FPRINTFTIME 0
160    #endif
161    
162    #if FPRINTFTIME
163    # define STREAM_OR_CHAR_T FILE
164    # define STRFTIME_ARG(x) /* empty */
165    #else
166    # define STREAM_OR_CHAR_T CHAR_T
167    # define STRFTIME_ARG(x) x,
168    #endif
169    
170    #if FPRINTFTIME
171    # define memset_byte(P, Len, Byte) \
172      do { size_t _i; for (_i = 0; _i < Len; _i++) fputc (Byte, P); } while (0)
173    # define memset_space(P, Len) memset_byte (P, Len, ' ')
174    # define memset_zero(P, Len) memset_byte (P, Len, '0')
175    #elif defined COMPILE_WIDE
176  # define memset_space(P, Len) (wmemset (P, L' ', Len), (P) += (Len))  # define memset_space(P, Len) (wmemset (P, L' ', Len), (P) += (Len))
177  # define memset_zero(P, Len) (wmemset (P, L'0', Len), (P) += (Len))  # define memset_zero(P, Len) (wmemset (P, L'0', Len), (P) += (Len))
178  #else  #else
# Line 173  extern char *tzname[]; Line 190  extern char *tzname[];
190          return 0;                                                             \          return 0;                                                             \
191        if (p)                                                                  \        if (p)                                                                  \
192          {                                                                     \          {                                                                     \
193            if (_delta > 0)                                                     \            if (digits == 0 && _delta > 0)                                      \
194              {                                                                 \              {                                                                 \
195                if (pad == L_('0'))                                             \                if (pad == L_('0'))                                             \
196                  memset_zero (p, _delta);                                      \                  memset_zero (p, _delta);                                      \
# Line 181  extern char *tzname[]; Line 198  extern char *tzname[];
198                  memset_space (p, _delta);                                     \                  memset_space (p, _delta);                                     \
199              }                                                                 \              }                                                                 \
200            f;                                                                  \            f;                                                                  \
201            p += _n;                                                            \            p += FPRINTFTIME ? 0 : _n;                                          \
202          }                                                                     \          }                                                                     \
203        i += _incr;                                                             \        i += _incr;                                                             \
204      } while (0)      } while (0)
205    
206  #define cpy(n, s) \  #if FPRINTFTIME
207    # define add1(C) add (1, fputc (C, p))
208    #else
209    # define add1(C) add (1, *p = C)
210    #endif
211    
212    #if FPRINTFTIME
213    # define cpy(n, s) \
214        add ((n),                                                                 \
215             if (to_lowcase)                                                      \
216               fwrite_lowcase (p, (s), _n);                                       \
217             else if (to_uppcase)                                                 \
218               fwrite_uppcase (p, (s), _n);                                       \
219             else                                                                 \
220               fwrite ((s), _n, 1, p))
221    #else
222    # define cpy(n, s)                                                            \
223      add ((n),                                                                 \      add ((n),                                                                 \
224           if (to_lowcase)                                                      \           if (to_lowcase)                                                      \
225             memcpy_lowcase (p, (s), _n LOCALE_ARG);                            \             memcpy_lowcase (p, (s), _n LOCALE_ARG);                            \
# Line 194  extern char *tzname[]; Line 227  extern char *tzname[];
227             memcpy_uppcase (p, (s), _n LOCALE_ARG);                            \             memcpy_uppcase (p, (s), _n LOCALE_ARG);                            \
228           else                                                                 \           else                                                                 \
229             MEMCPY ((void *) p, (void const *) (s), _n))             MEMCPY ((void *) p, (void const *) (s), _n))
230    #endif
231    
232  #ifdef COMPILE_WIDE  #ifdef COMPILE_WIDE
233  # ifndef USE_IN_EXTENDED_LOCALE_MODEL  # ifndef USE_IN_EXTENDED_LOCALE_MODEL
# Line 263  extern char *tzname[]; Line 297  extern char *tzname[];
297     more reliable way to accept other sets of digits.  */     more reliable way to accept other sets of digits.  */
298  #define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)  #define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
299    
300    #if FPRINTFTIME
301    static void
302    fwrite_lowcase (FILE *fp, const CHAR_T *src, size_t len)
303    {
304      while (len-- > 0)
305        {
306          fputc (TOLOWER ((UCHAR_T) *src, loc), fp);
307          ++src;
308        }
309    }
310    
311    static void
312    fwrite_uppcase (FILE *fp, const CHAR_T *src, size_t len)
313    {
314      while (len-- > 0)
315        {
316          fputc (TOUPPER ((UCHAR_T) *src, loc), fp);
317          ++src;
318        }
319    }
320    #else
321  static CHAR_T *  static CHAR_T *
322  memcpy_lowcase (CHAR_T *dest, const CHAR_T *src,  memcpy_lowcase (CHAR_T *dest, const CHAR_T *src,
323                  size_t len LOCALE_PARAM_PROTO)                  size_t len LOCALE_PARAM_PROTO)
# Line 280  memcpy_uppcase (CHAR_T *dest, const CHAR Line 335  memcpy_uppcase (CHAR_T *dest, const CHAR
335      dest[len] = TOUPPER ((UCHAR_T) src[len], loc);      dest[len] = TOUPPER ((UCHAR_T) src[len], loc);
336    return dest;    return dest;
337  }  }
338    #endif
339    
340    
341  #if ! HAVE_TM_GMTOFF  #if ! HAVE_TM_GMTOFF
# Line 355  static CHAR_T const month_name[][10] = Line 411  static CHAR_T const month_name[][10] =
411  # define my_strftime nstrftime  # define my_strftime nstrftime
412  #endif  #endif
413    
414    #if FPRINTFTIME
415    # undef my_strftime
416    # define my_strftime fprintftime
417    #endif
418    
419  #ifdef my_strftime  #ifdef my_strftime
420  # define extra_args , ut, ns  # define extra_args , ut, ns
421  # define extra_args_spec , int ut, int ns  # define extra_args_spec , int ut, int ns
422  #else  #else
423  # ifdef COMPILE_WIDE  # if defined COMPILE_WIDE
424  #  define my_strftime wcsftime  #  define my_strftime wcsftime
425  #  define nl_get_alt_digit _nl_get_walt_digit  #  define nl_get_alt_digit _nl_get_walt_digit
426  # else  # else
# Line 374  static CHAR_T const month_name[][10] = Line 435  static CHAR_T const month_name[][10] =
435  #endif  #endif
436    
437    
438  /* Write information from TP into S according to the format  /* Just like my_strftime, below, but with one more parameter, UPCASE,
439     string FORMAT, writing no more that MAXSIZE characters     to indicate that the result should be converted to upper case.  */
440     (including the terminating '\0') and returning number of  static size_t
441     characters written.  If S is NULL, nothing will be written  strftime_case_ (bool upcase, STREAM_OR_CHAR_T *s,
442     anywhere, so to determine how many characters would be                  STRFTIME_ARG (size_t maxsize)
443     written, use NULL for S and (size_t) -1 for MAXSIZE.  */                  const CHAR_T *format,
444  size_t                  const struct tm *tp extra_args_spec LOCALE_PARAM_PROTO)
 my_strftime (CHAR_T *s, size_t maxsize, const CHAR_T *format,  
              const struct tm *tp extra_args_spec LOCALE_PARAM_PROTO)  
445  {  {
446  #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL  #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
447    struct locale_data *const current = loc->__locales[LC_TIME];    struct locale_data *const current = loc->__locales[LC_TIME];
448  #endif  #endif
449    #if FPRINTFTIME
450      size_t maxsize = (size_t) -1;
451    #endif
452    
453    int hour12 = tp->tm_hour;    int hour12 = tp->tm_hour;
454  #ifdef _NL_CURRENT  #ifdef _NL_CURRENT
# Line 426  my_strftime (CHAR_T *s, size_t maxsize, Line 488  my_strftime (CHAR_T *s, size_t maxsize,
488  #endif  #endif
489    const char *zone;    const char *zone;
490    size_t i = 0;    size_t i = 0;
491    CHAR_T *p = s;    STREAM_OR_CHAR_T *p = s;
492    const CHAR_T *f;    const CHAR_T *f;
493  #if DO_MULTIBYTE && !defined COMPILE_WIDE  #if DO_MULTIBYTE && !defined COMPILE_WIDE
494    const char *format_end = NULL;    const char *format_end = NULL;
# Line 477  my_strftime (CHAR_T *s, size_t maxsize, Line 539  my_strftime (CHAR_T *s, size_t maxsize,
539      {      {
540        int pad = 0;              /* Padding for number ('-', '_', or 0).  */        int pad = 0;              /* Padding for number ('-', '_', or 0).  */
541        int modifier;             /* Field modifier ('E', 'O', or 0).  */        int modifier;             /* Field modifier ('E', 'O', or 0).  */
542        int digits;               /* Max digits for numeric format.  */        int digits = 0;           /* Max digits for numeric format.  */
543        int number_value;         /* Numeric value to be printed.  */        int number_value;         /* Numeric value to be printed.  */
544        unsigned int u_number_value; /* (unsigned int) number_value.  */        unsigned int u_number_value; /* (unsigned int) number_value.  */
545        bool negative_number;     /* 1 if the number is negative.  */        bool negative_number;     /* The number is negative.  */
546          bool always_output_a_sign; /* +/- should always be output.  */
547          int tz_colon_mask;        /* Bitmask of where ':' should appear.  */
548        const CHAR_T *subfmt;        const CHAR_T *subfmt;
549          CHAR_T sign_char;
550        CHAR_T *bufp;        CHAR_T *bufp;
551        CHAR_T buf[1 + (sizeof (int) < sizeof (time_t)        CHAR_T buf[1
552                        ? INT_STRLEN_BOUND (time_t)                   + 2 /* for the two colons in a %::z or %:::z time zone */
553                        : INT_STRLEN_BOUND (int))];                   + (sizeof (int) < sizeof (time_t)
554                        ? INT_STRLEN_BOUND (time_t)
555                        : INT_STRLEN_BOUND (int))];
556        int width = -1;        int width = -1;
557        bool to_lowcase = false;        bool to_lowcase = false;
558        bool to_uppcase = false;        bool to_uppcase = upcase;
559          size_t colons;
560        bool change_case = false;        bool change_case = false;
561        int format_char;        int format_char;
562    
# Line 523  my_strftime (CHAR_T *s, size_t maxsize, Line 591  my_strftime (CHAR_T *s, size_t maxsize,
591               be in the basic execution character set.  None of these               be in the basic execution character set.  None of these
592               characters can start a multibyte sequence, so they need               characters can start a multibyte sequence, so they need
593               not be analyzed further.  */               not be analyzed further.  */
594            add (1, *p = *f);            add1 (*f);
595            continue;            continue;
596    
597          default:          default:
# Line 574  my_strftime (CHAR_T *s, size_t maxsize, Line 642  my_strftime (CHAR_T *s, size_t maxsize,
642           or this is the wide character version.  */           or this is the wide character version.  */
643        if (*f != L_('%'))        if (*f != L_('%'))
644          {          {
645            add (1, *p = *f);            add1 (*f);
646            continue;            continue;
647          }          }
648    
# Line 650  my_strftime (CHAR_T *s, size_t maxsize, Line 718  my_strftime (CHAR_T *s, size_t maxsize,
718            digits = d;                                                         \            digits = d;                                                         \
719            negative_number = negative;                                         \            negative_number = negative;                                         \
720            u_number_value = v; goto do_signed_number            u_number_value = v; goto do_signed_number
721    
722              /* The mask is not what you might think.
723                 When the ordinal i'th bit is set, insert a colon
724                 before the i'th digit of the time zone representation.  */
725    #define DO_TZ_OFFSET(d, negative, mask, v) \
726              digits = d;                                                         \
727              negative_number = negative;                                         \
728              tz_colon_mask = mask;                                               \
729              u_number_value = v; goto do_tz_offset
730  #define DO_NUMBER_SPACEPAD(d, v) \  #define DO_NUMBER_SPACEPAD(d, v) \
731            digits = d;                                                         \            digits = d;                                                         \
732            number_value = v; goto do_number_spacepad            number_value = v; goto do_number_spacepad
# Line 657  my_strftime (CHAR_T *s, size_t maxsize, Line 734  my_strftime (CHAR_T *s, size_t maxsize,
734          case L_('%'):          case L_('%'):
735            if (modifier != 0)            if (modifier != 0)
736              goto bad_format;              goto bad_format;
737            add (1, *p = *f);            add1 (*f);
738            break;            break;
739    
740          case L_('a'):          case L_('a'):
# Line 741  my_strftime (CHAR_T *s, size_t maxsize, Line 818  my_strftime (CHAR_T *s, size_t maxsize,
818    
819          subformat:          subformat:
820            {            {
821              CHAR_T *old_start = p;              size_t len = strftime_case_ (to_uppcase,
822              size_t len = my_strftime (NULL, (size_t) -1, subfmt,                                           NULL, STRFTIME_ARG ((size_t) -1)
823                                        tp extra_args LOCALE_ARG);                                           subfmt,
824              add (len, my_strftime (p, maxsize - i, subfmt,                                           tp extra_args LOCALE_ARG);
825                                     tp extra_args LOCALE_ARG));              add (len, strftime_case_ (to_uppcase, p,
826                                          STRFTIME_ARG (maxsize - i)
827              if (to_uppcase)                                        subfmt,
828                while (old_start < p)                                        tp extra_args LOCALE_ARG));
                 {  
                   *old_start = TOUPPER ((UCHAR_T) *old_start, loc);  
                   ++old_start;  
                 }  
829            }            }
830            break;            break;
831    
# Line 855  my_strftime (CHAR_T *s, size_t maxsize, Line 928  my_strftime (CHAR_T *s, size_t maxsize,
928            DO_NUMBER_SPACEPAD (2, tp->tm_mday);            DO_NUMBER_SPACEPAD (2, tp->tm_mday);
929    
930            /* All numeric formats set DIGITS and NUMBER_VALUE (or U_NUMBER_VALUE)            /* All numeric formats set DIGITS and NUMBER_VALUE (or U_NUMBER_VALUE)
931               and then jump to one of these three labels.  */               and then jump to one of these labels.  */
932    
933            do_tz_offset:
934              always_output_a_sign = true;
935              goto do_number_body;
936    
937          do_number_spacepad:          do_number_spacepad:
938            /* Force `_' flag unless overridden by `0' or `-' flag.  */            /* Force `_' flag unless overridden by `0' or `-' flag.  */
# Line 868  my_strftime (CHAR_T *s, size_t maxsize, Line 945  my_strftime (CHAR_T *s, size_t maxsize,
945            u_number_value = number_value;            u_number_value = number_value;
946    
947          do_signed_number:          do_signed_number:
948              always_output_a_sign = false;
949              tz_colon_mask = 0;
950    
951            do_number_body:
952            /* Format U_NUMBER_VALUE according to the MODIFIER flag.            /* Format U_NUMBER_VALUE according to the MODIFIER flag.
953               NEGATIVE_NUMBER is nonzero if the original number was               NEGATIVE_NUMBER is nonzero if the original number was
954               negative; in this case it was converted directly to               negative; in this case it was converted directly to
# Line 904  my_strftime (CHAR_T *s, size_t maxsize, Line 985  my_strftime (CHAR_T *s, size_t maxsize,
985    
986            do            do
987              {              {
988                  if (tz_colon_mask & 1)
989                    *--bufp = ':';
990                  tz_colon_mask >>= 1;
991                *--bufp = u_number_value % 10 + L_('0');                *--bufp = u_number_value % 10 + L_('0');
992                u_number_value /= 10;                u_number_value /= 10;
993              }              }
994            while (u_number_value != 0);            while (u_number_value != 0 || tz_colon_mask != 0);
995    
996          do_number_sign_and_padding:          do_number_sign_and_padding:
997            if (digits < width)            if (digits < width)
998              digits = width;              digits = width;
999    
1000            if (negative_number)            sign_char = (negative_number ? L_('-')
1001              *--bufp = L_('-');                         : always_output_a_sign ? L_('+')
1002                           : 0);
1003    
1004            if (pad != L_('-'))            if (pad == L_('-'))
1005                {
1006                  if (sign_char)
1007                    add1 (sign_char);
1008                }
1009              else
1010              {              {
1011                int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))                int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))
1012                                        - bufp);                                        - bufp) - !!sign_char;
1013    
1014                if (padding > 0)                if (padding > 0)
1015                  {                  {
# Line 932  my_strftime (CHAR_T *s, size_t maxsize, Line 1022  my_strftime (CHAR_T *s, size_t maxsize,
1022                          memset_space (p, padding);                          memset_space (p, padding);
1023                        i += padding;                        i += padding;
1024                        width = width > padding ? width - padding : 0;                        width = width > padding ? width - padding : 0;
1025                          if (sign_char)
1026                            add1 (sign_char);
1027                      }                      }
1028                    else                    else
1029                      {                      {
1030                        if ((size_t) digits >= maxsize - i)                        if ((size_t) digits >= maxsize - i)
1031                          return 0;                          return 0;
1032    
1033                        if (negative_number)                        if (sign_char)
1034                          {                          add1 (sign_char);
                           ++bufp;  
   
                           if (p)  
                             *p++ = L_('-');  
                           ++i;  
                         }  
1035    
1036                        if (p)                        if (p)
1037                          memset_zero (p, padding);                          memset_zero (p, padding);
# Line 953  my_strftime (CHAR_T *s, size_t maxsize, Line 1039  my_strftime (CHAR_T *s, size_t maxsize,
1039                        width = 0;                        width = 0;
1040                      }                      }
1041                  }                  }
1042                  else
1043                    {
1044                      if (sign_char)
1045                        add1 (sign_char);
1046                    }
1047              }              }
1048    
1049            cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);            cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);
# Line 1012  my_strftime (CHAR_T *s, size_t maxsize, Line 1103  my_strftime (CHAR_T *s, size_t maxsize,
1103              goto bad_format;              goto bad_format;
1104    
1105            number_value = ns;            number_value = ns;
1106            if (width != -1)            if (width == -1)
1107                width = 9;
1108              else
1109              {              {
1110                /* Take an explicit width less than 9 as a precision.  */                /* Take an explicit width less than 9 as a precision.  */
1111                int j;                int j;
# Line 1020  my_strftime (CHAR_T *s, size_t maxsize, Line 1113  my_strftime (CHAR_T *s, size_t maxsize,
1113                  number_value /= 10;                  number_value /= 10;
1114              }              }
1115    
1116            DO_NUMBER (9, number_value);            DO_NUMBER (width, number_value);
1117  #endif  #endif
1118    
1119          case L_('n'):          case L_('n'):
1120            add (1, *p = L_('\n'));            add1 (L_('\n'));
1121            break;            break;
1122    
1123          case L_('P'):          case L_('P'):
# Line 1093  my_strftime (CHAR_T *s, size_t maxsize, Line 1186  my_strftime (CHAR_T *s, size_t maxsize,
1186              while (t != 0);              while (t != 0);
1187    
1188              digits = 1;              digits = 1;
1189                always_output_a_sign = false;
1190              goto do_number_sign_and_padding;              goto do_number_sign_and_padding;
1191            }            }
1192    
# Line 1118  my_strftime (CHAR_T *s, size_t maxsize, Line 1212  my_strftime (CHAR_T *s, size_t maxsize,
1212            goto subformat;            goto subformat;
1213    
1214          case L_('t'):          case L_('t'):
1215            add (1, *p = L_('\t'));            add1 (L_('\t'));
1216            break;            break;
1217    
1218          case L_('u'):          case L_('u'):
# Line 1280  my_strftime (CHAR_T *s, size_t maxsize, Line 1374  my_strftime (CHAR_T *s, size_t maxsize,
1374  #endif  #endif
1375            break;            break;
1376    
1377            case L_(':'):
1378              /* :, ::, and ::: are valid only just before 'z'.
1379                 :::: etc. are rejected later.  */
1380              for (colons = 1; f[colons] == L_(':'); colons++)
1381                continue;
1382              if (f[colons] != L_('z'))
1383                goto bad_format;
1384              f += colons;
1385              goto do_z_conversion;
1386    
1387          case L_('z'):          case L_('z'):
1388              colons = 0;
1389    
1390            do_z_conversion:
1391            if (tp->tm_isdst < 0)            if (tp->tm_isdst < 0)
1392              break;              break;
1393    
1394            {            {
1395              int diff;              int diff;
1396                int hour_diff;
1397                int min_diff;
1398                int sec_diff;
1399  #if HAVE_TM_GMTOFF  #if HAVE_TM_GMTOFF
1400              diff = tp->tm_gmtoff;              diff = tp->tm_gmtoff;
1401  #else  #else
# Line 1324  my_strftime (CHAR_T *s, size_t maxsize, Line 1434  my_strftime (CHAR_T *s, size_t maxsize,
1434                }                }
1435  #endif  #endif
1436    
1437              if (diff < 0)              hour_diff = diff / 60 / 60;
1438                min_diff = diff / 60 % 60;
1439                sec_diff = diff % 60;
1440    
1441                switch (colons)
1442                {                {
1443                  add (1, *p = L_('-'));                case 0: /* +hhmm */
1444                  diff = -diff;                  DO_TZ_OFFSET (5, diff < 0, 0, hour_diff * 100 + min_diff);
1445                }  
1446              else                case 1: tz_hh_mm: /* +hh:mm */
1447                add (1, *p = L_('+'));                  DO_TZ_OFFSET (6, diff < 0, 04, hour_diff * 100 + min_diff);
1448    
1449              diff /= 60;                case 2: tz_hh_mm_ss: /* +hh:mm:ss */
1450              DO_NUMBER (4, (diff / 60) * 100 + diff % 60);                  DO_TZ_OFFSET (9, diff < 0, 024,
1451                                  hour_diff * 10000 + min_diff * 100 + sec_diff);
1452    
1453                  case 3: /* +hh if possible, else +hh:mm, else +hh:mm:ss */
1454                    if (sec_diff != 0)
1455                      goto tz_hh_mm_ss;
1456                    if (min_diff != 0)
1457                      goto tz_hh_mm;
1458                    DO_TZ_OFFSET (3, diff < 0, 0, hour_diff);
1459    
1460                  default:
1461                    goto bad_format;
1462                  }
1463            }            }
1464    
1465          case L_('\0'):          /* GNU extension: % at end of format.  */          case L_('\0'):          /* GNU extension: % at end of format.  */
# Line 1354  my_strftime (CHAR_T *s, size_t maxsize, Line 1480  my_strftime (CHAR_T *s, size_t maxsize,
1480          }          }
1481      }      }
1482    
1483    #if ! FPRINTFTIME
1484    if (p && maxsize != 0)    if (p && maxsize != 0)
1485      *p = L_('\0');      *p = L_('\0');
1486    #endif
1487    
1488    return i;    return i;
1489  }  }
1490  #ifdef _LIBC  
1491    /* Write information from TP into S according to the format
1492       string FORMAT, writing no more that MAXSIZE characters
1493       (including the terminating '\0') and returning number of
1494       characters written.  If S is NULL, nothing will be written
1495       anywhere, so to determine how many characters would be
1496       written, use NULL for S and (size_t) -1 for MAXSIZE.  */
1497    size_t
1498    my_strftime (STREAM_OR_CHAR_T *s, STRFTIME_ARG (size_t maxsize)
1499                 const CHAR_T *format,
1500                 const struct tm *tp extra_args_spec LOCALE_PARAM_PROTO)
1501    {
1502      return strftime_case_ (false, s, STRFTIME_ARG (maxsize)
1503                             format, tp extra_args LOCALE_ARG);
1504    }
1505    
1506    #if defined _LIBC && ! FPRINTFTIME
1507  libc_hidden_def (my_strftime)  libc_hidden_def (my_strftime)
1508  #endif  #endif
1509    
1510    
1511  #ifdef emacs  #if defined emacs && ! FPRINTFTIME
1512  /* For Emacs we have a separate interface which corresponds to the normal  /* For Emacs we have a separate interface which corresponds to the normal
1513     strftime function plus the ut argument, but without the ns argument.  */     strftime function plus the ut argument, but without the ns argument.  */
1514  size_t  size_t

Legend:
Removed from v.1.9  
changed lines
  Added in v.1.10

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26