Skip to content

Commit 1951f56

Browse files
XadillaXrvagg
XadillaX
authored and
rvagg
committedJun 29, 2018
fix: let it support Node.js 10
·
v0.13.1v0.13.0
1 parent 3f4ae9d commit 1951f56

File tree

4 files changed

+110
-106
lines changed

4 files changed

+110
-106
lines changed
 

‎.travis.yml

+2-2
Original file line numberDiff line numberDiff line change
@@ -11,10 +11,10 @@ addons:
1111
- g++-4.8
1212
env:
1313
matrix:
14-
- TRAVIS_NODE_VERSION="0.10"
15-
- TRAVIS_NODE_VERSION="0.12"
1614
- TRAVIS_NODE_VERSION="4"
1715
- TRAVIS_NODE_VERSION="6"
16+
- TRAVIS_NODE_VERSION="8"
17+
- TRAVIS_NODE_VERSION="10"
1818
notifications:
1919
email:
2020
- rod@vagg.org

‎appveyor.yml

+2-3
Original file line numberDiff line numberDiff line change
@@ -7,11 +7,10 @@ environment:
77
# kudos to serialport for much of this
88

99
matrix:
10-
- nodejs_version: "0.10"
11-
- nodejs_version: "0.12"
1210
- nodejs_version: "4"
13-
- nodejs_version: "5"
1411
- nodejs_version: "6"
12+
- nodejs_version: "8"
13+
- nodejs_version: "10"
1514

1615
platform:
1716
- x86

‎bignum.cc

+103-98
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,7 @@ using namespace std;
4141
Nan::ThrowTypeError("Argument " #I " must be a uint32"); \
4242
return; \
4343
} \
44-
uint32_t VAR = info[I]->ToUint32()->Value();
44+
uint32_t VAR = Nan::To<int32_t>(info[I]).FromJust();
4545

