1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 | var bufPool = [];
|
13 |
|
14 |
|
15 | var TEMP_BUF_MAXIMUM_LENGTH = 20;
|
16 |
|
17 |
|
18 | var MIN_EXACT_INT64 = -0x8000000000000000;
|
19 |
|
20 |
|
21 | var MAX_EXACT_INT64 = 0x7ffffffffffffc00;
|
22 |
|
23 |
|
24 | var MAX_EXACT_UINT64 = 0xfffffffffffff800;
|
25 |
|
26 |
|
27 |
|
28 |
|
29 |
|
30 | var BIT_32 = 0x100000000;
|
31 |
|
32 |
|
33 |
|
34 |
|
35 |
|
36 | var BIT_64 = 0x10000000000000000;
|
37 |
|
38 |
|
39 |
|
40 |
|
41 |
|
42 |
|
43 |
|
44 |
|
45 | function lowestBit(num) {
|
46 | return num & -num;
|
47 | }
|
48 |
|
49 |
|
50 |
|
51 |
|
52 |
|
53 |
|
54 | function isLossyToAdd(accum, num) {
|
55 | if (num === 0) {
|
56 | return false;
|
57 | }
|
58 |
|
59 | var lowBit = lowestBit(num);
|
60 | var added = accum + lowBit;
|
61 |
|
62 | if (added === accum) {
|
63 | return true;
|
64 | }
|
65 |
|
66 | if (added - lowBit !== accum) {
|
67 | return true;
|
68 | }
|
69 |
|
70 | return false;
|
71 | }
|
72 |
|
73 |
|
74 |
|
75 |
|
76 |
|
77 |
|
78 |
|
79 |
|
80 |
|
81 |
|
82 |
|
83 | export function alloc(length) {
|
84 | var result = bufPool[length];
|
85 |
|
86 | if (result) {
|
87 | bufPool[length] = undefined;
|
88 | } else {
|
89 | result = new Buffer(length);
|
90 | }
|
91 |
|
92 | result.fill(0);
|
93 | return result;
|
94 | }
|
95 |
|
96 |
|
97 |
|
98 |
|
99 | export function free(buffer) {
|
100 | var length = buffer.length;
|
101 |
|
102 | if (length < TEMP_BUF_MAXIMUM_LENGTH) {
|
103 | bufPool[length] = buffer;
|
104 | }
|
105 | }
|
106 |
|
107 |
|
108 |
|
109 |
|
110 |
|
111 |
|
112 |
|
113 | export function resize(buffer, length) {
|
114 | if (length === buffer.length) {
|
115 | return buffer;
|
116 | }
|
117 |
|
118 | var newBuf = alloc(length);
|
119 | buffer.copy(newBuf);
|
120 | free(buffer);
|
121 | return newBuf;
|
122 | }
|
123 |
|
124 |
|
125 |
|
126 |
|
127 | export function readInt(buffer) {
|
128 | var length = buffer.length;
|
129 | var positive = buffer[length - 1] < 0x80;
|
130 | var result = positive ? 0 : -1;
|
131 | var lossy = false;
|
132 |
|
133 |
|
134 | if (length < 7) {
|
135 |
|
136 |
|
137 | for (var i = length - 1; i >= 0; i--) {
|
138 | result = result * 0x100 + buffer[i];
|
139 | }
|
140 | } else {
|
141 | for (var _i = length - 1; _i >= 0; _i--) {
|
142 | var one = buffer[_i];
|
143 | result *= 0x100;
|
144 |
|
145 | if (isLossyToAdd(result, one)) {
|
146 | lossy = true;
|
147 | }
|
148 |
|
149 | result += one;
|
150 | }
|
151 | }
|
152 |
|
153 | return {
|
154 | value: result,
|
155 | lossy: lossy
|
156 | };
|
157 | }
|
158 |
|
159 |
|
160 |
|
161 |
|
162 | export function readUInt(buffer) {
|
163 | var length = buffer.length;
|
164 | var result = 0;
|
165 | var lossy = false;
|
166 |
|
167 | if (length < 7) {
|
168 |
|
169 | for (var i = length - 1; i >= 0; i--) {
|
170 | result = result * 0x100 + buffer[i];
|
171 | }
|
172 | } else {
|
173 | for (var _i2 = length - 1; _i2 >= 0; _i2--) {
|
174 | var one = buffer[_i2];
|
175 | result *= 0x100;
|
176 |
|
177 | if (isLossyToAdd(result, one)) {
|
178 | lossy = true;
|
179 | }
|
180 |
|
181 | result += one;
|
182 | }
|
183 | }
|
184 |
|
185 | return {
|
186 | value: result,
|
187 | lossy: lossy
|
188 | };
|
189 | }
|
190 |
|
191 |
|
192 |
|
193 |
|
194 | export function writeInt64(value, buffer) {
|
195 | if (value < MIN_EXACT_INT64 || value > MAX_EXACT_INT64) {
|
196 | throw new Error("Value out of range.");
|
197 | }
|
198 |
|
199 | if (value < 0) {
|
200 | value += BIT_64;
|
201 | }
|
202 |
|
203 | writeUInt64(value, buffer);
|
204 | }
|
205 |
|
206 |
|
207 |
|
208 |
|
209 | export function writeUInt64(value, buffer) {
|
210 | if (value < 0 || value > MAX_EXACT_UINT64) {
|
211 | throw new Error("Value out of range.");
|
212 | }
|
213 |
|
214 | var lowWord = value % BIT_32;
|
215 | var highWord = Math.floor(value / BIT_32);
|
216 | buffer.writeUInt32LE(lowWord, 0);
|
217 | buffer.writeUInt32LE(highWord, 4);
|
218 | } |
\ | No newline at end of file |