lib/adodb/adodb-time.inc.php

   1 <?php
   2 /**
   3  * ADOdb Date Library.
   4  *
   5  * PHP native date functions use integer timestamps for computations.
   6  * Because of this, dates are restricted to the years 1901-2038 on Unix
   7  * and 1970-2038 on Windows due to integer overflow for dates beyond
   8  * those years. This library overcomes these limitations by replacing the
   9  * native function's signed integers (normally 32-bits) with PHP floating
  10  * point numbers (normally 64-bits).
  11  *
  12  * Dates from 100 A.D. to 3000 A.D. and later have been tested.
  13  * The minimum is 100 A.D. as <100 will invoke the 2 => 4 digit year
  14  * conversion. The maximum is billions of years in the future, but this
  15  * is a theoretical limit as the computation of that year would take too
  16  * long with the current implementation of adodb_mktime().
  17  *
  18  * Replaces native functions as follows:
  19  * - getdate()  with  adodb_getdate()
  20  * - date()     with  adodb_date()
  21  * - gmdate()   with  adodb_gmdate()
  22  * - mktime()   with  adodb_mktime()
  23  * - gmmktime() with  adodb_gmmktime()
  24  * - strftime() with  adodb_strftime()
  25  * - strftime() with  adodb_gmstrftime()
  26  *
  27  * The parameters are identical, except that adodb_date() accepts a subset
  28  * of date()'s field formats. Mktime() will convert from local time to GMT,
  29  * and date() will convert from GMT to local time, but daylight savings is
  30  * not handled currently.
  31  *
  32  * To improve performance, the native date functions are used whenever
  33  * possible, the library only switches to PHP code when the dates fall outside
  34  * of the 32-bit signed integer range.
  35  *
  36  * This library is independent of the rest of ADOdb, and can be used
  37  * as standalone code.
  38  *
  39  * GREGORIAN CORRECTION
  40  *
  41  * Pope Gregory shortened October of A.D. 1582 by ten days. Thursday,
  42  * October 4, 1582 (Julian) was followed immediately by Friday, October 15,
  43  * 1582 (Gregorian). We handle this correctly, so:
  44  * adodb_mktime(0, 0, 0, 10, 15, 1582) - adodb_mktime(0, 0, 0, 10, 4, 1582)
  45  * == 24 * 3600 (1 day)
  46  *
  47  * This file is part of ADOdb, a Database Abstraction Layer library for PHP.
  48  *
  49  * @package ADOdb
  50  * @link https://adodb.org Project's web site and documentation
  51  * @link https://github.com/ADOdb/ADOdb Source code and issue tracker
  52  *
  53  * The ADOdb Library is dual-licensed, released under both the BSD 3-Clause
  54  * and the GNU Lesser General Public Licence (LGPL) v2.1 or, at your option,
  55  * any later version. This means you can use it in proprietary products.
  56  * See the LICENSE.md file distributed with this source code for details.
  57  * @license BSD-3-Clause
  58  * @license LGPL-2.1-or-later
  59  *
  60  * @copyright 2003-2013 John Lim
  61  * @copyright 2014 Damien Regad, Mark Newnham and the ADOdb community
  62  */
  63
  64 /*
  65 =============================================================================
  66
  67 FUNCTION DESCRIPTIONS
  68
  69 ** FUNCTION adodb_time()
  70
  71 Returns the current time measured in the number of seconds since the Unix Epoch (January 1 1970 00:00:00 GMT) as an unsigned integer.
  72
  73 ** FUNCTION adodb_getdate($date=false)
  74
  75 Returns an array containing date information, as getdate(), but supports
  76 dates greater than 1901 to 2038. The local date/time format is derived from a
  77 heuristic the first time adodb_getdate is called.
  78
  79
  80 ** FUNCTION adodb_date($fmt, $timestamp = false)
  81
  82 Convert a timestamp to a formatted local date. If $timestamp is not defined, the
  83 current timestamp is used. Unlike the function date(), it supports dates
  84 outside the 1901 to 2038 range.
  85
  86 The format fields that adodb_date supports:
  87
  88 <pre>
  89         a - "am" or "pm"
  90         A - "AM" or "PM"
  91         d - day of the month, 2 digits with leading zeros; i.e. "01" to "31"
  92         D - day of the week, textual, 3 letters; e.g. "Fri"
  93         F - month, textual, long; e.g. "January"
  94         g - hour, 12-hour format without leading zeros; i.e. "1" to "12"
  95         G - hour, 24-hour format without leading zeros; i.e. "0" to "23"
  96         h - hour, 12-hour format; i.e. "01" to "12"
  97         H - hour, 24-hour format; i.e. "00" to "23"
  98         i - minutes; i.e. "00" to "59"
  99         j - day of the month without leading zeros; i.e. "1" to "31"
 100         l (lowercase 'L') - day of the week, textual, long; e.g. "Friday"
 101         L - boolean for whether it is a leap year; i.e. "0" or "1"
 102         m - month; i.e. "01" to "12"
 103         M - month, textual, 3 letters; e.g. "Jan"
 104         n - month without leading zeros; i.e. "1" to "12"
 105         O - Difference to Greenwich time in hours; e.g. "+0200"
 106         Q - Quarter, as in 1, 2, 3, 4
 107         r - RFC 2822 formatted date; e.g. "Thu, 21 Dec 2000 16:01:07 +0200"
 108         s - seconds; i.e. "00" to "59"
 109         S - English ordinal suffix for the day of the month, 2 characters;
 110                                 i.e. "st", "nd", "rd" or "th"
 111         t - number of days in the given month; i.e. "28" to "31"
 112         T - Timezone setting of this machine; e.g. "EST" or "MDT"
 113         U - seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)
 114         w - day of the week, numeric, i.e. "0" (Sunday) to "6" (Saturday)
 115         Y - year, 4 digits; e.g. "1999"
 116         y - year, 2 digits; e.g. "99"
 117         z - day of the year; i.e. "0" to "365"
 118         Z - timezone offset in seconds (i.e. "-43200" to "43200").
 119                                 The offset for timezones west of UTC is always negative,
 120                                 and for those east of UTC is always positive.
 121 </pre>
 122
 123 Unsupported:
 124 <pre>
 125         B - Swatch Internet time
 126         I (capital i) - "1" if Daylight Savings Time, "0" otherwise.
 127         W - ISO-8601 week number of year, weeks starting on Monday
 128
 129 </pre>
 130
 131
 132 ** FUNCTION adodb_date2($fmt, $isoDateString = false)
 133 Same as adodb_date, but 2nd parameter accepts iso date, eg.
 134
 135   adodb_date2('d-M-Y H:i','2003-12-25 13:01:34');
 136
 137
 138 ** FUNCTION adodb_gmdate($fmt, $timestamp = false)
 139
 140 Convert a timestamp to a formatted GMT date. If $timestamp is not defined, the
 141 current timestamp is used. Unlike the function date(), it supports dates
 142 outside the 1901 to 2038 range.
 143
 144
 145 ** FUNCTION adodb_mktime($hr, $min, $sec[, $month, $day, $year])
 146
 147 Converts a local date to a unix timestamp.  Unlike the function mktime(), it supports
 148 dates outside the 1901 to 2038 range. All parameters are optional.
 149
 150
 151 ** FUNCTION adodb_gmmktime($hr, $min, $sec [, $month, $day, $year])
 152
 153 Converts a gmt date to a unix timestamp.  Unlike the function gmmktime(), it supports
 154 dates outside the 1901 to 2038 range. Differs from gmmktime() in that all parameters
 155 are currently compulsory.
 156
 157 ** FUNCTION adodb_gmstrftime($fmt, $timestamp = false)
 158 Convert a timestamp to a formatted GMT date.
 159
 160 ** FUNCTION adodb_strftime($fmt, $timestamp = false)
 161
 162 Convert a timestamp to a formatted local date. Internally converts $fmt into
 163 adodb_date format, then echo result.
 164
 165 For best results, you can define the local date format yourself. Define a global
 166 variable $ADODB_DATE_LOCALE which is an array, 1st element is date format using
 167 adodb_date syntax, and 2nd element is the time format, also in adodb_date syntax.
 168
 169     eg. $ADODB_DATE_LOCALE = array('d/m/Y','H:i:s');
 170
 171         Supported format codes:
 172
 173 <pre>
 174         %a - abbreviated weekday name according to the current locale
 175         %A - full weekday name according to the current locale
 176         %b - abbreviated month name according to the current locale
 177         %B - full month name according to the current locale
 178         %c - preferred date and time representation for the current locale
 179         %d - day of the month as a decimal number (range 01 to 31)
 180         %D - same as %m/%d/%y
 181         %e - day of the month as a decimal number, a single digit is preceded by a space (range ' 1' to '31')
 182         %h - same as %b
 183         %H - hour as a decimal number using a 24-hour clock (range 00 to 23)
 184         %I - hour as a decimal number using a 12-hour clock (range 01 to 12)
 185         %m - month as a decimal number (range 01 to 12)
 186         %M - minute as a decimal number
 187         %n - newline character
 188         %p - either `am' or `pm' according to the given time value, or the corresponding strings for the current locale
 189         %r - time in a.m. and p.m. notation
 190         %R - time in 24 hour notation
 191         %S - second as a decimal number
 192         %t - tab character
 193         %T - current time, equal to %H:%M:%S
 194         %x - preferred date representation for the current locale without the time
 195         %X - preferred time representation for the current locale without the date
 196         %y - year as a decimal number without a century (range 00 to 99)
 197         %Y - year as a decimal number including the century
 198         %Z - time zone or name or abbreviation
 199         %% - a literal `%' character
 200 </pre>
 201
 202         Unsupported codes:
 203 <pre>
 204         %C - century number (the year divided by 100 and truncated to an integer, range 00 to 99)
 205         %g - like %G, but without the century.
 206         %G - The 4-digit year corresponding to the ISO week number (see %V).
 207              This has the same format and value as %Y, except that if the ISO week number belongs
 208                  to the previous or next year, that year is used instead.
 209         %j - day of the year as a decimal number (range 001 to 366)
 210         %u - weekday as a decimal number [1,7], with 1 representing Monday
 211         %U - week number of the current year as a decimal number, starting
 212             with the first Sunday as the first day of the first week
 213         %V - The ISO 8601:1988 week number of the current year as a decimal number,
 214              range 01 to 53, where week 1 is the first week that has at least 4 days in the
 215                  current year, and with Monday as the first day of the week. (Use %G or %g for
 216                  the year component that corresponds to the week number for the specified timestamp.)
 217         %w - day of the week as a decimal, Sunday being 0
 218         %W - week number of the current year as a decimal number, starting with the
 219              first Monday as the first day of the first week
 220 </pre>
 221
 222 =============================================================================
 223
 224 NOTES
 225
 226 Useful url for generating test timestamps:
 227         http://www.4webhelp.net/us/timestamp.php
 228
 229 Possible future optimizations include
 230
 231 a. Using an algorithm similar to Plauger's in "The Standard C Library"
 232 (page 428, xttotm.c _Ttotm() function). Plauger's algorithm will not
 233 work outside 32-bit signed range, so i decided not to implement it.
 234
 235 b. Implement daylight savings, which looks awfully complicated, see
 236         http://webexhibits.org/daylightsaving/
 237
 238
 239 CHANGELOG
 240 - 16 Jan 2011 0.36
 241 Added adodb_time() which returns current time. If > 2038, will return as float
 242
 243 - 7 Feb 2011 0.35
 244 Changed adodb_date to be symmetric with adodb_mktime. See $jan1_71. fix for bc.
 245
 246 - 13 July 2010 0.34
 247 Changed adodb_get_gm_diff to use DateTimeZone().
 248
 249 - 11 Feb 2008 0.33
 250 * Bug in 0.32 fix for hour handling. Fixed.
 251
 252 - 1 Feb 2008 0.32
 253 * Now adodb_mktime(0,0,0,12+$m,20,2040) works properly.
 254
 255 - 10 Jan 2008 0.31
 256 * Now adodb_mktime(0,0,0,24,1,2037) works correctly.
 257
 258 - 15 July 2007 0.30
 259 Added PHP 5.2.0 compatibility fixes.
 260  * gmtime behaviour for 1970 has changed. We use the actual date if it is between 1970 to 2038 to get the
 261  * timezone, otherwise we use the current year as the baseline to retrieve the timezone.
 262  * Also the timezone's in php 5.2.* support historical data better, eg. if timezone today was +8, but
 263    in 1970 it was +7:30, then php 5.2 return +7:30, while this library will use +8.
 264  *
 265
 266 - 19 March 2006 0.24
 267 Changed strftime() locale detection, because some locales prepend the day of week to the date when %c is used.
 268
 269 - 10 Feb 2006 0.23
 270 PHP5 compat: when we detect PHP5, the RFC2822 format for gmt 0000hrs is changed from -0000 to +0000.
 271         In PHP4, we will still use -0000 for 100% compat with PHP4.
 272
 273 - 08 Sept 2005 0.22
 274 In adodb_date2(), $is_gmt not supported properly. Fixed.
 275
 276 - 18 July  2005 0.21
 277 In PHP 4.3.11, the 'r' format has changed. Leading 0 in day is added. Changed for compat.
 278 Added support for negative months in adodb_mktime().
 279
 280 - 24 Feb 2005 0.20
 281 Added limited strftime/gmstrftime support. x10 improvement in performance of adodb_date().
 282
 283 - 21 Dec 2004 0.17
 284 In adodb_getdate(), the timestamp was accidentally converted to gmt when $is_gmt is false.
 285 Also adodb_mktime(0,0,0) did not work properly. Both fixed thx Mauro.
 286
 287 - 17 Nov 2004 0.16
 288 Removed intval typecast in adodb_mktime() for secs, allowing:
 289          adodb_mktime(0,0,0 + 2236672153,1,1,1934);
 290 Suggested by Ryan.
 291
 292 - 18 July 2004 0.15
 293 All params in adodb_mktime were formerly compulsory. Now only the hour, min, secs is compulsory.
 294 This brings it more in line with mktime (still not identical).
 295
 296 - 23 June 2004 0.14
 297
 298 Allow you to define your own daylights savings function, adodb_daylight_sv.
 299 If the function is defined (somewhere in an include), then you can correct for daylights savings.
 300
 301 In this example, we apply daylights savings in June or July, adding one hour. This is extremely
 302 unrealistic as it does not take into account time-zone, geographic location, current year.
 303
 304 function adodb_daylight_sv(&$arr, $is_gmt)
 305 {
 306         if ($is_gmt) return;
 307         $m = $arr['mon'];
 308         if ($m == 6 || $m == 7) $arr['hours'] += 1;
 309 }
 310
 311 This is only called by adodb_date() and not by adodb_mktime().
 312
 313 The format of $arr is
 314 Array (
 315    [seconds] => 0
 316    [minutes] => 0
 317    [hours] => 0
 318    [mday] => 1      # day of month, eg 1st day of the month
 319    [mon] => 2       # month (eg. Feb)
 320    [year] => 2102
 321    [yday] => 31     # days in current year
 322    [leap] =>        # true if leap year
 323    [ndays] => 28    # no of days in current month
 324    )
 325
 326
 327 - 28 Apr 2004 0.13
 328 Fixed adodb_date to properly support $is_gmt. Thx to Dimitar Angelov.
 329
 330 - 20 Mar 2004 0.12
 331 Fixed month calculation error in adodb_date. 2102-June-01 appeared as 2102-May-32.
 332
 333 - 26 Oct 2003 0.11
 334 Because of daylight savings problems (some systems apply daylight savings to
 335 January!!!), changed adodb_get_gmt_diff() to ignore daylight savings.
 336
 337 - 9 Aug 2003 0.10
 338 Fixed bug with dates after 2038.
 339 See PHPLens Issue No: 6980
 340
 341 - 1 July 2003 0.09
 342 Added support for Q (Quarter).
 343 Added adodb_date2(), which accepts ISO date in 2nd param
 344
 345 - 3 March 2003 0.08
 346 Added support for 'S' adodb_date() format char. Added constant ADODB_ALLOW_NEGATIVE_TS
 347 if you want PHP to handle negative timestamps between 1901 to 1969.
 348
 349 - 27 Feb 2003 0.07
 350 All negative numbers handled by adodb now because of RH 7.3+ problems.
 351 See http://bugs.php.net/bug.php?id=20048&edit=2
 352
 353 - 4 Feb 2003 0.06
 354 Fixed a typo, 1852 changed to 1582! This means that pre-1852 dates
 355 are now correctly handled.
 356
 357 - 29 Jan 2003 0.05
 358
 359 Leap year checking differs under Julian calendar (pre 1582). Also
 360 leap year code optimized by checking for most common case first.
 361
 362 We also handle month overflow correctly in mktime (eg month set to 13).
 363
 364 Day overflow for less than one month's days is supported.
 365
 366 - 28 Jan 2003 0.04
 367
 368 Gregorian correction handled. In PHP5, we might throw an error if
 369 mktime uses invalid dates around 5-14 Oct 1582. Released with ADOdb 3.10.
 370 Added limbo 5-14 Oct 1582 check, when we set to 15 Oct 1582.
 371
 372 - 27 Jan 2003 0.03
 373
 374 Fixed some more month problems due to gmt issues. Added constant ADODB_DATE_VERSION.
 375 Fixed calculation of days since start of year for <1970.
 376
 377 - 27 Jan 2003 0.02
 378
 379 Changed _adodb_getdate() to inline leap year checking for better performance.
 380 Fixed problem with time-zones west of GMT +0000.
 381
 382 - 24 Jan 2003 0.01
 383
 384 First implementation.
 385 */
 386
 387
 388 /* Initialization */
 389
 390 /*
 391         Version Number
 392 */
 393 define('ADODB_DATE_VERSION',0.35);
 394
 395 /*
 396         This code was originally for windows. But apparently this problem happens
 397         also with Linux, RH 7.3 and later!
 398
 399         glibc-2.2.5-34 and greater has been changed to return -1 for dates <
 400         1970.  This used to work.  The problem exists with RedHat 7.3 and 8.0
 401         echo (mktime(0, 0, 0, 1, 1, 1960));  // prints -1
 402
 403         References:
 404          http://bugs.php.net/bug.php?id=20048&edit=2
 405          http://lists.debian.org/debian-glibc/2002/debian-glibc-200205/msg00010.html
 406 */
 407
 408 if (!defined('ADODB_ALLOW_NEGATIVE_TS')) define('ADODB_NO_NEGATIVE_TS',1);
 409
 410 if (!DEFINED('ADODB_FUTURE_DATE_CUTOFF_YEARS'))
 411         DEFINE('ADODB_FUTURE_DATE_CUTOFF_YEARS',200);
 412
 413 function adodb_date_test_date($y1,$m,$d=13)
 414 {
 415         $h = round(rand()% 24);
 416         $t = adodb_mktime($h,0,0,$m,$d,$y1);
 417         $rez = adodb_date('Y-n-j H:i:s',$t);
 418         if ($h == 0) $h = '00';
 419         else if ($h < 10) $h = '0'.$h;
 420         if ("$y1-$m-$d $h:00:00" != $rez) {
 421                 print "<b>$y1 error, expected=$y1-$m-$d $h:00:00, adodb=$rez</b><br>";
 422                 return false;
 423         }
 424         return true;
 425 }
 426
 427 function adodb_date_test_strftime($fmt)
 428 {
 429         $s1 = strftime($fmt);
 430         $s2 = adodb_strftime($fmt);
 431
 432         if ($s1 == $s2) return true;
 433
 434         echo "error for $fmt,  strftime=$s1, adodb=$s2<br>";
 435         return false;
 436 }
 437
 438 /**
 439          Test Suite
 440 */
 441 function adodb_date_test()
 442 {
 443
 444         for ($m=-24; $m<=24; $m++)
 445                 echo "$m :",adodb_date('d-m-Y',adodb_mktime(0,0,0,1+$m,20,2040)),"<br>";
 446
 447         error_reporting(E_ALL);
 448         print "<h4>Testing adodb_date and adodb_mktime. version=".ADODB_DATE_VERSION.' PHP='.PHP_VERSION."</h4>";
 449         @set_time_limit(0);
 450         $fail = false;
 451
 452         // This flag disables calling of PHP native functions, so we can properly test the code
 453         if (!defined('ADODB_TEST_DATES')) define('ADODB_TEST_DATES',1);
 454
 455         $t = time();
 456
 457
 458         $fmt = 'Y-m-d H:i:s';
 459         echo '<pre>';
 460         echo 'adodb: ',adodb_date($fmt,$t),'<br>';
 461         echo 'php  : ',date($fmt,$t),'<br>';
 462         echo '</pre>';
 463
 464         adodb_date_test_strftime('%Y %m %x %X');
 465         adodb_date_test_strftime("%A %d %B %Y");
 466         adodb_date_test_strftime("%H %M S");
 467
 468         $t = adodb_mktime(0,0,0);
 469         if (!(adodb_date('Y-m-d') == date('Y-m-d'))) print 'Error in '.adodb_mktime(0,0,0).'<br>';
 470
 471         $t = adodb_mktime(0,0,0,6,1,2102);
 472         if (!(adodb_date('Y-m-d',$t) == '2102-06-01')) print 'Error in '.adodb_date('Y-m-d',$t).'<br>';
 473
 474         $t = adodb_mktime(0,0,0,2,1,2102);
 475         if (!(adodb_date('Y-m-d',$t) == '2102-02-01')) print 'Error in '.adodb_date('Y-m-d',$t).'<br>';
 476
 477
 478         print "<p>Testing gregorian <=> julian conversion<p>";
 479         $t = adodb_mktime(0,0,0,10,11,1492);
 480         //http://www.holidayorigins.com/html/columbus_day.html - Friday check
 481         if (!(adodb_date('D Y-m-d',$t) == 'Fri 1492-10-11')) print 'Error in Columbus landing<br>';
 482
 483         $t = adodb_mktime(0,0,0,2,29,1500);
 484         if (!(adodb_date('Y-m-d',$t) == '1500-02-29')) print 'Error in julian leap years<br>';
 485
 486         $t = adodb_mktime(0,0,0,2,29,1700);
 487         if (!(adodb_date('Y-m-d',$t) == '1700-03-01')) print 'Error in gregorian leap years<br>';
 488
 489         print  adodb_mktime(0,0,0,10,4,1582).' ';
 490         print adodb_mktime(0,0,0,10,15,1582);
 491         $diff = (adodb_mktime(0,0,0,10,15,1582) - adodb_mktime(0,0,0,10,4,1582));
 492         if ($diff != 3600*24) print " <b>Error in gregorian correction = ".($diff/3600/24)." days </b><br>";
 493
 494         print " 15 Oct 1582, Fri=".(adodb_dow(1582,10,15) == 5 ? 'Fri' : '<b>Error</b>')."<br>";
 495         print " 4 Oct 1582, Thu=".(adodb_dow(1582,10,4) == 4 ? 'Thu' : '<b>Error</b>')."<br>";
 496
 497         print "<p>Testing overflow<p>";
 498
 499         $t = adodb_mktime(0,0,0,3,33,1965);
 500         if (!(adodb_date('Y-m-d',$t) == '1965-04-02')) print 'Error in day overflow 1 <br>';
 501         $t = adodb_mktime(0,0,0,4,33,1971);
 502         if (!(adodb_date('Y-m-d',$t) == '1971-05-03')) print 'Error in day overflow 2 <br>';
 503         $t = adodb_mktime(0,0,0,1,60,1965);
 504         if (!(adodb_date('Y-m-d',$t) == '1965-03-01')) print 'Error in day overflow 3 '.adodb_date('Y-m-d',$t).' <br>';
 505         $t = adodb_mktime(0,0,0,12,32,1965);
 506         if (!(adodb_date('Y-m-d',$t) == '1966-01-01')) print 'Error in day overflow 4 '.adodb_date('Y-m-d',$t).' <br>';
 507         $t = adodb_mktime(0,0,0,12,63,1965);
 508         if (!(adodb_date('Y-m-d',$t) == '1966-02-01')) print 'Error in day overflow 5 '.adodb_date('Y-m-d',$t).' <br>';
 509         $t = adodb_mktime(0,0,0,13,3,1965);
 510         if (!(adodb_date('Y-m-d',$t) == '1966-01-03')) print 'Error in mth overflow 1 <br>';
 511
 512         print "Testing 2-digit => 4-digit year conversion<p>";
 513         if (adodb_year_digit_check(00) != 2000) print "Err 2-digit 2000<br>";
 514         if (adodb_year_digit_check(10) != 2010) print "Err 2-digit 2010<br>";
 515         if (adodb_year_digit_check(20) != 2020) print "Err 2-digit 2020<br>";
 516         if (adodb_year_digit_check(30) != 2030) print "Err 2-digit 2030<br>";
 517         if (adodb_year_digit_check(40) != 1940) print "Err 2-digit 1940<br>";
 518         if (adodb_year_digit_check(50) != 1950) print "Err 2-digit 1950<br>";
 519         if (adodb_year_digit_check(90) != 1990) print "Err 2-digit 1990<br>";
 520
 521         // Test string formatting
 522         print "<p>Testing date formatting</p>";
 523
 524         $fmt = '\d\a\t\e T Y-m-d H:i:s a A d D F g G h H i j l L m M n O \R\F\C2822 r s t U w y Y z Z 2003';
 525         $s1 = date($fmt,0);
 526         $s2 = adodb_date($fmt,0);
 527         if ($s1 != $s2) {
 528                 print " date() 0 failed<br>$s1<br>$s2<br>";
 529         }
 530         flush();
 531         for ($i=100; --$i > 0; ) {
 532
 533                 $ts = 3600.0*((rand()%60000)+(rand()%60000))+(rand()%60000);
 534                 $s1 = date($fmt,$ts);
 535                 $s2 = adodb_date($fmt,$ts);
 536                 //print "$s1 <br>$s2 <p>";
 537                 $pos = strcmp($s1,$s2);
 538
 539                 if (($s1) != ($s2)) {
 540                         for ($j=0,$k=strlen($s1); $j < $k; $j++) {
 541                                 if ($s1[$j] != $s2[$j]) {
 542                                         print substr($s1,$j).' ';
 543                                         break;
 544                                 }
 545                         }
 546                         print "<b>Error date(): $ts<br><pre>
 547 &nbsp; \"$s1\" (date len=".strlen($s1).")
 548 &nbsp; \"$s2\" (adodb_date len=".strlen($s2).")</b></pre><br>";
 549                         $fail = true;
 550                 }
 551
 552                 $a1 = getdate($ts);
 553                 $a2 = adodb_getdate($ts);
 554                 $rez = array_diff($a1,$a2);
 555                 if (sizeof($rez)>0) {
 556                         print "<b>Error getdate() $ts</b><br>";
 557                                 print_r($a1);
 558                         print "<br>";
 559                                 print_r($a2);
 560                         print "<p>";
 561                         $fail = true;
 562                 }
 563         }
 564
 565         // Test generation of dates outside 1901-2038
 566         print "<p>Testing random dates between 100 and 4000</p>";
 567         adodb_date_test_date(100,1);
 568         for ($i=100; --$i >= 0;) {
 569                 $y1 = 100+rand(0,1970-100);
 570                 $m = rand(1,12);
 571                 adodb_date_test_date($y1,$m);
 572
 573                 $y1 = 3000-rand(0,3000-1970);
 574                 adodb_date_test_date($y1,$m);
 575         }
 576         print '<p>';
 577         $start = 1960+rand(0,10);
 578         $yrs = 12;
 579         $i = 365.25*86400*($start-1970);
 580         $offset = 36000+rand(10000,60000);
 581         $max = 365*$yrs*86400;
 582         $lastyear = 0;
 583
 584         // we generate a timestamp, convert it to a date, and convert it back to a timestamp
 585         // and check if the roundtrip broke the original timestamp value.
 586         print "Testing $start to ".($start+$yrs).", or $max seconds, offset=$offset: ";
 587         $cnt = 0;
 588         for ($max += $i; $i < $max; $i += $offset) {
 589                 $ret = adodb_date('m,d,Y,H,i,s',$i);
 590                 $arr = explode(',',$ret);
 591                 if ($lastyear != $arr[2]) {
 592                         $lastyear = $arr[2];
 593                         print " $lastyear ";
 594                         flush();
 595                 }
 596                 $newi = adodb_mktime($arr[3],$arr[4],$arr[5],$arr[0],$arr[1],$arr[2]);
 597                 if ($i != $newi) {
 598                         print "Error at $i, adodb_mktime returned $newi ($ret)";
 599                         $fail = true;
 600                         break;
 601                 }
 602                 $cnt += 1;
 603         }
 604         echo "Tested $cnt dates<br>";
 605         if (!$fail) print "<p>Passed !</p>";
 606         else print "<p><b>Failed</b> :-(</p>";
 607 }
 608
 609 function adodb_time()
 610 {
 611         $d = new DateTime();
 612         return $d->format('U');
 613 }
 614
 615 /**
 616         Returns day of week, 0 = Sunday,... 6=Saturday.
 617         Algorithm from PEAR::Date_Calc
 618 */
 619 function adodb_dow($year, $month, $day)
 620 {
 621 /*
 622 Pope Gregory removed 10 days - October 5 to October 14 - from the year 1582 and
 623 proclaimed that from that time onwards 3 days would be dropped from the calendar
 624 every 400 years.
 625
 626 Thursday, October 4, 1582 (Julian) was followed immediately by Friday, October 15, 1582 (Gregorian).
 627 */
 628         if ($year <= 1582) {
 629                 if ($year < 1582 ||
 630                         ($year == 1582 && ($month < 10 || ($month == 10 && $day < 15)))) $greg_correction = 3;
 631                  else
 632                         $greg_correction = 0;
 633         } else
 634                 $greg_correction = 0;
 635
 636         if($month > 2)
 637             $month -= 2;
 638         else {
 639             $month += 10;
 640             $year--;
 641         }
 642
 643         $day =  floor((13 * $month - 1) / 5) +
 644                 $day + ($year % 100) +
 645                 floor(($year % 100) / 4) +
 646                 floor(($year / 100) / 4) - 2 *
 647                 floor($year / 100) + 77 + $greg_correction;
 648
 649         return $day - 7 * floor($day / 7);
 650 }
 651
 652
 653 /**
 654  Checks for leap year, returns true if it is. No 2-digit year check. Also
 655  handles julian calendar correctly.
 656 */
 657 function _adodb_is_leap_year($year)
 658 {
 659         if ($year % 4 != 0) return false;
 660
 661         if ($year % 400 == 0) {
 662                 return true;
 663         // if gregorian calendar (>1582), century not-divisible by 400 is not leap
 664         } else if ($year > 1582 && $year % 100 == 0 ) {
 665                 return false;
 666         }
 667
 668         return true;
 669 }
 670
 671
 672 /**
 673  checks for leap year, returns true if it is. Has 2-digit year check
 674 */
 675 function adodb_is_leap_year($year)
 676 {
 677         return  _adodb_is_leap_year(adodb_year_digit_check($year));
 678 }
 679
 680 /**
 681         Fix 2-digit years. Works for any century.
 682         Assumes that if 2-digit is more than 30 years in future, then previous century.
 683 */
 684 function adodb_year_digit_check($y)
 685 {
 686         if ($y < 100) {
 687
 688                 $yr = (integer) date("Y");
 689                 $century = (integer) ($yr /100);
 690
 691                 if ($yr%100 > 50) {
 692                         $c1 = $century + 1;
 693                         $c0 = $century;
 694                 } else {
 695                         $c1 = $century;
 696                         $c0 = $century - 1;
 697                 }
 698                 $c1 *= 100;
 699                 // if 2-digit year is less than 30 years in future, set it to this century
 700                 // otherwise if more than 30 years in future, then we set 2-digit year to the prev century.
 701                 if (($y + $c1) < $yr+30) $y = $y + $c1;
 702                 else $y = $y + $c0*100;
 703         }
 704         return $y;
 705 }
 706
 707 function adodb_get_gmt_diff_ts($ts)
 708 {
 709         if (0 <= $ts && $ts <= 0x7FFFFFFF) { // check if number in 32-bit signed range) {
 710                 $arr = getdate($ts);
 711                 $y = $arr['year'];
 712                 $m = $arr['mon'];
 713                 $d = $arr['mday'];
 714                 return adodb_get_gmt_diff($y,$m,$d);
 715         } else {
 716                 return adodb_get_gmt_diff(false,false,false);
 717         }
 718
 719 }
 720
 721 /**
 722  get local time zone offset from GMT. Does not handle historical timezones before 1970.
 723 */
 724 function adodb_get_gmt_diff($y,$m,$d)
 725 {
 726         static $TZ,$tzo;
 727
 728         if (!defined('ADODB_TEST_DATES')) $y = false;
 729         else if ($y < 1970 || $y >= 2038) $y = false;
 730
 731         if ($y !== false) {
 732                 $dt = new DateTime();
 733                 $dt->setISODate($y,$m,$d);
 734                 if (empty($tzo)) {
 735                         $tzo = new DateTimeZone(date_default_timezone_get());
 736                 #       $tzt = timezone_transitions_get( $tzo );
 737                 }
 738                 return -$tzo->getOffset($dt);
 739         } else {
 740                 if (isset($TZ)) return $TZ;
 741                 $y = date('Y');
 742                 /*
 743                 if (function_exists('date_default_timezone_get') && function_exists('timezone_offset_get')) {
 744                         $tzonename = date_default_timezone_get();
 745                         if ($tzonename) {
 746                                 $tobj = new DateTimeZone($tzonename);
 747                                 $TZ = -timezone_offset_get($tobj,new DateTime("now",$tzo));
 748                         }
 749                 }
 750                 */
 751                 if (empty($TZ)) $TZ = mktime(0,0,0,12,2,$y) - gmmktime(0,0,0,12,2,$y);
 752         }
 753         return $TZ;
 754 }
 755
 756 /**
 757         Returns an array with date info.
 758 */
 759 function adodb_getdate($d=false,$fast=false)
 760 {
 761         if ($d === false) return getdate();
 762         if (!defined('ADODB_TEST_DATES')) {
 763                 if ((abs($d) <= 0x7FFFFFFF)) { // check if number in 32-bit signed range
 764                         if (!defined('ADODB_NO_NEGATIVE_TS') || $d >= 0) // if windows, must be +ve integer
 765                                 return @getdate($d);
 766                 }
 767         }
 768         return _adodb_getdate($d);
 769 }
 770
 771 /*
 772 // generate $YRS table for _adodb_getdate()
 773 function adodb_date_gentable($out=true)
 774 {
 775
 776         for ($i=1970; $i >= 1600; $i-=10) {
 777                 $s = adodb_gmmktime(0,0,0,1,1,$i);
 778                 echo "$i => $s,<br>";
 779         }
 780 }
 781 adodb_date_gentable();
 782
 783 for ($i=1970; $i > 1500; $i--) {
 784
 785 echo "<hr />$i ";
 786         adodb_date_test_date($i,1,1);
 787 }
 788
 789 */
 790
 791
 792 $_month_table_normal = array("",31,28,31,30,31,30,31,31,30,31,30,31);
 793 $_month_table_leaf = array("",31,29,31,30,31,30,31,31,30,31,30,31);
 794
 795 function adodb_validdate($y,$m,$d)
 796 {
 797 global $_month_table_normal,$_month_table_leaf;
 798
 799         if (_adodb_is_leap_year($y)) $marr = $_month_table_leaf;
 800         else $marr = $_month_table_normal;
 801
 802         if ($m > 12 || $m < 1) return false;
 803
 804         if ($d > 31 || $d < 1) return false;
 805
 806         if ($marr[$m] < $d) return false;
 807
 808         if ($y < 1000 || $y > 3000) return false;
 809
 810         return true;
 811 }
 812
 813 /**
 814         Low-level function that returns the getdate() array. We have a special
 815         $fast flag, which if set to true, will return fewer array values,
 816         and is much faster as it does not calculate dow, etc.
 817 */
 818 function _adodb_getdate($origd=false,$fast=false,$is_gmt=false)
 819 {
 820 static $YRS;
 821 global $_month_table_normal,$_month_table_leaf, $_adodb_last_date_call_failed;
 822
 823         $_adodb_last_date_call_failed = false;
 824
 825         $d =  $origd - ($is_gmt ? 0 : adodb_get_gmt_diff_ts($origd));
 826         $_day_power = 86400;
 827         $_hour_power = 3600;
 828         $_min_power = 60;
 829
 830         $cutoffDate = time() + (60 * 60 * 24 * 365 * ADODB_FUTURE_DATE_CUTOFF_YEARS);
 831
 832         if ($d > $cutoffDate)
 833         {
 834                 $d = $cutoffDate;
 835                 $_adodb_last_date_call_failed = true;
 836         }
 837
 838         if ($d < -12219321600) $d -= 86400*10; // if 15 Oct 1582 or earlier, gregorian correction
 839
 840         $_month_table_normal = array("",31,28,31,30,31,30,31,31,30,31,30,31);
 841         $_month_table_leaf = array("",31,29,31,30,31,30,31,31,30,31,30,31);
 842
 843         $d366 = $_day_power * 366;
 844         $d365 = $_day_power * 365;
 845
 846         if ($d < 0) {
 847
 848                 if (empty($YRS)) $YRS = array(
 849                         1970 => 0,
 850                         1960 => -315619200,
 851                         1950 => -631152000,
 852                         1940 => -946771200,
 853                         1930 => -1262304000,
 854                         1920 => -1577923200,
 855                         1910 => -1893456000,
 856                         1900 => -2208988800,
 857                         1890 => -2524521600,
 858                         1880 => -2840140800,
 859                         1870 => -3155673600,
 860                         1860 => -3471292800,
 861                         1850 => -3786825600,
 862                         1840 => -4102444800,
 863                         1830 => -4417977600,
 864                         1820 => -4733596800,
 865                         1810 => -5049129600,
 866                         1800 => -5364662400,
 867                         1790 => -5680195200,
 868                         1780 => -5995814400,
 869                         1770 => -6311347200,
 870                         1760 => -6626966400,
 871                         1750 => -6942499200,
 872                         1740 => -7258118400,
 873                         1730 => -7573651200,
 874                         1720 => -7889270400,
 875                         1710 => -8204803200,
 876                         1700 => -8520336000,
 877                         1690 => -8835868800,
 878                         1680 => -9151488000,
 879                         1670 => -9467020800,
 880                         1660 => -9782640000,
 881                         1650 => -10098172800,
 882                         1640 => -10413792000,
 883                         1630 => -10729324800,
 884                         1620 => -11044944000,
 885                         1610 => -11360476800,
 886                         1600 => -11676096000);
 887
 888                 if ($is_gmt) $origd = $d;
 889                 // The valid range of a 32bit signed timestamp is typically from
 890                 // Fri, 13 Dec 1901 20:45:54 GMT to Tue, 19 Jan 2038 03:14:07 GMT
 891                 //
 892
 893                 # old algorithm iterates through all years. new algorithm does it in
 894                 # 10 year blocks
 895
 896                 /*
 897                 # old algo
 898                 for ($a = 1970 ; --$a >= 0;) {
 899                         $lastd = $d;
 900
 901                         if ($leaf = _adodb_is_leap_year($a)) $d += $d366;
 902                         else $d += $d365;
 903
 904                         if ($d >= 0) {
 905                                 $year = $a;
 906                                 break;
 907                         }
 908                 }
 909                 */
 910
 911                 $lastsecs = 0;
 912                 $lastyear = 1970;
 913                 foreach($YRS as $year => $secs) {
 914                         if ($d >= $secs) {
 915                                 $a = $lastyear;
 916                                 break;
 917                         }
 918                         $lastsecs = $secs;
 919                         $lastyear = $year;
 920                 }
 921
 922                 $d -= $lastsecs;
 923                 if (!isset($a)) $a = $lastyear;
 924
 925                 //echo ' yr=',$a,' ', $d,'.';
 926
 927                 for (; --$a >= 0;) {
 928                         $lastd = $d;
 929
 930                         if ($leaf = _adodb_is_leap_year($a)) $d += $d366;
 931                         else $d += $d365;
 932
 933                         if ($d >= 0) {
 934                                 $year = $a;
 935                                 break;
 936                         }
 937                 }
 938                 /**/
 939
 940                 $secsInYear = 86400 * ($leaf ? 366 : 365) + $lastd;
 941
 942                 $d = $lastd;
 943                 $mtab = ($leaf) ? $_month_table_leaf : $_month_table_normal;
 944                 for ($a = 13 ; --$a > 0;) {
 945                         $lastd = $d;
 946                         $d += $mtab[$a] * $_day_power;
 947                         if ($d >= 0) {
 948                                 $month = $a;
 949                                 $ndays = $mtab[$a];
 950                                 break;
 951                         }
 952                 }
 953
 954                 $d = $lastd;
 955                 $day = $ndays + ceil(($d+1) / ($_day_power));
 956
 957                 $d += ($ndays - $day+1)* $_day_power;
 958                 $hour = floor($d/$_hour_power);
 959
 960         } else {
 961                 for ($a = 1970 ;; $a++) {
 962                         $lastd = $d;
 963
 964                         if ($leaf = _adodb_is_leap_year($a)) $d -= $d366;
 965                         else $d -= $d365;
 966                         if ($d < 0) {
 967                                 $year = $a;
 968                                 break;
 969                         }
 970                 }
 971                 $secsInYear = $lastd;
 972                 $d = $lastd;
 973                 $mtab = ($leaf) ? $_month_table_leaf : $_month_table_normal;
 974                 for ($a = 1 ; $a <= 12; $a++) {
 975                         $lastd = $d;
 976                         $d -= $mtab[$a] * $_day_power;
 977                         if ($d < 0) {
 978                                 $month = $a;
 979                                 $ndays = $mtab[$a];
 980                                 break;
 981                         }
 982                 }
 983                 $d = $lastd;
 984                 $day = ceil(($d+1) / $_day_power);
 985                 $d = $d - ($day-1) * $_day_power;
 986                 $hour = floor($d /$_hour_power);
 987         }
 988
 989         $d -= $hour * $_hour_power;
 990         $min = floor($d/$_min_power);
 991         $secs = $d - $min * $_min_power;
 992         if ($fast) {
 993                 return array(
 994                 'seconds' => $secs,
 995                 'minutes' => $min,
 996                 'hours' => $hour,
 997                 'mday' => $day,
 998                 'mon' => $month,
 999                 'year' => $year,
1000                 'yday' => floor($secsInYear/$_day_power),
1001                 'leap' => $leaf,
1002                 'ndays' => $ndays
1003                 );
1004         }
1005
1006
1007         $dow = adodb_dow($year,$month,$day);
1008
1009         return array(
1010                 'seconds' => $secs,
1011                 'minutes' => $min,
1012                 'hours' => $hour,
1013                 'mday' => $day,
1014                 'wday' => $dow,
1015                 'mon' => $month,
1016                 'year' => $year,
1017                 'yday' => floor($secsInYear/$_day_power),
1018                 'weekday' => gmdate('l',$_day_power*(3+$dow)),
1019                 'month' => gmdate('F',mktime(0,0,0,$month,2,1971)),
1020                 0 => $origd
1021         );
1022 }
1023
1024 /**
1025  * Compute timezone offset.
1026  *
1027  * @param int  $gmt     Time offset from GMT, in seconds
1028  * @param bool $ignored Param leftover from removed PHP4-compatibility code
1029  *                      kept to avoid altering function signature.
1030  * @return string
1031  */
1032 function adodb_tz_offset($gmt, $ignored=true)
1033 {
1034         $zhrs = abs($gmt) / 3600;
1035         $hrs = floor($zhrs);
1036         return sprintf('%s%02d%02d', ($gmt <= 0) ? '+' : '-', $hrs, ($zhrs - $hrs) * 60);
1037 }
1038
1039
1040 function adodb_gmdate($fmt,$d=false)
1041 {
1042         return adodb_date($fmt,$d,true);
1043 }
1044
1045 // accepts unix timestamp and iso date format in $d
1046 function adodb_date2($fmt, $d=false, $is_gmt=false)
1047 {
1048         if ($d !== false) {
1049                 if (!preg_match(
1050                         "|^([0-9]{4})[-/\.]?([0-9]{1,2})[-/\.]?([0-9]{1,2})[ -]?(([0-9]{1,2}):?([0-9]{1,2}):?([0-9\.]{1,4}))?|",
1051                         ($d), $rr)) return adodb_date($fmt,false,$is_gmt);
1052
1053                 if ($rr[1] <= 100 && $rr[2]<= 1) return adodb_date($fmt,false,$is_gmt);
1054
1055                 // h-m-s-MM-DD-YY
1056                 if (!isset($rr[5])) $d = adodb_mktime(0,0,0,$rr[2],$rr[3],$rr[1],false,$is_gmt);
1057                 else $d = @adodb_mktime($rr[5],$rr[6],$rr[7],$rr[2],$rr[3],$rr[1],false,$is_gmt);
1058         }
1059
1060         return adodb_date($fmt,$d,$is_gmt);
1061 }
1062
1063
1064 /**
1065         Return formatted date based on timestamp $d
1066 */
1067 function adodb_date($fmt,$d=false,$is_gmt=false)
1068 {
1069         static $daylight;
1070         static $jan1_1971;
1071
1072         if (!isset($daylight)) {
1073                 $daylight = function_exists('adodb_daylight_sv');
1074                 if (empty($jan1_1971)) $jan1_1971 = mktime(0,0,0,1,1,1971); // we only use date() when > 1970 as adodb_mktime() only uses mktime() when > 1970
1075         }
1076
1077         if ($d === false) return ($is_gmt)? @gmdate($fmt): @date($fmt);
1078         if (!defined('ADODB_TEST_DATES')) {
1079
1080                 /*
1081                 * Format 'Q' is an ADOdb custom format, not supported in PHP
1082                 * so if there is a 'Q' in the format, we force it to use our
1083                 * function. There is a trivial overhead in this
1084                 */
1085
1086                 if ((abs($d) <= 0x7FFFFFFF) && strpos($fmt,'Q') === false)
1087                 { // check if number in 32-bit signed range
1088
1089                         if (!defined('ADODB_NO_NEGATIVE_TS') || $d >= $jan1_1971) // if windows, must be +ve integer
1090                                 return ($is_gmt)? @gmdate($fmt,$d): @date($fmt,$d);
1091
1092                 }
1093         }
1094         $_day_power = 86400;
1095
1096         $arr = _adodb_getdate($d,true,$is_gmt);
1097
1098         if ($daylight) adodb_daylight_sv($arr, $is_gmt);
1099
1100         $year = $arr['year'];
1101         $month = $arr['mon'];
1102         $day = $arr['mday'];
1103         $hour = $arr['hours'];
1104         $min = $arr['minutes'];
1105         $secs = $arr['seconds'];
1106
1107         $max = strlen($fmt);
1108         $dates = '';
1109
1110         /*
1111                 at this point, we have the following integer vars to manipulate:
1112                 $year, $month, $day, $hour, $min, $secs
1113         */
1114         for ($i=0; $i < $max; $i++) {
1115                 switch($fmt[$i]) {
1116                 case 'e':
1117                         $dates .= date('e');
1118                         break;
1119                 case 'T':
1120                         $dt = new DateTime();
1121                         $dt->SetDate($year,$month,$day);
1122                         $dates .= $dt->Format('T');
1123                         break;
1124                 // YEAR
1125                 case 'L': $dates .= $arr['leap'] ? '1' : '0'; break;
1126                 case 'r': // Thu, 21 Dec 2000 16:01:07 +0200
1127
1128                         // 4.3.11 uses '04 Jun 2004'
1129                         // 4.3.8 uses  ' 4 Jun 2004'
1130                         $dates .= gmdate('D',$_day_power*(3+adodb_dow($year,$month,$day))).', '
1131                                 . ($day<10?'0'.$day:$day) . ' '.date('M',mktime(0,0,0,$month,2,1971)).' '.$year.' ';
1132
1133                         if ($hour < 10) $dates .= '0'.$hour; else $dates .= $hour;
1134
1135                         if ($min < 10) $dates .= ':0'.$min; else $dates .= ':'.$min;
1136
1137                         if ($secs < 10) $dates .= ':0'.$secs; else $dates .= ':'.$secs;
1138
1139                         $gmt = adodb_get_gmt_diff($year,$month,$day);
1140
1141                         $dates .= ' '.adodb_tz_offset($gmt);
1142                         break;
1143
1144                 case 'Y': $dates .= $year; break;
1145                 case 'y': $dates .= substr($year,strlen($year)-2,2); break;
1146                 // MONTH
1147                 case 'm': if ($month<10) $dates .= '0'.$month; else $dates .= $month; break;
1148                 case 'Q':
1149                         $dates .= ceil($month / 3);
1150                         break;
1151                 case 'n': $dates .= $month; break;
1152                 case 'M': $dates .= date('M',mktime(0,0,0,$month,2,1971)); break;
1153                 case 'F': $dates .= date('F',mktime(0,0,0,$month,2,1971)); break;
1154                 // DAY
1155                 case 't': $dates .= $arr['ndays']; break;
1156                 case 'z': $dates .= $arr['yday']; break;
1157                 case 'w': $dates .= adodb_dow($year,$month,$day); break;
1158                 case 'W':
1159                         $dates .= sprintf('%02d',ceil( $arr['yday'] / 7) - 1);
1160                         break;
1161                 case 'l': $dates .= gmdate('l',$_day_power*(3+adodb_dow($year,$month,$day))); break;
1162                 case 'D': $dates .= gmdate('D',$_day_power*(3+adodb_dow($year,$month,$day))); break;
1163                 case 'j': $dates .= $day; break;
1164                 case 'd': if ($day<10) $dates .= '0'.$day; else $dates .= $day; break;
1165                 case 'S':
1166                         $d10 = $day % 10;
1167                         if ($d10 == 1) $dates .= 'st';
1168                         else if ($d10 == 2 && $day != 12) $dates .= 'nd';
1169                         else if ($d10 == 3) $dates .= 'rd';
1170                         else $dates .= 'th';
1171                         break;
1172
1173                 // HOUR
1174                 case 'Z':
1175                         $dates .= ($is_gmt) ? 0 : -adodb_get_gmt_diff($year,$month,$day); break;
1176                 case 'O':
1177                         $gmt = ($is_gmt) ? 0 : adodb_get_gmt_diff($year,$month,$day);
1178
1179                         $dates .= adodb_tz_offset($gmt);
1180                         break;
1181
1182                 case 'H':
1183                         if ($hour < 10) $dates .= '0'.$hour;
1184                         else $dates .= $hour;
1185                         break;
1186                 case 'h':
1187                         if ($hour > 12) $hh = $hour - 12;
1188                         else {
1189                                 if ($hour == 0) $hh = '12';
1190                                 else $hh = $hour;
1191                         }
1192
1193                         if ($hh < 10) $dates .= '0'.$hh;
1194                         else $dates .= $hh;
1195                         break;
1196
1197                 case 'G':
1198                         $dates .= $hour;
1199                         break;
1200
1201                 case 'g':
1202                         if ($hour > 12) $hh = $hour - 12;
1203                         else {
1204                                 if ($hour == 0) $hh = '12';
1205                                 else $hh = $hour;
1206                         }
1207                         $dates .= $hh;
1208                         break;
1209                 // MINUTES
1210                 case 'i': if ($min < 10) $dates .= '0'.$min; else $dates .= $min; break;
1211                 // SECONDS
1212                 case 'U': $dates .= $d; break;
1213                 case 's': if ($secs < 10) $dates .= '0'.$secs; else $dates .= $secs; break;
1214                 // AM/PM
1215                 // Note 00:00 to 11:59 is AM, while 12:00 to 23:59 is PM
1216                 case 'a':
1217                         if ($hour>=12) $dates .= 'pm';
1218                         else $dates .= 'am';
1219                         break;
1220                 case 'A':
1221                         if ($hour>=12) $dates .= 'PM';
1222                         else $dates .= 'AM';
1223                         break;
1224                 default:
1225                         $dates .= $fmt[$i]; break;
1226                 // ESCAPE
1227                 case "\\":
1228                         $i++;
1229                         if ($i < $max) $dates .= $fmt[$i];
1230                         break;
1231                 }
1232         }
1233         return $dates;
1234 }
1235
1236 /**
1237         Returns a timestamp given a GMT/UTC time.
1238         Note that $is_dst is not implemented and is ignored.
1239 */
1240 function adodb_gmmktime($hr,$min,$sec,$mon=false,$day=false,$year=false,$is_dst=false)
1241 {
1242         return adodb_mktime($hr,$min,$sec,$mon,$day,$year,$is_dst,true);
1243 }
1244
1245 /**
1246         Return a timestamp given a local time. Originally by jackbbs.
1247         Note that $is_dst is not implemented and is ignored.
1248
1249         Not a very fast algorithm - O(n) operation. Could be optimized to O(1).
1250 */
1251 function adodb_mktime($hr,$min,$sec,$mon=false,$day=false,$year=false,$is_dst=false,$is_gmt=false)
1252 {
1253         if (!defined('ADODB_TEST_DATES')) {
1254
1255                 if ($mon === false) {
1256                         return $is_gmt? @gmmktime($hr,$min,$sec): @mktime($hr,$min,$sec);
1257                 }
1258
1259                 // for windows, we don't check 1970 because with timezone differences,
1260                 // 1 Jan 1970 could generate negative timestamp, which is illegal
1261                 $usephpfns = (1970 < $year && $year < 2038
1262                         || !defined('ADODB_NO_NEGATIVE_TS') && (1901 < $year && $year < 2038)
1263                         );
1264
1265
1266                 if ($usephpfns && ($year + $mon/12+$day/365.25+$hr/(24*365.25) >= 2038)) $usephpfns = false;
1267
1268                 if ($usephpfns) {
1269                                 return $is_gmt ?
1270                                         @gmmktime($hr,$min,$sec,$mon,$day,$year):
1271                                         @mktime($hr,$min,$sec,$mon,$day,$year);
1272                 }
1273         }
1274
1275         $gmt_different = ($is_gmt) ? 0 : adodb_get_gmt_diff($year,$mon,$day);
1276
1277         /*
1278         # disabled because some people place large values in $sec.
1279         # however we need it for $mon because we use an array...
1280         $hr = intval($hr);
1281         $min = intval($min);
1282         $sec = intval($sec);
1283         */
1284         $mon = intval($mon);
1285         $day = intval($day);
1286         $year = intval($year);
1287
1288
1289         $year = adodb_year_digit_check($year);
1290
1291         if ($mon > 12) {
1292                 $y = floor(($mon-1)/ 12);
1293                 $year += $y;
1294                 $mon -= $y*12;
1295         } else if ($mon < 1) {
1296                 $y = ceil((1-$mon) / 12);
1297                 $year -= $y;
1298                 $mon += $y*12;
1299         }
1300
1301         $_day_power = 86400;
1302         $_hour_power = 3600;
1303         $_min_power = 60;
1304
1305         $_month_table_normal = array("",31,28,31,30,31,30,31,31,30,31,30,31);
1306         $_month_table_leaf = array("",31,29,31,30,31,30,31,31,30,31,30,31);
1307
1308         $_total_date = 0;
1309         if ($year >= 1970) {
1310                 for ($a = 1970 ; $a <= $year; $a++) {
1311                         $leaf = _adodb_is_leap_year($a);
1312                         if ($leaf == true) {
1313                                 $loop_table = $_month_table_leaf;
1314                                 $_add_date = 366;
1315                         } else {
1316                                 $loop_table = $_month_table_normal;
1317                                 $_add_date = 365;
1318                         }
1319                         if ($a < $year) {
1320                                 $_total_date += $_add_date;
1321                         } else {
1322                                 for($b=1;$b<$mon;$b++) {
1323                                         $_total_date += $loop_table[$b];
1324                                 }
1325                         }
1326                 }
1327                 $_total_date +=$day-1;
1328                 $ret = $_total_date * $_day_power + $hr * $_hour_power + $min * $_min_power + $sec + $gmt_different;
1329
1330         } else {
1331                 for ($a = 1969 ; $a >= $year; $a--) {
1332                         $leaf = _adodb_is_leap_year($a);
1333                         if ($leaf == true) {
1334                                 $loop_table = $_month_table_leaf;
1335                                 $_add_date = 366;
1336                         } else {
1337                                 $loop_table = $_month_table_normal;
1338                                 $_add_date = 365;
1339                         }
1340                         if ($a > $year) { $_total_date += $_add_date;
1341                         } else {
1342                                 for($b=12;$b>$mon;$b--) {
1343                                         $_total_date += $loop_table[$b];
1344                                 }
1345                         }
1346                 }
1347                 $_total_date += $loop_table[$mon] - $day;
1348
1349                 $_day_time = $hr * $_hour_power + $min * $_min_power + $sec;
1350                 $_day_time = $_day_power - $_day_time;
1351                 $ret = -( $_total_date * $_day_power + $_day_time - $gmt_different);
1352                 if ($ret < -12220185600) $ret += 10*86400; // if earlier than 5 Oct 1582 - gregorian correction
1353                 else if ($ret < -12219321600) $ret = -12219321600; // if in limbo, reset to 15 Oct 1582.
1354         }
1355         //print " dmy=$day/$mon/$year $hr:$min:$sec => " .$ret;
1356         return $ret;
1357 }
1358
1359 function adodb_gmstrftime($fmt, $ts=false)
1360 {
1361         return adodb_strftime($fmt,$ts,true);
1362 }
1363
1364 // hack - convert to adodb_date
1365 function adodb_strftime($fmt, $ts=false,$is_gmt=false)
1366 {
1367 global $ADODB_DATE_LOCALE;
1368
1369         if (!defined('ADODB_TEST_DATES')) {
1370                 if ((abs($ts) <= 0x7FFFFFFF)) { // check if number in 32-bit signed range
1371                         if (!defined('ADODB_NO_NEGATIVE_TS') || $ts >= 0) // if windows, must be +ve integer
1372                                 return ($is_gmt)? @gmstrftime($fmt,$ts): @strftime($fmt,$ts);
1373
1374                 }
1375         }
1376
1377         if (empty($ADODB_DATE_LOCALE)) {
1378         /*
1379                 $tstr = strtoupper(gmstrftime('%c',31366800)); // 30 Dec 1970, 1 am
1380                 $sep = substr($tstr,2,1);
1381                 $hasAM = strrpos($tstr,'M') !== false;
1382         */
1383                 # see PHPLens Issue No: 14865 for reasoning, and changelog for version 0.24
1384                 $dstr = gmstrftime('%x',31366800); // 30 Dec 1970, 1 am
1385                 $sep = substr($dstr,2,1);
1386                 $tstr = strtoupper(gmstrftime('%X',31366800)); // 30 Dec 1970, 1 am
1387                 $hasAM = strrpos($tstr,'M') !== false;
1388
1389                 $ADODB_DATE_LOCALE = array();
1390                 $ADODB_DATE_LOCALE[] =  strncmp($tstr,'30',2) == 0 ? 'd'.$sep.'m'.$sep.'y' : 'm'.$sep.'d'.$sep.'y';
1391                 $ADODB_DATE_LOCALE[]  = ($hasAM) ? 'h:i:s a' : 'H:i:s';
1392
1393         }
1394         $inpct = false;
1395         $fmtdate = '';
1396         for ($i=0,$max = strlen($fmt); $i < $max; $i++) {
1397                 $ch = $fmt[$i];
1398                 if ($ch == '%') {
1399                         if ($inpct) {
1400                                 $fmtdate .= '%';
1401                                 $inpct = false;
1402                         } else
1403                                 $inpct = true;
1404                 } else if ($inpct) {
1405
1406                         $inpct = false;
1407                         switch($ch) {
1408                         case '0':
1409                         case '1':
1410                         case '2':
1411                         case '3':
1412                         case '4':
1413                         case '5':
1414                         case '6':
1415                         case '7':
1416                         case '8':
1417                         case '9':
1418                         case 'E':
1419                         case 'O':
1420                                 /* ignore format modifiers */
1421                                 $inpct = true;
1422                                 break;
1423
1424                         case 'a': $fmtdate .= 'D'; break;
1425                         case 'A': $fmtdate .= 'l'; break;
1426                         case 'h':
1427                         case 'b': $fmtdate .= 'M'; break;
1428                         case 'B': $fmtdate .= 'F'; break;
1429                         case 'c': $fmtdate .= $ADODB_DATE_LOCALE[0].$ADODB_DATE_LOCALE[1]; break;
1430                         case 'C': $fmtdate .= '\C?'; break; // century
1431                         case 'd': $fmtdate .= 'd'; break;
1432                         case 'D': $fmtdate .= 'm/d/y'; break;
1433                         case 'e': $fmtdate .= 'j'; break;
1434                         case 'g': $fmtdate .= '\g?'; break; //?
1435                         case 'G': $fmtdate .= '\G?'; break; //?
1436                         case 'H': $fmtdate .= 'H'; break;
1437                         case 'I': $fmtdate .= 'h'; break;
1438                         case 'j': $fmtdate .= '?z'; $parsej = true; break; // wrong as j=1-based, z=0-basd
1439                         case 'm': $fmtdate .= 'm'; break;
1440                         case 'M': $fmtdate .= 'i'; break;
1441                         case 'n': $fmtdate .= "\n"; break;
1442                         case 'p': $fmtdate .= 'a'; break;
1443                         case 'r': $fmtdate .= 'h:i:s a'; break;
1444                         case 'R': $fmtdate .= 'H:i:s'; break;
1445                         case 'S': $fmtdate .= 's'; break;
1446                         case 't': $fmtdate .= "\t"; break;
1447                         case 'T': $fmtdate .= 'H:i:s'; break;
1448                         case 'u': $fmtdate .= '?u'; $parseu = true; break; // wrong strftime=1-based, date=0-based
1449                         case 'U': $fmtdate .= '?U'; $parseU = true; break;// wrong strftime=1-based, date=0-based
1450                         case 'x': $fmtdate .= $ADODB_DATE_LOCALE[0]; break;
1451                         case 'X': $fmtdate .= $ADODB_DATE_LOCALE[1]; break;
1452                         case 'w': $fmtdate .= '?w'; $parseu = true; break; // wrong strftime=1-based, date=0-based
1453                         case 'W': $fmtdate .= '?W'; $parseU = true; break;// wrong strftime=1-based, date=0-based
1454                         case 'y': $fmtdate .= 'y'; break;
1455                         case 'Y': $fmtdate .= 'Y'; break;
1456                         case 'Z': $fmtdate .= 'T'; break;
1457                         }
1458                 } else if (('A' <= ($ch) && ($ch) <= 'Z' ) || ('a' <= ($ch) && ($ch) <= 'z' ))
1459                         $fmtdate .= "\\".$ch;
1460                 else
1461                         $fmtdate .= $ch;
1462         }
1463         //echo "fmt=",$fmtdate,"<br>";
1464         if ($ts === false) $ts = time();
1465         $ret = adodb_date($fmtdate, $ts, $is_gmt);
1466         return $ret;
1467 }
1468
1469 /**
1470 * Returns the status of the last date calculation and whether it exceeds
1471 * the limit of ADODB_FUTURE_DATE_CUTOFF_YEARS
1472 *
1473 * @return boolean
1474 */
1475 function adodb_last_date_status()
1476 {
1477         global $_adodb_last_date_call_failed;
1478
1479         return $_adodb_last_date_call_failed;
1480 }