MS Windows FILETIME

FILETIME is a 64 bit type for containing a date-time in 100 ns periods elapsed since 1 January 1601 UTC (the "epoch") ¹. The type is made of 2 DWORDs, so is unsigned (no negatives). Microsoft recommends not doing arithmetic with the FILETIME type. They suggest LARGE_INTEGER² or INT64³ That are signed 64 bit types, FILETIME does not use bit 63 (sign bit), so no "acidental" negatives.

The FILETIME page¹ also states "Do not cast a pointer to a FILETIME structure to either a ULARGE_INTEGER or _INT64 value ..." (the PB equivalent is the QUAD). It does not say don't do the reverse. I define a QUAD, and pass its pointer to API functions using FILETIME. Let Windows put the number in a 64 bit variable that is already "aligned". Since I usually lookup the DECLARE statement in the include anyway, I copy it to my source changing it to BYREF var_name AS QUAD (more than 4 API functions is rare for me). (you may change function's name, do not change the ALIAS)

Popup list of FILETIME functions/subs (suggestions for additions to the list will be appreciated), the list.

Table Of "Weights" For Each Bit

The "Human Units" defined by groups of bits. unit steps don't come bit 58 is the most significant of problem for 28804 more years.

 Bit
Number Weight 
00  
01  
02  
03  
04  
05  
06  
07  
08  
09  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62   † is exact ‡ last year of MS FILETIME useing up to &h7FFFFFFFFFFFFFFF All rows of "Human Units" larger unit.

column to help show that time and date are not This is because of decimal numbers and 60, 60, 24 out evenly in binary (always just twice the previous). And though bit for 2024, there will not be a "Year 2K" kind Of Bit
nanoSecondsHuman
Units
(approx.) 100100 ns † 200200 ns † 400400 ns † 800800 ns † 16001.6 µs † 32003.2 µs † 64006.2 µs † 1280012.8 µs † 2560025.6 µs † 5120051.2 µs † 102400102 µs 204800204 µs 409600409 µs 819200819 µs 16384001.63 ms 32768003.27 ms 65536006.55 ms 1310720013.1 ms 2621440026.2 ms 5242880052.4 ms 104857600104 ms 209715200209 ms 419430400419 ms 838860800838 ms 16777216001.67 s 3355443200 6710886400 13421772800 26843545600 536870912000.894 minutes 1073741824001.79 minutes 214748364800 429496729600 858993459200 1717986918400 34359738368000.954 hours 6871947673600 13743895347200 27487790694400 54975581388800 1099511627776001.27 days 219902325555200 439804651110400 8796093022208001.45 weeks 1759218604441600 35184372088832001.32 months 7036874417766400 14073748835532800 28147497671065600 562949953421312001.78 years 112589990684262400 225179981368524800 4503599627370496001.43 decades 900719925474099200 1801439850948198400 36028797018963968001.14 centuries 7205759403792793600 14411518807585587200 28823037615171174400hi bit of 2024 57646075230342348800 115292150460684697600 230584300921369395200 461168601842738790400hi bit of 30827 ‡ and SYSTEMTIME (is a whole year, more times in 30828 by is not supported)

Bit Number	Weight
00
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

column filled till seconds, then only close next

Source Code For Left Two Columns Of Table

The FOR/NEXT stop is not 64 because first bit is named "0". It is not 63 because in a QUAD that is the sign bit, and FILETIME is (should) never be negative (discussed at top of page). BitArray(0) is set to "1" instead of "100" because the QUAD array elements would overflow for last few bits. To show as starting at "100" and times 2 for each, the "00" is appended to the output string build.

'This is console code.
'Console is easier for "one time quickie" than dialog, controls and callback.
#compile exe
#dim all
'
function pbmain () as long
  local BitArray() as quad
  local BitNum as long
  local nSec, LPad as string
  dim BitArray(62)
  BitArray(0) = 1
  for BitNum = 1 to 62
     BitArray(BitNum) = BitArray(BitNum - 1) * 2
  next
  for BitNum = 0 to 62
    nSec = dec$(BitArray(BitNum, 19))
    LPad = space$(20 - len(nSec))
        con.print dec$(BitNum, 2) + LPad + nSec + "00"
  next
  con.waitkey$
end function
'Old syntax works, but "CON." differentiates this code from "TXT.".
'(TXT.WINDOW does not scroll vertically, so is not suitable for this job.)

Backmatter

¹ learn.microsoft ... filetime (opens new window/tab).
² learn.microsoft ... large_integer (opens new window/tab).
³ learn.microsoft ... int64 (opens in a new window/tab).

Created on 20 October 2024.

To Domain Home.

To Dale's Notebook index.

To Programs index.

Bit Number	Weight
00
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

Bit Number	Weight
00
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

Bit Number	Weight
00
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62