porffor 0.2.0-dfa0583 → 0.2.0-e04e26f

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 (51) hide show
  1. package/LICENSE +20 -20
  2. package/README.md +123 -84
  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 +317 -72
  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 +151 -0
  12. package/compiler/builtins/crypto.ts +120 -0
  13. package/compiler/builtins/date.ts +1128 -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 +42 -0
  18. package/compiler/builtins/string.ts +1055 -0
  19. package/compiler/builtins/tostring.ts +45 -0
  20. package/compiler/builtins.js +468 -264
  21. package/compiler/{codeGen.js → codegen.js} +899 -347
  22. package/compiler/embedding.js +22 -22
  23. package/compiler/encoding.js +108 -10
  24. package/compiler/generated_builtins.js +1136 -0
  25. package/compiler/index.js +36 -34
  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 -46
  35. package/package.json +9 -5
  36. package/porf +4 -0
  37. package/rhemyn/compile.js +5 -3
  38. package/rhemyn/parse.js +323 -320
  39. package/rhemyn/test/parse.js +58 -58
  40. package/runner/compare.js +34 -34
  41. package/runner/debug.js +122 -0
  42. package/runner/index.js +49 -10
  43. package/runner/profiler.js +102 -0
  44. package/runner/repl.js +40 -7
  45. package/runner/sizes.js +37 -37
  46. package/compiler/builtins/base64.js +0 -92
  47. package/runner/info.js +0 -89
  48. package/runner/profile.js +0 -46
  49. package/runner/results.json +0 -1
  50. package/runner/transform.js +0 -15
  51. package/util/enum.js +0 -20
package/LICENSE CHANGED
@@ -1,21 +1,21 @@
1
- MIT License
2
-
3
- Copyright (c) 2023 CanadaHonk
4
-
5
- Permission is hereby granted, free of charge, to any person obtaining a copy
6
- of this software and associated documentation files (the "Software"), to deal
7
- in the Software without restriction, including without limitation the rights
8
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
- copies of the Software, and to permit persons to whom the Software is
10
- furnished to do so, subject to the following conditions:
11
-
12
- The above copyright notice and this permission notice shall be included in all
13
- copies or substantial portions of the Software.
14
-
15
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
1
+ MIT License
2
+
3
+ Copyright (c) 2023 CanadaHonk
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
21
  SOFTWARE.
package/README.md CHANGED
@@ -10,6 +10,65 @@ Porffor is a very unique JS engine, due many wildly different approaches. It is
10
10
 
