btime.pas

   1 { Copyright (C) 2005 Bas Steendijk and Peter Green\r
   2   For conditions of distribution and use, see copyright notice in zlib_license.txt\r
   3   which is included in the package\r
   4   ----------------------------------------------------------------------------- }\r
   5 {\r
   6 this unit returns unix timestamp with seconds and microseconds (as float)\r
   7 works on windows/delphi, and on freepascal on unix.\r
   8 }\r
   9 \r
  10 \r
  11 unit btime;\r
  12 {$ifdef fpc}\r
  13   {$mode delphi}\r
  14 {$endif}\r
  15 \r
  16 {$include lcoreconfig.inc}\r
  17 \r
  18 interface\r
  19 \r
  20 {$ifdef mswindows}\r
  21 uses\r
  22   ltimevalstuff;\r
  23 {$endif}  \r
  24 \r
  25 type\r
  26   float=extended;\r
  27   tunixtimeint={$ifdef ver100}longint;{$else}int64;{$endif}\r
  28 \r
  29 const\r
  30   colorburst=39375000/11;  {3579545.4545....}\r
  31 \r
  32 var\r
  33   timezone:integer;\r
  34   timezonestr:string;\r
  35   irctime,unixtime:tunixtimeint;\r
  36   tickcount:integer;\r
  37   settimebias:tunixtimeint;\r
  38   performancecountfreq:extended;\r
  39   btimenowin8:boolean;\r
  40 \r
  41 function irctimefloat:float;\r
  42 function irctimeint:tunixtimeint;\r
  43 \r
  44 //unix timestamp (UTC) float seconds\r
  45 function unixtimefloat:float;\r
  46 function unixtimeint:tunixtimeint;\r
  47 \r
  48 //monotonic float seconds\r
  49 function monotimefloat:float;\r
  50 \r
  51 //monotonic (alias, old function name)\r
  52 function wintimefloat:float;\r
  53 \r
  54 procedure settime(newtime:tunixtimeint);\r
  55 procedure gettimezone;\r
  56 procedure timehandler;\r
  57 procedure init;\r
  58 \r
  59 function timestring(i:tunixtimeint):string;      // Wednesday August 15 2012 -- 16:21:09 +02:00\r
  60 function timestrshort(i:tunixtimeint):string;    // Wed Aug 15 16:21:09 2012\r
  61 function timestriso(i:tunixtimeint):string;      // 2012-08-15 16:21:09\r
  62 function timestrisoutc(i:float):string;          // 2012-08-15T14:21:09.255553Z\r
  63 \r
  64 procedure beginhightimerrate;\r
  65 procedure endhightimerrate;\r
  66 \r
  67 {$ifdef mswindows}\r
  68 function unixtimefloat_systemtime:float;\r
  69 {$endif}\r
  70 \r
  71 function oletounixfloat(t:float):float;\r
  72 function oletounix(t:tdatetime):tunixtimeint;\r
  73 function unixtoole(i:float):tdatetime;\r
  74 \r
  75 {$ifdef mswindows}\r
  76 function mmtimefloat:float;\r
  77 function qpctimefloat:float;\r
  78 {$endif}\r
  79 \r
  80 {$ifdef mswindows}\r
  81 procedure gettimeofday(var tv:ttimeval);\r
  82 {$endif}\r
  83 \r
  84 \r
  85 const\r
  86   mmtime_driftavgsize=32;\r
  87   mmtime_warmupnum=4;\r
  88   mmtime_warmupcyclelength=15;\r
  89 var\r
  90   //this flag is to be set when btime has been running long enough to stabilise\r
  91   warmup_finished:boolean;\r
  92 \r
  93   timefloatbias:float;\r
  94   ticks_freq:float=0;\r
  95   ticks_freq2:float=0;\r
  96   ticks_freq_known:boolean=false;\r
  97   lastunixtimefloat:float=0;\r
  98   lastsynctime:float=0;\r
  99   lastsyncbias:float=0;\r
 100 \r
 101   mmtime_last:integer=0;\r
 102   mmtime_wrapadd:float;\r
 103   mmtime_lastsyncmm:float=0;\r
 104   mmtime_lastsyncqpc:float=0;\r
 105   mmtime_drift:float=1;\r
 106   mmtime_lastresult:float;\r
 107   mmtime_nextdriftcorrection:float;\r
 108   mmtime_driftavg:array[0..mmtime_driftavgsize] of float;\r
 109   mmtime_synchedqpc:boolean;\r
 110 \r
 111   mmtime_prev_drift:float;\r
 112   mmtime_prev_lastsyncmm:float;\r
 113   mmtime_prev_lastsyncqpc:float;\r
 114 \r
 115 implementation\r
 116 \r
 117 \r
 118 \r
 119 uses\r
 120   {$ifdef UNIX}\r
 121     {$ifdef VER1_0}\r
 122       linux,\r
 123     {$else}\r
 124       baseunix,unix,unixutil,sockets, {unixutil and sockets needed by unixstuff.inc on some compiler versions}\r
 125     {$endif}\r
 126     {$ifdef linux}\r
 127       dl,\r
 128     {$endif}\r
 129   {$else}\r
 130     windows,unitsettc,mmsystem,\r
 131   {$endif}\r
 132   sysutils;\r
 133 \r
 134   {$include unixstuff.inc}\r
 135 \r
 136 \r
 137 const\r
 138   daysdifference=25569;\r
 139 \r
 140 function oletounixfloat(t:float):float;\r
 141 begin\r
 142   t := (t - daysdifference) * 86400;\r
 143   result := t;\r
 144 end;\r
 145 \r
 146 function oletounix(t:tdatetime):tunixtimeint;\r
 147 begin\r
 148   result := round(oletounixfloat(t));\r
 149 end;\r
 150 \r
 151 function unixtoole(i:float):tdatetime;\r
 152 begin\r
 153   result := ((i)/86400)+daysdifference;\r
 154 end;\r
 155 \r
 156 const\r
 157   highdwordconst=65536.0 * 65536.0;\r
 158 \r
 159 function utrunc(f:float):integer;\r
 160 {converts float to integer, in 32 bits unsigned range}\r
 161 begin\r
 162   if f >= (highdwordconst/2) then f := f - highdwordconst;\r
 163   result := trunc(f);\r
 164 end;\r
 165 \r
 166 function uinttofloat(i:integer):float;\r
 167 {converts 32 bits unsigned integer to float}\r
 168 begin\r
 169   result := i;\r
 170   if result < 0 then result := result + highdwordconst;\r
 171 end;\r
 172 \r
 173 {$ifdef unix}\r
 174 {-----------------------------------------*nix/freepascal code to read time }\r
 175 \r
 176 function unixtimefloat:float;\r
 177 var\r
 178   tv:ttimeval;\r
 179 begin\r
 180   gettimeofday(tv);\r
 181   result := tv.tv_sec+(tv.tv_usec/1000000);\r
 182 end;\r
 183 \r
 184 {$ifdef linux}\r
 185   {$define monotimefloat_implemented}\r
 186   const\r
 187     CLOCK_MONOTONIC = 1;\r
 188   type \r
 189     ptimeval = ^ttimeval;\r
 190     tclock_gettime = function(clk_id: integer; tp: ptimeval): integer; cdecl;\r
 191 \r
 192   var\r
 193     librt_handle:pointer;\r
 194     librt_inited:boolean;\r
 195     clock_gettime: tclock_gettime;\r
 196 \r
 197   function monotimefloat:float;\r
 198   var\r
 199     ts: ttimeval;\r
 200   begin\r
 201     if not librt_inited then begin\r
 202       librt_inited := true;\r
 203       clock_gettime := nil;\r
 204       librt_handle := dlopen('librt.so', RTLD_LAZY);\r
 205       if assigned(librt_handle) then begin\r
 206         clock_gettime := dlsym(librt_handle, 'clock_gettime');\r
 207       end;\r
 208     end;\r
 209     if assigned(clock_gettime) then begin\r
 210       if clock_gettime(CLOCK_MONOTONIC, @ts) = 0 then begin\r
 211         //note this really returns nanoseconds\r
 212         result := ts.tv_sec + ts.tv_usec / 1000000000.0;\r
 213         exit;\r
 214       end;\r
 215     end;\r
 216     //fallback\r
 217     result := unixtimefloat;\r
 218   end;\r
 219 \r
 220 \r
 221 {$endif} {linux}\r
 222 \r
 223 {$ifdef darwin} {mac OS X}\r
 224 {$define monotimefloat_implemented}\r
 225 \r
 226   type\r
 227     tmach_timebase_info = packed record\r
 228       numer: longint;\r
 229       denom: longint;\r
 230     end;\r
 231     pmach_timebase_info = ^tmach_timebase_info;\r
 232      \r
 233     function mach_absolute_time: int64; cdecl; external;\r
 234     function mach_timebase_info(info: pmach_timebase_info): integer; cdecl; external;\r
 235 \r
 236   var\r
 237     timebase_info: tmach_timebase_info;\r
 238 \r
 239   function monotimefloat:float;\r
 240   var\r
 241     i:int64;\r
 242   begin\r
 243     if timebase_info.denom = 0 then begin\r
 244       mach_timebase_info(@timebase_info);\r
 245     end;\r
 246     i := mach_absolute_time;\r
 247     result := (i * timebase_info.numer div timebase_info.denom) / 1000000000.0;\r
 248   end;\r
 249 \r
 250 {$endif} {darwin, mac OS X}\r
 251 \r
 252 \r
 253 {$ifndef monotimefloat_implemented} {fallback}\r
 254   \r
 255   function monotimefloat:extended;\r
 256   begin\r
 257     result := unixtimefloat;\r
 258   end;\r
 259 \r
 260 {$endif} {monotimefloat fallback}\r
 261 \r
 262 \r
 263 function unixtimeint:tunixtimeint;\r
 264 var\r
 265   tv:ttimeval;\r
 266 begin\r
 267   gettimeofday(tv);\r
 268   result := tv.tv_sec;\r
 269 end;\r
 270 \r
 271 {------------------------------ end of *nix/freepascal section}\r
 272 \r
 273 {$else} {delphi 3}\r
 274 {------------------------------ windows/delphi code to read time}\r
 275 \r
 276 \r
 277 {simulate gettimeofday on windows so one can always use gettimeofday if preferred}\r
 278 \r
 279 procedure gettimeofday(var tv:ttimeval);\r
 280 var\r
 281   e:extended;\r
 282 begin\r
 283   e := unixtimefloat;\r
 284   tv.tv_sec := round(int(e));\r
 285   tv.tv_usec := trunc(frac(e)*1000000);\r
 286   {just in case}\r
 287   if (tv.tv_usec < 0) then tv.tv_usec := 0;\r
 288   if (tv.tv_usec > 999999) then tv.tv_usec := 999999;\r
 289 end;\r
 290 \r
 291 \r
 292 {\r
 293 time float: gettickcount\r
 294 resolution: 9x: ~55 ms NT: 1/64th of a second\r
 295 guarantees: continuous without any jumps\r
 296 frequency base: same as system clock.\r
 297 epoch: system boot\r
 298 note: if called more than once per 49.7 days, 32 bits wrapping is compensated for and it keeps going on.\r
 299 note: i handle the timestamp as signed integer, but with the wrap compensation that works as well, and is faster\r
 300 }\r
 301 \r
 302 function mmtimefloat:float;\r
 303 const\r
 304   wrapduration=highdwordconst * 0.001;\r
 305 var\r
 306   i:integer;\r
 307   temp:float;\r
 308 begin\r
 309   i := gettickcount; {timegettime}\r
 310   if i < mmtime_last then begin\r
 311     mmtime_wrapadd := mmtime_wrapadd + wrapduration;\r
 312   end;\r
 313   mmtime_last := i;\r
 314   result := mmtime_wrapadd + i * 0.001;\r
 315 \r
 316   if (ticks_freq <> 0) and ticks_freq_known then begin\r
 317     {the value we get is rounded to 1 ms, but the ticks are not a multiple of 1 ms\r
 318     this makes the value noisy. use the known ticks frequency to restore the original value}\r
 319     temp := int((result / ticks_freq)+0.5) * ticks_freq;\r
 320 \r
 321     {if the known ticks freq is wrong (can happen), disable the un-rounding behavior\r
 322     this will be a bit less accurate but it prevents problems}\r
 323     if abs(temp - result) > 0.002 then begin\r
 324       ticks_freq := 0;\r
 325     end else result := temp;\r
 326   end;\r
 327 end;\r
 328 \r
 329 procedure measure_ticks_freq;\r
 330 var\r
 331   f,g:float;\r
 332   o:tosversioninfo;\r
 333   isnt:boolean;\r
 334 {  is9x:boolean;}\r
 335   adjust1,adjust2:cardinal;\r
 336   adjustbool:longbool;\r
 337 begin\r
 338   if (performancecountfreq = 0) then qpctimefloat;\r
 339   ticks_freq_known := false;\r
 340   settc;\r
 341   f := mmtimefloat;\r
 342   repeat g := mmtimefloat until g > f;\r
 343   unsettc;\r
 344   f := g - f;\r
 345   fillchar(o,sizeof(o),0);\r
 346   o.dwOSVersionInfoSize := sizeof(o);\r
 347   getversionex(o);\r
 348   isnt := o.dwPlatformId = VER_PLATFORM_WIN32_NT;\r
 349 {  is9x := o.dwPlatformId = VER_PLATFORM_WIN32_WINDOWS;}\r
 350 \r
 351   ticks_freq2 := f;\r
 352   mmtime_synchedqpc := false;\r
 353 \r
 354   if (isnt and (o.dwMajorVersion >= 5)) then begin\r
 355     {windows 2000 and later: query tick rate from OS in 100 ns units\r
 356     typical rates: XP: 156250 or 100144, windows 7: 156001}\r
 357     if GetSystemTimeAdjustment(adjust1,adjust2,adjustbool) then begin\r
 358       ticks_freq := adjust1 / 10000000.0;\r
 359       ticks_freq_known := true;\r
 360       mmtime_synchedqpc := false;\r
 361     end;\r
 362   end;\r
 363 \r
 364   {9x}\r
 365   if (performancecountfreq = 1193182) and (f >= 0.050) and (f <= 0.060) then begin\r
 366     ticks_freq_known := true;\r
 367     ticks_freq := 65536 / (colorburst / 3);\r
 368     mmtime_synchedqpc := true;\r
 369   end;\r
 370   ticks_freq_known := true;\r
 371   if ticks_freq <> 0 then ticks_freq2 := ticks_freq;\r
 372 //  writeln(formatfloat('0.000000',ticks_freq));\r
 373 end;\r
 374 \r
 375 {\r
 376 time float: QueryPerformanceCounter\r
 377 resolution: <1us\r
 378 guarantees: can have forward jumps depending on hardware. can have forward and backwards jitter on dual core.\r
 379 frequency base: on NT, not the system clock, drifts compared to it.\r
 380 epoch: system boot\r
 381 }\r
 382 function qpctimefloat:extended;\r
 383 var\r
 384   p:packed record\r
 385     lowpart:longint;\r
 386     highpart:longint\r
 387   end;\r
 388   p2:tlargeinteger absolute p;\r
 389   e:extended;\r
 390 begin\r
 391   if performancecountfreq = 0 then begin\r
 392     QueryPerformancefrequency(p2);\r
 393     e := p.lowpart;\r
 394     if e < 0 then e := e + highdwordconst;\r
 395     performancecountfreq := ((p.highpart*highdwordconst)+e);\r
 396   end;\r
 397   queryperformancecounter(p2);\r
 398   e := p.lowpart;\r
 399   if e < 0 then e := e + highdwordconst;\r
 400 \r
 401   result := ((p.highpart*highdwordconst)+e)/performancecountfreq;\r
 402 end;\r
 403 \r
 404 {\r
 405 time float: QPC locked to gettickcount\r
 406 resolution: <1us\r
 407 guarantees: continuous without any jumps\r
 408 frequency base: same as system clock.\r
 409 epoch: system boot\r
 410 }\r
 411 \r
 412 function mmqpctimefloat:float;\r
 413 const\r
 414   maxretries=5;\r
 415   margin=0.002;\r
 416 var\r
 417 {  jump:float;}\r
 418   mm,f,qpc,newdrift:float;\r
 419   qpcjumped:boolean;\r
 420   a,b:integer;\r
 421 {  retrycount:integer;}\r
 422 begin\r
 423   if not ticks_freq_known then measure_ticks_freq;\r
 424 {  retrycount := maxretries;}\r
 425 \r
 426   qpc := qpctimefloat;\r
 427   mm := mmtimefloat;\r
 428   f := (qpc - mmtime_lastsyncqpc) * mmtime_drift + mmtime_lastsyncmm;\r
 429   //writeln('XXXX ',formatfloat('0.000000',qpc-mm));\r
 430   qpcjumped := ((f-mm) > ticks_freq2+margin) or ((f-mm) < -margin);\r
 431 //  if qpcjumped then writeln('qpc jumped ',(f-mm));\r
 432   if ((qpc > mmtime_nextdriftcorrection) and not mmtime_synchedqpc) or qpcjumped then begin\r
 433 \r
 434     mmtime_nextdriftcorrection := qpc + 1;\r
 435     repeat\r
 436       mmtime_prev_drift := mmtime_drift;\r
 437       mmtime_prev_lastsyncmm := mmtime_lastsyncmm;\r
 438       mmtime_prev_lastsyncqpc := mmtime_lastsyncqpc;\r
 439 \r
 440       mm := mmtimefloat;\r
 441     {  dec(retrycount);}\r
 442       settc;\r
 443       result := qpctimefloat;\r
 444       f := mmtimefloat;\r
 445       repeat\r
 446         if f = mm then result := qpctimefloat;\r
 447         f := mmtimefloat\r
 448       until f > mm;\r
 449       qpc := qpctimefloat;\r
 450 \r
 451       unsettc;\r
 452       if (qpc > result + 0.0001) then begin\r
 453         continue;\r
 454       end;\r
 455       mm := f;\r
 456 \r
 457       if (mmtime_lastsyncqpc <> 0) and not qpcjumped then begin\r
 458         newdrift := (mm - mmtime_lastsyncmm) / (qpc - mmtime_lastsyncqpc);\r
 459         mmtime_drift := newdrift;\r
 460      {   writeln('raw drift: ',formatfloat('0.00000000',mmtime_drift));}\r
 461         move(mmtime_driftavg[0],mmtime_driftavg[1],sizeof(mmtime_driftavg[0])*high(mmtime_driftavg));\r
 462         mmtime_driftavg[0] := mmtime_drift;\r
 463 \r
 464 {        write('averaging drift ',formatfloat('0.00000000',mmtime_drift),' -> ');}\r
 465 {        mmtime_drift := 0;}\r
 466         b := 0;\r
 467         for a := 0 to high(mmtime_driftavg) do begin\r
 468           if mmtime_driftavg[a] <> 0 then inc(b);\r
 469 {          mmtime_drift := mmtime_drift + mmtime_driftavg[a];}\r
 470         end;\r
 471 {        mmtime_drift := mmtime_drift / b;}\r
 472         a := 5;\r
 473         if (b = 1) then a := 5 else if (b = 2) then a := 15 else if (b = 3) then a := 30 else if (b = 4) then a := 60 else if (b = 5) then a := 120 else if (b >= 5) then a := 120;\r
 474         mmtime_nextdriftcorrection := qpc + a;\r
 475         if (b >= 2) then warmup_finished := true;\r
 476 {        writeln(formatfloat('0.00000000',mmtime_drift));}\r
 477        if mmtime_synchedqpc then mmtime_drift := 1;\r
 478       end;\r
 479 \r
 480       mmtime_lastsyncqpc := qpc;\r
 481       mmtime_lastsyncmm := mm;\r
 482   {   writeln(formatfloat('0.00000000',mmtime_drift));}\r
 483       break;\r
 484     until false;\r
 485 \r
 486 \r
 487     qpc := qpctimefloat;\r
 488 \r
 489     result := (qpc - mmtime_lastsyncqpc) * mmtime_drift + mmtime_lastsyncmm;\r
 490 \r
 491     {f := (qpc - mmtime_prev_lastsyncqpc) * mmtime_prev_drift + mmtime_prev_lastsyncmm;\r
 492     jump := result-f;\r
 493     writeln('jump ',formatfloat('0.000000',jump),'   drift ',formatfloat('0.00000000',mmtime_drift),' duration ',formatfloat('0.000',(mmtime_lastsyncqpc-mmtime_prev_lastsyncqpc)),' ',formatfloat('0.00000000',jump/(mmtime_lastsyncqpc-mmtime_prev_lastsyncqpc)));}\r
 494 \r
 495     f := result;\r
 496   end;\r
 497 \r
 498   result := f;\r
 499 \r
 500   if (result < mmtime_lastresult) then result := mmtime_lastresult;\r
 501   mmtime_lastresult := result;\r
 502 end;\r
 503 \r
 504 { free pascals tsystemtime is incompatible with windows api calls\r
 505  so we declare it ourselves - plugwash\r
 506 }\r
 507 {$ifdef fpc}\r
 508 type\r
 509   TSystemTime = record\r
 510      wYear: Word;\r
 511      wMonth: Word;\r
 512      wDayOfWeek: Word;\r
 513      wDay: Word;\r
 514      wHour: Word;\r
 515      wMinute: Word;\r
 516      wSecond: Word;\r
 517      wMilliseconds: Word;\r
 518   end;\r
 519  {$endif}\r
 520 function Date_utc: extended;\r
 521 var\r
 522   SystemTime: TSystemTime;\r
 523 begin\r
 524   {$ifdef fpc}\r
 525     GetsystemTime(@SystemTime);\r
 526   {$else}\r
 527     GetsystemTime(SystemTime);\r
 528   {$endif}\r
 529   with SystemTime do Result := EncodeDate(wYear, wMonth, wDay);\r
 530 end;\r
 531 \r
 532 function Time_utc: extended;\r
 533 var\r
 534   SystemTime: TSystemTime;\r
 535 begin\r
 536   {$ifdef fpc}\r
 537     GetsystemTime(@SystemTime);\r
 538   {$else}\r
 539     GetsystemTime(SystemTime);\r
 540   {$endif}\r
 541   with SystemTime do\r
 542     Result := EncodeTime(wHour, wMinute, wSecond, wMilliSeconds);\r
 543 end;\r
 544 \r
 545 function Now_utc: extended;\r
 546 begin\r
 547   Result := round(Date_utc) + Time_utc;\r
 548 end;\r
 549 \r
 550 function unixtimefloat_systemtime:float;\r
 551 begin\r
 552   {result := oletounixfloat(now_utc);}\r
 553 \r
 554   {this method gives exactly the same result with extended precision, but is less sensitive to float rounding in theory}\r
 555   result := oletounixfloat(int(date_utc+0.5))+time_utc*86400;\r
 556 end;\r
 557 \r
 558 function monotimefloat:extended;\r
 559 begin\r
 560   result := mmqpctimefloat;\r
 561 end;\r
 562 \r
 563 \r
 564 \r
 565 var\r
 566   GetSystemTimePreciseAsFileTime:procedure(var v:tfiletime); stdcall;\r
 567   win8inited:boolean;\r
 568 \r
 569 procedure initwin8;\r
 570 var\r
 571   dllhandle:thandle;\r
 572 \r
 573 begin\r
 574   win8inited := true;\r
 575   dllhandle := loadlibrary('kernel32.dll');\r
 576   if (dllhandle <> 0) then begin\r
 577     GetSystemTimePreciseAsFileTime := getprocaddress(dllhandle,'GetSystemTimePreciseAsFileTime');\r
 578   end;\r
 579 end;\r
 580 \r
 581 \r
 582 function unixtimefloat_win8:float;\r
 583 var\r
 584   ft:tfiletime;\r
 585   i:int64 absolute ft;\r
 586 begin\r
 587   GetSystemTimePreciseAsFileTime(ft);\r
 588   {change from windows 1601-01-01 to unix 1970-01-01.\r
 589   use integer math for this, to preserve precision}\r
 590   dec(i, 116444736000000000);\r
 591   result := (i / 10000000);\r
 592 end;\r
 593 \r
 594 \r
 595 \r
 596 function unixtimefloat:float;\r
 597 const\r
 598   margin = 0.0012;\r
 599 var\r
 600   f,g,h:float;\r
 601 begin\r
 602   if not btimenowin8 then begin\r
 603     if not win8inited then initwin8;\r
 604     if assigned(@GetSystemTimePreciseAsFileTime) then begin\r
 605       result := unixtimefloat_win8;\r
 606       exit;\r
 607     end;  \r
 608   end;\r
 609 \r
 610   result := monotimefloat+timefloatbias;\r
 611   f := result-unixtimefloat_systemtime;\r
 612   if ((f > ticks_freq2+margin) or (f < -margin)) or (timefloatbias = 0) then begin\r
 613 //    writeln('unixtimefloat init');\r
 614     f := unixtimefloat_systemtime;\r
 615     settc;\r
 616     repeat g := unixtimefloat_systemtime; h := monotimefloat until g > f;\r
 617     unsettc;\r
 618     timefloatbias := g-h;\r
 619     result := unixtimefloat;\r
 620   end;\r
 621 \r
 622   {for small changes backwards, guarantee no steps backwards}\r
 623   if (result <= lastunixtimefloat) and (result > lastunixtimefloat-1.5) then result := lastunixtimefloat + 0.0000001;\r
 624   lastunixtimefloat := result;\r
 625 end;\r
 626 \r
 627 function unixtimeint:tunixtimeint;\r
 628 begin\r
 629   result := trunc(unixtimefloat);\r
 630 end;\r
 631 \r
 632 {$endif}\r
 633 {-----------------------------------------------end of platform specific}\r
 634 \r
 635 function wintimefloat:float;\r
 636 begin\r
 637   result := monotimefloat;\r
 638 end;\r
 639 \r
 640 function irctimefloat:float;\r
 641 begin\r
 642   result := unixtimefloat+settimebias;\r
 643 end;\r
 644 \r
 645 function irctimeint:tunixtimeint;\r
 646 begin\r
 647   result := unixtimeint+settimebias;\r
 648 end;\r
 649 \r
 650 \r
 651 procedure settime(newtime:tunixtimeint);\r
 652 var\r
 653   a:tunixtimeint;\r
 654 begin\r
 655   a := irctimeint-settimebias;\r
 656   if newtime = 0 then settimebias := 0 else settimebias := newtime-a;\r
 657 \r
 658   irctime := irctimeint;\r
 659 end;\r
 660 \r
 661 procedure timehandler;\r
 662 begin\r
 663   if unixtime = 0 then init;\r
 664   unixtime := unixtimeint;\r
 665   irctime := irctimeint;\r
 666   if unixtime and 63 = 0 then begin\r
 667     {update everything, apply timezone changes, clock changes, etc}\r
 668     gettimezone;\r
 669     timefloatbias := 0;\r
 670     unixtime := unixtimeint;\r
 671     irctime := irctimeint;\r
 672   end;\r
 673 end;\r
 674 \r
 675 \r
 676 procedure gettimezone;\r
 677 var\r
 678   {$ifdef UNIX}\r
 679     {$ifndef ver1_9_4}\r
 680       {$ifndef ver1_0}\r
 681         {$define above194}\r
 682       {$endif}\r
 683     {$endif}\r
 684     {$ifndef above194}\r
 685       hh,mm,ss:word;\r
 686     {$endif}\r
 687   {$endif}\r
 688   l:integer;\r
 689 begin\r
 690   {$ifdef UNIX}\r
 691     {$ifdef above194}\r
 692       timezone := tzseconds;\r
 693     {$else}\r
 694       gettime(hh,mm,ss);\r
 695       timezone := (longint(hh) * 3600 + mm * 60 + ss) - (unixtimeint mod 86400);\r
 696     {$endif}\r
 697   {$else}\r
 698   timezone := round((now-now_utc)*86400);\r
 699   {$endif}\r
 700 \r
 701   while timezone > 43200 do dec(timezone,86400);\r
 702   while timezone < -43200 do inc(timezone,86400);\r
 703 \r
 704   if timezone >= 0 then timezonestr := '+' else timezonestr := '-';\r
 705   l := abs(timezone) div 60;\r
 706   timezonestr := timezonestr + char(l div 600 mod 10+48)+char(l div 60 mod 10+48)+':'+char(l div 10 mod 6+48)+char(l mod 10+48);\r
 707 end;\r
 708 \r
 709 function timestrshort(i:tunixtimeint):string;\r
 710 const\r
 711   weekday:array[0..6] of string[4]=('Thu','Fri','Sat','Sun','Mon','Tue','Wed');\r
 712   month:array[0..11] of string[4]=('Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec');\r
 713 var\r
 714   y,m,d,h,min,sec,ms:word;\r
 715   t:tdatetime;\r
 716 begin\r
 717   t := unixtoole(i+timezone);\r
 718   decodedate(t,y,m,d);\r
 719   decodetime(t,h,min,sec,ms);\r
 720   result := weekday[(i+timezone) div 86400 mod 7]+' '+month[m-1]+' '+inttostr(d)+' '+\r
 721   inttostr(h div 10)+inttostr(h mod 10)+':'+inttostr(min div 10)+inttostr(min mod 10)+':'+inttostr(sec div 10)+inttostr(sec mod 10)+' '+\r
 722   inttostr(y);\r
 723 end;\r
 724 \r
 725 function timestring(i:tunixtimeint):string;\r
 726 const\r
 727   weekday:array[0..6] of string[10]=('Thursday','Friday','Saturday','Sunday','Monday','Tuesday','Wednesday');\r
 728   month:array[0..11] of string[10]=('January','February','March','April','May','June','July','August','September','October','November','December');\r
 729 var\r
 730   y,m,d,h,min,sec,ms:word;\r
 731   t:tdatetime;\r
 732 begin\r
 733   t := unixtoole(i+timezone);\r
 734   decodedate(t,y,m,d);\r
 735   decodetime(t,h,min,sec,ms);\r
 736   result := weekday[(i+timezone) div 86400 mod 7]+' '+month[m-1]+' '+inttostr(d)+' '+inttostr(y)+' -- '+\r
 737   inttostr(h div 10)+inttostr(h mod 10)+':'+inttostr(min div 10)+inttostr(min mod 10)+':'+inttostr(sec div 10)+inttostr(sec mod 10)+' '+\r
 738   timezonestr;\r
 739 end;\r
 740 \r
 741 function timestriso(i:tunixtimeint):string;\r
 742 var\r
 743   y,m,d,h,min,sec,ms:word;\r
 744   t:tdatetime;\r
 745 begin\r
 746   t := unixtoole(i+timezone);\r
 747   decodedate(t,y,m,d);\r
 748   decodetime(t,h,min,sec,ms);\r
 749   result := inttostr(y)+'-'+inttostr(m div 10)+inttostr(m mod 10)+'-'+inttostr(d div 10)+inttostr(d mod 10)+' '+inttostr(h div 10)+inttostr(h mod 10)+':'+inttostr(min div 10)+inttostr(min mod 10)+':'+inttostr(sec div 10)+inttostr(sec mod 10);\r
 750 end;\r
 751 \r
 752 function timestrisoutc(i:float):string;\r
 753 var\r
 754   y,m,d,h,min,sec,ms:word;\r
 755   t:tdatetime;\r
 756   fr:float;\r
 757 begin\r
 758   t := unixtoole(i);\r
 759   decodedate(t,y,m,d);\r
 760   decodetime(t,h,min,sec,ms);\r
 761   result := inttostr(y)+'-'+inttostr(m div 10)+inttostr(m mod 10)+'-'+inttostr(d div 10)+inttostr(d mod 10)+'T'+inttostr(h div 10)+inttostr(h mod 10)+':'+inttostr(min div 10)+inttostr(min mod 10)+':'+inttostr(sec div 10)+inttostr(sec mod 10);\r
 762   fr := frac(i);\r
 763 \r
 764   result := result + '.'+\r
 765   inttostr(trunc(fr*10) mod 10)+\r
 766   inttostr(trunc(fr*100) mod 10)+\r
 767   inttostr(trunc(fr*1000) mod 10)+\r
 768   inttostr(trunc(fr*10000) mod 10)+\r
 769   inttostr(trunc(fr*100000) mod 10)+\r
 770   inttostr(trunc(fr*1000000) mod 10)+'Z';\r
 771 \r
 772 end;\r
 773 \r
 774 procedure beginhightimerrate;\r
 775 begin\r
 776   {$ifdef mswindows}timebeginperiod(1);{$endif}\r
 777 end;\r
 778 \r
 779 procedure endhightimerrate;\r
 780 begin\r
 781   {$ifdef mswindows}timeendperiod(1);{$endif}\r
 782 end;\r
 783 \r
 784 procedure init;\r
 785 begin\r
 786   {$ifdef btimehighrate}beginhightimerrate;{$endif}\r
 787   fillchar(mmtime_driftavg,sizeof(mmtime_driftavg),0);\r
 788   settimebias := 0;\r
 789   gettimezone;\r
 790   unixtime := unixtimeint;\r
 791   irctime := irctimeint;\r
 792 end;\r
 793 \r
 794 initialization init;\r
 795 \r
 796 end.\r