1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
// Js_of_ocaml runtime support
// http://www.ocsigen.org/js_of_ocaml/
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, with linking exception;
// either version 2.1 of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//Provides: caml_format_int const (const, const)
//Requires: caml_parse_format, caml_finish_formatting, caml_str_repeat
//Requires: caml_string_of_jsbytes, caml_jsbytes_of_string
function caml_format_int(fmt, i) {
if (caml_jsbytes_of_string(fmt) == "%d") return caml_string_of_jsbytes(""+i);
var f = caml_parse_format(fmt);
if (i < 0) { if (f.signedconv) { f.sign = -1; i = -i; } else i >>>= 0; }
var s = i.toString(f.base);
if (f.prec >= 0) {
f.filler = ' ';
var n = f.prec - s.length;
if (n > 0) s = caml_str_repeat (n, '0') + s;
}
return caml_finish_formatting(f, s);
}
//Provides: caml_parse_sign_and_base
//Requires: caml_string_unsafe_get, caml_ml_string_length
function caml_parse_sign_and_base (s) {
var i = 0, len = caml_ml_string_length(s), base = 10, sign = 1;
if (len > 0) {
switch (caml_string_unsafe_get(s,i)) {
case 45: i++; sign = -1; break;
case 43: i++; sign = 1; break;
}
}
if (i + 1 < len && caml_string_unsafe_get(s, i) == 48)
switch (caml_string_unsafe_get(s, i + 1)) {
case 120: case 88: base = 16; i += 2; break;
case 111: case 79: base = 8; i += 2; break;
case 98: case 66: base = 2; i += 2; break;
case 117: case 85: i += 2; break;
}
return [i, sign, base];
}
//Provides: caml_parse_digit
function caml_parse_digit(c) {
if (c >= 48 && c <= 57) return c - 48;
if (c >= 65 && c <= 90) return c - 55;
if (c >= 97 && c <= 122) return c - 87;
return -1;
}
//Provides: caml_int_of_string (const)
//Requires: caml_ml_string_length, caml_string_unsafe_get
//Requires: caml_parse_sign_and_base, caml_parse_digit, caml_failwith
function caml_int_of_string (s) {
var r = caml_parse_sign_and_base (s);
var i = r[0], sign = r[1], base = r[2];
var len = caml_ml_string_length(s);
var threshold = -1 >>> 0;
var c = (i < len)?caml_string_unsafe_get(s, i):0;
var d = caml_parse_digit(c);
if (d < 0 || d >= base) caml_failwith("int_of_string");
var res = d;
for (i++;i<len;i++) {
c = caml_string_unsafe_get(s, i);
if (c == 95) continue;
d = caml_parse_digit(c);
if (d < 0 || d >= base) break;
res = base * res + d;
if (res > threshold) caml_failwith("int_of_string");
}
if (i != len) caml_failwith("int_of_string");
// For base different from 10, we expect an unsigned representation,
// hence any value of 'res' (less than 'threshold') is acceptable.
// But we have to convert the result back to a signed integer.
res = sign * res;
if ((base == 10) && ((res | 0) != res))
/* Signed representation expected, allow -2^(nbits-1) to 2^(nbits-1) - 1 */
caml_failwith("int_of_string");
return res | 0;
}
//Provides: caml_mul const
function caml_mul(a,b){
return Math.imul(a,b);
}
//Provides: caml_div
//Requires: caml_raise_zero_divide
function caml_div(x,y) {
if (y == 0) caml_raise_zero_divide ();
return (x/y)|0;
}
//Provides: caml_mod
//Requires: caml_raise_zero_divide
function caml_mod(x,y) {
if (y == 0) caml_raise_zero_divide ();
return x%y;
}
//Provides: caml_bswap16
function caml_bswap16(x) {
return ((((x & 0x00FF) << 8) |
((x & 0xFF00) >> 8)));
}
//Provides: caml_int32_bswap
function caml_int32_bswap(x) {
return (((x & 0x000000FF) << 24) |
((x & 0x0000FF00) << 8) |
((x & 0x00FF0000) >>> 8) |
((x & 0xFF000000) >>> 24));
}
//Provides: caml_int64_bswap
//Requires: caml_int64_to_bytes, caml_int64_of_bytes
function caml_int64_bswap(x) {
var y = caml_int64_to_bytes(x);
return caml_int64_of_bytes([y[7], y[6], y[5], y[4], y[3], y[2], y[1], y[0]]);
}
|
