4d8350c · Idris-dev · git.iko.soy

git.iko.soy/Idris-dev

on master help sign in

Merge pull request #3829 from be5invis/be5invis-codegen-js-opt

4d8350cNiklas Larsson9 years ago

.travis.yml+2

compare with master

unifiedsplit

@@ -54,6 +54,8 @@ before_cache:

54 - rm -fv $HOME/.cabal/packages/hackage.haskell.org/00-index.tar

56before_install:

57+ - nvm install 6

58+ - nvm use 6

57 - unset CC

59 - unset CC

58 - if [[ $TRAVIS_OS_NAME == 'linux' ]];

60 - if [[ $TRAVIS_OS_NAME == 'linux' ]];

59 then

61 then

idris.cabal+5−1

@@ -47,7 +47,8 @@ Build-type: Custom

47Tested-With: GHC == 7.6.3, GHC == 7.8.4, GHC == 7.10.3, GHC == 8.0.1

49Data-files: idrisdoc/styles.css

50− jsrts/jsbn/jsbn.js

50+ jsrts/jsbn/jsbn-browser.js

51+ jsrts/jsbn/jsbn-node.js

51 jsrts/Runtime-common.js

52 jsrts/Runtime-common.js

52 jsrts/Runtime-javascript.js

53 jsrts/Runtime-javascript.js

53 jsrts/Runtime-node.js

54 jsrts/Runtime-node.js

@@ -223,8 +224,11 @@ Library

223 , IRTS.CodegenJavaScript

224 , IRTS.CodegenJavaScript

224 , IRTS.Exports

225 , IRTS.Exports

225 , IRTS.JavaScript.AST

226 , IRTS.JavaScript.AST

227+ , IRTS.JavaScript.Name

226 , IRTS.JavaScript.Codegen

228 , IRTS.JavaScript.Codegen

227 , IRTS.JavaScript.LangTransforms

229 , IRTS.JavaScript.LangTransforms

230+ , IRTS.JavaScript.Specialize

231+ , IRTS.JavaScript.PrimOp

228 , IRTS.Compiler

232 , IRTS.Compiler

229 , IRTS.Defunctionalise

233 , IRTS.Defunctionalise

230 , IRTS.DumpBC

234 , IRTS.DumpBC

jsrts/Runtime-common.js+21−14

@@ -1,15 +1,22 @@

1−

1+const $JSRTS = {

2−var js_idris_throw2 = function (x){

2+ throw: function (x) {

3− throw x;

3+ throw x;

4−}

4+ },

5−

5+ Lazy: function (e) {

6+ this.js_idris_lazy_calc = e;

7+ this.js_idris_lazy_val = void 0;

8+ },

6−var js_idris_force = function (x){

9+ force: function (x) {

7− if(x === undefined || x.js_idris_lazy_calc === undefined){

10+ if (x === undefined || x.js_idris_lazy_calc === undefined) {

8− return x

11+ return x

9− }else{

12+ } else {

10− if(x.js_idris_lazy_val === undefined){

13+ if (x.js_idris_lazy_val === undefined) {

11− x.js_idris_lazy_val = x.js_idris_lazy_calc()

14+ x.js_idris_lazy_val = x.js_idris_lazy_calc()

15+ }

16+ return x.js_idris_lazy_val

17+ }

18+ },

19+ prim_strSubstr: function (offset, len, str) {

20+ return str.substr(Math.max(0, offset), Math.max(0, len))

12 }

21 }

13− return x.js_idris_lazy_val

14− }

22+};

15−}

jsrts/Runtime-javascript.js+11−9

@@ -1,9 +1,11 @@

1−var js_idris_systemInfo = function(index) {

1+$JSRTS.prim_systemInfo = function (index) {

2− switch(index) {

2+ switch (index) {

3− case 0:

3+ case 0:

4− return "javascript";

4+ return "javascript";

5− case 1:

5+ case 1:

6− return navigator.platform;

6+ return navigator.platform;

7− }

7+ }

8− return "";

8+ return "";

9−}

9+};

10+$JSRTS.prim_writeStr = function (x) { return console.log(x) }

11+$JSRTS.prim_readStr = function () { return prompt('Prelude.getLine') };

jsrts/Runtime-node.js+30−9

@@ -1,10 +1,31 @@

1−var js_idris_systemInfo = function(index) {

1+$JSRTS.os = require('os');

2− var os = require('os')

2+$JSRTS.fs = require('fs');

3+$JSRTS.prim_systemInfo = function (index) {

3− switch(index) {

4+ switch (index) {

4− case 0:

5+ case 0:

5− return "node";

6+ return "node";

6− case 1:

7+ case 1:

7− return os.platform();

8+ return $JSRTS.os.platform();

8 }

9 }

9− return "";

10+ return "";

10−}

11+};

12+$JSRTS.prim_writeStr = function (x) { return process.stdout.write(x) }

13+$JSRTS.prim_readStr = function () {

14+ var ret = '';

15+ var b = new Buffer(1024);

16+ var i = 0;

17+ while (true) {

18+ $JSRTS.fs.readSync(0, b, i, 1)

19+ if (b[i] == 10) {

20+ ret = b.toString('utf8', 0, i);

21+ break;

22+ }

23+ i++;

24+ if (i == b.length) {

25+ nb = new Buffer(b.length * 2);

26+ b.copy(nb)

27+ b = nb;

28+ }

29+ }

30+ return ret;

31+};

jsrts/jsbn/jsbn-browser.jsnew file+1353

@@ -0,0 +1,1353 @@

1+$JSRTS.jsbn = (function () {

5+ // See "LICENSE" for details.

7+ // Basic JavaScript BN library - subset useful for RSA encryption.

9+ // Bits per digit

10+ var dbits;

11+

12+ // JavaScript engine analysis

13+ var canary = 0xdeadbeefcafe;

14+ var j_lm = ((canary & 0xffffff) == 0xefcafe);

15+

16+ // (public) Constructor

17+ function BigInteger(a, b, c) {

18+ if (a != null)

19+ if ("number" == typeof a) this.fromNumber(a, b, c);

20+ else if (b == null && "string" != typeof a) this.fromString(a, 256);

21+ else this.fromString(a, b);

22+ }

23+

24+ // return new, unset BigInteger

25+ function nbi() { return new BigInteger(null); }

26+

27+ // am: Compute w_j += (x*this_i), propagate carries,

28+ // c is initial carry, returns final carry.

29+ // c < 3*dvalue, x < 2*dvalue, this_i < dvalue

30+ // We need to select the fastest one that works in this environment.

31+

32+ // am1: use a single mult and divide to get the high bits,

33+ // max digit bits should be 26 because

34+ // max internal value = 2*dvalue^2-2*dvalue (< 2^53)

35+ function am1(i, x, w, j, c, n) {

36+ while (--n >= 0) {

37+ var v = x * this[i++] + w[j] + c;

38+ c = Math.floor(v / 0x4000000);

39+ w[j++] = v & 0x3ffffff;

40+ }

41+ return c;

42+ }

43+ // am2 avoids a big mult-and-extract completely.

44+ // Max digit bits should be <= 30 because we do bitwise ops

45+ // on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)

46+ function am2(i, x, w, j, c, n) {

47+ var xl = x & 0x7fff, xh = x >> 15;

48+ while (--n >= 0) {

49+ var l = this[i] & 0x7fff;

50+ var h = this[i++] >> 15;

51+ var m = xh * l + h * xl;

52+ l = xl * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff);

53+ c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30);

54+ w[j++] = l & 0x3fffffff;

55+ }

56+ return c;

57+ }

58+ // Alternately, set max digit bits to 28 since some

59+ // browsers slow down when dealing with 32-bit numbers.

60+ function am3(i, x, w, j, c, n) {

61+ var xl = x & 0x3fff, xh = x >> 14;

62+ while (--n >= 0) {

63+ var l = this[i] & 0x3fff;

64+ var h = this[i++] >> 14;

65+ var m = xh * l + h * xl;

66+ l = xl * l + ((m & 0x3fff) << 14) + w[j] + c;

67+ c = (l >> 28) + (m >> 14) + xh * h;

68+ w[j++] = l & 0xfffffff;

69+ }

70+ return c;

71+ }

72+ var inBrowser = typeof navigator !== "undefined";

73+ if (inBrowser && j_lm && (navigator.appName == "Microsoft Internet Explorer")) {

74+ BigInteger.prototype.am = am2;

75+ dbits = 30;

76+ }

77+ else if (inBrowser && j_lm && (navigator.appName != "Netscape")) {

78+ BigInteger.prototype.am = am1;

79+ dbits = 26;

80+ }

81+ else { // Mozilla/Netscape seems to prefer am3

82+ BigInteger.prototype.am = am3;

83+ dbits = 28;

84+ }

85+

86+ BigInteger.prototype.DB = dbits;

87+ BigInteger.prototype.DM = ((1 << dbits) - 1);

88+ BigInteger.prototype.DV = (1 << dbits);

89+

90+ var BI_FP = 52;

91+ BigInteger.prototype.FV = Math.pow(2, BI_FP);

92+ BigInteger.prototype.F1 = BI_FP - dbits;

93+ BigInteger.prototype.F2 = 2 * dbits - BI_FP;

94+

95+ // Digit conversions

96+ var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";

97+ var BI_RC = new Array();

98+ var rr, vv;

99+ rr = "0".charCodeAt(0);

100+ for (vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv;

101+ rr = "a".charCodeAt(0);

102+ for (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;

103+ rr = "A".charCodeAt(0);

104+ for (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;

105+

106+ function int2char(n) { return BI_RM.charAt(n); }

107+ function intAt(s, i) {

108+ var c = BI_RC[s.charCodeAt(i)];

109+ return (c == null) ? -1 : c;

110+ }

111+

112+ // (protected) copy this to r

113+ function bnpCopyTo(r) {

114+ for (var i = this.t - 1; i >= 0; --i) r[i] = this[i];

115+ r.t = this.t;

116+ r.s = this.s;

117+ }

118+

119+ // (protected) set from integer value x, -DV <= x < DV

120+ function bnpFromInt(x) {

121+ this.t = 1;

122+ this.s = (x < 0) ? -1 : 0;

123+ if (x > 0) this[0] = x;

124+ else if (x < -1) this[0] = x + this.DV;

125+ else this.t = 0;

126+ }

127+

128+ // return bigint initialized to value

129+ function nbv(i) { var r = nbi(); r.fromInt(i); return r; }

130+

131+ // (protected) set from string and radix

132+ function bnpFromString(s, b) {

133+ var k;

134+ if (b == 16) k = 4;

135+ else if (b == 8) k = 3;

136+ else if (b == 256) k = 8; // byte array

137+ else if (b == 2) k = 1;

138+ else if (b == 32) k = 5;

139+ else if (b == 4) k = 2;

140+ else { this.fromRadix(s, b); return; }

141+ this.t = 0;

142+ this.s = 0;

143+ var i = s.length, mi = false, sh = 0;

144+ while (--i >= 0) {

145+ var x = (k == 8) ? s[i] & 0xff : intAt(s, i);

146+ if (x < 0) {

147+ if (s.charAt(i) == "-") mi = true;

148+ continue;

149+ }

150+ mi = false;

151+ if (sh == 0)

152+ this[this.t++] = x;

153+ else if (sh + k > this.DB) {

154+ this[this.t - 1] |= (x & ((1 << (this.DB - sh)) - 1)) << sh;

155+ this[this.t++] = (x >> (this.DB - sh));

156+ }

157+ else

158+ this[this.t - 1] |= x << sh;

159+ sh += k;

160+ if (sh >= this.DB) sh -= this.DB;

161+ }

162+ if (k == 8 && (s[0] & 0x80) != 0) {

163+ this.s = -1;

164+ if (sh > 0) this[this.t - 1] |= ((1 << (this.DB - sh)) - 1) << sh;

165+ }

166+ this.clamp();

167+ if (mi) BigInteger.ZERO.subTo(this, this);

168+ }

169+

170+ // (protected) clamp off excess high words

171+ function bnpClamp() {

172+ var c = this.s & this.DM;

173+ while (this.t > 0 && this[this.t - 1] == c)--this.t;

174+ }

175+

176+ // (public) return string representation in given radix

177+ function bnToString(b) {

178+ if (this.s < 0) return "-" + this.negate().toString(b);

179+ var k;

180+ if (b == 16) k = 4;

181+ else if (b == 8) k = 3;

182+ else if (b == 2) k = 1;

183+ else if (b == 32) k = 5;

184+ else if (b == 4) k = 2;

185+ else return this.toRadix(b);

186+ var km = (1 << k) - 1, d, m = false, r = "", i = this.t;

187+ var p = this.DB - (i * this.DB) % k;

188+ if (i-- > 0) {

189+ if (p < this.DB && (d = this[i] >> p) > 0) { m = true; r = int2char(d); }

190+ while (i >= 0) {

191+ if (p < k) {

192+ d = (this[i] & ((1 << p) - 1)) << (k - p);

193+ d |= this[--i] >> (p += this.DB - k);

194+ }

195+ else {

196+ d = (this[i] >> (p -= k)) & km;

197+ if (p <= 0) { p += this.DB; --i; }

198+ }

199+ if (d > 0) m = true;

200+ if (m) r += int2char(d);

201+ }

202+ }

203+ return m ? r : "0";

204+ }

205+

206+ // (public) -this

207+ function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this, r); return r; }

208+

209+ // (public) |this|

210+ function bnAbs() { return (this.s < 0) ? this.negate() : this; }

211+

212+ // (public) return + if this > a, - if this < a, 0 if equal

213+ function bnCompareTo(a) {

214+ var r = this.s - a.s;

215+ if (r != 0) return r;

216+ var i = this.t;

217+ r = i - a.t;

218+ if (r != 0) return (this.s < 0) ? -r : r;

219+ while (--i >= 0) if ((r = this[i] - a[i]) != 0) return r;

220+ return 0;

221+ }

222+

223+ // returns bit length of the integer x

224+ function nbits(x) {

225+ var r = 1, t;

226+ if ((t = x >>> 16) != 0) { x = t; r += 16; }

227+ if ((t = x >> 8) != 0) { x = t; r += 8; }

228+ if ((t = x >> 4) != 0) { x = t; r += 4; }

229+ if ((t = x >> 2) != 0) { x = t; r += 2; }

230+ if ((t = x >> 1) != 0) { x = t; r += 1; }

231+ return r;

232+ }

233+

234+ // (public) return the number of bits in "this"

235+ function bnBitLength() {

236+ if (this.t <= 0) return 0;

237+ return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ (this.s & this.DM));

238+ }

239+

240+ // (protected) r = this << n*DB

241+ function bnpDLShiftTo(n, r) {

242+ var i;

243+ for (i = this.t - 1; i >= 0; --i) r[i + n] = this[i];

244+ for (i = n - 1; i >= 0; --i) r[i] = 0;

245+ r.t = this.t + n;

246+ r.s = this.s;

247+ }

248+

249+ // (protected) r = this >> n*DB

250+ function bnpDRShiftTo(n, r) {

251+ for (var i = n; i < this.t; ++i) r[i - n] = this[i];

252+ r.t = Math.max(this.t - n, 0);

253+ r.s = this.s;

254+ }

255+

256+ // (protected) r = this << n

257+ function bnpLShiftTo(n, r) {

258+ var bs = n % this.DB;

259+ var cbs = this.DB - bs;

260+ var bm = (1 << cbs) - 1;

261+ var ds = Math.floor(n / this.DB), c = (this.s << bs) & this.DM, i;

262+ for (i = this.t - 1; i >= 0; --i) {

263+ r[i + ds + 1] = (this[i] >> cbs) | c;

264+ c = (this[i] & bm) << bs;

265+ }

266+ for (i = ds - 1; i >= 0; --i) r[i] = 0;

267+ r[ds] = c;

268+ r.t = this.t + ds + 1;

269+ r.s = this.s;

270+ r.clamp();

271+ }

272+

273+ // (protected) r = this >> n

274+ function bnpRShiftTo(n, r) {

275+ r.s = this.s;

276+ var ds = Math.floor(n / this.DB);

277+ if (ds >= this.t) { r.t = 0; return; }

278+ var bs = n % this.DB;

279+ var cbs = this.DB - bs;

280+ var bm = (1 << bs) - 1;

281+ r[0] = this[ds] >> bs;

282+ for (var i = ds + 1; i < this.t; ++i) {

283+ r[i - ds - 1] |= (this[i] & bm) << cbs;

284+ r[i - ds] = this[i] >> bs;

285+ }

286+ if (bs > 0) r[this.t - ds - 1] |= (this.s & bm) << cbs;

287+ r.t = this.t - ds;

288+ r.clamp();

289+ }

290+

291+ // (protected) r = this - a

292+ function bnpSubTo(a, r) {

293+ var i = 0, c = 0, m = Math.min(a.t, this.t);

294+ while (i < m) {

295+ c += this[i] - a[i];

296+ r[i++] = c & this.DM;

297+ c >>= this.DB;

298+ }

299+ if (a.t < this.t) {

300+ c -= a.s;

301+ while (i < this.t) {

302+ c += this[i];

303+ r[i++] = c & this.DM;

304+ c >>= this.DB;

305+ }

306+ c += this.s;

307+ }

308+ else {

309+ c += this.s;

310+ while (i < a.t) {

311+ c -= a[i];

312+ r[i++] = c & this.DM;

313+ c >>= this.DB;

314+ }

315+ c -= a.s;

316+ }

317+ r.s = (c < 0) ? -1 : 0;

318+ if (c < -1) r[i++] = this.DV + c;

319+ else if (c > 0) r[i++] = c;

320+ r.t = i;

321+ r.clamp();

322+ }

323+

324+ // (protected) r = this * a, r != this,a (HAC 14.12)

325+ // "this" should be the larger one if appropriate.

326+ function bnpMultiplyTo(a, r) {

327+ var x = this.abs(), y = a.abs();

328+ var i = x.t;

329+ r.t = i + y.t;

330+ while (--i >= 0) r[i] = 0;

331+ for (i = 0; i < y.t; ++i) r[i + x.t] = x.am(0, y[i], r, i, 0, x.t);

332+ r.s = 0;

333+ r.clamp();

334+ if (this.s != a.s) BigInteger.ZERO.subTo(r, r);

335+ }

336+

337+ // (protected) r = this^2, r != this (HAC 14.16)

338+ function bnpSquareTo(r) {

339+ var x = this.abs();

340+ var i = r.t = 2 * x.t;

341+ while (--i >= 0) r[i] = 0;

342+ for (i = 0; i < x.t - 1; ++i) {

343+ var c = x.am(i, x[i], r, 2 * i, 0, 1);

344+ if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.DV) {

345+ r[i + x.t] -= x.DV;

346+ r[i + x.t + 1] = 1;

347+ }

348+ }

349+ if (r.t > 0) r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1);

350+ r.s = 0;

351+ r.clamp();

352+ }

353+

354+ // (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)

355+ // r != q, this != m. q or r may be null.

356+ function bnpDivRemTo(m, q, r) {

357+ var pm = m.abs();

358+ if (pm.t <= 0) return;

359+ var pt = this.abs();

360+ if (pt.t < pm.t) {

361+ if (q != null) q.fromInt(0);

362+ if (r != null) this.copyTo(r);

363+ return;

364+ }

365+ if (r == null) r = nbi();

366+ var y = nbi(), ts = this.s, ms = m.s;

367+ var nsh = this.DB - nbits(pm[pm.t - 1]); // normalize modulus

368+ if (nsh > 0) { pm.lShiftTo(nsh, y); pt.lShiftTo(nsh, r); }

369+ else { pm.copyTo(y); pt.copyTo(r); }

370+ var ys = y.t;

371+ var y0 = y[ys - 1];

372+ if (y0 == 0) return;

373+ var yt = y0 * (1 << this.F1) + ((ys > 1) ? y[ys - 2] >> this.F2 : 0);

374+ var d1 = this.FV / yt, d2 = (1 << this.F1) / yt, e = 1 << this.F2;

375+ var i = r.t, j = i - ys, t = (q == null) ? nbi() : q;

376+ y.dlShiftTo(j, t);

377+ if (r.compareTo(t) >= 0) {

378+ r[r.t++] = 1;

379+ r.subTo(t, r);

380+ }

381+ BigInteger.ONE.dlShiftTo(ys, t);

382+ t.subTo(y, y); // "negative" y so we can replace sub with am later

383+ while (y.t < ys) y[y.t++] = 0;

384+ while (--j >= 0) {

385+ // Estimate quotient digit

386+ var qd = (r[--i] == y0) ? this.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2);

387+ if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) { // Try it out

388+ y.dlShiftTo(j, t);

389+ r.subTo(t, r);

390+ while (r[i] < --qd) r.subTo(t, r);

391+ }

392+ }

393+ if (q != null) {

394+ r.drShiftTo(ys, q);

395+ if (ts != ms) BigInteger.ZERO.subTo(q, q);

396+ }

397+ r.t = ys;

398+ r.clamp();

399+ if (nsh > 0) r.rShiftTo(nsh, r); // Denormalize remainder

400+ if (ts < 0) BigInteger.ZERO.subTo(r, r);

401+ }

402+

403+ // (public) this mod a

404+ function bnMod(a) {

405+ var r = nbi();

406+ this.abs().divRemTo(a, null, r);

407+ if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r, r);

408+ return r;

409+ }

410+

411+ // Modular reduction using "classic" algorithm

412+ function Classic(m) { this.m = m; }

413+ function cConvert(x) {

414+ if (x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m);

415+ else return x;

416+ }

417+ function cRevert(x) { return x; }

418+ function cReduce(x) { x.divRemTo(this.m, null, x); }

419+ function cMulTo(x, y, r) { x.multiplyTo(y, r); this.reduce(r); }

420+ function cSqrTo(x, r) { x.squareTo(r); this.reduce(r); }

421+

422+ Classic.prototype.convert = cConvert;

423+ Classic.prototype.revert = cRevert;

424+ Classic.prototype.reduce = cReduce;

425+ Classic.prototype.mulTo = cMulTo;

426+ Classic.prototype.sqrTo = cSqrTo;

427+

428+ // (protected) return "-1/this % 2^DB"; useful for Mont. reduction

429+ // justification:

430+ // xy == 1 (mod m)

431+ // xy = 1+km

432+ // xy(2-xy) = (1+km)(1-km)

433+ // x[y(2-xy)] = 1-k^2m^2

434+ // x[y(2-xy)] == 1 (mod m^2)

435+ // if y is 1/x mod m, then y(2-xy) is 1/x mod m^2

436+ // should reduce x and y(2-xy) by m^2 at each step to keep size bounded.

437+ // JS multiply "overflows" differently from C/C++, so care is needed here.

438+ function bnpInvDigit() {

439+ if (this.t < 1) return 0;

440+ var x = this[0];

441+ if ((x & 1) == 0) return 0;

442+ var y = x & 3; // y == 1/x mod 2^2

443+ y = (y * (2 - (x & 0xf) * y)) & 0xf; // y == 1/x mod 2^4

444+ y = (y * (2 - (x & 0xff) * y)) & 0xff; // y == 1/x mod 2^8

445+ y = (y * (2 - (((x & 0xffff) * y) & 0xffff))) & 0xffff; // y == 1/x mod 2^16

446+ // last step - calculate inverse mod DV directly;

447+ // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints

448+ y = (y * (2 - x * y % this.DV)) % this.DV; // y == 1/x mod 2^dbits

449+ // we really want the negative inverse, and -DV < y < DV

450+ return (y > 0) ? this.DV - y : -y;

451+ }

452+

453+ // Montgomery reduction

454+ function Montgomery(m) {

455+ this.m = m;

456+ this.mp = m.invDigit();

457+ this.mpl = this.mp & 0x7fff;

458+ this.mph = this.mp >> 15;

459+ this.um = (1 << (m.DB - 15)) - 1;

460+ this.mt2 = 2 * m.t;

461+ }

462+

463+ // xR mod m

464+ function montConvert(x) {

465+ var r = nbi();

466+ x.abs().dlShiftTo(this.m.t, r);

467+ r.divRemTo(this.m, null, r);

468+ if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r, r);

469+ return r;

470+ }

471+

472+ // x/R mod m

473+ function montRevert(x) {

474+ var r = nbi();

475+ x.copyTo(r);

476+ this.reduce(r);

477+ return r;

478+ }

479+

480+ // x = x/R mod m (HAC 14.32)

481+ function montReduce(x) {

482+ while (x.t <= this.mt2) // pad x so am has enough room later

483+ x[x.t++] = 0;

484+ for (var i = 0; i < this.m.t; ++i) {

485+ // faster way of calculating u0 = x[i]*mp mod DV

486+ var j = x[i] & 0x7fff;

487+ var u0 = (j * this.mpl + (((j * this.mph + (x[i] >> 15) * this.mpl) & this.um) << 15)) & x.DM;

488+ // use am to combine the multiply-shift-add into one call

489+ j = i + this.m.t;

490+ x[j] += this.m.am(0, u0, x, i, 0, this.m.t);

491+ // propagate carry

492+ while (x[j] >= x.DV) { x[j] -= x.DV; x[++j]++; }

493+ }

494+ x.clamp();

495+ x.drShiftTo(this.m.t, x);

496+ if (x.compareTo(this.m) >= 0) x.subTo(this.m, x);

497+ }

498+

499+ // r = "x^2/R mod m"; x != r

500+ function montSqrTo(x, r) { x.squareTo(r); this.reduce(r); }

501+

502+ // r = "xy/R mod m"; x,y != r

503+ function montMulTo(x, y, r) { x.multiplyTo(y, r); this.reduce(r); }

504+

505+ Montgomery.prototype.convert = montConvert;

506+ Montgomery.prototype.revert = montRevert;

507+ Montgomery.prototype.reduce = montReduce;

508+ Montgomery.prototype.mulTo = montMulTo;

509+ Montgomery.prototype.sqrTo = montSqrTo;

510+

511+ // (protected) true iff this is even

512+ function bnpIsEven() { return ((this.t > 0) ? (this[0] & 1) : this.s) == 0; }

513+

514+ // (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)

515+ function bnpExp(e, z) {

516+ if (e > 0xffffffff || e < 1) return BigInteger.ONE;

517+ var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e) - 1;

518+ g.copyTo(r);

519+ while (--i >= 0) {

520+ z.sqrTo(r, r2);

521+ if ((e & (1 << i)) > 0) z.mulTo(r2, g, r);

522+ else { var t = r; r = r2; r2 = t; }

523+ }

524+ return z.revert(r);

525+ }

526+

527+ // (public) this^e % m, 0 <= e < 2^32

528+ function bnModPowInt(e, m) {

529+ var z;

530+ if (e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m);

531+ return this.exp(e, z);

532+ }

533+

534+ // protected

535+ BigInteger.prototype.copyTo = bnpCopyTo;

536+ BigInteger.prototype.fromInt = bnpFromInt;

537+ BigInteger.prototype.fromString = bnpFromString;

538+ BigInteger.prototype.clamp = bnpClamp;

539+ BigInteger.prototype.dlShiftTo = bnpDLShiftTo;

540+ BigInteger.prototype.drShiftTo = bnpDRShiftTo;

541+ BigInteger.prototype.lShiftTo = bnpLShiftTo;

542+ BigInteger.prototype.rShiftTo = bnpRShiftTo;

543+ BigInteger.prototype.subTo = bnpSubTo;

544+ BigInteger.prototype.multiplyTo = bnpMultiplyTo;

545+ BigInteger.prototype.squareTo = bnpSquareTo;

546+ BigInteger.prototype.divRemTo = bnpDivRemTo;

547+ BigInteger.prototype.invDigit = bnpInvDigit;

548+ BigInteger.prototype.isEven = bnpIsEven;

549+ BigInteger.prototype.exp = bnpExp;

550+

551+ // public

552+ BigInteger.prototype.toString = bnToString;

553+ BigInteger.prototype.negate = bnNegate;

554+ BigInteger.prototype.abs = bnAbs;

555+ BigInteger.prototype.compareTo = bnCompareTo;

556+ BigInteger.prototype.bitLength = bnBitLength;

557+ BigInteger.prototype.mod = bnMod;

558+ BigInteger.prototype.modPowInt = bnModPowInt;

559+

560+ // "constants"

561+ BigInteger.ZERO = nbv(0);

562+ BigInteger.ONE = nbv(1);

563+

566+ // See "LICENSE" for details.

567+

568+ // Extended JavaScript BN functions, required for RSA private ops.

569+

570+ // Version 1.1: new BigInteger("0", 10) returns "proper" zero

571+ // Version 1.2: square() API, isProbablePrime fix

572+

573+ // (public)

574+ function bnClone() { var r = nbi(); this.copyTo(r); return r; }

575+

576+ // (public) return value as integer

577+ function bnIntValue() {

578+ if (this.s < 0) {

579+ if (this.t == 1) return this[0] - this.DV;

580+ else if (this.t == 0) return -1;

581+ }

582+ else if (this.t == 1) return this[0];

583+ else if (this.t == 0) return 0;

584+ // assumes 16 < DB < 32

585+ return ((this[1] & ((1 << (32 - this.DB)) - 1)) << this.DB) | this[0];

586+ }

