porffor 0.2.0-cb647c8 → 0.2.0-de394c3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (55) hide show
  1. package/LICENSE +20 -20
  2. package/README.md +114 -63
  3. package/asur/README.md +2 -0
  4. package/asur/index.js +1262 -0
  5. package/byg/index.js +237 -0
  6. package/compiler/2c.js +1 -1
  7. package/compiler/{sections.js → assemble.js} +63 -15
  8. package/compiler/builtins/annexb_string.js +72 -0
  9. package/compiler/builtins/annexb_string.ts +19 -0
  10. package/compiler/builtins/array.ts +145 -0
  11. package/compiler/builtins/base64.ts +105 -22
  12. package/compiler/builtins/crypto.ts +120 -0
  13. package/compiler/builtins/date.ts +1370 -0
  14. package/compiler/builtins/escape.ts +141 -0
  15. package/compiler/builtins/int.ts +147 -0
  16. package/compiler/builtins/number.ts +527 -0
  17. package/compiler/builtins/porffor.d.ts +41 -1
  18. package/compiler/builtins/string.ts +1055 -0
  19. package/compiler/builtins/tostring.ts +45 -0
  20. package/compiler/builtins.js +455 -243
  21. package/compiler/{codeGen.js → codegen.js} +912 -337
  22. package/compiler/embedding.js +22 -22
  23. package/compiler/encoding.js +108 -10
  24. package/compiler/generated_builtins.js +1262 -0
  25. package/compiler/index.js +25 -29
  26. package/compiler/log.js +6 -3
  27. package/compiler/opt.js +50 -36
  28. package/compiler/parse.js +35 -27
  29. package/compiler/precompile.js +123 -0
  30. package/compiler/prefs.js +26 -0
  31. package/compiler/prototype.js +13 -28
  32. package/compiler/types.js +37 -0
  33. package/compiler/wasmSpec.js +28 -8
  34. package/compiler/wrap.js +51 -47
  35. package/fib.js +7 -0
  36. package/package.json +9 -5
  37. package/porf +2 -0
  38. package/rhemyn/compile.js +5 -3
  39. package/rhemyn/parse.js +323 -320
  40. package/rhemyn/test/parse.js +58 -58
  41. package/runner/compare.js +34 -34
  42. package/runner/debug.js +122 -0
  43. package/runner/index.js +48 -9
  44. package/runner/profiler.js +102 -0
  45. package/runner/repl.js +40 -7
  46. package/runner/sizes.js +37 -37
  47. package/demo.js +0 -3
  48. package/demo.ts +0 -1
  49. package/filesize.cmd +0 -2
  50. package/runner/info.js +0 -89
  51. package/runner/profile.js +0 -46
  52. package/runner/results.json +0 -1
  53. package/runner/transform.js +0 -15
  54. package/tmp.c +0 -1248
  55. package/util/enum.js +0 -20
@@ -1,36 +1,116 @@
1
- // @porf -funsafe-no-unlikely-proto-checks
1
+ // @porf -funsafe-no-unlikely-proto-checks -valtype=i32
2
2
 
3
- import type { i32, bytestring } from './porffor.d.ts';
3
+ // while (len >= 8) {
4
+ // Porffor.wasm`
5
+ // local tmp i64
6
+ // local.get ${i}
7
+ // i64.load 0 4
8
+ // local.set tmp
4
9
 
5
- const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
10
+ // local k i64
11
+ // i64.const 0
12
+ // local.set k
6
13
 
