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