587+

588+ // (public) return value as byte

589+ function bnByteValue() { return (this.t == 0) ? this.s : (this[0] << 24) >> 24; }

590+

591+ // (public) return value as short (assumes DB>=16)

592+ function bnShortValue() { return (this.t == 0) ? this.s : (this[0] << 16) >> 16; }

593+

594+ // (protected) return x s.t. r^x < DV

595+ function bnpChunkSize(r) { return Math.floor(Math.LN2 * this.DB / Math.log(r)); }

596+

597+ // (public) 0 if this == 0, 1 if this > 0

598+ function bnSigNum() {

599+ if (this.s < 0) return -1;

600+ else if (this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0;

601+ else return 1;

602+ }

603+

604+ // (protected) convert to radix string

605+ function bnpToRadix(b) {

606+ if (b == null) b = 10;

607+ if (this.signum() == 0 || b < 2 || b > 36) return "0";

608+ var cs = this.chunkSize(b);

609+ var a = Math.pow(b, cs);

610+ var d = nbv(a), y = nbi(), z = nbi(), r = "";

611+ this.divRemTo(d, y, z);

612+ while (y.signum() > 0) {

613+ r = (a + z.intValue()).toString(b).substr(1) + r;

614+ y.divRemTo(d, y, z);

615+ }

616+ return z.intValue().toString(b) + r;

617+ }

618+

619+ // (protected) convert from radix string

620+ function bnpFromRadix(s, b) {

621+ this.fromInt(0);

622+ if (b == null) b = 10;

623+ var cs = this.chunkSize(b);

624+ var d = Math.pow(b, cs), mi = false, j = 0, w = 0;

625+ for (var i = 0; i < s.length; ++i) {

626+ var x = intAt(s, i);

627+ if (x < 0) {

628+ if (s.charAt(i) == "-" && this.signum() == 0) mi = true;

629+ continue;

630+ }

631+ w = b * w + x;

632+ if (++j >= cs) {

633+ this.dMultiply(d);

634+ this.dAddOffset(w, 0);

635+ j = 0;

636+ w = 0;

637+ }

638+ }

639+ if (j > 0) {

640+ this.dMultiply(Math.pow(b, j));

641+ this.dAddOffset(w, 0);

642+ }

643+ if (mi) BigInteger.ZERO.subTo(this, this);

644+ }

645+

646+ // (protected) alternate constructor

647+ function bnpFromNumber(a, b, c) {

648+ if ("number" == typeof b) {

649+ // new BigInteger(int,int,RNG)

650+ if (a < 2) this.fromInt(1);

651+ else {

652+ this.fromNumber(a, c);

653+ if (!this.testBit(a - 1)) // force MSB set

654+ this.bitwiseTo(BigInteger.ONE.shiftLeft(a - 1), op_or, this);

655+ if (this.isEven()) this.dAddOffset(1, 0); // force odd

656+ while (!this.isProbablePrime(b)) {

657+ this.dAddOffset(2, 0);

658+ if (this.bitLength() > a) this.subTo(BigInteger.ONE.shiftLeft(a - 1), this);

659+ }

660+ }

661+ }

662+ else {

663+ // new BigInteger(int,RNG)

664+ var x = new Array(), t = a & 7;

665+ x.length = (a >> 3) + 1;

666+ b.nextBytes(x);

667+ if (t > 0) x[0] &= ((1 << t) - 1); else x[0] = 0;

668+ this.fromString(x, 256);

669+ }

670+ }

671+

672+ // (public) convert to bigendian byte array

673+ function bnToByteArray() {

674+ var i = this.t, r = new Array();

675+ r[0] = this.s;

676+ var p = this.DB - (i * this.DB) % 8, d, k = 0;

677+ if (i-- > 0) {

678+ if (p < this.DB && (d = this[i] >> p) != (this.s & this.DM) >> p)

679+ r[k++] = d | (this.s << (this.DB - p));

680+ while (i >= 0) {

681+ if (p < 8) {

682+ d = (this[i] & ((1 << p) - 1)) << (8 - p);

683+ d |= this[--i] >> (p += this.DB - 8);

684+ }

685+ else {

686+ d = (this[i] >> (p -= 8)) & 0xff;

687+ if (p <= 0) { p += this.DB; --i; }

688+ }

689+ if ((d & 0x80) != 0) d |= -256;

690+ if (k == 0 && (this.s & 0x80) != (d & 0x80))++k;

691+ if (k > 0 || d != this.s) r[k++] = d;

692+ }

693+ }

694+ return r;

695+ }

696+

697+ function bnEquals(a) { return (this.compareTo(a) == 0); }

698+ function bnMin(a) { return (this.compareTo(a) < 0) ? this : a; }

699+ function bnMax(a) { return (this.compareTo(a) > 0) ? this : a; }

700+

701+ // (protected) r = this op a (bitwise)

702+ function bnpBitwiseTo(a, op, r) {

703+ var i, f, m = Math.min(a.t, this.t);

704+ for (i = 0; i < m; ++i) r[i] = op(this[i], a[i]);

705+ if (a.t < this.t) {

706+ f = a.s & this.DM;

707+ for (i = m; i < this.t; ++i) r[i] = op(this[i], f);

708+ r.t = this.t;

709+ }

710+ else {

711+ f = this.s & this.DM;

712+ for (i = m; i < a.t; ++i) r[i] = op(f, a[i]);

713+ r.t = a.t;

714+ }

715+ r.s = op(this.s, a.s);

716+ r.clamp();

717+ }

718+

719+ // (public) this & a

720+ function op_and(x, y) { return x & y; }

721+ function bnAnd(a) { var r = nbi(); this.bitwiseTo(a, op_and, r); return r; }

722+

723+ // (public) this | a

724+ function op_or(x, y) { return x | y; }

725+ function bnOr(a) { var r = nbi(); this.bitwiseTo(a, op_or, r); return r; }

726+

727+ // (public) this ^ a

728+ function op_xor(x, y) { return x ^ y; }

729+ function bnXor(a) { var r = nbi(); this.bitwiseTo(a, op_xor, r); return r; }

730+

731+ // (public) this & ~a

732+ function op_andnot(x, y) { return x & ~y; }

733+ function bnAndNot(a) { var r = nbi(); this.bitwiseTo(a, op_andnot, r); return r; }

734+

735+ // (public) ~this

736+ function bnNot() {

737+ var r = nbi();

738+ for (var i = 0; i < this.t; ++i) r[i] = this.DM & ~this[i];

739+ r.t = this.t;

740+ r.s = ~this.s;

741+ return r;

742+ }

743+

744+ // (public) this << n

745+ function bnShiftLeft(n) {

746+ var r = nbi();

747+ if (n < 0) this.rShiftTo(-n, r); else this.lShiftTo(n, r);

748+ return r;

749+ }

750+

751+ // (public) this >> n

752+ function bnShiftRight(n) {

753+ var r = nbi();

754+ if (n < 0) this.lShiftTo(-n, r); else this.rShiftTo(n, r);

755+ return r;

756+ }

757+

758+ // return index of lowest 1-bit in x, x < 2^31

759+ function lbit(x) {

760+ if (x == 0) return -1;

761+ var r = 0;

762+ if ((x & 0xffff) == 0) { x >>= 16; r += 16; }

763+ if ((x & 0xff) == 0) { x >>= 8; r += 8; }

764+ if ((x & 0xf) == 0) { x >>= 4; r += 4; }

765+ if ((x & 3) == 0) { x >>= 2; r += 2; }

766+ if ((x & 1) == 0)++r;

767+ return r;

768+ }

769+

770+ // (public) returns index of lowest 1-bit (or -1 if none)

771+ function bnGetLowestSetBit() {

772+ for (var i = 0; i < this.t; ++i)

773+ if (this[i] != 0) return i * this.DB + lbit(this[i]);

774+ if (this.s < 0) return this.t * this.DB;

775+ return -1;

776+ }

777+

778+ // return number of 1 bits in x

779+ function cbit(x) {

780+ var r = 0;

781+ while (x != 0) { x &= x - 1; ++r; }

782+ return r;

783+ }

784+

785+ // (public) return number of set bits

786+ function bnBitCount() {

787+ var r = 0, x = this.s & this.DM;

788+ for (var i = 0; i < this.t; ++i) r += cbit(this[i] ^ x);

789+ return r;

790+ }

791+

792+ // (public) true iff nth bit is set

793+ function bnTestBit(n) {

794+ var j = Math.floor(n / this.DB);

795+ if (j >= this.t) return (this.s != 0);

796+ return ((this[j] & (1 << (n % this.DB))) != 0);

797+ }

798+

799+ // (protected) this op (1<<n)

800+ function bnpChangeBit(n, op) {

801+ var r = BigInteger.ONE.shiftLeft(n);

802+ this.bitwiseTo(r, op, r);

803+ return r;

804+ }

805+

806+ // (public) this | (1<<n)

807+ function bnSetBit(n) { return this.changeBit(n, op_or); }

808+

809+ // (public) this & ~(1<<n)

810+ function bnClearBit(n) { return this.changeBit(n, op_andnot); }

811+

812+ // (public) this ^ (1<<n)

813+ function bnFlipBit(n) { return this.changeBit(n, op_xor); }

814+

815+ // (protected) r = this + a

816+ function bnpAddTo(a, r) {

817+ var i = 0, c = 0, m = Math.min(a.t, this.t);

818+ while (i < m) {

819+ c += this[i] + a[i];

820+ r[i++] = c & this.DM;

821+ c >>= this.DB;

822+ }

823+ if (a.t < this.t) {

824+ c += a.s;

825+ while (i < this.t) {

826+ c += this[i];

827+ r[i++] = c & this.DM;

828+ c >>= this.DB;

829+ }

830+ c += this.s;

831+ }

832+ else {

833+ c += this.s;

834+ while (i < a.t) {

835+ c += a[i];

836+ r[i++] = c & this.DM;

837+ c >>= this.DB;

838+ }

839+ c += a.s;

840+ }

841+ r.s = (c < 0) ? -1 : 0;

842+ if (c > 0) r[i++] = c;

843+ else if (c < -1) r[i++] = this.DV + c;

844+ r.t = i;

845+ r.clamp();

846+ }

847+

848+ // (public) this + a

849+ function bnAdd(a) { var r = nbi(); this.addTo(a, r); return r; }

850+

851+ // (public) this - a

852+ function bnSubtract(a) { var r = nbi(); this.subTo(a, r); return r; }

853+

854+ // (public) this * a

855+ function bnMultiply(a) { var r = nbi(); this.multiplyTo(a, r); return r; }

856+

857+ // (public) this^2

858+ function bnSquare() { var r = nbi(); this.squareTo(r); return r; }

859+

860+ // (public) this / a

861+ function bnDivide(a) { var r = nbi(); this.divRemTo(a, r, null); return r; }

862+

863+ // (public) this % a

864+ function bnRemainder(a) { var r = nbi(); this.divRemTo(a, null, r); return r; }

865+

866+ // (public) [this/a,this%a]

867+ function bnDivideAndRemainder(a) {

868+ var q = nbi(), r = nbi();

869+ this.divRemTo(a, q, r);

870+ return new Array(q, r);

871+ }

872+

873+ // (protected) this *= n, this >= 0, 1 < n < DV

874+ function bnpDMultiply(n) {

875+ this[this.t] = this.am(0, n - 1, this, 0, 0, this.t);

876+ ++this.t;

877+ this.clamp();

878+ }

879+

880+ // (protected) this += n << w words, this >= 0

881+ function bnpDAddOffset(n, w) {

882+ if (n == 0) return;

883+ while (this.t <= w) this[this.t++] = 0;

884+ this[w] += n;

885+ while (this[w] >= this.DV) {

886+ this[w] -= this.DV;

887+ if (++w >= this.t) this[this.t++] = 0;

888+ ++this[w];

889+ }

890+ }

891+

892+ // A "null" reducer

893+ function NullExp() { }

894+ function nNop(x) { return x; }

895+ function nMulTo(x, y, r) { x.multiplyTo(y, r); }

896+ function nSqrTo(x, r) { x.squareTo(r); }

897+

898+ NullExp.prototype.convert = nNop;

899+ NullExp.prototype.revert = nNop;

900+ NullExp.prototype.mulTo = nMulTo;

901+ NullExp.prototype.sqrTo = nSqrTo;

902+

903+ // (public) this^e

904+ function bnPow(e) { return this.exp(e, new NullExp()); }

905+

906+ // (protected) r = lower n words of "this * a", a.t <= n

907+ // "this" should be the larger one if appropriate.

908+ function bnpMultiplyLowerTo(a, n, r) {

909+ var i = Math.min(this.t + a.t, n);

910+ r.s = 0; // assumes a,this >= 0

911+ r.t = i;

912+ while (i > 0) r[--i] = 0;

913+ var j;

914+ for (j = r.t - this.t; i < j; ++i) r[i + this.t] = this.am(0, a[i], r, i, 0, this.t);

915+ for (j = Math.min(a.t, n); i < j; ++i) this.am(0, a[i], r, i, 0, n - i);

916+ r.clamp();

917+ }

918+

919+ // (protected) r = "this * a" without lower n words, n > 0

920+ // "this" should be the larger one if appropriate.

921+ function bnpMultiplyUpperTo(a, n, r) {

922+ --n;

923+ var i = r.t = this.t + a.t - n;

924+ r.s = 0; // assumes a,this >= 0

925+ while (--i >= 0) r[i] = 0;

926+ for (i = Math.max(n - this.t, 0); i < a.t; ++i)

927+ r[this.t + i - n] = this.am(n - i, a[i], r, 0, 0, this.t + i - n);

928+ r.clamp();

929+ r.drShiftTo(1, r);

930+ }

931+

932+ // Barrett modular reduction

933+ function Barrett(m) {

934+ // setup Barrett

935+ this.r2 = nbi();

936+ this.q3 = nbi();

937+ BigInteger.ONE.dlShiftTo(2 * m.t, this.r2);

938+ this.mu = this.r2.divide(m);

939+ this.m = m;

940+ }

941+

942+ function barrettConvert(x) {

943+ if (x.s < 0 || x.t > 2 * this.m.t) return x.mod(this.m);

944+ else if (x.compareTo(this.m) < 0) return x;

945+ else { var r = nbi(); x.copyTo(r); this.reduce(r); return r; }

946+ }

947+

948+ function barrettRevert(x) { return x; }

949+

950+ // x = x mod m (HAC 14.42)

951+ function barrettReduce(x) {

952+ x.drShiftTo(this.m.t - 1, this.r2);

953+ if (x.t > this.m.t + 1) { x.t = this.m.t + 1; x.clamp(); }

954+ this.mu.multiplyUpperTo(this.r2, this.m.t + 1, this.q3);

955+ this.m.multiplyLowerTo(this.q3, this.m.t + 1, this.r2);

956+ while (x.compareTo(this.r2) < 0) x.dAddOffset(1, this.m.t + 1);

957+ x.subTo(this.r2, x);

958+ while (x.compareTo(this.m) >= 0) x.subTo(this.m, x);

959+ }

960+

961+ // r = x^2 mod m; x != r

962+ function barrettSqrTo(x, r) { x.squareTo(r); this.reduce(r); }

963+

964+ // r = x*y mod m; x,y != r

965+ function barrettMulTo(x, y, r) { x.multiplyTo(y, r); this.reduce(r); }

966+

967+ Barrett.prototype.convert = barrettConvert;

968+ Barrett.prototype.revert = barrettRevert;

969+ Barrett.prototype.reduce = barrettReduce;

970+ Barrett.prototype.mulTo = barrettMulTo;

971+ Barrett.prototype.sqrTo = barrettSqrTo;

972+

973+ // (public) this^e % m (HAC 14.85)

974+ function bnModPow(e, m) {

975+ var i = e.bitLength(), k, r = nbv(1), z;

976+ if (i <= 0) return r;

977+ else if (i < 18) k = 1;

978+ else if (i < 48) k = 3;

979+ else if (i < 144) k = 4;

980+ else if (i < 768) k = 5;

981+ else k = 6;

982+ if (i < 8)

983+ z = new Classic(m);

984+ else if (m.isEven())

985+ z = new Barrett(m);

986+ else

987+ z = new Montgomery(m);

988+

989+ // precomputation

990+ var g = new Array(), n = 3, k1 = k - 1, km = (1 << k) - 1;

991+ g[1] = z.convert(this);

992+ if (k > 1) {

993+ var g2 = nbi();

994+ z.sqrTo(g[1], g2);

995+ while (n <= km) {

996+ g[n] = nbi();

997+ z.mulTo(g2, g[n - 2], g[n]);

998+ n += 2;

999+ }

1000+ }

1001+

1002+ var j = e.t - 1, w, is1 = true, r2 = nbi(), t;

1003+ i = nbits(e[j]) - 1;

1004+ while (j >= 0) {

1005+ if (i >= k1) w = (e[j] >> (i - k1)) & km;

1006+ else {

1007+ w = (e[j] & ((1 << (i + 1)) - 1)) << (k1 - i);

1008+ if (j > 0) w |= e[j - 1] >> (this.DB + i - k1);

1009+ }

1010+

1011+ n = k;

1012+ while ((w & 1) == 0) { w >>= 1; --n; }

1013+ if ((i -= n) < 0) { i += this.DB; --j; }

1014+ if (is1) { // ret == 1, don't bother squaring or multiplying it

1015+ g[w].copyTo(r);

1016+ is1 = false;

1017+ }

1018+ else {

1019+ while (n > 1) { z.sqrTo(r, r2); z.sqrTo(r2, r); n -= 2; }

1020+ if (n > 0) z.sqrTo(r, r2); else { t = r; r = r2; r2 = t; }

1021+ z.mulTo(r2, g[w], r);

1022+ }

1023+

1024+ while (j >= 0 && (e[j] & (1 << i)) == 0) {

1025+ z.sqrTo(r, r2); t = r; r = r2; r2 = t;

1026+ if (--i < 0) { i = this.DB - 1; --j; }

1027+ }

1028+ }

1029+ return z.revert(r);

1030+ }

1031+

1032+ // (public) gcd(this,a) (HAC 14.54)

1033+ function bnGCD(a) {

1034+ var x = (this.s < 0) ? this.negate() : this.clone();

1035+ var y = (a.s < 0) ? a.negate() : a.clone();

1036+ if (x.compareTo(y) < 0) { var t = x; x = y; y = t; }

1037+ var i = x.getLowestSetBit(), g = y.getLowestSetBit();

1038+ if (g < 0) return x;

1039+ if (i < g) g = i;

1040+ if (g > 0) {

1041+ x.rShiftTo(g, x);

1042+ y.rShiftTo(g, y);

1043+ }

1044+ while (x.signum() > 0) {

1045+ if ((i = x.getLowestSetBit()) > 0) x.rShiftTo(i, x);

1046+ if ((i = y.getLowestSetBit()) > 0) y.rShiftTo(i, y);

1047+ if (x.compareTo(y) >= 0) {

1048+ x.subTo(y, x);

1049+ x.rShiftTo(1, x);

1050+ }

1051+ else {

1052+ y.subTo(x, y);

1053+ y.rShiftTo(1, y);

1054+ }

1055+ }

1056+ if (g > 0) y.lShiftTo(g, y);

1057+ return y;

1058+ }

1059+

1060+ // (protected) this % n, n < 2^26

1061+ function bnpModInt(n) {

1062+ if (n <= 0) return 0;

1063+ var d = this.DV % n, r = (this.s < 0) ? n - 1 : 0;

1064+ if (this.t > 0)

1065+ if (d == 0) r = this[0] % n;

1066+ else for (var i = this.t - 1; i >= 0; --i) r = (d * r + this[i]) % n;

1067+ return r;

1068+ }

1069+

1070+ // (public) 1/this % m (HAC 14.61)

1071+ function bnModInverse(m) {

1072+ var ac = m.isEven();

1073+ if ((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO;

1074+ var u = m.clone(), v = this.clone();

1075+ var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1);

1076+ while (u.signum() != 0) {

1077+ while (u.isEven()) {

1078+ u.rShiftTo(1, u);

1079+ if (ac) {

1080+ if (!a.isEven() || !b.isEven()) { a.addTo(this, a); b.subTo(m, b); }

1081+ a.rShiftTo(1, a);

1082+ }

1083+ else if (!b.isEven()) b.subTo(m, b);

1084+ b.rShiftTo(1, b);

1085+ }

1086+ while (v.isEven()) {

1087+ v.rShiftTo(1, v);

1088+ if (ac) {

1089+ if (!c.isEven() || !d.isEven()) { c.addTo(this, c); d.subTo(m, d); }

1090+ c.rShiftTo(1, c);

1091+ }

1092+ else if (!d.isEven()) d.subTo(m, d);

1093+ d.rShiftTo(1, d);

1094+ }

1095+ if (u.compareTo(v) >= 0) {

1096+ u.subTo(v, u);

1097+ if (ac) a.subTo(c, a);

1098+ b.subTo(d, b);

1099+ }

1100+ else {

1101+ v.subTo(u, v);

1102+ if (ac) c.subTo(a, c);

1103+ d.subTo(b, d);

1104+ }

1105+ }

1106+ if (v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO;

1107+ if (d.compareTo(m) >= 0) return d.subtract(m);

1108+ if (d.signum() < 0) d.addTo(m, d); else return d;

1109+ if (d.signum() < 0) return d.add(m); else return d;

1110+ }

1111+

1112+ var lowprimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997];

1113+ var lplim = (1 << 26) / lowprimes[lowprimes.length - 1];

1114+

1115+ // (public) test primality with certainty >= 1-.5^t

1116+ function bnIsProbablePrime(t) {

1117+ var i, x = this.abs();

1118+ if (x.t == 1 && x[0] <= lowprimes[lowprimes.length - 1]) {

1119+ for (i = 0; i < lowprimes.length; ++i)

1120+ if (x[0] == lowprimes[i]) return true;

1121+ return false;

1122+ }

1123+ if (x.isEven()) return false;

1124+ i = 1;

1125+ while (i < lowprimes.length) {

1126+ var m = lowprimes[i], j = i + 1;

1127+ while (j < lowprimes.length && m < lplim) m *= lowprimes[j++];

1128+ m = x.modInt(m);

1129+ while (i < j) if (m % lowprimes[i++] == 0) return false;

1130+ }

1131+ return x.millerRabin(t);

1132+ }

1133+

1134+ // (protected) true if probably prime (HAC 4.24, Miller-Rabin)

1135+ function bnpMillerRabin(t) {

1136+ var n1 = this.subtract(BigInteger.ONE);

1137+ var k = n1.getLowestSetBit();

1138+ if (k <= 0) return false;

1139+ var r = n1.shiftRight(k);

1140+ t = (t + 1) >> 1;

1141+ if (t > lowprimes.length) t = lowprimes.length;

1142+ var a = nbi();

1143+ for (var i = 0; i < t; ++i) {

1144+ //Pick bases at random, instead of starting at 2

1145+ a.fromInt(lowprimes[Math.floor(Math.random() * lowprimes.length)]);

1146+ var y = a.modPow(r, this);

1147+ if (y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {

1148+ var j = 1;

1149+ while (j++ < k && y.compareTo(n1) != 0) {

1150+ y = y.modPowInt(2, this);

1151+ if (y.compareTo(BigInteger.ONE) == 0) return false;

1152+ }

1153+ if (y.compareTo(n1) != 0) return false;

1154+ }

1155+ }

1156+ return true;

1157+ }

1158+

1159+ // protected

1160+ BigInteger.prototype.chunkSize = bnpChunkSize;

1161+ BigInteger.prototype.toRadix = bnpToRadix;

1162+ BigInteger.prototype.fromRadix = bnpFromRadix;

1163+ BigInteger.prototype.fromNumber = bnpFromNumber;

1164+ BigInteger.prototype.bitwiseTo = bnpBitwiseTo;

1165+ BigInteger.prototype.changeBit = bnpChangeBit;

1166+ BigInteger.prototype.addTo = bnpAddTo;

1167+ BigInteger.prototype.dMultiply = bnpDMultiply;

1168+ BigInteger.prototype.dAddOffset = bnpDAddOffset;

1169+ BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;

1170+ BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;

1171+ BigInteger.prototype.modInt = bnpModInt;

1172+ BigInteger.prototype.millerRabin = bnpMillerRabin;

1173+

1174+ // public

1175+ BigInteger.prototype.clone = bnClone;

1176+ BigInteger.prototype.intValue = bnIntValue;

1177+ BigInteger.prototype.byteValue = bnByteValue;

1178+ BigInteger.prototype.shortValue = bnShortValue;

1179+ BigInteger.prototype.signum = bnSigNum;

1180+ BigInteger.prototype.toByteArray = bnToByteArray;

1181+ BigInteger.prototype.equals = bnEquals;

1182+ BigInteger.prototype.min = bnMin;

1183+ BigInteger.prototype.max = bnMax;

1184+ BigInteger.prototype.and = bnAnd;

1185+ BigInteger.prototype.or = bnOr;

1186+ BigInteger.prototype.xor = bnXor;

1187+ BigInteger.prototype.andNot = bnAndNot;

1188+ BigInteger.prototype.not = bnNot;

1189+ BigInteger.prototype.shiftLeft = bnShiftLeft;

1190+ BigInteger.prototype.shiftRight = bnShiftRight;

1191+ BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;

1192+ BigInteger.prototype.bitCount = bnBitCount;

1193+ BigInteger.prototype.testBit = bnTestBit;

1194+ BigInteger.prototype.setBit = bnSetBit;

1195+ BigInteger.prototype.clearBit = bnClearBit;

1196+ BigInteger.prototype.flipBit = bnFlipBit;

1197+ BigInteger.prototype.add = bnAdd;

1198+ BigInteger.prototype.subtract = bnSubtract;

1199+ BigInteger.prototype.multiply = bnMultiply;

1200+ BigInteger.prototype.divide = bnDivide;

1201+ BigInteger.prototype.remainder = bnRemainder;

1202+ BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;

1203+ BigInteger.prototype.modPow = bnModPow;

1204+ BigInteger.prototype.modInverse = bnModInverse;

1205+ BigInteger.prototype.pow = bnPow;

1206+ BigInteger.prototype.gcd = bnGCD;

1207+ BigInteger.prototype.isProbablePrime = bnIsProbablePrime;

1208+

1209+ // JSBN-specific extension

1210+ BigInteger.prototype.square = bnSquare;

1211+

1212+ // Expose the Barrett function

1213+ BigInteger.prototype.Barrett = Barrett

1214+

1215+ // BigInteger interfaces not implemented in jsbn:

1216+

1217+ // BigInteger(int signum, byte[] magnitude)

1218+ // double doubleValue()

1219+ // float floatValue()

1220+ // int hashCode()

1221+ // long longValue()

1222+ // static BigInteger valueOf(long val)

1223+

1224+ // Random number generator - requires a PRNG backend, e.g. prng4.js

1225+

1226+ // For best results, put code like

1227+ // <body onClick='rng_seed_time();' onKeyPress='rng_seed_time();'>

1228+ // in your main HTML document.

1229+

1230+ var rng_state;

1231+ var rng_pool;

1232+ var rng_pptr;

1233+

1234+ // Mix in a 32-bit integer into the pool

1235+ function rng_seed_int(x) {

1236+ rng_pool[rng_pptr++] ^= x & 255;

1237+ rng_pool[rng_pptr++] ^= (x >> 8) & 255;

1238+ rng_pool[rng_pptr++] ^= (x >> 16) & 255;

1239+ rng_pool[rng_pptr++] ^= (x >> 24) & 255;

1240+ if (rng_pptr >= rng_psize) rng_pptr -= rng_psize;

1241+ }

1242+

1243+ // Mix in the current time (w/milliseconds) into the pool

1244+ function rng_seed_time() {

1245+ rng_seed_int(new Date().getTime());

1246+ }

1247+

1248+ // Initialize the pool with junk if needed.

1249+ if (rng_pool == null) {

1250+ rng_pool = new Array();

1251+ rng_pptr = 0;

1252+ var t;

1253+ if (typeof window !== "undefined" && window.crypto) {

1254+ if (window.crypto.getRandomValues) {

1255+ // Use webcrypto if available

1256+ var ua = new Uint8Array(32);

1257+ window.crypto.getRandomValues(ua);

1258+ for (t = 0; t < 32; ++t)

1259+ rng_pool[rng_pptr++] = ua[t];

1260+ }

1261+ else if (navigator.appName == "Netscape" && navigator.appVersion < "5") {

1262+ // Extract entropy (256 bits) from NS4 RNG if available

1263+ var z = window.crypto.random(32);

1264+ for (t = 0; t < z.length; ++t)

1265+ rng_pool[rng_pptr++] = z.charCodeAt(t) & 255;

1266+ }

1267+ }

1268+ while (rng_pptr < rng_psize) { // extract some randomness from Math.random()

1269+ t = Math.floor(65536 * Math.random());

1270+ rng_pool[rng_pptr++] = t >>> 8;

1271+ rng_pool[rng_pptr++] = t & 255;

1272+ }

1273+ rng_pptr = 0;

1274+ rng_seed_time();

1275+ //rng_seed_int(window.screenX);

1276+ //rng_seed_int(window.screenY);

1277+ }

1278+

1279+ function rng_get_byte() {

1280+ if (rng_state == null) {

1281+ rng_seed_time();

1282+ rng_state = prng_newstate();

1283+ rng_state.init(rng_pool);

1284+ for (rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr)

1285+ rng_pool[rng_pptr] = 0;

1286+ rng_pptr = 0;

1287+ //rng_pool = null;

1288+ }

1289+ // TODO: allow reseeding after first request

1290+ return rng_state.next();

1291+ }

1292+

1293+ function rng_get_bytes(ba) {

1294+ var i;

1295+ for (i = 0; i < ba.length; ++i) ba[i] = rng_get_byte();

1296+ }

1297+

1298+ function SecureRandom() { }

1299+

1300+ SecureRandom.prototype.nextBytes = rng_get_bytes;

1301+

1302+ // prng4.js - uses Arcfour as a PRNG

1303+

1304+ function Arcfour() {

1305+ this.i = 0;

1306+ this.j = 0;

1307+ this.S = new Array();

1308+ }

1309+

1310+ // Initialize arcfour context from key, an array of ints, each from [0..255]

1311+ function ARC4init(key) {

1312+ var i, j, t;

1313+ for (i = 0; i < 256; ++i)

1314+ this.S[i] = i;

1315+ j = 0;

1316+ for (i = 0; i < 256; ++i) {

1317+ j = (j + this.S[i] + key[i % key.length]) & 255;

1318+ t = this.S[i];

1319+ this.S[i] = this.S[j];

1320+ this.S[j] = t;

1321+ }

1322+ this.i = 0;

1323+ this.j = 0;

1324+ }

1325+

1326+ function ARC4next() {

1327+ var t;

1328+ this.i = (this.i + 1) & 255;

1329+ this.j = (this.j + this.S[this.i]) & 255;

1330+ t = this.S[this.i];

1331+ this.S[this.i] = this.S[this.j];

1332+ this.S[this.j] = t;

1333+ return this.S[(t + this.S[this.i]) & 255];

1334+ }

1335+

1336+ Arcfour.prototype.init = ARC4init;

1337+ Arcfour.prototype.next = ARC4next;

1338+

1339+ // Plug in your RNG constructor here

1340+ function prng_newstate() {

1341+ return new Arcfour();

1342+ }

1343+

1344+ // Pool size must be a multiple of 4 and greater than 32.

1345+ // An array of bytes the size of the pool will be passed to init()

1346+ var rng_psize = 256;

1347+

1348+ return {

1349+ BigInteger: BigInteger,

1350+ SecureRandom: SecureRandom

1351+ };

1352+

1353+}).call(this);

jsrts/jsbn/jsbn-node.jsnew file+1

@@ -0,0 +1 @@

1+$JSRTS.jsbn = require('jsbn');

jsrts/jsbn/jsbn.jsdeleted−1353

@@ -1,1353 +0,0 @@

1−var jsbn = (function(){

2−

5− // See "LICENSE" for details.

6−

7− // Basic JavaScript BN library - subset useful for RSA encryption.

8−

9− // Bits per digit

10− var dbits;

11−

12− // JavaScript engine analysis

13− var canary = 0xdeadbeefcafe;

14− var j_lm = ((canary&0xffffff)==0xefcafe);

15−

16− // (public) Constructor

17− function BigInteger(a,b,c) {

18− if(a != null)

19− if("number" == typeof a) this.fromNumber(a,b,c);

20− else if(b == null && "string" != typeof a) this.fromString(a,256);

21− else this.fromString(a,b);

22− }

23−

24− // return new, unset BigInteger

25− function nbi() { return new BigInteger(null); }

26−

27− // am: Compute w_j += (x*this_i), propagate carries,

28− // c is initial carry, returns final carry.

29− // c < 3*dvalue, x < 2*dvalue, this_i < dvalue

30− // We need to select the fastest one that works in this environment.

31−

32− // am1: use a single mult and divide to get the high bits,

33− // max digit bits should be 26 because

34− // max internal value = 2*dvalue^2-2*dvalue (< 2^53)

35− function am1(i,x,w,j,c,n) {

36− while(--n >= 0) {

37− var v = x*this[i++]+w[j]+c;

38− c = Math.floor(v/0x4000000);

39− w[j++] = v&0x3ffffff;

40− }

41− return c;

42− }

43− // am2 avoids a big mult-and-extract completely.

44− // Max digit bits should be <= 30 because we do bitwise ops

45− // on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)

46− function am2(i,x,w,j,c,n) {

47− var xl = x&0x7fff, xh = x>>15;

48− while(--n >= 0) {

49− var l = this[i]&0x7fff;

50− var h = this[i++]>>15;

51− var m = xh*l+h*xl;

52− l = xl*l+((m&0x7fff)<<15)+w[j]+(c&0x3fffffff);

53− c = (l>>>30)+(m>>>15)+xh*h+(c>>>30);

54− w[j++] = l&0x3fffffff;

55− }

56− return c;

57− }

58− // Alternately, set max digit bits to 28 since some

59− // browsers slow down when dealing with 32-bit numbers.

60− function am3(i,x,w,j,c,n) {

61− var xl = x&0x3fff, xh = x>>14;

62− while(--n >= 0) {

63− var l = this[i]&0x3fff;

64− var h = this[i++]>>14;

65− var m = xh*l+h*xl;

66− l = xl*l+((m&0x3fff)<<14)+w[j]+c;

67− c = (l>>28)+(m>>14)+xh*h;

68− w[j++] = l&0xfffffff;

69− }

70− return c;

71− }

72− var inBrowser = typeof navigator !== "undefined";

73− if(inBrowser && j_lm && (navigator.appName == "Microsoft Internet Explorer")) {

74− BigInteger.prototype.am = am2;

75− dbits = 30;

76− }

77− else if(inBrowser && j_lm && (navigator.appName != "Netscape")) {

78− BigInteger.prototype.am = am1;

79− dbits = 26;

80− }

81− else { // Mozilla/Netscape seems to prefer am3

82− BigInteger.prototype.am = am3;

83− dbits = 28;

84− }

85−

86− BigInteger.prototype.DB = dbits;

87− BigInteger.prototype.DM = ((1<<dbits)-1);

88− BigInteger.prototype.DV = (1<<dbits);

89−

90− var BI_FP = 52;

91− BigInteger.prototype.FV = Math.pow(2,BI_FP);

92− BigInteger.prototype.F1 = BI_FP-dbits;

93− BigInteger.prototype.F2 = 2*dbits-BI_FP;

94−

95− // Digit conversions

96− var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";

97− var BI_RC = new Array();

98− var rr,vv;

99− rr = "0".charCodeAt(0);

100− for(vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv;

101− rr = "a".charCodeAt(0);

102− for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;

103− rr = "A".charCodeAt(0);

104− for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;

105−

106− function int2char(n) { return BI_RM.charAt(n); }

107− function intAt(s,i) {

108− var c = BI_RC[s.charCodeAt(i)];

109− return (c==null)?-1:c;

110− }

111−

112− // (protected) copy this to r

113− function bnpCopyTo(r) {

114− for(var i = this.t-1; i >= 0; --i) r[i] = this[i];

115− r.t = this.t;

116− r.s = this.s;

117− }

118−

119− // (protected) set from integer value x, -DV <= x < DV

120− function bnpFromInt(x) {

121− this.t = 1;

122− this.s = (x<0)?-1:0;

123− if(x > 0) this[0] = x;

124− else if(x < -1) this[0] = x+this.DV;

125− else this.t = 0;

126− }

127−

128− // return bigint initialized to value

129− function nbv(i) { var r = nbi(); r.fromInt(i); return r; }

130−

131− // (protected) set from string and radix

132− function bnpFromString(s,b) {

133− var k;

134− if(b == 16) k = 4;

135− else if(b == 8) k = 3;

136− else if(b == 256) k = 8; // byte array

137− else if(b == 2) k = 1;

138− else if(b == 32) k = 5;

139− else if(b == 4) k = 2;

140− else { this.fromRadix(s,b); return; }

141− this.t = 0;

142− this.s = 0;

143− var i = s.length, mi = false, sh = 0;

144− while(--i >= 0) {

145− var x = (k==8)?s[i]&0xff:intAt(s,i);

146− if(x < 0) {

147− if(s.charAt(i) == "-") mi = true;

148− continue;

149− }

150− mi = false;

151− if(sh == 0)

152− this[this.t++] = x;

153− else if(sh+k > this.DB) {

154− this[this.t-1] |= (x&((1<<(this.DB-sh))-1))<<sh;

155− this[this.t++] = (x>>(this.DB-sh));

156− }

157− else

158− this[this.t-1] |= x<<sh;

159− sh += k;

160− if(sh >= this.DB) sh -= this.DB;

161− }

162− if(k == 8 && (s[0]&0x80) != 0) {

163− this.s = -1;

164− if(sh > 0) this[this.t-1] |= ((1<<(this.DB-sh))-1)<<sh;

165− }

166− this.clamp();

167− if(mi) BigInteger.ZERO.subTo(this,this);

168− }

169−

170− // (protected) clamp off excess high words

171− function bnpClamp() {

172− var c = this.s&this.DM;

173− while(this.t > 0 && this[this.t-1] == c) --this.t;

174− }

175−

176− // (public) return string representation in given radix

177− function bnToString(b) {

178− if(this.s < 0) return "-"+this.negate().toString(b);

179− var k;

180− if(b == 16) k = 4;

181− else if(b == 8) k = 3;

182− else if(b == 2) k = 1;

183− else if(b == 32) k = 5;

184− else if(b == 4) k = 2;

185− else return this.toRadix(b);

186− var km = (1<<k)-1, d, m = false, r = "", i = this.t;

187− var p = this.DB-(i*this.DB)%k;

188− if(i-- > 0) {

189− if(p < this.DB && (d = this[i]>>p) > 0) { m = true; r = int2char(d); }

190− while(i >= 0) {

191− if(p < k) {

192− d = (this[i]&((1<<p)-1))<<(k-p);

193− d |= this[--i]>>(p+=this.DB-k);

194− }

195− else {

196− d = (this[i]>>(p-=k))&km;

197− if(p <= 0) { p += this.DB; --i; }

198− }

199− if(d > 0) m = true;

200− if(m) r += int2char(d);

201− }

202− }

203− return m?r:"0";

204− }

205−

206− // (public) -this

207− function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this,r); return r; }

208−

209− // (public) |this|

210− function bnAbs() { return (this.s<0)?this.negate():this; }

211−

212− // (public) return + if this > a, - if this < a, 0 if equal

213− function bnCompareTo(a) {

214− var r = this.s-a.s;

215− if(r != 0) return r;

216− var i = this.t;

217− r = i-a.t;

218− if(r != 0) return (this.s<0)?-r:r;

219− while(--i >= 0) if((r=this[i]-a[i]) != 0) return r;

220− return 0;

221− }

222−

223− // returns bit length of the integer x

224− function nbits(x) {

225− var r = 1, t;

226− if((t=x>>>16) != 0) { x = t; r += 16; }

227− if((t=x>>8) != 0) { x = t; r += 8; }

228− if((t=x>>4) != 0) { x = t; r += 4; }

229− if((t=x>>2) != 0) { x = t; r += 2; }

230− if((t=x>>1) != 0) { x = t; r += 1; }

231− return r;

232− }

233−

234− // (public) return the number of bits in "this"

235− function bnBitLength() {

236− if(this.t <= 0) return 0;

237− return this.DB*(this.t-1)+nbits(this[this.t-1]^(this.s&this.DM));

238− }

239−

240− // (protected) r = this << n*DB

241− function bnpDLShiftTo(n,r) {

242− var i;

243− for(i = this.t-1; i >= 0; --i) r[i+n] = this[i];

244− for(i = n-1; i >= 0; --i) r[i] = 0;

245− r.t = this.t+n;

246− r.s = this.s;

247− }

248−

249− // (protected) r = this >> n*DB

250− function bnpDRShiftTo(n,r) {

251− for(var i = n; i < this.t; ++i) r[i-n] = this[i];

252− r.t = Math.max(this.t-n,0);

253− r.s = this.s;

254− }

255−

256− // (protected) r = this << n

257− function bnpLShiftTo(n,r) {

258− var bs = n%this.DB;

259− var cbs = this.DB-bs;

260− var bm = (1<<cbs)-1;

261− var ds = Math.floor(n/this.DB), c = (this.s<<bs)&this.DM, i;

262− for(i = this.t-1; i >= 0; --i) {

263− r[i+ds+1] = (this[i]>>cbs)|c;

264− c = (this[i]&bm)<<bs;

265− }

266− for(i = ds-1; i >= 0; --i) r[i] = 0;

267− r[ds] = c;

268− r.t = this.t+ds+1;

269− r.s = this.s;

270− r.clamp();

271− }

272−

273− // (protected) r = this >> n

274− function bnpRShiftTo(n,r) {

275− r.s = this.s;

276− var ds = Math.floor(n/this.DB);

277− if(ds >= this.t) { r.t = 0; return; }

278− var bs = n%this.DB;

279− var cbs = this.DB-bs;

280− var bm = (1<<bs)-1;

281− r[0] = this[ds]>>bs;

282− for(var i = ds+1; i < this.t; ++i) {

283− r[i-ds-1] |= (this[i]&bm)<<cbs;

284− r[i-ds] = this[i]>>bs;

285− }

286− if(bs > 0) r[this.t-ds-1] |= (this.s&bm)<<cbs;

287− r.t = this.t-ds;

288− r.clamp();

289− }

290−

291− // (protected) r = this - a

292− function bnpSubTo(a,r) {

293− var i = 0, c = 0, m = Math.min(a.t,this.t);

294− while(i < m) {

295− c += this[i]-a[i];

296− r[i++] = c&this.DM;

297− c >>= this.DB;

298− }

299− if(a.t < this.t) {

300− c -= a.s;

301− while(i < this.t) {

302− c += this[i];

303− r[i++] = c&this.DM;

304− c >>= this.DB;

305− }

306− c += this.s;

307− }

308− else {

309− c += this.s;

310− while(i < a.t) {

311− c -= a[i];

312− r[i++] = c&this.DM;

313− c >>= this.DB;

314− }

315− c -= a.s;

316− }

317− r.s = (c<0)?-1:0;

318− if(c < -1) r[i++] = this.DV+c;

319− else if(c > 0) r[i++] = c;

320− r.t = i;

321− r.clamp();

322− }

323−

324− // (protected) r = this * a, r != this,a (HAC 14.12)

325− // "this" should be the larger one if appropriate.

326− function bnpMultiplyTo(a,r) {

327− var x = this.abs(), y = a.abs();

328− var i = x.t;

329− r.t = i+y.t;

330− while(--i >= 0) r[i] = 0;

331− for(i = 0; i < y.t; ++i) r[i+x.t] = x.am(0,y[i],r,i,0,x.t);

332− r.s = 0;

333− r.clamp();

334− if(this.s != a.s) BigInteger.ZERO.subTo(r,r);

335− }

336−

337− // (protected) r = this^2, r != this (HAC 14.16)

338− function bnpSquareTo(r) {

339− var x = this.abs();

340− var i = r.t = 2*x.t;

341− while(--i >= 0) r[i] = 0;

342− for(i = 0; i < x.t-1; ++i) {

343− var c = x.am(i,x[i],r,2*i,0,1);

344− if((r[i+x.t]+=x.am(i+1,2*x[i],r,2*i+1,c,x.t-i-1)) >= x.DV) {

345− r[i+x.t] -= x.DV;

346− r[i+x.t+1] = 1;

347− }

348− }

349− if(r.t > 0) r[r.t-1] += x.am(i,x[i],r,2*i,0,1);

350− r.s = 0;

351− r.clamp();

352− }

353−

354− // (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)

355− // r != q, this != m. q or r may be null.

356− function bnpDivRemTo(m,q,r) {

357− var pm = m.abs();

358− if(pm.t <= 0) return;

359− var pt = this.abs();

360− if(pt.t < pm.t) {

361− if(q != null) q.fromInt(0);

362− if(r != null) this.copyTo(r);

363− return;

364− }

365− if(r == null) r = nbi();

366− var y = nbi(), ts = this.s, ms = m.s;

367− var nsh = this.DB-nbits(pm[pm.t-1]); // normalize modulus

368− if(nsh > 0) { pm.lShiftTo(nsh,y); pt.lShiftTo(nsh,r); }

369− else { pm.copyTo(y); pt.copyTo(r); }

370− var ys = y.t;

371− var y0 = y[ys-1];

372− if(y0 == 0) return;

373− var yt = y0*(1<<this.F1)+((ys>1)?y[ys-2]>>this.F2:0);

374− var d1 = this.FV/yt, d2 = (1<<this.F1)/yt, e = 1<<this.F2;

375− var i = r.t, j = i-ys, t = (q==null)?nbi():q;

376− y.dlShiftTo(j,t);

377− if(r.compareTo(t) >= 0) {

378− r[r.t++] = 1;

379− r.subTo(t,r);

380− }

381− BigInteger.ONE.dlShiftTo(ys,t);

382− t.subTo(y,y); // "negative" y so we can replace sub with am later

383− while(y.t < ys) y[y.t++] = 0;

384− while(--j >= 0) {

385− // Estimate quotient digit

386− var qd = (r[--i]==y0)?this.DM:Math.floor(r[i]*d1+(r[i-1]+e)*d2);

387− if((r[i]+=y.am(0,qd,r,j,0,ys)) < qd) { // Try it out

388− y.dlShiftTo(j,t);

389− r.subTo(t,r);

390− while(r[i] < --qd) r.subTo(t,r);

391− }

392− }

393− if(q != null) {

394− r.drShiftTo(ys,q);

395− if(ts != ms) BigInteger.ZERO.subTo(q,q);

396− }

397− r.t = ys;

398− r.clamp();

399− if(nsh > 0) r.rShiftTo(nsh,r); // Denormalize remainder

400− if(ts < 0) BigInteger.ZERO.subTo(r,r);

401− }

402−

403− // (public) this mod a

404− function bnMod(a) {

405− var r = nbi();

406− this.abs().divRemTo(a,null,r);

407− if(this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r,r);

408− return r;

409− }

410−

411− // Modular reduction using "classic" algorithm

412− function Classic(m) { this.m = m; }

413− function cConvert(x) {

414− if(x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m);

415− else return x;

416− }

417− function cRevert(x) { return x; }

418− function cReduce(x) { x.divRemTo(this.m,null,x); }

419− function cMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }

420− function cSqrTo(x,r) { x.squareTo(r); this.reduce(r); }

421−

422− Classic.prototype.convert = cConvert;

423− Classic.prototype.revert = cRevert;

424− Classic.prototype.reduce = cReduce;

425− Classic.prototype.mulTo = cMulTo;

426− Classic.prototype.sqrTo = cSqrTo;

427−

428− // (protected) return "-1/this % 2^DB"; useful for Mont. reduction

429− // justification:

430− // xy == 1 (mod m)

431− // xy = 1+km

432− // xy(2-xy) = (1+km)(1-km)

433− // x[y(2-xy)] = 1-k^2m^2

434− // x[y(2-xy)] == 1 (mod m^2)

435− // if y is 1/x mod m, then y(2-xy) is 1/x mod m^2

436− // should reduce x and y(2-xy) by m^2 at each step to keep size bounded.

437− // JS multiply "overflows" differently from C/C++, so care is needed here.

438− function bnpInvDigit() {

439− if(this.t < 1) return 0;

440− var x = this[0];

441− if((x&1) == 0) return 0;

442− var y = x&3; // y == 1/x mod 2^2

443− y = (y*(2-(x&0xf)*y))&0xf; // y == 1/x mod 2^4

444− y = (y*(2-(x&0xff)*y))&0xff; // y == 1/x mod 2^8

445− y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff; // y == 1/x mod 2^16

446− // last step - calculate inverse mod DV directly;

447− // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints

448− y = (y*(2-x*y%this.DV))%this.DV; // y == 1/x mod 2^dbits

449− // we really want the negative inverse, and -DV < y < DV

450− return (y>0)?this.DV-y:-y;

451− }

452−

453− // Montgomery reduction

454− function Montgomery(m) {

455− this.m = m;

456− this.mp = m.invDigit();

457− this.mpl = this.mp&0x7fff;

458− this.mph = this.mp>>15;

459− this.um = (1<<(m.DB-15))-1;

460− this.mt2 = 2*m.t;

461− }

462−

463− // xR mod m

464− function montConvert(x) {

465− var r = nbi();

466− x.abs().dlShiftTo(this.m.t,r);

467− r.divRemTo(this.m,null,r);

468− if(x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r,r);

469− return r;

470− }

471−

472− // x/R mod m

473− function montRevert(x) {

474− var r = nbi();

475− x.copyTo(r);

476− this.reduce(r);

477− return r;

478− }

479−

480− // x = x/R mod m (HAC 14.32)

481− function montReduce(x) {

482− while(x.t <= this.mt2) // pad x so am has enough room later

483− x[x.t++] = 0;

484− for(var i = 0; i < this.m.t; ++i) {

485− // faster way of calculating u0 = x[i]*mp mod DV

486− var j = x[i]&0x7fff;

487− var u0 = (j*this.mpl+(((j*this.mph+(x[i]>>15)*this.mpl)&this.um)<<15))&x.DM;

488− // use am to combine the multiply-shift-add into one call

489− j = i+this.m.t;

490− x[j] += this.m.am(0,u0,x,i,0,this.m.t);

491− // propagate carry

492− while(x[j] >= x.DV) { x[j] -= x.DV; x[++j]++; }

493− }

494− x.clamp();

495− x.drShiftTo(this.m.t,x);

496− if(x.compareTo(this.m) >= 0) x.subTo(this.m,x);

497− }

498−

499− // r = "x^2/R mod m"; x != r

500− function montSqrTo(x,r) { x.squareTo(r); this.reduce(r); }

501−

502− // r = "xy/R mod m"; x,y != r

503− function montMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }

