workbench/libs/locale/formatdate.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 #include "locale_intern.h"
  10 #include <exec/types.h>
  11 #include <utility/hooks.h>
  12 #include <utility/date.h>
  13 #include <proto/utility.h>
  14 #include <clib/alib_protos.h>
  15
  16 #include <stdio.h>
  17
  18 VOID PrintDigits(UWORD number, char fill, UWORD len, const struct Hook *hook,
  19     const struct Locale *locale);
  20 VOID _WriteChar(char token, const struct Hook *hook,
  21     const struct Locale *locale);
  22 VOID _WriteString(CONST_STRPTR string, const struct Hook *hook,
  23     const struct Locale *locale);
  24
  25 static const ULONG dayspermonth[13] =
  26     {0 /* not used */,0,31,59,90,120,151,181,212,243,273,304,334};
  27
  28 /*****************************************************************************
  29
  30     NAME */
  31 #include <proto/locale.h>
  32
  33         AROS_LH4(VOID, FormatDate,
  34
  35 /*  SYNOPSIS */
  36         AROS_LHA(const struct Locale    *, locale, A0),
  37         AROS_LHA(CONST_STRPTR, formatString, A1),
  38         AROS_LHA(const struct DateStamp *, date, A2),
  39         AROS_LHA(const struct Hook      *, hook, A3),
  40
  41 /*  LOCATION */
  42         struct LocaleBase *, LocaleBase, 10, Locale)
  43
  44 /*  FUNCTION
  45
  46     Generate a date string based on a template. The bytes generated are sent
  47     to a user specified callback function.
  48
  49     INPUTS
  50
  51     locale        --  the locale to use when formatting the string or NULL
  52                       for the system default locale.
  53     formatString  --  the formatting template string; this is much like the
  54                       printf() formatting style, i.e. a % followed by a
  55                       formatting command. The following commands exist:
  56
  57                       %a -- abbreviated weekday name
  58                       %A -- weekday name
  59                       %b -- abbreviated month name
  60                       %B -- month name
  61                       %c -- the same as "%a %b %d %H:%M:%S %Y"
  62                       %C -- the same as "%a %b %e %T %Z %Y"
  63                       %d -- day number with leading zeros
  64                       %D -- the same as "%m/%d/%y"
  65                       %e -- day number with leading spaces
  66                       %h -- abbreviated month name
  67                       %H -- hour using 24 hour style with leading zeros
  68                       %I -- hour using 12 hour style with leading zeros
  69                       %j -- julian date
  70                       %m -- month number with leading zeros
  71                       %M -- the number of minutes with leading zeros
  72                       %n -- linefeed
  73                       %p -- AM or PM string
  74                       %q -- hour using 24 hour style
  75                       %Q -- hour using 12 hour style
  76                       %r -- the same as "%I:%M:%S %p"
  77                       %R -- the same as "%H:%M"
  78                       %S -- the number of seconds with leading zeros
  79                       %t -- tab
  80                       %T -- the same as "%H:%M:%S"
  81                       %U -- the week number, taking Sunday as the first day
  82                             of the week
  83                       %w -- the weekday number
  84                       %W -- the week number, taking Monday as the first day
  85                             of the week
  86                       %x -- the same as "%m/%d/%y"
  87                       %X -- the same as "%H:%M:%S"
  88                       %y -- the year using two digits with leading zeros
  89                       %Y -- the year using four digits with leading zeros
  90
  91                       If the template parameter is NULL, a single null byte
  92                       is sent to the callback function.
  93
  94     date          --  the current date
  95     hook          --  callback function; this is called for every character
  96                       generated with the following arguments:
  97
  98                       * pointer to hook structure
  99                       * character
 100                       * pointer to locale
 101
 102     RESULT
 103
 104     NOTES
 105
 106     EXAMPLE
 107
 108     BUGS
 109
 110     SEE ALSO
 111
 112     ParseDate(), <libraries/locale.h>
 113
 114     INTERNALS
 115
 116 *****************************************************************************/
 117 {
 118     AROS_LIBFUNC_INIT
 119
 120     struct ClockData cData;
 121     ULONG week, days, tmp;
 122     struct Locale *def_locale = NULL;
 123
 124     if (hook == NULL)
 125         return;
 126
 127     if (locale == NULL)
 128     {
 129         locale = OpenLocale(NULL);
 130         if (locale == NULL)
 131             return;
 132         def_locale = (struct Locale *)locale;
 133     }
 134
 135     if (formatString == NULL)
 136     {
 137         _WriteChar(0, hook, locale);
 138         CloseLocale(def_locale);
 139         return;
 140     }
 141
 142     /* TODO: Amiga2Date will fail around year 2114, because then the
 143      *       number of seconds since 1978 won't fit in a 32 bit variable anymore!
 144      */
 145
 146     Amiga2Date(date->ds_Days * 86400 + date->ds_Minute * 60 +
 147         date->ds_Tick / 50, &cData);
 148
 149     while (*formatString != 0)
 150     {
 151         if (*formatString == '%')
 152         {
 153             switch (*(++formatString))
 154             {
 155             case 'a':
 156                 _WriteString(GetLocaleStr(locale, ABDAY_1 + cData.wday),
 157                     hook, locale);
 158                 break;
 159
 160             case 'A':
 161                 _WriteString(GetLocaleStr(locale, DAY_1 + cData.wday), hook,
 162                     locale);
 163                 break;
 164
 165             case 'b':
 166                 _WriteString(GetLocaleStr(locale,
 167                         ABMON_1 + cData.month - 1), hook, locale);
 168                 break;
 169
 170             case 'B':
 171                 _WriteString(GetLocaleStr(locale, MON_1 + cData.month - 1),
 172                     hook, locale);
 173                 break;
 174
 175             case 'c':
 176                 FormatDate(locale, "%a %b %d %H:%M:%S %Y", date, hook);
 177                 break;
 178
 179             case 'C':
 180                 FormatDate(locale, "%a %b %e %T %Z %Y", date, hook);
 181                 break;
 182
 183             case 'd':
 184                 PrintDigits(cData.mday, '0', 2, hook, locale);
 185                 break;
 186
 187             case 'x':
 188             case 'D':
 189                 FormatDate(locale, "%m/%d/%y", date, hook);
 190                 break;
 191
 192             case 'e':
 193                 PrintDigits(cData.mday, ' ', 2, hook, locale);
 194                 break;
 195
 196             case 'h':
 197                 _WriteString(GetLocaleStr(locale,
 198                         ABMON_1 + cData.month - 1), hook, locale);
 199                 break;
 200
 201             case 'H':
 202                 PrintDigits(cData.hour, '0', 2, hook, locale);
 203                 break;
 204
 205             case 'I':
 206                 PrintDigits(cData.hour % 12, '0', 2, hook, locale);
 207                 break;
 208
 209             case 'j':
 210                 /* TODO: Julian date not tested. */
 211                 /* Julian date is DDD (1 - 366) */
 212                 PrintDigits(cData.mday + dayspermonth[cData.month],
 213                     '0', 3, hook, locale);
 214                 break;
 215
 216             case 'm':
 217                 PrintDigits(cData.month, '0', 2, hook, locale);
 218                 break;
 219
 220             case 'M':
 221                 PrintDigits(cData.min, '0', 2, hook, locale);
 222                 break;
 223
 224             case 'n':
 225                 _WriteChar('\n', hook, locale);
 226                 break;
 227
 228             case 'p':
 229                 _WriteString(GetLocaleStr(locale,
 230                         cData.hour < 12 ? AM_STR : PM_STR), hook, locale);
 231                 break;
 232
 233             case 'q':
 234                 PrintDigits(cData.hour, -1, 2, hook, locale);
 235                 break;
 236
 237             case 'Q':
 238                 PrintDigits(cData.hour % 12, -1, 2, hook, locale);
 239                 break;
 240
 241             case 'r':
 242                 FormatDate(locale, "%I:%M:%S %p", date, hook);
 243                 break;
 244
 245             case 'R':
 246                 FormatDate(locale, "%H:%M", date, hook);
 247                 break;
 248
 249             case 'S':
 250                 PrintDigits(cData.sec, '0', 2, hook, locale);
 251                 break;
 252
 253             case 't':
 254                 _WriteChar('\t', hook, locale);
 255                 break;
 256
 257             case 'X':
 258             case 'T':
 259                 FormatDate(locale, "%H:%M:%S", date, hook);
 260                 break;
 261
 262             case 'W':          /* week number, Monday first day of week */
 263             case 'U':          /* week number, Sunday first day of week */
 264                 days = cData.mday + dayspermonth[cData.month];
 265
 266                 /* leap year ? */
 267                 if (0 == (cData.year % 4) && cData.month > 2)
 268                 {
 269                     /*
 270                      ** 1700, 1800, 1900, 2100, 2200 re not leap years.
 271                      ** 2000 is a leap year.
 272                      ** -> if a year is divisible by 100 but not by 400 then
 273                      ** it is not a leap year!
 274                      */
 275                     if (0 == (cData.year % 100) && 0 != (cData.year % 400))
 276                         ;
 277                     else
 278                         days++;
 279                 }
 280
 281                 /*
 282                  ** If January 1st is a Monday then the first week
 283                  ** will start with a Sunday January 7th if Sunday is the first day of the week
 284                  ** but if Monday is the first day of the week then Jan 1st will also be the
 285                  ** first day of the first week.
 286                  */
 287                 /*
 288                  ** Go to Saturday = last day of week if Sunday is first day of week
 289                  ** Go to Sunday   = last day of week if Monday is first day of week
 290                  */
 291                 if ('U' == *formatString)
 292                 {
 293                     /* Sunday is first day of the week */
 294                     tmp = days + (6 - cData.wday);
 295                 }
 296                 else
 297                 {
 298                     /* Monday is first day of week */
 299                     if (0 != cData.wday)
 300                         tmp = days + (7 - cData.wday);
 301                     else
 302                         tmp = days;
 303                 }
 304
 305                 if (tmp < 7)
 306                     week = 0;
 307                 else
 308                 {
 309                     /* cut off the few days that belong to week 0 */
 310                     tmp -= (tmp % 7);
 311                     /* Calculate the full amount of weeks */
 312                     week = tmp / 7;
 313                 }
 314
 315                 PrintDigits(week, '0', 2, hook, locale);
 316                 break;
 317
 318             case 'w':
 319                 PrintDigits(cData.wday, -1, 1, hook, locale);
 320                 break;
 321
 322             case 'y':
 323                 PrintDigits(cData.year % 100, '0', 2, hook, locale);
 324                 break;
 325
 326             case 'Y':
 327                 PrintDigits(cData.year, '0', 4, hook, locale);
 328                 break;
 329
 330             case 'Z':
 331                 /* cuurent time zone Unimplemented in 3.1 */
 332                 break;
 333
 334             case 0:
 335                 break;
 336
 337             default:
 338                 _WriteChar(*formatString, hook, locale);
 339                 break;
 340             }
 341         }
 342         else
 343         {
 344             _WriteChar(*formatString, hook, locale);
 345         }
 346
 347         formatString++;
 348     }
 349
 350     _WriteChar(0, hook, locale);        /* Write null terminator */
 351
 352     CloseLocale(def_locale);
 353
 354     AROS_LIBFUNC_EXIT
 355 }
 356
 357
 358 VOID _WriteString(CONST_STRPTR string, const struct Hook *hook,
 359     const struct Locale *locale)
 360 {
 361     while (*string != 0)
 362     {
 363         _WriteChar(*string++, hook, locale);
 364     }
 365 }
 366
 367
 368 VOID _WriteChar(char token, const struct Hook *hook,
 369     const struct Locale *locale)
 370 {
 371     AROS_UFC3NR(VOID, hook->h_Entry,
 372         AROS_UFCA(const struct Hook *, hook, A0),
 373         AROS_UFCA(const struct Locale *, locale, A2),
 374         AROS_UFCA(char, token, A1));
 375 }
 376
 377
 378 VOID PrintDigits(UWORD number, char fill, UWORD len,
 379     const struct Hook *hook, const struct Locale *locale)
 380 {
 381     char buf[7];
 382     char *ptr = &buf[6];
 383     int i = 0;
 384
 385     buf[6] = 0;
 386
 387     while ((number || !i) && i < len)
 388     {
 389         *--ptr = number % 10 + '0';
 390         number /= 10;
 391         i++;
 392     }
 393
 394     while (len - i > 0 && (char)-1 != fill)
 395     {
 396         len--;
 397         _WriteChar(fill, hook, locale);
 398     }
 399
 400     _WriteString((char *)ptr, hook, locale);
 401 }