7
- const btoa = (input: bytestring): bytestring => {
8
- // todo: throw invalid character for unicode
14
+ // loop 64
15
+ // local.get ${j}
9
16
 
10
- let output: bytestring = "";
11
- let i: i32 = 0;
17
+ // local.get ${keyStrPtr}
12
18
 
13
- while (i < input.length) {
14
- const chr1: i32 = input.charCodeAt(i++);
15
- const chr2: i32 = input.charCodeAt(i++);
16
- const chr3: i32 = input.charCodeAt(i++);
19
+ // local.get tmp
20
+
21
+ // ;; k * 6
22
+ // i64.const 58
23
+
24
+ // local.get k
25
+ // i64.const 6
26
+ // i64.mul
27
+
28
+ // i64.sub
29
+
30
+ // ;; tmp >> (58 - (k * 6))
31
+ // i64.shr_u
32
+
33
+ // ;; (tmp >> (58 - (k * 6))) & 0x3f
34
+ // i64.const 63
35
+ // i64.and
36
+
37
+ // i32.wrap_i64
38
+
39
+ // ;; keyStrPtr + ...
40
+ // i32.add
41
+
42
+ // ;; load character from keyStr
43
+ // i32.load8_u 0 4
44
+
45
+ // ;; store in output at j
46
+ // i32.store8 0 4
47
+
48
+ // local.get ${j}
49
+ // i32.const 1
50
+ // i32.add
51
+ // local.set ${j}
52
+
53
+ // local.get k
54
+ // i64.const 1
55
+ // i64.add
56
+ // local.tee k
57
+
58
+ // i64.const 8
59
+ // i64.lt_s
60
+ // br_if 0
61
+ // end
62
+
63
+ // `;
64
+
65
+ // // len -= 6;
66
+ // i += 6;
67
+ // }
68
+
69
+ // // while (k < 8) {
70
+ // // Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + Porffor.wasm.i32.wrap_i64(Porffor.wasm.i64.and(
71
+ // // Porffor.wasm.i64.shr_u(tmp, Porffor.wasm.i64.extend_i32_u(58 - k * 6)),
72
+ // // Porffor.wasm.i64.const(0x3f)
73
+ // // )), 0, 4), 0, 4);
74
+ // // k += 1;
75
+ // // }
76
+
77
+ // i += 6;
78
+ // len -= 6;
79
+ // }
80
+
81
+ export const btoa = (input: bytestring): bytestring => {
82
+ const keyStr: bytestring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
83
+ const keyStrPtr: i32 = Porffor.wasm`local.get ${keyStr}`;
84
+
85
+ let len: i32 = input.length;
86
+ let output: bytestring = '';
87
+ output.length = 4 * (len / 3 + !!(len % 3));
88
+
89
+ let i: i32 = Porffor.wasm`local.get ${input}`,
90
+ j: i32 = Porffor.wasm`local.get ${output}`;
91
+
92
+ const endPtr = i + len;
93
+ while (i < endPtr) {
94
+ const chr1: i32 = Porffor.wasm.i32.load8_u(i++, 0, 4);
95
+ const chr2: i32 = i < endPtr ? Porffor.wasm.i32.load8_u(i++, 0, 4) : -1;
96
+ const chr3: i32 = i < endPtr ? Porffor.wasm.i32.load8_u(i++, 0, 4) : -1;
17
97
 
18
98
  const enc1: i32 = chr1 >> 2;
19
- const enc2: i32 = ((chr1 & 3) << 4) | (chr2 >> 4);
20
- let enc3: i32 = ((chr2 & 15) << 2) | (chr3 >> 6);
99
+ const enc2: i32 = ((chr1 & 3) << 4) | (chr2 == -1 ? 0 : (chr2 >> 4));
100
+ let enc3: i32 = ((chr2 & 15) << 2) | (chr3 == -1 ? 0 : (chr3 >> 6));
21
101
  let enc4: i32 = chr3 & 63;
22
102
 
23
- if (isNaN(chr2)) {
103
+ if (chr2 == -1) {
24
104
  enc3 = 64;
25
105
  enc4 = 64;
26
- } else if (isNaN(chr3)) {
106
+ } else if (chr3 == -1) {
27
107
  enc4 = 64;
28
108
  }
29
109
 
30
- output += keyStr.charAt(enc1);
31
- output += keyStr.charAt(enc2);
32
- output += keyStr.charAt(enc3);
33
- output += keyStr.charAt(enc4);
110
+ Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc1, 0, 4), 0, 4);
111
+ Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc2, 0, 4), 0, 4);
112
+ Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc3, 0, 4), 0, 4);
113
+ Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc4, 0, 4), 0, 4);
34
114
  }
35
115
 
36
116
  return output;
@@ -54,13 +134,16 @@ const btoa = (input: bytestring): bytestring => {
54
134
  chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
55
135
  chr3 = ((enc3 & 3) << 6) | enc4;
56
136
 
57
- output += String.fromCharCode(chr1);
137
+ // output += String.fromCharCode(chr1);
138
+ Porffor.bytestring.appendCharCode(output, chr1);
58
139
 
59
140
  if (enc3 != 64) {
60
- output += String.fromCharCode(chr2);
141
+ // output += String.fromCharCode(chr2);
142
+ Porffor.bytestring.appendCharCode(output, chr2);
61
143
  }
62
144
  if (enc4 != 64) {
63
- output += String.fromCharCode(chr3);
145
+ // output += String.fromCharCode(chr3);
146
+ Porffor.bytestring.appendCharCode(output, chr3);
64
147
  }
65
148
  }
66
149
 