504−

505− Montgomery.prototype.convert = montConvert;

506− Montgomery.prototype.revert = montRevert;

507− Montgomery.prototype.reduce = montReduce;

508− Montgomery.prototype.mulTo = montMulTo;

509− Montgomery.prototype.sqrTo = montSqrTo;

510−

511− // (protected) true iff this is even

512− function bnpIsEven() { return ((this.t>0)?(this[0]&1):this.s) == 0; }

513−

514− // (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)

515− function bnpExp(e,z) {

516− if(e > 0xffffffff || e < 1) return BigInteger.ONE;

517− var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1;

518− g.copyTo(r);

519− while(--i >= 0) {

520− z.sqrTo(r,r2);

521− if((e&(1<<i)) > 0) z.mulTo(r2,g,r);

522− else { var t = r; r = r2; r2 = t; }

523− }

524− return z.revert(r);

525− }

526−

527− // (public) this^e % m, 0 <= e < 2^32

528− function bnModPowInt(e,m) {

529− var z;

530− if(e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m);

531− return this.exp(e,z);

532− }

533−

534− // protected

535− BigInteger.prototype.copyTo = bnpCopyTo;

536− BigInteger.prototype.fromInt = bnpFromInt;

537− BigInteger.prototype.fromString = bnpFromString;

538− BigInteger.prototype.clamp = bnpClamp;

539− BigInteger.prototype.dlShiftTo = bnpDLShiftTo;

540− BigInteger.prototype.drShiftTo = bnpDRShiftTo;

541− BigInteger.prototype.lShiftTo = bnpLShiftTo;

542− BigInteger.prototype.rShiftTo = bnpRShiftTo;

543− BigInteger.prototype.subTo = bnpSubTo;

544− BigInteger.prototype.multiplyTo = bnpMultiplyTo;

545− BigInteger.prototype.squareTo = bnpSquareTo;

546− BigInteger.prototype.divRemTo = bnpDivRemTo;

547− BigInteger.prototype.invDigit = bnpInvDigit;

548− BigInteger.prototype.isEven = bnpIsEven;

549− BigInteger.prototype.exp = bnpExp;

550−

551− // public

552− BigInteger.prototype.toString = bnToString;

553− BigInteger.prototype.negate = bnNegate;

554− BigInteger.prototype.abs = bnAbs;

555− BigInteger.prototype.compareTo = bnCompareTo;

556− BigInteger.prototype.bitLength = bnBitLength;

557− BigInteger.prototype.mod = bnMod;

558− BigInteger.prototype.modPowInt = bnModPowInt;

559−

560− // "constants"

561− BigInteger.ZERO = nbv(0);

562− BigInteger.ONE = nbv(1);

563−

566− // See "LICENSE" for details.

567−

568− // Extended JavaScript BN functions, required for RSA private ops.

569−

570− // Version 1.1: new BigInteger("0", 10) returns "proper" zero

571− // Version 1.2: square() API, isProbablePrime fix

572−

573− // (public)

574− function bnClone() { var r = nbi(); this.copyTo(r); return r; }

575−

576− // (public) return value as integer

577− function bnIntValue() {

578− if(this.s < 0) {

579− if(this.t == 1) return this[0]-this.DV;

580− else if(this.t == 0) return -1;

581− }

582− else if(this.t == 1) return this[0];

583− else if(this.t == 0) return 0;

584− // assumes 16 < DB < 32

585− return ((this[1]&((1<<(32-this.DB))-1))<<this.DB)|this[0];

586− }

587−

588− // (public) return value as byte

589− function bnByteValue() { return (this.t==0)?this.s:(this[0]<<24)>>24; }

590−

591− // (public) return value as short (assumes DB>=16)

592− function bnShortValue() { return (this.t==0)?this.s:(this[0]<<16)>>16; }

593−

594− // (protected) return x s.t. r^x < DV

595− function bnpChunkSize(r) { return Math.floor(Math.LN2*this.DB/Math.log(r)); }

596−

597− // (public) 0 if this == 0, 1 if this > 0

