rom/dos/datetostr.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Convert a DateTime struct into strings.
   6     Lang: english
   7 */
   8 #include "dos_intern.h"
   9 #include "date.h"
  10
  11 #ifdef TEST
  12 #       include <proto/dos.h>
  13 #       include <stdio.h>
  14 #       undef AROS_LH1
  15 #       undef DateToStr
  16 #       undef AROS_LHA
  17 #       define AROS_LH1(ret,name,arg,type,base,offset,libname) \
  18     ret name (arg)
  19 #       define AROS_LHA(type,name,reg) type name
  20 #endif
  21
  22 const ULONG Dos_DayTable[]=
  23 {
  24     0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335
  25 };
  26
  27 const char *const Dos_MonthTable[]=
  28 {
  29     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  30     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  31 };
  32
  33 const char *const Dos_WeekTable[]=
  34 {
  35     "Sunday", "Monday", "Tuesday", "Wednesday",
  36     "Thursday", "Friday", "Saturday"
  37 };
  38
  39 const char *const Dos_SubstDateTable[]=
  40 {
  41     "Tomorrow", "Today", "Yesterday"
  42 };
  43
  44 /*****************************************************************************
  45
  46     NAME */
  47 #include <dos/datetime.h>
  48 #include <proto/dos.h>
  49
  50         AROS_LH1(BOOL, DateToStr,
  51
  52 /*  SYNOPSIS */
  53         AROS_LHA(struct DateTime *, datetime, D1),
  54
  55 /*  LOCATION */
  56         struct DosLibrary *, DOSBase, 124, Dos)
  57
  58 /*  FUNCTION
  59         DateToStr converts an AmigaDOS DateStamp to a human
  60         readable ASCII string as requested by your settings in the
  61         DateTime structure.
  62
  63     INPUTS
  64         DateTime - a pointer to an initialized DateTime structure. The
  65                    DateTime structure should be initialized as follows:
  66
  67                 dat_Stamp: The datestamp to convert to ascii
  68
  69                 dat_Format: How to convert the datestamp into
  70                         dat_StrDate. Can be any of the following:
  71
  72                     FORMAT_DOS: AmigaDOS format (dd-mmm-yy). This
  73                         is the default if you specify something other
  74                         than any entry in this list.
  75
  76                     FORMAT_INT: International format (yy-mmm-dd).
  77
  78                     FORMAT_USA: American format (mm-dd-yy).
  79
  80                     FORMAT_CDN: Canadian format (dd-mm-yy).
  81
  82                     FORMAT_DEF default format for locale.
  83
  84
  85                 dat_Flags: Modifies dat_Format. The only flag
  86                         used by this function is DTF_SUBST. If set, then
  87                         a string like "Today" or "Monday" is generated
  88                         instead of the normal format if possible.
  89
  90                 dat_StrDay: Pointer to a buffer to receive the day of
  91                         the week string. (Monday, Tuesday, etc.). If null,
  92                         this string will not be generated.
  93
  94                 dat_StrDate: Pointer to a buffer to receive the date
  95                         string, in the format requested by dat_Format,
  96                         subject to possible modifications by DTF_SUBST. If
  97                         null, this string will not be generated.
  98
  99                 dat_StrTime: Pointer to a buffer to receive the time
 100                         of day string. If NULL, this will not be generated.
 101
 102
 103     RESULT
 104         A zero return indicates that the DateStamp was invalid, and could
 105         not be converted.  Non-zero indicates that the call succeeded.
 106
 107     NOTES
 108
 109     EXAMPLE
 110         See below.
 111
 112     BUGS
 113
 114     SEE ALSO
 115         DateStamp(), StrtoDate()
 116
 117     INTERNALS
 118
 119 *****************************************************************************/
 120 {
 121     AROS_LIBFUNC_INIT
 122
 123     /* Starting days of the months in a leap year. */
 124
 125     STRPTR buf, fstring;
 126     const UBYTE * name;
 127
 128     LONG year, month, days, mins, tick, leap=1;
 129
 130     /* Read time. */
 131     days=datetime->dat_Stamp.ds_Days;
 132     mins=datetime->dat_Stamp.ds_Minute;
 133     tick=datetime->dat_Stamp.ds_Tick;
 134
 135     /*
 136         Check if timestamp is correct. Correct timestamps lie
 137         between the 1.1.1978 0:00:00 and the 11.7.5881588 23:59:59.
 138     */
 139     if(days<0||(ULONG)mins>=24*60||(ULONG)tick>=TICKS_PER_SECOND*60)
 140         return DOSFALSE;
 141
 142     if(datetime->dat_StrDay!=NULL)
 143     {
 144         /* Get weekday name. The 1.1.1978 was a sunday. */
 145         buf=datetime->dat_StrDay;
 146         name=Dos_WeekTable[days%7];
 147         while((*buf++=*name++)!=0)
 148             ;
 149     }
 150
 151     if(datetime->dat_StrDate!=NULL)
 152     {
 153         /*
 154             Calculate year and the days in the year. Use a short method
 155             if the date is between the 1.1.1978 and the 1.1.2100:
 156             Every year even divisible by 4 in this time span is a leap year.
 157             There are 92 normal and 30 leap years there.
 158         */
 159         if(days<92*365+30*366)
 160         {
 161             /*
 162                 1976 was a leap year so use it as a base to divide the days
 163                 into 4-year blocks (each beginning with a leap year).
 164             */
 165             days+=366+365;
 166             year=4*(days/(366+3*365))+1976;
 167             days%=(366+3*365);
 168
 169             /* Now divide the 4-year blocks into single years. */
 170             if (days>=366)
 171             {
 172                 leap=0;
 173                 days--;
 174                 year+=days/365;
 175                 days%=365;
 176             }
 177         }
 178         else
 179         {
 180             /*
 181                 The rule for calendar calculations are:
 182                 1. Every year even divisible by 4 is a leap year.
 183                 2. As an exception from rule 1 every year even divisible by
 184                    100 is not.
 185                 3. Every year even divisible by 400 is a leap year as an
 186                    exception from rule 2.
 187                 So 1996, 2000 and 2004 are leap years - 1900 and 1999 are not.
 188
 189                 Use 2000 as a base to devide the days into 400 year blocks,
 190                 those into 100 year blocks and so on...
 191             */
 192             days-=17*365+5*366;
 193             year=400*(days/(97*366+303*365))+2000;
 194             days%=(97*366+303*365);
 195
 196             if(days>=366)
 197             {
 198                 leap=0;
 199                 days--;
 200                 year+=100*(days/(24*366+76*365));
 201                 days%=(24*366+76*365);
 202
 203                 if(days>=365)
 204                 {
 205                     leap=1;
 206                     days++;
 207                     year+=4*(days/(366+3*365));
 208                     days%=(366+3*365);
 209
 210                     if(days>=366)
 211                     {
 212                         leap=0;
 213                         days--;
 214                         year+=days/365;
 215                         days%=365;
 216                     }
 217                 }
 218             }
 219         }
 220         /*
 221              The starting-day table assumes a leap year - so add one day if
 222              the date is after february 28th and the year is no leap year.
 223         */
 224         if(!leap&&days>=31+28)
 225             days++;
 226
 227         for(month=11;;month--)
 228         {
 229             if(days>=Dos_DayTable[month])
 230             {
 231                 days-=Dos_DayTable[month];
 232                 break;
 233             }
 234         }
 235
 236         /* Remember that 0 means 1.1.1978. */
 237         days++;
 238         month++;
 239
 240         /* Build date string */
 241         buf=datetime->dat_StrDate;
 242
 243         switch (datetime->dat_Format)
 244         {
 245         case FORMAT_INT: fstring="y-m-d"; break;
 246         case FORMAT_USA: fstring="M-d-y"; break;
 247         case FORMAT_CDN: fstring="d-M-y"; break;
 248         case FORMAT_DEF: fstring="d.M.y"; break;
 249         default:         fstring="d-m-y"; break;
 250         }
 251
 252         if (datetime->dat_Flags & DTF_SUBST)
 253         {
 254             struct DateStamp curr;
 255
 256             DateStamp (&curr);
 257
 258             curr.ds_Days -= datetime->dat_Stamp.ds_Days;
 259
 260             if (curr.ds_Days >= -1 && curr.ds_Days <= 7)
 261             {
 262                 fstring = "";
 263
 264                 if (curr.ds_Days <= 1)
 265                     name = Dos_SubstDateTable[curr.ds_Days+1];
 266                 else
 267                     name = Dos_WeekTable[datetime->dat_Stamp.ds_Days%7];
 268
 269                 while ((*buf++ = *name++) != 0);
 270             }
 271         }
 272
 273         if (*fstring)
 274         {
 275             while (*fstring)
 276             {
 277                 switch(*fstring)
 278                 {
 279                 case 'y':
 280 #if (AROS_FLAVOUR & AROS_FLAVOUR_BINCOMPAT)
 281                     *buf++ = year/10%10+'0';
 282                     *buf++ = year%10+'0';
 283 #else
 284                     *buf++ = year/1000%10+'0';
 285                     *buf++ = year/100%10+'0';
 286                     *buf++ = year/10%10+'0';
 287                     *buf++ = year%10+'0';
 288 #endif
 289                     break;
 290                 case 'm':
 291                     name=Dos_MonthTable[month-1];
 292                     while(*name)
 293                         *buf++=*name++;
 294                     break;
 295                 case 'M':
 296                     *buf++=month/10%10+'0';
 297                     *buf++=month%10+'0';
 298                     break;
 299                 case 'd':
 300                     *buf++=days/10%10+'0';
 301                     *buf++=days%10+'0';
 302                     break;
 303                 default:
 304                     *buf++=*fstring;
 305                     break;
 306                 }
 307
 308                 fstring ++;
 309             }
 310
 311             *buf = 0;
 312         }
 313     }
 314
 315     if(datetime->dat_StrTime!=NULL)
 316     {
 317         /* Build time string */
 318         datetime->dat_StrTime[0] = mins/(10*60)+'0';
 319         datetime->dat_StrTime[1] = mins/60%10+'0';
 320         datetime->dat_StrTime[2] = ':';
 321         datetime->dat_StrTime[3] = mins/10%6+'0';
 322         datetime->dat_StrTime[4] = mins%10+'0';
 323         datetime->dat_StrTime[5] = ':';
 324         datetime->dat_StrTime[6] = tick/(10*TICKS_PER_SECOND)+'0';
 325         datetime->dat_StrTime[7] = tick/TICKS_PER_SECOND%10+'0';
 326         datetime->dat_StrTime[8] = 0;
 327     }
 328
 329     /* All done. Return OK. */
 330     return DOSTRUE;
 331     AROS_LIBFUNC_EXIT
 332 } /* DateToStr */
 333
 334 #ifdef TEST
 335
 336 #       include <stdio.h>
 337 #       include <dos/datetime.h>
 338 #       include <proto/dos.h>
 339
 340 int main (int argc, char ** argv)
 341 {
 342     struct DateTime curr;
 343     char day[LEN_DATSTRING];
 344     char time[LEN_DATSTRING];
 345     char date[LEN_DATSTRING];
 346
 347     DateStamp (&curr.dat_Stamp);
 348
 349     curr.dat_Format  = FORMAT_DOS;
 350     curr.dat_Flags   = 0;
 351     curr.dat_StrDay  = day;
 352     curr.dat_StrDate = date;
 353     curr.dat_StrTime = time;
 354
 355     DateToStr (&curr);
 356
 357     printf ("Today is %s, %s. It's %s\n"
 358         , day
 359         , date
 360         , time
 361     );
 362
 363     curr.dat_Format = FORMAT_DEF;
 364
 365     DateToStr (&curr);
 366
 367     printf ("Local date: %s\n", date);
 368
 369     curr.dat_Flags = DTF_SUBST;
 370
 371     DateToStr (&curr);
 372
 373     printf ("Date with DTF_SUBST: %s\n", date);
 374
 375     curr.dat_Stamp.ds_Days ++;
 376
 377     DateToStr (&curr);
 378
 379     printf ("Date +1 with DTF_SUBST: %s\n", date);
 380
 381     curr.dat_Stamp.ds_Days ++;
 382
 383     DateToStr (&curr);
 384
 385     printf ("Date +2 with DTF_SUBST: %s\n", date);
 386
 387     curr.dat_Stamp.ds_Days ++;
 388
 389     DateToStr (&curr);
 390
 391     printf ("Date +3 with DTF_SUBST: %s\n", date);
 392
 393     curr.dat_Stamp.ds_Days -= 4;
 394
 395     DateToStr (&curr);
 396
 397     printf ("Date -1 with DTF_SUBST: %s\n", date);
 398
 399     curr.dat_Stamp.ds_Days --;
 400
 401     DateToStr (&curr);
 402
 403     printf ("Date -2 with DTF_SUBST: %s\n", date);
 404
 405     curr.dat_Stamp.ds_Days --;
 406
 407     DateToStr (&curr);
 408
 409     printf ("Date -3 with DTF_SUBST: %s\n", date);
 410
 411     curr.dat_Stamp.ds_Days   = 0;
 412     curr.dat_Stamp.ds_Minute = 0;
 413     curr.dat_Stamp.ds_Tick   = 0;
 414
 415     DateToStr (&curr);
 416
 417     printf ("First Date: %s, %s. Time: %s\n", day, date, time);
 418
 419     curr.dat_Stamp.ds_Days   = 0;
 420     curr.dat_Stamp.ds_Minute = 1;
 421     curr.dat_Stamp.ds_Tick   = 0;
 422
 423     DateToStr (&curr);
 424
 425     printf ("First Date + 1 Minute: %s, %s. Time: %s\n", day, date, time);
 426
 427     curr.dat_Stamp.ds_Days   = 0;
 428     curr.dat_Stamp.ds_Minute = 0;
 429     curr.dat_Stamp.ds_Tick   = 153;
 430
 431     DateToStr (&curr);
 432
 433     printf ("First Date + 153 Ticks: %s, %s. Time: %s\n", day, date, time);
 434
 435     curr.dat_Stamp.ds_Days   = 1;
 436     curr.dat_Stamp.ds_Minute = 0;
 437     curr.dat_Stamp.ds_Tick   = 0;
 438
 439     DateToStr (&curr);
 440
 441     printf ("First Date: %s, %s. Time: %s\n", day, date, time);
 442
 443     return 0;
 444 } /* main */
 445
 446 #endif /* TEST */