PageRenderTime 45ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 0ms

/lib/rdfapi-php/api/util/adodb/adodb-time.inc.php

https://github.com/komagata/plnet
PHP | 967 lines | 504 code | 97 blank | 366 comment | 193 complexity | b75dbb98a3c8930e74a2e26558666abe MD5 | raw file
Possible License(s): LGPL-2.1 
    

  1. <?php

    2. 

  2. /**

    3. 

  3. ADOdb Date Library, part of the ADOdb abstraction library

    4. 

  4. Download: http://php.weblogs.com/adodb_date_time_library

    5. 

  5. 

    6. 

  6. PHP native date functions use integer timestamps for computations.

    7. 

  7. Because of this, dates are restricted to the years 1901-2038 on Unix 

    8. 

  8. and 1970-2038 on Windows due to integer overflow for dates beyond 

    9. 

  9. those years. This library overcomes these limitations by replacing the 

    10. 

  10. native function's signed integers (normally 32-bits) with PHP floating 

    11. 

  11. point numbers (normally 64-bits).

    12. 

  12. 

    13. 

  13. Dates from 100 A.D. to 3000 A.D. and later

    14. 

  14. have been tested. The minimum is 100 A.D. as <100 will invoke the

    15. 

  15. 2 => 4 digit year conversion. The maximum is billions of years in the 

    16. 

  16. future, but this is a theoretical limit as the computation of that year 

    17. 

  17. would take too long with the current implementation of adodb_mktime().

    18. 

  18. 

    19. 

  19. This library replaces native functions as follows:

    20. 

  20. 

    21. 

  21. <pre>	

    22. 

  22. 	getdate()  with  adodb_getdate()

    23. 

  23. 	date()     with  adodb_date() 

    24. 

  24. 	gmdate()   with  adodb_gmdate()

    25. 

  25. 	mktime()   with  adodb_mktime()

    26. 

  26. 	gmmktime() with  adodb_gmmktime()

    27. 

  27. </pre>

    28. 

  28. 	

    29. 

  29. The parameters are identical, except that adodb_date() accepts a subset

    30. 

  30. of date()'s field formats. Mktime() will convert from local time to GMT, 

    31. 

  31. and date() will convert from GMT to local time, but daylight savings is 

    32. 

  32. not handled currently.

    33. 

  33. 

    34. 

  34. This library is independant of the rest of ADOdb, and can be used

    35. 

  35. as standalone code.

    36. 

  36. 

    37. 

  37. PERFORMANCE

    38. 

  38. 

    39. 

  39. For high speed, this library uses the native date functions where

    40. 

  40. possible, and only switches to PHP code when the dates fall outside 

    41. 

  41. the 32-bit signed integer range.

    42. 

  42. 

    43. 

  43. GREGORIAN CORRECTION

    44. 

  44. 

    45. 

  45. Pope Gregory shortened October of A.D. 1582 by ten days. Thursday, 

    46. 

  46. October 4, 1582 (Julian) was followed immediately by Friday, October 15, 

    47. 

  47. 1582 (Gregorian). 

    48. 

  48. 

    49. 

  49. Since 0.06, we handle this correctly, so:

    50. 

  50. 

    51. 

  51. adodb_mktime(0,0,0,10,15,1582) - adodb_mktime(0,0,0,10,4,1582) 

    52. 

  52. 	== 24 * 3600 (1 day)

    53. 

  53. 

    54. 

  54. =============================================================================

    55. 

  55. 

    56. 

  56. COPYRIGHT

    57. 

  57. 

    58. 

  58. (c) 2003 John Lim and released under BSD-style license except for code by jackbbs,

    59. 

  59. which includes adodb_mktime, adodb_get_gmt_diff, adodb_is_leap_year

    60. 

  60. and originally found at http://www.php.net/manual/en/function.mktime.php

    61. 

  61. 

    62. 

  62. =============================================================================

    63. 

  63. 

    64. 

  64. BUG REPORTS

    65. 

  65. 

    66. 

  66. These should be posted to the ADOdb forums at

    67. 

  67. 

    68. 

  68. 	http://phplens.com/lens/lensforum/topics.php?id=4

    69. 

  69. 

    70. 

  70. =============================================================================

    71. 

  71. 

    72. 

  72. FUNCTION DESCRIPTIONS

    73. 

  73. 

    74. 

  74. 

    75. 

  75. FUNCTION adodb_getdate($date=false)

    76. 

  76. 

    77. 

  77. Returns an array containing date information, as getdate(), but supports

    78. 

  78. dates greater than 1901 to 2038.

    79. 

  79. 

    80. 

  80. 

    81. 

  81. FUNCTION adodb_date($fmt, $timestamp = false)

    82. 

  82. 

    83. 

  83. Convert a timestamp to a formatted local date. If $timestamp is not defined, the

    84. 

  84. current timestamp is used. Unlike the function date(), it supports dates

    85. 

  85. outside the 1901 to 2038 range.

    86. 

  86. 

    87. 

  87. The format fields that adodb_date supports:

    88. 

  88. 

    89. 

  89. <pre>

    90. 

  90. a - "am" or "pm" 

    91. 

  91. A - "AM" or "PM" 

    92. 

  92. d - day of the month, 2 digits with leading zeros; i.e. "01" to "31" 

    93. 

  93. D - day of the week, textual, 3 letters; e.g. "Fri" 

    94. 

  94. F - month, textual, long; e.g. "January" 

    95. 

  95. g - hour, 12-hour format without leading zeros; i.e. "1" to "12" 

    96. 

  96. G - hour, 24-hour format without leading zeros; i.e. "0" to "23" 

    97. 

  97. h - hour, 12-hour format; i.e. "01" to "12" 

    98. 

  98. H - hour, 24-hour format; i.e. "00" to "23" 

    99. 

  99. i - minutes; i.e. "00" to "59" 

    100. 

  100. j - day of the month without leading zeros; i.e. "1" to "31" 

    101. 

  101. l (lowercase 'L') - day of the week, textual, long; e.g. "Friday"  

    102. 

  102. L - boolean for whether it is a leap year; i.e. "0" or "1" 

    103. 

  103. m - month; i.e. "01" to "12" 

    104. 

  104. M - month, textual, 3 letters; e.g. "Jan" 

    105. 

  105. n - month without leading zeros; i.e. "1" to "12" 

    106. 

  106. O - Difference to Greenwich time in hours; e.g. "+0200" 

    107. 

  107. Q - Quarter, as in 1, 2, 3, 4 

    108. 

  108. r - RFC 822 formatted date; e.g. "Thu, 21 Dec 2000 16:01:07 +0200" 

    109. 

  109. s - seconds; i.e. "00" to "59" 

    110. 

  110. S - English ordinal suffix for the day of the month, 2 characters; 

    111. 

  111.    			i.e. "st", "nd", "rd" or "th" 

    112. 

  112. t - number of days in the given month; i.e. "28" to "31"

    113. 

  113. T - Timezone setting of this machine; e.g. "EST" or "MDT" 

    114. 

  114. U - seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)  

    115. 

  115. w - day of the week, numeric, i.e. "0" (Sunday) to "6" (Saturday) 

    116. 

  116. Y - year, 4 digits; e.g. "1999" 

    117. 

  117. y - year, 2 digits; e.g. "99" 

    118. 

  118. z - day of the year; i.e. "0" to "365" 

    119. 

  119. Z - timezone offset in seconds (i.e. "-43200" to "43200"). 

    120. 

  120.    			The offset for timezones west of UTC is always negative, 

    121. 

  121. 			and for those east of UTC is always positive. 

    122. 

  122. </pre>

    123. 

  123. 

    124. 

  124. Unsupported:

    125. 

  125. <pre>

    126. 

  126. B - Swatch Internet time 

    127. 

  127. I (capital i) - "1" if Daylight Savings Time, "0" otherwise.

    128. 

  128. W - ISO-8601 week number of year, weeks starting on Monday 

    129. 

  129. 

    130. 

  130. </pre>

    131. 

  131. 

    132. 

  132. FUNCTION adodb_date2($fmt, $isoDateString = false)

    133. 

  133. Same as adodb_date, but 2nd parameter accepts iso date, eg.

    134. 

  134. 

    135. 

  135.   adodb_date2('d-M-Y H:i','2003-12-25 13:01:34');

    136. 

  136. 

    137. 

  137. FUNCTION adodb_gmdate($fmt, $timestamp = false)

    138. 

  138. 

    139. 

  139. Convert a timestamp to a formatted GMT date. If $timestamp is not defined, the

    140. 

  140. current timestamp is used. Unlike the function date(), it supports dates

    141. 

  141. outside the 1901 to 2038 range.

    142. 

  142. 

    143. 

  143. 

    144. 

  144. FUNCTION adodb_mktime($hr, $min, $sec [, $month, $day, $year])

    145. 

  145. 

    146. 

  146. Converts a local date to a unix timestamp.  Unlike the function mktime(), it supports

    147. 

  147. dates outside the 1901 to 2038 range. Differs from mktime() in that all parameters

    148. 

  148. are currently compulsory.

    149. 

  149. 

    150. 

  150. FUNCTION adodb_gmmktime($hr, $min, $sec [, $month, $day, $year])

    151. 

  151. 

    152. 

  152. Converts a gmt date to a unix timestamp.  Unlike the function gmmktime(), it supports

    153. 

  153. dates outside the 1901 to 2038 range. Differs from gmmktime() in that all parameters

    154. 

  154. are currently compulsory.

    155. 

  155. 

    156. 

  156. =============================================================================

    157. 

  157. 

    158. 

  158. NOTES

    159. 

  159. 

    160. 

  160. Useful url for generating test timestamps:

    161. 

  161. 	http://www.4webhelp.net/us/timestamp.php

    162. 

  162. 

    163. 

  163. Possible future optimizations include 

    164. 

  164. 

    165. 

  165. a. Using an algorithm similar to Plauger's in "The Standard C Library" 

    166. 

  166. (page 428, xttotm.c _Ttotm() function). Plauger's algorithm will not 

    167. 

  167. work outside 32-bit signed range, so i decided not to implement it.

    168. 

  168. 

    169. 

  169. b. Iterate over a block of years (say 12) when searching for the 

    170. 

  170. correct year.

    171. 

  171. 

    172. 

  172. c. Implement daylight savings, which looks awfully complicated, see

    173. 

  173. 	http://webexhibits.org/daylightsaving/

    174. 

  174. 

    175. 

  175. 

    176. 

  176. CHANGELOG

    177. 

  177. - 18 July 2004 0.15

    178. 

  178. All params in adodb_mktime were formerly compulsory. Now only the hour, min, secs is compulsory. This

    179. 

  179. brings it more in line with mktime (still not identical).

    180. 

  180. 

    181. 

  181. - 23 June 2004 0.14

    182. 

  182. 

    183. 

  183. Allow you to define your own daylights savings function, adodb_daylight_sv.

    184. 

  184. If the function is defined (somewhere in an include), then you can correct for daylights savings.

    185. 

  185. 

    186. 

  186. In this example, we apply daylights savings in June or July, adding one hour. This is extremely

    187. 

  187. unrealistic as it does not take into account time-zone, geographic location, current year.

    188. 

  188. 

    189. 

  189. function adodb_daylight_sv(&$arr, $is_gmt)

    190. 

  190. {

    191. 

  191. 	if ($is_gmt) return;

    192. 

  192. 	$m = $arr['mon'];

    193. 

  193. 	if ($m == 6 || $m == 7) $arr['hours'] += 1;

    194. 

  194. }

    195. 

  195. 

    196. 

  196. This is only called by adodb_date() and not by adodb_mktime(). 

    197. 

  197. 

    198. 

  198. The format of $arr is

    199. 

  199. Array ( 

    200. 

  200.    [seconds] => 0 

    201. 

  201.    [minutes] => 0 

    202. 

  202.    [hours] => 0 

    203. 

  203.    [mday] => 1      # day of month, eg 1st day of the month

    204. 

  204.    [mon] => 2       # month (eg. Feb)

    205. 

  205.    [year] => 2102 

    206. 

  206.    [yday] => 31     # days in current year

    207. 

  207.    [leap] =>        # true if leap year

    208. 

  208.    [ndays] => 28    # no of days in current month

    209. 

  209.    ) 

    210. 

  210.    

    211. 

  211. 

    212. 

  212. - 28 Apr 2004 0.13

    213. 

  213. Fixed adodb_date to properly support $is_gmt. Thx to Dimitar Angelov.

    214. 

  214. 

    215. 

  215. - 20 Mar 2004 0.12

    216. 

  216. Fixed month calculation error in adodb_date. 2102-June-01 appeared as 2102-May-32.

    217. 

  217. 

    218. 

  218. - 26 Oct 2003 0.11

    219. 

  219. Because of daylight savings problems (some systems apply daylight savings to 

    220. 

  220. January!!!), changed adodb_get_gmt_diff() to ignore daylight savings.

    221. 

  221. 

    222. 

  222. - 9 Aug 2003 0.10

    223. 

  223. Fixed bug with dates after 2038. 

    224. 

  224. See http://phplens.com/lens/lensforum/msgs.php?id=6980

    225. 

  225. 

    226. 

  226. - 1 July 2003 0.09

    227. 

  227. Added support for Q (Quarter).

    228. 

  228. Added adodb_date2(), which accepts ISO date in 2nd param

    229. 

  229. 

    230. 

  230. - 3 March 2003 0.08

    231. 

  231. Added support for 'S' adodb_date() format char. Added constant ADODB_ALLOW_NEGATIVE_TS

    232. 

  232. if you want PHP to handle negative timestamps between 1901 to 1969.

    233. 

  233. 

    234. 

  234. - 27 Feb 2003 0.07

    235. 

  235. All negative numbers handled by adodb now because of RH 7.3+ problems.

    236. 

  236. See http://bugs.php.net/bug.php?id=20048&edit=2

    237. 

  237. 

    238. 

  238. - 4 Feb 2003 0.06

    239. 

  239. Fixed a typo, 1852 changed to 1582! This means that pre-1852 dates

    240. 

  240. are now correctly handled.

    241. 

  241. 

    242. 

  242. - 29 Jan 2003 0.05

    243. 

  243. 

    244. 

  244. Leap year checking differs under Julian calendar (pre 1582). Also

    245. 

  245. leap year code optimized by checking for most common case first.

    246. 

  246. 

    247. 

  247. We also handle month overflow correctly in mktime (eg month set to 13).

    248. 

  248. 

    249. 

  249. Day overflow for less than one month's days is supported.

    250. 

  250. 

    251. 

  251. - 28 Jan 2003 0.04

    252. 

  252. 

    253. 

  253. Gregorian correction handled. In PHP5, we might throw an error if 

    254. 

  254. mktime uses invalid dates around 5-14 Oct 1582. Released with ADOdb 3.10.

    255. 

  255. Added limbo 5-14 Oct 1582 check, when we set to 15 Oct 1582.

    256. 

  256. 

    257. 

  257. - 27 Jan 2003 0.03

    258. 

  258. 

    259. 

  259. Fixed some more month problems due to gmt issues. Added constant ADODB_DATE_VERSION.

    260. 

  260. Fixed calculation of days since start of year for <1970. 

    261. 

  261. 

    262. 

  262. - 27 Jan 2003 0.02

    263. 

  263. 

    264. 

  264. Changed _adodb_getdate() to inline leap year checking for better performance.

    265. 

  265. Fixed problem with time-zones west of GMT +0000.

    266. 

  266. 

    267. 

  267. - 24 Jan 2003 0.01

    268. 

  268. 

    269. 

  269. First implementation.

    270. 

  270. */

    271. 

  271. 

    272. 

  272. 

    273. 

  273. /* Initialization */

    274. 

  274. 

    275. 

  275. /*

    276. 

  276. 	Version Number

    277. 

  277. */

    278. 

  278. define('ADODB_DATE_VERSION',0.15);

    279. 

  279. 

    280. 

  280. /*

    281. 

  281. 	We check for Windows as only +ve ints are accepted as dates on Windows.

    282. 

  282. 	

    283. 

  283. 	Apparently this problem happens also with Linux, RH 7.3 and later!

    284. 

  284. 	

    285. 

  285. 	glibc-2.2.5-34 and greater has been changed to return -1 for dates <

    286. 

  286. 	1970.  This used to work.  The problem exists with RedHat 7.3 and 8.0

    287. 

  287. 	echo (mktime(0, 0, 0, 1, 1, 1960));  // prints -1

    288. 

  288. 	

    289. 

  289. 	References:

    290. 

  290. 	 http://bugs.php.net/bug.php?id=20048&edit=2

    291. 

  291. 	 http://lists.debian.org/debian-glibc/2002/debian-glibc-200205/msg00010.html

    292. 

  292. */

    293. 

  293. 

    294. 

  294. if (!defined('ADODB_ALLOW_NEGATIVE_TS')) define('ADODB_NO_NEGATIVE_TS',1);

    295. 

  295. 

    296. 

  296. function adodb_date_test_date($y1,$m)

    297. 

  297. {

    298. 

  298. 	//print " $y1/$m ";

    299. 

  299. 	$t = adodb_mktime(0,0,0,$m,13,$y1);

    300. 

  300. 	if ("$y1-$m-13 00:00:00" != adodb_date('Y-n-d H:i:s',$t)) {

    301. 

  301. 		print "<b>$y1 error</b><br>";

    302. 

  302. 		return false;

    303. 

  303. 	}

    304. 

  304. 	return true;

    305. 

  305. }

    306. 

  306. /**

    307. 

  307. 	 Test Suite

    308. 

  308. */

    309. 

  309. function adodb_date_test()

    310. 

  310. {

    311. 

  311. 	

    312. 

  312. 	error_reporting(E_ALL);

    313. 

  313. 	print "<h4>Testing adodb_date and adodb_mktime. version=".ADODB_DATE_VERSION. "</h4>";

    314. 

  314. 	@set_time_limit(0);

    315. 

  315. 	$fail = false;

    316. 

  316. 	

    317. 

  317. 	// This flag disables calling of PHP native functions, so we can properly test the code

    318. 

  318. 	if (!defined('ADODB_TEST_DATES')) define('ADODB_TEST_DATES',1);

    319. 

  319. 	

    320. 

  320. 	$t = adodb_mktime(0,0,0);

    321. 

  321. 	if (!(adodb_date('Y-m-d') == date('Y-m-d'))) print 'Error in '.adodb_mktime(0,0,0).'<br>';

    322. 

  322. 	

    323. 

  323. 	$t = adodb_mktime(0,0,0,6,1,2102);

    324. 

  324. 	if (!(adodb_date('Y-m-d',$t) == '2102-06-01')) print 'Error in '.adodb_date('Y-m-d',$t).'<br>';

    325. 

  325. 	

    326. 

  326. 	$t = adodb_mktime(0,0,0,2,1,2102);

    327. 

  327. 	if (!(adodb_date('Y-m-d',$t) == '2102-02-01')) print 'Error in '.adodb_date('Y-m-d',$t).'<br>';

    328. 

  328. 	

    329. 

  329. 	

    330. 

  330. 	print "<p>Testing gregorian <=> julian conversion<p>";

    331. 

  331. 	$t = adodb_mktime(0,0,0,10,11,1492);

    332. 

  332. 	//http://www.holidayorigins.com/html/columbus_day.html - Friday check

    333. 

  333. 	if (!(adodb_date('D Y-m-d',$t) == 'Fri 1492-10-11')) print 'Error in Columbus landing<br>';

    334. 

  334. 	

    335. 

  335. 	$t = adodb_mktime(0,0,0,2,29,1500);

    336. 

  336. 	if (!(adodb_date('Y-m-d',$t) == '1500-02-29')) print 'Error in julian leap years<br>';

    337. 

  337. 	

    338. 

  338. 	$t = adodb_mktime(0,0,0,2,29,1700);

    339. 

  339. 	if (!(adodb_date('Y-m-d',$t) == '1700-03-01')) print 'Error in gregorian leap years<br>';

    340. 

  340. 	

    341. 

  341. 	print  adodb_mktime(0,0,0,10,4,1582).' ';

    342. 

  342. 	print adodb_mktime(0,0,0,10,15,1582);

    343. 

  343. 	$diff = (adodb_mktime(0,0,0,10,15,1582) - adodb_mktime(0,0,0,10,4,1582));

    344. 

  344. 	if ($diff != 3600*24) print " <b>Error in gregorian correction = ".($diff/3600/24)." days </b><br>";

    345. 

  345. 		

    346. 

  346. 	print " 15 Oct 1582, Fri=".(adodb_dow(1582,10,15) == 5 ? 'Fri' : '<b>Error</b>')."<br>";

    347. 

  347. 	print " 4 Oct 1582, Thu=".(adodb_dow(1582,10,4) == 4 ? 'Thu' : '<b>Error</b>')."<br>";

    348. 

  348. 	

    349. 

  349. 	print "<p>Testing overflow<p>";

    350. 

  350. 	

    351. 

  351. 	$t = adodb_mktime(0,0,0,3,33,1965);

    352. 

  352. 	if (!(adodb_date('Y-m-d',$t) == '1965-04-02')) print 'Error in day overflow 1 <br>';

    353. 

  353. 	$t = adodb_mktime(0,0,0,4,33,1971);

    354. 

  354. 	if (!(adodb_date('Y-m-d',$t) == '1971-05-03')) print 'Error in day overflow 2 <br>';

    355. 

  355. 	$t = adodb_mktime(0,0,0,1,60,1965);

    356. 

  356. 	if (!(adodb_date('Y-m-d',$t) == '1965-03-01')) print 'Error in day overflow 3 '.adodb_date('Y-m-d',$t).' <br>';

    357. 

  357. 	$t = adodb_mktime(0,0,0,12,32,1965);

    358. 

  358. 	if (!(adodb_date('Y-m-d',$t) == '1966-01-01')) print 'Error in day overflow 4 '.adodb_date('Y-m-d',$t).' <br>';

    359. 

  359. 	$t = adodb_mktime(0,0,0,12,63,1965);

    360. 

  360. 	if (!(adodb_date('Y-m-d',$t) == '1966-02-01')) print 'Error in day overflow 5 '.adodb_date('Y-m-d',$t).' <br>';

    361. 

  361. 	$t = adodb_mktime(0,0,0,13,3,1965);

    362. 

  362. 	if (!(adodb_date('Y-m-d',$t) == '1966-01-03')) print 'Error in mth overflow 1 <br>';

    363. 

  363. 	

    364. 

  364. 	print "Testing 2-digit => 4-digit year conversion<p>";

    365. 

  365. 	if (adodb_year_digit_check(00) != 2000) print "Err 2-digit 2000<br>";

    366. 

  366. 	if (adodb_year_digit_check(10) != 2010) print "Err 2-digit 2010<br>";

    367. 

  367. 	if (adodb_year_digit_check(20) != 2020) print "Err 2-digit 2020<br>";

    368. 

  368. 	if (adodb_year_digit_check(30) != 2030) print "Err 2-digit 2030<br>";

    369. 

  369. 	if (adodb_year_digit_check(40) != 1940) print "Err 2-digit 1940<br>";

    370. 

  370. 	if (adodb_year_digit_check(50) != 1950) print "Err 2-digit 1950<br>";

    371. 

  371. 	if (adodb_year_digit_check(90) != 1990) print "Err 2-digit 1990<br>";

    372. 

  372. 	

    373. 

  373. 	// Test string formating

    374. 

  374. 	print "<p>Testing date formating</p>";

    375. 

  375. 	$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\C822 r s t U w y Y z Z 2003';

    376. 

  376. 	$s1 = date($fmt,0);

    377. 

  377. 	$s2 = adodb_date($fmt,0);

    378. 

  378. 	if ($s1 != $s2) {

    379. 

  379. 		print " date() 0 failed<br>$s1<br>$s2<br>";

    380. 

  380. 	}

    381. 

  381. 	flush();

    382. 

  382. 	for ($i=100; --$i > 0; ) {

    383. 

  383. 

    384. 

  384. 		$ts = 3600.0*((rand()%60000)+(rand()%60000))+(rand()%60000);

    385. 

  385. 		$s1 = date($fmt,$ts);

    386. 

  386. 		$s2 = adodb_date($fmt,$ts);

    387. 

  387. 		//print "$s1 <br>$s2 <p>";

    388. 

  388. 		$pos = strcmp($s1,$s2);

    389. 

  389. 

    390. 

  390. 		if (($s1) != ($s2)) {

    391. 

  391. 			for ($j=0,$k=strlen($s1); $j < $k; $j++) {

    392. 

  392. 				if ($s1[$j] != $s2[$j]) {

    393. 

  393. 					print substr($s1,$j).' ';

    394. 

  394. 					break;

    395. 

  395. 				}

    396. 

  396. 			}

    397. 

  397. 			print "<b>Error date(): $ts<br><pre> 

    398. 

  398. &nbsp; \"$s1\" (date len=".strlen($s1).")

    399. 

  399. &nbsp; \"$s2\" (adodb_date len=".strlen($s2).")</b></pre><br>";

    400. 

  400. 			$fail = true;

    401. 

  401. 		}

    402. 

  402. 		

    403. 

  403. 		$a1 = getdate($ts);

    404. 

  404. 		$a2 = adodb_getdate($ts);

    405. 

  405. 		$rez = array_diff($a1,$a2);

    406. 

  406. 		if (sizeof($rez)>0) {

    407. 

  407. 			print "<b>Error getdate() $ts</b><br>";

    408. 

  408. 				print_r($a1);

    409. 

  409. 			print "<br>";

    410. 

  410. 				print_r($a2);

    411. 

  411. 			print "<p>";

    412. 

  412. 			$fail = true;

    413. 

  413. 		}

    414. 

  414. 	}

    415. 

  415. 	

    416. 

  416. 	// Test generation of dates outside 1901-2038

    417. 

  417. 	print "<p>Testing random dates between 100 and 4000</p>";

    418. 

  418. 	adodb_date_test_date(100,1);

    419. 

  419. 	for ($i=100; --$i >= 0;) {

    420. 

  420. 		$y1 = 100+rand(0,1970-100);

    421. 

  421. 		$m = rand(1,12);

    422. 

  422. 		adodb_date_test_date($y1,$m);

    423. 

  423. 		

    424. 

  424. 		$y1 = 3000-rand(0,3000-1970);

    425. 

  425. 		adodb_date_test_date($y1,$m);

    426. 

  426. 	}

    427. 

  427. 	print '<p>';

    428. 

  428. 	$start = 1960+rand(0,10);

    429. 

  429. 	$yrs = 12;

    430. 

  430. 	$i = 365.25*86400*($start-1970);

    431. 

  431. 	$offset = 36000+rand(10000,60000);

    432. 

  432. 	$max = 365*$yrs*86400;

    433. 

  433. 	$lastyear = 0;

    434. 

  434. 	

    435. 

  435. 	// we generate a timestamp, convert it to a date, and convert it back to a timestamp

    436. 

  436. 	// and check if the roundtrip broke the original timestamp value.

    437. 

  437. 	print "Testing $start to ".($start+$yrs).", or $max seconds, offset=$offset: ";

    438. 

  438. 	$cnt = 0;

    439. 

  439. 	for ($max += $i; $i < $max; $i += $offset) {

    440. 

  440. 		$ret = adodb_date('m,d,Y,H,i,s',$i);

    441. 

  441. 		$arr = explode(',',$ret);

    442. 

  442. 		if ($lastyear != $arr[2]) {

    443. 

  443. 			$lastyear = $arr[2];

    444. 

  444. 			print " $lastyear ";

    445. 

  445. 			flush();

    446. 

  446. 		}

    447. 

  447. 		$newi = adodb_mktime($arr[3],$arr[4],$arr[5],$arr[0],$arr[1],$arr[2]);

    448. 

  448. 		if ($i != $newi) {

    449. 

  449. 			print "Error at $i, adodb_mktime returned $newi ($ret)";

    450. 

  450. 			$fail = true;

    451. 

  451. 			break;

    452. 

  452. 		}

    453. 

  453. 		$cnt += 1;

    454. 

  454. 	}

    455. 

  455. 	echo "Tested $cnt dates<br>";

    456. 

  456. 	if (!$fail) print "<p>Passed !</p>";

    457. 

  457. 	else print "<p><b>Failed</b> :-(</p>";

    458. 

  458. }

    459. 

  459. 

    460. 

  460. /**

    461. 

  461. 	Returns day of week, 0 = Sunday,... 6=Saturday. 

    462. 

  462. 	Algorithm from PEAR::Date_Calc

    463. 

  463. */

    464. 

  464. function adodb_dow($year, $month, $day)

    465. 

  465. {

    466. 

  466. /*

    467. 

  467. Pope Gregory removed 10 days - October 5 to October 14 - from the year 1582 and 

    468. 

  468. proclaimed that from that time onwards 3 days would be dropped from the calendar 

    469. 

  469. every 400 years.

    470. 

  470. 

    471. 

  471. Thursday, October 4, 1582 (Julian) was followed immediately by Friday, October 15, 1582 (Gregorian). 

    472. 

  472. */

    473. 

  473. 	if ($year <= 1582) {

    474. 

  474. 		if ($year < 1582 || 

    475. 

  475. 			($year == 1582 && ($month < 10 || ($month == 10 && $day < 15)))) $greg_correction = 3;

    476. 

  476. 		 else

    477. 

  477. 			$greg_correction = 0;

    478. 

  478. 	} else

    479. 

  479. 		$greg_correction = 0;

    480. 

  480. 	

    481. 

  481. 	if($month > 2)

    482. 

  482. 	    $month -= 2;

    483. 

  483. 	else {

    484. 

  484. 	    $month += 10;

    485. 

  485. 	    $year--;

    486. 

  486. 	}

    487. 

  487. 	

    488. 

  488. 	$day =  ( floor((13 * $month - 1) / 5) +

    489. 

  489. 	        $day + ($year % 100) +

    490. 

  490. 	        floor(($year % 100) / 4) +

    491. 

  491. 	        floor(($year / 100) / 4) - 2 *

    492. 

  492. 	        floor($year / 100) + 77);

    493. 

  493. 	

    494. 

  494. 	return (($day - 7 * floor($day / 7))) + $greg_correction;

    495. 

  495. }

    496. 

  496. 

    497. 

  497. 

    498. 

  498. /**

    499. 

  499.  Checks for leap year, returns true if it is. No 2-digit year check. Also 

    500. 

  500.  handles julian calendar correctly.

    501. 

  501. */

    502. 

  502. function _adodb_is_leap_year($year) 

    503. 

  503. {

    504. 

  504. 	if ($year % 4 != 0) return false;

    505. 

  505. 	

    506. 

  506. 	if ($year % 400 == 0) {

    507. 

  507. 		return true;

    508. 

  508. 	// if gregorian calendar (>1582), century not-divisible by 400 is not leap

    509. 

  509. 	} else if ($year > 1582 && $year % 100 == 0 ) {

    510. 

  510. 		return false;

    511. 

  511. 	} 

    512. 

  512. 	

    513. 

  513. 	return true;

    514. 

  514. }

    515. 

  515. 

    516. 

  516. /**

    517. 

  517.  checks for leap year, returns true if it is. Has 2-digit year check

    518. 

  518. */

    519. 

  519. function adodb_is_leap_year($year) 

    520. 

  520. {

    521. 

  521. 	return  _adodb_is_leap_year(adodb_year_digit_check($year));

    522. 

  522. }

    523. 

  523. 

    524. 

  524. /**

    525. 

  525. 	Fix 2-digit years. Works for any century.

    526. 

  526.  	Assumes that if 2-digit is more than 30 years in future, then previous century.

    527. 

  527. */

    528. 

  528. function adodb_year_digit_check($y) 

    529. 

  529. {

    530. 

  530. 	if ($y < 100) {

    531. 

  531. 	

    532. 

  532. 		$yr = (integer) date("Y");

    533. 

  533. 		$century = (integer) ($yr /100);

    534. 

  534. 		

    535. 

  535. 		if ($yr%100 > 50) {

    536. 

  536. 			$c1 = $century + 1;

    537. 

  537. 			$c0 = $century;

    538. 

  538. 		} else {

    539. 

  539. 			$c1 = $century;

    540. 

  540. 			$c0 = $century - 1;

    541. 

  541. 		}

    542. 

  542. 		$c1 *= 100;

    543. 

  543. 		// if 2-digit year is less than 30 years in future, set it to this century

    544. 

  544. 		// otherwise if more than 30 years in future, then we set 2-digit year to the prev century.

    545. 

  545. 		if (($y + $c1) < $yr+30) $y = $y + $c1;

    546. 

  546. 		else $y = $y + $c0*100;

    547. 

  547. 	}

    548. 

  548. 	return $y;

    549. 

  549. }

    550. 

  550. 

    551. 

  551. /**

    552. 

  552.  get local time zone offset from GMT

    553. 

  553. */

    554. 

  554. function adodb_get_gmt_diff() 

    555. 

  555. {

    556. 

  556. static $TZ;

    557. 

  557. 	if (isset($TZ)) return $TZ;

    558. 

  558. 	

    559. 

  559. 	$TZ = mktime(0,0,0,1,2,1970,0) - gmmktime(0,0,0,1,2,1970,0);

    560. 

  560. 	return $TZ;

    561. 

  561. }

    562. 

  562. 

    563. 

  563. /**

    564. 

  564. 	Returns an array with date info.

    565. 

  565. */

    566. 

  566. function adodb_getdate($d=false,$fast=false)

    567. 

  567. {

    568. 

  568. 	if ($d === false) return getdate();

    569. 

  569. 	if (!defined('ADODB_TEST_DATES')) {

    570. 

  570. 		if ((abs($d) <= 0x7FFFFFFF)) { // check if number in 32-bit signed range

    571. 

  571. 			if (!defined('ADODB_NO_NEGATIVE_TS') || $d >= 0) // if windows, must be +ve integer

    572. 

  572. 				return @getdate($d);

    573. 

  573. 		}

    574. 

  574. 	}

    575. 

  575. 	return _adodb_getdate($d);

    576. 

  576. }

    577. 

  577. 

    578. 

  578. /**

    579. 

  579. 	Low-level function that returns the getdate() array. We have a special

    580. 

  580. 	$fast flag, which if set to true, will return fewer array values,

    581. 

  581. 	and is much faster as it does not calculate dow, etc.

    582. 

  582. */

    583. 

  583. function _adodb_getdate($origd=false,$fast=false,$is_gmt=false)

    584. 

  584. {

    585. 

  585. 	$d =  $origd - ($is_gmt ? 0 : adodb_get_gmt_diff());

    586. 

  586. 	

    587. 

  587. 	$_day_power = 86400;

    588. 

  588. 	$_hour_power = 3600;

    589. 

  589. 	$_min_power = 60;

    590. 

  590. 	

    591. 

  591. 	if ($d < -12219321600) $d -= 86400*10; // if 15 Oct 1582 or earlier, gregorian correction 

    592. 

  592. 	

    593. 

  593. 	$_month_table_normal = array("",31,28,31,30,31,30,31,31,30,31,30,31);

    594. 

  594. 	$_month_table_leaf = array("",31,29,31,30,31,30,31,31,30,31,30,31);

    595. 

  595. 	

    596. 

  596. 	$d366 = $_day_power * 366;

    597. 

  597. 	$d365 = $_day_power * 365;

    598. 

  598. 	

    599. 

  599. 	if ($d < 0) {

    600. 

  600. 		$origd = $d;

    601. 

  601. 		// The valid range of a 32bit signed timestamp is typically from 

    602. 

  602. 		// Fri, 13 Dec 1901 20:45:54 GMT to Tue, 19 Jan 2038 03:14:07 GMT

    603. 

  603. 		for ($a = 1970 ; --$a >= 0;) {

    604. 

  604. 			$lastd = $d;

    605. 

  605. 			

    606. 

  606. 			if ($leaf = _adodb_is_leap_year($a)) $d += $d366;

    607. 

  607. 			else $d += $d365;

    608. 

  608. 			

    609. 

  609. 			if ($d >= 0) {

    610. 

  610. 				$year = $a;

    611. 

  611. 				break;

    612. 

  612. 			}

    613. 

  613. 		}

    614. 

  614. 		

    615. 

  615. 		$secsInYear = 86400 * ($leaf ? 366 : 365) + $lastd;

    616. 

  616. 		

    617. 

  617. 		$d = $lastd;

    618. 

  618. 		$mtab = ($leaf) ? $_month_table_leaf : $_month_table_normal;

    619. 

  619. 		for ($a = 13 ; --$a > 0;) {

    620. 

  620. 			$lastd = $d;

    621. 

  621. 			$d += $mtab[$a] * $_day_power;

    622. 

  622. 			if ($d >= 0) {

    623. 

  623. 				$month = $a;

    624. 

  624. 				$ndays = $mtab[$a];

    625. 

  625. 				break;

    626. 

  626. 			}

    627. 

  627. 		}

    628. 

  628. 		

    629. 

  629. 		$d = $lastd;

    630. 

  630. 		$day = $ndays + ceil(($d+1) / ($_day_power));

    631. 

  631. 

    632. 

  632. 		$d += ($ndays - $day+1)* $_day_power;

    633. 

  633. 		$hour = floor($d/$_hour_power);

    634. 

  634. 	

    635. 

  635. 	} else {

    636. 

  636. 		for ($a = 1970 ;; $a++) {

    637. 

  637. 			$lastd = $d;

    638. 

  638. 			

    639. 

  639. 			if ($leaf = _adodb_is_leap_year($a)) $d -= $d366;

    640. 

  640. 			else $d -= $d365;

    641. 

  641. 			if ($d < 0) {

    642. 

  642. 				$year = $a;

    643. 

  643. 				break;

    644. 

  644. 			}

    645. 

  645. 		}

    646. 

  646. 		$secsInYear = $lastd;

    647. 

  647. 		$d = $lastd;

    648. 

  648. 		$mtab = ($leaf) ? $_month_table_leaf : $_month_table_normal;

    649. 

  649. 		for ($a = 1 ; $a <= 12; $a++) {

    650. 

  650. 			$lastd = $d;

    651. 

  651. 			$d -= $mtab[$a] * $_day_power;

    652. 

  652. 			if ($d < 0) {

    653. 

  653. 				$month = $a;

    654. 

  654. 				$ndays = $mtab[$a];

    655. 

  655. 				break;

    656. 

  656. 			}

    657. 

  657. 		}

    658. 

  658. 		$d = $lastd;

    659. 

  659. 		$day = ceil(($d+1) / $_day_power);

    660. 

  660. 		$d = $d - ($day-1) * $_day_power;

    661. 

  661. 		$hour = floor($d /$_hour_power);

    662. 

  662. 	}

    663. 

  663. 	

    664. 

  664. 	$d -= $hour * $_hour_power;

    665. 

  665. 	$min = floor($d/$_min_power);

    666. 

  666. 	$secs = $d - $min * $_min_power;

    667. 

  667. 	if ($fast) {

    668. 

  668. 		return array(

    669. 

  669. 		'seconds' => $secs,

    670. 

  670. 		'minutes' => $min,

    671. 

  671. 		'hours' => $hour,

    672. 

  672. 		'mday' => $day,

    673. 

  673. 		'mon' => $month,

    674. 

  674. 		'year' => $year,

    675. 

  675. 		'yday' => floor($secsInYear/$_day_power),

    676. 

  676. 		'leap' => $leaf,

    677. 

  677. 		'ndays' => $ndays

    678. 

  678. 		);

    679. 

  679. 	}

    680. 

  680. 	

    681. 

  681. 	

    682. 

  682. 	$dow = adodb_dow($year,$month,$day);

    683. 

  683. 

    684. 

  684. 	return array(

    685. 

  685. 		'seconds' => $secs,

    686. 

  686. 		'minutes' => $min,

    687. 

  687. 		'hours' => $hour,

    688. 

  688. 		'mday' => $day,

    689. 

  689. 		'wday' => $dow,

    690. 

  690. 		'mon' => $month,

    691. 

  691. 		'year' => $year,

    692. 

  692. 		'yday' => floor($secsInYear/$_day_power),

    693. 

  693. 		'weekday' => gmdate('l',$_day_power*(3+$dow)),

    694. 

  694. 		'month' => gmdate('F',mktime(0,0,0,$month,2,1971)),

    695. 

  695. 		0 => $origd

    696. 

  696. 	);

    697. 

  697. }

    698. 

  698. 

    699. 

  699. function adodb_gmdate($fmt,$d=false)

    700. 

  700. {

    701. 

  701. 	return adodb_date($fmt,$d,true);

    702. 

  702. }

    703. 

  703. 

    704. 

  704. // accepts unix timestamp and iso date format in $d

    705. 

  705. function adodb_date2($fmt, $d=false, $is_gmt=false)

    706. 

  706. {

    707. 

  707. 	if ($d !== false) {

    708. 

  708. 		if (!preg_match( 

    709. 

  709. 			"|^([0-9]{4})[-/\.]?([0-9]{1,2})[-/\.]?([0-9]{1,2})[ -]?(([0-9]{1,2}):?([0-9]{1,2}):?([0-9\.]{1,4}))?|", 

    710. 

  710. 			($d), $rr)) return adodb_date($fmt,false,$is_gmt);

    711. 

  711. 

    712. 

  712. 		if ($rr[1] <= 100 && $rr[2]<= 1) return adodb_date($fmt,false,$is_gmt);

    713. 

  713. 	

    714. 

  714. 		// h-m-s-MM-DD-YY

    715. 

  715. 		if (!isset($rr[5])) $d = adodb_mktime(0,0,0,$rr[2],$rr[3],$rr[1]);

    716. 

  716. 		else $d = @adodb_mktime($rr[5],$rr[6],$rr[7],$rr[2],$rr[3],$rr[1]);

    717. 

  717. 	}

    718. 

  718. 	

    719. 

  719. 	return adodb_date($fmt,$d,$is_gmt);

    720. 

  720. }

    721. 

  721. 

    722. 

  722. 

    723. 

  723. /**

    724. 

  724. 	Return formatted date based on timestamp $d

    725. 

  725. */

    726. 

  726. function adodb_date($fmt,$d=false,$is_gmt=false)

    727. 

  727. {

    728. 

  728. static $daylight;

    729. 

  729. 

    730. 

  730. 	if ($d === false) return ($is_gmt)? @gmdate($fmt): @date($fmt);

    731. 

  731. 	if (!defined('ADODB_TEST_DATES')) {

    732. 

  732. 		if ((abs($d) <= 0x7FFFFFFF)) { // check if number in 32-bit signed range

    733. 

  733. 			if (!defined('ADODB_NO_NEGATIVE_TS') || $d >= 0) // if windows, must be +ve integer

    734. 

  734. 				return ($is_gmt)? @gmdate($fmt,$d): @date($fmt,$d);

    735. 

  735. 

    736. 

  736. 		}

    737. 

  737. 	}

    738. 

  738. 	$_day_power = 86400;

    739. 

  739. 	

    740. 

  740. 	$arr = _adodb_getdate($d,true,$is_gmt);

    741. 

  741. 	if (!isset($daylight)) $daylight = function_exists('adodb_daylight_sv');

    742. 

  742. 	if ($daylight) adodb_daylight_sv($arr, $is_gmt);

    743. 

  743. 	

    744. 

  744. 	$year = $arr['year'];

    745. 

  745. 	$month = $arr['mon'];

    746. 

  746. 	$day = $arr['mday'];

    747. 

  747. 	$hour = $arr['hours'];

    748. 

  748. 	$min = $arr['minutes'];

    749. 

  749. 	$secs = $arr['seconds'];

    750. 

  750. 	

    751. 

  751. 	$max = strlen($fmt);

    752. 

  752. 	$dates = '';

    753. 

  753. 	

    754. 

  754. 	/*

    755. 

  755. 		at this point, we have the following integer vars to manipulate:

    756. 

  756. 		$year, $month, $day, $hour, $min, $secs

    757. 

  757. 	*/

    758. 

  758. 	for ($i=0; $i < $max; $i++) {

    759. 

  759. 		switch($fmt[$i]) {

    760. 

  760. 		case 'T': $dates .= date('T');break;

    761. 

  761. 		// YEAR

    762. 

  762. 		case 'L': $dates .= $arr['leap'] ? '1' : '0'; break;

    763. 

  763. 		case 'r': // Thu, 21 Dec 2000 16:01:07 +0200

    764. 

  764. 		

    765. 

  765. 			$dates .= gmdate('D',$_day_power*(3+adodb_dow($year,$month,$day))).', '		

    766. 

  766. 				. ($day<10?' '.$day:$day) . ' '.date('M',mktime(0,0,0,$month,2,1971)).' '.$year.' ';

    767. 

  767. 			

    768. 

  768. 			if ($hour < 10) $dates .= '0'.$hour; else $dates .= $hour; 

    769. 

  769. 			

    770. 

  770. 			if ($min < 10) $dates .= ':0'.$min; else $dates .= ':'.$min;

    771. 

  771. 			

    772. 

  772. 			if ($secs < 10) $dates .= ':0'.$secs; else $dates .= ':'.$secs;

    773. 

  773. 			

    774. 

  774. 			$gmt = adodb_get_gmt_diff();

    775. 

  775. 			$dates .= sprintf(' %s%04d',($gmt<0)?'+':'-',abs($gmt)/36); break;

    776. 

  776. 				

    777. 

  777. 		case 'Y': $dates .= $year; break;

    778. 

  778. 		case 'y': $dates .= substr($year,strlen($year)-2,2); break;

    779. 

  779. 		// MONTH

    780. 

  780. 		case 'm': if ($month<10) $dates .= '0'.$month; else $dates .= $month; break;

    781. 

  781. 		case 'Q': $dates .= ($month+3)>>2; break;

    782. 

  782. 		case 'n': $dates .= $month; break;

    783. 

  783. 		case 'M': $dates .= date('M',mktime(0,0,0,$month,2,1971)); break;

    784. 

  784. 		case 'F': $dates .= date('F',mktime(0,0,0,$month,2,1971)); break;

    785. 

  785. 		// DAY

    786. 

  786. 		case 't': $dates .= $arr['ndays']; break;

    787. 

  787. 		case 'z': $dates .= $arr['yday']; break;

    788. 

  788. 		case 'w': $dates .= adodb_dow($year,$month,$day); break;

    789. 

  789. 		case 'l': $dates .= gmdate('l',$_day_power*(3+adodb_dow($year,$month,$day))); break;

    790. 

  790. 		case 'D': $dates .= gmdate('D',$_day_power*(3+adodb_dow($year,$month,$day))); break;

    791. 

  791. 		case 'j': $dates .= $day; break;

    792. 

  792. 		case 'd': if ($day<10) $dates .= '0'.$day; else $dates .= $day; break;

    793. 

  793. 		case 'S': 

    794. 

  794. 			$d10 = $day % 10;

    795. 

  795. 			if ($d10 == 1) $dates .= 'st';

    796. 

  796. 			else if ($d10 == 2 && $day != 12) $dates .= 'nd';

    797. 

  797. 			else if ($d10 == 3) $dates .= 'rd';

    798. 

  798. 			else $dates .= 'th';

    799. 

  799. 			break;

    800. 

  800. 			

    801. 

  801. 		// HOUR

    802. 

  802. 		case 'Z':

    803. 

  803. 			$dates .= ($is_gmt) ? 0 : -adodb_get_gmt_diff(); break;

    804. 

  804. 		case 'O': 

    805. 

  805. 			$gmt = ($is_gmt) ? 0 : adodb_get_gmt_diff();

    806. 

  806. 			$dates .= sprintf('%s%04d',($gmt<0)?'+':'-',abs($gmt)/36); break;

    807. 

  807. 			

    808. 

  808. 		case 'H': 

    809. 

  809. 			if ($hour < 10) $dates .= '0'.$hour; 

    810. 

  810. 			else $dates .= $hour; 

    811. 

  811. 			break;

    812. 

  812. 		case 'h': 

    813. 

  813. 			if ($hour > 12) $hh = $hour - 12; 

    814. 

  814. 			else {

    815. 

  815. 				if ($hour == 0) $hh = '12'; 

    816. 

  816. 				else $hh = $hour;

    817. 

  817. 			}

    818. 

  818. 			

    819. 

  819. 			if ($hh < 10) $dates .= '0'.$hh;

    820. 

  820. 			else $dates .= $hh;

    821. 

  821. 			break;

    822. 

  822. 			

    823. 

  823. 		case 'G': 

    824. 

  824. 			$dates .= $hour;

    825. 

  825. 			break;

    826. 

  826. 			

    827. 

  827. 		case 'g':

    828. 

  828. 			if ($hour > 12) $hh = $hour - 12; 

    829. 

  829. 			else {

    830. 

  830. 				if ($hour == 0) $hh = '12'; 

    831. 

  831. 				else $hh = $hour; 

    832. 

  832. 			}

    833. 

  833. 			$dates .= $hh;

    834. 

  834. 			break;

    835. 

  835. 		// MINUTES

    836. 

  836. 		case 'i': if ($min < 10) $dates .= '0'.$min; else $dates .= $min; break;

    837. 

  837. 		// SECONDS

    838. 

  838. 		case 'U': $dates .= $d; break;

    839. 

  839. 		case 's': if ($secs < 10) $dates .= '0'.$secs; else $dates .= $secs; break;

    840. 

  840. 		// AM/PM

    841. 

  841. 		// Note 00:00 to 11:59 is AM, while 12:00 to 23:59 is PM

    842. 

  842. 		case 'a':

    843. 

  843. 			if ($hour>=12) $dates .= 'pm';

    844. 

  844. 			else $dates .= 'am';

    845. 

  845. 			break;

    846. 

  846. 		case 'A':

    847. 

  847. 			if ($hour>=12) $dates .= 'PM';

    848. 

  848. 			else $dates .= 'AM';

    849. 

  849. 			break;

    850. 

  850. 		default:

    851. 

  851. 			$dates .= $fmt[$i]; break;

    852. 

  852. 		// ESCAPE

    853. 

  853. 		case "\\": 

    854. 

  854. 			$i++;

    855. 

  855. 			if ($i < $max) $dates .= $fmt[$i];

    856. 

  856. 			break;

    857. 

  857. 		}

    858. 

  858. 	}

    859. 

  859. 	return $dates;

    860. 

  860. }

    861. 

  861. 

    862. 

  862. /**

    863. 

  863. 	Returns a timestamp given a GMT/UTC time. 

    864. 

  864. 	Note that $is_dst is not implemented and is ignored.

    865. 

  865. */

    866. 

  866. function adodb_gmmktime($hr,$min,$sec,$mon=false,$day=false,$year=false,$is_dst=false)

    867. 

  867. {

    868. 

  868. 	return adodb_mktime($hr,$min,$sec,$mon,$day,$year,$is_dst,true);

    869. 

  869. }

    870. 

  870. 

    871. 

  871. /**

    872. 

  872. 	Return a timestamp given a local time. Originally by jackbbs.

    873. 

  873. 	Note that $is_dst is not implemented and is ignored.

    874. 

  874. 	

    875. 

  875. 	Not a very fast algorithm - O(n) operation. Could be optimized to O(1).

    876. 

  876. */

    877. 

  877. function adodb_mktime($hr,$min,$sec,$mon=false,$day=false,$year=false,$is_dst=false,$is_gmt=false) 

    878. 

  878. {

    879. 

  879. 	if (!defined('ADODB_TEST_DATES')) {

    880. 

  880. 		// for windows, we don't check 1970 because with timezone differences, 

    881. 

  881. 		// 1 Jan 1970 could generate negative timestamp, which is illegal

    882. 

  882. 		if (1971 < $year && $year < 2038

    883. 

  883. 			|| $mon === false

    884. 

  884. 			|| !defined('ADODB_NO_NEGATIVE_TS') && (1901 < $year && $year < 2038)

    885. 

  885. 			)

    886. 

  886. 				return $is_gmt?

    887. 

  887. 					@gmmktime($hr,$min,$sec,$mon,$day,$year):

    888. 

  888. 					@mktime($hr,$min,$sec,$mon,$day,$year);

    889. 

  889. 	}

    890. 

  890. 	

    891. 

  891. 	$gmt_different = ($is_gmt) ? 0 : adodb_get_gmt_diff();

    892. 

  892. 	

    893. 

  893. 	$hr = intval($hr);

    894. 

  894. 	$min = intval($min);

    895. 

  895. 	$sec = intval($sec);

    896. 

  896. 	$mon = intval($mon);

    897. 

  897. 	$day = intval($day);

    898. 

  898. 	$year = intval($year);

    899. 

  899. 	

    900. 

  900. 	

    901. 

  901. 	$year = adodb_year_digit_check($year);

    902. 

  902. 	

    903. 

  903. 	if ($mon > 12) {

    904. 

  904. 		$y = floor($mon / 12);

    905. 

  905. 		$year += $y;

    906. 

  906. 		$mon -= $y*12;

    907. 

  907. 	}

    908. 

  908. 	

    909. 

  909. 	$_day_power = 86400;

    910. 

  910. 	$_hour_power = 3600;

    911. 

  911. 	$_min_power = 60;

    912. 

  912. 	

    913. 

  913. 	$_month_table_normal = array("",31,28,31,30,31,30,31,31,30,31,30,31);

    914. 

  914. 	$_month_table_leaf = array("",31,29,31,30,31,30,31,31,30,31,30,31);

    915. 

  915. 	

    916. 

  916. 	$_total_date = 0;

    917. 

  917. 	if ($year >= 1970) {

    918. 

  918. 		for ($a = 1970 ; $a <= $year; $a++) {

    919. 

  919. 			$leaf = _adodb_is_leap_year($a);

    920. 

  920. 			if ($leaf == true) {

    921. 

  921. 				$loop_table = $_month_table_leaf;

    922. 

  922. 				$_add_date = 366;

    923. 

  923. 			} else {

    924. 

  924. 				$loop_table = $_month_table_normal;

    925. 

  925. 				$_add_date = 365;

    926. 

  926. 			}

    927. 

  927. 			if ($a < $year) { 

    928. 

  928. 				$_total_date += $_add_date;

    929. 

  929. 			} else {

    930. 

  930. 				for($b=1;$b<$mon;$b++) {

    931. 

  931. 					$_total_date += $loop_table[$b];

    932. 

  932. 				}

    933. 

  933. 			}

    934. 

  934. 		}

    935. 

  935. 		$_total_date +=$day-1;

    936. 

  936. 		$ret = $_total_date * $_day_power + $hr * $_hour_power + $min * $_min_power + $sec + $gmt_different;

    937. 

  937. 	

    938. 

  938. 	} else {

    939. 

  939. 		for ($a = 1969 ; $a >= $year; $a--) {

    940. 

  940. 			$leaf = _adodb_is_leap_year($a);

    941. 

  941. 			if ($leaf == true) {

    942. 

  942. 				$loop_table = $_month_table_leaf;

    943. 

  943. 				$_add_date = 366;

    944. 

  944. 			} else {

    945. 

  945. 				$loop_table = $_month_table_normal;

    946. 

  946. 				$_add_date = 365;

    947. 

  947. 			}

    948. 

  948. 			if ($a > $year) { $_total_date += $_add_date;

    949. 

  949. 			} else {

    950. 

  950. 				for($b=12;$b>$mon;$b--) {

    951. 

  951. 					$_total_date += $loop_table[$b];

    952. 

  952. 				}

    953. 

  953. 			}

    954. 

  954. 		}

    955. 

  955. 		$_total_date += $loop_table[$mon] - $day;

    956. 

  956. 		

    957. 

  957. 		$_day_time = $hr * $_hour_power + $min * $_min_power + $sec;

    958. 

  958. 		$_day_time = $_day_power - $_day_time;

    959. 

  959. 		$ret = -( $_total_date * $_day_power + $_day_time - $gmt_different);

    960. 

  960. 		if ($ret < -12220185600) $ret += 10*86400; // if earlier than 5 Oct 1582 - gregorian correction

    961. 

  961. 		else if ($ret < -12219321600) $ret = -12219321600; // if in limbo, reset to 15 Oct 1582.

    962. 

  962. 	} 

    963. 

  963. 	//print " dmy=$day/$mon/$year $hr:$min:$sec => " .$ret;

    964. 

  964. 	return $ret;

    965. 

  965. }

    966. 

  966. 

    967. 

  967. ?>
    968.