598− function bnSigNum() {

599− if(this.s < 0) return -1;

600− else if(this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0;

601− else return 1;

602− }

603−

604− // (protected) convert to radix string

605− function bnpToRadix(b) {

606− if(b == null) b = 10;

607− if(this.signum() == 0 || b < 2 || b > 36) return "0";

608− var cs = this.chunkSize(b);

609− var a = Math.pow(b,cs);

610− var d = nbv(a), y = nbi(), z = nbi(), r = "";

611− this.divRemTo(d,y,z);

612− while(y.signum() > 0) {

613− r = (a+z.intValue()).toString(b).substr(1) + r;

614− y.divRemTo(d,y,z);

615− }

616− return z.intValue().toString(b) + r;

617− }

618−

619− // (protected) convert from radix string

620− function bnpFromRadix(s,b) {

621− this.fromInt(0);

622− if(b == null) b = 10;

623− var cs = this.chunkSize(b);

624− var d = Math.pow(b,cs), mi = false, j = 0, w = 0;

625− for(var i = 0; i < s.length; ++i) {

626− var x = intAt(s,i);

627− if(x < 0) {

628− if(s.charAt(i) == "-" && this.signum() == 0) mi = true;

629− continue;

630− }

631− w = b*w+x;

632− if(++j >= cs) {

633− this.dMultiply(d);

634− this.dAddOffset(w,0);

635− j = 0;

636− w = 0;

637− }

638− }

639− if(j > 0) {

640− this.dMultiply(Math.pow(b,j));

641− this.dAddOffset(w,0);

642− }

643− if(mi) BigInteger.ZERO.subTo(this,this);

644− }

645−

646− // (protected) alternate constructor

647− function bnpFromNumber(a,b,c) {

648− if("number" == typeof b) {

649− // new BigInteger(int,int,RNG)

650− if(a < 2) this.fromInt(1);

651− else {

652− this.fromNumber(a,c);

653− if(!this.testBit(a-1)) // force MSB set

654− this.bitwiseTo(BigInteger.ONE.shiftLeft(a-1),op_or,this);

655− if(this.isEven()) this.dAddOffset(1,0); // force odd

656− while(!this.isProbablePrime(b)) {

657− this.dAddOffset(2,0);

658− if(this.bitLength() > a) this.subTo(BigInteger.ONE.shiftLeft(a-1),this);

659− }

660− }

661− }

662− else {

663− // new BigInteger(int,RNG)

664− var x = new Array(), t = a&7;

665− x.length = (a>>3)+1;

666− b.nextBytes(x);

667− if(t > 0) x[0] &= ((1<<t)-1); else x[0] = 0;

668− this.fromString(x,256);

669− }

670− }

671−

672− // (public) convert to bigendian byte array

673− function bnToByteArray() {

674− var i = this.t, r = new Array();

675− r[0] = this.s;

676− var p = this.DB-(i*this.DB)%8, d, k = 0;

677− if(i-- > 0) {

678− if(p < this.DB && (d = this[i]>>p) != (this.s&this.DM)>>p)

679− r[k++] = d|(this.s<<(this.DB-p));

680− while(i >= 0) {

681− if(p < 8) {

682− d = (this[i]&((1<<p)-1))<<(8-p);

683− d |= this[--i]>>(p+=this.DB-8);

684− }

685− else {

686− d = (this[i]>>(p-=8))&0xff;

687− if(p <= 0) { p += this.DB; --i; }

688− }

689− if((d&0x80) != 0) d |= -256;

690− if(k == 0 && (this.s&0x80) != (d&0x80)) ++k;

691− if(k > 0 || d != this.s) r[k++] = d;

692− }

693− }

694− return r;

695− }

696−

697− function bnEquals(a) { return(this.compareTo(a)==0); }

698− function bnMin(a) { return(this.compareTo(a)<0)?this:a; }

699− function bnMax(a) { return(this.compareTo(a)>0)?this:a; }

700−

701− // (protected) r = this op a (bitwise)

702− function bnpBitwiseTo(a,op,r) {

703− var i, f, m = Math.min(a.t,this.t);

704− for(i = 0; i < m; ++i) r[i] = op(this[i],a[i]);

705− if(a.t < this.t) {

706− f = a.s&this.DM;

707− for(i = m; i < this.t; ++i) r[i] = op(this[i],f);

708− r.t = this.t;

709− }

710− else {

711− f = this.s&this.DM;

712− for(i = m; i < a.t; ++i) r[i] = op(f,a[i]);

713− r.t = a.t;

714− }

715− r.s = op(this.s,a.s);

716− r.clamp();

717− }

718−

719− // (public) this & a

720− function op_and(x,y) { return x&y; }

721− function bnAnd(a) { var r = nbi(); this.bitwiseTo(a,op_and,r); return r; }

722−

723− // (public) this | a

724− function op_or(x,y) { return x|y; }

725− function bnOr(a) { var r = nbi(); this.bitwiseTo(a,op_or,r); return r; }

726−

727− // (public) this ^ a

728− function op_xor(x,y) { return x^y; }

729− function bnXor(a) { var r = nbi(); this.bitwiseTo(a,op_xor,r); return r; }

730−

731− // (public) this & ~a

732− function op_andnot(x,y) { return x&~y; }

733− function bnAndNot(a) { var r = nbi(); this.bitwiseTo(a,op_andnot,r); return r; }

734−

735− // (public) ~this

736− function bnNot() {

737− var r = nbi();

738− for(var i = 0; i < this.t; ++i) r[i] = this.DM&~this[i];

739− r.t = this.t;

740− r.s = ~this.s;

741− return r;

742− }

743−

744− // (public) this << n

745− function bnShiftLeft(n) {

746− var r = nbi();

747− if(n < 0) this.rShiftTo(-n,r); else this.lShiftTo(n,r);

748− return r;

749− }

750−

751− // (public) this >> n

752− function bnShiftRight(n) {

753− var r = nbi();

754− if(n < 0) this.lShiftTo(-n,r); else this.rShiftTo(n,r);

755− return r;

756− }

757−

758− // return index of lowest 1-bit in x, x < 2^31

759− function lbit(x) {

760− if(x == 0) return -1;

761− var r = 0;

762− if((x&0xffff) == 0) { x >>= 16; r += 16; }

763− if((x&0xff) == 0) { x >>= 8; r += 8; }

764− if((x&0xf) == 0) { x >>= 4; r += 4; }

765− if((x&3) == 0) { x >>= 2; r += 2; }

766− if((x&1) == 0) ++r;

767− return r;

768− }

769−

770− // (public) returns index of lowest 1-bit (or -1 if none)

771− function bnGetLowestSetBit() {

772− for(var i = 0; i < this.t; ++i)

773− if(this[i] != 0) return i*this.DB+lbit(this[i]);

774− if(this.s < 0) return this.t*this.DB;

775− return -1;

776− }

777−

778− // return number of 1 bits in x

779− function cbit(x) {

780− var r = 0;

781− while(x != 0) { x &= x-1; ++r; }

782− return r;

783− }

784−

785− // (public) return number of set bits

786− function bnBitCount() {

787− var r = 0, x = this.s&this.DM;

788− for(var i = 0; i < this.t; ++i) r += cbit(this[i]^x);

789− return r;

790− }

791−

792− // (public) true iff nth bit is set

793− function bnTestBit(n) {

794− var j = Math.floor(n/this.DB);

795− if(j >= this.t) return(this.s!=0);

796− return((this[j]&(1<<(n%this.DB)))!=0);

797− }

798−

799− // (protected) this op (1<<n)

800− function bnpChangeBit(n,op) {

801− var r = BigInteger.ONE.shiftLeft(n);

802− this.bitwiseTo(r,op,r);

803− return r;

804− }

805−

806− // (public) this | (1<<n)

807− function bnSetBit(n) { return this.changeBit(n,op_or); }

808−

809− // (public) this & ~(1<<n)

810− function bnClearBit(n) { return this.changeBit(n,op_andnot); }

811−

812− // (public) this ^ (1<<n)

813− function bnFlipBit(n) { return this.changeBit(n,op_xor); }

814−

815− // (protected) r = this + a

816− function bnpAddTo(a,r) {

817− var i = 0, c = 0, m = Math.min(a.t,this.t);

818− while(i < m) {

819− c += this[i]+a[i];

820− r[i++] = c&this.DM;

821− c >>= this.DB;

822− }

823− if(a.t < this.t) {

824− c += a.s;

825− while(i < this.t) {

826− c += this[i];

827− r[i++] = c&this.DM;

828− c >>= this.DB;

829− }

830− c += this.s;

831− }

832− else {

833− c += this.s;

834− while(i < a.t) {

835− c += a[i];

836− r[i++] = c&this.DM;

837− c >>= this.DB;

838− }

839− c += a.s;

840− }

841− r.s = (c<0)?-1:0;

842− if(c > 0) r[i++] = c;

843− else if(c < -1) r[i++] = this.DV+c;

844− r.t = i;

845− r.clamp();

846− }

847−

848− // (public) this + a

849− function bnAdd(a) { var r = nbi(); this.addTo(a,r); return r; }

850−

851− // (public) this - a

852− function bnSubtract(a) { var r = nbi(); this.subTo(a,r); return r; }

853−

854− // (public) this * a

855− function bnMultiply(a) { var r = nbi(); this.multiplyTo(a,r); return r; }

856−

857− // (public) this^2

858− function bnSquare() { var r = nbi(); this.squareTo(r); return r; }

859−

860− // (public) this / a

861− function bnDivide(a) { var r = nbi(); this.divRemTo(a,r,null); return r; }

862−

863− // (public) this % a

864− function bnRemainder(a) { var r = nbi(); this.divRemTo(a,null,r); return r; }

865−

866− // (public) [this/a,this%a]

867− function bnDivideAndRemainder(a) {

868− var q = nbi(), r = nbi();

869− this.divRemTo(a,q,r);

870− return new Array(q,r);

871− }

872−

873− // (protected) this *= n, this >= 0, 1 < n < DV

874− function bnpDMultiply(n) {

875− this[this.t] = this.am(0,n-1,this,0,0,this.t);

876− ++this.t;

877− this.clamp();

878− }

879−

880− // (protected) this += n << w words, this >= 0

881− function bnpDAddOffset(n,w) {

882− if(n == 0) return;

883− while(this.t <= w) this[this.t++] = 0;

884− this[w] += n;

885− while(this[w] >= this.DV) {

886− this[w] -= this.DV;

887− if(++w >= this.t) this[this.t++] = 0;

888− ++this[w];

889− }

890− }

891−

892− // A "null" reducer

893− function NullExp() {}

894− function nNop(x) { return x; }

895− function nMulTo(x,y,r) { x.multiplyTo(y,r); }

896− function nSqrTo(x,r) { x.squareTo(r); }

897−

898− NullExp.prototype.convert = nNop;

899− NullExp.prototype.revert = nNop;

900− NullExp.prototype.mulTo = nMulTo;

901− NullExp.prototype.sqrTo = nSqrTo;

902−

903− // (public) this^e

904− function bnPow(e) { return this.exp(e,new NullExp()); }

905−

906− // (protected) r = lower n words of "this * a", a.t <= n

907− // "this" should be the larger one if appropriate.

908− function bnpMultiplyLowerTo(a,n,r) {

909− var i = Math.min(this.t+a.t,n);

910− r.s = 0; // assumes a,this >= 0

911− r.t = i;

912− while(i > 0) r[--i] = 0;

913− var j;

914− for(j = r.t-this.t; i < j; ++i) r[i+this.t] = this.am(0,a[i],r,i,0,this.t);

915− for(j = Math.min(a.t,n); i < j; ++i) this.am(0,a[i],r,i,0,n-i);

916− r.clamp();

917− }

918−

919− // (protected) r = "this * a" without lower n words, n > 0

920− // "this" should be the larger one if appropriate.

921− function bnpMultiplyUpperTo(a,n,r) {

922− --n;

923− var i = r.t = this.t+a.t-n;

924− r.s = 0; // assumes a,this >= 0

925− while(--i >= 0) r[i] = 0;

926− for(i = Math.max(n-this.t,0); i < a.t; ++i)

927− r[this.t+i-n] = this.am(n-i,a[i],r,0,0,this.t+i-n);

928− r.clamp();

929− r.drShiftTo(1,r);

930− }

931−

932− // Barrett modular reduction

933− function Barrett(m) {

934− // setup Barrett

935− this.r2 = nbi();

936− this.q3 = nbi();

937− BigInteger.ONE.dlShiftTo(2*m.t,this.r2);

938− this.mu = this.r2.divide(m);

939− this.m = m;

940− }

941−

942− function barrettConvert(x) {

943− if(x.s < 0 || x.t > 2*this.m.t) return x.mod(this.m);

944− else if(x.compareTo(this.m) < 0) return x;

945− else { var r = nbi(); x.copyTo(r); this.reduce(r); return r; }

946− }

947−

948− function barrettRevert(x) { return x; }

949−

950− // x = x mod m (HAC 14.42)

951− function barrettReduce(x) {

952− x.drShiftTo(this.m.t-1,this.r2);

953− if(x.t > this.m.t+1) { x.t = this.m.t+1; x.clamp(); }

954− this.mu.multiplyUpperTo(this.r2,this.m.t+1,this.q3);

955− this.m.multiplyLowerTo(this.q3,this.m.t+1,this.r2);

956− while(x.compareTo(this.r2) < 0) x.dAddOffset(1,this.m.t+1);

957− x.subTo(this.r2,x);

958− while(x.compareTo(this.m) >= 0) x.subTo(this.m,x);

959− }

960−

961− // r = x^2 mod m; x != r

962− function barrettSqrTo(x,r) { x.squareTo(r); this.reduce(r); }

963−

964− // r = x*y mod m; x,y != r

965− function barrettMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }

966−

967− Barrett.prototype.convert = barrettConvert;

968− Barrett.prototype.revert = barrettRevert;

969− Barrett.prototype.reduce = barrettReduce;

970− Barrett.prototype.mulTo = barrettMulTo;

971− Barrett.prototype.sqrTo = barrettSqrTo;

972−

973− // (public) this^e % m (HAC 14.85)

974− function bnModPow(e,m) {

975− var i = e.bitLength(), k, r = nbv(1), z;

976− if(i <= 0) return r;

977− else if(i < 18) k = 1;

978− else if(i < 48) k = 3;

979− else if(i < 144) k = 4;

980− else if(i < 768) k = 5;

981− else k = 6;

982− if(i < 8)

983− z = new Classic(m);

984− else if(m.isEven())

985− z = new Barrett(m);

986− else

987− z = new Montgomery(m);

988−

989− // precomputation

990− var g = new Array(), n = 3, k1 = k-1, km = (1<<k)-1;

991− g[1] = z.convert(this);

992− if(k > 1) {

993− var g2 = nbi();

994− z.sqrTo(g[1],g2);

995− while(n <= km) {

996− g[n] = nbi();

997− z.mulTo(g2,g[n-2],g[n]);

998− n += 2;

999− }

1000− }

1001−

1002− var j = e.t-1, w, is1 = true, r2 = nbi(), t;

1003− i = nbits(e[j])-1;

1004− while(j >= 0) {

1005− if(i >= k1) w = (e[j]>>(i-k1))&km;

1006− else {

1007− w = (e[j]&((1<<(i+1))-1))<<(k1-i);

1008− if(j > 0) w |= e[j-1]>>(this.DB+i-k1);

1009− }

1010−

1011− n = k;

1012− while((w&1) == 0) { w >>= 1; --n; }

1013− if((i -= n) < 0) { i += this.DB; --j; }

1014− if(is1) { // ret == 1, don't bother squaring or multiplying it

1015− g[w].copyTo(r);

1016− is1 = false;

1017− }

1018− else {

1019− while(n > 1) { z.sqrTo(r,r2); z.sqrTo(r2,r); n -= 2; }

1020− if(n > 0) z.sqrTo(r,r2); else { t = r; r = r2; r2 = t; }

1021− z.mulTo(r2,g[w],r);

1022− }

1023−

1024− while(j >= 0 && (e[j]&(1<<i)) == 0) {

1025− z.sqrTo(r,r2); t = r; r = r2; r2 = t;

1026− if(--i < 0) { i = this.DB-1; --j; }

1027− }

1028− }

1029− return z.revert(r);

1030− }

1031−

1032− // (public) gcd(this,a) (HAC 14.54)

1033− function bnGCD(a) {

1034− var x = (this.s<0)?this.negate():this.clone();

1035− var y = (a.s<0)?a.negate():a.clone();

1036− if(x.compareTo(y) < 0) { var t = x; x = y; y = t; }

1037− var i = x.getLowestSetBit(), g = y.getLowestSetBit();

1038− if(g < 0) return x;

1039− if(i < g) g = i;

1040− if(g > 0) {

1041− x.rShiftTo(g,x);

1042− y.rShiftTo(g,y);

1043− }

1044− while(x.signum() > 0) {

1045− if((i = x.getLowestSetBit()) > 0) x.rShiftTo(i,x);

1046− if((i = y.getLowestSetBit()) > 0) y.rShiftTo(i,y);

1047− if(x.compareTo(y) >= 0) {

1048− x.subTo(y,x);

1049− x.rShiftTo(1,x);

1050− }

1051− else {

1052− y.subTo(x,y);

1053− y.rShiftTo(1,y);

1054− }

1055− }

1056− if(g > 0) y.lShiftTo(g,y);

1057− return y;

1058− }

1059−

1060− // (protected) this % n, n < 2^26

1061− function bnpModInt(n) {

1062− if(n <= 0) return 0;

1063− var d = this.DV%n, r = (this.s<0)?n-1:0;

1064− if(this.t > 0)

1065− if(d == 0) r = this[0]%n;

1066− else for(var i = this.t-1; i >= 0; --i) r = (d*r+this[i])%n;

1067− return r;

1068− }

1069−

1070− // (public) 1/this % m (HAC 14.61)

1071− function bnModInverse(m) {

1072− var ac = m.isEven();

1073− if((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO;

1074− var u = m.clone(), v = this.clone();

1075− var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1);

1076− while(u.signum() != 0) {

1077− while(u.isEven()) {

1078− u.rShiftTo(1,u);

1079− if(ac) {

1080− if(!a.isEven() || !b.isEven()) { a.addTo(this,a); b.subTo(m,b); }

1081− a.rShiftTo(1,a);

1082− }

1083− else if(!b.isEven()) b.subTo(m,b);

1084− b.rShiftTo(1,b);

1085− }

1086− while(v.isEven()) {

1087− v.rShiftTo(1,v);

1088− if(ac) {

1089− if(!c.isEven() || !d.isEven()) { c.addTo(this,c); d.subTo(m,d); }

1090− c.rShiftTo(1,c);

1091− }

1092− else if(!d.isEven()) d.subTo(m,d);

1093− d.rShiftTo(1,d);

1094− }

1095− if(u.compareTo(v) >= 0) {

1096− u.subTo(v,u);

1097− if(ac) a.subTo(c,a);

1098− b.subTo(d,b);

1099− }

1100− else {

1101− v.subTo(u,v);

1102− if(ac) c.subTo(a,c);

1103− d.subTo(b,d);

1104− }

1105− }

1106− if(v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO;

1107− if(d.compareTo(m) >= 0) return d.subtract(m);

1108− if(d.signum() < 0) d.addTo(m,d); else return d;

1109− if(d.signum() < 0) return d.add(m); else return d;

1110− }

1111−

1112− var lowprimes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997];

1113− var lplim = (1<<26)/lowprimes[lowprimes.length-1];

1114−

1115− // (public) test primality with certainty >= 1-.5^t

1116− function bnIsProbablePrime(t) {

1117− var i, x = this.abs();

1118− if(x.t == 1 && x[0] <= lowprimes[lowprimes.length-1]) {

1119− for(i = 0; i < lowprimes.length; ++i)

1120− if(x[0] == lowprimes[i]) return true;

1121− return false;

1122− }

1123− if(x.isEven()) return false;

1124− i = 1;

1125− while(i < lowprimes.length) {

1126− var m = lowprimes[i], j = i+1;

1127− while(j < lowprimes.length && m < lplim) m *= lowprimes[j++];

1128− m = x.modInt(m);

1129− while(i < j) if(m%lowprimes[i++] == 0) return false;

1130− }

1131− return x.millerRabin(t);

1132− }

1133−

1134− // (protected) true if probably prime (HAC 4.24, Miller-Rabin)

1135− function bnpMillerRabin(t) {

1136− var n1 = this.subtract(BigInteger.ONE);

1137− var k = n1.getLowestSetBit();

1138− if(k <= 0) return false;

1139− var r = n1.shiftRight(k);

1140− t = (t+1)>>1;

1141− if(t > lowprimes.length) t = lowprimes.length;

1142− var a = nbi();

1143− for(var i = 0; i < t; ++i) {

1144− //Pick bases at random, instead of starting at 2

1145− a.fromInt(lowprimes[Math.floor(Math.random()*lowprimes.length)]);

1146− var y = a.modPow(r,this);

1147− if(y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {

1148− var j = 1;

1149− while(j++ < k && y.compareTo(n1) != 0) {

1150− y = y.modPowInt(2,this);

1151− if(y.compareTo(BigInteger.ONE) == 0) return false;

1152− }

1153− if(y.compareTo(n1) != 0) return false;

1154− }

1155− }

1156− return true;

1157− }

1158−

1159− // protected

1160− BigInteger.prototype.chunkSize = bnpChunkSize;

1161− BigInteger.prototype.toRadix = bnpToRadix;

1162− BigInteger.prototype.fromRadix = bnpFromRadix;

1163− BigInteger.prototype.fromNumber = bnpFromNumber;

1164− BigInteger.prototype.bitwiseTo = bnpBitwiseTo;

1165− BigInteger.prototype.changeBit = bnpChangeBit;

1166− BigInteger.prototype.addTo = bnpAddTo;

1167− BigInteger.prototype.dMultiply = bnpDMultiply;

1168− BigInteger.prototype.dAddOffset = bnpDAddOffset;

1169− BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;

1170− BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;

1171− BigInteger.prototype.modInt = bnpModInt;

1172− BigInteger.prototype.millerRabin = bnpMillerRabin;

1173−

1174− // public

1175− BigInteger.prototype.clone = bnClone;

1176− BigInteger.prototype.intValue = bnIntValue;

1177− BigInteger.prototype.byteValue = bnByteValue;

1178− BigInteger.prototype.shortValue = bnShortValue;

1179− BigInteger.prototype.signum = bnSigNum;

1180− BigInteger.prototype.toByteArray = bnToByteArray;

1181− BigInteger.prototype.equals = bnEquals;

1182− BigInteger.prototype.min = bnMin;

1183− BigInteger.prototype.max = bnMax;

1184− BigInteger.prototype.and = bnAnd;

1185− BigInteger.prototype.or = bnOr;

1186− BigInteger.prototype.xor = bnXor;

1187− BigInteger.prototype.andNot = bnAndNot;

1188− BigInteger.prototype.not = bnNot;

1189− BigInteger.prototype.shiftLeft = bnShiftLeft;

1190− BigInteger.prototype.shiftRight = bnShiftRight;

1191− BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;

1192− BigInteger.prototype.bitCount = bnBitCount;

1193− BigInteger.prototype.testBit = bnTestBit;

1194− BigInteger.prototype.setBit = bnSetBit;

1195− BigInteger.prototype.clearBit = bnClearBit;

1196− BigInteger.prototype.flipBit = bnFlipBit;

1197− BigInteger.prototype.add = bnAdd;

1198− BigInteger.prototype.subtract = bnSubtract;

1199− BigInteger.prototype.multiply = bnMultiply;

1200− BigInteger.prototype.divide = bnDivide;

1201− BigInteger.prototype.remainder = bnRemainder;

1202− BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;

1203− BigInteger.prototype.modPow = bnModPow;

1204− BigInteger.prototype.modInverse = bnModInverse;

1205− BigInteger.prototype.pow = bnPow;

1206− BigInteger.prototype.gcd = bnGCD;

1207− BigInteger.prototype.isProbablePrime = bnIsProbablePrime;

1208−

1209− // JSBN-specific extension

1210− BigInteger.prototype.square = bnSquare;

1211−

1212− // Expose the Barrett function

1213− BigInteger.prototype.Barrett = Barrett

1214−

1215− // BigInteger interfaces not implemented in jsbn:

1216−

1217− // BigInteger(int signum, byte[] magnitude)

1218− // double doubleValue()

1219− // float floatValue()

1220− // int hashCode()

1221− // long longValue()

1222− // static BigInteger valueOf(long val)

1223−

1224− // Random number generator - requires a PRNG backend, e.g. prng4.js

1225−

1226− // For best results, put code like

1227− // <body onClick='rng_seed_time();' onKeyPress='rng_seed_time();'>

1228− // in your main HTML document.

1229−

1230− var rng_state;

1231− var rng_pool;

1232− var rng_pptr;

1233−

1234− // Mix in a 32-bit integer into the pool

1235− function rng_seed_int(x) {

1236− rng_pool[rng_pptr++] ^= x & 255;

1237− rng_pool[rng_pptr++] ^= (x >> 8) & 255;

1238− rng_pool[rng_pptr++] ^= (x >> 16) & 255;

1239− rng_pool[rng_pptr++] ^= (x >> 24) & 255;

1240− if(rng_pptr >= rng_psize) rng_pptr -= rng_psize;

1241− }

1242−

1243− // Mix in the current time (w/milliseconds) into the pool

1244− function rng_seed_time() {

1245− rng_seed_int(new Date().getTime());

1246− }

1247−

1248− // Initialize the pool with junk if needed.

1249− if(rng_pool == null) {

1250− rng_pool = new Array();

1251− rng_pptr = 0;

1252− var t;

1253− if(typeof window !== "undefined" && window.crypto) {

1254− if (window.crypto.getRandomValues) {

1255− // Use webcrypto if available

1256− var ua = new Uint8Array(32);

1257− window.crypto.getRandomValues(ua);

1258− for(t = 0; t < 32; ++t)

1259− rng_pool[rng_pptr++] = ua[t];

1260− }

1261− else if(navigator.appName == "Netscape" && navigator.appVersion < "5") {

1262− // Extract entropy (256 bits) from NS4 RNG if available

1263− var z = window.crypto.random(32);

1264− for(t = 0; t < z.length; ++t)

1265− rng_pool[rng_pptr++] = z.charCodeAt(t) & 255;

1266− }

1267− }

1268− while(rng_pptr < rng_psize) { // extract some randomness from Math.random()

1269− t = Math.floor(65536 * Math.random());

1270− rng_pool[rng_pptr++] = t >>> 8;

1271− rng_pool[rng_pptr++] = t & 255;

1272− }

1273− rng_pptr = 0;

1274− rng_seed_time();

1275− //rng_seed_int(window.screenX);

1276− //rng_seed_int(window.screenY);

1277− }

1278−

1279− function rng_get_byte() {

1280− if(rng_state == null) {

1281− rng_seed_time();

1282− rng_state = prng_newstate();

1283− rng_state.init(rng_pool);

1284− for(rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr)

1285− rng_pool[rng_pptr] = 0;

1286− rng_pptr = 0;

1287− //rng_pool = null;

1288− }

1289− // TODO: allow reseeding after first request

1290− return rng_state.next();

1291− }

1292−

1293− function rng_get_bytes(ba) {

1294− var i;

1295− for(i = 0; i < ba.length; ++i) ba[i] = rng_get_byte();

1296− }

1297−

1298− function SecureRandom() {}

1299−

1300− SecureRandom.prototype.nextBytes = rng_get_bytes;

1301−

1302− // prng4.js - uses Arcfour as a PRNG

1303−

1304− function Arcfour() {

1305− this.i = 0;

1306− this.j = 0;

1307− this.S = new Array();

1308− }

1309−

1310− // Initialize arcfour context from key, an array of ints, each from [0..255]

1311− function ARC4init(key) {

1312− var i, j, t;

1313− for(i = 0; i < 256; ++i)

1314− this.S[i] = i;

1315− j = 0;

1316− for(i = 0; i < 256; ++i) {

1317− j = (j + this.S[i] + key[i % key.length]) & 255;

1318− t = this.S[i];

1319− this.S[i] = this.S[j];

1320− this.S[j] = t;

1321− }

1322− this.i = 0;

1323− this.j = 0;

1324− }

1325−

1326− function ARC4next() {

1327− var t;

1328− this.i = (this.i + 1) & 255;

1329− this.j = (this.j + this.S[this.i]) & 255;

1330− t = this.S[this.i];

1331− this.S[this.i] = this.S[this.j];

1332− this.S[this.j] = t;

1333− return this.S[(t + this.S[this.i]) & 255];

1334− }

1335−

1336− Arcfour.prototype.init = ARC4init;

1337− Arcfour.prototype.next = ARC4next;

1338−

1339− // Plug in your RNG constructor here

1340− function prng_newstate() {

1341− return new Arcfour();

1342− }

1343−

1344− // Pool size must be a multiple of 4 and greater than 32.

1345− // An array of bytes the size of the pool will be passed to init()

1346− var rng_psize = 256;

1347−

1348− return {

1349− BigInteger: BigInteger,

1350− SecureRandom: SecureRandom

1351− };

1352−

1353−}).call(this);

src/IRTS/CodegenJavaScript.hs+2−35

@@ -40,29 +40,6 @@ htmlFooter =

40 , "</html>"

41 ]

43−nodeReadLine :: Text

44−nodeReadLine =

45− T.concat [ "var js_idris_readStr = function() {\n"

46− , " var ret = '';"

47− , " var b = new Buffer(1024);"

48− , " var i = 0;\n"

49− , " while(true) {\n"

50− , " fs.readSync(0, b, i, 1 )\n"

51− , " if (b[i] == 10) {\n"

52− , " ret = b.toString('utf8', 0, i);\n"

53− , " break;\n"

54− , " }\n"

55− , " i++;\n"

56− , " if (i == b.length) {\n"

57− , " nb = new Buffer (b.length*2);\n"

58− , " b.copy(nb)\n"

59− , " b = nb;\n"

60− , " }\n"

61− , " }\n"

62− , " return ret;\n"

63− , " };\n"

64− ]

65−

66codegenJavaScript :: CodeGenerator

43codegenJavaScript :: CodeGenerator

67codegenJavaScript ci =

44codegenJavaScript ci =

68 let (h, f) = if (map toLower $ takeExtension $ outputFile ci) == ".html" then

45 let (h, f) = if (map toLower $ takeExtension $ outputFile ci) == ".html" then

@@ -70,28 +47,18 @@ codegenJavaScript ci =

70 else ("","")

47 else ("","")

71 in codegenJs (CGConf { header = h

48 in codegenJs (CGConf { header = h

72 , footer = f

49 , footer = f

73− , initialization = const ""

50+ , jsbnPath = "jsbn/jsbn-browser.js"

74− , writeStrTemplate = "console.log(%0)"

75− , readStrTemplate = "prompt('Prelude.getLine')"

76 , extraRunTime = "Runtime-javascript.js"

51 , extraRunTime = "Runtime-javascript.js"

77 }

52 }

78 )

53 )

79 ci

54 ci

81−initializationNode :: CGStats -> Text

82−initializationNode x =

83− T.concat [ if usedWriteStr x || usedReadStr x then "var fs = require('fs');\n" else ""

84− , if usedReadStr x then nodeReadLine else ""

85− ]

86−

87codegenNode :: CodeGenerator

56codegenNode :: CodeGenerator

88codegenNode ci =

57codegenNode ci =

89 do

58 do

90 codegenJs (CGConf { header = "#!/usr/bin/env node\n"

59 codegenJs (CGConf { header = "#!/usr/bin/env node\n"

91 , footer = ""

60 , footer = ""

92− , initialization = initializationNode

61+ , jsbnPath = "jsbn/jsbn-browser.js"

93− , writeStrTemplate = "fs.writeSync(1,%0)"

94− , readStrTemplate = "js_idris_readStr()"

95 , extraRunTime = "Runtime-node.js"

62 , extraRunTime = "Runtime-node.js"

96 }

63 }

97 )

64 )

src/IRTS/JavaScript/AST.hs+232−124

@@ -1,15 +1,26 @@