4646
#define REQ_INT64_ARG(I, VAR) \
4747
if (info.Length() <= (I) || !info[I]->IsNumber()) { \
@@ -66,8 +66,8 @@ using namespace std;
6666

6767
#define WRAP_RESULT(RES, VAR) \
6868
Local<Value> arg[1] = { Nan::New<External>(static_cast<BigNum*>(RES)) }; \
69-
Local<Object> VAR = Nan::New<FunctionTemplate>(constructor_template)-> \
70-
GetFunction()->NewInstance(1, arg);
69+
Local<Object> VAR = Nan::NewInstance(Nan::New<FunctionTemplate>(constructor_template)->GetFunction(), \
70+
1, arg).ToLocalChecked();
7171

7272
class AutoBN_CTX
7373
{
@@ -140,9 +140,9 @@ int BN_jacobi_priv(const BIGNUM *A,const BIGNUM *N,int *jacobi,
140140
BN_copy(a1,A);
141141
BN_copy(n1,N);
142142
startjacobistep1:
143-
if BN_is_zero(a1) /* step 1 */
143+
if (BN_is_zero(a1)) /* step 1 */
144144
goto endBN_jacobi; /* *jacobi = 1; */
145-
if BN_is_one(a1) /* step 2 */
145+
if (BN_is_one(a1)) /* step 2 */
146146
goto endBN_jacobi; /* *jacobi = 1; */
147147
for (e=0;;e++) /* step 3 */
148148
if (BN_is_odd(a1))
@@ -180,14 +180,14 @@ int BN_jacobi_priv(const BIGNUM *A,const BIGNUM *N,int *jacobi,
180180
class BigNum : public Nan::ObjectWrap {
181181
public:
182182
static void Initialize(Local<Object> target);
183-
BIGNUM bignum_;
183+
BIGNUM* bignum_;
184184
static Nan::Persistent<Function> js_conditioner;
185185
static void SetJSConditioner(Local<Function> constructor);
186186

187187
protected:
188188
static Nan::Persistent<FunctionTemplate> constructor_template;
189189

190-
BigNum(const String::Utf8Value& str, uint64_t base);
190+
BigNum(const Nan::Utf8String& str, uint64_t base);
191191
BigNum(uint64_t num);
192192
BigNum(int64_t num);
193193
BigNum(BIGNUM *num);
@@ -291,20 +291,19 @@ void BigNum::Initialize(v8::Local<v8::Object> target) {
291291
target->Set(Nan::New("BigNum").ToLocalChecked(), tmpl->GetFunction());
292292
}
293293

294-
BigNum::BigNum(const v8::String::Utf8Value& str, uint64_t base) : Nan::ObjectWrap ()
294+
BigNum::BigNum(const Nan::Utf8String& str, uint64_t base) : Nan::ObjectWrap (),
295+
bignum_(BN_new())
295296
{
296-
BN_init(&bignum_);
297-
BN_zero(&bignum_);
297+
BN_zero(bignum_);
298298

299-
BIGNUM *res = &bignum_;
299+
BIGNUM *res = bignum_;
300300

301301
const char *cstr = *str;
302302
switch (base) {
303303
case 2:
304-
BN_init(&bignum_);
305304
for (int i = 0, l = str.length(); i < l; i++) {
306305
if (cstr[l-i-1] != '0') {
307-
BN_set_bit(&bignum_, i);
306+
BN_set_bit(bignum_, i);
308307
}
309308
}
310309
break;
@@ -320,57 +319,56 @@ BigNum::BigNum(const v8::String::Utf8Value& str, uint64_t base) : Nan::ObjectWra
320319
}
321320
}
322321

323-
BigNum::BigNum(uint64_t num) : Nan::ObjectWrap ()
322+
BigNum::BigNum(uint64_t num) : Nan::ObjectWrap (),
323+
bignum_(BN_new())
324324
{
325-
BN_init(&bignum_);
326-
327325
if (sizeof(BN_ULONG) >= 8 || num <= 0xFFFFFFFFL) {
328-
BN_set_word(&bignum_, num);
326+
BN_set_word(bignum_, num);
329327
} else {
330-
BN_set_word(&bignum_, num >> 32);
331-
BN_lshift(&bignum_, &bignum_, 32);
332-
BN_add_word(&bignum_, num & 0xFFFFFFFFL);
328+
BN_set_word(bignum_, num >> 32);
329+
BN_lshift(bignum_, bignum_, 32);
330+
BN_add_word(bignum_, num & 0xFFFFFFFFL);
333331
}
334332
}
335333

336-
BigNum::BigNum(int64_t num) : Nan::ObjectWrap ()
334+
BigNum::BigNum(int64_t num) : Nan::ObjectWrap (),
335+
bignum_(BN_new())
337336
{
338337
bool neg = (num < 0);
339-
BN_init(&bignum_);
340338

341339
if (neg) {
342340
num = -num;
343341
}
344342
if (num < 0) { // num is -2^63
345-
BN_one(&bignum_);
346-
BN_lshift(&bignum_, &bignum_, 63);
343+
BN_one(bignum_);
344+
BN_lshift(bignum_, bignum_, 63);
347345
} else if (sizeof(BN_ULONG) >= 8 || num <= 0xFFFFFFFFL) {
348-
BN_set_word(&bignum_, num);
346+
BN_set_word(bignum_, num);
349347
} else {
350-
BN_set_word(&bignum_, num >> 32);
351-
BN_lshift(&bignum_, &bignum_, 32);
352-
BN_add_word(&bignum_, num & 0xFFFFFFFFL);
348+
BN_set_word(bignum_, num >> 32);
349+
BN_lshift(bignum_, bignum_, 32);
350+
BN_add_word(bignum_, num & 0xFFFFFFFFL);
353351
}
354352
if (neg) {
355-
BN_set_negative(&bignum_, 1);
353+
BN_set_negative(bignum_, 1);
356354
}
357355
}
358356

359-
BigNum::BigNum(BIGNUM *num) : Nan::ObjectWrap ()
357+
BigNum::BigNum(BIGNUM *num) : Nan::ObjectWrap (),
358+
bignum_(BN_new())
360359
{
361-
BN_init(&bignum_);
362-
BN_copy(&bignum_, num);
360+
BN_copy(bignum_, num);
363361
}
364362

365-
BigNum::BigNum() : Nan::ObjectWrap ()
363+
BigNum::BigNum() : Nan::ObjectWrap (),
364+
bignum_(BN_new())
366365
{
367-
BN_init(&bignum_);
368-
BN_zero(&bignum_);
366+
BN_zero(bignum_);
369367
}
370368

371369
BigNum::~BigNum()
372370
{
373-
BN_clear_free(&bignum_);
371+
BN_clear_free(bignum_);
374372
}
375373

376374
NAN_METHOD(BigNum::New)
@@ -381,8 +379,16 @@ NAN_METHOD(BigNum::New)
381379
for (int i = 0; i < len; i++) {
382380
newArgs[i] = info[i];
383381
}
384-
Local<Value> newInst = Nan::New<FunctionTemplate>(constructor_template)->
385-
GetFunction()->NewInstance(len, newArgs);
382+
383+
Nan::TryCatch tryCatch;
384+
Nan::MaybeLocal<Object> newInstMaybeLocal = Nan::NewInstance(
385+
Nan::New<FunctionTemplate>(constructor_template)->GetFunction(), len, newArgs);
386+
if (tryCatch.HasCaught()) {
387+
tryCatch.ReThrow();
388+
return;
389+
}
390+
391+
Local<Value> newInst = newInstMaybeLocal.ToLocalChecked();
386392
delete[] newArgs;
387393
info.GetReturnValue().Set(newInst);
388394
return;
@@ -409,8 +415,8 @@ NAN_METHOD(BigNum::New)
409415
return;
410416
}
411417

412-
String::Utf8Value str(obj->ToObject()->Get(Nan::New("num").ToLocalChecked())->ToString());
413-
base = obj->ToObject()->Get(Nan::New("base").ToLocalChecked())->ToNumber()->Value();
418+
Nan::Utf8String str(obj->ToObject()->Get(Nan::New("num").ToLocalChecked())->ToString());
419+
base = Nan::To<int64_t>(obj->ToObject()->Get(Nan::New("base").ToLocalChecked())).FromJust();
414420

415421
bignum = new BigNum(str, base);
416422
}
@@ -433,10 +439,10 @@ NAN_METHOD(BigNum::ToString)
433439
char *to = NULL;
434440
switch (base) {
435441
case 10:
436-
to = BN_bn2dec(&bignum->bignum_);
442+
to = BN_bn2dec(bignum->bignum_);
437443
break;
438444
case 16:
439-
to = BN_bn2hex(&bignum->bignum_);
445+
to = BN_bn2hex(bignum->bignum_);
440446
break;
441447
default:
442448
Nan::ThrowError("Invalid base, only 10 and 16 are supported");
@@ -456,7 +462,7 @@ NAN_METHOD(BigNum::Badd)
456462
BigNum *bn = Nan::ObjectWrap::Unwrap<BigNum>(info[0]->ToObject());
457463
BigNum *res = new BigNum();
458464

459-
BN_add(&res->bignum_, &bignum->bignum_, &bn->bignum_);
465+
BN_add(res->bignum_, bignum->bignum_, bn->bignum_);
460466

461467
WRAP_RESULT(res, result);
462468

@@ -469,7 +475,7 @@ NAN_METHOD(BigNum::Bsub)
469475

470476
BigNum *bn = Nan::ObjectWrap::Unwrap<BigNum>(info[0]->ToObject());
471477
BigNum *res = new BigNum();
472-
BN_sub(&res->bignum_, &bignum->bignum_, &bn->bignum_);
478+
BN_sub(res->bignum_, bignum->bignum_, bn->bignum_);
473479

474480
WRAP_RESULT(res, result);
475481

@@ -483,7 +489,7 @@ NAN_METHOD(BigNum::Bmul)
483489

484490
BigNum *bn = Nan::ObjectWrap::Unwrap<BigNum>(info[0]->ToObject());
485491
BigNum *res = new BigNum();
486-
BN_mul(&res->bignum_, &bignum->bignum_, &bn->bignum_, ctx);
492+
BN_mul(res->bignum_, bignum->bignum_, bn->bignum_, ctx);
487493

488494
WRAP_RESULT(res, result);
489495

@@ -497,7 +503,7 @@ NAN_METHOD(BigNum::Bdiv)
497503

498504
BigNum *bi = Nan::ObjectWrap::Unwrap<BigNum>(info[0]->ToObject());
499505
BigNum *res = new BigNum();
500-
BN_div(&res->bignum_, NULL, &bignum->bignum_, &bi->bignum_, ctx);
506+
BN_div(res->bignum_, NULL, bignum->bignum_, bi->bignum_, ctx);
501507

502508
WRAP_RESULT(res, result);
503509

@@ -509,12 +515,12 @@ NAN_METHOD(BigNum::Uadd)
509515
BigNum *bignum = Nan::ObjectWrap::Unwrap<BigNum>(info.This());
510516

511517
REQ_UINT64_ARG(0, x);
512-
BigNum *res = new BigNum(&bignum->bignum_);
518+
BigNum *res = new BigNum(bignum->bignum_);
513519
if (sizeof(BN_ULONG) >= 8 || x <= 0xFFFFFFFFL) {
514-
BN_add_word(&res->bignum_, x);
520+
BN_add_word(res->bignum_, x);
515521
} else {
516522
BigNum *bn = new BigNum(x);
517-
BN_add(&res->bignum_, &bignum->bignum_, &bn->bignum_);
523+
BN_add(res->bignum_, bignum->bignum_, bn->bignum_);
518524
}
519525

520526
WRAP_RESULT(res, result);
@@ -527,12 +533,12 @@ NAN_METHOD(BigNum::Usub)
527533
BigNum *bignum = Nan::ObjectWrap::Unwrap<BigNum>(info.This());
528534

529535
REQ_UINT64_ARG(0, x);
530-
BigNum *res = new BigNum(&bignum->bignum_);
536+
BigNum *res = new BigNum(bignum->bignum_);
531537
if (sizeof(BN_ULONG) >= 8 || x <= 0xFFFFFFFFL) {
532-
BN_sub_word(&res->bignum_, x);
538+
BN_sub_word(res->bignum_, x);
533539
} else {
534540
BigNum *bn = new BigNum(x);
535-
BN_sub(&res->bignum_, &bignum->bignum_, &bn->bignum_);
541+
BN_sub(res->bignum_, bignum->bignum_, bn->bignum_);
536542
}
537543

538544
WRAP_RESULT(res, result);
@@ -545,13 +551,13 @@ NAN_METHOD(BigNum::Umul)
545551
BigNum *bignum = Nan::ObjectWrap::Unwrap<BigNum>(info.This());
546552

547553
REQ_UINT64_ARG(0, x);
548-
BigNum *res = new BigNum(&bignum->bignum_);
554+
BigNum *res = new BigNum(bignum->bignum_);
549555
if (sizeof(BN_ULONG) >= 8 || x <= 0xFFFFFFFFL) {
550-
BN_mul_word(&res->bignum_, x);
556+
BN_mul_word(res->bignum_, x);
551557
} else {
552558
AutoBN_CTX ctx;
553559
BigNum *bn = new BigNum(x);
554-
BN_mul(&res->bignum_, &bignum->bignum_, &bn->bignum_, ctx);
560+
BN_mul(res->bignum_, bignum->bignum_, bn->bignum_, ctx);
555561
}
556562

557563
WRAP_RESULT(res, result);
@@ -564,13 +570,13 @@ NAN_METHOD(BigNum::Udiv)
564570
BigNum *bignum = Nan::ObjectWrap::Unwrap<BigNum>(info.This());
565571

566572
REQ_UINT64_ARG(0, x);
567-
BigNum *res = new BigNum(&bignum->bignum_);
573+
BigNum *res = new BigNum(bignum->bignum_);
568574
if (sizeof(BN_ULONG) >= 8 || x <= 0xFFFFFFFFL) {
569-
BN_div_word(&res->bignum_, x);
575+
BN_div_word(res->bignum_, x);
570576
} else {
571577
AutoBN_CTX ctx;
572578
BigNum *bn = new BigNum(x);
573-
BN_div(&res->bignum_, NULL, &bignum->bignum_, &bn->bignum_, ctx);
579+
BN_div(res->bignum_, NULL, bignum->bignum_, bn->bignum_, ctx);
574580
}
575581

576582
WRAP_RESULT(res, result);
@@ -584,7 +590,7 @@ NAN_METHOD(BigNum::Umul_2exp)
584590

585591
REQ_UINT32_ARG(0, x);
586592
BigNum *res = new BigNum();
587-
BN_lshift(&res->bignum_, &bignum->bignum_, x);
593+
BN_lshift(res->bignum_, bignum->bignum_, x);
588594

589595
WRAP_RESULT(res, result);
590596

@@ -597,7 +603,7 @@ NAN_METHOD(BigNum::Udiv_2exp)
597603

598604
REQ_UINT32_ARG(0, x);
599605
BigNum *res = new BigNum();
600-
BN_rshift(&res->bignum_, &bignum->bignum_, x);
606+
BN_rshift(res->bignum_, bignum->bignum_, x);
601607

602608
WRAP_RESULT(res, result);
603609

@@ -608,8 +614,8 @@ NAN_METHOD(BigNum::Babs)
608614
{
609615
BigNum *bignum = Nan::ObjectWrap::Unwrap<BigNum>(info.This());
610616

611-
BigNum *res = new BigNum(&bignum->bignum_);
612-
BN_set_negative(&res->bignum_, 0);
617+
BigNum *res = new BigNum(bignum->bignum_);
618+
BN_set_negative(res->bignum_, 0);
613619

614620
WRAP_RESULT(res, result);
615621

@@ -620,8 +626,8 @@ NAN_METHOD(BigNum::Bneg)
620626
{
621627
BigNum *bignum = Nan::ObjectWrap::Unwrap<BigNum>(info.This());
622628

623-
BigNum *res = new BigNum(&bignum->bignum_);
624-
BN_set_negative(&res->bignum_, !BN_is_negative(&res->bignum_));
629+
BigNum *res = new BigNum(bignum->bignum_);
630+
BN_set_negative(res->bignum_, !BN_is_negative(res->bignum_));
625631

626632
WRAP_RESULT(res, result);
627633

@@ -635,7 +641,7 @@ NAN_METHOD(BigNum::Bmod)
635641

636642
BigNum *bn = Nan::ObjectWrap::Unwrap<BigNum>(info[0]->ToObject());
637643
BigNum *res = new BigNum();
638-
BN_div(NULL, &res->bignum_, &bignum->bignum_, &bn->bignum_, ctx);
644+
BN_div(NULL, res->bignum_, bignum->bignum_, bn->bignum_, ctx);
639645

640646
WRAP_RESULT(res, result);
641647

@@ -649,11 +655,11 @@ NAN_METHOD(BigNum::Umod)
649655
REQ_UINT64_ARG(0, x);
650656
BigNum *res = new BigNum();
651657
if (sizeof(BN_ULONG) >= 8 || x <= 0xFFFFFFFFL) {
652-
BN_set_word(&res->bignum_, BN_mod_word(&bignum->bignum_, x));
658+
BN_set_word(res->bignum_, BN_mod_word(bignum->bignum_, x));
653659
} else {
654660
AutoBN_CTX ctx;
655661
BigNum *bn = new BigNum(x);
656-
BN_div(NULL, &res->bignum_, &bignum->bignum_, &bn->bignum_, ctx);
662+
BN_div(NULL, res->bignum_, bignum->bignum_, bn->bignum_, ctx);
657663
}
658664

659665
WRAP_RESULT(res, result);
@@ -669,7 +675,7 @@ NAN_METHOD(BigNum::Bpowm)
669675
BigNum *bn1 = Nan::ObjectWrap::Unwrap<BigNum>(info[0]->ToObject());
670676
BigNum *bn2 = Nan::ObjectWrap::Unwrap<BigNum>(info[1]->ToObject());
671677
BigNum *res = new BigNum();
672-
BN_mod_exp(&res->bignum_, &bignum->bignum_, &bn1->bignum_, &bn2->bignum_, ctx);
678+
BN_mod_exp(res->bignum_, bignum->bignum_, bn1->bignum_, bn2->bignum_, ctx);
673679

674680
WRAP_RESULT(res, result);
675681

@@ -686,7 +692,7 @@ NAN_METHOD(BigNum::Upowm)
686692
BigNum *exp = new BigNum(x);
687693

688694
BigNum *res = new BigNum();
689-
BN_mod_exp(&res->bignum_, &bignum->bignum_, &exp->bignum_, &bn->bignum_, ctx);
695+
BN_mod_exp(res->bignum_, bignum->bignum_, exp->bignum_, bn->bignum_, ctx);
690696

691697
WRAP_RESULT(res, result);
692698

@@ -702,7 +708,7 @@ NAN_METHOD(BigNum::Upow)
702708
BigNum *exp = new BigNum(x);
703709

704710
BigNum *res = new BigNum();
705-
BN_exp(&res->bignum_, &bignum->bignum_, &exp->bignum_, ctx);
711+
BN_exp(res->bignum_, bignum->bignum_, exp->bignum_, ctx);
706712

707713
WRAP_RESULT(res, result);
708714

@@ -715,7 +721,7 @@ NAN_METHOD(BigNum::Brand0)
715721

716722
BigNum *res = new BigNum();
717723

718-
BN_rand_range(&res->bignum_, &bignum->bignum_);
724+
BN_rand_range(res->bignum_, bignum->bignum_);
719725

720726
WRAP_RESULT(res, result);
721727

@@ -729,7 +735,7 @@ NAN_METHOD(BigNum::Uprime0)
729735

730736
BigNum *res = new BigNum();
731737

732-
BN_generate_prime_ex(&res->bignum_, x, safe, NULL, NULL, NULL);
738+
BN_generate_prime_ex(res->bignum_, x, safe, NULL, NULL, NULL);
733739

734740
WRAP_RESULT(res, result);
735741

@@ -743,7 +749,7 @@ NAN_METHOD(BigNum::Probprime)
743749

744750
REQ_UINT32_ARG(0, reps);
745751

746-
info.GetReturnValue().Set(Nan::New<Number>(BN_is_prime_ex(&bignum->bignum_, reps, ctx, NULL)));
752+
info.GetReturnValue().Set(Nan::New<Number>(BN_is_prime_ex(bignum->bignum_, reps, ctx, NULL)));
747753
}
748754

749755
NAN_METHOD(BigNum::IsBitSet)
@@ -752,7 +758,7 @@ NAN_METHOD(BigNum::IsBitSet)
752758

753759
REQ_UINT32_ARG(0, n);
754760

755-
info.GetReturnValue().Set(Nan::New<Number>(BN_is_bit_set(&bignum->bignum_, n)));
761+
info.GetReturnValue().Set(Nan::New<Number>(BN_is_bit_set(bignum->bignum_, n)));
756762
}
757763

758764
NAN_METHOD(BigNum::Bcompare)
@@ -761,7 +767,7 @@ NAN_METHOD(BigNum::Bcompare)
761767

762768
BigNum *bn = Nan::ObjectWrap::Unwrap<BigNum>(info[0]->ToObject());
763769

764-
info.GetReturnValue().Set(Nan::New<Number>(BN_cmp(&bignum->bignum_, &bn->bignum_)));
770+
info.GetReturnValue().Set(Nan::New<Number>(BN_cmp(bignum->bignum_, bn->bignum_)));
765771
}
766772

767773
NAN_METHOD(BigNum::Scompare)
@@ -770,7 +776,7 @@ NAN_METHOD(BigNum::Scompare)
770776

771777
REQ_INT64_ARG(0, x);
772778
BigNum *bn = new BigNum(x);
773-
int res = BN_cmp(&bignum->bignum_, &bn->bignum_);
779+
int res = BN_cmp(bignum->bignum_, bn->bignum_);
774780

775781
info.GetReturnValue().Set(Nan::New<Number>(res));
776782
}
@@ -782,14 +788,13 @@ NAN_METHOD(BigNum::Ucompare)
782788
REQ_UINT64_ARG(0, x);
783789
int res;
784790
if (sizeof(BN_ULONG) >= 8 || x <= 0xFFFFFFFFL) {
785-
BIGNUM bn;
786-
BN_init(&bn);
787-
BN_set_word(&bn, x);
788-
res = BN_cmp(&bignum->bignum_, &bn);
789-
BN_clear_free(&bn);
791+
BIGNUM* bn = BN_new();
792+
BN_set_word(bn, x);
793+
res = BN_cmp(bignum->bignum_, bn);
794+
BN_clear_free(bn);
790795
} else {
791796
BigNum *bn = new BigNum(x);
792-
res = BN_cmp(&bignum->bignum_, &bn->bignum_);
797+
res = BN_cmp(bignum->bignum_, bn->bignum_);
793798
}
794799

795800
info.GetReturnValue().Set(Nan::New<Number>(res));
@@ -892,17 +897,17 @@ BigNum::Bop(Nan::NAN_METHOD_ARGS_TYPE info, int op)
892897
BigNum *bignum = Nan::ObjectWrap::Unwrap<BigNum>(info.This());
893898
BigNum *bn = Nan::ObjectWrap::Unwrap<BigNum>(info[0]->ToObject());
894899

895-
bool bignumNegative = BN_is_negative(&bignum->bignum_);
896-
bool bnNegative = BN_is_negative(&bn->bignum_);
900+
bool bignumNegative = BN_is_negative(bignum->bignum_);
901+
bool bnNegative = BN_is_negative(bn->bignum_);
897902

898903
BigNum *res = new BigNum();
899904

900905
// Modified from https://github.com/Worlize/WebSocket-Node/blob/master/src/xor.cpp
901906
// Portions Copyright (c) Agora S.A.
902907
// Licensed under the MIT License.
903908

904-
int payloadSize = BN_bn2mpi(&bignum->bignum_, NULL);
905-
int maskSize = BN_bn2mpi(&bn->bignum_, NULL);
909+
int payloadSize = BN_bn2mpi(bignum->bignum_, NULL);
910+
int maskSize = BN_bn2mpi(bn->bignum_, NULL);
906911

907912
uint32_t size = max(payloadSize, maskSize);
908913
int offset = abs(payloadSize - maskSize);
@@ -919,8 +924,8 @@ BigNum::Bop(Nan::NAN_METHOD_ARGS_TYPE info, int op)
919924
uint8_t* payload = (uint8_t*) calloc(size, sizeof(char));
920925
uint8_t* mask = (uint8_t*) calloc(size, sizeof(char));
921926

922-
BN_bn2mpi(&bignum->bignum_, payload + payloadOffset);
923-
BN_bn2mpi(&bn->bignum_, mask + maskOffset);
927+
BN_bn2mpi(bignum->bignum_, payload + payloadOffset);
928+
BN_bn2mpi(bn->bignum_, mask + maskOffset);
924929

925930
if (payloadSize < maskSize) {
926931
shiftSizeAndMSB(payload, mask, payloadOffset);
@@ -989,7 +994,7 @@ BigNum::Bop(Nan::NAN_METHOD_ARGS_TYPE info, int op)
989994
twos_complement2mpi(payload + BN_PAYLOAD_OFFSET, size - BN_PAYLOAD_OFFSET);
990995
}
991996

992-
BN_mpi2bn(payload, size, &res->bignum_);
997+
BN_mpi2bn(payload, size, res->bignum_);
993998

994999
WRAP_RESULT(res, result);
9951000

@@ -1021,7 +1026,7 @@ NAN_METHOD(BigNum::Binvertm)
10211026

10221027
BigNum *bn = Nan::ObjectWrap::Unwrap<BigNum>(info[0]->ToObject());
10231028
BigNum *res = new BigNum();
1024-
BN_mod_inverse(&res->bignum_, &bignum->bignum_, &bn->bignum_, ctx);
1029+
BN_mod_inverse(res->bignum_, bignum->bignum_, bn->bignum_, ctx);
10251030

10261031
WRAP_RESULT(res, result);
10271032

@@ -1042,7 +1047,7 @@ NAN_METHOD(BigNum::BitLength)
10421047
{
10431048
BigNum *bignum = Nan::ObjectWrap::Unwrap<BigNum>(info.This());
10441049

1045-
int size = BN_num_bits(&bignum->bignum_);
1050+
int size = BN_num_bits(bignum->bignum_);
10461051
Local<Value> result = Nan::New<Integer>(size);
10471052

10481053
info.GetReturnValue().Set(result);
@@ -1056,7 +1061,7 @@ NAN_METHOD(BigNum::Bgcd)
10561061
BigNum *bi = Nan::ObjectWrap::Unwrap<BigNum>(info[0]->ToObject());
10571062
BigNum *res = new BigNum();
10581063

1059-
BN_gcd(&res->bignum_, &bignum->bignum_, &bi->bignum_, ctx);
1064+
BN_gcd(res->bignum_, bignum->bignum_, bi->bignum_, ctx);
10601065

10611066
WRAP_RESULT(res, result);
10621067
info.GetReturnValue().Set(result);
@@ -1070,7 +1075,7 @@ NAN_METHOD(BigNum::Bjacobi)
10701075
BigNum *bn_n = Nan::ObjectWrap::Unwrap<BigNum>(info[0]->ToObject());
10711076
int res = 0;
10721077

1073-
if (BN_jacobi_priv(&bn_a->bignum_, &bn_n->bignum_, &res, ctx) == -1) {
1078+
if (BN_jacobi_priv(bn_a->bignum_, bn_n->bignum_, &res, ctx) == -1) {
10741079
Nan::ThrowError("Jacobi symbol calculation failed");
10751080
return;
10761081
}
@@ -1082,21 +1087,21 @@ NAN_METHOD(BigNum::Bsetcompact)
10821087
{
10831088
BigNum *bignum = Nan::ObjectWrap::Unwrap<BigNum>(info.This());
10841089

1085-
unsigned int nCompact = info[0]->ToUint32()->Value();
1090+
unsigned int nCompact = Nan::To<uint32_t>(info[0]).FromJust();
10861091
unsigned int nSize = nCompact >> 24;
10871092
bool fNegative =(nCompact & 0x00800000) != 0;
10881093
unsigned int nWord = nCompact & 0x007fffff;
10891094
if (nSize <= 3)
10901095
{
10911096
nWord >>= 8*(3-nSize);
1092-
BN_set_word(&bignum->bignum_, nWord);
1097+
BN_set_word(bignum->bignum_, nWord);
10931098
}
10941099
else
10951100
{
1096-
BN_set_word(&bignum->bignum_, nWord);
1097-
BN_lshift(&bignum->bignum_, &bignum->bignum_, 8*(nSize-3));
1101+
BN_set_word(bignum->bignum_, nWord);
1102+
BN_lshift(bignum->bignum_, bignum->bignum_, 8*(nSize-3));
10981103
}
1099-
BN_set_negative(&bignum->bignum_, fNegative);
1104+
BN_set_negative(bignum->bignum_, fNegative);
11001105

11011106
info.GetReturnValue().Set(info.This());
11021107
}

‎package.json

+3-3
Original file line numberDiff line numberDiff line change
@@ -22,14 +22,14 @@
2222
"url": "http://www.justmoon.net"
2323
},
2424
"dependencies": {
25-
"nan": "^2.3.4",
26-
"node-pre-gyp": "~0.6.28"
25+
"nan": "^2.10.0",
26+
"node-pre-gyp": "~0.10.2"
2727
},
2828
"devDependencies": {
2929
"aws-sdk": "~2.4.0",
3030
"put": "~0.0.5",
3131
"standard": "~7.1.2",
32-
"tap": "~5.7.2"
32+
"tap": "~12.0.1"
3333
},
3434
"scripts": {
3535
"install": "node-pre-gyp install --fallback-to-build",

0 commit comments

Comments
 (0)
Please sign in to comment.