11
11
  Porffor is primarily built from scratch, the only thing that is not is the parser (using [Acorn](https://github.com/acornjs/acorn)). Binaryen/etc is not used, we make final wasm binaries ourself. You could imagine it as compiling a language which is a sub (some things unsupported) and super (new/custom apis) set of javascript. Not based on any particular spec version, focusing on function/working over spec compliance.
12
12
 
13
+ ## Usage
14
+ Expect nothing to work! Only very limited JS is currently supported. See files in `bench` for examples.
15
+
16
+ ### Setup
17
+ 1. Clone this repo (`git clone https://github.com/CanadaHonk/porffor.git`)
18
+ 2. `npm install` - for parser(s)
19
+
20
+ ### Running a file
21
+ The repos comes with easy alias files for Unix and Windows, which you can use like so:
22
+ - Unix: `./porf path/to/script.js`
23
+ - Windows: `.\porf path/to/script.js`
24
+
25
+ Please note that further examples below will just use `./porf`, you need to use `.\porf` on Windows. You can also swap out `node` in the alias to use another runtime like Deno (`deno run -A`) or Bun (`bun ...`), or just use it yourself (eg `node runner/index.js ...`, `bun runner/index.js ...`). Node and Bun should work great, Deno support is WIP.
26
+
27
+ ### Trying a REPL
28
+ **`./porf`**. Just run it with no script file argument.
29
+
30
+ ### Compiling to native binaries
31
+ > [!WARNING]
32
+ > Compiling to native binaries uses [2c](#2c), Porffor's own Wasm -> C compiler, which is experimental.
33
+
34
+ **`./porf native path/to/script.js out(.exe)`**. You can specify the compiler with `-compiler=clang/zig/gcc`, and which opt level to use with `-cO=O3` (`Ofast` by default). Output binaries are also stripped by default.
35
+
36
+ ### Compiling to C
37
+ > [!WARNING]
38
+ > Compiling to C uses [2c](#2c), Porffor's own Wasm -> C compiler, which is experimental.
39
+
40
+ **`./porf c path/to/script.js (out.c)`**. When not including an output file, it will be printed to stdout instead.
41
+
42
+ ### Compiling to a Wasm binary
43
+ **`./porf compile path/to/script.js out.wasm`**. Currently it does not use an import standard like WASI, so it is mostly unusable.
44
+
45
+ ### Options
46
+ - `-target=wasm|c|native` (default: `wasm`) to set target output (native compiles c output to binary, see args below)
47
+ - `-target=c|native` only:
48
+ - `-o=out.c|out.exe|out` to set file to output c or binary
49
+ - `-target=native` only:
50
+ - `-compiler=clang` to set compiler binary (path/name) to use to compile
51
+ - `-cO=O3` to set compiler opt argument
52
+ - `-parser=acorn|@babel/parser|meriyah|hermes-parser` (default: `acorn`) to set which parser to use
53
+ - `-parse-types` to enable parsing type annotations/typescript. if `-parser` is unset, changes default to `@babel/parser`. does not type check
54
+ - `-opt-types` to perform optimizations using type annotations as compiler hints. does not type check
55
+ - `-valtype=i32|i64|f64` (default: `f64`) to set valtype
56
+ - `-O0` to disable opt
57
+ - `-O1` (default) to enable basic opt (simplify insts, treeshake wasm imports)
58
+ - `-O2` to enable advanced opt (inlining). unstable
59
+ - `-O3` to enable advanceder opt (precompute const math). unstable
60
+ - `-no-run` to not run wasm output, just compile
61
+ - `-opt-log` to log some opts
62
+ - `-code-log` to log some codegen (you probably want `-funcs`)
63
+ - `-regex-log` to log some regex
64
+ - `-funcs` to log funcs
65
+ - `-ast-log` to log AST
66
+ - `-opt-funcs` to log funcs after opt
67
+ - `-sections` to log sections as hex
68
+ - `-opt-no-inline` to not inline any funcs
69
+ - `-tail-call` to enable tail calls (experimental + not widely implemented)
70
+ - `-compile-hints` to enable V8 compilation hints (experimental + doesn't seem to do much?)
71
+
13
72
  ## Limitations
14
73
  - No full object support yet
15
74
  - Little built-ins/prototype
@@ -18,10 +77,15 @@ Porffor is primarily built from scratch, the only thing that is not is the parse
18
77
  - Literal callees only in calls (eg `print()` works, `a = print; a()` does not)
19
78
  - No `eval()` etc (since it is AOT)
20
79
 
21
- ## Rhemyn
80
+ ## Sub-engines
81
+
82
+ ### Asur
83
+ Asur is Porffor's own Wasm engine; it is an intentionally simple interpreter written in JS. It is very WIP. See [its readme](asur/README.md) for more details.
84
+
85
+ ### Rhemyn
22
86
  Rhemyn is Porffor's own regex engine; it compiles literal regex to Wasm bytecode AOT (remind you of anything?). It is quite basic and WIP. See [its readme](rhemyn/README.md) for more details.
23
87
 
24
- ## 2c
88
+ ### 2c
25
89
  2c is Porffor's own Wasm -> C compiler, using generated Wasm bytecode and internal info to generate specific and efficient/fast C code. Little boilerplate/preluded code or required external files, just for CLI binaries (not like wasm2c very much).
26
90
 
27
91
  ## Supported
@@ -86,20 +150,25 @@ These include some early (stage 1/0) and/or dead (last commit years ago) proposa
86
150
  - `for...of` (arrays and strings)
87
151
  - Array member setting (`arr[0] = 2`, `arr[0] += 2`, etc)
88
152
  - Array constructor (`Array(5)`, `new Array(1, 2, 3)`)
153
+ - Labelled statements (`foo: while (...)`)
154
+ - `do...while`
89
155
 
90
156
  ### Built-ins
91
157
 
92
158
  - `NaN` and `Infinity` (f64 only)
93
159
  - `isNaN()` and `isFinite()` (f64 only)
94
160
  - Most of `Number` (`MAX_VALUE`, `MIN_VALUE`, `MAX_SAFE_INTEGER`, `MIN_SAFE_INTEGER`, `POSITIVE_INFINITY`, `NEGATIVE_INFINITY`, `EPSILON`, `NaN`, `isNaN`, `isFinite`, `isInteger`, `isSafeInteger`) (some f64 only)
95
- - Some `Math` funcs (`Math.sqrt`, `Math.abs`, `Math.floor`, `Math.sign`, `Math.round`, `Math.trunc`, `Math.clz32`, `Math.fround`, `Math.random`) (f64 only)
161
+ - Some `Math` funcs (`sqrt`, `abs`, `floor`, `sign`, `round`, `trunc`, `clz32`, `fround`, `random`) (f64 only)
96
162
  - Basic `globalThis` support
97
163
  - Basic `Boolean` and `Number`
98
164
  - Basic `eval` for literals
99
165
  - `Math.random()` using self-made xorshift128+ PRNG
100
- - Some of `performance` (`now()`)
166
+ - Some of `performance` (`now()`, `timeOrigin`)
101
167
  - Some of `Array.prototype` (`at`, `push`, `pop`, `shift`, `fill`)
168
+ - Some of `Array` (`of`, `isArray`)
102
169
  - Some of `String.prototype` (`at`, `charAt`, `charCodeAt`)
170
+ - Some of `crypto` (`randomUUID`)
171
+ - `escape`
103
172
 
104
173
  ### Custom
105
174
 
@@ -108,48 +177,8 @@ These include some early (stage 1/0) and/or dead (last commit years ago) proposa
108
177
  - Intrinsic functions (see below)
109
178
  - Inlining wasm via ``asm`...``\` "macro"
110
179
 
111
- ## Todo
112
- No particular order and no guarentees, just what could happen soon™
113
-
114
- - Arrays
115
- - More of `Array` prototype
116
- - Arrays/strings inside arrays
117
- - Destructuring
118
- - Objects
119
- - Basic object expressions (eg `{}`, `{ a: 0 }`)
120
- - Wasm
121
- - *Basic* Wasm engine (interpreter) in JS
122
- - More math operators (`**`, etc)
123
- - `do { ... } while (...)`
124
- - Typed export inputs (array)
125
- - Exceptions
126
- - Rewrite to use actual strings (optional?)
127
- - `try { } finally { }`
128
- - Rethrowing inside catch
129
- - Optimizations
130
- - Rewrite local indexes per func for smallest local header and remove unused idxs
131
- - Smarter inline selection (snapshots?)
132
- - Remove const ifs (`if (true)`, etc)
133
- - Memory alignment
134
- - Runtime
135
- - WASI target
136
- - Run precompiled Wasm file if given
137
- - Cool proposals
138
- - [Optional Chaining Assignment](https://github.com/tc39/proposal-optional-chaining-assignment)
139
- - [Modulus and Additional Integer Math](https://github.com/tc39/proposal-integer-and-modulus-math)
140
- - [Array Equality](https://github.com/tc39/proposal-array-equality)
141
- - [Declarations in Conditionals](https://github.com/tc39/proposal-Declarations-in-Conditionals)
142
- - [Seeded Pseudo-Random Numbers](https://github.com/tc39/proposal-seeded-random)
143
- - [`do` expressions](https://github.com/tc39/proposal-do-expressions)
144
- - [String Trim Characters](https://github.com/Kingwl/proposal-string-trim-characters)
145
- - Posts
146
- - Inlining investigation
147
- - Self hosted testing?
148
-
149
180
  ## Performance
150
- *For the things it supports most of the time*, Porffor is *blazingly fast* compared to most interpreters, and common engines running without JIT. For those with JIT, it is usually slower by default, but can catch up with compiler arguments and typed input.
151
-
152
- ![Screenshot of comparison chart](https://github.com/CanadaHonk/porffor/assets/19228318/76c75264-cc68-4be1-8891-c06dc389d97a)
181
+ *For the features it supports most of the time*, Porffor is *blazingly fast* compared to most interpreters and common engines running without JIT. For those with JIT, it is usually slower by default, but can catch up with compiler arguments and typed input, even more so when compiling to native binaries.
153
182
 
154
183
  ## Optimizations
155
184
  Mostly for reducing size. I do not really care about compiler perf/time as long as it is reasonable. We do not use/rely on external opt tools (`wasm-opt`, etc), instead doing optimization inside the compiler itself creating even smaller code sizes than `wasm-opt` itself can produce as we have more internal information.
@@ -184,7 +213,7 @@ Porffor can run Test262 via some hacks/transforms which remove unsupported featu
184
213
  ## Codebase
185
214
  - `compiler`: contains the compiler itself
186
215
  - `builtins.js`: all built-ins of the engine (spec, custom. vars, funcs)
187
- - `codeGen.js`: code (wasm) generation, ast -> wasm. The bulk of the effort
216
+ - `codegen.js`: code (wasm) generation, ast -> wasm. The bulk of the effort
188
217
  - `decompile.js`: basic wasm decompiler for debug info
189
218
  - `embedding.js`: utils for embedding consts
190
219
  - `encoding.js`: utils for encoding things as bytes as wasm expects
@@ -192,7 +221,7 @@ Porffor can run Test262 via some hacks/transforms which remove unsupported featu
192
221
  - `index.js`: doing all the compiler steps, takes code in, wasm out
193
222
  - `opt.js`: self-made wasm bytecode optimizer
194
223
  - `parse.js`: parser simply wrapping acorn
195
- - `sections.js`: assembles wasm ops and metadata into a wasm module/file
224
+ - `assemble.js`: assembles wasm ops and metadata into a wasm module/file
196
225
  - `wasmSpec.js`: "enums"/info from wasm spec
197
226
  - `wrap.js`: wrapper for compiler which instantiates and produces nice exports
198
227
 
@@ -211,48 +240,58 @@ Porffor can run Test262 via some hacks/transforms which remove unsupported featu
211
240
  ## Usecases
212
241
  Basically none right now (other than giving people headaches). Potential ideas:
213
242
  - Safety. As Porffor is written in JS, a memory-safe language\*, and compiles JS to Wasm, a fully sandboxed environment\*, it is quite safe. (\* These rely on the underlying implementations being secure. You could also run Wasm, or even Porffor itself, with an interpreter instead of a JIT for bonus security points too.)
214
- - Compiling JS to native binaries. This is still very early, [`2c`](#2c) is not that good yet :(
243
+ - Compiling JS to native binaries. This is still very early!
215
244
  - More in future probably?
216
245
 
217
- ## Usage
218
- Basically nothing will work :). See files in `test` and `bench` for examples.
219
-
220
- 1. Clone repo
221
- 2. `npm install`
222
- 3. `node test` to run tests (some will fail)
223
- 4. `node runner path/to/code.js` to run a file (or `node runner` to use wip repl)
224
-
225
- You can also use Deno (`deno run -A ...` instead of `node ...`), or Bun (`bun ...` instead of `node ...`).
246
+ ## Todo
247
+ No particular order and no guarentees, just what could happen soon™
226
248
 
227
- ### Options
228
- - `-target=wasm|c|native` (default: `wasm`) to set target output (native compiles c output to binary, see args below)
229
- - `-target=c|native` only:
230
- - `-o=out.c|out.exe|out` to set file to output c or binary
231
- - `-target=native` only:
232
- - `-compiler=clang` to set compiler binary (path/name) to use to compile
233
- - `-cO=O3` to set compiler opt argument
234
- - `-parser=acorn|@babel/parser|meriyah|hermes-parser` (default: `acorn`) to set which parser to use
235
- - `-parse-types` to enable parsing type annotations/typescript. if `-parser` is unset, changes default to `@babel/parser`. does not type check
236
- - `-opt-types` to perform optimizations using type annotations as compiler hints. does not type check
237
- - `-valtype=i32|i64|f64` (default: `f64`) to set valtype
238
- - `-O0` to disable opt
239
- - `-O1` (default) to enable basic opt (simplify insts, treeshake wasm imports)
240
- - `-O2` to enable advanced opt (inlining). unstable
241
- - `-O3` to enable advanceder opt (precompute const math). unstable
242
- - `-no-run` to not run wasm output, just compile
243
- - `-opt-log` to log some opts
244
- - `-code-log` to log some codegen (you probably want `-funcs`)
245
- - `-regex-log` to log some regex
246
- - `-funcs` to log funcs
247
- - `-ast-log` to log AST
248
- - `-opt-funcs` to log funcs after opt
249
- - `-sections` to log sections as hex
250
- - `-opt-no-inline` to not inline any funcs
251
- - `-tail-call` to enable tail calls (experimental + not widely implemented)
252
- - `-compile-hints` to enable V8 compilation hints (experimental + doesn't seem to do much?)
249
+ - Arrays
250
+ - More of `Array` prototype
251
+ - Arrays/strings inside arrays
252
+ - Destructuring
253
+ - Objects
254
+ - Basic object expressions (eg `{}`, `{ a: 0 }`)
255
+ - Asur
256
+ - Support memory
257
+ - Support exceptions
258
+ - More math operators (`**`, etc)
259
+ - Typed export inputs (array)
260
+ - Exceptions
261
+ - Rewrite to use actual strings (optional?)
262
+ - `try { } finally { }`
263
+ - Rethrowing inside catch
264
+ - Optimizations
265
+ - Rewrite local indexes per func for smallest local header and remove unused idxs
266
+ - Smarter inline selection (snapshots?)
267
+ - Remove const ifs (`if (true)`, etc)
268
+ - Memory alignment
269
+ - Add general pref for always using "fast" (non-short circuiting) or/and
270
+ - Runtime
271
+ - WASI target
272
+ - Run precompiled Wasm file if given
273
+ - Docs
274
+ - Update codebase readme section
275
+ - REPL
276
+ - Basic polyfill of `node:repl` for non-Node runtimes to work
277
+ - Cool proposals
278
+ - [Optional Chaining Assignment](https://github.com/tc39/proposal-optional-chaining-assignment)
279
+ - [Modulus and Additional Integer Math](https://github.com/tc39/proposal-integer-and-modulus-math)
280
+ - [Array Equality](https://github.com/tc39/proposal-array-equality)
281
+ - [Declarations in Conditionals](https://github.com/tc39/proposal-Declarations-in-Conditionals)
282
+ - [Seeded Pseudo-Random Numbers](https://github.com/tc39/proposal-seeded-random)
283
+ - [`do` expressions](https://github.com/tc39/proposal-do-expressions)
284
+ - [String Trim Characters](https://github.com/Kingwl/proposal-string-trim-characters)
285
+ - Posts
286
+ - Inlining investigation
287
+ - JS -> Native
288
+ - Precompiled TS built-ins
289
+ - Asur
290
+ - `escape()` optimization
291
+ - Self hosted testing?
253
292
 
254
293
  ## VSCode extension
255
- There is a vscode extension in `porffor-for-vscode` which tweaks JS syntax highlighting to be nicer with porffor features (eg highlighting wasm inside of inline asm).
294
+ There is a vscode extension in `vscode-ext` which tweaks JS syntax highlighting to be nicer with porffor features (eg highlighting wasm inside of inline asm).
256
295
 
257
296
  ## Isn't this the same as AssemblyScript/other Wasm langs?
258
297
  No. they are not alike at all internally and have very different goals/ideals:
package/asur/README.md ADDED
@@ -0,0 +1,2 @@
1
+ # asur
2
+ a basic experimental wip wasm engine/interpreter in js. wasm engine for porffor. not serious/intended for (real) use