1{-|

2Module : IRTS.JavaScript.AST

3−Description : AST for javascrit

3+Description : The JavaScript AST.

4Copyright :

5License : BSD3

6Maintainer : The Idris Community.

7-}

8{-# LANGUAGE DeriveDataTypeable, OverloadedStrings, PatternGuards #-}

9{-# LANGUAGE DeriveDataTypeable, OverloadedStrings, PatternGuards #-}

10−module IRTS.JavaScript.AST( JsAST(..)

11+module IRTS.JavaScript.AST

12+ ( JsExpr(..)

13+ , JsStmt(..)

11− , jsAst2Text

14+ , jsAst2Text

15+ , jsStmt2Text

16+ , jsLazy

17+ , jsCurryLam

18+ , jsCurryApp

19+ , jsAppN

20+ , jsExpr2Stmt

21+ , jsStmt2Expr

22+ , jsSetVar

12− ) where

23+ ) where

14import Data.Char

25import Data.Char

15import Data.Data

26import Data.Data

@@ -17,39 +28,74 @@ import Data.Text (Text)

17import qualified Data.Text as T

28import qualified Data.Text as T

18import Numeric

29import Numeric

31+data JsStmt

20−data JsAST = JsEmpty

32+ = JsEmpty

21− | JsNull

33+ | JsComment Text

22− | JsLambda [Text] JsAST

34+ | JsExprStmt JsExpr

23− | JsCurryLambda [Text] JsAST

24− | JsFun Text [Text] JsAST

35+ | JsFun Text

25− | JsReturn JsAST

36+ [Text]

26− | JsApp Text [JsAST]

37+ JsStmt

27− | JsCurryApp JsAST [JsAST]

38+ | JsSeq JsStmt

28− | JsMethod JsAST Text [JsAST]

39+ JsStmt

29− | JsVar Text

40+ | JsReturn JsExpr

30− | JsSeq JsAST JsAST

41+ | JsDecVar Text

31− | JsConst Text JsAST

42+ JsExpr

32− | JsLet Text JsAST

43+ | JsDecConst Text

33− | JsSetVar Text JsAST

44+ JsExpr

34− | JsArrayProj JsAST JsAST

45+ | JsDecLet Text

35− | JsNum Double

46+ JsExpr

36− | JsInt Int

47+ | JsSet JsExpr

37− | JsStr String

48+ JsExpr

38− | JsArray [JsAST]

49+ | JsIf JsExpr

50+ JsStmt

51+ (Maybe JsStmt)

39− | JsSwitchCase JsAST [(JsAST, JsAST)] (Maybe JsAST)

52+ | JsSwitchCase JsExpr

53+ [(JsExpr, JsStmt)]

54+ (Maybe JsStmt)

40− | JsError JsAST

55+ | JsError JsExpr

41− | JsErrorExp JsAST

56+ | JsForever JsStmt

42− | JsBinOp Text JsAST JsAST

43− | JsForeign Text [JsAST]

44− | JsWhileTrue JsAST

45− | JsContinue

57+ | JsContinue

46− | JsBreak

58+ | JsBreak

47− | JsTrue

48− | JsComment Text

49− | JsForce JsAST

50− | JsLazy JsAST

51− deriving (Show, Eq, Data, Typeable)

59+ deriving (Show, Eq, Data, Typeable)

61+data JsExpr

62+ = JsNull

63+ | JsUndefined

64+ | JsThis

65+ | JsLambda [Text]

66+ JsStmt

67+ | JsApp JsExpr

68+ [JsExpr]

69+ | JsNew JsExpr

70+ [JsExpr]

71+ | JsPart JsExpr

72+ Text

73+ | JsMethod JsExpr

74+ Text

75+ [JsExpr]

76+ | JsVar Text

77+ | JsArrayProj JsExpr

78+ JsExpr

79+ | JsObj [(Text, JsExpr)]

80+ | JsProp JsExpr

81+ Text

82+ | JsInt Int

83+ | JsBool Bool

84+ | JsInteger Integer

85+ | JsDouble Double

86+ | JsStr String

87+ | JsArray [JsExpr]

88+ | JsErrorExp JsExpr

89+ | JsUniOp Text

90+ JsExpr

91+ | JsBinOp Text

92+ JsExpr

93+ JsExpr

94+ | JsForeign Text

95+ [JsExpr]

96+ | JsB2I JsExpr

97+ | JsForce JsExpr

98+ deriving (Show, Eq, Data, Typeable)

54translateChar :: Char -> String

100translateChar :: Char -> String

55translateChar ch

101translateChar ch

@@ -82,107 +128,169 @@ translateChar ch

82 '\DLE', '\DC1', '\DC2', '\DC3', '\DC4', '\NAK', '\SYN', '\ETB',

128 '\DLE', '\DC1', '\DC2', '\DC3', '\DC4', '\NAK', '\SYN', '\ETB',

83 '\CAN', '\EM', '\SUB', '\ESC', '\FS', '\GS', '\RS', '\US']

129 '\CAN', '\EM', '\SUB', '\ESC', '\FS', '\GS', '\RS', '\US']

130

131+

85indent :: Text -> Text

132indent :: Text -> Text

86indent x =

133indent x =

87− let l = T.lines x

134+ let l = T.lines x

88− il = map (\y -> T.replicate 3 " " `T.append` y) l

135+ il = map (\y -> T.replicate 4 " " `T.append` y) l

89 in T.unlines il

136 in T.unlines il

137

91−curryDef :: [Text] -> JsAST -> Text

138+jsCurryLam :: [Text] -> JsExpr -> JsExpr

92−curryDef [] body =

139+jsCurryLam [] body = body

93− jsAst2Text body

140+jsCurryLam (x:xs) body = JsLambda [x] $ JsReturn $ jsCurryLam xs body

94−curryDef (x:xs) body =

141+

95− T.concat [ "(function", "(", x, "){return "

142+jsCurryApp :: JsExpr -> [JsExpr] -> JsExpr

96− , curryDef xs body

143+jsCurryApp fn [] = fn

97− , "})"

144+jsCurryApp fn args = foldl (\ff aa -> JsApp ff [aa]) fn args

98− ]

145

146+jsAppN :: Text -> [JsExpr] -> JsExpr

147+jsAppN fn args = JsApp (JsVar fn) args

100

148

101−jsAst2Text :: JsAST -> Text

149+jsSetVar :: Text -> JsExpr -> JsStmt

150+jsSetVar n x = JsSet (JsVar n) x

151+

152+jsStmt2Text :: JsStmt -> Text

153+jsStmt2Text JsEmpty = ""

154+jsStmt2Text (JsComment c) = T.unlines $ map ("// " `T.append`) $ T.lines c

155+jsStmt2Text (JsExprStmt e) = T.concat [jsAst2Text e, ";"]

156+jsStmt2Text (JsReturn x) = T.concat ["return ", jsAst2Text x, ";"]

157+jsStmt2Text (JsDecVar name exp) =

158+ T.concat ["var ", name, " = ", jsAst2Text exp, ";"]

159+jsStmt2Text (JsDecConst name exp) =

160+ T.concat ["const ", name, " = ", jsAst2Text exp, ";"]

161+jsStmt2Text (JsDecLet name exp) =

162+ T.concat ["let ", name, " = ", jsAst2Text exp, ";"]

163+jsStmt2Text (JsFun name args body) =

164+ T.concat

165+ [ "function "

166+ , name

167+ , "("

168+ , T.intercalate ", " args

169+ , "){\n"

170+ , indent $ jsStmt2Text body

171+ , "}\n"

172+ ]

173+jsStmt2Text (JsIf cond conseq (Just next@(JsIf _ _ _))) =

174+ T.concat

175+ [ "if("

176+ , jsAst2Text cond

177+ , ") {\n"

178+ , indent $ jsStmt2Text conseq

179+ , "} else "

180+ , jsStmt2Text next

181+ ]

182+jsStmt2Text (JsIf cond conseq (Just alt)) =

183+ T.concat

184+ [ "if("

185+ , jsAst2Text cond

186+ , ") {\n"

187+ , indent $ jsStmt2Text conseq

188+ , "} else {\n"

189+ , indent $ jsStmt2Text alt

190+ , "}\n"

191+ ]

192+jsStmt2Text (JsIf cond conseq Nothing) =

193+ T.concat ["if(", jsAst2Text cond, ") {\n", indent $ jsStmt2Text conseq, "}\n"]

194+jsStmt2Text (JsSwitchCase exp l d) =

195+ T.concat

196+ [ "switch("

197+ , jsAst2Text exp

198+ , "){\n"

199+ , indent $ T.concat $ map case2Text l

200+ , indent $ default2Text d

201+ , "}\n"

202+ ]

203+ where

204+ case2Text :: (JsExpr, JsStmt) -> Text

205+ case2Text (x, y) =

206+ T.concat

207+ [ "case "

102−jsAst2Text JsEmpty = ""

208+ , jsAst2Text x

209+ , ":\n"

210+ , indent $ T.concat [jsStmt2Text y, ";\nbreak;\n"]

211+ ]

212+ default2Text :: Maybe JsStmt -> Text

213+ default2Text Nothing = ""

214+ default2Text (Just z) =

215+ T.concat ["default:\n", indent $ T.concat [jsStmt2Text z, ";\nbreak;\n"]]

216+jsStmt2Text (JsError t) = T.concat ["throw new Error( ", jsAst2Text t, ");"]

217+jsStmt2Text (JsForever x) =

218+ T.concat ["for(;;) {\n", indent $ jsStmt2Text x, "}\n"]

219+jsStmt2Text JsContinue = "continue;"

220+jsStmt2Text JsBreak = "break;"

221+jsStmt2Text (JsSeq JsEmpty y) = jsStmt2Text y

222+jsStmt2Text (JsSeq x JsEmpty) = jsStmt2Text x

223+jsStmt2Text (JsSeq x y) = T.concat [jsStmt2Text x, "\n", jsStmt2Text y]

224+jsStmt2Text (JsSet term exp) =

225+ T.concat [jsAst2Text term, " = ", jsAst2Text exp, ";"]

226+

227+jsAst2Text :: JsExpr -> Text

103jsAst2Text JsNull = "null"

228jsAst2Text JsNull = "null"

229+jsAst2Text JsUndefined = "(void 0)"

230+jsAst2Text JsThis = "this"

104jsAst2Text (JsLambda args body) =

231jsAst2Text (JsLambda args body) =

232+ T.concat

105− T.concat [ "(function", "(", T.intercalate ", " args , "){"

233+ [ "(function"

106− , jsAst2Text body

234+ , "("

107− , "})"

108− ]

109−jsAst2Text (JsCurryLambda args body) = curryDef args body

110−jsAst2Text (JsFun name args body) =

111− T.concat [ "var ", name, " = function(", T.intercalate ", " args , "){\n"

235+ , T.intercalate ", " args

236+ , "){\n"

112− , indent $ jsAst2Text body

237+ , indent $ jsStmt2Text body

113− , "}\n"

238+ , "})"

114− ]

239+ ]

115−jsAst2Text (JsReturn x) = T.concat [ "return ", jsAst2Text x]

240+jsAst2Text (JsApp fn args) =

116−jsAst2Text (JsApp fn args) = T.concat [fn, "(", T.intercalate ", " $ map jsAst2Text args, ")"]

241+ T.concat [jsAst2Text fn, "(", T.intercalate ", " $ map jsAst2Text args, ")"]

117−jsAst2Text (JsCurryApp fn []) = jsAst2Text fn

242+jsAst2Text (JsNew fn args) =

118−jsAst2Text (JsCurryApp fn args) = T.concat [jsAst2Text fn, "(", T.intercalate ")(" $ map jsAst2Text args, ")"]

243+ T.concat ["new ", jsAst2Text fn, "(", T.intercalate ", " $ map jsAst2Text args, ")"]

119jsAst2Text (JsMethod obj name args) =

244jsAst2Text (JsMethod obj name args) =

245+ T.concat

120− T.concat [ jsAst2Text obj

246+ [ jsAst2Text obj

121− , "."

247+ , "."

122− , name, "("

248+ , name

249+ , "("

123− , T.intercalate ", " $ map jsAst2Text args

250+ , T.intercalate ", " $ map jsAst2Text args

124− , ")"

251+ , ")"

125− ]

252+ ]

253+jsAst2Text (JsPart obj name) =

254+ T.concat [jsAst2Text obj, "[", T.pack (show name), "]"]

126jsAst2Text (JsVar x) = x

255jsAst2Text (JsVar x) = x

127−jsAst2Text (JsSeq JsEmpty y) = jsAst2Text y

256+jsAst2Text (JsObj props) =

128−jsAst2Text (JsSeq x JsEmpty) = jsAst2Text x

257+ T.concat

129−jsAst2Text (JsSeq x y) = T.concat [jsAst2Text x, ";\n", jsAst2Text y]

258+ [ "({"

259+ , T.intercalate

260+ ", "

130−jsAst2Text (JsConst name exp) = T.concat [ "var ", name, " = ", jsAst2Text exp] -- using var instead of const until ES6

261+ (map (\(name, val) -> T.concat [name, ": ", jsAst2Text val]) props)

131−jsAst2Text (JsLet name exp) = T.concat [ "var ", name, " = ", jsAst2Text exp] -- using var instead of let until ES6

262+ , "})"

132−jsAst2Text (JsSetVar name exp) = T.concat [ name, " = ", jsAst2Text exp]

263+ ]

264+jsAst2Text (JsProp object name) = T.concat [jsAst2Text object, ".", name]

265+jsAst2Text (JsArrayProj i exp) =

133−jsAst2Text (JsArrayProj i exp) = T.concat [ jsAst2Text exp, "[", jsAst2Text i, "]"]

266+ T.concat [jsAst2Text exp, "[", jsAst2Text i, "]"]

134−jsAst2Text (JsInt i) = T.pack $ show i ++ "|0"

267+jsAst2Text (JsInt i) = T.pack $ show i

268+jsAst2Text (JsBool True) = T.pack "true"

269+jsAst2Text (JsBool False) = T.pack "false"

135−jsAst2Text (JsNum d) = T.pack $ show d

270+jsAst2Text (JsDouble d) = T.pack $ show d

271+jsAst2Text (JsInteger i) = T.pack $ show i

136jsAst2Text (JsStr s) = "\"" `T.append` T.pack (concatMap translateChar s) `T.append` "\""

272jsAst2Text (JsStr s) = "\"" `T.append` T.pack (concatMap translateChar s) `T.append` "\""

273+jsAst2Text (JsArray l) =

137−jsAst2Text (JsArray l) = T.concat [ "[", T.intercalate ", " (map jsAst2Text l), "]"]

274+ T.concat ["[", T.intercalate ", " (map jsAst2Text l), "]"]

138−jsAst2Text (JsSwitchCase exp l d) =

139− T.concat [ "switch(", jsAst2Text exp, "){\n"

140− , indent $ T.concat $ map case2Text l

141− , indent $ default2Text d

142− , "}\n"

143− ]

144−jsAst2Text (JsError t) =

145− T.concat ["throw new Error( ", jsAst2Text t, ")"]

146jsAst2Text (JsErrorExp t) =

275jsAst2Text (JsErrorExp t) =

147− T.concat ["js_idris_throw2(new Error( ", jsAst2Text t, "))"]

276+ T.concat ["$JSRTS.throw(new Error( ", jsAst2Text t, "))"]

148jsAst2Text (JsBinOp op a1 a2) =

277jsAst2Text (JsBinOp op a1 a2) =

149− T.concat ["(", jsAst2Text a1," ", op, " ",jsAst2Text a2, ")"]

278+ T.concat ["(", jsAst2Text a1, " ", op, " ", jsAst2Text a2, ")"]

279+jsAst2Text (JsUniOp op a) = T.concat ["(", op, jsAst2Text a, ")"]

150jsAst2Text (JsForeign code args) =

280jsAst2Text (JsForeign code args) =

151 let args_repl c i [] = c

281 let args_repl c i [] = c

282+ args_repl c i (t:r) =

152− args_repl c i (t:r) = args_repl (T.replace ("%" `T.append` T.pack (show i)) t c) (i+1) r

283+ args_repl (T.replace ("%" `T.append` T.pack (show i)) (T.concat ["(", t, ")"]) c) (i + 1) r

153 in T.concat ["(", args_repl code 0 (map jsAst2Text args), ")"]

284 in T.concat ["(", args_repl code 0 (map jsAst2Text args), ")"]

154−jsAst2Text (JsWhileTrue w) =

285+jsAst2Text (JsB2I x) = jsAst2Text $ JsBinOp "+" x (JsInt 0)

155− T.concat [ "while(true){\n"

156− , indent $ jsAst2Text w

157− , "}\n"

158− ]

159−jsAst2Text JsContinue =

160− "continue"

161−jsAst2Text JsBreak =

162− "break"

163−jsAst2Text JsTrue =

164− "true"

165−jsAst2Text (JsComment c)=

166− T.concat ["/*",c,"*/"]

167−jsAst2Text (JsLazy e) =

168− T.concat [ "{js_idris_lazy_calc:function(){"

169− , indent $ jsAst2Text e

170− , "}}"

171− ]

172−jsAst2Text (JsForce e) =

286+jsAst2Text (JsForce e) = T.concat ["$JSRTS.force(", jsAst2Text e, ")"]

173− T.concat ["js_idris_force(", jsAst2Text e, ")"]

287+

174−

288+jsLazy :: JsExpr -> JsExpr

175−

289+jsLazy e = JsNew (JsProp (JsVar "$JSRTS") "Lazy") [(JsLambda [] $ JsReturn e)]

176−

290+

177−case2Text :: (JsAST, JsAST) -> Text

291+jsExpr2Stmt :: JsExpr -> JsStmt

178−case2Text (x,y) =

292+jsExpr2Stmt = JsExprStmt

179− T.concat [ "case ", jsAst2Text x, ":\n"

293+

180− , indent $ T.concat [ jsAst2Text y, ";\nbreak;\n"]

294+jsStmt2Expr :: JsStmt -> JsExpr

181− ]

295+jsStmt2Expr (JsExprStmt x) = x

182−

296+jsStmt2Expr x = JsApp (JsLambda [] x) []

183−default2Text :: Maybe JsAST -> Text

184−default2Text Nothing = ""

185−default2Text (Just z) =

186− T.concat [ "default:\n"

187− , indent $ T.concat [ jsAst2Text z, ";\nbreak;\n"]

188− ]

src/IRTS/JavaScript/Codegen.hs+279−516

@@ -16,10 +16,14 @@ import Idris.Core.TT

16import IRTS.CodegenCommon

17import IRTS.JavaScript.AST

18import IRTS.JavaScript.LangTransforms

19+import IRTS.JavaScript.Name

20+import IRTS.JavaScript.PrimOp

21+import IRTS.JavaScript.Specialize

19import IRTS.Lang

22import IRTS.Lang

20import IRTS.LangOpts

23import IRTS.LangOpts

21import IRTS.System

24import IRTS.System

26+import Control.Monad

23import Control.Monad.Trans.State

27import Control.Monad.Trans.State

24import Data.List (nub)

28import Data.List (nub)

25import Data.Map.Strict (Map)

29import Data.Map.Strict (Map)

@@ -41,22 +45,20 @@ import Data.Generics.Uniplate.Data

41import Data.List

45import Data.List

42import GHC.Generics (Generic)

46import GHC.Generics (Generic)

44−data Partial = Partial Name Int Int deriving (Eq, Ord)

45−

46−data CGStats = CGStats { usedWriteStr :: Bool

47− , usedReadStr :: Bool

48− , usedBigInt :: Bool

48+data CGStats = CGStats { usedBigInt :: Bool

49 , partialApplications :: Set Partial

50+ , hiddenClasses :: Set HiddenClass

50 }

51 }

52emptyStats :: CGStats

53emptyStats :: CGStats

53−emptyStats = CGStats {usedWriteStr = False, partialApplications = Set.empty, usedBigInt = False, usedReadStr = False}

54+emptyStats = CGStats { partialApplications = Set.empty

55+ , hiddenClasses = Set.empty

56+ , usedBigInt = False

57+ }

55data CGConf = CGConf { header :: Text

59data CGConf = CGConf { header :: Text

56 , footer :: Text

60 , footer :: Text

57− , initialization :: CGStats -> Text

61+ , jsbnPath :: String

58− , writeStrTemplate :: Text

59− , readStrTemplate :: Text

60 , extraRunTime :: String

62 , extraRunTime :: String

61 }

63 }

@@ -96,7 +98,7 @@ codegenJs conf ci =

97 path <- getIdrisJSRTSDir

99 path <- getIdrisJSRTSDir

98 jsbn <- if usedBigInt stats

100 jsbn <- if usedBigInt stats

99− then TIO.readFile $ path </> "jsbn/jsbn.js"

101+ then TIO.readFile $ path </> jsbnPath conf

100 else return ""

102 else return ""

101

103

102 runtimeCommon <- TIO.readFile $ path </> "Runtime-common.js"

104 runtimeCommon <- TIO.readFile $ path </> "Runtime-common.js"

@@ -106,30 +108,18 @@ codegenJs conf ci =

106 TIO.writeFile (outputFile ci) $ T.concat [ header conf

108 TIO.writeFile (outputFile ci) $ T.concat [ header conf

107 , "\"use strict\";\n\n"

109 , "\"use strict\";\n\n"

108 , "(function(){\n\n"

110 , "(function(){\n\n"

109− , jsbn

110− , initialization conf stats

111− , doPartials (partialApplications stats)

112− , includes, "\n"

113 , runtimeCommon, "\n"

111 , runtimeCommon, "\n"

114 , extraRT, "\n"

112 , extraRT, "\n"

113+ , jsbn, "\n"

114+ , doPartials (partialApplications stats), "\n"

115+ , doHiddenClasses (hiddenClasses stats), "\n"

116+ , includes, "\n"

115 , out, "\n"

117 , out, "\n"

116− , "\n"

117− , jsName (sMN 0 "runMain"), "();\n\n"

118+ , jsName (sMN 0 "runMain"), "();\n"

118− , "\n}.call(this))"

119+ , "}.call(this))"

119 , footer conf

120 , footer conf

120 ]

121 ]

121

122

122−jsName :: Name -> Text

123−jsName n = T.pack $ "idris_" ++ concatMap jschar (showCG n)

124− where jschar x | isAlpha x || isDigit x = [x]

125− | otherwise = "_" ++ show (fromEnum x) ++ "_"

126−

127−jsPartialName :: Partial -> Text

128−jsPartialName (Partial n i j) = T.concat ["partial_", T.pack $ show i, "_", T.pack $ show j, "_" , jsName n]

129−

130−jsTailCallOptimName :: Text -> Text

131−jsTailCallOptimName x = T.concat ["tailCallOptim_cgIdris_", x]

132−

133doPartials :: Set Partial -> Text

123doPartials :: Set Partial -> Text

134doPartials x =

124doPartials x =

135 T.intercalate "\n" (map f $ Set.toList x)

125 T.intercalate "\n" (map f $ Set.toList x)

@@ -137,41 +127,50 @@ doPartials x =

137 f p@(Partial n i j) =

127 f p@(Partial n i j) =

138 let vars1 = map (T.pack . ("x"++) . show) [1..i]

128 let vars1 = map (T.pack . ("x"++) . show) [1..i]

139 vars2 = map (T.pack . ("x"++) . show) [(i+1)..j]

129 vars2 = map (T.pack . ("x"++) . show) [(i+1)..j]

140− in jsAst2Text $

130+ in jsStmt2Text $

131+ JsFun (jsNamePartial p) vars1 $ JsReturn $

141− JsFun (jsPartialName p) vars1 $ JsReturn $ JsCurryLambda vars2 (JsApp (jsName n) (map JsVar (vars1 ++ vars2)) )

132+ jsCurryLam vars2 (jsAppN (jsName n) (map JsVar (vars1 ++ vars2)) )

133+

134+doHiddenClasses :: Set HiddenClass -> Text

135+doHiddenClasses x =

136+ T.intercalate "\n" (map f $ Set.toList x)

137+ where

138+ f p@(HiddenClass n id arity) =

139+ let vars = map dataPartName $ take arity [1..]

140+ in jsStmt2Text $

141+ JsFun (jsNameHiddenClass p) vars $ JsSeq (JsSet (JsProp JsThis "type") (JsInt id)) $ seqJs

142+ $ map (\tv -> JsSet (JsProp JsThis tv) (JsVar tv)) vars

142

143

143doCodegen :: CGConf -> Map Name LDecl -> [LDecl] -> (Text, CGStats)

144doCodegen :: CGConf -> Map Name LDecl -> [LDecl] -> (Text, CGStats)

144doCodegen conf defs decls =

145doCodegen conf defs decls =

145 let xs = map (doCodegenDecl conf defs) decls

146 let xs = map (doCodegenDecl conf defs) decls