@@ -0,0 +1,120 @@
1
+ // @porf -funsafe-no-unlikely-proto-checks -valtype=i32
2
+
3
+ export const __crypto_randomUUID = (): bytestring => {
4
+ let bytes: bytestring = '................';
5
+
6
+ const bytesPtr: i32 = Porffor.wasm`local.get ${bytes}`;
7
+
8
+ let a: i32 = bytesPtr;
9
+ let aEndPtr: i32 = a + 16;
10
+ while (a < aEndPtr) {
11
+ Porffor.wasm.i32.store8(a++, Porffor.randomByte(), 0, 4);
12
+ }
13
+
14
+ // bytes[6] = (bytes[6] & 0b00001111) | 0b01000000
15
+ Porffor.wasm.i32.store8(
16
+ bytesPtr,
17
+ (Porffor.wasm.i32.load8_u(bytesPtr, 0, 10) & 0b00001111) | 0b01000000,
18
+ 0,
19
+ 10 // 4 + 6
20
+ );
21
+
22
+ // bytes[8] = (bytes[8] & 0b00111111) | 0b10000000
23
+ Porffor.wasm.i32.store8(
24
+ bytesPtr,
25
+ (Porffor.wasm.i32.load8_u(bytesPtr, 0, 12) & 0b00111111) | 0b10000000,
26
+ 0,
27
+ 12 // 4 + 8
28
+ );
29
+
30
+ let output: bytestring = '------------------------------------';
31
+
32
+ let i: i32 = Porffor.wasm`local.get ${output}`;
33
+ let j: i32 = bytesPtr;
34
+
35
+ // bytes[0..4]-bytes[4..6]-bytes[6..8]-bytes[8..10]-bytes[10..15]
36
+ // 00112233-4455-6677-8899-aabbccddeeff
37
+
38
+ // bytes[0..4]-
39
+ let endPtr: i32 = i + 8;
40
+ while (i < endPtr) {
41
+ const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
42
+
43
+ let lower: i32 = (byte & 0x0f) + 48;
44
+ if (lower > 57) lower += 39;
45
+
46
+ let upper: i32 = (byte >> 4) + 48;
47
+ if (upper > 57) upper += 39;
48
+
49
+ Porffor.wasm.i32.store8(i++, upper, 0, 4);
50
+ Porffor.wasm.i32.store8(i++, lower, 0, 4);
51
+ }
52
+ i++;
53
+
54
+ // bytes[4..6]-
55
+ endPtr = i + 4;
56
+ while (i < endPtr) {
57
+ const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
58
+
59
+ let lower: i32 = (byte & 0x0f) + 48;
60
+ if (lower > 57) lower += 39;
61
+
62
+ let upper: i32 = (byte >> 4) + 48;
63
+ if (upper > 57) upper += 39;
64
+
65
+ Porffor.wasm.i32.store8(i++, upper, 0, 4);
66
+ Porffor.wasm.i32.store8(i++, lower, 0, 4);
67
+ }
68
+ i++;
69
+
70
+ // bytes[6..8]-
71
+ endPtr = i + 4;
72
+ while (i < endPtr) {
73
+ const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
74
+
75
+ let lower: i32 = (byte & 0x0f) + 48;
76
+ if (lower > 57) lower += 39;
77
+
78
+ let upper: i32 = (byte >> 4) + 48;
79
+ if (upper > 57) upper += 39;
80
+
81
+ Porffor.wasm.i32.store8(i++, upper, 0, 4);
82
+ Porffor.wasm.i32.store8(i++, lower, 0, 4);
83
+ }
84
+ i++;
85
+
86
+ // bytes[8..10]-
87
+ endPtr = i + 4;
88
+ while (i < endPtr) {
89
+ const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
90
+
91
+ let lower: i32 = (byte & 0x0f) + 48;
92
+ if (lower > 57) lower += 39;
93
+
94
+ let upper: i32 = (byte >> 4) + 48;
95
+ if (upper > 57) upper += 39;
96
+
97
+ Porffor.wasm.i32.store8(i++, upper, 0, 4);
98
+ Porffor.wasm.i32.store8(i++, lower, 0, 4);
99
+ }
100
+ i++;
101
+
102
+ // bytes[10..15]
103
+ endPtr = i + 12;
104
+ while (i < endPtr) {
105
+ const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
106
+
107
+ let lower: i32 = (byte & 0x0f) + 48;
108
+ if (lower > 57) lower += 39;
109
+
110
+ let upper: i32 = (byte >> 4) + 48;
111
+ if (upper > 57) upper += 39;
112
+
113
+ Porffor.wasm.i32.store8(i++, upper, 0, 4);
114
+ Porffor.wasm.i32.store8(i++, lower, 0, 4);
115
+ }
116
+ i++;
117
+
118
+
119
+ return output;
120
+ };