rom/dos/datetostr.c

   1 /*
   2     Copyright © 1995-2010, 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     "Future", "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         default:         fstring="d-M-y"; break;
 249         }
 250
 251         if (datetime->dat_Flags & DTF_SUBST)
 252         {
 253             struct DateStamp curr;
 254
 255             DateStamp (&curr);
 256
 257             curr.ds_Days -= datetime->dat_Stamp.ds_Days;
 258
 259             if (curr.ds_Days <= 7)
 260             {
 261                 fstring = "";
 262
 263                 if ((curr.ds_Days <= 1) && (curr.ds_Days >= -1))
 264                     name = Dos_SubstDateTable[curr.ds_Days+2];
 265                 else if (curr.ds_Days < -1)
 266                     name = Dos_SubstDateTable[0];
 267                 else
 268                     name = Dos_WeekTable[datetime->dat_Stamp.ds_Days%7];
 269
 270                 while ((*buf++ = *name++) != 0);
 271             }
 272         }
 273
 274         if (*fstring)
 275         {
 276             while (*fstring)
 277             {
 278                 switch(*fstring)
 279                 {
 280                 case 'y':
 281                     *buf++ = year/10%10+'0';
 282                     *buf++ = year%10+'0';
 283                     break;
 284                 case 'm':
 285                     name=Dos_MonthTable[month-1];
 286                     while(*name)
 287                         *buf++=*name++;
 288                     break;
 289                 case 'M':
 290                     *buf++=month/10%10+'0';
 291                     *buf++=month%10+'0';
 292                     break;
 293                 case 'd':
 294                     *buf++=days/10%10+'0';
 295                     *buf++=days%10+'0';
 296                     break;
 297                 default:
 298                     *buf++=*fstring;
 299                     break;
 300                 }
 301
 302                 fstring ++;
 303             }
 304
 305             *buf = 0;
 306         }
 307     }
 308
 309     if(datetime->dat_StrTime!=NULL)
 310     {
 311         /* Build time string */
 312         datetime->dat_StrTime[0] = mins/(10*60)+'0';
 313         datetime->dat_StrTime[1] = mins/60%10+'0';
 314         datetime->dat_StrTime[2] = ':';
 315         datetime->dat_StrTime[3] = mins/10%6+'0';
 316         datetime->dat_StrTime[4] = mins%10+'0';
 317         datetime->dat_StrTime[5] = ':';
 318         datetime->dat_StrTime[6] = tick/(10*TICKS_PER_SECOND)+'0';
 319         datetime->dat_StrTime[7] = tick/TICKS_PER_SECOND%10+'0';
 320         datetime->dat_StrTime[8] = 0;
 321     }
 322
 323     /* All done. Return OK. */
 324     return DOSTRUE;
 325     AROS_LIBFUNC_EXIT
 326 } /* DateToStr */
 327
 328 #ifdef TEST
 329
 330 #        include <stdio.h>
 331 #        include <dos/datetime.h>
 332 #        include <proto/dos.h>
 333
 334 int main (int argc, char ** argv)
 335 {
 336     struct DateTime curr;
 337     char day[LEN_DATSTRING];
 338     char time[LEN_DATSTRING];
 339     char date[LEN_DATSTRING];
 340
 341     DateStamp (&curr.dat_Stamp);
 342
 343     curr.dat_Format  = FORMAT_DOS;
 344     curr.dat_Flags   = 0;
 345     curr.dat_StrDay  = day;
 346     curr.dat_StrDate = date;
 347     curr.dat_StrTime = time;
 348
 349     DateToStr (&curr);
 350
 351     printf ("Today is %s, %s. It's %s\n"
 352         , day
 353         , date
 354         , time
 355     );
 356
 357     curr.dat_Format = FORMAT_DEF;
 358
 359     DateToStr (&curr);
 360
 361     printf ("Local date: %s\n", date);
 362
 363     curr.dat_Flags = DTF_SUBST;
 364
 365     DateToStr (&curr);
 366
 367     printf ("Date with DTF_SUBST: %s\n", date);
 368
 369     curr.dat_Stamp.ds_Days ++;
 370
 371     DateToStr (&curr);
 372
 373     printf ("Date +1 with DTF_SUBST: %s\n", date);
 374
 375     curr.dat_Stamp.ds_Days ++;
 376
 377     DateToStr (&curr);
 378
 379     printf ("Date +2 with DTF_SUBST: %s\n", date);
 380
 381     curr.dat_Stamp.ds_Days ++;
 382
 383     DateToStr (&curr);
 384
 385     printf ("Date +3 with DTF_SUBST: %s\n", date);
 386
 387     curr.dat_Stamp.ds_Days -= 4;
 388
 389     DateToStr (&curr);
 390
 391     printf ("Date -1 with DTF_SUBST: %s\n", date);
 392
 393     curr.dat_Stamp.ds_Days --;
 394
 395     DateToStr (&curr);
 396
 397     printf ("Date -2 with DTF_SUBST: %s\n", date);
 398
 399     curr.dat_Stamp.ds_Days --;
 400
 401     DateToStr (&curr);
 402
 403     printf ("Date -3 with DTF_SUBST: %s\n", date);
 404
 405     curr.dat_Stamp.ds_Days   = 0;
 406     curr.dat_Stamp.ds_Minute = 0;
 407     curr.dat_Stamp.ds_Tick   = 0;
 408
 409     DateToStr (&curr);
 410
 411     printf ("First Date: %s, %s. Time: %s\n", day, date, time);
 412
 413     curr.dat_Stamp.ds_Days   = 0;
 414     curr.dat_Stamp.ds_Minute = 1;
 415     curr.dat_Stamp.ds_Tick   = 0;
 416
 417     DateToStr (&curr);
 418
 419     printf ("First Date + 1 Minute: %s, %s. Time: %s\n", day, date, time);
 420
 421     curr.dat_Stamp.ds_Days   = 0;
 422     curr.dat_Stamp.ds_Minute = 0;
 423     curr.dat_Stamp.ds_Tick   = 153;
 424
 425     DateToStr (&curr);
 426
 427     printf ("First Date + 153 Ticks: %s, %s. Time: %s\n", day, date, time);
 428
 429     curr.dat_Stamp.ds_Days   = 1;
 430     curr.dat_Stamp.ds_Minute = 0;
 431     curr.dat_Stamp.ds_Tick   = 0;
 432
 433     DateToStr (&curr);
 434
 435     printf ("First Date: %s, %s. Time: %s\n", day, date, time);
 436
 437     return 0;
 438 } /* main */
 439
 440 #endif /* TEST */