146− groupCGStats x y = CGStats {usedWriteStr = usedWriteStr x || usedWriteStr y

147+ groupCGStats x y = CGStats { partialApplications = partialApplications x `Set.union` partialApplications y

147− , partialApplications = partialApplications x `Set.union` partialApplications y

148+ , hiddenClasses = hiddenClasses x `Set.union` hiddenClasses y

148 , usedBigInt = usedBigInt x || usedBigInt y

149 , usedBigInt = usedBigInt x || usedBigInt y

149− , usedReadStr = usedReadStr x || usedReadStr y

150 }

151 in (T.intercalate "\n" $ map fst xs, foldl' groupCGStats emptyStats (map snd xs) )

152

153doCodegenDecl :: CGConf -> Map Name LDecl -> LDecl -> (Text, CGStats)

154doCodegenDecl conf defs (LFun _ n args def) =

155 let (ast, stats) = cgFun conf defs n args def

156− in (jsAst2Text $ ast, stats)

156+ in (T.concat [jsStmt2Text (JsComment $ T.pack $ show n), "\n", jsStmt2Text ast], stats)

157−doCodegenDecl conf defs (LConstructor n i sz) =

157+doCodegenDecl conf defs (LConstructor n i sz) = ("", emptyStats)

158− ("", emptyStats)

159

158

160−seqJs :: [JsAST] -> JsAST

159+seqJs :: [JsStmt] -> JsStmt

161seqJs [] = JsEmpty

160seqJs [] = JsEmpty

162seqJs (x:xs) = JsSeq x (seqJs xs)

161seqJs (x:xs) = JsSeq x (seqJs xs)

163

162

164

163

165data CGBodyState = CGBodyState { defs :: Map Name LDecl

164data CGBodyState = CGBodyState { defs :: Map Name LDecl

166 , lastIntName :: Int

165 , lastIntName :: Int

166+ , reWrittenNames :: Map.Map Name JsExpr

167 , currentFnNameAndArgs :: (Text, [Text])

168 , usedArgsTailCallOptim :: Set (Text, Text)

169 , isTailRec :: Bool

170 , conf :: CGConf

171− , usedWrite :: Bool

172− , usedRead :: Bool

173 , usedITBig :: Bool

171 , usedITBig :: Bool

174 , partialApps :: Set Partial

172 , partialApps :: Set Partial

173+ , hiddenCls :: Set HiddenClass

175 }

174 }

176

175

177getNewCGName :: State CGBodyState Text

176getNewCGName :: State CGBodyState Text

@@ -180,12 +179,16 @@ getNewCGName =

180 st <- get

179 st <- get

181 let v = lastIntName st + 1

180 let v = lastIntName st + 1

182 put $ st {lastIntName = v}

181 put $ st {lastIntName = v}

183− return $ T.pack $ "cgIdris_" ++ show v

182+ return $ jsNameGenerated v

184

183

185addPartial :: Partial -> State CGBodyState ()

184addPartial :: Partial -> State CGBodyState ()

186addPartial p =

185addPartial p =

187 modify (\s -> s {partialApps = Set.insert p (partialApps s) })

186 modify (\s -> s {partialApps = Set.insert p (partialApps s) })

188

187

188+addHiddenClass :: HiddenClass -> State CGBodyState ()

189+addHiddenClass p =

190+ modify (\s -> s {hiddenCls = Set.insert p (hiddenCls s) })

191+

189addUsedArgsTailCallOptim :: Set (Text, Text) -> State CGBodyState ()

192addUsedArgsTailCallOptim :: Set (Text, Text) -> State CGBodyState ()

190addUsedArgsTailCallOptim p =

193addUsedArgsTailCallOptim p =

191 modify (\s -> s {usedArgsTailCallOptim = Set.union p (usedArgsTailCallOptim s) })

194 modify (\s -> s {usedArgsTailCallOptim = Set.union p (usedArgsTailCallOptim s) })

@@ -194,12 +197,12 @@ getNewCGNames :: Int -> State CGBodyState [Text]

194getNewCGNames n =

197getNewCGNames n =

195 mapM (\_ -> getNewCGName) [1..n]

198 mapM (\_ -> getNewCGName) [1..n]

196

199

197−getConsId :: Name -> State CGBodyState Int

200+getConsId :: Name -> State CGBodyState (Int, Int)

198getConsId n =

201getConsId n =

199 do

202 do

200 st <- get

203 st <- get

201 case Map.lookup n (defs st) of

204 case Map.lookup n (defs st) of

202− Just (LConstructor _ conId _) -> pure conId

205+ Just (LConstructor _ conId arity) -> pure (conId, arity)

203 _ -> error $ "Internal JS Backend error " ++ showCG n ++ " is not a constructor."

206 _ -> error $ "Internal JS Backend error " ++ showCG n ++ " is not a constructor."

204

207

205getArgList :: Name -> State CGBodyState (Maybe [Name])

208getArgList :: Name -> State CGBodyState (Maybe [Name])

@@ -216,49 +219,33 @@ data BodyResTarget = ReturnBT

216 | DecConstBT Text

219 | DecConstBT Text

217 | GetExpBT

220 | GetExpBT

218

221

219−replaceVarsByProj :: JsAST -> Map Text Int -> JsAST -> JsAST

220−replaceVarsByProj n d z =

221− transform f z

222− where

223− f :: JsAST -> JsAST

224− f (JsVar x) =

225− case Map.lookup x d of

226− Nothing -> (JsVar x)

227− Just i -> JsArrayProj (JsInt i) n

228− f x = x

229−

230−cgFun :: CGConf -> Map Name LDecl -> Name -> [Name] -> LExp -> (JsAST, CGStats)

222+cgFun :: CGConf -> Map Name LDecl -> Name -> [Name] -> LExp -> (JsStmt, CGStats)

231−cgFun cnf dfs n args def =

223+cgFun cnf dfs n args def = do

232− let

233− fnName = jsName n

224+ let fnName = jsName n

234− argNames = map jsName args

225+ let argNames = map jsName args

235− ((decs, res),st) = runState

226+ let ((decs, res),st) = runState

236 (cgBody ReturnBT def)

227 (cgBody ReturnBT def)

237− (CGBodyState { defs=dfs

228+ (CGBodyState { defs = dfs

238 , lastIntName = 0

229 , lastIntName = 0

230+ , reWrittenNames = Map.empty

239 , currentFnNameAndArgs = (fnName, argNames)

231 , currentFnNameAndArgs = (fnName, argNames)

240 , usedArgsTailCallOptim = Set.empty

232 , usedArgsTailCallOptim = Set.empty

241 , isTailRec = False

233 , isTailRec = False

242 , conf = cnf

234 , conf = cnf

243− , usedWrite = False

244− , usedRead = False

245 , usedITBig = False

235 , usedITBig = False

246 , partialApps = Set.empty

236 , partialApps = Set.empty

237+ , hiddenCls = Set.empty

247 }

238 }

248 )

239 )

249− body = if isTailRec st then

250− JsSeq

251− (declareUsedOptimArgs $ usedArgsTailCallOptim st)

240+ let body = if isTailRec st then JsSeq (declareUsedOptimArgs $ usedArgsTailCallOptim st) (JsForever ((seqJs decs) `JsSeq` res)) else (seqJs decs) `JsSeq` res

252− (JsWhileTrue ((seqJs decs) `JsSeq` res))

253− else (seqJs decs) `JsSeq` res

254− in (JsFun fnName argNames $ body, CGStats { usedWriteStr = usedWrite st

241+ let fn = JsFun fnName argNames body

255− , partialApplications = partialApps st

242+ let state' = CGStats { partialApplications = partialApps st

243+ , hiddenClasses = hiddenCls st

256− , usedBigInt = usedITBig st

244+ , usedBigInt = usedITBig st

257− , usedReadStr = usedRead st

258− }

245+ }

259− )

246+ (fn, state')

260−

247+

261−getSwitchJs :: JsAST -> [LAlt] -> JsAST

248+getSwitchJs :: JsExpr -> [LAlt] -> JsExpr

262getSwitchJs x alts =

249getSwitchJs x alts =

263 if any conCase alts then JsArrayProj (JsInt 0) x

250 if any conCase alts then JsArrayProj (JsInt 0) x

264 else if any constBigIntCase alts then JsForeign "%0.toString()" [x]

251 else if any constBigIntCase alts then JsForeign "%0.toString()" [x]

@@ -268,48 +255,92 @@ getSwitchJs x alts =

268 constBigIntCase (LConstCase (BI _) _) = True

255 constBigIntCase (LConstCase (BI _) _) = True

269 constBigIntCase _ = False

256 constBigIntCase _ = False

270

257

271−addRT :: BodyResTarget -> JsAST -> JsAST

258+addRT :: BodyResTarget -> JsExpr -> JsStmt

272addRT ReturnBT x = JsReturn x

259addRT ReturnBT x = JsReturn x

273−addRT (DecBT n) x = JsLet n x

260+addRT (DecBT n) x = JsDecLet n x

261+addRT (DecConstBT n) x = JsDecConst n x

274−addRT (SetBT n) x = JsSetVar n x

262+addRT (SetBT n) x = JsSet (JsVar n) x

275−addRT (DecConstBT n) x = JsConst n x

276−addRT GetExpBT x = x

263+addRT GetExpBT x = JsExprStmt x

277

264

278−declareUsedOptimArgs :: Set (Text, Text) -> JsAST

265+declareUsedOptimArgs :: Set (Text, Text) -> JsStmt

279−declareUsedOptimArgs x = seqJs $ map (\(x,y) -> JsLet x (JsVar y) ) (Set.toList x)

266+declareUsedOptimArgs x = seqJs $ map (\(x,y) -> JsDecLet x (JsVar y) ) (Set.toList x)

280

267

281−tailCallOptimRefreshArgs :: [(Text, JsAST)] -> Set Text -> ((JsAST, JsAST), Set (Text, Text))

268+tailCallOptimRefreshArgs :: [(Text, JsExpr)] -> Set Text -> ((JsStmt, JsStmt), Set (Text, Text))

282tailCallOptimRefreshArgs [] s = ((JsEmpty, JsEmpty), Set.empty)

269tailCallOptimRefreshArgs [] s = ((JsEmpty, JsEmpty), Set.empty)

283tailCallOptimRefreshArgs ((n,x):r) s =

270tailCallOptimRefreshArgs ((n,x):r) s =

284 let ((y1,y2), y3) = tailCallOptimRefreshArgs r (Set.insert n s) --

271 let ((y1,y2), y3) = tailCallOptimRefreshArgs r (Set.insert n s) --

285 in if Set.null $ (Set.fromList [ z | z <- universeBi x ]) `Set.intersection` s then

272 in if Set.null $ (Set.fromList [ z | z <- universeBi x ]) `Set.intersection` s then

286− ((y1, JsSetVar n x `JsSeq` y2), y3)

273+ ((y1, jsSetVar n x `JsSeq` y2), y3)

287 else

274 else

288 let n' = jsTailCallOptimName n

275 let n' = jsTailCallOptimName n

289− in ((JsSetVar n' x `JsSeq` y1, JsSetVar n (JsVar n') `JsSeq` y2), Set.insert (n',n) y3)

276+ in ((jsSetVar n' x `JsSeq` y1, jsSetVar n (JsVar n') `JsSeq` y2), Set.insert (n',n) y3)

290−

277+

291−

278+cgName :: Name -> State CGBodyState JsExpr

279+cgName b = do

280+ st <- get

281+ case Map.lookup b (reWrittenNames st) of

282+ Just e -> pure e

283+ _ -> pure $ JsVar $ jsName b

284+

292−cgBody :: BodyResTarget -> LExp -> State CGBodyState ([JsAST], JsAST)

285+cgBody :: BodyResTarget -> LExp -> State CGBodyState ([JsStmt], JsStmt)

293−cgBody rt (LV (Glob n)) =

286+cgBody rt expr =

287+ case expr of

288+ (LCase _ (LOp oper [x, y]) [LConstCase (I 0) (LCon _ _ ff []), LDefaultCase (LCon _ _ tt [])])

289+ | (ff == qualifyN "Prelude.Bool" "False" &&

290+ tt == qualifyN "Prelude.Bool" "True") ->

291+ case (Map.lookup oper primDB) of

292+ Just (needBI, pti, c) | pti == PTBool -> do

293+ z <- mapM (cgBody GetExpBT) [x, y]

294+ when needBI setUsedITBig

295+ let res = jsPrimCoerce pti PTBool $ c $ map (jsStmt2Expr . snd) z

296+ pure $ (concat $ map fst z, addRT rt res)

297+ _ -> cgBody' rt expr

298+ (LCase _ e [LConCase _ n _ (LCon _ _ tt []), LDefaultCase (LCon _ _ ff [])])

299+ | (ff == qualifyN "Prelude.Bool" "False" &&

300+ tt == qualifyN "Prelude.Bool" "True") -> do

301+ (d, v) <- cgBody GetExpBT e

302+ test <- formConTest n (jsStmt2Expr v)

303+ pure $ (d, addRT rt $ JsUniOp (T.pack "!") $ JsUniOp (T.pack "!") test)

304+ (LCase _ e [LConCase _ n _ (LCon _ _ tt []), LConCase _ _ _ (LCon _ _ ff [])])

305+ | (ff == qualifyN "Prelude.Bool" "False" &&

306+ tt == qualifyN "Prelude.Bool" "True") -> do

307+ (d, v) <- cgBody GetExpBT e

308+ test <- formConTest n (jsStmt2Expr v)

309+ pure $ (d, addRT rt $ JsUniOp (T.pack "!") $ JsUniOp (T.pack "!") test)

310+ (LCase _ e [LConCase _ n _ (LCon _ _ ff []), LDefaultCase (LCon _ _ tt [])])

311+ | (ff == qualifyN "Prelude.Bool" "False" &&

312+ tt == qualifyN "Prelude.Bool" "True") -> do

313+ (d, v) <- cgBody GetExpBT e

314+ test <- formConTest n (jsStmt2Expr v)

315+ pure $ (d, addRT rt $ JsUniOp (T.pack "!") test)

316+ (LCase _ e [LConCase _ n _ (LCon _ _ ff []), LConCase _ _ _ (LCon _ _ tt [])])

317+ | (ff == qualifyN "Prelude.Bool" "False" &&

318+ tt == qualifyN "Prelude.Bool" "True") -> do

319+ (d, v) <- cgBody GetExpBT e

320+ test <- formConTest n (jsStmt2Expr v)

321+ pure $ (d, addRT rt $ JsUniOp (T.pack "!") test)

322+ (LCase f e [LConCase nf ff [] alt, LConCase nt tt [] conseq])

323+ | (ff == qualifyN "Prelude.Bool" "False" &&

324+ tt == qualifyN "Prelude.Bool" "True") ->

325+ cgBody' rt $ LCase f e [LConCase nt tt [] conseq, LConCase nf ff [] alt]

326+ expr -> cgBody' rt expr

327+

328+cgBody' :: BodyResTarget -> LExp -> State CGBodyState ([JsStmt], JsStmt)

329+cgBody' rt (LV (Glob n)) =

294 do

330 do

295 argsFn <- getArgList n

331 argsFn <- getArgList n

296 case argsFn of

332 case argsFn of

297− Just [] ->

333+ Just a -> cgBody' rt (LApp False (LV (Glob n)) [])

298− pure $ ([], addRT rt $ JsApp (jsName n) [])

299− Just a ->

300− do

301− let part = Partial n 0 (length a)

302− addPartial part

303− pure ([], addRT rt $ JsApp (jsPartialName part) [])

304− Nothing ->

334+ Nothing -> do

335+ n' <- cgName n

305− pure $ ([], addRT rt $ JsVar $ jsName n)

336+ pure $ ([], addRT rt n')

306−cgBody rt (LApp tailcall (LV (Glob fn)) args) =

337+cgBody' rt (LApp tailcall (LV (Glob fn)) args) =

307 do

338 do

308 let fname = jsName fn

339 let fname = jsName fn

309 st <- get

340 st <- get

310 let (currFn, argN) = currentFnNameAndArgs st

341 let (currFn, argN) = currentFnNameAndArgs st

311 z <- mapM (cgBody GetExpBT) args

342 z <- mapM (cgBody GetExpBT) args

312− let argVals = map snd z

343+ let argVals = map (jsStmt2Expr . snd) z

313 let preDecs = concat $ map fst z

344 let preDecs = concat $ map fst z

314 case (fname == currFn && (length args) == (length argN), rt) of

345 case (fname == currFn && (length args) == (length argN), rt) of

315 (True, ReturnBT) ->

346 (True, ReturnBT) ->

@@ -322,82 +353,88 @@ cgBody rt (LApp tailcall (LV (Glob fn)) args) =

322 do

353 do

323 argsFn <- getArgList fn

354 argsFn <- getArgList fn

324 case argsFn of

355 case argsFn of

325− Nothing ->

356+ Nothing -> do

357+ fn' <- cgName fn

326− pure (preDecs, addRT rt $ JsCurryApp (JsVar fname) argVals )

358+ pure (preDecs, addRT rt $ jsCurryApp fn' argVals )

327 Just agFn ->

359 Just agFn ->

328 do

360 do

329 let lenAgFn = length agFn

361 let lenAgFn = length agFn

330 let lenArgs = length args

362 let lenArgs = length args

331 case compare lenAgFn lenArgs of

363 case compare lenAgFn lenArgs of

332 EQ ->

364 EQ ->

333− pure (preDecs, addRT rt $ JsApp fname argVals)

365+ pure (preDecs, addRT rt $ jsAppN fname argVals)

334 LT ->

366 LT ->

335− pure (preDecs, addRT rt $ JsCurryApp (JsApp fname (take lenAgFn argVals )) (drop lenAgFn argVals) )

367+ pure (preDecs, addRT rt $ jsCurryApp (jsAppN fname (take lenAgFn argVals)) (drop lenAgFn argVals) )

336 GT ->

368 GT ->

337 do

369 do

338 let part = Partial fn lenArgs lenAgFn

370 let part = Partial fn lenArgs lenAgFn

339 addPartial part

371 addPartial part

340− pure (preDecs, addRT rt $ JsApp (jsPartialName part) argVals )

372+ pure (preDecs, addRT rt $ jsAppN (jsNamePartial part) argVals )

341

373

342−cgBody rt (LForce (LLazyApp n args)) = cgBody rt (LApp False (LV (Glob n)) args)

374+cgBody' rt (LForce (LLazyApp n args)) = cgBody rt (LApp False (LV (Glob n)) args)

343−cgBody rt (LLazyApp n args) =

375+cgBody' rt (LLazyApp n args) =

344 do

376 do

345 (d,v) <- cgBody ReturnBT (LApp False (LV (Glob n)) args)

377 (d,v) <- cgBody ReturnBT (LApp False (LV (Glob n)) args)

346− pure ([], addRT rt $ JsLazy $ JsSeq (seqJs d) v)

378+ pure ([], addRT rt $ jsLazy $ jsStmt2Expr $ JsSeq (seqJs d) v)

347−cgBody rt (LForce e) =

379+cgBody' rt (LForce e) =

348 do

380 do

349 (d,v) <- cgBody GetExpBT e

381 (d,v) <- cgBody GetExpBT e

350− pure (d, addRT rt $ JsForce v)

382+ pure (d, addRT rt $ JsForce $ jsStmt2Expr v)

351−cgBody rt (LLet n v sc) =

383+cgBody' rt (LLet n v sc) =

352 do

384 do

353 (d1, v1) <- cgBody (DecConstBT $ jsName n) v

385 (d1, v1) <- cgBody (DecConstBT $ jsName n) v

354 (d2, v2) <- cgBody rt sc

386 (d2, v2) <- cgBody rt sc

355− pure $ ((d1 ++ v1 : d2), v2 )

387+ pure $ ((d1 ++ v1 : d2), v2)

356−cgBody rt (LProj e i) =

388+cgBody' rt (LProj e i) =

357 do

389 do

358 (d, v) <- cgBody GetExpBT e

390 (d, v) <- cgBody GetExpBT e

359− pure $ (d, addRT rt $ JsArrayProj (JsInt $ i+1) $ v)

391+ pure $ (d, addRT rt $ JsArrayProj (JsInt $ i+1) $ jsStmt2Expr v)

360−cgBody rt (LCon _ conId n args) =

392+cgBody' rt (LCon _ conId n args) =

361 do

393 do

362 z <- mapM (cgBody GetExpBT) args

394 z <- mapM (cgBody GetExpBT) args

395+ con <- formCon n (map (jsStmt2Expr . snd) z)

363− pure $ (concat $ map fst z, addRT rt $ JsArray (JsInt conId : map snd z))

396+ pure $ (concat $ map fst z, addRT rt con)

364−cgBody rt (LCase _ e alts) =

397+cgBody' rt (LCase _ e alts) = do

365− do

366− (d,v) <- cgBody GetExpBT e

398+ (d, v) <- cgBody GetExpBT e

367− resName <- getNewCGName

399+ resName <- getNewCGName

368− swName <- getNewCGName

400+ (decSw, entry) <-

369− (altsJs,def) <- cgAlts rt resName (JsVar swName) alts

401+ case (all altHasNoProj alts && length alts <= 2, v) of

370− let decSw = JsConst swName v

402+ (True, _) -> pure (JsEmpty, jsStmt2Expr v)

371− let sw = JsSwitchCase (getSwitchJs (JsVar swName) alts) altsJs def

403+ (False, JsExprStmt (JsVar n)) -> pure (JsEmpty, jsStmt2Expr v)

404+ _ -> do

405+ swName <- getNewCGName

406+ pure (JsDecConst swName $ jsStmt2Expr v, JsVar swName)

407+ sw' <- cgIfTree rt resName entry alts

408+ let sw =

409+ case sw' of

410+ (Just x) -> x

411+ Nothing -> JsExprStmt JsNull

372− case rt of

412+ case rt of

373− ReturnBT ->

374− pure (d ++ [decSw], sw)

413+ ReturnBT -> pure (d ++ [decSw], sw)

375− (DecBT nvar) ->

414+ (DecBT nvar) -> pure (d ++ [decSw, JsDecLet nvar JsNull], sw)

376− pure (d ++ [decSw, JsLet nvar JsNull], sw)

415+ (DecConstBT nvar) -> pure (d ++ [decSw, JsDecLet nvar JsNull], sw)

377− (SetBT nvar) ->

378− pure (d ++ [decSw], sw)

416+ (SetBT nvar) -> pure (d ++ [decSw], sw)

379− GetExpBT ->

417+ GetExpBT ->

418+ pure

380− pure (d ++ [decSw, JsLet resName JsNull, sw], JsVar resName)

419+ (d ++ [decSw, JsDecLet resName JsNull, sw], JsExprStmt $ JsVar resName)

381− (DecConstBT nvar) ->

382− pure (d ++ [decSw, JsLet nvar JsNull], sw)

383−cgBody rt (LConst c) =

420+cgBody' rt (LConst c) =

384 do

421 do

385 cst <- cgConst c

422 cst <- cgConst c

386 pure ([], (addRT rt) $ cst)

423 pure ([], (addRT rt) $ cst)

387−cgBody rt (LOp op args) =

424+cgBody' rt (LOp op args) =

388 do

425 do

389 z <- mapM (cgBody GetExpBT) args

426 z <- mapM (cgBody GetExpBT) args

390− res <- cgOp op (map snd z)

427+ res <- cgOp op (map (jsStmt2Expr . snd) z)

391 pure $ (concat $ map fst z, addRT rt $ res)

428 pure $ (concat $ map fst z, addRT rt $ res)

392−cgBody rt LNothing = pure ([], addRT rt JsNull)

429+cgBody' rt LNothing = pure ([], addRT rt JsNull)

393−cgBody rt (LError x) = pure ([], JsError $ JsStr x)

430+cgBody' rt (LError x) = pure ([], JsError $ JsStr x)

394−cgBody rt x@(LForeign dres (FStr code) args ) =

431+cgBody' rt x@(LForeign dres (FStr code) args ) =

395 do

432 do

396 z <- mapM (cgBody GetExpBT) (map snd args)

433 z <- mapM (cgBody GetExpBT) (map snd args)

397− jsArgs <- sequence $ map cgForeignArg (zip (map fst args) (map snd z))

434+ jsArgs <- sequence $ map cgForeignArg (zip (map fst args) (map (jsStmt2Expr . snd) z))

398 jsDres <- cgForeignRes dres $ JsForeign (T.pack code) jsArgs

435 jsDres <- cgForeignRes dres $ JsForeign (T.pack code) jsArgs

399 pure $ (concat $ map fst z, addRT rt $ jsDres)

436 pure $ (concat $ map fst z, addRT rt $ jsDres)

400−cgBody _ x = error $ "Instruction " ++ show x ++ " not compilable yet"

437+cgBody' _ x = error $ "Instruction " ++ show x ++ " not compilable yet"

401

438

402altsRT :: Text -> BodyResTarget -> BodyResTarget

439altsRT :: Text -> BodyResTarget -> BodyResTarget

403altsRT rn ReturnBT = ReturnBT

440altsRT rn ReturnBT = ReturnBT

@@ -406,36 +443,88 @@ altsRT rn (SetBT n) = SetBT n

406altsRT rn (DecConstBT n) = SetBT n

443altsRT rn (DecConstBT n) = SetBT n

407altsRT rn GetExpBT = SetBT rn

444altsRT rn GetExpBT = SetBT rn

408

445

409−cgAlts :: BodyResTarget -> Text -> JsAST -> [LAlt] -> State CGBodyState ([(JsAST, JsAST)], Maybe JsAST)

446+altHasNoProj :: LAlt -> Bool

447+altHasNoProj (LConCase _ _ args _) = args == []

448+altHasNoProj _ = True

449+

450+formCon :: Name -> [JsExpr] -> State CGBodyState JsExpr

451+formCon n args = do

452+ case specialCased n of

453+ Just (ctor, test, match) -> pure $ ctor args

454+ Nothing -> do

455+ (conId, arity) <- getConsId n

456+ if (arity > 0)

457+ then do

458+ let hc = HiddenClass n conId arity

459+ addHiddenClass hc

460+ pure $ JsNew (JsVar $ jsNameHiddenClass hc) args

461+ else pure $ JsInt conId

462+

463+formConTest :: Name -> JsExpr -> State CGBodyState JsExpr

464+formConTest n x = do

465+ case specialCased n of

466+ Just (ctor, test, match) -> pure $ test x

467+ Nothing -> do

468+ (conId, arity) <- getConsId n

469+ if (arity > 0)

470+ then pure $ JsBinOp "===" (JsProp x (T.pack "type")) (JsInt conId)

471+ else pure $ JsBinOp "===" x (JsInt conId)

472+

473+formProj :: Name -> JsExpr -> Int -> JsExpr

474+formProj n v i =

475+ case specialCased n of

476+ Just (ctor, test, proj) -> proj v i

477+ Nothing -> JsProp v (dataPartName i)

478+

479+smartif :: JsExpr -> JsStmt -> Maybe JsStmt -> JsStmt

480+smartif cond conseq (Just alt) = JsIf cond conseq (Just alt)

481+smartif cond conseq Nothing = conseq

482+

483+formConstTest :: JsExpr -> Const -> State CGBodyState JsExpr

484+formConstTest scrvar t = case t of

485+ BI _ -> do

486+ t' <- cgConst t

487+ cgOp' PTBool (LEq (ATInt ITBig)) [scrvar, t']

488+ _ -> do

489+ t' <- cgConst t

490+ pure $ JsBinOp "===" scrvar t'

491+

492+cgIfTree :: BodyResTarget

493+ -> Text

494+ -> JsExpr

495+ -> [LAlt]

496+ -> State CGBodyState (Maybe JsStmt)

497+cgIfTree _ _ _ [] = pure Nothing

410−cgAlts rt resName scrvar ((LConstCase t exp):r) =

498+cgIfTree rt resName scrvar ((LConstCase t exp):r) = do

411− do

412− (d, v) <- cgBody (altsRT resName rt) exp

499+ (d, v) <- cgBody (altsRT resName rt) exp

413− (ar, def) <- cgAlts rt resName scrvar r

500+ alternatives <- cgIfTree rt resName scrvar r

414− cst <- case t of

501+ test <- formConstTest scrvar t

415− BI _ ->

502+ pure $ Just $

416− do

417− setUsedITBig

418− c' <- cgConst t

419− pure $ JsForeign "%0.toString()" [c']

420− _ -> cgConst t

421− pure ((cst, JsSeq (seqJs d) v) : ar, def)

503+ smartif test (JsSeq (seqJs d) v) alternatives

422−cgAlts rt resName scrvar ((LDefaultCase exp):r) =

504+cgIfTree rt resName scrvar ((LDefaultCase exp):r) = do

423− do

424− (d, v) <- cgBody (altsRT resName rt) exp

505+ (d, v) <- cgBody (altsRT resName rt) exp

425− pure ([], Just $ JsSeq (seqJs d) v)

506+ pure $ Just $ JsSeq (seqJs d) v

426−cgAlts rt resName scrvar ((LConCase _ n args exp):r) =

507+cgIfTree rt resName scrvar ((LConCase _ n args exp):r) = do

427− do

508+ alternatives <- cgIfTree rt resName scrvar r

428− (d, v) <- cgBody (altsRT resName rt) exp

509+ test <- formConTest n scrvar

429− (ar, def) <- cgAlts rt resName scrvar r

510+ st <- get

430− conId <- getConsId n

511+ let rwn = reWrittenNames st

431− let replace = replaceVarsByProj scrvar (Map.fromList $ zip (map jsName args) [1..])

512+ put $

432− let branchBody = JsSeq (seqJs $ map replace d) (replace v)

513+ st

433− pure ((JsInt conId, branchBody) : ar, def)

514+ { reWrittenNames =

434−cgAlts _ _ _ [] =

515+ foldl

435− pure ([],Nothing)

516+ (\m (n, j) -> Map.insert n (formProj n scrvar j) m)

436−

517+ rwn

437−

518+ (zip args [1 ..])

519+ }

520+ (d, v) <- cgBody (altsRT resName rt) exp

521+ st1 <- get

522+ put $ st1 {reWrittenNames = rwn}

523+ let branchBody = JsSeq (seqJs d) v

524+ pure $ Just $ smartif test branchBody alternatives

525+

526+

438−cgForeignArg :: (FDesc, JsAST) -> State CGBodyState JsAST

527+cgForeignArg :: (FDesc, JsExpr) -> State CGBodyState JsExpr

439cgForeignArg (FApp (UN "JS_IntT") _, v) = pure v

528cgForeignArg (FApp (UN "JS_IntT") _, v) = pure v

440cgForeignArg (FCon (UN "JS_Str"), v) = pure v

529cgForeignArg (FCon (UN "JS_Str"), v) = pure v

441cgForeignArg (FCon (UN "JS_Ptr"), v) = pure v

530cgForeignArg (FCon (UN "JS_Ptr"), v) = pure v

@@ -446,14 +535,14 @@ cgForeignArg (FApp (UN "JS_FnT") [_,FApp (UN "JS_Fn") [_,_, a, FApp (UN "JS_FnBa

446cgForeignArg (FApp (UN "JS_FnT") [_,FApp (UN "JS_Fn") [_,_, a, FApp (UN "JS_FnIO") [_,_, b]]], f) =

535cgForeignArg (FApp (UN "JS_FnT") [_,FApp (UN "JS_Fn") [_,_, a, FApp (UN "JS_FnIO") [_,_, b]]], f) =

447 do

536 do

448 jsx <- cgForeignArg (a, JsVar "x")

537 jsx <- cgForeignArg (a, JsVar "x")

449− jsres <- cgForeignRes b $ JsCurryApp (JsCurryApp f [jsx]) [JsNull]

538+ jsres <- cgForeignRes b $ jsCurryApp (jsCurryApp f [jsx]) [JsNull]

450 pure $ JsLambda ["x"] $ JsReturn jsres

539 pure $ JsLambda ["x"] $ JsReturn jsres

451cgForeignArg (desc, _) =

540cgForeignArg (desc, _) =

452 do

541 do

453 st <- get

542 st <- get

454 error $ "Foreign arg type " ++ show desc ++ " not supported. While generating function " ++ (show $ fst $ currentFnNameAndArgs st)

543 error $ "Foreign arg type " ++ show desc ++ " not supported. While generating function " ++ (show $ fst $ currentFnNameAndArgs st)

455

544

456−cgForeignRes :: FDesc -> JsAST -> State CGBodyState JsAST

545+cgForeignRes :: FDesc -> JsExpr -> State CGBodyState JsExpr

457cgForeignRes (FApp (UN "JS_IntT") _) x = pure x

546cgForeignRes (FApp (UN "JS_IntT") _) x = pure x

458cgForeignRes (FCon (UN "JS_Unit")) x = pure x

547cgForeignRes (FCon (UN "JS_Unit")) x = pure x

459cgForeignRes (FCon (UN "JS_Str")) x = pure x

548cgForeignRes (FCon (UN "JS_Str")) x = pure x

@@ -468,359 +557,33 @@ setUsedITBig :: State CGBodyState ()

468setUsedITBig = modify (\s -> s {usedITBig = True})

557setUsedITBig = modify (\s -> s {usedITBig = True})

469

558

470

559

471−cgConst :: Const -> State CGBodyState JsAST

560+cgConst :: Const -> State CGBodyState JsExpr

472cgConst (I i) = pure $ JsInt i

561cgConst (I i) = pure $ JsInt i

473cgConst (BI i) =

562cgConst (BI i) =

474 do

563 do

475 setUsedITBig

564 setUsedITBig

476− pure $ JsForeign "new jsbn.BigInteger(%0)" [JsStr $ show i]

565+ pure $ JsForeign "new $JSRTS.jsbn.BigInteger(%0)" [JsStr $ show i]

477cgConst (Ch c) = pure $ JsStr [c]

566cgConst (Ch c) = pure $ JsStr [c]

478cgConst (Str s) = pure $ JsStr s

567cgConst (Str s) = pure $ JsStr s

479−cgConst (Fl f) = pure $ JsNum f

568+cgConst (Fl f) = pure $ JsDouble f

480cgConst (B8 x) = pure $ JsForeign (T.pack $ show x ++ " & 0xFF") []

569cgConst (B8 x) = pure $ JsForeign (T.pack $ show x ++ " & 0xFF") []

481cgConst (B16 x) = pure $ JsForeign (T.pack $ show x ++ " & 0xFFFF") []

570cgConst (B16 x) = pure $ JsForeign (T.pack $ show x ++ " & 0xFFFF") []

482cgConst (B32 x) = pure $ JsForeign (T.pack $ show x ++ "|0" ) []

571cgConst (B32 x) = pure $ JsForeign (T.pack $ show x ++ "|0" ) []

483cgConst (B64 x) =

572cgConst (B64 x) =

484 do

573 do

485 setUsedITBig

574 setUsedITBig

486− pure $ JsForeign "new jsbn.BigInteger(%0).and(new jsbn.BigInteger(%1))" [JsStr $ show x, JsStr $ show 0xFFFFFFFFFFFFFFFF]

575+ pure $ JsForeign "new $JSRTS.jsbn.BigInteger(%0).and(new $JSRTS.jsbn.BigInteger(%1))" [JsStr $ show x, JsStr $ show 0xFFFFFFFFFFFFFFFF]

487cgConst x | isTypeConst x = pure $ JsInt 0

576cgConst x | isTypeConst x = pure $ JsInt 0

488cgConst x = error $ "Constant " ++ show x ++ " not compilable yet"

577cgConst x = error $ "Constant " ++ show x ++ " not compilable yet"

489

578

490−jsB2I :: JsAST -> JsAST

579+cgOp :: PrimFn -> [JsExpr] -> State CGBodyState JsExpr

491−jsB2I x = JsForeign "%0 ? 1|0 : 0|0" [x]

580+cgOp = cgOp' PTAny

492−

581+

493−cgOp :: PrimFn -> [JsAST] -> State CGBodyState JsAST

582+cgOp' :: JsPrimTy -> PrimFn -> [JsExpr] -> State CGBodyState JsExpr

494−cgOp (LPlus ATFloat) [l, r] = pure $ JsBinOp "+" l r

583+cgOp' pt (LExternal name) _ | name == sUN "prim__null" = pure JsNull

495−cgOp (LPlus (ATInt ITChar)) [l, r] = pure $ JsForeign "String.fromCharCode(%0.charCodeAt(0) + %1.charCodeAt(0))" [l,r]

584+cgOp' pt (LExternal name) [l,r] | name == sUN "prim__eqPtr" = pure $ JsBinOp "==" l r

496−cgOp (LPlus (ATInt ITNative)) [l, r] = pure $ JsForeign "%0+%1|0" [l,r]

585+cgOp' pt op exps = case Map.lookup op primDB of

497−cgOp (LPlus (ATInt (ITFixed IT8))) [l, r] = pure $ JsForeign "%0 + %1 & 0xFF" [l,r]

586+ Just (useBigInt, pti, combinator) -> do

498−cgOp (LPlus (ATInt (ITFixed IT16))) [l, r] = pure $ JsForeign "%0 + %1 & 0xFFFF" [l,r]

587+ when useBigInt setUsedITBig

499−cgOp (LPlus (ATInt (ITFixed IT32))) [l, r] = pure $ JsForeign "%0+%1|0" [l,r]

588+ pure $ jsPrimCoerce pti pt $ combinator exps

500−cgOp (LPlus (ATInt ITBig)) [l, r] =

589+ Nothing -> error ("Operator " ++ show (op, exps) ++ " not implemented")

501− do

502− setUsedITBig

503− pure $ JsMethod l "add" [r]

504−cgOp (LPlus (ATInt (ITFixed IT64))) [l, r] =

505− do

506− setUsedITBig

507− pure $ JsForeign "%0.add(%1).and(new jsbn.BigInteger(%2))" [l,r, JsStr $ show 0xFFFFFFFFFFFFFFFF]

508−cgOp (LMinus ATFloat) [l, r] = pure $ JsBinOp "-" l r

509−cgOp (LMinus (ATInt ITChar)) [l, r] = pure $ JsForeign "String.fromCharCode(%0.charCodeAt(0) - %1.charCodeAt(0))" [l,r]

510−cgOp (LMinus (ATInt ITNative)) [l, r] = pure $ JsForeign "%0-%1|0" [l,r]

511−cgOp (LMinus (ATInt (ITFixed IT8))) [l, r] = pure $ JsForeign "%0 - %1 & 0xFF" [l,r]

512−cgOp (LMinus (ATInt (ITFixed IT16))) [l, r] = pure $ JsForeign "%0 - %1 & 0xFFFF" [l,r]

513−cgOp (LMinus (ATInt (ITFixed IT32))) [l, r] = pure $ JsForeign "%0-%1|0" [l,r]

514−cgOp (LMinus (ATInt ITBig)) [l, r] =

515− do

516− setUsedITBig

517− pure $ JsMethod l "subtract" [r]

518−cgOp (LMinus (ATInt (ITFixed IT64))) [l, r] =

519− do

520− setUsedITBig

521− pure $ JsForeign "%0.subtract(%1).and(new jsbn.BigInteger(%2))" [l,r, JsStr $ show 0xFFFFFFFFFFFFFFFF]

522−cgOp (LTimes ATFloat) [l, r] = pure $ JsBinOp "*" l r

523−cgOp (LTimes (ATInt ITChar)) [l, r] = pure $ JsForeign "String.fromCharCode(%0.charCodeAt(0) * %1.charCodeAt(0))" [l,r]

524−cgOp (LTimes (ATInt ITNative)) [l, r] = pure $ JsForeign "%0*%1|0" [l,r]

525−cgOp (LTimes (ATInt (ITFixed IT8))) [l, r] = pure $ JsForeign "%0 * %1 & 0xFF" [l,r]

526−cgOp (LTimes (ATInt (ITFixed IT16))) [l, r] = pure $ JsForeign "%0 * %1 & 0xFFFF" [l,r]

527−cgOp (LTimes (ATInt (ITFixed IT32))) [l, r] = pure $ JsForeign "%0*%1|0" [l,r]

528−cgOp (LTimes (ATInt ITBig)) [l, r] =

529− do

530− setUsedITBig

531− pure $ JsMethod l "multiply" [r]

532−cgOp (LTimes (ATInt (ITFixed IT64))) [l, r] =

533− do

534− setUsedITBig

535− pure $ JsForeign "%0.multiply(%1).and(new jsbn.BigInteger(%2))" [l,r, JsStr $ show 0xFFFFFFFFFFFFFFFF]

536−cgOp (LUDiv (ITFixed IT8)) [l, r] = pure $ JsForeign "%0 / %1" [l,r]

537−cgOp (LUDiv (ITFixed IT16)) [l, r] = pure $ JsForeign "%0 / %1" [l,r]

538−cgOp (LUDiv (ITFixed IT32)) [l, r] = pure $ JsForeign "(%0>>>0) / (%1>>>0) |0" [l,r]

539−cgOp (LUDiv (ITFixed IT64)) [l, r] =

540− do

541− setUsedITBig

542− pure $ JsForeign "%0.divide(%1)" [l,r]

543−cgOp (LSDiv ATFloat) [l,r] = pure $ JsBinOp "/" l r

544−cgOp (LSDiv (ATInt (ITFixed IT8))) [l, r] = pure $ JsForeign "%0 / %1" [l,r]

545−cgOp (LSDiv (ATInt (ITFixed IT16))) [l, r] = pure $ JsForeign "%0 / %1" [l,r]

546−cgOp (LSDiv (ATInt (ITFixed IT32))) [l, r] = pure $ JsForeign "%0 / %1 |0" [l,r]

547−cgOp (LSDiv (ATInt (ITFixed IT64))) [l, r] =

548− do

549− setUsedITBig

550− pure $ JsForeign "%0.divide(%1)" [l,r]

551−cgOp (LSDiv (ATInt ITNative)) [l,r] = pure $ JsForeign "%0/%1|0" [l, r]

552−cgOp (LSDiv (ATInt ITBig)) [l,r] =

553− do

554− setUsedITBig

555− pure $ JsMethod l "divide" [r]

556−cgOp (LURem (ITFixed IT8)) [l, r] = pure $ JsForeign "%0 % %1" [l,r]

557−cgOp (LURem (ITFixed IT16)) [l, r] = pure $ JsForeign "%0 % %1" [l,r]

558−cgOp (LURem (ITFixed IT32)) [l, r] = pure $ JsForeign "(%0>>>0) % (%1>>>0) |0" [l,r]

559−cgOp (LURem (ITFixed IT64)) [l,r] =

560− do

561− setUsedITBig

562− pure $ JsMethod l "remainder" [r]

563−cgOp (LSRem ATFloat) [l,r] = pure $ JsBinOp "%" l r

564−cgOp (LSRem (ATInt ITNative)) [l,r] = pure $ JsForeign "%0 % %1 |0" [l,r]

565−cgOp (LSRem (ATInt (ITFixed IT8))) [l, r] = pure $ JsForeign "%0 % %1" [l,r]

566−cgOp (LSRem (ATInt (ITFixed IT16))) [l, r] = pure $ JsForeign "%0 % %1" [l,r]

567−cgOp (LSRem (ATInt (ITFixed IT32))) [l, r] = pure $ JsForeign "%0 % %1 |0" [l,r]

568−cgOp (LSRem (ATInt (ITFixed IT64))) [l, r] =

569− do

570− setUsedITBig

571− pure $ JsMethod l "remainder" [r]

572−cgOp (LSRem (ATInt ITBig)) [l,r] =

573− do

574− setUsedITBig

575− pure $ JsMethod l "remainder" [r]

576−cgOp (LAnd ITNative) [l, r] = pure $ JsForeign "%0 & %1" [l,r]

577−cgOp (LAnd (ITFixed IT8)) [l, r] = pure $ JsForeign "%0 & %1" [l,r]

578−cgOp (LAnd (ITFixed IT16)) [l, r] = pure $ JsForeign "%0 & %1" [l,r]

579−cgOp (LAnd (ITFixed IT32)) [l, r] = pure $ JsForeign "%0 & %1" [l,r]

580−cgOp (LAnd (ITFixed IT64)) [l,r] =

581− do

582− setUsedITBig

583− pure $ JsMethod l "and" [r]

584−cgOp (LAnd ITBig) [l,r] =

585− do

586− setUsedITBig

587− pure $ JsMethod l "and" [r]

588−cgOp (LOr ITNative) [l, r] = pure $ JsForeign "%0 | %1" [l,r]

589−cgOp (LOr (ITFixed IT8)) [l, r] = pure $ JsForeign "%0 | %1" [l,r]

590−cgOp (LOr (ITFixed IT16)) [l, r] = pure $ JsForeign "%0 | %1" [l,r]

591−cgOp (LOr (ITFixed IT32)) [l, r] = pure $ JsForeign "%0 | %1" [l,r]

592−cgOp (LOr (ITFixed IT64)) [l,r] =

593− do

594− setUsedITBig

595− pure $ JsMethod l "or" [r]

596−cgOp (LOr ITBig) [l,r] =

597− do

598− setUsedITBig

599− pure $ JsMethod l "or" [r]

600−cgOp (LXOr ITNative) [l, r] = pure $ JsForeign "%0 ^ %1" [l,r]

601−cgOp (LXOr (ITFixed IT8)) [l, r] = pure $ JsForeign "%0 ^ %1" [l,r]

602−cgOp (LXOr (ITFixed IT16)) [l, r] = pure $ JsForeign "%0 ^ %1" [l,r]

603−cgOp (LXOr (ITFixed IT32)) [l, r] = pure $ JsForeign "%0 ^ %1" [l,r]

604−cgOp (LXOr (ITFixed IT64)) [l,r] =

605− do

606− setUsedITBig

607− pure $ JsMethod l "xor" [r]

608−cgOp (LXOr ITBig) [l,r] =

609− do

610− setUsedITBig

611− pure $ JsMethod l "xor" [r]

612−cgOp (LSHL ITNative) [l, r] = pure $ JsForeign "%0 << %1 |0" [l,r]

613−cgOp (LSHL (ITFixed IT8)) [l, r] = pure $ JsForeign "%0 << %1 & 0xFF" [l,r]

614−cgOp (LSHL (ITFixed IT16)) [l, r] = pure $ JsForeign "%0 << %1 & 0xFFFF" [l,r]

615−cgOp (LSHL (ITFixed IT32)) [l, r] = pure $ JsForeign "%0 << %1 |0" [l,r]

616−cgOp (LSHL (ITFixed IT64)) [l, r] =

617− do

618− setUsedITBig

619− pure $ JsForeign "%0.shiftLeft(%1).and(new jsbn.BigInteger(%2))" [l,r, JsStr $ show 0xFFFFFFFFFFFFFFFF]

620−cgOp (LSHL ITBig) [l,r] =

621− do

622− setUsedITBig

623− pure $ JsMethod l "shiftLeft" [r]

624−cgOp (LLSHR ITNative) [l, r] = pure $ JsForeign "%0 >> %1 |0" [l,r]

625−cgOp (LLSHR (ITFixed IT8)) [l, r] = pure $ JsForeign "%0 >> %1" [l,r]

626−cgOp (LLSHR (ITFixed IT16)) [l, r] = pure $ JsForeign "%0 >> %1" [l,r]

627−cgOp (LLSHR (ITFixed IT32)) [l, r] = pure $ JsForeign "%0 >> %1|0" [l,r]

628−cgOp (LLSHR (ITFixed IT64)) [l, r] =

629− do

630− setUsedITBig

631− pure $ JsForeign "%0.shiftRight(%1)" [l,r]

632−cgOp (LASHR ITNative) [l, r] = pure $ JsForeign "%0 >> %1 |0" [l,r]

633−cgOp (LASHR (ITFixed IT8)) [l, r] = pure $ JsForeign "%0 >> %1" [l,r]

634−cgOp (LASHR (ITFixed IT16)) [l, r] = pure $ JsForeign "%0 >> %1" [l,r]

635−cgOp (LASHR (ITFixed IT32)) [l, r] = pure $ JsForeign "%0 >> %1|0" [l,r]

636−cgOp (LASHR (ITFixed IT64)) [l, r] =

637− do

638− setUsedITBig

639− pure $ JsForeign "%0.shiftRight(%1)" [l,r]

640−cgOp (LEq ATFloat) [l, r] = pure $ jsB2I $ JsBinOp "==" l r

641−cgOp (LEq (ATInt ITNative)) [l, r] = pure $ jsB2I $ JsBinOp "==" l r

642−cgOp (LEq (ATInt ITChar)) [l,r] = pure $ jsB2I $ JsBinOp "==" l r

643−cgOp (LEq (ATInt ITBig)) [l, r] =

644− do

645− setUsedITBig

646− pure $ jsB2I $ JsMethod l "equals" [r]

647−cgOp (LEq (ATInt (ITFixed IT8))) [l, r] = pure $ jsB2I $ JsBinOp "==" l r

648−cgOp (LEq (ATInt (ITFixed IT16))) [l, r] = pure $ jsB2I $ JsBinOp "==" l r

649−cgOp (LEq (ATInt (ITFixed IT32))) [l, r] = pure $ jsB2I $ JsBinOp "==" l r

650−cgOp (LEq (ATInt (ITFixed IT64))) [l, r] =

651− do

652− setUsedITBig

653− pure $ jsB2I $ JsMethod l "equals" [r]

654−cgOp (LLt (ITFixed IT8)) [l, r] = pure $ JsForeign "%0 < %1" [l,r]

655−cgOp (LLt (ITFixed IT16)) [l, r] = pure $ JsForeign "%0 < %1" [l,r]

656−cgOp (LLt (ITFixed IT32)) [l, r] = pure $ JsForeign "(%0>>>0) < (%1>>>0)" [l,r]

657−cgOp (LLt (ITFixed IT64)) [l, r] =

658− do

659− setUsedITBig

660− pure $ jsB2I $ JsForeign "%0.compareTo(%1) < 0" [l,r]

661−cgOp (LLe (ITFixed IT8)) [l, r] = pure $ JsForeign "%0 <= %1" [l,r]

662−cgOp (LLe (ITFixed IT16)) [l, r] = pure $ JsForeign "%0 <= %1" [l,r]

663−cgOp (LLe (ITFixed IT32)) [l, r] = pure $ JsForeign "(%0>>>0) <= (%1>>>0)" [l,r]

664−cgOp (LLe (ITFixed IT64)) [l, r] =

665− do

666− setUsedITBig

667− pure $ jsB2I $ JsForeign "%0.compareTo(%1) <= 0" [l,r]

668−cgOp (LGt (ITFixed IT8)) [l, r] = pure $ JsForeign "%0 > %1" [l,r]

669−cgOp (LGt (ITFixed IT16)) [l, r] = pure $ JsForeign "%0 > %1" [l,r]

670−cgOp (LGt (ITFixed IT32)) [l, r] = pure $ JsForeign "(%0>>>0) > (%1>>>0)" [l,r]

671−cgOp (LGt (ITFixed IT64)) [l, r] =

672− do

673− setUsedITBig

674− pure $ jsB2I $ JsForeign "%0.compareTo(%1) > 0" [l,r]

675−cgOp (LGe (ITFixed IT8)) [l, r] = pure $ JsForeign "%0 >= %1" [l,r]

676−cgOp (LGe (ITFixed IT16)) [l, r] = pure $ JsForeign "%0 >= %1" [l,r]

677−cgOp (LGe (ITFixed IT32)) [l, r] = pure $ JsForeign "(%0>>>0) >= (%1>>>0)" [l,r]

678−cgOp (LGe (ITFixed IT64)) [l, r] =

679− do

680− setUsedITBig

681− pure $ jsB2I $ JsForeign "%0.compareTo(%1) >= 0" [l,r]

682−cgOp (LSLt ATFloat) [l, r] = pure $ jsB2I $ JsBinOp "<" l r

683−cgOp (LSLt (ATInt ITChar)) [l, r] = pure $ jsB2I $ JsBinOp "<" l r

684−cgOp (LSLt (ATInt ITNative)) [l, r] = pure $ jsB2I $ JsBinOp "<" l r

685−cgOp (LSLt (ATInt ITBig)) [l, r] =

686− do

687− setUsedITBig

688− pure $ jsB2I $ JsForeign "%0.compareTo(%1) < 0" [l,r]

689−cgOp (LSLt (ATInt (ITFixed IT8))) [l, r] = pure $ jsB2I $ JsBinOp "<" l r

690−cgOp (LSLt (ATInt (ITFixed IT16))) [l, r] = pure $ jsB2I $ JsBinOp "<" l r

691−cgOp (LSLt (ATInt (ITFixed IT32))) [l, r] = pure $ jsB2I $ JsBinOp "<" l r

692−cgOp (LSLt (ATInt (ITFixed IT64))) [l, r] =

693− do

694− setUsedITBig

695− pure $ jsB2I $ JsForeign "%0.compareTo(%1) < 0" [l,r]

696−cgOp (LSLe ATFloat) [l, r] = pure $ jsB2I $ JsBinOp "<=" l r

697−cgOp (LSLe (ATInt ITNative)) [l, r] = pure $ jsB2I $ JsBinOp "<=" l r

698−cgOp (LSLe (ATInt ITBig)) [l, r] =

699− do

700− setUsedITBig

701− pure $ jsB2I $ JsForeign "%0.compareTo(%1) <= 0" [l,r]

702−cgOp (LSLe (ATInt (ITFixed IT8))) [l, r] = pure $ jsB2I $ JsBinOp "<=" l r

703−cgOp (LSLe (ATInt (ITFixed IT16))) [l, r] = pure $ jsB2I $ JsBinOp "<=" l r

704−cgOp (LSLe (ATInt (ITFixed IT32))) [l, r] = pure $ jsB2I $ JsBinOp "<=" l r

705−cgOp (LSLe (ATInt (ITFixed IT64))) [l, r] =

706− do

707− setUsedITBig

708− pure $ jsB2I $ JsForeign "%0.compareTo(%1) <= 0" [l,r]

709−cgOp (LSGt ATFloat) [l, r] = pure $ jsB2I $ JsBinOp ">" l r

710−cgOp (LSGt (ATInt ITNative)) [l, r] = pure $ jsB2I $ JsBinOp ">" l r

711−cgOp (LSGt (ATInt ITBig)) [l, r] =

712− do

713− setUsedITBig

714− pure $ jsB2I $ JsForeign "%0.compareTo(%1) > 0" [l,r]

715−cgOp (LSGt (ATInt (ITFixed IT8))) [l, r] = pure $ jsB2I $ JsBinOp ">" l r

716−cgOp (LSGt (ATInt (ITFixed IT16))) [l, r] = pure $ jsB2I $ JsBinOp ">" l r

717−cgOp (LSGt (ATInt (ITFixed IT32))) [l, r] = pure $ jsB2I $ JsBinOp ">" l r

718−cgOp (LSGt (ATInt (ITFixed IT64))) [l, r] =

719− do

720− setUsedITBig

721− pure $ jsB2I $ JsForeign "%0.compareTo(%1) > 0" [l,r]

722−cgOp (LSGe ATFloat) [l, r] = pure $ jsB2I $ JsBinOp ">=" l r

723−cgOp (LSGe (ATInt ITNative)) [l, r] = pure $ jsB2I $ JsBinOp ">=" l r

724−cgOp (LSGe (ATInt ITBig)) [l, r] =

725− do

726− setUsedITBig

727− pure $ jsB2I $ JsForeign "%0.compareTo(%1) >= 0" [l,r]

728−cgOp (LSGe (ATInt (ITFixed IT8))) [l, r] = pure $ jsB2I $ JsBinOp ">=" l r

729−cgOp (LSGe (ATInt (ITFixed IT16))) [l, r] = pure $ jsB2I $ JsBinOp ">=" l r

730−cgOp (LSGe (ATInt (ITFixed IT32))) [l, r] = pure $ jsB2I $ JsBinOp ">=" l r

731−cgOp (LSGe (ATInt (ITFixed IT64))) [l, r] =

732− do

733− setUsedITBig

734− pure $ jsB2I $ JsForeign "%0.compareTo(%1) >= 0" [l,r]

735−cgOp (LSExt ITNative ITBig) [x] =

736− do

737− setUsedITBig

738− pure $ JsForeign "new jsbn.BigInteger(String(%0))" [x]

739−cgOp (LZExt (ITFixed IT8) ITNative) [x] = pure x

740−cgOp (LZExt (ITFixed IT16) ITNative) [x] = pure x

741−cgOp (LZExt (ITFixed IT32) ITNative) [x] = pure x

742−cgOp (LZExt ITNative ITBig) [x] =

743− do

744− setUsedITBig

745− pure $ JsForeign "new jsbn.BigInteger(String(%0))" [x]

746−cgOp (LTrunc ITBig ITNative) [x] =

747− do

748− setUsedITBig

749− pure $ JsForeign "%0.intValue()|0" [x]

750−cgOp (LTrunc (ITFixed IT16) (ITFixed IT8)) [x] = pure $ JsForeign "%0 & 0xFF" [x]

751−cgOp (LTrunc (ITFixed IT32) (ITFixed IT8)) [x] = pure $ JsForeign "%0 & 0xFF" [x]

752−cgOp (LTrunc (ITFixed IT64) (ITFixed IT8)) [x] =

753− do

754− setUsedITBig

755− pure $ JsForeign "%0.intValue() & 0xFF" [x]

756−cgOp (LTrunc (ITFixed IT32) (ITFixed IT16)) [x] = pure $ JsForeign "%0 & 0xFFFF" [x]

757−cgOp (LTrunc (ITFixed IT64) (ITFixed IT16)) [x] =

758− do

759− setUsedITBig

760− pure $ JsForeign "%0.intValue() & 0xFFFF" [x]

761−cgOp (LTrunc (ITFixed IT64) (ITFixed IT32)) [x] =

762− do

763− setUsedITBig

764− pure $ JsForeign "%0.intValue() & 0xFFFFFFFF" [x]

765−cgOp (LTrunc ITBig (ITFixed IT64)) [x] =

766− do

767− setUsedITBig

768− pure $ JsForeign "%0.and(new jsbn.BigInteger(%1))" [x, JsStr $ show 0xFFFFFFFFFFFFFFFF]

769−cgOp LStrConcat [l,r] = pure $ JsBinOp "+" l r

770−cgOp LStrLt [l, r] = pure $ jsB2I $ JsBinOp "<" l r

771−cgOp LStrEq [l,r] = pure $ jsB2I $ JsBinOp "==" l r

772−cgOp LStrLen [x] = pure $ JsForeign "%0.length" [x]

773−cgOp (LIntFloat ITNative) [x] = pure $ x

774−cgOp (LIntFloat ITBig) [x] =

775− do

776− setUsedITBig

777− pure $ JsForeign "%0.intValue()" [x]

778−cgOp (LFloatInt ITNative) [x] = pure $ JsForeign "%0|0" [x]

779−cgOp (LIntStr ITNative) [x] = pure $ JsApp "String" [x]

780−cgOp (LIntStr ITBig) [x] =

781− do

782− setUsedITBig

783− pure $ JsForeign "%0.toString()" [x]

784−cgOp (LStrInt ITNative) [x] = pure $ JsForeign "parseInt(%0)|0" [x]

785−cgOp (LStrInt ITBig) [x] =

786− do

787− setUsedITBig

788− pure $ JsForeign "new jsbn.BigInteger(%0)" [x]

789−cgOp (LFloatStr) [x] = pure $ JsApp "String" [x]

790−cgOp (LStrFloat) [x] = pure $ JsApp "parseFloat" [x]

791−cgOp (LChInt ITNative) [x] = pure $ JsForeign "%0.charCodeAt(0)|0" [x]

792−cgOp (LIntCh ITNative) [x] = pure $ JsApp "String.fromCharCode" [x]

793−cgOp LFExp [x] = pure $ JsApp "Math.exp" [x]

794−cgOp LFLog [x] = pure $ JsApp "Math.log" [x]

795−cgOp LFSin [x] = pure $ JsApp "Math.sin" [x]

796−cgOp LFCos [x] = pure $ JsApp "Math.cos" [x]

797−cgOp LFTan [x] = pure $ JsApp "Math.tan" [x]

798−cgOp LFASin [x] = pure $ JsApp "Math.asin" [x]

799−cgOp LFACos [x] = pure $ JsApp "Math.acos" [x]

800−cgOp LFATan [x] = pure $ JsApp "Math.atan" [x]

801−cgOp LFSqrt [x] = pure $ JsApp "Math.sqrt" [x]

802−cgOp LFFloor [x] = pure $ JsApp "Math.floor" [x]

803−cgOp LFCeil [x] = pure $ JsApp "Math.ceil" [x]

804−cgOp LFNegate [x] = pure $ JsForeign "-%0" [x]

805−cgOp LStrHead [x] = pure $ JsArrayProj (JsInt 0) x

806−cgOp LStrTail [x] = pure $ JsMethod x "slice" [JsInt 1]

807−cgOp LStrCons [l,r] = pure $ JsForeign "%0+%1" [l,r]

808−cgOp LStrIndex [x, y] = pure $ JsArrayProj y x

809−cgOp LStrRev [x] = pure $ JsForeign "%0.split('').reverse().join('')" [x]

810−cgOp LStrSubstr [offset,len,str] = pure $ JsForeign "%0.substr(Math.max(0,%1), Math.max(0, %2))" [str, offset, len]

811−cgOp LReadStr [_] =

812− do

813− s <- get

814− put $ s {usedRead = True}

815− pure $ JsForeign (readStrTemplate $ conf s) []

816−cgOp LWriteStr [_,str] =

817− do

818− s <- get

819− put $ s {usedWrite = True}

820− pure $ JsForeign (writeStrTemplate $ conf s) [str]

821−cgOp LSystemInfo [x] = pure $ JsApp "js_idris_systemInfo" [x]

822−cgOp (LExternal name) _ | name == sUN "prim__null" = pure JsNull

823−cgOp (LExternal name) [l,r] | name == sUN "prim__eqPtr" = pure $ JsBinOp "==" l r

824−cgOp LCrash [l] = pure $ JsErrorExp l

825−cgOp LNoOp [x] = pure x

826−cgOp op exps = error ("Operator " ++ show (op, exps) ++ " not implemented")

src/IRTS/JavaScript/Name.hsnew file+60

@@ -0,0 +1,60 @@

1+{-|

2+Module : IRTS.JavaScript.Name

3+Description : The JavaScript name mangler.

4+Copyright :

5+License : BSD3

6+Maintainer : The Idris Community.

7+-}

9+{-# LANGUAGE OverloadedStrings, PatternGuards #-}

10+

11+module IRTS.JavaScript.Name

12+ ( jsName

13+ , jsNameGenerated

14+ , Partial(..)

15+ , jsNamePartial

16+ , jsTailCallOptimName

17+ , HiddenClass(..)

18+ , jsNameHiddenClass

19+ , dataPartName

20+ ) where

21+

22+import Data.Char

23+import Data.List

24+import qualified Data.Map.Strict as Map

25+import Data.Text (Text)

26+import qualified Data.Text as T

27+import Idris.Core.TT

28+import IRTS.JavaScript.AST

29+

30+jsEscape :: String -> String

31+jsEscape = concatMap jschar

32+ where

33+ jschar x

34+ | isAlpha x || isDigit x = [x]

35+ | x == '.' = "__"

36+ | otherwise = "_" ++ show (fromEnum x) ++ "_"

37+

38+jsName :: Name -> Text

39+jsName (MN i u) = T.concat ["$_", T.pack (show i), "_", T.pack $ jsEscape $ T.unpack u]

40+jsName n = T.pack $ jsEscape $ showCG n

41+

42+jsNameGenerated :: Int -> Text

43+jsNameGenerated v = T.pack $ "$cg$" ++ show v

44+

45+data Partial = Partial Name Int Int deriving (Eq, Ord)

46+

47+jsNamePartial :: Partial -> Text

48+jsNamePartial (Partial n i j) = T.concat ["$partial_", T.pack $ show i, "_", T.pack $ show j, "$" , jsName n]

49+

50+jsTailCallOptimName :: Text -> Text

51+jsTailCallOptimName x = T.concat ["$tco$", x]

52+

53+

54+data HiddenClass = HiddenClass Name Int Int deriving (Eq, Ord)

55+

56+jsNameHiddenClass :: HiddenClass -> Text

57+jsNameHiddenClass (HiddenClass n id arity) = T.concat ["$HC_", T.pack $ show arity, "_", T.pack $ show id,"$", jsName n]

58+

59+dataPartName :: Int -> Text

60+dataPartName i = T.pack $ "$" ++ show i

src/IRTS/JavaScript/PrimOp.hsnew file+239

@@ -0,0 +1,239 @@

1+{-|

2+Module : IRTS.JavaScript.PrimOp

3+Description : The JavaScript primitive operations.

4+Copyright :

5+License : BSD3

6+Maintainer : The Idris Community.

7+-}

9+{-# LANGUAGE OverloadedStrings, PatternGuards, StandaloneDeriving #-}

10+

11+module IRTS.JavaScript.PrimOp

12+ ( PrimF

13+ , PrimDec

14+ , JsPrimTy(..)

15+ , primDB

16+ , jsPrimCoerce

17+ ) where

18+

19+import Data.Char

20+import Data.List

21+import qualified Data.Map.Strict as Map

22+import Data.Text (Text)

23+import qualified Data.Text as T

24+import Idris.Core.TT

25+import IRTS.JavaScript.AST

26+import IRTS.Lang

27+

28+data JsPrimTy = PTBool | PTAny deriving (Eq, Ord)

29+

30+type PrimF = [JsExpr] -> JsExpr

31+type PrimDec = (Bool, JsPrimTy, PrimF)

32+

33+deriving instance Ord PrimFn

34+

35+primDB :: Map.Map PrimFn PrimDec

36+primDB =

37+ Map.fromList [

38+ item (LPlus ATFloat) False PTAny $ binop "+"

39+ , item (LPlus (ATInt ITChar)) False PTAny $ JsForeign "String.fromCharCode(%0.charCodeAt(0) + %1.charCodeAt(0))"

40+ , item (LPlus (ATInt ITNative)) False PTAny $ JsForeign "%0+%1|0"

41+ , item (LPlus (ATInt (ITFixed IT8))) False PTAny $ JsForeign "%0 + %1 & 0xFF"

42+ , item (LPlus (ATInt (ITFixed IT16))) False PTAny $ JsForeign "%0 + %1 & 0xFFFF"

43+ , item (LPlus (ATInt (ITFixed IT32))) False PTAny $ JsForeign "%0+%1|0"

44+ , item (LPlus (ATInt ITBig)) True PTAny $ method "add"

45+ , item (LPlus (ATInt (ITFixed IT64))) True PTAny $

46+ \[l, r] -> JsForeign "%0.add(%1).and(new $JSRTS.jsbn.BigInteger(%2))" [l,r, JsStr $ show 0xFFFFFFFFFFFFFFFF]

47+ , item (LMinus ATFloat) False PTAny $ binop "-"

48+ , item (LMinus (ATInt ITChar)) False PTAny $ JsForeign "String.fromCharCode(%0.charCodeAt(0) - %1.charCodeAt(0))"

49+ , item (LMinus (ATInt ITNative)) False PTAny $ JsForeign "%0-%1|0"

50+ , item (LMinus (ATInt (ITFixed IT8))) False PTAny $ JsForeign "%0 - %1 & 0xFF"

51+ , item (LMinus (ATInt (ITFixed IT16))) False PTAny $ JsForeign "%0 - %1 & 0xFFFF"

52+ , item (LMinus (ATInt (ITFixed IT32))) False PTAny $ JsForeign "%0-%1|0"

53+ , item (LMinus (ATInt ITBig)) True PTAny $ method "subtract"

54+ , item (LMinus (ATInt (ITFixed IT64))) True PTAny $

55+ \[l, r] -> JsForeign "%0.subtract(%1).and(new $JSRTS.jsbn.BigInteger(%2))" [l,r, JsStr $ show 0xFFFFFFFFFFFFFFFF]

56+ , item (LTimes ATFloat) False PTAny $ binop "*"

57+ , item (LTimes (ATInt ITChar)) False PTAny $ JsForeign "String.fromCharCode(%0.charCodeAt(0) * %1.charCodeAt(0))"

58+ , item (LTimes (ATInt ITNative)) False PTAny $ JsForeign "%0*%1|0"

59+ , item (LTimes (ATInt (ITFixed IT8))) False PTAny $ JsForeign "%0 * %1 & 0xFF"

60+ , item (LTimes (ATInt (ITFixed IT16))) False PTAny $ JsForeign "%0 * %1 & 0xFFFF"

61+ , item (LTimes (ATInt (ITFixed IT32))) False PTAny $ JsForeign "%0*%1|0"

62+ , item (LTimes (ATInt ITBig)) True PTAny $ method "multiply"

63+ , item (LTimes (ATInt (ITFixed IT64))) True PTAny $

64+ \[l, r] -> JsForeign "%0.multiply(%1).and(new $JSRTS.jsbn.BigInteger(%2))" [l,r, JsStr $ show 0xFFFFFFFFFFFFFFFF]

65+ , item (LUDiv (ITFixed IT8)) False PTAny $ JsForeign "%0 / %1"

66+ , item (LUDiv (ITFixed IT16)) False PTAny $ JsForeign "%0 / %1"

67+ , item (LUDiv (ITFixed IT32)) False PTAny $ JsForeign "(%0>>>0) / (%1>>>0) |0"

68+ , item (LUDiv (ITFixed IT64)) True PTAny $ JsForeign "%0.divide(%1)"

69+ , item (LSDiv ATFloat) False PTAny $ binop "/"

70+ , item (LSDiv (ATInt (ITFixed IT8))) False PTAny $ JsForeign "%0 / %1"

71+ , item (LSDiv (ATInt (ITFixed IT16))) False PTAny $ JsForeign "%0 / %1"

72+ , item (LSDiv (ATInt (ITFixed IT32))) False PTAny $ JsForeign "%0 / %1 |0"

73+ , item (LSDiv (ATInt (ITFixed IT64))) True PTAny $ JsForeign "%0.divide(%1)"

74+ , item (LSDiv (ATInt ITNative)) False PTAny $ JsForeign "%0/%1|0"

75+ , item (LSDiv (ATInt ITBig)) True PTAny $ method "divide"

76+ , item (LURem (ITFixed IT8)) False PTAny $ JsForeign "%0 % %1"

77+ , item (LURem (ITFixed IT16)) False PTAny $ JsForeign "%0 % %1"

78+ , item (LURem (ITFixed IT32)) False PTAny $ JsForeign "(%0>>>0) % (%1>>>0) |0"

79+ , item (LURem (ITFixed IT64)) True PTAny $ method "remainder"

80+ , item (LSRem ATFloat) False PTAny $ binop "%"

81+ , item (LSRem (ATInt ITNative)) False PTAny $ JsForeign "%0 % %1 |0"

82+ , item (LSRem (ATInt (ITFixed IT8))) False PTAny $ JsForeign "%0 % %1"

83+ , item (LSRem (ATInt (ITFixed IT16))) False PTAny $ JsForeign "%0 % %1"

84+ , item (LSRem (ATInt (ITFixed IT32))) False PTAny $ JsForeign "%0 % %1 |0"

85+ , item (LSRem (ATInt (ITFixed IT64))) True PTAny $ method "remainder"

86+ , item (LSRem (ATInt ITBig)) True PTAny $ method "remainder"

87+ , item (LAnd ITNative) False PTAny $ JsForeign "%0 & %1"

88+ , item (LAnd (ITFixed IT8)) False PTAny $ JsForeign "%0 & %1"

89+ , item (LAnd (ITFixed IT16)) False PTAny $ JsForeign "%0 & %1"

90+ , item (LAnd (ITFixed IT32)) False PTAny $ JsForeign "%0 & %1"

91+ , item (LAnd (ITFixed IT64)) True PTAny $ method "and"

92+ , item (LAnd ITBig) True PTAny $ method "and"

93+ , item (LOr ITNative) False PTAny $ JsForeign "%0 | %1"

94+ , item (LOr (ITFixed IT8)) False PTAny $ JsForeign "%0 | %1"

95+ , item (LOr (ITFixed IT16)) False PTAny $ JsForeign "%0 | %1"

96+ , item (LOr (ITFixed IT32)) False PTAny $ JsForeign "%0 | %1"

97+ , item (LOr (ITFixed IT64)) True PTAny $ method "or"

98+ , item (LOr ITBig) True PTAny $ method "or"

99+ , item (LXOr ITNative) False PTAny $ JsForeign "%0 ^ %1"

100+ , item (LXOr (ITFixed IT8)) False PTAny $ JsForeign "%0 ^ %1"

101+ , item (LXOr (ITFixed IT16)) False PTAny $ JsForeign "%0 ^ %1"

102+ , item (LXOr (ITFixed IT32)) False PTAny $ JsForeign "%0 ^ %1"

103+ , item (LXOr (ITFixed IT64)) True PTAny $ method "xor"

104+ , item (LXOr ITBig) True PTAny $ method "xor"

105+ , item (LSHL ITNative) False PTAny $ JsForeign "%0 << %1 |0"

106+ , item (LSHL (ITFixed IT8)) False PTAny $ JsForeign "%0 << %1 & 0xFF"

107+ , item (LSHL (ITFixed IT16)) False PTAny $ JsForeign "%0 << %1 & 0xFFFF"

108+ , item (LSHL (ITFixed IT32)) False PTAny $ JsForeign "%0 << %1 | 0"

109+ , item (LSHL (ITFixed IT64)) True PTAny $

110+ \[l, r] -> JsForeign "%0.shiftLeft(%1).and(new $JSRTS.jsbn.BigInteger(%2))" [l,r, JsStr $ show 0xFFFFFFFFFFFFFFFF]

111+ , item (LSHL ITBig) True PTAny $ method "shiftLeft"

112+ , item (LLSHR ITNative) False PTAny $ JsForeign "%0 >> %1 |0"

113+ , item (LLSHR (ITFixed IT8)) False PTAny $ JsForeign "%0 >> %1"

114+ , item (LLSHR (ITFixed IT16)) False PTAny $ JsForeign "%0 >> %1"

115+ , item (LLSHR (ITFixed IT32)) False PTAny $ JsForeign "%0 >> %1|0"

116+ , item (LLSHR (ITFixed IT64)) True PTAny $ JsForeign "%0.shiftRight(%1)"

117+ , item (LASHR ITNative) False PTAny $ JsForeign "%0 >> %1 |0"

118+ , item (LASHR (ITFixed IT8)) False PTAny $ JsForeign "%0 >> %1"

119+ , item (LASHR (ITFixed IT16)) False PTAny $ JsForeign "%0 >> %1"

120+ , item (LASHR (ITFixed IT32)) False PTAny $ JsForeign "%0 >> %1|0"

121+ , item (LASHR (ITFixed IT64)) True PTAny $ JsForeign "%0.shiftRight(%1)"

122+ , item (LEq ATFloat) False PTBool $ binop "==="

123+ , item (LEq (ATInt ITNative)) False PTBool $ binop "==="

124+ , item (LEq (ATInt ITChar)) False PTBool $ binop "==="

125+ , item (LEq (ATInt ITBig)) True PTBool $ method "equals"

126+ , item (LEq (ATInt (ITFixed IT8))) False PTBool $ binop "==="

127+ , item (LEq (ATInt (ITFixed IT16))) False PTBool $ binop "==="

128+ , item (LEq (ATInt (ITFixed IT32))) False PTBool $ binop "==="

129+ , item (LEq (ATInt (ITFixed IT64))) True PTBool $ method "equals"

130+ , item (LLt (ITFixed IT8)) False PTBool $ JsForeign "%0 < %1"

131+ , item (LLt (ITFixed IT16)) False PTBool $ JsForeign "%0 < %1"

132+ , item (LLt (ITFixed IT32)) False PTBool $ JsForeign "(%0>>>0) < (%1>>>0)"

133+ , item (LLt (ITFixed IT64)) True PTBool $ JsForeign "%0.compareTo(%1) < 0"

134+ , item (LLe (ITFixed IT8)) False PTBool $ JsForeign "%0 <= %1"

135+ , item (LLe (ITFixed IT16)) False PTBool $ JsForeign "%0 <= %1"

136+ , item (LLe (ITFixed IT32)) False PTBool $ JsForeign "(%0>>>0) <= (%1>>>0)"

137+ , item (LLe (ITFixed IT64)) True PTBool $ JsForeign "%0.compareTo(%1) <= 0"

138+ , item (LGt (ITFixed IT8)) False PTBool $ JsForeign "%0 > %1"

139+ , item (LGt (ITFixed IT16)) False PTBool $ JsForeign "%0 > %1"

140+ , item (LGt (ITFixed IT32)) False PTBool $ JsForeign "(%0>>>0) > (%1>>>0)"

141+ , item (LGt (ITFixed IT64)) True PTBool $ JsForeign "%0.compareTo(%1) > 0"

142+ , item (LGe (ITFixed IT8)) False PTBool $ JsForeign "%0 >= %1"

143+ , item (LGe (ITFixed IT16)) False PTBool $ JsForeign "%0 >= %1"

144+ , item (LGe (ITFixed IT32)) False PTBool $ JsForeign "(%0>>>0) >= (%1>>>0)"

145+ , item (LGe (ITFixed IT64)) True PTBool $ JsForeign "%0.compareTo(%1) >= 0"

146+ , item (LSLt ATFloat) False PTBool $ binop "<"

147+ , item (LSLt (ATInt ITChar)) False PTBool $ binop "<"

148+ , item (LSLt (ATInt ITNative)) False PTBool $ binop "<"

149+ , item (LSLt (ATInt ITBig)) True PTBool $ JsForeign "%0.compareTo(%1) < 0"

150+ , item (LSLt (ATInt (ITFixed IT8))) False PTBool $ binop "<"

151+ , item (LSLt (ATInt (ITFixed IT16))) False PTBool $ binop "<"

152+ , item (LSLt (ATInt (ITFixed IT32))) False PTBool $ binop "<"

153+ , item (LSLt (ATInt (ITFixed IT64))) True PTBool $ JsForeign "%0.compareTo(%1) < 0"

154+ , item (LSLe ATFloat) False PTBool $ binop "<="

155+ , item (LSLe (ATInt ITNative)) False PTBool $ binop "<="

156+ , item (LSLe (ATInt ITBig)) True PTBool $ JsForeign "%0.compareTo(%1) <= 0"

157+ , item (LSLe (ATInt (ITFixed IT8))) False PTBool $ binop "<="

158+ , item (LSLe (ATInt (ITFixed IT16))) False PTBool $ binop "<="

159+ , item (LSLe (ATInt (ITFixed IT32))) False PTBool $ binop "<="

160+ , item (LSLe (ATInt (ITFixed IT64))) True PTBool $ JsForeign "%0.compareTo(%1) <= 0"

161+ , item (LSGt ATFloat) False PTBool $ binop ">"

162+ , item (LSGt (ATInt ITNative)) False PTBool $ binop ">"

163+ , item (LSGt (ATInt ITBig)) True PTBool $ JsForeign "%0.compareTo(%1) > 0"

164+ , item (LSGt (ATInt (ITFixed IT8))) False PTBool $ binop ">"

165+ , item (LSGt (ATInt (ITFixed IT16))) False PTBool $ binop ">"

166+ , item (LSGt (ATInt (ITFixed IT32))) False PTBool $ binop ">"

167+ , item (LSGt (ATInt (ITFixed IT64))) True PTBool $ JsForeign "%0.compareTo(%1) > 0"

168+ , item (LSGe ATFloat) False PTBool $ binop ">="

169+ , item (LSGe (ATInt ITNative)) False PTBool $ binop ">="

170+ , item (LSGe (ATInt ITBig)) True PTBool $ JsForeign "%0.compareTo(%1) >= 0"

171+ , item (LSGe (ATInt (ITFixed IT8))) False PTBool $ binop ">="

172+ , item (LSGe (ATInt (ITFixed IT16))) False PTBool $ binop ">="

173+ , item (LSGe (ATInt (ITFixed IT32))) False PTBool $ binop ">="

174+ , item (LSGe (ATInt (ITFixed IT64))) True PTBool $ JsForeign "%0.compareTo(%1) >= 0"

175+ , item (LSExt ITNative ITBig) True PTAny $ JsForeign "new $JSRTS.jsbn.BigInteger(''+%0)"

176+ , item (LZExt (ITFixed IT8) ITNative) False PTAny $ head

177+ , item (LZExt (ITFixed IT16) ITNative) False PTAny $ head

178+ , item (LZExt (ITFixed IT32) ITNative) False PTAny $ head

179+ , item (LZExt ITNative ITBig) True PTAny $ JsForeign "new $JSRTS.jsbn.BigInteger(''+%0)"

180+ , item (LTrunc ITBig ITNative) True PTAny $ JsForeign "%0.intValue()|0"

181+ , item (LTrunc (ITFixed IT16) (ITFixed IT8)) False PTAny $ JsForeign "%0 & 0xFF"

182+ , item (LTrunc (ITFixed IT32) (ITFixed IT8)) False PTAny $ JsForeign "%0 & 0xFF"

183+ , item (LTrunc (ITFixed IT64) (ITFixed IT8)) True PTAny $ JsForeign "%0.intValue() & 0xFF"

184+ , item (LTrunc (ITFixed IT32) (ITFixed IT16)) False PTAny $ JsForeign "%0 & 0xFFFF"

185+ , item (LTrunc (ITFixed IT64) (ITFixed IT16)) True PTAny $ JsForeign "%0.intValue() & 0xFFFF"

186+ , item (LTrunc (ITFixed IT64) (ITFixed IT32)) True PTAny $ JsForeign "%0.intValue() & 0xFFFFFFFF"

187+ , item (LTrunc ITBig (ITFixed IT64)) True PTAny $

188+ \[x] -> JsForeign "%0.and(new $JSRTS.jsbn.BigInteger(%1))" [x, JsStr $ show 0xFFFFFFFFFFFFFFFF]

189+ , item LStrConcat False PTAny $ binop "+"

190+ , item LStrLt False PTBool $ binop "<"

191+ , item LStrEq False PTBool $ binop "=="

192+ , item LStrLen False PTAny $ JsForeign "%0.length"

193+ , item (LIntFloat ITNative) False PTAny $ head

194+ , item (LIntFloat ITBig) True PTAny $ JsForeign "%0.intValue()"

195+ , item (LFloatInt ITNative) False PTAny $ JsForeign "%0|0"

196+ , item (LIntStr ITNative) False PTAny $ JsForeign "''+%0"

197+ , item (LIntStr ITBig) True PTAny $ JsForeign "%0.toString()"

198+ , item (LStrInt ITNative) False PTAny $ JsForeign "parseInt(%0)|0"

199+ , item (LStrInt ITBig) True PTAny $ JsForeign "new $JSRTS.jsbn.BigInteger(%0)"

200+ , item (LFloatStr) False PTAny $ JsForeign "''+%0"

201+ , item (LStrFloat) False PTAny $ jsAppN "parseFloat"

202+ , item (LChInt ITNative) False PTAny $ JsForeign "%0.charCodeAt(0)|0"

203+ , item (LIntCh ITNative) False PTAny $ jsAppN "String.fromCharCode"

204+ , item LFExp False PTAny $ jsAppN "Math.exp"

205+ , item LFLog False PTAny $ jsAppN "Math.log"

206+ , item LFSin False PTAny $ jsAppN "Math.sin"

207+ , item LFCos False PTAny $ jsAppN "Math.cos"

208+ , item LFTan False PTAny $ jsAppN "Math.tan"

209+ , item LFASin False PTAny $ jsAppN "Math.asin"

210+ , item LFACos False PTAny $ jsAppN "Math.acos"

211+ , item LFATan False PTAny $ jsAppN "Math.atan"

212+ , item LFSqrt False PTAny $ jsAppN "Math.sqrt"

213+ , item LFFloor False PTAny $ jsAppN "Math.floor"

214+ , item LFCeil False PTAny $ jsAppN "Math.ceil"

215+ , item LFNegate False PTAny $ JsForeign "-%0"

216+ , item LStrHead False PTAny $ \[x] -> JsArrayProj (JsInt 0) x

217+ , item LStrTail False PTAny $ \[x] -> JsMethod x "slice" [JsInt 1]

218+ , item LStrCons False PTAny $ JsForeign "%0+%1"

219+ , item LStrIndex False PTAny $ \[x, y] -> JsArrayProj y x

220+ , item LStrRev False PTAny $ JsForeign "%0.split('').reverse().join('')"

221+ , item LStrSubstr False PTAny $ JsForeign "$JSRTS.prim_strSubstr(%0, %1, %2)"

222+ , item LSystemInfo False PTAny $ JsApp (JsProp (JsVar "$JSRTS") "prim_systemInfo")

223+ , item LCrash False PTAny $ \[l] -> JsErrorExp l

224+ , item LReadStr False PTAny $ \[_] -> JsApp (JsProp (JsVar "$JSRTS") "prim_readStr") []

225+ , item LWriteStr False PTAny $ \[_, str] -> JsApp (JsProp (JsVar "$JSRTS") "prim_writeStr") [str]

226+ , item LNoOp False PTAny $ head

227+ ]

228+ where

229+ item :: PrimFn -> Bool -> JsPrimTy -> PrimF -> (PrimFn, PrimDec)

230+ item fn ubi pty c = (fn, (ubi, pty, c))

231+ binop op [l, r] = JsBinOp op l r

232+ method op (l:r) = JsMethod l op r

233+

234+jsB2I :: JsExpr -> JsExpr

235+jsB2I x = JsForeign "%0 ? 1|0 : 0|0" [x]

236+

237+jsPrimCoerce :: JsPrimTy -> JsPrimTy -> JsExpr -> JsExpr

238+jsPrimCoerce PTBool PTAny x = jsB2I x

239+jsPrimCoerce _ _ x = x

src/IRTS/JavaScript/Specialize.hsnew file+123

@@ -0,0 +1,123 @@

1+{-|

2+Module : IRTS.JavaScript.Specialize

3+Description : The JavaScript specializer.

4+Copyright :

5+License : BSD3

6+Maintainer : The Idris Community.

7+-}

9+{-# LANGUAGE OverloadedStrings, PatternGuards #-}

10+

11+module IRTS.JavaScript.Specialize

12+ ( SCtor

13+ , STest

14+ , SProj

15+ , specialCased

16+ , specialCall

17+ , qualifyN

18+ ) where

19+

20+import Data.Char

21+import Data.List

22+import qualified Data.Map.Strict as Map

23+import Data.Text (Text)

24+import qualified Data.Text as T

25+import Idris.Core.TT

26+import IRTS.JavaScript.AST

27+

28+split :: Char -> String -> [String]

29+split c "" = [""]

30+split c (x:xs)

31+ | c == x = "" : split c xs

32+ | otherwise =

33+ let ~(h:t) = split c xs

34+ in ((x : h) : t)

35+

36+qualify :: String -> Name -> Name

37+qualify "" n = n

38+qualify ns n = sNS n (reverse $ split '.' ns)

39+

40+qualifyN :: String -> String -> Name

41+qualifyN ns n = qualify ns $ sUN n

42+

43+-- special-cased constructors

44+type SCtor = [JsExpr] -> JsExpr

45+

46+type STest = JsExpr -> JsExpr

47+

48+type SProj = JsExpr -> Int -> JsExpr

49+

50+constructorOptimizeDB :: Map.Map Name (SCtor, STest, SProj)

51+constructorOptimizeDB =

52+ Map.fromList

53+ [ item "Prelude.Bool" "True" (const $ JsBool True) trueTest cantProj

54+ , item "Prelude.Bool" "False" (const $ JsBool False) falseTest cantProj

55+ , item "Prelude.Interfaces" "LT" (const $ JsInt (0-1)) ltTest cantProj

56+ , item "Prelude.Interfaces" "EQ" (const $ JsInt 0) eqTest cantProj

57+ , item "Prelude.Interfaces" "GT" (const $ JsInt 1) gtTest cantProj

58+ -- , item "Prelude.List" "::" cons fillList uncons

59+ -- , item "Prelude.List" "Nil" nil emptyList cantProj

60+ -- , item "Prelude.Maybe" "Just" (\[x] -> x) notNoneTest justProj

61+ -- , item "Prelude.Maybe" "Nothing" (const $ JsUndefined) noneTest cantProj

62+ ]

63+ -- constructors

64+ where

65+ nil = const $ JsArray []

66+ cons [h, t] = JsMethod (JsArray [h]) "concat" [t]

67+ -- tests

68+ --trueTest e = JsUniOp (T.pack "!") $ JsUniOp (T.pack "!") e

69+ trueTest = id

70+ falseTest e = JsUniOp (T.pack "!") e

71+ emptyList e = JsBinOp "===" (JsProp e "length") (JsInt 0)

72+ fillList e = JsBinOp ">" (JsProp e "length") (JsInt 0)

73+ ltTest e = JsBinOp "<" e (JsInt 0)

74+ eqTest e = JsBinOp "===" e (JsInt 0)

75+ gtTest e = JsBinOp ">" e (JsInt 0)

76+ noneTest e = JsBinOp "===" e JsUndefined

77+ notNoneTest e = JsBinOp "!==" e JsUndefined

78+ -- projections

79+ justProj x n = x

80+ uncons x 1 = JsArrayProj (JsInt 0) x

81+ uncons x 2 = JsMethod x "slice" [JsInt 1]

82+ cantProj x j = error $ "This type should be projected"

83+ item :: String

84+ -> String

85+ -> SCtor

86+ -> STest

87+ -> SProj

88+ -> (Name, (SCtor, STest, SProj))

89+ item ns n ctor test match = (qualifyN ns n, (ctor, test, match))

90+

91+specialCased :: Name -> Maybe (SCtor, STest, SProj)

92+specialCased n = Map.lookup n constructorOptimizeDB

93+

94+-- special functions

95+type SSig = (Int, [JsExpr] -> JsExpr)

96+

97+callSpecializeDB :: Map.Map Name (SSig)

98+callSpecializeDB =

99+ Map.fromList

100+ [ qb "Eq" "Int" "==" "==="

101+ , qb "Ord" "Int" "<" "<"

102+ , qb "Ord" "Int" ">" ">"

103+ , qb "Ord" "Int" "<=" "<="

104+ , qb "Ord" "Int" ">=" ">="

105+ , qb "Eq" "Double" "==" "==="

106+ , qb "Ord" "Double" "<" "<"

107+ , qb "Ord" "Double" ">" ">"

108+ , qb "Ord" "Double" "<=" "<="

109+ , qb "Ord" "Double" ">=" ">="

110+ ]

111+ where

112+ qb intf ty op jsop =

113+ ( qualify "Prelude.Interfaces" $

114+ SN $

115+ WhereN

116+ 0

117+ (qualify "Prelude.Interfaces" $

118+ SN $ ImplementationN (qualifyN "Prelude.Interfaces" intf) [ty])

119+ (SN $ MethodN $ UN op)

120+ , (2, \[x, y] -> JsBinOp jsop x y))

121+

122+specialCall :: Name -> Maybe SSig

123+specialCall n = Map.lookup n callSpecializeDB