src/strftime.c

   1 /* strftime - custom formatting of date and/or time
   2    Copyright (C) 1989, 1991, 1992 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; see the file COPYING.  If not, write to
  16    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17    Boston, MA 02111-1307, USA.  */
  18
  19 /* Synched up with: FSF 19.30. */
  20
  21 /* Note: this version of strftime lacks locale support,
  22    but it is standalone.
  23
  24    Performs `%' substitutions similar to those in printf.  Except
  25    where noted, substituted fields have a fixed size; numeric fields are
  26    padded if necessary.  Padding is with zeros by default; for fields
  27    that display a single number, padding can be changed or inhibited by
  28    following the `%' with one of the modifiers described below.  Unknown
  29    field specifiers are copied as normal characters.  All other
  30    characters are copied to the output without change.
  31
  32    Supports a superset of the ANSI C field specifiers.
  33
  34    Literal character fields:
  35    %    %
  36    n    newline
  37    t    tab
  38
  39    Numeric modifiers (a nonstandard extension):
  40    -    do not pad the field
  41    _    pad the field with spaces
  42
  43    Time fields:
  44    %H   hour (00..23)
  45    %I   hour (01..12)
  46    %k   hour ( 0..23)
  47    %l   hour ( 1..12)
  48    %M   minute (00..59)
  49    %p   locale's AM or PM
  50    %r   time, 12-hour (hh:mm:ss [AP]M)
  51    %R   time, 24-hour (hh:mm)
  52    %s   time in seconds since 00:00:00, Jan 1, 1970 (a nonstandard extension)
  53    %S   second (00..61)
  54    %T   time, 24-hour (hh:mm:ss)
  55    %X   locale's time representation (%H:%M:%S)
  56    %Z   time zone (EDT), or nothing if no time zone is determinable
  57
  58    Date fields:
  59    %a   locale's abbreviated weekday name (Sun..Sat)
  60    %A   locale's full weekday name, variable length (Sunday..Saturday)
  61    %b   locale's abbreviated month name (Jan..Dec)
  62    %B   locale's full month name, variable length (January..December)
  63    %c   locale's date and time (Sat Nov 04 12:02:33 EST 1989)
  64    %C   century (00..99)
  65    %d   day of month (01..31)
  66    %e   day of month ( 1..31)
  67    %D   date (mm/dd/yy)
  68    %h   same as %b
  69    %j   day of year (001..366)
  70    %m   month (01..12)
  71    %U   week number of year with Sunday as first day of week (00..53)
  72    %w   day of week (0..6)
  73    %W   week number of year with Monday as first day of week (00..53)
  74    %x   locale's date representation (mm/dd/yy)
  75    %y   last two digits of year (00..99)
  76    %Y   year (1970...)
  77
  78    David MacKenzie <djm@gnu.ai.mit.edu> */
  79
  80 #ifdef HAVE_CONFIG_H
  81 #include <config.h>
  82 #include "lisp.h"
  83 #endif
  84
  85 #include <stdio.h>
  86 #include <sys/types.h>
  87 #if defined(TM_IN_SYS_TIME) || (!defined(HAVE_TM_ZONE) && !defined(HAVE_TZNAME))
  88 #include <sys/time.h>
  89 #else
  90 #include <time.h>
  91 #endif
  92
  93 #ifndef STDC_HEADERS
  94 time_t mktime ();
  95 #endif
  96
  97 #if defined(WIN32_NATIVE) || defined(CYGWIN)
  98 #include <time.h>
  99 #else
 100 #if defined(HAVE_TZNAME)
 101 extern char *tzname[2];
 102 #endif
 103 #endif /* WIN32_NATIVE */
 104
 105 #ifdef emacs
 106 #define strftime emacs_strftime
 107 #endif
 108
 109 /* Types of padding for numbers in date and time. */
 110 enum padding
 111 {
 112   none, blank, zero
 113 };
 114
 115 static char const* const days[] =
 116 {
 117   "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
 118 };
 119
 120 static char const * const months[] =
 121 {
 122   "January", "February", "March", "April", "May", "June",
 123   "July", "August", "September", "October", "November", "December"
 124 };
 125
 126 /* Add character C to STRING and increment LENGTH,
 127    unless LENGTH would exceed MAX. */
 128
 129 #define add_char(c) do          \
 130 {                               \
 131   if (length + 1 <= max)        \
 132     string[length++] = (c);     \
 133 } while (0)
 134
 135 /* Add a 2 digit number to STRING, padding if specified.
 136    Return the number of characters added, up to MAX. */
 137
 138 static int
 139 add_num2 (char *string, int num, int max, enum padding pad)
 140 {
 141   int top = num / 10;
 142   int length = 0;
 143
 144   if (top == 0 && pad == blank)
 145     add_char (' ');
 146   else if (top != 0 || pad == zero)
 147     add_char (top + '0');
 148   add_char (num % 10 + '0');
 149   return length;
 150 }
 151
 152 /* Add a 3 digit number to STRING, padding if specified.
 153    Return the number of characters added, up to MAX. */
 154
 155 static int
 156 add_num3 (char *string, int num, int max, enum padding pad)
 157 {
 158   int top = num / 100;
 159   int mid = (num - top * 100) / 10;
 160   int length = 0;
 161
 162   if (top == 0 && pad == blank)
 163     add_char (' ');
 164   else if (top != 0 || pad == zero)
 165     add_char (top + '0');
 166   if (mid == 0 && top == 0 && pad == blank)
 167     add_char (' ');
 168   else if (mid != 0 || top != 0 || pad == zero)
 169     add_char (mid + '0');
 170   add_char (num % 10 + '0');
 171   return length;
 172 }
 173
 174 /* Like strncpy except return the number of characters copied. */
 175
 176 static int
 177 add_str (char *to, const char *from, int max)
 178 {
 179   int i;
 180
 181   for (i = 0; from[i] && i <= max; ++i)
 182     to[i] = from[i];
 183   return i;
 184 }
 185
 186 static int
 187 add_num_time_t (char *string, int max, time_t num)
 188 {
 189   /* This buffer is large enough to hold the character representation
 190      (including the trailing NUL) of any unsigned decimal quantity
 191      whose binary representation fits in 128 bits.  */
 192   char buf[40];
 193   int length;
 194
 195   if (sizeof (num) > 16)
 196     ABORT ();
 197   sprintf (buf, "%lu", (unsigned long) num);
 198   length = add_str (string, buf, max);
 199   return length;
 200 }
 201
 202 /* Return the week in the year of the time in TM, with the weeks
 203    starting on Sundays. */
 204
 205 static int
 206 sun_week (const struct tm *tm)
 207 {
 208   int dl;
 209
 210   /* Set `dl' to the day in the year of the last day of the week previous
 211      to the one containing the day specified in TM.  If the day specified
 212      in TM is in the first week of the year, `dl' will be negative or 0.
 213      Otherwise, calculate the number of complete weeks before our week
 214      (dl / 7) and add any partial week at the start of the year (dl % 7). */
 215   dl = tm->tm_yday - tm->tm_wday;
 216   return dl <= 0 ? 0 : dl / 7 + (dl % 7 != 0);
 217 }
 218
 219 /* Return the week in the year of the time in TM, with the weeks
 220    starting on Mondays. */
 221
 222 static int
 223 mon_week (const struct tm *tm)
 224 {
 225   int dl, wday;
 226
 227   if (tm->tm_wday == 0)
 228     wday = 6;
 229   else
 230     wday = tm->tm_wday - 1;
 231   dl = tm->tm_yday - wday;
 232   return dl <= 0 ? 0 : dl / 7 + (dl % 7 != 0);
 233 }
 234
 235 #if !defined(HAVE_TM_ZONE) && !defined(HAVE_TZNAME)
 236 char *zone_name (const struct tm *tp);
 237 char *
 238 zone_name (const struct tm *tp)
 239 {
 240   char *timezone ();
 241   struct timeval tv;
 242   struct timezone tz;
 243
 244   gettimeofday (&tv, &tz);
 245   return timezone (tz.tz_minuteswest, tp->tm_isdst);
 246 }
 247 #endif
 248
 249 /* Format the time given in TM according to FORMAT, and put the
 250    results in STRING.
 251    Return the number of characters (not including terminating null)
 252    that were put into STRING, or 0 if the length would have
 253    exceeded MAX. */
 254
 255 size_t strftime (char *string, size_t max, const char *format,
 256                  const struct tm *tm);
 257
 258 size_t
 259 strftime (char *string, size_t max, const char *format, const struct tm *tm)
 260 {
 261   enum padding pad;             /* Type of padding to apply. */
 262   size_t length = 0;            /* Characters put in STRING so far. */
 263
 264   for (; *format && length < max; ++format)
 265     {
 266       if (*format != '%')
 267         add_char (*format);
 268       else
 269         {
 270           ++format;
 271           /* Modifiers: */
 272           if (*format == '-')
 273             {
 274               pad = none;
 275               ++format;
 276             }
 277           else if (*format == '_')
 278             {
 279               pad = blank;
 280               ++format;
 281             }
 282           else
 283             pad = zero;
 284
 285           switch (*format)
 286             {
 287               /* Literal character fields: */
 288             case 0:
 289             case '%':
 290               add_char ('%');
 291               break;
 292             case 'n':
 293               add_char ('\n');
 294               break;
 295             case 't':
 296               add_char ('\t');
 297               break;
 298             default:
 299               add_char (*format);
 300               break;
 301
 302               /* Time fields: */
 303             case 'H':
 304             case 'k':
 305               length +=
 306                 add_num2 (&string[length], tm->tm_hour, max - length,
 307                           *format == 'H' ? pad : blank);
 308               break;
 309             case 'I':
 310             case 'l':
 311               {
 312                 int hour12;
 313
 314                 if (tm->tm_hour == 0)
 315                   hour12 = 12;
 316                 else if (tm->tm_hour > 12)
 317                   hour12 = tm->tm_hour - 12;
 318                 else
 319                   hour12 = tm->tm_hour;
 320                 length +=
 321                   add_num2 (&string[length], hour12, max - length,
 322                             *format == 'I' ? pad : blank);
 323               }
 324               break;
 325             case 'M':
 326               length +=
 327                 add_num2 (&string[length], tm->tm_min, max - length, pad);
 328               break;
 329             case 'p':
 330               if (tm->tm_hour < 12)
 331                 add_char ('A');
 332               else
 333                 add_char ('P');
 334               add_char ('M');
 335               break;
 336             case 'r':
 337               length +=
 338                 strftime (&string[length], max - length, "%I:%M:%S %p", tm);
 339               break;
 340             case 'R':
 341               length +=
 342                 strftime (&string[length], max - length, "%H:%M", tm);
 343               break;
 344
 345             case 's':
 346               {
 347                 struct tm writable_tm;
 348                 writable_tm = *tm;
 349                 length += add_num_time_t (&string[length], max - length,
 350                                           mktime (&writable_tm));
 351               }
 352               break;
 353
 354             case 'S':
 355               length +=
 356                 add_num2 (&string[length], tm->tm_sec, max - length, pad);
 357               break;
 358             case 'T':
 359               length +=
 360                 strftime (&string[length], max - length, "%H:%M:%S", tm);
 361               break;
 362             case 'X':
 363               length +=
 364                 strftime (&string[length], max - length, "%H:%M:%S", tm);
 365               break;
 366             case 'Z':
 367 #ifdef HAVE_TM_ZONE
 368               length += add_str (&string[length], tm->tm_zone, max - length);
 369 #else
 370 #ifdef HAVE_TZNAME
 371               if (tm->tm_isdst && tzname[1] && *tzname[1])
 372                 length += add_str (&string[length], tzname[1], max - length);
 373               else
 374                 length += add_str (&string[length], tzname[0], max - length);
 375 #else
 376               length += add_str (&string[length], zone_name (tm), max - length);
 377 #endif
 378 #endif
 379               break;
 380
 381               /* Date fields: */
 382             case 'a':
 383               add_char (days[tm->tm_wday][0]);
 384               add_char (days[tm->tm_wday][1]);
 385               add_char (days[tm->tm_wday][2]);
 386               break;
 387             case 'A':
 388               length +=
 389                 add_str (&string[length], days[tm->tm_wday], max - length);
 390               break;
 391             case 'b':
 392             case 'h':
 393               add_char (months[tm->tm_mon][0]);
 394               add_char (months[tm->tm_mon][1]);
 395               add_char (months[tm->tm_mon][2]);
 396               break;
 397             case 'B':
 398               length +=
 399                 add_str (&string[length], months[tm->tm_mon], max - length);
 400               break;
 401             case 'c':
 402               length +=
 403                 strftime (&string[length], max - length,
 404                           "%a %b %d %H:%M:%S %Z %Y", tm);
 405               break;
 406             case 'C':
 407               length +=
 408                 add_num2 (&string[length], (tm->tm_year + 1900) / 100,
 409                           max - length, pad);
 410               break;
 411             case 'd':
 412               length +=
 413                 add_num2 (&string[length], tm->tm_mday, max - length, pad);
 414               break;
 415             case 'e':
 416               length +=
 417                 add_num2 (&string[length], tm->tm_mday, max - length, blank);
 418               break;
 419             case 'D':
 420               length +=
 421                 strftime (&string[length], max - length, "%m/%d/%y", tm);
 422               break;
 423             case 'j':
 424               length +=
 425                 add_num3 (&string[length], tm->tm_yday + 1, max - length, pad);
 426               break;
 427             case 'm':
 428               length +=
 429                 add_num2 (&string[length], tm->tm_mon + 1, max - length, pad);
 430               break;
 431             case 'U':
 432               length +=
 433                 add_num2 (&string[length], sun_week (tm), max - length, pad);
 434               break;
 435             case 'w':
 436               add_char (tm->tm_wday + '0');
 437               break;
 438             case 'W':
 439               length +=
 440                 add_num2 (&string[length], mon_week (tm), max - length, pad);
 441               break;
 442             case 'x':
 443               length +=
 444                 strftime (&string[length], max - length, "%m/%d/%y", tm);
 445               break;
 446             case 'y':
 447               length +=
 448                 add_num2 (&string[length], tm->tm_year % 100,
 449                           max - length, pad);
 450               break;
 451             case 'Y':
 452               add_char ((tm->tm_year + 1900) / 1000 + '0');
 453               length +=
 454                 add_num3 (&string[length],
 455                           (1900 + tm->tm_year) % 1000, max - length, zero);
 456               break;
 457             }
 458         }
 459     }
 460   add_char (0);
 461   return length - 1;
 462 }