FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
netdata/node.d/node_modules/node-int64.js at master · imcom/netdata · GitHub
imcom
/
netdata
Public
forked from
netdata/netdata
Notifications
You must be signed in to change notification settings
Fork
0
Star
0
Code
Pull requests
0
Actions
Projects
Wiki
Security and quality
0
Insights
Additional navigation options
Code
Pull requests
Actions
Projects
Wiki
Security and quality
Insights
Expand file tree
Breadcrumbs
netdata
/
node.d
/
node_modules
/
node-int64.js
Copy path
More file actions
More file actions
Latest commit
History
History
History
268 lines (236 loc) · 7.86 KB
Breadcrumbs
netdata
/
node.d
/
node_modules
/
node-int64.js
Copy path
File metadata and controls
268 lines (236 loc) · 7.86 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
1
2
3
4
5
6
7
8
9
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
// Int64.js
//
// Copyright (c) 2012 Robert Kieffer
// MIT License - http://opensource.org/licenses/mit-license.php
/**
* Support for handling 64-bit int numbers in Javascript (node.js)
*
* JS Numbers are IEEE-754 binary double-precision floats, which limits the
* range of values that can be represented with integer precision to:
*
* 2^^53 <= N <= 2^53
*
* Int64 objects wrap a node Buffer that holds the 8-bytes of int64 data. These
* objects operate directly on the buffer which means that if they are created
* using an existing buffer then setting the value will modify the Buffer, and
* vice-versa.
*
* Internal Representation
*
* The internal buffer format is Big Endian. I.e. the most-significant byte is
* at buffer[0], the least-significant at buffer[7]. For the purposes of
* converting to/from JS native numbers, the value is assumed to be a signed
* integer stored in 2's complement form.
*
* For details about IEEE-754 see:
* http://en.wikipedia.org/wiki/Double_precision_floating-point_format
*/
// Useful masks and values for bit twiddling
var
MASK31
=
0x7fffffff
,
VAL31
=
0x80000000
;
var
MASK32
=
0xffffffff
,
VAL32
=
0x100000000
;
// Map for converting hex octets to strings
var
_HEX
=
[
]
;
for
(
var
i
=
0
;
i
<
256
;
i
++
)
{
_HEX
[
i
]
=
(
i
>
0xF
?
''
:
'0'
)
+
i
.
toString
(
16
)
;
}
//
// Int64
//
/**
* Constructor accepts any of the following argument types:
*
* new Int64(buffer[, offset=0]) - Existing Buffer with byte offset
* new Int64(Uint8Array[, offset=0]) - Existing Uint8Array with a byte offset
* new Int64(string) - Hex string (throws if n is outside int64 range)
* new Int64(number) - Number (throws if n is outside int64 range)
* new Int64(hi, lo) - Raw bits as two 32-bit values
*/
var
Int64
=
module
.
exports
=
function
(
a1
,
a2
)
{
if
(
a1
instanceof
Buffer
)
{
this
.
buffer
=
a1
;
this
.
offset
=
a2
||
0
;
}
else
if
(
Object
.
prototype
.
toString
.
call
(
a1
)
==
'[object Uint8Array]'
)
{
// Under Browserify, Buffers can extend Uint8Arrays rather than an
// instance of Buffer. We could assume the passed in Uint8Array is actually
// a buffer but that won't handle the case where a raw Uint8Array is passed
// in. We construct a new Buffer just in case.
this
.
buffer
=
new
Buffer
(
a1
)
;
this
.
offset
=
a2
||
0
;
}
else
{
this
.
buffer
=
this
.
buffer
||
new
Buffer
(
8
)
;
this
.
offset
=
0
;
this
.
setValue
.
apply
(
this
,
arguments
)
;
}
}
;
// Max integer value that JS can accurately represent
Int64
.
MAX_INT
=
Math
.
pow
(
2
,
53
)
;
// Min integer value that JS can accurately represent
Int64
.
MIN_INT
=
-
Math
.
pow
(
2
,
53
)
;
Int64
.
prototype
=
{
constructor
:
Int64
,
/**
* Do in-place 2's compliment. See
* http://en.wikipedia.org/wiki/Two's_complement
*/
_2scomp
:
function
(
)
{
var
b
=
this
.
buffer
,
o
=
this
.
offset
,
carry
=
1
;
for
(
var
i
=
o
+
7
;
i
>=
o
;
i
--
)
{
var
v
=
(
b
[
i
]
^
0xff
)
+
carry
;
b
[
i
]
=
v
&
0xff
;
carry
=
v
>>
8
;
}
}
,
/**
* Set the value. Takes any of the following arguments:
*
* setValue(string) - A hexidecimal string
* setValue(number) - Number (throws if n is outside int64 range)
* setValue(hi, lo) - Raw bits as two 32-bit values
*/
setValue
:
function
(
hi
,
lo
)
{
var
negate
=
false
;
if
(
arguments
.
length
==
1
)
{
if
(
typeof
(
hi
)
==
'number'
)
{
// Simplify bitfield retrieval by using abs() value. We restore sign
// later
negate
=
hi
<
0
;
hi
=
Math
.
abs
(
hi
)
;
lo
=
hi
%
VAL32
;
hi
=
hi
/
VAL32
;
if
(
hi
>
VAL32
)
throw
new
RangeError
(
hi
+
' is outside Int64 range'
)
;
hi
=
hi
|
0
;
}
else
if
(
typeof
(
hi
)
==
'string'
)
{
hi
=
(
hi
+
''
)
.
replace
(
/
^
0
x
/
,
''
)
;
lo
=
hi
.
substr
(
-
8
)
;
hi
=
hi
.
length
>
8
?
hi
.
substr
(
0
,
hi
.
length
-
8
)
:
''
;
hi
=
parseInt
(
hi
,
16
)
;
lo
=
parseInt
(
lo
,
16
)
;
}
else
{
throw
new
Error
(
hi
+
' must be a Number or String'
)
;
}
}
// Technically we should throw if hi or lo is outside int32 range here, but
// it's not worth the effort. Anything past the 32'nd bit is ignored.
// Copy bytes to buffer
var
b
=
this
.
buffer
,
o
=
this
.
offset
;
for
(
var
i
=
7
;
i
>=
0
;
i
--
)
{
b
[
o
+
i
]
=
lo
&
0xff
;
lo
=
i
==
4
?
hi
:
lo
>>>
8
;
}
// Restore sign of passed argument
if
(
negate
)
this
.
_2scomp
(
)
;
}
,
/**
* Convert to a native JS number.
*
* WARNING: Do not expect this value to be accurate to integer precision for
* large (positive or negative) numbers!
*
*
@param
allowImprecise If true, no check is performed to verify the
* returned value is accurate to integer precision. If false, imprecise
* numbers (very large positive or negative numbers) will be forced to +/-
* Infinity.
*/
toNumber
:
function
(
allowImprecise
)
{
var
b
=
this
.
buffer
,
o
=
this
.
offset
;
// Running sum of octets, doing a 2's complement
var
negate
=
b
[
o
]
&
0x80
,
x
=
0
,
carry
=
1
;
for
(
var
i
=
7
,
m
=
1
;
i
>=
0
;
i
--
,
m
*=
256
)
{
var
v
=
b
[
o
+
i
]
;
// 2's complement for negative numbers
if
(
negate
)
{
v
=
(
v
^
0xff
)
+
carry
;
carry
=
v
>>
8
;
v
=
v
&
0xff
;
}
x
+=
v
*
m
;
}
// Return Infinity if we've lost integer precision
if
(
!
allowImprecise
&&
x
>=
Int64
.
MAX_INT
)
{
return
negate
?
-
Infinity
:
Infinity
;
}
return
negate
?
-
x
:
x
;
}
,
/**
* Convert to a JS Number. Returns +/-Infinity for values that can't be
* represented to integer precision.
*/
valueOf
:
function
(
)
{
return
this
.
toNumber
(
false
)
;
}
,
/**
* Return string value
*
*
@param
radix Just like Number#toString()'s radix
*/
toString
:
function
(
radix
)
{
return
this
.
valueOf
(
)
.
toString
(
radix
||
10
)
;
}
,
/**
* Return a string showing the buffer octets, with MSB on the left.
*
*
@param
sep separator string. default is '' (empty string)
*/
toOctetString
:
function
(
sep
)
{
var
out
=
new
Array
(
8
)
;
var
b
=
this
.
buffer
,
o
=
this
.
offset
;
for
(
var
i
=
0
;
i
<
8
;
i
++
)
{
out
[
i
]
=
_HEX
[
b
[
o
+
i
]
]
;
}
return
out
.
join
(
sep
||
''
)
;
}
,
/**
* Returns the int64's 8 bytes in a buffer.
*
*
@param
{
bool
} [rawBuffer=false] If no offset and this is true, return the internal buffer. Should only be used if
* you're discarding the Int64 afterwards, as it breaks encapsulation.
*/
toBuffer
:
function
(
rawBuffer
)
{
if
(
rawBuffer
&&
this
.
offset
===
0
)
return
this
.
buffer
;
var
out
=
new
Buffer
(
8
)
;
this
.
buffer
.
copy
(
out
,
0
,
this
.
offset
,
this
.
offset
+
8
)
;
return
out
;
}
,
/**
* Copy 8 bytes of int64 into target buffer at target offset.
*
*
@param
{
Buffer
} targetBuffer Buffer to copy into.
*
@param
{
number
} [targetOffset=0] Offset into target buffer.
*/
copy
:
function
(
targetBuffer
,
targetOffset
)
{
this
.
buffer
.
copy
(
targetBuffer
,
targetOffset
||
0
,
this
.
offset
,
this
.
offset
+
8
)
;
}
,
/**
* Returns a number indicating whether this comes before or after or is the
* same as the other in sort order.
*
*
@param
{
Int64
} other Other Int64 to compare.
*/
compare
:
function
(
other
)
{
// If sign bits differ ...
if
(
(
this
.
buffer
[
this
.
offset
]
&
0x80
)
!=
(
other
.
buffer
[
other
.
offset
]
&
0x80
)
)
{
return
other
.
buffer
[
other
.
offset
]
-
this
.
buffer
[
this
.
offset
]
;
}
// otherwise, compare bytes lexicographically
for
(
var
i
=
0
;
i
<
8
;
i
++
)
{
if
(
this
.
buffer
[
this
.
offset
+
i
]
!==
other
.
buffer
[
other
.
offset
+
i
]
)
{
return
this
.
buffer
[
this
.
offset
+
i
]
-
other
.
buffer
[
other
.
offset
+
i
]
;
}
}
return
0
;
}
,
/**
* Returns a boolean indicating if this integer is equal to other.
*
*
@param
{
Int64
} other Other Int64 to compare.
*/
equals
:
function
(
other
)
{
return
this
.
compare
(
other
)
===
0
;
}
,
/**
* Pretty output in console.log
*/
inspect
:
function
(
)
{
return
'[Int64 value:'
+
this
+
' octets:'
+
this
.
toOctetString
(
' '
)
+
']'
;
}
}
;
Back
|
FazBrowse Home
|
New Git URL