2023-02-21 09:42:41 +11:00
|
|
|
# This file is automatically @generated by Cargo.
|
|
|
|
|
# It is not intended for manual editing.
|
|
|
|
|
version = 3
|
|
|
|
|
|
2023-08-19 23:18:54 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "Inflector"
|
|
|
|
|
version = "0.11.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"lazy_static",
|
|
|
|
|
"regex",
|
|
|
|
|
]
|
2023-08-19 23:18:54 -07:00
|
|
|
|
2023-08-18 19:37:52 +10:00
|
|
|
[[package]]
|
|
|
|
|
name = "addr2line"
|
2023-08-25 13:41:04 -07:00
|
|
|
version = "0.21.0"
|
2023-08-18 19:37:52 +10:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-08-25 13:41:04 -07:00
|
|
|
checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
|
2023-08-18 19:37:52 +10:00
|
|
|
dependencies = [
|
|
|
|
|
"gimli",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "adler"
|
|
|
|
|
version = "1.0.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "aead"
|
|
|
|
|
version = "0.5.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"crypto-common",
|
|
|
|
|
"generic-array",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "aes"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.8.4"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"cipher",
|
|
|
|
|
"cpufeatures",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "aes-gcm"
|
|
|
|
|
version = "0.10.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"aead",
|
|
|
|
|
"aes",
|
|
|
|
|
"cipher",
|
|
|
|
|
"ctr",
|
|
|
|
|
"ghash",
|
|
|
|
|
"subtle",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "ahash"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.8.11"
|
2023-08-28 14:58:24 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
|
2023-08-28 14:58:24 -07:00
|
|
|
dependencies = [
|
2023-08-30 21:05:35 -07:00
|
|
|
"cfg-if",
|
2023-08-28 14:58:24 -07:00
|
|
|
"getrandom",
|
|
|
|
|
"once_cell",
|
|
|
|
|
"version_check",
|
2023-10-24 11:24:59 -07:00
|
|
|
"zerocopy",
|
2023-08-28 14:58:24 -07:00
|
|
|
]
|
|
|
|
|
|
2023-02-21 09:42:41 +11:00
|
|
|
[[package]]
|
|
|
|
|
name = "aho-corasick"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.1.3"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
|
2023-02-21 09:42:41 +11:00
|
|
|
dependencies = [
|
|
|
|
|
"memchr",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "android-tzdata"
|
|
|
|
|
version = "0.1.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "android_system_properties"
|
|
|
|
|
version = "0.1.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"libc",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-20 13:15:28 -05:00
|
|
|
[[package]]
|
|
|
|
|
name = "anes"
|
|
|
|
|
version = "0.1.6"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
|
|
|
|
|
|
2023-09-05 16:02:27 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "anstream"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.6.13"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "d96bd03f33fe50a863e394ee9718a706f988b9079b20c3784fb726e7678b62fb"
|
2023-09-05 16:02:27 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"anstyle",
|
|
|
|
|
"anstyle-parse",
|
|
|
|
|
"anstyle-query",
|
|
|
|
|
"anstyle-wincon",
|
|
|
|
|
"colorchoice",
|
|
|
|
|
"utf8parse",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "anstyle"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.0.6"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "8901269c6307e8d93993578286ac0edf7f195079ffff5ebdeea6a59ffb7e36bc"
|
2023-09-05 16:02:27 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "anstyle-parse"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.2.3"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "c75ac65da39e5fe5ab759307499ddad880d724eed2f6ce5b5e8a26f4f387928c"
|
2023-09-05 16:02:27 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"utf8parse",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "anstyle-query"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.0.2"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "e28923312444cdd728e4738b3f9c9cac739500909bb3d3c94b43551b16517648"
|
2023-09-05 16:02:27 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"windows-sys 0.52.0",
|
2023-09-05 16:02:27 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "anstyle-wincon"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "3.0.2"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "1cd54b81ec8d6180e24654d0b371ad22fc3dd083b6ff8ba325b72e00c87660a7"
|
2023-09-05 16:02:27 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"anstyle",
|
2024-03-23 15:45:55 -07:00
|
|
|
"windows-sys 0.52.0",
|
2023-09-05 16:02:27 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-18 19:37:52 +10:00
|
|
|
[[package]]
|
|
|
|
|
name = "anyhow"
|
2024-03-14 16:49:30 +00:00
|
|
|
version = "1.0.81"
|
2023-08-18 19:37:52 +10:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-14 16:49:30 +00:00
|
|
|
checksum = "0952808a6c2afd1aa8947271f3a60f1a6763c7b912d210184c5149b5cf147247"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"backtrace",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "approx"
|
|
|
|
|
version = "0.1.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "08abcc3b4e9339e33a3d0a5ed15d84a687350c05689d825e0f6655eef9e76a94"
|
|
|
|
|
|
2024-02-11 12:59:00 +11:00
|
|
|
[[package]]
|
|
|
|
|
name = "approx"
|
|
|
|
|
version = "0.5.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
|
|
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"num-traits 0.2.18",
|
2024-02-11 12:59:00 +11:00
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "arc-swap"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.7.0"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "7b3d0060af21e8d11a926981cc00c6c1541aa91dd64b9f881985c3da1094425f"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "asn1-rs"
|
|
|
|
|
version = "0.5.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "7f6fd5ddaf0351dff5b8da21b2fb4ff8e08ddd02857f0bf69c47639106c0fff0"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"asn1-rs-derive",
|
|
|
|
|
"asn1-rs-impl",
|
|
|
|
|
"displaydoc",
|
|
|
|
|
"nom",
|
2024-03-23 15:45:55 -07:00
|
|
|
"num-traits 0.2.18",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"rusticata-macros",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"time",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "asn1-rs-derive"
|
|
|
|
|
version = "0.4.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "726535892e8eae7e70657b4c8ea93d26b8553afb1ce617caee529ef96d7dee6c"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"syn 1.0.109",
|
|
|
|
|
"synstructure 0.12.6",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "asn1-rs-impl"
|
|
|
|
|
version = "0.1.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "2777730b2039ac0f95f093556e61b6d26cebed5393ca6f152717777cec3a42ed"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"syn 1.0.109",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-05 16:02:27 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "async-codec-lite"
|
|
|
|
|
version = "0.0.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "2527c30e3972d8ff366b353125dae828c4252a154dbe6063684f6c5e014760a3"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"anyhow",
|
|
|
|
|
"bytes",
|
|
|
|
|
"futures-core",
|
|
|
|
|
"futures-io",
|
|
|
|
|
"futures-sink",
|
|
|
|
|
"log",
|
|
|
|
|
"pin-project-lite",
|
|
|
|
|
"thiserror",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-20 18:27:08 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "async-recursion"
|
2024-03-20 17:07:49 -07:00
|
|
|
version = "1.1.0"
|
2023-09-20 18:27:08 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-20 17:07:49 -07:00
|
|
|
checksum = "30c5ef0ede93efbf733c1a727f3b6b5a1060bbedd5600183e66f6e4be4af0ec5"
|
2023-09-20 18:27:08 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-09-20 18:27:08 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "async-trait"
|
2024-03-28 11:03:45 -07:00
|
|
|
version = "0.1.79"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-28 11:03:45 -07:00
|
|
|
checksum = "a507401cad91ec6a857ed5513a2073c82a9b9048762b885bb98655b306964681"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
2023-10-23 14:03:38 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "atomic"
|
|
|
|
|
version = "0.5.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "c59bdb34bc650a32731b31bd8f0829cc15d24a708ee31559e0bb34f2bc320cba"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "atomic-waker"
|
|
|
|
|
version = "1.1.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
|
|
|
|
|
|
2023-09-05 16:02:27 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "auto_impl"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.2.0"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "3c87f3f15e7794432337fc718554eaa4dc8f04c9677a950ffe366f20a162ae42"
|
2023-09-05 16:02:27 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-09-05 16:02:27 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "autocfg"
|
|
|
|
|
version = "1.1.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
|
|
|
|
|
|
2023-08-18 19:37:52 +10:00
|
|
|
[[package]]
|
|
|
|
|
name = "backtrace"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.3.70"
|
2023-08-18 19:37:52 +10:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "95d8e92cac0961e91dbd517496b00f7e9b92363dbe6d42c3198268323798860c"
|
2023-08-18 19:37:52 +10:00
|
|
|
dependencies = [
|
|
|
|
|
"addr2line",
|
|
|
|
|
"cc",
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"libc",
|
|
|
|
|
"miniz_oxide",
|
|
|
|
|
"object",
|
|
|
|
|
"rustc-demangle",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "base16ct"
|
|
|
|
|
version = "0.2.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
|
|
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "base64"
|
|
|
|
|
version = "0.13.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "base64"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.21.7"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
|
2023-08-18 08:12:32 -07:00
|
|
|
|
2024-03-26 21:28:50 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "base64"
|
|
|
|
|
version = "0.22.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "9475866fec1451be56a3c2400fd081ff546538961565ccb5b7142cbd22bc7a51"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "base64ct"
|
|
|
|
|
version = "1.6.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
|
|
|
|
|
|
2023-09-20 17:36:26 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "bigdecimal"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.4.3"
|
2023-09-20 17:36:26 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "9324c8014cd04590682b34f1e9448d38f0674d0f7b2dc553331016ef0e4e9ebc"
|
2023-09-20 17:36:26 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"autocfg",
|
|
|
|
|
"libm",
|
|
|
|
|
"num-bigint",
|
|
|
|
|
"num-integer",
|
2024-03-23 15:45:55 -07:00
|
|
|
"num-traits 0.2.18",
|
2023-09-20 17:36:26 -07:00
|
|
|
"serde",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-02 16:23:17 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "bincode"
|
|
|
|
|
version = "1.3.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"serde",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "bit_field"
|
|
|
|
|
version = "0.10.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "dc827186963e592360843fb5ba4b973e145841266c1357f7180c43526f2e5b61"
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "bitflags"
|
|
|
|
|
version = "1.3.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "bitflags"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "2.5.0"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "bitvec"
|
|
|
|
|
version = "1.0.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"funty",
|
|
|
|
|
"radium",
|
|
|
|
|
"tap",
|
|
|
|
|
"wyz",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "block-buffer"
|
|
|
|
|
version = "0.10.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"generic-array",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "block-padding"
|
|
|
|
|
version = "0.3.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"generic-array",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "bson"
|
2024-02-11 19:40:26 +00:00
|
|
|
version = "2.9.0"
|
2023-08-28 14:58:24 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 19:40:26 +00:00
|
|
|
checksum = "ce21468c1c9c154a85696bb25c20582511438edb6ad67f846ba1378ffdd80222"
|
2023-08-28 14:58:24 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"ahash",
|
|
|
|
|
"base64 0.13.1",
|
|
|
|
|
"bitvec",
|
|
|
|
|
"chrono",
|
|
|
|
|
"hex",
|
2024-03-23 15:45:55 -07:00
|
|
|
"indexmap 2.2.5",
|
2023-08-28 14:58:24 -07:00
|
|
|
"js-sys",
|
2023-08-30 21:05:35 -07:00
|
|
|
"once_cell",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"rand 0.8.5",
|
2023-08-28 14:58:24 -07:00
|
|
|
"serde",
|
|
|
|
|
"serde_bytes",
|
|
|
|
|
"serde_json",
|
2023-09-14 15:05:07 -06:00
|
|
|
"time",
|
2023-08-28 14:58:24 -07:00
|
|
|
"uuid",
|
|
|
|
|
]
|
|
|
|
|
|
2023-02-21 09:42:41 +11:00
|
|
|
[[package]]
|
|
|
|
|
name = "bumpalo"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "3.15.4"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "7ff69b9dd49fd426c69a0db9fc04dd934cdb6645ff000864d98f7e2af8830eaa"
|
2023-02-21 09:42:41 +11:00
|
|
|
|
2024-01-29 17:36:29 +11:00
|
|
|
[[package]]
|
|
|
|
|
name = "bytecount"
|
|
|
|
|
version = "0.6.7"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "e1e5f035d16fc623ae5f74981db80a439803888314e3a555fd6f04acd51a3205"
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "bytemuck"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.15.0"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "5d6d68c57235a3a081186990eca2867354726650f42f7516ca50c28d6281fd15"
|
2023-09-12 14:59:40 -07:00
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "byteorder"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "1.5.0"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
|
2023-08-24 15:34:51 -07:00
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "bytes"
|
2023-09-18 18:22:25 -06:00
|
|
|
version = "1.5.0"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-09-18 18:22:25 -06:00
|
|
|
checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"serde",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-20 13:15:28 -05:00
|
|
|
[[package]]
|
|
|
|
|
name = "cast"
|
|
|
|
|
version = "0.3.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "cbc"
|
|
|
|
|
version = "0.1.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"cipher",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 19:37:52 +10:00
|
|
|
[[package]]
|
|
|
|
|
name = "cc"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.0.90"
|
2023-08-18 19:37:52 +10:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "8cd6604a82acf3039f1144f54b8eb34e91ffba622051189e71b781822d5ee1f5"
|
2023-08-18 19:37:52 +10:00
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "ccm"
|
|
|
|
|
version = "0.5.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "9ae3c82e4355234767756212c570e29833699ab63e6ffd161887314cc5b43847"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"aead",
|
|
|
|
|
"cipher",
|
|
|
|
|
"ctr",
|
|
|
|
|
"subtle",
|
|
|
|
|
]
|
|
|
|
|
|
2023-02-21 09:42:41 +11:00
|
|
|
[[package]]
|
|
|
|
|
name = "cfg-if"
|
|
|
|
|
version = "1.0.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "cgmath"
|
|
|
|
|
version = "0.16.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "64a4b57c8f4e3a2e9ac07e0f6abc9c24b6fc9e1b54c3478cfb598f3d0023e51c"
|
|
|
|
|
dependencies = [
|
2024-02-11 12:59:00 +11:00
|
|
|
"approx 0.1.1",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"mint",
|
|
|
|
|
"num-traits 0.1.43",
|
|
|
|
|
"rand 0.4.6",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 19:37:52 +10:00
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "chrono"
|
2024-03-28 18:30:45 +00:00
|
|
|
version = "0.4.37"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-28 18:30:45 +00:00
|
|
|
checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"android-tzdata",
|
2023-08-25 13:41:04 -07:00
|
|
|
"iana-time-zone",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"js-sys",
|
2024-03-23 15:45:55 -07:00
|
|
|
"num-traits 0.2.18",
|
2023-08-18 08:12:32 -07:00
|
|
|
"serde",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"wasm-bindgen",
|
2024-03-23 15:45:55 -07:00
|
|
|
"windows-targets 0.52.4",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
2023-09-20 13:15:28 -05:00
|
|
|
[[package]]
|
|
|
|
|
name = "ciborium"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.2.2"
|
2023-09-20 13:15:28 -05:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
|
2023-09-20 13:15:28 -05:00
|
|
|
dependencies = [
|
|
|
|
|
"ciborium-io",
|
|
|
|
|
"ciborium-ll",
|
|
|
|
|
"serde",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "ciborium-io"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.2.2"
|
2023-09-20 13:15:28 -05:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
|
2023-09-20 13:15:28 -05:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "ciborium-ll"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.2.2"
|
2023-09-20 13:15:28 -05:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
|
2023-09-20 13:15:28 -05:00
|
|
|
dependencies = [
|
|
|
|
|
"ciborium-io",
|
2024-03-23 15:45:55 -07:00
|
|
|
"half",
|
2023-09-20 13:15:28 -05:00
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "cipher"
|
|
|
|
|
version = "0.4.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"crypto-common",
|
|
|
|
|
"inout",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-05 16:02:27 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "clap"
|
2024-03-28 22:42:04 +00:00
|
|
|
version = "4.5.4"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-28 22:42:04 +00:00
|
|
|
checksum = "90bc066a67923782aa8515dbaea16946c5bcc5addbd668bb80af688e53e548a0"
|
2023-09-05 16:02:27 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"clap_builder",
|
2023-09-14 15:05:07 -06:00
|
|
|
"clap_derive",
|
2023-09-05 16:02:27 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "clap_builder"
|
2024-03-08 09:36:23 -08:00
|
|
|
version = "4.5.2"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-08 09:36:23 -08:00
|
|
|
checksum = "ae129e2e766ae0ec03484e609954119f123cc1fe650337e155d03b022f24f7b4"
|
2023-09-05 16:02:27 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"anstream",
|
|
|
|
|
"anstyle",
|
2023-09-14 15:05:07 -06:00
|
|
|
"clap_lex",
|
2023-09-05 16:02:27 -07:00
|
|
|
"strsim",
|
|
|
|
|
"unicase",
|
|
|
|
|
"unicode-width",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "clap_derive"
|
2024-03-28 22:42:04 +00:00
|
|
|
version = "4.5.4"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-28 22:42:04 +00:00
|
|
|
checksum = "528131438037fd55894f62d6e9f068b8f45ac57ffa77517819645d10aed04f64"
|
2023-09-05 16:02:27 -07:00
|
|
|
dependencies = [
|
2024-03-21 03:57:58 +00:00
|
|
|
"heck 0.5.0",
|
2023-09-05 16:02:27 -07:00
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-09-05 16:02:27 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "clap_lex"
|
2024-02-11 11:09:03 -08:00
|
|
|
version = "0.7.0"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 11:09:03 -08:00
|
|
|
checksum = "98cc8fbded0c607b7ba9dd60cd98df59af97e84d24e49c8557331cfc26d301ce"
|
2023-09-05 16:02:27 -07:00
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "color_quant"
|
|
|
|
|
version = "1.1.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
|
|
|
|
|
|
2023-09-05 16:02:27 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "colorchoice"
|
|
|
|
|
version = "1.0.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "colored"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "2.1.0"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "cbf2150cce219b664a8a70df7a1f933836724b503f8a413af9365b4dcc4d90b8"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"lazy_static",
|
|
|
|
|
"windows-sys 0.48.0",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "console"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.15.8"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"encode_unicode",
|
|
|
|
|
"lazy_static",
|
|
|
|
|
"libc",
|
|
|
|
|
"unicode-width",
|
2024-03-23 15:45:55 -07:00
|
|
|
"windows-sys 0.52.0",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
2024-03-11 17:50:31 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "console_error_panic_hook"
|
|
|
|
|
version = "0.1.7"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"wasm-bindgen",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "const-oid"
|
|
|
|
|
version = "0.9.6"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "convert_case"
|
|
|
|
|
version = "0.6.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"unicode-segmentation",
|
2023-08-18 08:12:32 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "core-foundation"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.9.4"
|
2023-08-28 14:58:24 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
|
2023-08-28 14:58:24 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"core-foundation-sys",
|
|
|
|
|
"libc",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "core-foundation-sys"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.8.6"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "cpufeatures"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.2.12"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"libc",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "crc"
|
|
|
|
|
version = "3.0.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "86ec7a15cbe22e59248fc7eadb1907dab5ba09372595da4d73dd805ed4417dfe"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"crc-catalog",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "crc-catalog"
|
|
|
|
|
version = "2.4.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "crc32fast"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.4.0"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-20 13:15:28 -05:00
|
|
|
[[package]]
|
|
|
|
|
name = "criterion"
|
|
|
|
|
version = "0.5.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"anes",
|
|
|
|
|
"cast",
|
|
|
|
|
"ciborium",
|
|
|
|
|
"clap",
|
|
|
|
|
"criterion-plot",
|
|
|
|
|
"is-terminal",
|
|
|
|
|
"itertools 0.10.5",
|
2024-03-23 15:45:55 -07:00
|
|
|
"num-traits 0.2.18",
|
2023-09-20 13:15:28 -05:00
|
|
|
"once_cell",
|
|
|
|
|
"oorandom",
|
|
|
|
|
"plotters",
|
|
|
|
|
"rayon",
|
|
|
|
|
"regex",
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_derive",
|
|
|
|
|
"serde_json",
|
|
|
|
|
"tinytemplate",
|
|
|
|
|
"walkdir",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "criterion-plot"
|
|
|
|
|
version = "0.5.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"cast",
|
|
|
|
|
"itertools 0.10.5",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "crossbeam-channel"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.5.12"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "ab3db02a9c5b5121e1e42fbdb1aeb65f5e02624cc58c43f2884c6ccac0b82f95"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"crossbeam-utils",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "crossbeam-deque"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.8.5"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"crossbeam-epoch",
|
|
|
|
|
"crossbeam-utils",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "crossbeam-epoch"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.9.18"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"crossbeam-utils",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "crossbeam-utils"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.8.19"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "crunchy"
|
|
|
|
|
version = "0.2.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "crypto-bigint"
|
|
|
|
|
version = "0.5.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"generic-array",
|
|
|
|
|
"rand_core 0.6.4",
|
|
|
|
|
"subtle",
|
|
|
|
|
"zeroize",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "crypto-common"
|
|
|
|
|
version = "0.1.6"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"generic-array",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"rand_core 0.6.4",
|
2023-08-24 15:34:51 -07:00
|
|
|
"typenum",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "ctr"
|
|
|
|
|
version = "0.9.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"cipher",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "curve25519-dalek"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "4.1.2"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "0a677b8922c94e01bdbb12126b0bc852f00447528dee1782229af9c720c3f348"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"cpufeatures",
|
|
|
|
|
"curve25519-dalek-derive",
|
|
|
|
|
"fiat-crypto",
|
|
|
|
|
"platforms",
|
|
|
|
|
"rustc_version",
|
|
|
|
|
"subtle",
|
|
|
|
|
"zeroize",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "curve25519-dalek-derive"
|
|
|
|
|
version = "0.1.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
]
|
|
|
|
|
|
2023-09-05 16:02:27 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "dashmap"
|
|
|
|
|
version = "5.5.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
2024-03-23 15:45:55 -07:00
|
|
|
"hashbrown 0.14.3",
|
2023-09-05 16:02:27 -07:00
|
|
|
"lock_api",
|
|
|
|
|
"once_cell",
|
2023-10-24 11:24:59 -07:00
|
|
|
"parking_lot_core 0.9.9",
|
2023-09-05 16:02:27 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "data-encoding"
|
2023-12-12 09:26:36 -06:00
|
|
|
version = "2.5.0"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-12-12 09:26:36 -06:00
|
|
|
checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5"
|
2023-08-18 08:12:32 -07:00
|
|
|
|
2023-11-09 16:39:12 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "databake"
|
2023-11-20 11:16:01 -06:00
|
|
|
version = "0.1.7"
|
2023-11-09 16:39:12 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-11-20 11:16:01 -06:00
|
|
|
checksum = "82175d72e69414ceafbe2b49686794d3a8bed846e0d50267355f83ea8fdd953a"
|
2023-11-09 16:39:12 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"databake-derive",
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "databake-derive"
|
2023-11-20 11:16:01 -06:00
|
|
|
version = "0.1.7"
|
2023-11-09 16:39:12 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-11-20 11:16:01 -06:00
|
|
|
checksum = "377af281d8f23663862a7c84623bc5dcf7f8c44b13c7496a590bdc157f941a43"
|
2023-11-09 16:39:12 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2024-03-23 15:45:55 -07:00
|
|
|
"synstructure 0.13.1",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "der"
|
|
|
|
|
version = "0.7.8"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "fffa369a668c8af7dbf8b5e56c9f744fbd399949ed171606040001947de40b1c"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"const-oid",
|
|
|
|
|
"pem-rfc7468",
|
|
|
|
|
"zeroize",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "der-parser"
|
|
|
|
|
version = "8.2.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "dbd676fbbab537128ef0278adb5576cf363cff6aa22a7b24effe97347cfab61e"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"asn1-rs",
|
|
|
|
|
"displaydoc",
|
|
|
|
|
"nom",
|
|
|
|
|
"num-bigint",
|
2024-03-23 15:45:55 -07:00
|
|
|
"num-traits 0.2.18",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"rusticata-macros",
|
2023-11-09 16:39:12 -06:00
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "deranged"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.3.11"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
|
2023-10-24 11:24:59 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"powerfmt",
|
|
|
|
|
]
|
2023-08-25 13:41:04 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "derive-docs"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.1.12"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
2024-03-13 12:56:46 -07:00
|
|
|
"Inflector",
|
2024-03-23 15:45:55 -07:00
|
|
|
"anyhow",
|
2023-08-25 13:41:04 -07:00
|
|
|
"convert_case",
|
|
|
|
|
"expectorate",
|
Remove just one enum (#1096)
# Problem
This is my proposal for fixing #1107 . I've only done it for one stdlib function, `tangentialArcTo` -- if y'all like it, I'll apply this idea to the rest of the stdlib.
Previously, if users want to put a tag on the arc, the function's parameters change type.
```
// Tag missing: first param is array
tangentialArcTo([x, y], %)
// Tag present: first param is object
tangentialArcTo({to: [x, y], tag: "myTag"}, %)
```
# Solution
My proposal in #1006 is that KCL should have optional values. This means we can change the stdlib `tangentialArcTo` function to use them. In this PR, the calls are now like
```
// Tag missing: first param is array
tangentialArcTo([x, y], %)
// Tag present: first param is array still, but we now pass a tag at the end.
tangentialArcTo([x, y], %, "myTag")
```
This adds an "option" type to KCL typesystem, but it's not really revealed to users (no KCL types are revealed to users right now, they write untyped code and only interact with types when they get type errors upon executing programs). Also adds a None type, which is the default case of the Optional enum.
2023-12-18 23:49:32 -06:00
|
|
|
"once_cell",
|
2023-08-25 13:41:04 -07:00
|
|
|
"pretty_assertions",
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
Remove just one enum (#1096)
# Problem
This is my proposal for fixing #1107 . I've only done it for one stdlib function, `tangentialArcTo` -- if y'all like it, I'll apply this idea to the rest of the stdlib.
Previously, if users want to put a tag on the arc, the function's parameters change type.
```
// Tag missing: first param is array
tangentialArcTo([x, y], %)
// Tag present: first param is object
tangentialArcTo({to: [x, y], tag: "myTag"}, %)
```
# Solution
My proposal in #1006 is that KCL should have optional values. This means we can change the stdlib `tangentialArcTo` function to use them. In this PR, the calls are now like
```
// Tag missing: first param is array
tangentialArcTo([x, y], %)
// Tag present: first param is array still, but we now pass a tag at the end.
tangentialArcTo([x, y], %, "myTag")
```
This adds an "option" type to KCL typesystem, but it's not really revealed to users (no KCL types are revealed to users right now, they write untyped code and only interact with types when they get type errors upon executing programs). Also adds a None type, which is the default case of the Optional enum.
2023-12-18 23:49:32 -06:00
|
|
|
"regex",
|
2024-03-23 15:45:55 -07:00
|
|
|
"rustfmt-wrapper",
|
2024-03-13 14:22:22 -07:00
|
|
|
"serde",
|
|
|
|
|
"serde_tokenstream",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2024-03-13 14:22:22 -07:00
|
|
|
]
|
|
|
|
|
|
2024-03-28 17:29:42 -05:00
|
|
|
[[package]]
|
|
|
|
|
name = "derive-docs"
|
|
|
|
|
version = "0.1.12"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "138b94245509a9dd516008788b585c34847829cf37b40a758b4aa581cf94f147"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"Inflector",
|
|
|
|
|
"convert_case",
|
|
|
|
|
"once_cell",
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"regex",
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_tokenstream",
|
|
|
|
|
"syn 2.0.55",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "diesel_derives"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "2.1.3"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "5d02eecb814ae714ffe61ddc2db2dd03e6c49a42e269b5001355500d431cce0c"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"diesel_table_macro_syntax",
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "diesel_table_macro_syntax"
|
|
|
|
|
version = "0.1.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "fc5557efc453706fed5e4fa85006fe9817c224c3f480a34c7e5959fd700921c5"
|
|
|
|
|
dependencies = [
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-12-19 11:24:44 -06:00
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "diff"
|
|
|
|
|
version = "0.1.13"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "digest"
|
|
|
|
|
version = "0.10.7"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"block-buffer",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"const-oid",
|
2023-08-24 15:34:51 -07:00
|
|
|
"crypto-common",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"subtle",
|
2023-08-24 15:34:51 -07:00
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "displaydoc"
|
|
|
|
|
version = "0.2.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "487585f4d0c6655fe74905e2504d8ad6908e4db67f744eb140876906c2f3175d"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "dyn-clone"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.0.17"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125"
|
2023-08-18 08:12:32 -07:00
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "ecdsa"
|
|
|
|
|
version = "0.16.9"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"der",
|
|
|
|
|
"digest",
|
|
|
|
|
"elliptic-curve",
|
|
|
|
|
"rfc6979",
|
|
|
|
|
"signature",
|
|
|
|
|
"spki",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "either"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.10.0"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a"
|
2023-08-18 08:12:32 -07:00
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "elliptic-curve"
|
|
|
|
|
version = "0.13.8"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"base16ct",
|
|
|
|
|
"crypto-bigint",
|
|
|
|
|
"digest",
|
|
|
|
|
"ff",
|
|
|
|
|
"generic-array",
|
|
|
|
|
"group",
|
|
|
|
|
"hkdf",
|
|
|
|
|
"pem-rfc7468",
|
|
|
|
|
"pkcs8",
|
|
|
|
|
"rand_core 0.6.4",
|
|
|
|
|
"sec1",
|
|
|
|
|
"subtle",
|
|
|
|
|
"zeroize",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "encode_unicode"
|
|
|
|
|
version = "0.3.6"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "encoding_rs"
|
|
|
|
|
version = "0.8.33"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "enum-iterator"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.5.0"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "9fd242f399be1da0a5354aa462d57b4ab2b4ee0683cc552f7c007d2d12d36e94"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"enum-iterator-derive",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "enum-iterator-derive"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.3.0"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "03cdc46ec28bd728e67540c528013c6a10eb69a02eb31078a1bda695438cbfb8"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "equivalent"
|
|
|
|
|
version = "1.0.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "errno"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.3.8"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"libc",
|
2024-03-23 15:45:55 -07:00
|
|
|
"windows-sys 0.52.0",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "euler"
|
|
|
|
|
version = "0.4.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "3f19d11568a4a46aee488bdab3a2963e5e2c3cfd6091aa0abceaddcea82c0bc1"
|
|
|
|
|
dependencies = [
|
2024-02-11 12:59:00 +11:00
|
|
|
"approx 0.1.1",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"cgmath",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "expectorate"
|
2023-09-27 08:39:16 -07:00
|
|
|
version = "1.1.0"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-09-27 08:39:16 -07:00
|
|
|
checksum = "de6f19b25bdfa2747ae775f37cd109c31f1272d4e4c83095be0727840aa1d75f"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"console",
|
|
|
|
|
"newline-converter",
|
|
|
|
|
"similar",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "exr"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.72.0"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "887d93f60543e9a9362ef8a21beedd0a833c5d9610e18c67abe15a5963dcb1a4"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"bit_field",
|
|
|
|
|
"flume",
|
2024-03-23 15:45:55 -07:00
|
|
|
"half",
|
2023-09-12 14:59:40 -07:00
|
|
|
"lebe",
|
|
|
|
|
"miniz_oxide",
|
|
|
|
|
"rayon-core",
|
|
|
|
|
"smallvec",
|
|
|
|
|
"zune-inflate",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "fastrand"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "2.0.1"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "fdeflate"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.3.4"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "4f9bfee30e4dedf0ab8b422f03af778d9612b63f502710fc500a334ebe2de645"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"simd-adler32",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "ff"
|
|
|
|
|
version = "0.13.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"rand_core 0.6.4",
|
|
|
|
|
"subtle",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "fiat-crypto"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.2.7"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "c007b1ae3abe1cb6f85a16305acd418b7ca6343b953633fee2b76d8f108b830f"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "flate2"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "1.0.28"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"crc32fast",
|
|
|
|
|
"miniz_oxide",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "flume"
|
2023-09-18 18:22:25 -06:00
|
|
|
version = "0.11.0"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-09-18 18:22:25 -06:00
|
|
|
checksum = "55ac459de2512911e4b674ce33cf20befaba382d05b62b008afc1c8b57cbf181"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"spin 0.9.8",
|
2023-09-12 14:59:40 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "fnv"
|
|
|
|
|
version = "1.0.7"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "foreign-types"
|
|
|
|
|
version = "0.3.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"foreign-types-shared",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "foreign-types-shared"
|
|
|
|
|
version = "0.1.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "form_urlencoded"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.2.1"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"percent-encoding",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "format_serde_error"
|
|
|
|
|
version = "0.3.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "e5837b8e6a4001f99fe4746767fb7379e8510c508a843caa136cc12ed9c0bad0"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"colored",
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_json",
|
2024-03-23 15:45:55 -07:00
|
|
|
"serde_yaml",
|
2023-08-25 13:41:04 -07:00
|
|
|
"unicode-segmentation",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "fuchsia-cprng"
|
|
|
|
|
version = "0.1.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
|
|
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "funty"
|
|
|
|
|
version = "2.0.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "futures"
|
2024-02-11 19:54:02 +00:00
|
|
|
version = "0.3.30"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 19:54:02 +00:00
|
|
|
checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"futures-channel",
|
|
|
|
|
"futures-core",
|
|
|
|
|
"futures-executor",
|
|
|
|
|
"futures-io",
|
|
|
|
|
"futures-sink",
|
|
|
|
|
"futures-task",
|
|
|
|
|
"futures-util",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "futures-channel"
|
2024-02-11 19:54:02 +00:00
|
|
|
version = "0.3.30"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 19:54:02 +00:00
|
|
|
checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"futures-core",
|
|
|
|
|
"futures-sink",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "futures-core"
|
2024-02-11 19:54:02 +00:00
|
|
|
version = "0.3.30"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 19:54:02 +00:00
|
|
|
checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
|
2023-08-24 15:34:51 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "futures-executor"
|
2024-02-11 19:54:02 +00:00
|
|
|
version = "0.3.30"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 19:54:02 +00:00
|
|
|
checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"futures-core",
|
|
|
|
|
"futures-task",
|
|
|
|
|
"futures-util",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "futures-io"
|
2024-02-11 19:54:02 +00:00
|
|
|
version = "0.3.30"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 19:54:02 +00:00
|
|
|
checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
|
2023-08-24 15:34:51 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "futures-macro"
|
2024-02-11 19:54:02 +00:00
|
|
|
version = "0.3.30"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 19:54:02 +00:00
|
|
|
checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-08-24 15:34:51 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "futures-sink"
|
2024-02-11 19:54:02 +00:00
|
|
|
version = "0.3.30"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 19:54:02 +00:00
|
|
|
checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
|
2023-08-24 15:34:51 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "futures-task"
|
2024-02-11 19:54:02 +00:00
|
|
|
version = "0.3.30"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 19:54:02 +00:00
|
|
|
checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
|
2023-08-24 15:34:51 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "futures-util"
|
2024-02-11 19:54:02 +00:00
|
|
|
version = "0.3.30"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 19:54:02 +00:00
|
|
|
checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"futures-channel",
|
|
|
|
|
"futures-core",
|
|
|
|
|
"futures-io",
|
|
|
|
|
"futures-macro",
|
|
|
|
|
"futures-sink",
|
|
|
|
|
"futures-task",
|
|
|
|
|
"memchr",
|
|
|
|
|
"pin-project-lite",
|
|
|
|
|
"pin-utils",
|
|
|
|
|
"slab",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "generic-array"
|
|
|
|
|
version = "0.14.7"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"typenum",
|
|
|
|
|
"version_check",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"zeroize",
|
2023-08-24 15:34:51 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "getrandom"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.2.12"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "190092ea657667030ac6a35e305e62fc4dd69fd98ac98631e5d3a2b1575a12b5"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"js-sys",
|
|
|
|
|
"libc",
|
2023-09-14 15:05:07 -06:00
|
|
|
"wasi",
|
2023-08-18 08:12:32 -07:00
|
|
|
"wasm-bindgen",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "ghash"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.5.1"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"opaque-debug",
|
|
|
|
|
"polyval",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "gif"
|
2024-02-29 19:57:37 -08:00
|
|
|
version = "0.13.1"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-29 19:57:37 -08:00
|
|
|
checksum = "3fb2d69b19215e18bb912fa30f7ce15846e301408695e44e0ef719f1da9e19f2"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"color_quant",
|
|
|
|
|
"weezl",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "gimli"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.28.1"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
|
2023-08-18 08:12:32 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "gloo-utils"
|
|
|
|
|
version = "0.2.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "0b5555354113b18c547c1d3a98fbf7fb32a9ff4f6fa112ce823a21641a0ba3aa"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"js-sys",
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_json",
|
|
|
|
|
"wasm-bindgen",
|
|
|
|
|
"web-sys",
|
|
|
|
|
]
|
|
|
|
|
|
2024-02-12 12:18:37 -08:00
|
|
|
[[package]]
|
|
|
|
|
name = "gltf-derive"
|
|
|
|
|
version = "1.4.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "438ffe1a5540d75403feaf23636b164e816e93f6f03131674722b3886ce32a57"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"inflections",
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2024-02-12 12:18:37 -08:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "gltf-json"
|
|
|
|
|
version = "1.4.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "655951ba557f2bc69ea4b0799446bae281fa78efae6319968bdd2c3e9a06d8e1"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"gltf-derive",
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_derive",
|
|
|
|
|
"serde_json",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "grackle"
|
|
|
|
|
version = "0.1.0"
|
|
|
|
|
dependencies = [
|
2024-03-19 12:11:45 -04:00
|
|
|
"image",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"kcl-lib",
|
2024-02-28 16:24:03 -06:00
|
|
|
"kittycad",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"kittycad-execution-plan",
|
2024-02-28 16:24:03 -06:00
|
|
|
"kittycad-execution-plan-macros",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"kittycad-execution-plan-traits",
|
2024-02-28 16:24:03 -06:00
|
|
|
"kittycad-modeling-cmds",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"kittycad-modeling-session",
|
|
|
|
|
"pretty_assertions",
|
2024-02-06 22:44:30 +11:00
|
|
|
"serde_json",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"thiserror",
|
2024-01-29 17:36:29 +11:00
|
|
|
"tokio",
|
2024-03-19 12:11:45 -04:00
|
|
|
"twenty-twenty",
|
2024-02-28 16:24:03 -06:00
|
|
|
"uuid",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "group"
|
|
|
|
|
version = "0.13.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"ff",
|
|
|
|
|
"rand_core 0.6.4",
|
|
|
|
|
"subtle",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "h2"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.3.25"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "4fbd2820c5e49886948654ab546d0688ff24530286bdcf8fca3cefb16d4618eb"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"bytes",
|
|
|
|
|
"fnv",
|
|
|
|
|
"futures-core",
|
|
|
|
|
"futures-sink",
|
|
|
|
|
"futures-util",
|
2024-03-23 15:45:55 -07:00
|
|
|
"http 0.2.12",
|
|
|
|
|
"indexmap 2.2.5",
|
2023-08-25 13:41:04 -07:00
|
|
|
"slab",
|
|
|
|
|
"tokio",
|
|
|
|
|
"tokio-util",
|
|
|
|
|
"tracing",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-20 13:15:28 -05:00
|
|
|
[[package]]
|
|
|
|
|
name = "half"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "2.4.0"
|
2024-03-19 16:19:57 -05:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "b5eceaaeec696539ddaf7b333340f1af35a5aa87ae3e4f3ead0532f72affab2e"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"cfg-if",
|
2023-09-12 14:59:40 -07:00
|
|
|
"crunchy",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "hashbrown"
|
|
|
|
|
version = "0.12.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "hashbrown"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.14.3"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "heck"
|
|
|
|
|
version = "0.4.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
|
|
|
|
|
|
2024-03-21 03:57:58 +00:00
|
|
|
[[package]]
|
|
|
|
|
name = "heck"
|
|
|
|
|
version = "0.5.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
2024-03-19 16:19:57 -05:00
|
|
|
name = "hermit-abi"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.3.9"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
|
2023-08-24 15:34:51 -07:00
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "hex"
|
|
|
|
|
version = "0.4.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "hkdf"
|
|
|
|
|
version = "0.12.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"hmac",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "hmac"
|
|
|
|
|
version = "0.12.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"digest",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "home"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.5.9"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"windows-sys 0.52.0",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "http"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.2.12"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"bytes",
|
|
|
|
|
"fnv",
|
|
|
|
|
"itoa",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "http"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.1.0"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "21b9ddb458710bc376481b842f5da65cdf31522de232c1ca8146abce2a358258"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"bytes",
|
|
|
|
|
"fnv",
|
|
|
|
|
"itoa",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "http-body"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.4.6"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"bytes",
|
2024-03-23 15:45:55 -07:00
|
|
|
"http 0.2.12",
|
2023-08-25 13:41:04 -07:00
|
|
|
"pin-project-lite",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "httparse"
|
|
|
|
|
version = "1.8.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
2023-08-25 13:41:04 -07:00
|
|
|
name = "httpdate"
|
|
|
|
|
version = "1.0.3"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-08-25 13:41:04 -07:00
|
|
|
checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
|
2023-08-18 08:12:32 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
2023-08-25 13:41:04 -07:00
|
|
|
name = "hyper"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.14.28"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
2023-08-25 13:41:04 -07:00
|
|
|
"bytes",
|
|
|
|
|
"futures-channel",
|
|
|
|
|
"futures-core",
|
|
|
|
|
"futures-util",
|
|
|
|
|
"h2",
|
2024-03-23 15:45:55 -07:00
|
|
|
"http 0.2.12",
|
2023-08-25 13:41:04 -07:00
|
|
|
"http-body",
|
|
|
|
|
"httparse",
|
|
|
|
|
"httpdate",
|
|
|
|
|
"itoa",
|
|
|
|
|
"pin-project-lite",
|
2024-03-23 15:45:55 -07:00
|
|
|
"socket2",
|
2023-08-25 13:41:04 -07:00
|
|
|
"tokio",
|
|
|
|
|
"tower-service",
|
|
|
|
|
"tracing",
|
|
|
|
|
"want",
|
2023-08-18 08:12:32 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
2023-08-25 13:41:04 -07:00
|
|
|
name = "hyper-rustls"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.24.2"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"futures-util",
|
2024-03-23 15:45:55 -07:00
|
|
|
"http 0.2.12",
|
2023-08-25 13:41:04 -07:00
|
|
|
"hyper",
|
2024-03-23 15:45:55 -07:00
|
|
|
"rustls 0.21.10",
|
2023-08-25 13:41:04 -07:00
|
|
|
"tokio",
|
2024-02-11 19:19:37 +00:00
|
|
|
"tokio-rustls 0.24.1",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
2023-08-18 08:12:32 -07:00
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "hyper-tls"
|
|
|
|
|
version = "0.5.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"bytes",
|
|
|
|
|
"hyper",
|
|
|
|
|
"native-tls",
|
|
|
|
|
"tokio",
|
|
|
|
|
"tokio-native-tls",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
2023-08-25 13:41:04 -07:00
|
|
|
name = "iana-time-zone"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.1.60"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
2023-08-25 13:41:04 -07:00
|
|
|
"android_system_properties",
|
|
|
|
|
"core-foundation-sys",
|
|
|
|
|
"iana-time-zone-haiku",
|
|
|
|
|
"js-sys",
|
2023-08-18 08:12:32 -07:00
|
|
|
"wasm-bindgen",
|
2023-10-24 11:24:59 -07:00
|
|
|
"windows-core",
|
2023-08-18 08:12:32 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
2023-08-25 13:41:04 -07:00
|
|
|
name = "iana-time-zone-haiku"
|
|
|
|
|
version = "0.1.2"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-08-25 13:41:04 -07:00
|
|
|
checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
2023-08-25 13:41:04 -07:00
|
|
|
"cc",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "idna"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.5.0"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"unicode-bidi",
|
|
|
|
|
"unicode-normalization",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "image"
|
2024-02-29 19:57:37 -08:00
|
|
|
version = "0.24.9"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-29 19:57:37 -08:00
|
|
|
checksum = "5690139d2f55868e080017335e4b94cb7414274c74f1669c84fb5feba2c9f69d"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"bytemuck",
|
|
|
|
|
"byteorder",
|
|
|
|
|
"color_quant",
|
|
|
|
|
"exr",
|
|
|
|
|
"gif",
|
|
|
|
|
"jpeg-decoder",
|
2024-03-23 15:45:55 -07:00
|
|
|
"num-traits 0.2.18",
|
2023-09-12 14:59:40 -07:00
|
|
|
"png",
|
|
|
|
|
"qoi",
|
|
|
|
|
"tiff",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "image-compare"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.3.1"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "c16b73efbb4b417b4e036cb6f0b0d31c43568a90ab575a4c7611c4396ec1a6b8"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"image",
|
|
|
|
|
"itertools 0.10.5",
|
|
|
|
|
"rayon",
|
|
|
|
|
"thiserror",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "indexmap"
|
|
|
|
|
version = "1.9.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"autocfg",
|
|
|
|
|
"hashbrown 0.12.3",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "indexmap"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "2.2.5"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "7b0b929d511467233429c45a44ac1dcaa21ba0f5ba11e4879e6ed28ddb4f9df4"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"equivalent",
|
2024-03-23 15:45:55 -07:00
|
|
|
"hashbrown 0.14.3",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "inflections"
|
|
|
|
|
version = "1.1.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "a257582fdcde896fd96463bf2d40eefea0580021c0712a0e2b028b60b47a837a"
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "inout"
|
|
|
|
|
version = "0.1.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"block-padding",
|
|
|
|
|
"generic-array",
|
|
|
|
|
]
|
|
|
|
|
|
2023-11-01 12:40:40 -05:00
|
|
|
[[package]]
|
|
|
|
|
name = "insta"
|
2024-03-28 18:21:03 +00:00
|
|
|
version = "1.37.0"
|
2023-11-01 12:40:40 -05:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-28 18:21:03 +00:00
|
|
|
checksum = "1718b3f2b85bb5054baf8ce406e36401f27c3169205f4175504c4b1d98252d3f"
|
2023-11-01 12:40:40 -05:00
|
|
|
dependencies = [
|
|
|
|
|
"console",
|
|
|
|
|
"lazy_static",
|
|
|
|
|
"linked-hash-map",
|
|
|
|
|
"serde",
|
|
|
|
|
"similar",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "instant"
|
|
|
|
|
version = "0.1.12"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"js-sys",
|
|
|
|
|
"wasm-bindgen",
|
|
|
|
|
"web-sys",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "interceptor"
|
|
|
|
|
version = "0.10.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "5927883184e6a819b22d5e4f5f7bc7ca134fde9b2026fbddd8d95249746ba21e"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"async-trait",
|
|
|
|
|
"bytes",
|
|
|
|
|
"log",
|
|
|
|
|
"rand 0.8.5",
|
|
|
|
|
"rtcp",
|
2024-03-23 15:45:55 -07:00
|
|
|
"rtp 0.9.0",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"thiserror",
|
|
|
|
|
"tokio",
|
|
|
|
|
"waitgroup",
|
|
|
|
|
"webrtc-srtp",
|
|
|
|
|
"webrtc-util",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "ipnet"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "2.9.0"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "is-terminal"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.4.12"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"hermit-abi",
|
|
|
|
|
"libc",
|
|
|
|
|
"windows-sys 0.52.0",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "itertools"
|
|
|
|
|
version = "0.10.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"either",
|
|
|
|
|
]
|
|
|
|
|
|
2024-03-23 15:45:55 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "itertools"
|
|
|
|
|
version = "0.11.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"either",
|
|
|
|
|
]
|
|
|
|
|
|
2023-11-15 11:41:12 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "itertools"
|
2024-02-11 11:22:48 -08:00
|
|
|
version = "0.12.1"
|
2023-11-15 11:41:12 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 11:22:48 -08:00
|
|
|
checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
|
2023-11-15 11:41:12 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"either",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "itoa"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.0.10"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "jpeg-decoder"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.3.1"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "f5d4a7da358eff58addd2877a45865158f0d78c911d43a5784ceb7bbf52833b0"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"rayon",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "js-sys"
|
2024-03-05 20:22:54 +00:00
|
|
|
version = "0.3.69"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-05 20:22:54 +00:00
|
|
|
checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"wasm-bindgen",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
2023-08-29 12:35:45 -07:00
|
|
|
name = "kcl-lib"
|
2024-03-28 17:29:42 -05:00
|
|
|
version = "0.1.47"
|
2023-08-28 14:58:24 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"anyhow",
|
2024-02-11 12:59:00 +11:00
|
|
|
"approx 0.5.1",
|
2023-09-20 18:27:08 -07:00
|
|
|
"async-recursion",
|
2023-09-17 21:57:43 -07:00
|
|
|
"async-trait",
|
2024-03-26 21:28:50 -07:00
|
|
|
"base64 0.22.0",
|
2023-08-28 14:58:24 -07:00
|
|
|
"bson",
|
2024-03-12 23:57:43 -07:00
|
|
|
"chrono",
|
2023-09-14 15:05:07 -06:00
|
|
|
"clap",
|
2024-03-26 21:28:50 -07:00
|
|
|
"convert_case",
|
2023-09-20 13:15:28 -05:00
|
|
|
"criterion",
|
2023-09-05 16:02:27 -07:00
|
|
|
"dashmap",
|
2023-11-09 16:39:12 -06:00
|
|
|
"databake",
|
2024-03-28 17:29:42 -05:00
|
|
|
"derive-docs 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
|
2023-08-28 14:58:24 -07:00
|
|
|
"expectorate",
|
|
|
|
|
"futures",
|
2024-02-12 12:18:37 -08:00
|
|
|
"gltf-json",
|
2024-03-26 21:28:50 -07:00
|
|
|
"image",
|
2023-11-01 12:40:40 -05:00
|
|
|
"insta",
|
2024-02-11 11:22:48 -08:00
|
|
|
"itertools 0.12.1",
|
2023-08-28 14:58:24 -07:00
|
|
|
"js-sys",
|
|
|
|
|
"kittycad",
|
2024-02-28 16:24:03 -06:00
|
|
|
"kittycad-execution-plan-macros",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"kittycad-execution-plan-traits",
|
2023-08-28 14:58:24 -07:00
|
|
|
"lazy_static",
|
2024-03-12 23:57:43 -07:00
|
|
|
"mime_guess",
|
2024-02-11 12:09:50 -08:00
|
|
|
"parse-display 0.9.0",
|
2023-08-28 14:58:24 -07:00
|
|
|
"pretty_assertions",
|
|
|
|
|
"reqwest",
|
2024-02-15 13:56:31 -08:00
|
|
|
"ropey",
|
2023-08-28 14:58:24 -07:00
|
|
|
"schemars",
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_json",
|
2024-03-12 23:57:43 -07:00
|
|
|
"sha2",
|
2023-08-28 14:58:24 -07:00
|
|
|
"thiserror",
|
|
|
|
|
"tokio",
|
2024-02-11 19:19:37 +00:00
|
|
|
"tokio-tungstenite",
|
2023-09-05 16:02:27 -07:00
|
|
|
"tower-lsp",
|
2024-01-11 15:31:35 -08:00
|
|
|
"ts-rs",
|
2024-03-26 21:28:50 -07:00
|
|
|
"twenty-twenty",
|
2023-08-28 14:58:24 -07:00
|
|
|
"uuid",
|
|
|
|
|
"wasm-bindgen",
|
|
|
|
|
"wasm-bindgen-futures",
|
2023-09-17 21:57:43 -07:00
|
|
|
"web-sys",
|
2024-03-23 15:45:55 -07:00
|
|
|
"winnow 0.5.40",
|
2024-03-12 23:57:43 -07:00
|
|
|
"zip",
|
2023-08-28 14:58:24 -07:00
|
|
|
]
|
|
|
|
|
|
2023-11-10 10:36:21 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "kcl-macros"
|
|
|
|
|
version = "0.1.0"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"databake",
|
|
|
|
|
"kcl-lib",
|
|
|
|
|
"pretty_assertions",
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-11-10 10:36:21 -06:00
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "kittycad"
|
2024-03-26 19:07:16 -07:00
|
|
|
version = "0.2.63"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-26 19:07:16 -07:00
|
|
|
checksum = "93a332250e08fd715ad3d5826e04d36da1c5bb42d0c1b1ff1f0598278b9ebf3c"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"anyhow",
|
2023-09-12 14:59:40 -07:00
|
|
|
"async-trait",
|
2024-03-23 15:45:55 -07:00
|
|
|
"base64 0.21.7",
|
2023-09-21 15:22:04 -05:00
|
|
|
"bigdecimal",
|
2023-08-25 13:41:04 -07:00
|
|
|
"bytes",
|
|
|
|
|
"chrono",
|
2023-08-18 08:12:32 -07:00
|
|
|
"data-encoding",
|
2023-09-12 14:59:40 -07:00
|
|
|
"format_serde_error",
|
|
|
|
|
"futures",
|
2024-03-23 15:45:55 -07:00
|
|
|
"http 0.2.12",
|
2023-09-05 16:02:27 -07:00
|
|
|
"itertools 0.10.5",
|
2023-09-12 14:59:40 -07:00
|
|
|
"log",
|
2024-03-12 23:57:43 -07:00
|
|
|
"mime_guess",
|
2024-02-11 12:09:50 -08:00
|
|
|
"parse-display 0.8.2",
|
2023-08-18 08:12:32 -07:00
|
|
|
"phonenumber",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"rand 0.8.5",
|
2023-09-12 14:59:40 -07:00
|
|
|
"reqwest",
|
|
|
|
|
"reqwest-conditional-middleware",
|
2023-09-14 15:05:07 -06:00
|
|
|
"reqwest-middleware",
|
2023-09-12 14:59:40 -07:00
|
|
|
"reqwest-retry",
|
|
|
|
|
"reqwest-tracing",
|
2023-08-18 08:12:32 -07:00
|
|
|
"schemars",
|
|
|
|
|
"serde",
|
2023-08-29 16:31:19 -07:00
|
|
|
"serde_bytes",
|
2023-08-18 08:12:32 -07:00
|
|
|
"serde_json",
|
2023-09-12 14:59:40 -07:00
|
|
|
"serde_urlencoded",
|
2023-08-18 08:12:32 -07:00
|
|
|
"thiserror",
|
2023-09-12 14:59:40 -07:00
|
|
|
"tracing",
|
2023-08-18 08:12:32 -07:00
|
|
|
"url",
|
|
|
|
|
"uuid",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "kittycad-execution-plan"
|
2024-03-28 17:29:42 -05:00
|
|
|
version = "0.1.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "e913f8e5f3ef7928cddca2e7b53c6582d7be6a8f900d18ce6c31c04083056270"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"bytes",
|
2024-03-20 19:44:25 -07:00
|
|
|
"gltf-json",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"insta",
|
|
|
|
|
"kittycad",
|
2024-03-04 19:51:03 -06:00
|
|
|
"kittycad-execution-plan-macros",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"kittycad-execution-plan-traits",
|
|
|
|
|
"kittycad-modeling-cmds",
|
|
|
|
|
"kittycad-modeling-session",
|
2024-02-11 12:09:50 -08:00
|
|
|
"parse-display-derive 0.8.2",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"serde",
|
2024-03-20 19:44:25 -07:00
|
|
|
"serde_json",
|
2024-01-29 17:36:29 +11:00
|
|
|
"tabled",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"thiserror",
|
|
|
|
|
"tokio",
|
|
|
|
|
"uuid",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "kittycad-execution-plan-macros"
|
2024-03-13 20:15:40 -05:00
|
|
|
version = "0.1.9"
|
2024-03-28 17:29:42 -05:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "0611fc9b9786175da21d895ffa0f65039e19c9111e94a41b7af999e3b95f045f"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "kittycad-execution-plan-traits"
|
2024-03-21 16:49:10 -05:00
|
|
|
version = "0.1.15"
|
2024-03-28 17:29:42 -05:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "123cb47e2780ea8ef3aa67b4db237a27b388d3d3b96db457e274aa4565723151"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"serde",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"uuid",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "kittycad-modeling-cmds"
|
2024-03-28 17:29:42 -05:00
|
|
|
version = "0.2.10"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "b41beb7d9b776df93fd449604de5c447e33c7bd3326fd590002dc18cf5f08166"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"anyhow",
|
|
|
|
|
"chrono",
|
|
|
|
|
"data-encoding",
|
|
|
|
|
"diesel_derives",
|
|
|
|
|
"enum-iterator",
|
|
|
|
|
"enum-iterator-derive",
|
|
|
|
|
"euler",
|
2024-03-23 15:45:55 -07:00
|
|
|
"http 0.2.12",
|
2024-02-28 16:24:03 -06:00
|
|
|
"kittycad-execution-plan-macros",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"kittycad-execution-plan-traits",
|
2024-02-28 16:24:03 -06:00
|
|
|
"kittycad-modeling-cmds-macros",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"kittycad-unit-conversion-derive",
|
|
|
|
|
"measurements",
|
2024-02-11 12:09:50 -08:00
|
|
|
"parse-display 0.8.2",
|
|
|
|
|
"parse-display-derive 0.8.2",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"schemars",
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_bytes",
|
|
|
|
|
"serde_json",
|
|
|
|
|
"uuid",
|
|
|
|
|
"webrtc",
|
|
|
|
|
]
|
|
|
|
|
|
2024-02-28 16:24:03 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "kittycad-modeling-cmds-macros"
|
2024-03-21 16:17:48 -05:00
|
|
|
version = "0.1.5"
|
2024-03-28 17:29:42 -05:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "385775cc9d5bf25579f3029824ca1a6e7ab1b7c338e972ec8e8fcefff801f353"
|
2024-02-28 16:24:03 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2024-02-28 16:24:03 -06:00
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "kittycad-modeling-session"
|
2024-03-28 17:29:42 -05:00
|
|
|
version = "0.1.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "6ee3a24232a086ec12ae4cfee443485c22e6c6959936d861006fa13bebef0904"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"futures",
|
|
|
|
|
"kittycad",
|
|
|
|
|
"kittycad-modeling-cmds",
|
2024-03-19 16:19:57 -05:00
|
|
|
"lsystem",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"reqwest",
|
|
|
|
|
"serde_json",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"tokio",
|
2024-02-11 19:19:37 +00:00
|
|
|
"tokio-tungstenite",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"uuid",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "kittycad-unit-conversion-derive"
|
|
|
|
|
version = "0.1.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "7001c46a92c1edce6722a3900539b198230980799035f02d92b4e7df3fc08738"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"inflections",
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"syn 1.0.109",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "lazy_static"
|
|
|
|
|
version = "1.4.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "lebe"
|
|
|
|
|
version = "0.5.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "03087c2bad5e1034e8cace5926dec053fb3790248370865f5117a7d0213354c8"
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "libc"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.2.153"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
|
2023-08-18 08:12:32 -07:00
|
|
|
|
2023-09-20 17:36:26 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "libm"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.2.8"
|
2023-09-20 17:36:26 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
|
2023-09-20 17:36:26 -07:00
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "linked-hash-map"
|
|
|
|
|
version = "0.5.6"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
|
|
|
|
|
|
2023-09-14 15:05:07 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "linux-raw-sys"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.4.13"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "lock_api"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.4.11"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"autocfg",
|
|
|
|
|
"scopeguard",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "log"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.4.21"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
2023-08-25 13:41:04 -07:00
|
|
|
"serde",
|
2023-08-18 08:12:32 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "lru-cache"
|
|
|
|
|
version = "0.1.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"linked-hash-map",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-05 16:02:27 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "lsp-types"
|
|
|
|
|
version = "0.94.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "c66bfd44a06ae10647fe3f8214762e9369fd4248df1350924b4ef9e770a85ea1"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"bitflags 1.3.2",
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_json",
|
|
|
|
|
"serde_repr",
|
|
|
|
|
"url",
|
|
|
|
|
]
|
|
|
|
|
|
2024-03-19 16:19:57 -05:00
|
|
|
[[package]]
|
|
|
|
|
name = "lsystem"
|
|
|
|
|
version = "0.2.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "23c47210f2a9f5ae2073e7b847026e3233bcb012aa6845201c69c26481762a81"
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
name = "matchit"
|
|
|
|
|
version = "0.7.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94"
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "md-5"
|
|
|
|
|
version = "0.10.6"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"digest",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "measurements"
|
|
|
|
|
version = "0.11.0"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
checksum = "f5b734b4e8187ea5777bc29c086f0970a27d8de42061b48f5af32cafc0ca904b"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"libm",
|
|
|
|
|
]
|
2023-09-12 14:59:40 -07:00
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "memchr"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "2.7.1"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
|
2023-08-18 08:12:32 -07:00
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "memoffset"
|
|
|
|
|
version = "0.7.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"autocfg",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "mime"
|
|
|
|
|
version = "0.3.17"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "mime_guess"
|
|
|
|
|
version = "2.0.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "4192263c238a5f0d0c6bfd21f336a313a4ce1c450542449ca191bb657b4642ef"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"mime",
|
|
|
|
|
"unicase",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "minimal-lexical"
|
|
|
|
|
version = "0.2.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "miniz_oxide"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.7.2"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"adler",
|
2023-09-12 14:59:40 -07:00
|
|
|
"simd-adler32",
|
2023-08-18 08:12:32 -07:00
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "mint"
|
|
|
|
|
version = "0.5.9"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "e53debba6bda7a793e5f99b8dacf19e626084f525f7829104ba9898f367d85ff"
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "mio"
|
2024-03-05 20:23:16 +00:00
|
|
|
version = "0.8.11"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-05 20:23:16 +00:00
|
|
|
checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"libc",
|
2023-09-14 15:05:07 -06:00
|
|
|
"wasi",
|
2023-08-25 13:41:04 -07:00
|
|
|
"windows-sys 0.48.0",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "native-tls"
|
|
|
|
|
version = "0.2.11"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"lazy_static",
|
|
|
|
|
"libc",
|
|
|
|
|
"log",
|
|
|
|
|
"openssl",
|
|
|
|
|
"openssl-probe",
|
|
|
|
|
"openssl-sys",
|
|
|
|
|
"schannel",
|
|
|
|
|
"security-framework",
|
|
|
|
|
"security-framework-sys",
|
|
|
|
|
"tempfile",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "newline-converter"
|
|
|
|
|
version = "0.3.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "47b6b097ecb1cbfed438542d16e84fd7ad9b0c76c8a65b7f9039212a3d14dc7f"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"unicode-segmentation",
|
2023-08-24 15:34:51 -07:00
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "nix"
|
|
|
|
|
version = "0.26.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "598beaf3cc6fdd9a5dfb1630c2800c7acd31df7aaf0f565796fba2b53ca1af1b"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"bitflags 1.3.2",
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"libc",
|
2024-03-23 15:45:55 -07:00
|
|
|
"memoffset",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"pin-utils",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "nom"
|
|
|
|
|
version = "7.1.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"memchr",
|
|
|
|
|
"minimal-lexical",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "num-bigint"
|
|
|
|
|
version = "0.4.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"autocfg",
|
|
|
|
|
"num-integer",
|
2024-03-23 15:45:55 -07:00
|
|
|
"num-traits 0.2.18",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
2024-03-23 15:45:55 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "num-conv"
|
|
|
|
|
version = "0.1.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "num-integer"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.1.46"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"num-traits 0.2.18",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "num-traits"
|
|
|
|
|
version = "0.1.43"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "92e5113e9fd4cc14ded8e499429f396a20f98c772a47cc8622a736e1ec843c31"
|
|
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"num-traits 0.2.18",
|
2023-09-12 14:59:40 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "num-traits"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.2.18"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"autocfg",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "num_cpus"
|
|
|
|
|
version = "1.16.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
|
|
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"hermit-abi",
|
2024-03-19 16:19:57 -05:00
|
|
|
"libc",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "object"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.32.2"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"memchr",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "oid-registry"
|
|
|
|
|
version = "0.6.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "9bedf36ffb6ba96c2eb7144ef6270557b52e54b20c0a8e1eb2ff99a6c6959bff"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"asn1-rs",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "once_cell"
|
2024-02-11 12:09:59 -08:00
|
|
|
version = "1.19.0"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 12:09:59 -08:00
|
|
|
checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
|
2023-08-18 08:12:32 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "oncemutex"
|
|
|
|
|
version = "0.1.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "44d11de466f4a3006fe8a5e7ec84e93b79c70cb992ae0aa0eb631ad2df8abfe2"
|
|
|
|
|
|
2023-09-20 13:15:28 -05:00
|
|
|
[[package]]
|
|
|
|
|
name = "oorandom"
|
|
|
|
|
version = "11.1.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "opaque-debug"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.3.1"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "openssl"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.10.64"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"bitflags 2.5.0",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"cfg-if",
|
|
|
|
|
"foreign-types",
|
|
|
|
|
"libc",
|
|
|
|
|
"once_cell",
|
|
|
|
|
"openssl-macros",
|
|
|
|
|
"openssl-sys",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "openssl-macros"
|
|
|
|
|
version = "0.1.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
]
|
|
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "openssl-probe"
|
|
|
|
|
version = "0.1.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "openssl-sys"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.9.101"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "dda2b0f344e78efc2facf7d195d098df0dd72151b26ab98da807afc26c198dff"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"cc",
|
|
|
|
|
"libc",
|
|
|
|
|
"pkg-config",
|
|
|
|
|
"vcpkg",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "opentelemetry"
|
|
|
|
|
version = "0.17.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "6105e89802af13fdf48c49d7646d3b533a70e536d818aae7e78ba0433d01acb8"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"async-trait",
|
|
|
|
|
"crossbeam-channel",
|
|
|
|
|
"futures-channel",
|
|
|
|
|
"futures-executor",
|
|
|
|
|
"futures-util",
|
|
|
|
|
"js-sys",
|
|
|
|
|
"lazy_static",
|
|
|
|
|
"percent-encoding",
|
|
|
|
|
"pin-project",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"rand 0.8.5",
|
2023-09-12 14:59:40 -07:00
|
|
|
"thiserror",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "p256"
|
|
|
|
|
version = "0.13.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"ecdsa",
|
|
|
|
|
"elliptic-curve",
|
|
|
|
|
"primeorder",
|
|
|
|
|
"sha2",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "p384"
|
|
|
|
|
version = "0.13.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "70786f51bcc69f6a4c0360e063a4cac5419ef7c5cd5b3c99ad70f3be5ba79209"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"ecdsa",
|
|
|
|
|
"elliptic-curve",
|
|
|
|
|
"primeorder",
|
|
|
|
|
"sha2",
|
|
|
|
|
]
|
|
|
|
|
|
2024-01-29 17:36:29 +11:00
|
|
|
[[package]]
|
|
|
|
|
name = "papergrid"
|
2024-02-06 22:44:30 +11:00
|
|
|
version = "0.11.0"
|
2024-01-29 17:36:29 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-06 22:44:30 +11:00
|
|
|
checksum = "9ad43c07024ef767f9160710b3a6773976194758c7919b17e63b863db0bdf7fb"
|
2024-01-29 17:36:29 +11:00
|
|
|
dependencies = [
|
|
|
|
|
"bytecount",
|
|
|
|
|
"fnv",
|
|
|
|
|
"unicode-width",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "parking_lot"
|
|
|
|
|
version = "0.11.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"instant",
|
|
|
|
|
"lock_api",
|
|
|
|
|
"parking_lot_core 0.8.6",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "parking_lot"
|
|
|
|
|
version = "0.12.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"lock_api",
|
2023-10-24 11:24:59 -07:00
|
|
|
"parking_lot_core 0.9.9",
|
2023-09-12 14:59:40 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "parking_lot_core"
|
|
|
|
|
version = "0.8.6"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "60a2cfe6f0ad2bfc16aefa463b497d5c7a5ecd44a23efa72aa342d90177356dc"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"instant",
|
|
|
|
|
"libc",
|
|
|
|
|
"redox_syscall 0.2.16",
|
|
|
|
|
"smallvec",
|
|
|
|
|
"winapi",
|
2023-08-24 15:34:51 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "parking_lot_core"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.9.9"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"libc",
|
2023-10-24 11:24:59 -07:00
|
|
|
"redox_syscall 0.4.1",
|
2023-08-24 15:34:51 -07:00
|
|
|
"smallvec",
|
2023-08-25 13:41:04 -07:00
|
|
|
"windows-targets 0.48.5",
|
2023-08-24 15:34:51 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "parse-display"
|
|
|
|
|
version = "0.8.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "c6509d08722b53e8dafe97f2027b22ccbe3a5db83cb352931e9716b0aa44bc5c"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"once_cell",
|
2024-02-11 12:09:50 -08:00
|
|
|
"parse-display-derive 0.8.2",
|
2023-08-18 08:12:32 -07:00
|
|
|
"regex",
|
|
|
|
|
]
|
|
|
|
|
|
2024-02-11 12:09:50 -08:00
|
|
|
[[package]]
|
|
|
|
|
name = "parse-display"
|
|
|
|
|
version = "0.9.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "06af5f9333eb47bd9ba8462d612e37a8328a5cb80b13f0af4de4c3b89f52dee5"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"parse-display-derive 0.9.0",
|
|
|
|
|
"regex",
|
|
|
|
|
"regex-syntax 0.8.2",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "parse-display-derive"
|
|
|
|
|
version = "0.8.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "68517892c8daf78da08c0db777fcc17e07f2f63ef70041718f8a7630ad84f341"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"once_cell",
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"regex",
|
2023-09-18 18:22:25 -06:00
|
|
|
"regex-syntax 0.7.5",
|
2024-02-11 12:09:50 -08:00
|
|
|
"structmeta 0.2.0",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2024-02-11 12:09:50 -08:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "parse-display-derive"
|
|
|
|
|
version = "0.9.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "dc9252f259500ee570c75adcc4e317fa6f57a1e47747d622e0bf838002a7b790"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"regex",
|
|
|
|
|
"regex-syntax 0.8.2",
|
|
|
|
|
"structmeta 0.3.0",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "pem"
|
|
|
|
|
version = "3.0.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "1b8fcc794035347fb64beda2d3b462595dd2753e3f268d89c5aae77e8cf2c310"
|
|
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"base64 0.21.7",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"serde",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "pem-rfc7468"
|
|
|
|
|
version = "0.7.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"base64ct",
|
2023-08-18 08:12:32 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "percent-encoding"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "2.3.1"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
|
2023-08-18 08:12:32 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "phonenumber"
|
2023-09-21 15:02:23 -05:00
|
|
|
version = "0.3.3+8.13.9"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-09-21 15:02:23 -05:00
|
|
|
checksum = "635f3e6288e4f01c049d89332a031bd74f25d64b6fb94703ca966e819488cd06"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"bincode",
|
|
|
|
|
"either",
|
|
|
|
|
"fnv",
|
2024-03-23 15:45:55 -07:00
|
|
|
"itertools 0.11.0",
|
2023-08-18 08:12:32 -07:00
|
|
|
"lazy_static",
|
|
|
|
|
"nom",
|
|
|
|
|
"quick-xml",
|
|
|
|
|
"regex",
|
|
|
|
|
"regex-cache",
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_derive",
|
2023-09-21 15:02:23 -05:00
|
|
|
"strum",
|
2023-08-18 08:12:32 -07:00
|
|
|
"thiserror",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-05 16:02:27 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "pin-project"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.1.5"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
|
2023-09-05 16:02:27 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"pin-project-internal",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "pin-project-internal"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.1.5"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
|
2023-09-05 16:02:27 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-09-05 16:02:27 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "pin-project-lite"
|
2023-08-28 14:58:24 -07:00
|
|
|
version = "0.2.13"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-08-28 14:58:24 -07:00
|
|
|
checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
|
2023-08-24 15:34:51 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "pin-utils"
|
|
|
|
|
version = "0.1.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "pkcs8"
|
|
|
|
|
version = "0.10.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"der",
|
|
|
|
|
"spki",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "pkg-config"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.3.30"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "platforms"
|
|
|
|
|
version = "3.3.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "626dec3cac7cc0e1577a2ec3fc496277ec2baa084bebad95bb6fdbfae235f84c"
|
|
|
|
|
|
2023-09-20 13:15:28 -05:00
|
|
|
[[package]]
|
|
|
|
|
name = "plotters"
|
|
|
|
|
version = "0.3.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d2c224ba00d7cadd4d5c660deaf2098e5e80e07846537c51f9cfa4be50c1fd45"
|
|
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"num-traits 0.2.18",
|
2023-09-20 13:15:28 -05:00
|
|
|
"plotters-backend",
|
|
|
|
|
"plotters-svg",
|
|
|
|
|
"wasm-bindgen",
|
|
|
|
|
"web-sys",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "plotters-backend"
|
|
|
|
|
version = "0.3.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "9e76628b4d3a7581389a35d5b6e2139607ad7c75b17aed325f210aa91f4a9609"
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "plotters-svg"
|
|
|
|
|
version = "0.3.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "38f6d39893cca0701371e3c27294f09797214b86f1fb951b89ade8ec04e2abab"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"plotters-backend",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "png"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.17.13"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "06e4b0d3d1312775e782c86c91a111aa1f910cbb65e1337f9975b5f9a554b5e1"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"bitflags 1.3.2",
|
|
|
|
|
"crc32fast",
|
|
|
|
|
"fdeflate",
|
|
|
|
|
"flate2",
|
|
|
|
|
"miniz_oxide",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "polyval"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.6.2"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"cpufeatures",
|
|
|
|
|
"opaque-debug",
|
|
|
|
|
"universal-hash",
|
|
|
|
|
]
|
|
|
|
|
|
2023-10-24 11:24:59 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "powerfmt"
|
|
|
|
|
version = "0.2.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "ppv-lite86"
|
|
|
|
|
version = "0.2.17"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "pretty_assertions"
|
|
|
|
|
version = "1.4.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "af7cee1a6c8a5b9208b3cb1061f10c0cb689087b3d8ce85fb9d2dd7a29b6ba66"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"diff",
|
|
|
|
|
"yansi",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "primeorder"
|
|
|
|
|
version = "0.13.6"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"elliptic-curve",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "proc-macro-error"
|
|
|
|
|
version = "1.0.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro-error-attr",
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"syn 1.0.109",
|
|
|
|
|
"version_check",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "proc-macro-error-attr"
|
|
|
|
|
version = "1.0.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"version_check",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "proc-macro2"
|
2024-03-12 23:43:16 -07:00
|
|
|
version = "1.0.79"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-12 23:43:16 -07:00
|
|
|
checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"unicode-ident",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "qoi"
|
|
|
|
|
version = "0.4.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"bytemuck",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "quick-xml"
|
|
|
|
|
version = "0.28.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "0ce5e73202a820a31f8a0ee32ada5e21029c81fd9e3ebf668a40832e4219d9d1"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"memchr",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "quote"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
version = "1.0.35"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "radium"
|
|
|
|
|
version = "0.7.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "rand"
|
|
|
|
|
version = "0.4.6"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"fuchsia-cprng",
|
|
|
|
|
"libc",
|
|
|
|
|
"rand_core 0.3.1",
|
|
|
|
|
"rdrand",
|
|
|
|
|
"winapi",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "rand"
|
|
|
|
|
version = "0.8.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"libc",
|
|
|
|
|
"rand_chacha",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"rand_core 0.6.4",
|
2023-08-24 15:34:51 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "rand_chacha"
|
|
|
|
|
version = "0.3.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"ppv-lite86",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"rand_core 0.6.4",
|
2023-08-24 15:34:51 -07:00
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "rand_core"
|
|
|
|
|
version = "0.3.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"rand_core 0.4.2",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "rand_core"
|
|
|
|
|
version = "0.4.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "rand_core"
|
|
|
|
|
version = "0.6.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"getrandom",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "rayon"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.9.0"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "e4963ed1bc86e4f3ee217022bd855b297cef07fb9eac5dfa1f788b220b49b3bd"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"either",
|
|
|
|
|
"rayon-core",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "rayon-core"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.12.1"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"crossbeam-deque",
|
|
|
|
|
"crossbeam-utils",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "rcgen"
|
|
|
|
|
version = "0.11.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "52c4f3084aa3bc7dfbba4eff4fab2a54db4324965d8872ab933565e6fbd83bc6"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"pem",
|
|
|
|
|
"ring 0.16.20",
|
|
|
|
|
"time",
|
|
|
|
|
"x509-parser",
|
|
|
|
|
"yasna",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "rdrand"
|
|
|
|
|
version = "0.4.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"rand_core 0.3.1",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "redox_syscall"
|
|
|
|
|
version = "0.2.16"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"bitflags 1.3.2",
|
|
|
|
|
]
|
|
|
|
|
|
2023-10-24 11:24:59 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "redox_syscall"
|
|
|
|
|
version = "0.4.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"bitflags 1.3.2",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "regex"
|
2024-02-11 19:50:19 +00:00
|
|
|
version = "1.10.3"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 19:50:19 +00:00
|
|
|
checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"aho-corasick",
|
|
|
|
|
"memchr",
|
|
|
|
|
"regex-automata",
|
2023-10-24 11:24:59 -07:00
|
|
|
"regex-syntax 0.8.2",
|
2023-08-18 08:12:32 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "regex-automata"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.4.6"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"aho-corasick",
|
|
|
|
|
"memchr",
|
2023-10-24 11:24:59 -07:00
|
|
|
"regex-syntax 0.8.2",
|
2023-08-18 08:12:32 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "regex-cache"
|
|
|
|
|
version = "0.2.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "2f7b62d69743b8b94f353b6b7c3deb4c5582828328bcb8d5fedf214373808793"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"lru-cache",
|
|
|
|
|
"oncemutex",
|
|
|
|
|
"regex",
|
2023-08-25 13:41:04 -07:00
|
|
|
"regex-syntax 0.6.29",
|
2023-08-18 08:12:32 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "regex-syntax"
|
2023-08-25 13:41:04 -07:00
|
|
|
version = "0.6.29"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-08-25 13:41:04 -07:00
|
|
|
checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
|
2023-08-18 08:12:32 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "regex-syntax"
|
2023-09-18 18:22:25 -06:00
|
|
|
version = "0.7.5"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-09-18 18:22:25 -06:00
|
|
|
checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
|
2023-08-18 08:12:32 -07:00
|
|
|
|
2023-10-24 11:24:59 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "regex-syntax"
|
|
|
|
|
version = "0.8.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "reqwest"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.11.27"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"base64 0.21.7",
|
2023-08-25 13:41:04 -07:00
|
|
|
"bytes",
|
|
|
|
|
"encoding_rs",
|
|
|
|
|
"futures-core",
|
|
|
|
|
"futures-util",
|
|
|
|
|
"h2",
|
2024-03-23 15:45:55 -07:00
|
|
|
"http 0.2.12",
|
2023-08-25 13:41:04 -07:00
|
|
|
"http-body",
|
|
|
|
|
"hyper",
|
|
|
|
|
"hyper-rustls",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"hyper-tls",
|
2023-08-25 13:41:04 -07:00
|
|
|
"ipnet",
|
|
|
|
|
"js-sys",
|
|
|
|
|
"log",
|
|
|
|
|
"mime",
|
|
|
|
|
"mime_guess",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"native-tls",
|
2023-08-25 13:41:04 -07:00
|
|
|
"once_cell",
|
|
|
|
|
"percent-encoding",
|
|
|
|
|
"pin-project-lite",
|
2024-03-23 15:45:55 -07:00
|
|
|
"rustls 0.21.10",
|
|
|
|
|
"rustls-pemfile 1.0.4",
|
2023-08-25 13:41:04 -07:00
|
|
|
"serde",
|
|
|
|
|
"serde_json",
|
|
|
|
|
"serde_urlencoded",
|
2024-02-11 19:40:06 +00:00
|
|
|
"sync_wrapper",
|
2023-10-03 07:20:08 -07:00
|
|
|
"system-configuration",
|
2023-08-25 13:41:04 -07:00
|
|
|
"tokio",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"tokio-native-tls",
|
2024-02-11 19:19:37 +00:00
|
|
|
"tokio-rustls 0.24.1",
|
2024-02-15 13:56:31 -08:00
|
|
|
"tokio-util",
|
2023-08-25 13:41:04 -07:00
|
|
|
"tower-service",
|
|
|
|
|
"url",
|
|
|
|
|
"wasm-bindgen",
|
|
|
|
|
"wasm-bindgen-futures",
|
2024-02-15 13:56:31 -08:00
|
|
|
"wasm-streams",
|
2023-08-25 13:41:04 -07:00
|
|
|
"web-sys",
|
|
|
|
|
"webpki-roots",
|
|
|
|
|
"winreg",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "reqwest-conditional-middleware"
|
|
|
|
|
version = "0.2.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "59e50a2e70970896c99d1b8f20ddc30a70b30d3ac6e619a03a8353b64a49b277"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"async-trait",
|
|
|
|
|
"reqwest",
|
2023-09-14 15:05:07 -06:00
|
|
|
"reqwest-middleware",
|
2023-08-25 13:41:04 -07:00
|
|
|
"task-local-extensions",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "reqwest-middleware"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.2.5"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "5a735987236a8e238bf0296c7e351b999c188ccc11477f311b82b55c93984216"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"anyhow",
|
|
|
|
|
"async-trait",
|
2024-03-23 15:45:55 -07:00
|
|
|
"http 0.2.12",
|
2023-09-12 14:59:40 -07:00
|
|
|
"reqwest",
|
|
|
|
|
"serde",
|
|
|
|
|
"task-local-extensions",
|
|
|
|
|
"thiserror",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "reqwest-retry"
|
|
|
|
|
version = "0.2.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "5c6a11c05102e5bec712c0619b8c7b7eda8b21a558a0bd981ceee15c38df8be4"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"anyhow",
|
|
|
|
|
"async-trait",
|
|
|
|
|
"chrono",
|
|
|
|
|
"futures",
|
|
|
|
|
"getrandom",
|
2024-03-23 15:45:55 -07:00
|
|
|
"http 0.2.12",
|
2023-09-12 14:59:40 -07:00
|
|
|
"hyper",
|
|
|
|
|
"parking_lot 0.11.2",
|
|
|
|
|
"reqwest",
|
2023-09-14 15:05:07 -06:00
|
|
|
"reqwest-middleware",
|
2023-09-12 14:59:40 -07:00
|
|
|
"retry-policies",
|
|
|
|
|
"task-local-extensions",
|
|
|
|
|
"tokio",
|
|
|
|
|
"tracing",
|
|
|
|
|
"wasm-timer",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "reqwest-tracing"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.4.8"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "190838e54153d7a7e2ea98851304b3ce92daeabf14c54d32b01b84a3e636f683"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"anyhow",
|
|
|
|
|
"async-trait",
|
|
|
|
|
"getrandom",
|
|
|
|
|
"matchit",
|
|
|
|
|
"opentelemetry",
|
|
|
|
|
"reqwest",
|
2023-09-14 15:05:07 -06:00
|
|
|
"reqwest-middleware",
|
2023-09-12 14:59:40 -07:00
|
|
|
"task-local-extensions",
|
|
|
|
|
"tracing",
|
|
|
|
|
"tracing-opentelemetry",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "retry-policies"
|
|
|
|
|
version = "0.1.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "e09bbcb5003282bcb688f0bae741b278e9c7e8f378f561522c9806c58e075d9b"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"anyhow",
|
|
|
|
|
"chrono",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"rand 0.8.5",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "rfc6979"
|
|
|
|
|
version = "0.4.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"hmac",
|
|
|
|
|
"subtle",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "ring"
|
|
|
|
|
version = "0.16.20"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"cc",
|
|
|
|
|
"libc",
|
|
|
|
|
"once_cell",
|
|
|
|
|
"spin 0.5.2",
|
|
|
|
|
"untrusted 0.7.1",
|
|
|
|
|
"web-sys",
|
|
|
|
|
"winapi",
|
2023-09-12 14:59:40 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "ring"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.17.8"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"cc",
|
2024-03-23 15:45:55 -07:00
|
|
|
"cfg-if",
|
2023-10-24 11:24:59 -07:00
|
|
|
"getrandom",
|
2023-08-25 13:41:04 -07:00
|
|
|
"libc",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"spin 0.9.8",
|
|
|
|
|
"untrusted 0.9.0",
|
2024-03-23 15:45:55 -07:00
|
|
|
"windows-sys 0.52.0",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
2024-02-15 13:56:31 -08:00
|
|
|
[[package]]
|
|
|
|
|
name = "ropey"
|
|
|
|
|
version = "1.6.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "93411e420bcd1a75ddd1dc3caf18c23155eda2c090631a85af21ba19e97093b5"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"smallvec",
|
|
|
|
|
"str_indices",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "rtcp"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.10.1"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "33648a781874466a62d89e265fee9f17e32bc7d05a256e6cca41bf97eadcd8aa"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"bytes",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"webrtc-util",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "rtp"
|
|
|
|
|
version = "0.9.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "e60482acbe8afb31edf6b1413103b7bca7a65004c423b3c3993749a083994fbe"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"bytes",
|
|
|
|
|
"rand 0.8.5",
|
|
|
|
|
"serde",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"webrtc-util",
|
|
|
|
|
]
|
|
|
|
|
|
2024-03-23 15:45:55 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "rtp"
|
|
|
|
|
version = "0.10.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "47fca9bd66ae0b1f3f649b8f5003d6176433d7293b78b0fce7e1031816bdd99d"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"bytes",
|
|
|
|
|
"rand 0.8.5",
|
|
|
|
|
"serde",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"webrtc-util",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "rustc-demangle"
|
|
|
|
|
version = "0.1.23"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "rustc_version"
|
|
|
|
|
version = "0.4.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"semver",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "rustfmt-wrapper"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.2.1"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "f1adc9dfed5cc999077978cc7163b9282c5751c8d39827c4ea8c8c220ca5a440"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"serde",
|
|
|
|
|
"tempfile",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"toml",
|
|
|
|
|
"toolchain_find",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "rusticata-macros"
|
|
|
|
|
version = "4.1.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "faf0c4a6ece9950b9abdb62b1cfcf2a68b3b67a10ba445b3bb85be2a293d0632"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"nom",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-14 15:05:07 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "rustix"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.38.32"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "65e04861e65f21776e67888bfbea442b3642beaa0138fdb1dd7a84a52dffdb89"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"bitflags 2.5.0",
|
2023-08-25 13:41:04 -07:00
|
|
|
"errno",
|
|
|
|
|
"libc",
|
2023-09-18 18:22:25 -06:00
|
|
|
"linux-raw-sys",
|
2024-03-23 15:45:55 -07:00
|
|
|
"windows-sys 0.52.0",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "rustls"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.21.10"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "f9d5a6813c0759e4609cd494e8e725babae6a2ca7b62a5536a13daaec6fcb7ba"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"log",
|
2024-03-23 15:45:55 -07:00
|
|
|
"ring 0.17.8",
|
2024-02-11 19:19:37 +00:00
|
|
|
"rustls-webpki 0.101.7",
|
2023-08-25 13:41:04 -07:00
|
|
|
"sct",
|
|
|
|
|
]
|
|
|
|
|
|
2024-02-11 19:19:37 +00:00
|
|
|
[[package]]
|
|
|
|
|
name = "rustls"
|
|
|
|
|
version = "0.22.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "e87c9956bd9807afa1f77e0f7594af32566e830e088a5576d27c5b6f30f49d41"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"log",
|
2024-03-23 15:45:55 -07:00
|
|
|
"ring 0.17.8",
|
2024-02-11 19:19:37 +00:00
|
|
|
"rustls-pki-types",
|
|
|
|
|
"rustls-webpki 0.102.2",
|
|
|
|
|
"subtle",
|
|
|
|
|
"zeroize",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "rustls-native-certs"
|
2024-02-11 19:19:37 +00:00
|
|
|
version = "0.7.0"
|
2023-08-28 14:58:24 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 19:19:37 +00:00
|
|
|
checksum = "8f1fb85efa936c42c6d5fc28d2629bb51e4b2f4b8a5211e297d599cc5a093792"
|
2023-08-28 14:58:24 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"openssl-probe",
|
2024-03-23 15:45:55 -07:00
|
|
|
"rustls-pemfile 2.1.1",
|
2024-02-11 19:19:37 +00:00
|
|
|
"rustls-pki-types",
|
2023-08-28 14:58:24 -07:00
|
|
|
"schannel",
|
|
|
|
|
"security-framework",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "rustls-pemfile"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.0.4"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"base64 0.21.7",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
2024-02-11 19:19:37 +00:00
|
|
|
[[package]]
|
|
|
|
|
name = "rustls-pemfile"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "2.1.1"
|
2024-02-11 19:19:37 +00:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "f48172685e6ff52a556baa527774f61fcaa884f59daf3375c62a3f1cd2549dab"
|
2024-02-11 19:19:37 +00:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"base64 0.21.7",
|
2024-02-11 19:19:37 +00:00
|
|
|
"rustls-pki-types",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "rustls-pki-types"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.4.0"
|
2024-02-11 19:19:37 +00:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "868e20fada228fefaf6b652e00cc73623d54f8171e7352c18bb281571f2d92da"
|
2024-02-11 19:19:37 +00:00
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "rustls-webpki"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.101.7"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"ring 0.17.8",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"untrusted 0.9.0",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
2024-02-11 19:19:37 +00:00
|
|
|
[[package]]
|
|
|
|
|
name = "rustls-webpki"
|
|
|
|
|
version = "0.102.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "faaa0a62740bedb9b2ef5afa303da42764c012f743917351dc9a237ea1663610"
|
|
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"ring 0.17.8",
|
2024-02-11 19:19:37 +00:00
|
|
|
"rustls-pki-types",
|
|
|
|
|
"untrusted 0.9.0",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "rustversion"
|
|
|
|
|
version = "1.0.14"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "ryu"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.0.17"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "same-file"
|
|
|
|
|
version = "1.0.6"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"winapi-util",
|
|
|
|
|
]
|
2023-08-18 08:12:32 -07:00
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "schannel"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.1.23"
|
2023-08-28 14:58:24 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534"
|
2023-08-28 14:58:24 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"windows-sys 0.52.0",
|
2023-08-28 14:58:24 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "schemars"
|
2023-11-15 11:41:12 -06:00
|
|
|
version = "0.8.16"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-11-15 11:41:12 -06:00
|
|
|
checksum = "45a28f4c49489add4ce10783f7911893516f15afe45d015608d41faca6bc4d29"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
2023-09-21 15:22:04 -05:00
|
|
|
"bigdecimal",
|
2023-08-18 08:12:32 -07:00
|
|
|
"bytes",
|
|
|
|
|
"chrono",
|
|
|
|
|
"dyn-clone",
|
|
|
|
|
"schemars_derive",
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_json",
|
|
|
|
|
"url",
|
|
|
|
|
"uuid",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "schemars_derive"
|
2023-11-15 11:41:12 -06:00
|
|
|
version = "0.8.16"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-11-15 11:41:12 -06:00
|
|
|
checksum = "c767fd6fa65d9ccf9cf026122c1b555f2ef9a4f0cea69da4d7dbc3e258d30967"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"serde_derive_internals",
|
2023-08-25 13:41:04 -07:00
|
|
|
"syn 1.0.109",
|
2023-08-18 08:12:32 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
2023-08-24 15:34:51 -07:00
|
|
|
name = "scopeguard"
|
|
|
|
|
version = "1.2.0"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-08-24 15:34:51 -07:00
|
|
|
checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
|
2023-08-18 08:12:32 -07:00
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "sct"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.7.1"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"ring 0.17.8",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"untrusted 0.9.0",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "sdp"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.6.1"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "af90731e1f1150eb1740e35f9832958832a893965b632adc7ad27086077e24c7"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"rand 0.8.5",
|
|
|
|
|
"substring",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"url",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "sec1"
|
|
|
|
|
version = "0.7.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"base16ct",
|
|
|
|
|
"der",
|
|
|
|
|
"generic-array",
|
|
|
|
|
"pkcs8",
|
|
|
|
|
"subtle",
|
|
|
|
|
"zeroize",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "security-framework"
|
|
|
|
|
version = "2.9.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "05b64fb303737d99b81884b2c63433e9ae28abebe5eb5045dcdd175dc2ecf4de"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"bitflags 1.3.2",
|
|
|
|
|
"core-foundation",
|
|
|
|
|
"core-foundation-sys",
|
|
|
|
|
"libc",
|
|
|
|
|
"security-framework-sys",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "security-framework-sys"
|
|
|
|
|
version = "2.9.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "e932934257d3b408ed8f30db49d85ea163bfe74961f017f405b025af298f0c7a"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"core-foundation-sys",
|
|
|
|
|
"libc",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "semver"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.0.22"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "92d43fe69e652f3df9bdc2b85b2854a0825b86e4fb76bc44d945137d053639ca"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
2023-08-24 15:34:51 -07:00
|
|
|
name = "serde"
|
2024-03-08 09:36:35 -08:00
|
|
|
version = "1.0.197"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-08 09:36:35 -08:00
|
|
|
checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
2023-08-24 15:34:51 -07:00
|
|
|
"serde_derive",
|
2023-08-18 08:12:32 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "serde_bytes"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.11.14"
|
2023-08-28 14:58:24 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "8b8497c313fd43ab992087548117643f6fcd935cbf36f176ffda0aacf9591734"
|
2023-08-28 14:58:24 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"serde",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "serde_derive"
|
2024-03-08 09:36:35 -08:00
|
|
|
version = "1.0.197"
|
2023-08-18 08:12:32 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-08 09:36:35 -08:00
|
|
|
checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-08-18 08:12:32 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "serde_derive_internals"
|
|
|
|
|
version = "0.26.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-08-25 13:41:04 -07:00
|
|
|
checksum = "85bf8229e7920a9f636479437026331ce11aa132b4dde37d121944a44d6e5f3c"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"syn 1.0.109",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "serde_json"
|
2024-03-28 11:08:27 -07:00
|
|
|
version = "1.0.115"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-28 11:08:27 -07:00
|
|
|
checksum = "12dc5c46daa8e9fdf4f5e71b6cf9a53f2487da0e86e55808e2d35539666497dd"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"indexmap 2.2.5",
|
2023-08-25 13:41:04 -07:00
|
|
|
"itoa",
|
|
|
|
|
"ryu",
|
|
|
|
|
"serde",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-05 16:02:27 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "serde_repr"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.1.18"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "0b2e6b945e9d3df726b65d6ee24060aff8e3533d431f677a9695db04eff9dfdb"
|
2023-09-05 16:02:27 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-09-05 16:02:27 -07:00
|
|
|
]
|
|
|
|
|
|
2023-10-24 11:24:59 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "serde_spanned"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.6.5"
|
2023-10-24 11:24:59 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "eb3622f419d1296904700073ea6cc23ad690adbd66f13ea683df73298736f0c1"
|
2023-10-24 11:24:59 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"serde",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "serde_tokenstream"
|
|
|
|
|
version = "0.2.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "8a00ffd23fd882d096f09fcaae2a9de8329a328628e86027e049ee051dc1621f"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"serde",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "serde_urlencoded"
|
|
|
|
|
version = "0.7.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"form_urlencoded",
|
|
|
|
|
"itoa",
|
|
|
|
|
"ryu",
|
|
|
|
|
"serde",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "serde_yaml"
|
|
|
|
|
version = "0.8.26"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "578a7433b776b56a35785ed5ce9a7e777ac0598aac5a6dd1b4b18a307c7fc71b"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"indexmap 1.9.3",
|
|
|
|
|
"ryu",
|
|
|
|
|
"serde",
|
|
|
|
|
"yaml-rust",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "sha1"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.10.6"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"cpufeatures",
|
|
|
|
|
"digest",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "sha2"
|
|
|
|
|
version = "0.10.8"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"cpufeatures",
|
|
|
|
|
"digest",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "sharded-slab"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.1.7"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"lazy_static",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "signal-hook-registry"
|
|
|
|
|
version = "1.4.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"libc",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "signature"
|
|
|
|
|
version = "2.2.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"digest",
|
|
|
|
|
"rand_core 0.6.4",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "simd-adler32"
|
|
|
|
|
version = "0.3.7"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "similar"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "2.4.0"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "32fea41aca09ee824cc9724996433064c89f7777e60762749a4170a14abbfa21"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "slab"
|
|
|
|
|
version = "0.4.9"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"autocfg",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "smallvec"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.13.2"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
|
2023-08-24 15:34:51 -07:00
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "smol_str"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.2.1"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "e6845563ada680337a52d43bb0b29f396f2d911616f6573012645b9e3d048a49"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"serde",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "socket2"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.5.6"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "05ffd9c0a93b7543e062e759284fcf5f5e3b098501104bfbdde4d404db792871"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"libc",
|
2024-03-23 15:45:55 -07:00
|
|
|
"windows-sys 0.52.0",
|
2023-08-24 15:34:51 -07:00
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "spin"
|
|
|
|
|
version = "0.5.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "spin"
|
|
|
|
|
version = "0.9.8"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"lock_api",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "spki"
|
|
|
|
|
version = "0.7.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"base64ct",
|
|
|
|
|
"der",
|
2023-09-12 14:59:40 -07:00
|
|
|
]
|
|
|
|
|
|
2024-02-15 13:56:31 -08:00
|
|
|
[[package]]
|
|
|
|
|
name = "str_indices"
|
|
|
|
|
version = "0.4.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "e9557cb6521e8d009c51a8666f09356f4b817ba9ba0981a305bd86aee47bd35c"
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "strsim"
|
2024-02-11 11:09:03 -08:00
|
|
|
version = "0.11.0"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 11:09:03 -08:00
|
|
|
checksum = "5ee073c9e4cd00e28217186dbe12796d692868f432bf2e97ee73bed0c56dfa01"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-08-18 19:37:52 +10:00
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "structmeta"
|
|
|
|
|
version = "0.2.0"
|
2023-08-18 19:37:52 +10:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-08-18 08:12:32 -07:00
|
|
|
checksum = "78ad9e09554f0456d67a69c1584c9798ba733a5b50349a6c0d0948710523922d"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-02-11 12:09:50 -08:00
|
|
|
"structmeta-derive 0.2.0",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2024-02-11 12:09:50 -08:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "structmeta"
|
|
|
|
|
version = "0.3.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "2e1575d8d40908d70f6fd05537266b90ae71b15dbbe7a8b7dffa2b759306d329"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"structmeta-derive 0.3.0",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-08-18 08:12:32 -07:00
|
|
|
]
|
2023-08-18 19:37:52 +10:00
|
|
|
|
|
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "structmeta-derive"
|
2023-08-18 19:37:52 +10:00
|
|
|
version = "0.2.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-08-18 08:12:32 -07:00
|
|
|
checksum = "a60bcaff7397072dca0017d1db428e30d5002e00b6847703e2e42005c95fbe00"
|
2023-08-18 19:37:52 +10:00
|
|
|
dependencies = [
|
2023-08-18 08:12:32 -07:00
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-08-18 19:37:52 +10:00
|
|
|
]
|
|
|
|
|
|
2024-02-11 12:09:50 -08:00
|
|
|
[[package]]
|
|
|
|
|
name = "structmeta-derive"
|
|
|
|
|
version = "0.3.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "152a0b65a590ff6c3da95cabe2353ee04e6167c896b28e3b14478c2636c922fc"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2024-02-11 12:09:50 -08:00
|
|
|
]
|
|
|
|
|
|
2023-09-21 15:02:23 -05:00
|
|
|
[[package]]
|
|
|
|
|
name = "strum"
|
|
|
|
|
version = "0.24.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"strum_macros",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "strum_macros"
|
|
|
|
|
version = "0.24.3"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
|
|
|
|
|
dependencies = [
|
2024-03-21 03:57:58 +00:00
|
|
|
"heck 0.4.1",
|
2023-09-21 15:02:23 -05:00
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"rustversion",
|
|
|
|
|
"syn 1.0.109",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "stun"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.5.1"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "d3f371788132e9d623e6eab4ba28aac083763a4133f045e6ebaee5ceb869803d"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"base64 0.21.7",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"crc",
|
|
|
|
|
"lazy_static",
|
|
|
|
|
"md-5",
|
|
|
|
|
"rand 0.8.5",
|
2024-03-23 15:45:55 -07:00
|
|
|
"ring 0.17.8",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"subtle",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"tokio",
|
|
|
|
|
"url",
|
|
|
|
|
"webrtc-util",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "substring"
|
|
|
|
|
version = "1.4.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "42ee6433ecef213b2e72f587ef64a2f5943e7cd16fbd82dbe8bc07486c534c86"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"autocfg",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "subtle"
|
|
|
|
|
version = "2.5.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
|
|
|
|
|
|
2023-02-21 09:42:41 +11:00
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "syn"
|
2023-08-25 13:41:04 -07:00
|
|
|
version = "1.0.109"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-08-25 13:41:04 -07:00
|
|
|
checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"unicode-ident",
|
|
|
|
|
]
|
2023-02-21 09:42:41 +11:00
|
|
|
|
2023-07-20 12:38:05 +10:00
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "syn"
|
2024-03-27 10:16:56 -07:00
|
|
|
version = "2.0.55"
|
2023-07-20 12:38:05 +10:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-27 10:16:56 -07:00
|
|
|
checksum = "002a1b3dbf967edfafc32655d0f377ab0bb7b994aa1d32c8cc7e9b8bf3ebb8f0"
|
2023-07-20 12:38:05 +10:00
|
|
|
dependencies = [
|
2023-08-18 08:12:32 -07:00
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"unicode-ident",
|
2023-07-20 12:38:05 +10:00
|
|
|
]
|
|
|
|
|
|
2024-02-11 19:40:06 +00:00
|
|
|
[[package]]
|
|
|
|
|
name = "sync_wrapper"
|
|
|
|
|
version = "0.1.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "synstructure"
|
|
|
|
|
version = "0.12.6"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "f36bdaa60a83aca3921b5259d5400cbf5e90fc51931376a9bd4a0eb79aa7210f"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"syn 1.0.109",
|
|
|
|
|
"unicode-xid",
|
|
|
|
|
]
|
|
|
|
|
|
2023-11-09 16:39:12 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "synstructure"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.13.1"
|
2023-11-09 16:39:12 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
|
2023-11-09 16:39:12 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-11-09 16:39:12 -06:00
|
|
|
]
|
|
|
|
|
|
2023-10-03 07:20:08 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "system-configuration"
|
2024-03-12 23:43:06 -07:00
|
|
|
version = "0.5.1"
|
2023-10-03 07:20:08 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-12 23:43:06 -07:00
|
|
|
checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
|
2023-10-03 07:20:08 -07:00
|
|
|
dependencies = [
|
2024-03-12 23:43:06 -07:00
|
|
|
"bitflags 1.3.2",
|
2023-10-03 07:20:08 -07:00
|
|
|
"core-foundation",
|
|
|
|
|
"system-configuration-sys",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "system-configuration-sys"
|
2024-03-12 23:43:06 -07:00
|
|
|
version = "0.5.0"
|
2023-10-03 07:20:08 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-12 23:43:06 -07:00
|
|
|
checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9"
|
2023-10-03 07:20:08 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"core-foundation-sys",
|
|
|
|
|
"libc",
|
|
|
|
|
]
|
|
|
|
|
|
2024-01-29 17:36:29 +11:00
|
|
|
[[package]]
|
|
|
|
|
name = "tabled"
|
2024-02-06 22:44:30 +11:00
|
|
|
version = "0.15.0"
|
2024-01-29 17:36:29 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-06 22:44:30 +11:00
|
|
|
checksum = "4c998b0c8b921495196a48aabaf1901ff28be0760136e31604f7967b0792050e"
|
2024-01-29 17:36:29 +11:00
|
|
|
dependencies = [
|
|
|
|
|
"papergrid",
|
|
|
|
|
"tabled_derive",
|
|
|
|
|
"unicode-width",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "tabled_derive"
|
2024-02-06 22:44:30 +11:00
|
|
|
version = "0.7.0"
|
2024-01-29 17:36:29 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-06 22:44:30 +11:00
|
|
|
checksum = "4c138f99377e5d653a371cdad263615634cfc8467685dfe8e73e2b8e98f44b17"
|
2024-01-29 17:36:29 +11:00
|
|
|
dependencies = [
|
2024-03-21 03:57:58 +00:00
|
|
|
"heck 0.4.1",
|
2024-01-29 17:36:29 +11:00
|
|
|
"proc-macro-error",
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
|
|
|
|
"syn 1.0.109",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "tap"
|
|
|
|
|
version = "1.0.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "task-local-extensions"
|
|
|
|
|
version = "0.1.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "ba323866e5d033818e3240feeb9f7db2c4296674e4d9e16b97b7bf8f490434e8"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"pin-utils",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "tempfile"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "3.10.1"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"fastrand",
|
2023-09-18 18:22:25 -06:00
|
|
|
"rustix",
|
2024-03-23 15:45:55 -07:00
|
|
|
"windows-sys 0.52.0",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-19 23:18:54 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "termcolor"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.4.1"
|
2023-08-19 23:18:54 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
|
2023-08-19 23:18:54 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"winapi-util",
|
|
|
|
|
]
|
|
|
|
|
|
2023-02-21 09:42:41 +11:00
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "thiserror"
|
2024-03-20 17:06:42 -07:00
|
|
|
version = "1.0.58"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-20 17:06:42 -07:00
|
|
|
checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"thiserror-impl",
|
|
|
|
|
]
|
2023-02-21 09:42:41 +11:00
|
|
|
|
2023-08-18 19:37:52 +10:00
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "thiserror-impl"
|
2024-03-20 17:06:42 -07:00
|
|
|
version = "1.0.58"
|
2023-08-18 19:37:52 +10:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-20 17:06:42 -07:00
|
|
|
checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7"
|
2023-08-18 08:12:32 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-08-18 08:12:32 -07:00
|
|
|
]
|
2023-08-18 19:37:52 +10:00
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "thread_local"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.1.8"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"once_cell",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "tiff"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.9.1"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "ba1310fcea54c6a9a4fd1aad794ecc02c31682f6bfbecdf460bf19533eed1e3e"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"flate2",
|
|
|
|
|
"jpeg-decoder",
|
|
|
|
|
"weezl",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "time"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.3.34"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "c8248b6521bb14bc45b4067159b9b6ad792e2d6d754d6c41fb50e29fefe38749"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"deranged",
|
|
|
|
|
"itoa",
|
2024-03-23 15:45:55 -07:00
|
|
|
"num-conv",
|
2023-10-24 11:24:59 -07:00
|
|
|
"powerfmt",
|
2023-08-25 13:41:04 -07:00
|
|
|
"serde",
|
|
|
|
|
"time-core",
|
|
|
|
|
"time-macros",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "time-core"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.1.2"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "time-macros"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.2.17"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "7ba3a3ef41e6672a2f0f001392bb5dcd3ff0a9992d618ca761a11c3121547774"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"num-conv",
|
2023-08-25 13:41:04 -07:00
|
|
|
"time-core",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-20 13:15:28 -05:00
|
|
|
[[package]]
|
|
|
|
|
name = "tinytemplate"
|
|
|
|
|
version = "1.2.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_json",
|
|
|
|
|
]
|
|
|
|
|
|
2023-02-21 09:42:41 +11:00
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "tinyvec"
|
|
|
|
|
version = "1.6.0"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-08-18 08:12:32 -07:00
|
|
|
checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
|
2023-02-21 09:42:41 +11:00
|
|
|
dependencies = [
|
2023-08-18 08:12:32 -07:00
|
|
|
"tinyvec_macros",
|
2023-02-21 09:42:41 +11:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "tinyvec_macros"
|
|
|
|
|
version = "0.1.1"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-08-18 08:12:32 -07:00
|
|
|
checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
|
2023-02-21 09:42:41 +11:00
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "tokio"
|
2024-02-11 12:10:17 -08:00
|
|
|
version = "1.36.0"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 12:10:17 -08:00
|
|
|
checksum = "61285f6515fa018fb2d1e46eb21223fff441ee8db5d0f1435e8ab4f5cdb80931"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"backtrace",
|
|
|
|
|
"bytes",
|
|
|
|
|
"libc",
|
|
|
|
|
"mio",
|
|
|
|
|
"num_cpus",
|
2023-09-12 14:59:40 -07:00
|
|
|
"parking_lot 0.12.1",
|
2023-08-24 15:34:51 -07:00
|
|
|
"pin-project-lite",
|
|
|
|
|
"signal-hook-registry",
|
2024-03-23 15:45:55 -07:00
|
|
|
"socket2",
|
2023-08-24 15:34:51 -07:00
|
|
|
"tokio-macros",
|
2023-08-25 13:41:04 -07:00
|
|
|
"windows-sys 0.48.0",
|
2023-08-24 15:34:51 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "tokio-macros"
|
2023-11-10 05:24:40 -05:00
|
|
|
version = "2.2.0"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-11-10 05:24:40 -05:00
|
|
|
checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "tokio-native-tls"
|
|
|
|
|
version = "0.3.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"native-tls",
|
|
|
|
|
"tokio",
|
2023-08-24 15:34:51 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "tokio-rustls"
|
|
|
|
|
version = "0.24.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
|
|
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"rustls 0.21.10",
|
2023-08-25 13:41:04 -07:00
|
|
|
"tokio",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
2024-02-11 19:19:37 +00:00
|
|
|
name = "tokio-rustls"
|
|
|
|
|
version = "0.25.0"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 19:19:37 +00:00
|
|
|
checksum = "775e0c0f0adb3a2f22a00c4745d728b479985fc15ee7ca6a2608388c5569860f"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
2024-02-11 19:19:37 +00:00
|
|
|
"rustls 0.22.2",
|
|
|
|
|
"rustls-pki-types",
|
2023-08-24 15:34:51 -07:00
|
|
|
"tokio",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "tokio-tungstenite"
|
|
|
|
|
version = "0.21.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "c83b561d025642014097b66e6c1bb422783339e0909e4429cde4749d1990bc38"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"futures-util",
|
|
|
|
|
"log",
|
2024-02-11 19:19:37 +00:00
|
|
|
"rustls 0.22.2",
|
|
|
|
|
"rustls-native-certs",
|
|
|
|
|
"rustls-pki-types",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"tokio",
|
2024-02-11 19:19:37 +00:00
|
|
|
"tokio-rustls 0.25.0",
|
|
|
|
|
"tungstenite",
|
2023-08-24 15:34:51 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "tokio-util"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.7.10"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"bytes",
|
|
|
|
|
"futures-core",
|
|
|
|
|
"futures-sink",
|
|
|
|
|
"pin-project-lite",
|
|
|
|
|
"tokio",
|
|
|
|
|
"tracing",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "toml"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.8.12"
|
2023-10-24 11:24:59 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "e9dd1545e8208b4a5af1aa9bbd0b4cf7e9ea08fabc5d0a5c67fcaafa17433aa3"
|
2023-10-24 11:24:59 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_spanned",
|
|
|
|
|
"toml_datetime",
|
|
|
|
|
"toml_edit",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "toml_datetime"
|
|
|
|
|
version = "0.6.5"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"serde",
|
|
|
|
|
]
|
|
|
|
|
|
2023-10-24 11:24:59 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "toml_edit"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.22.9"
|
2023-10-24 11:24:59 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "8e40bb779c5187258fd7aad0eb68cb8706a0a81fa712fbea808ab43c4b8374c4"
|
2023-10-24 11:24:59 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"indexmap 2.2.5",
|
2023-10-24 11:24:59 -07:00
|
|
|
"serde",
|
|
|
|
|
"serde_spanned",
|
|
|
|
|
"toml_datetime",
|
2024-03-23 15:45:55 -07:00
|
|
|
"winnow 0.6.5",
|
2023-10-24 11:24:59 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "toolchain_find"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.4.0"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "ebc8c9a7f0a2966e1acdaf0461023d0b01471eeead645370cf4c3f5cff153f2a"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"home",
|
2023-10-24 11:24:59 -07:00
|
|
|
"once_cell",
|
2023-08-25 13:41:04 -07:00
|
|
|
"regex",
|
|
|
|
|
"semver",
|
|
|
|
|
"walkdir",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-05 16:02:27 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "tower"
|
|
|
|
|
version = "0.4.13"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"futures-core",
|
|
|
|
|
"futures-util",
|
|
|
|
|
"pin-project",
|
|
|
|
|
"pin-project-lite",
|
|
|
|
|
"tower-layer",
|
|
|
|
|
"tower-service",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "tower-layer"
|
|
|
|
|
version = "0.3.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "tower-lsp"
|
|
|
|
|
version = "0.20.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d4ba052b54a6627628d9b3c34c176e7eda8359b7da9acd497b9f20998d118508"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"async-codec-lite",
|
|
|
|
|
"async-trait",
|
|
|
|
|
"auto_impl",
|
|
|
|
|
"bytes",
|
|
|
|
|
"dashmap",
|
|
|
|
|
"futures",
|
|
|
|
|
"httparse",
|
|
|
|
|
"lsp-types",
|
|
|
|
|
"memchr",
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_json",
|
|
|
|
|
"tokio",
|
|
|
|
|
"tokio-util",
|
|
|
|
|
"tower",
|
|
|
|
|
"tower-lsp-macros",
|
|
|
|
|
"tracing",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "tower-lsp-macros"
|
|
|
|
|
version = "0.9.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "84fd902d4e0b9a4b27f2f440108dc034e1758628a9b702f8ec61ad66355422fa"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-09-05 16:02:27 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "tower-service"
|
|
|
|
|
version = "0.3.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "tracing"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.1.40"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"pin-project-lite",
|
2023-09-05 16:02:27 -07:00
|
|
|
"tracing-attributes",
|
2023-08-25 13:41:04 -07:00
|
|
|
"tracing-core",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-05 16:02:27 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "tracing-attributes"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.1.27"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
|
2023-09-05 16:02:27 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-09-05 16:02:27 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "tracing-core"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.1.32"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"once_cell",
|
2023-09-12 14:59:40 -07:00
|
|
|
"valuable",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "tracing-log"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.1.4"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "f751112709b4e791d8ce53e32c4ed2d353565a795ce84da2285393f41557bdf2"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"log",
|
2023-10-24 11:24:59 -07:00
|
|
|
"once_cell",
|
2023-09-12 14:59:40 -07:00
|
|
|
"tracing-core",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "tracing-opentelemetry"
|
|
|
|
|
version = "0.17.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "fbbe89715c1dbbb790059e2565353978564924ee85017b5fff365c872ff6721f"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"once_cell",
|
|
|
|
|
"opentelemetry",
|
|
|
|
|
"tracing",
|
|
|
|
|
"tracing-core",
|
|
|
|
|
"tracing-log",
|
|
|
|
|
"tracing-subscriber",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "tracing-subscriber"
|
2024-01-08 21:22:53 -06:00
|
|
|
version = "0.3.18"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-01-08 21:22:53 -06:00
|
|
|
checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"sharded-slab",
|
|
|
|
|
"thread_local",
|
|
|
|
|
"tracing-core",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "try-lock"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.2.5"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-08-19 23:18:54 -07:00
|
|
|
[[package]]
|
2024-01-11 15:31:35 -08:00
|
|
|
name = "ts-rs"
|
2024-02-11 12:59:00 +11:00
|
|
|
version = "7.1.1"
|
2023-08-29 12:35:45 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 12:59:00 +11:00
|
|
|
checksum = "fc2cae1fc5d05d47aa24b64f9a4f7cba24cdc9187a2084dd97ac57bef5eccae6"
|
2023-08-19 23:18:54 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"thiserror",
|
|
|
|
|
"ts-rs-macros",
|
|
|
|
|
"uuid",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "ts-rs-macros"
|
2024-02-11 12:59:00 +11:00
|
|
|
version = "7.1.1"
|
2023-08-29 12:35:45 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-11 12:59:00 +11:00
|
|
|
checksum = "73f7f9b821696963053a89a7bd8b292dc34420aea8294d7b225274d488f3ec92"
|
2023-08-19 23:18:54 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"Inflector",
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-08-19 23:18:54 -07:00
|
|
|
"termcolor",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "tungstenite"
|
|
|
|
|
version = "0.21.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "9ef1a641ea34f399a848dea702823bbecfb4c486f911735368f1f137cb8257e1"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"byteorder",
|
|
|
|
|
"bytes",
|
|
|
|
|
"data-encoding",
|
2024-03-23 15:45:55 -07:00
|
|
|
"http 1.1.0",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"httparse",
|
|
|
|
|
"log",
|
|
|
|
|
"rand 0.8.5",
|
2024-02-11 19:19:37 +00:00
|
|
|
"rustls 0.22.2",
|
|
|
|
|
"rustls-pki-types",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"sha1",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"url",
|
|
|
|
|
"utf-8",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "turn"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.7.1"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "ffb2ac4f331064513ad510b7a36edc0df555bd61672986607f7c9ff46f98f415"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"async-trait",
|
2024-03-23 15:45:55 -07:00
|
|
|
"base64 0.21.7",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"futures",
|
|
|
|
|
"log",
|
|
|
|
|
"md-5",
|
|
|
|
|
"rand 0.8.5",
|
2024-03-23 15:45:55 -07:00
|
|
|
"ring 0.17.8",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"stun",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"tokio",
|
2024-03-23 15:45:55 -07:00
|
|
|
"tokio-util",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"webrtc-util",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "twenty-twenty"
|
2024-01-08 21:22:53 -06:00
|
|
|
version = "0.7.0"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-01-08 21:22:53 -06:00
|
|
|
checksum = "89a5e28c4bcd7c383369d2c546aee1690febefcfc51b051e098fb8233cb9c08e"
|
2023-09-12 14:59:40 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"anyhow",
|
|
|
|
|
"image",
|
|
|
|
|
"image-compare",
|
|
|
|
|
"uuid",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "typenum"
|
2023-09-18 18:22:25 -06:00
|
|
|
version = "1.17.0"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-09-18 18:22:25 -06:00
|
|
|
checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
|
2023-08-24 15:34:51 -07:00
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "unicase"
|
|
|
|
|
version = "2.7.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"version_check",
|
|
|
|
|
]
|
|
|
|
|
|
2023-02-21 09:42:41 +11:00
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "unicode-bidi"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.3.15"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
|
2023-02-21 09:42:41 +11:00
|
|
|
|
|
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "unicode-ident"
|
2023-09-18 18:22:25 -06:00
|
|
|
version = "1.0.12"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-09-18 18:22:25 -06:00
|
|
|
checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
|
2023-02-21 09:42:41 +11:00
|
|
|
|
2023-07-20 12:38:05 +10:00
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "unicode-normalization"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.1.23"
|
2023-07-20 12:38:05 +10:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
|
2023-07-20 12:38:05 +10:00
|
|
|
dependencies = [
|
2023-08-18 08:12:32 -07:00
|
|
|
"tinyvec",
|
2023-07-20 12:38:05 +10:00
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "unicode-segmentation"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "1.11.0"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "unicode-width"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.1.11"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-11-09 16:39:12 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "unicode-xid"
|
|
|
|
|
version = "0.2.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "universal-hash"
|
|
|
|
|
version = "0.5.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"crypto-common",
|
|
|
|
|
"subtle",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "untrusted"
|
|
|
|
|
version = "0.7.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "untrusted"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.9.0"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-02-21 09:42:41 +11:00
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "url"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "2.5.0"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
|
2023-02-21 09:42:41 +11:00
|
|
|
dependencies = [
|
2023-08-18 08:12:32 -07:00
|
|
|
"form_urlencoded",
|
|
|
|
|
"idna",
|
|
|
|
|
"percent-encoding",
|
|
|
|
|
"serde",
|
2023-02-21 09:42:41 +11:00
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "utf-8"
|
|
|
|
|
version = "0.7.6"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
|
|
|
|
|
|
2023-09-05 16:02:27 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "utf8parse"
|
|
|
|
|
version = "0.2.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
|
|
|
|
|
|
2023-07-20 12:38:05 +10:00
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "uuid"
|
2024-03-20 17:07:15 -07:00
|
|
|
version = "1.8.0"
|
2023-07-20 12:38:05 +10:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-20 17:07:15 -07:00
|
|
|
checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
|
2023-07-20 12:38:05 +10:00
|
|
|
dependencies = [
|
2023-10-23 14:03:38 -07:00
|
|
|
"atomic",
|
2023-08-18 08:12:32 -07:00
|
|
|
"getrandom",
|
|
|
|
|
"serde",
|
|
|
|
|
"wasm-bindgen",
|
2023-07-20 12:38:05 +10:00
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "valuable"
|
|
|
|
|
version = "0.1.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "vcpkg"
|
|
|
|
|
version = "0.2.15"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "version_check"
|
|
|
|
|
version = "0.9.4"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "waitgroup"
|
|
|
|
|
version = "0.1.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d1f50000a783467e6c0200f9d10642f4bc424e39efc1b770203e88b488f79292"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"atomic-waker",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "walkdir"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "2.5.0"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"same-file",
|
|
|
|
|
"winapi-util",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "want"
|
|
|
|
|
version = "0.3.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"try-lock",
|
|
|
|
|
]
|
|
|
|
|
|
2023-02-21 09:42:41 +11:00
|
|
|
[[package]]
|
2023-08-18 08:12:32 -07:00
|
|
|
name = "wasi"
|
|
|
|
|
version = "0.11.0+wasi-snapshot-preview1"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-08-18 08:12:32 -07:00
|
|
|
checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
|
2023-02-21 09:42:41 +11:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "wasm-bindgen"
|
2024-03-05 20:22:54 +00:00
|
|
|
version = "0.2.92"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-05 20:22:54 +00:00
|
|
|
checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
|
2023-02-21 09:42:41 +11:00
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"wasm-bindgen-macro",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "wasm-bindgen-backend"
|
2024-03-05 20:22:54 +00:00
|
|
|
version = "0.2.92"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-05 20:22:54 +00:00
|
|
|
checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
|
2023-02-21 09:42:41 +11:00
|
|
|
dependencies = [
|
|
|
|
|
"bumpalo",
|
|
|
|
|
"log",
|
|
|
|
|
"once_cell",
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-02-21 09:42:41 +11:00
|
|
|
"wasm-bindgen-shared",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "wasm-bindgen-futures"
|
2024-03-08 09:36:56 -08:00
|
|
|
version = "0.4.42"
|
2023-08-24 15:34:51 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-08 09:36:56 -08:00
|
|
|
checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0"
|
2023-08-24 15:34:51 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
2023-09-05 16:02:27 -07:00
|
|
|
"futures-core",
|
2023-08-24 15:34:51 -07:00
|
|
|
"js-sys",
|
|
|
|
|
"wasm-bindgen",
|
|
|
|
|
"web-sys",
|
|
|
|
|
]
|
|
|
|
|
|
2023-02-21 09:42:41 +11:00
|
|
|
[[package]]
|
|
|
|
|
name = "wasm-bindgen-macro"
|
2024-03-05 20:22:54 +00:00
|
|
|
version = "0.2.92"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-05 20:22:54 +00:00
|
|
|
checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
|
2023-02-21 09:42:41 +11:00
|
|
|
dependencies = [
|
|
|
|
|
"quote",
|
|
|
|
|
"wasm-bindgen-macro-support",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "wasm-bindgen-macro-support"
|
2024-03-05 20:22:54 +00:00
|
|
|
version = "0.2.92"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-05 20:22:54 +00:00
|
|
|
checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
|
2023-02-21 09:42:41 +11:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-02-21 09:42:41 +11:00
|
|
|
"wasm-bindgen-backend",
|
|
|
|
|
"wasm-bindgen-shared",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "wasm-bindgen-shared"
|
2024-03-05 20:22:54 +00:00
|
|
|
version = "0.2.92"
|
2023-02-21 09:42:41 +11:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-05 20:22:54 +00:00
|
|
|
checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
|
2023-02-21 09:42:41 +11:00
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "wasm-lib"
|
|
|
|
|
version = "0.1.0"
|
|
|
|
|
dependencies = [
|
2023-09-12 14:59:40 -07:00
|
|
|
"anyhow",
|
2023-08-28 14:58:24 -07:00
|
|
|
"bson",
|
2024-03-11 17:50:31 -07:00
|
|
|
"console_error_panic_hook",
|
2023-09-05 16:02:27 -07:00
|
|
|
"futures",
|
2023-08-18 19:37:52 +10:00
|
|
|
"gloo-utils",
|
2023-09-12 14:59:40 -07:00
|
|
|
"image",
|
2023-09-05 16:02:27 -07:00
|
|
|
"js-sys",
|
2023-08-29 12:35:45 -07:00
|
|
|
"kcl-lib",
|
2023-08-18 08:12:32 -07:00
|
|
|
"kittycad",
|
2023-09-17 21:57:43 -07:00
|
|
|
"pretty_assertions",
|
2023-09-12 14:59:40 -07:00
|
|
|
"reqwest",
|
2023-02-21 09:42:41 +11:00
|
|
|
"serde_json",
|
2023-09-12 14:59:40 -07:00
|
|
|
"tokio",
|
2023-09-05 16:02:27 -07:00
|
|
|
"tower-lsp",
|
2023-09-12 14:59:40 -07:00
|
|
|
"twenty-twenty",
|
|
|
|
|
"uuid",
|
2023-08-18 19:37:52 +10:00
|
|
|
"wasm-bindgen",
|
2023-08-24 15:34:51 -07:00
|
|
|
"wasm-bindgen-futures",
|
2023-09-05 16:02:27 -07:00
|
|
|
"wasm-streams",
|
|
|
|
|
"web-sys",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "wasm-streams"
|
2023-11-01 08:43:18 -05:00
|
|
|
version = "0.4.0"
|
2023-09-05 16:02:27 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-11-01 08:43:18 -05:00
|
|
|
checksum = "b65dc4c90b63b118468cf747d8bf3566c1913ef60be765b5730ead9e0a3ba129"
|
2023-09-05 16:02:27 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"futures-util",
|
|
|
|
|
"js-sys",
|
|
|
|
|
"wasm-bindgen",
|
|
|
|
|
"wasm-bindgen-futures",
|
|
|
|
|
"web-sys",
|
2023-08-18 19:37:52 +10:00
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "wasm-timer"
|
|
|
|
|
version = "0.2.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "be0ecb0db480561e9a7642b5d3e4187c128914e58aa84330b9493e3eb68c5e7f"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"futures",
|
|
|
|
|
"js-sys",
|
|
|
|
|
"parking_lot 0.11.2",
|
|
|
|
|
"pin-utils",
|
|
|
|
|
"wasm-bindgen",
|
|
|
|
|
"wasm-bindgen-futures",
|
|
|
|
|
"web-sys",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 19:37:52 +10:00
|
|
|
[[package]]
|
|
|
|
|
name = "web-sys"
|
2024-03-07 20:11:07 +00:00
|
|
|
version = "0.3.69"
|
2023-08-18 19:37:52 +10:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-07 20:11:07 +00:00
|
|
|
checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
|
2023-08-18 19:37:52 +10:00
|
|
|
dependencies = [
|
|
|
|
|
"js-sys",
|
2023-02-21 09:42:41 +11:00
|
|
|
"wasm-bindgen",
|
|
|
|
|
]
|
2023-08-18 19:37:52 +10:00
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "webpki-roots"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.25.4"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "webrtc"
|
|
|
|
|
version = "0.9.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "d91e7cf018f7185552bf6a5dd839f4ed9827aea33b746763c9a215f84a0d0b34"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"arc-swap",
|
|
|
|
|
"async-trait",
|
|
|
|
|
"bytes",
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"hex",
|
|
|
|
|
"interceptor",
|
|
|
|
|
"lazy_static",
|
|
|
|
|
"log",
|
|
|
|
|
"rand 0.8.5",
|
|
|
|
|
"rcgen",
|
|
|
|
|
"regex",
|
|
|
|
|
"ring 0.16.20",
|
|
|
|
|
"rtcp",
|
2024-03-23 15:45:55 -07:00
|
|
|
"rtp 0.9.0",
|
|
|
|
|
"rustls 0.21.10",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"sdp",
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_json",
|
|
|
|
|
"sha2",
|
|
|
|
|
"smol_str",
|
|
|
|
|
"stun",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"time",
|
|
|
|
|
"tokio",
|
|
|
|
|
"turn",
|
|
|
|
|
"url",
|
|
|
|
|
"waitgroup",
|
|
|
|
|
"webrtc-data",
|
|
|
|
|
"webrtc-dtls",
|
|
|
|
|
"webrtc-ice",
|
|
|
|
|
"webrtc-mdns",
|
|
|
|
|
"webrtc-media",
|
|
|
|
|
"webrtc-sctp",
|
|
|
|
|
"webrtc-srtp",
|
|
|
|
|
"webrtc-util",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "webrtc-data"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.8.1"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "e8c08e648e10572b9edbe741074e0f4d3cb221aa7cdf9a814ee71606de312f33"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"bytes",
|
|
|
|
|
"log",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"tokio",
|
|
|
|
|
"webrtc-sctp",
|
|
|
|
|
"webrtc-util",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "webrtc-dtls"
|
|
|
|
|
version = "0.8.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "32b140b953f986e97828aa33ec6318186b05d862bee689efbc57af04a243e832"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"aes",
|
|
|
|
|
"aes-gcm",
|
|
|
|
|
"async-trait",
|
|
|
|
|
"bincode",
|
|
|
|
|
"byteorder",
|
|
|
|
|
"cbc",
|
|
|
|
|
"ccm",
|
|
|
|
|
"der-parser",
|
|
|
|
|
"hkdf",
|
|
|
|
|
"hmac",
|
|
|
|
|
"log",
|
|
|
|
|
"p256",
|
|
|
|
|
"p384",
|
|
|
|
|
"rand 0.8.5",
|
|
|
|
|
"rand_core 0.6.4",
|
|
|
|
|
"rcgen",
|
|
|
|
|
"ring 0.16.20",
|
2024-03-23 15:45:55 -07:00
|
|
|
"rustls 0.21.10",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"sec1",
|
|
|
|
|
"serde",
|
|
|
|
|
"sha1",
|
|
|
|
|
"sha2",
|
|
|
|
|
"subtle",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"tokio",
|
|
|
|
|
"webrtc-util",
|
|
|
|
|
"x25519-dalek",
|
|
|
|
|
"x509-parser",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "webrtc-ice"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.10.1"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "a1bbd6b3dea22cc6e961e22b012e843d8869e2ac8e76b96e54d4a25e311857ad"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"arc-swap",
|
|
|
|
|
"async-trait",
|
|
|
|
|
"crc",
|
|
|
|
|
"log",
|
|
|
|
|
"rand 0.8.5",
|
|
|
|
|
"serde",
|
|
|
|
|
"serde_json",
|
|
|
|
|
"stun",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"tokio",
|
|
|
|
|
"turn",
|
|
|
|
|
"url",
|
|
|
|
|
"uuid",
|
|
|
|
|
"waitgroup",
|
|
|
|
|
"webrtc-mdns",
|
|
|
|
|
"webrtc-util",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "webrtc-mdns"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.6.1"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "ce981f93104a8debb3563bb0cedfe4aa2f351fdf6b53f346ab50009424125c08"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"log",
|
2024-03-23 15:45:55 -07:00
|
|
|
"socket2",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"thiserror",
|
|
|
|
|
"tokio",
|
|
|
|
|
"webrtc-util",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "webrtc-media"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.7.1"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "280017b6b9625ef7329146332518b339c3cceff231cc6f6a9e0e6acab25ca4af"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"byteorder",
|
|
|
|
|
"bytes",
|
|
|
|
|
"rand 0.8.5",
|
2024-03-23 15:45:55 -07:00
|
|
|
"rtp 0.10.0",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"thiserror",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "webrtc-sctp"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.9.1"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "df75ec042002fe995194712cbeb2029107a60a7eab646f1b789eb1be94d0e367"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"arc-swap",
|
|
|
|
|
"async-trait",
|
|
|
|
|
"bytes",
|
|
|
|
|
"crc",
|
|
|
|
|
"log",
|
|
|
|
|
"rand 0.8.5",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"tokio",
|
|
|
|
|
"webrtc-util",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "webrtc-srtp"
|
|
|
|
|
version = "0.11.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "c1db1f36c1c81e4b1e531c0b9678ba0c93809e196ce62122d87259bb71c03b9f"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"aead",
|
|
|
|
|
"aes",
|
|
|
|
|
"aes-gcm",
|
|
|
|
|
"byteorder",
|
|
|
|
|
"bytes",
|
|
|
|
|
"ctr",
|
|
|
|
|
"hmac",
|
|
|
|
|
"log",
|
|
|
|
|
"rtcp",
|
2024-03-23 15:45:55 -07:00
|
|
|
"rtp 0.9.0",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
"sha1",
|
|
|
|
|
"subtle",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"tokio",
|
|
|
|
|
"webrtc-util",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "webrtc-util"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.8.1"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "5e85154ef743d9a2a116d104faaaa82740a281b8b4bed5ee691a2df6c133d873"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"async-trait",
|
|
|
|
|
"bitflags 1.3.2",
|
|
|
|
|
"bytes",
|
|
|
|
|
"ipnet",
|
|
|
|
|
"lazy_static",
|
|
|
|
|
"libc",
|
|
|
|
|
"log",
|
|
|
|
|
"nix",
|
|
|
|
|
"rand 0.8.5",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"tokio",
|
|
|
|
|
"winapi",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "weezl"
|
2024-02-29 19:57:37 -08:00
|
|
|
version = "0.1.8"
|
2023-09-12 14:59:40 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-29 19:57:37 -08:00
|
|
|
checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"
|
2023-09-12 14:59:40 -07:00
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "winapi"
|
|
|
|
|
version = "0.3.9"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"winapi-i686-pc-windows-gnu",
|
|
|
|
|
"winapi-x86_64-pc-windows-gnu",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "winapi-i686-pc-windows-gnu"
|
|
|
|
|
version = "0.4.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
|
|
|
|
|
|
2023-08-19 23:18:54 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "winapi-util"
|
2023-10-24 11:24:59 -07:00
|
|
|
version = "0.1.6"
|
2023-08-19 23:18:54 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2023-10-24 11:24:59 -07:00
|
|
|
checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596"
|
2023-08-19 23:18:54 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"winapi",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 08:12:32 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "winapi-x86_64-pc-windows-gnu"
|
|
|
|
|
version = "0.4.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
2023-10-24 11:24:59 -07:00
|
|
|
name = "windows-core"
|
2024-01-08 21:22:53 -06:00
|
|
|
version = "0.52.0"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-01-08 21:22:53 -06:00
|
|
|
checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"windows-targets 0.52.4",
|
2023-08-25 13:41:04 -07:00
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows-sys"
|
|
|
|
|
version = "0.48.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
|
|
|
|
|
dependencies = [
|
2023-08-25 13:41:04 -07:00
|
|
|
"windows-targets 0.48.5",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
2024-03-23 15:45:55 -07:00
|
|
|
name = "windows-sys"
|
|
|
|
|
version = "0.52.0"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
|
2023-08-25 13:41:04 -07:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"windows-targets 0.52.4",
|
2023-08-24 15:34:51 -07:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "windows-targets"
|
|
|
|
|
version = "0.48.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
|
|
|
|
|
dependencies = [
|
2023-08-25 13:41:04 -07:00
|
|
|
"windows_aarch64_gnullvm 0.48.5",
|
|
|
|
|
"windows_aarch64_msvc 0.48.5",
|
|
|
|
|
"windows_i686_gnu 0.48.5",
|
|
|
|
|
"windows_i686_msvc 0.48.5",
|
|
|
|
|
"windows_x86_64_gnu 0.48.5",
|
|
|
|
|
"windows_x86_64_gnullvm 0.48.5",
|
|
|
|
|
"windows_x86_64_msvc 0.48.5",
|
2023-08-24 15:34:51 -07:00
|
|
|
]
|
|
|
|
|
|
2024-01-08 21:22:53 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows-targets"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.52.4"
|
2024-01-08 21:22:53 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b"
|
2024-01-08 21:22:53 -06:00
|
|
|
dependencies = [
|
2024-03-23 15:45:55 -07:00
|
|
|
"windows_aarch64_gnullvm 0.52.4",
|
|
|
|
|
"windows_aarch64_msvc 0.52.4",
|
|
|
|
|
"windows_i686_gnu 0.52.4",
|
|
|
|
|
"windows_i686_msvc 0.52.4",
|
|
|
|
|
"windows_x86_64_gnu 0.52.4",
|
|
|
|
|
"windows_x86_64_gnullvm 0.52.4",
|
|
|
|
|
"windows_x86_64_msvc 0.52.4",
|
2024-01-08 21:22:53 -06:00
|
|
|
]
|
|
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows_aarch64_gnullvm"
|
|
|
|
|
version = "0.48.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
|
|
|
|
|
|
2024-01-08 21:22:53 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows_aarch64_gnullvm"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.52.4"
|
2024-03-19 16:19:57 -05:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows_aarch64_msvc"
|
|
|
|
|
version = "0.48.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
|
|
|
|
|
|
2024-01-08 21:22:53 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows_aarch64_msvc"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.52.4"
|
2024-03-19 16:19:57 -05:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows_i686_gnu"
|
|
|
|
|
version = "0.48.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
|
|
|
|
|
|
2024-01-08 21:22:53 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows_i686_gnu"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.52.4"
|
2024-01-08 21:22:53 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows_i686_msvc"
|
|
|
|
|
version = "0.48.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
|
|
|
|
|
|
2024-01-08 21:22:53 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows_i686_msvc"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.52.4"
|
2024-03-19 16:19:57 -05:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows_x86_64_gnu"
|
|
|
|
|
version = "0.48.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
|
|
|
|
|
|
2024-01-08 21:22:53 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows_x86_64_gnu"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.52.4"
|
2024-03-19 16:19:57 -05:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows_x86_64_gnullvm"
|
|
|
|
|
version = "0.48.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
|
|
|
|
|
|
2024-01-08 21:22:53 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows_x86_64_gnullvm"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.52.4"
|
2023-08-25 13:41:04 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177"
|
2023-08-25 13:41:04 -07:00
|
|
|
|
2023-08-24 15:34:51 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows_x86_64_msvc"
|
|
|
|
|
version = "0.48.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
|
|
|
|
|
|
2024-01-08 21:22:53 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "windows_x86_64_msvc"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.52.4"
|
2024-01-08 21:22:53 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8"
|
2024-01-08 21:22:53 -06:00
|
|
|
|
2023-09-22 21:57:39 -05:00
|
|
|
[[package]]
|
|
|
|
|
name = "winnow"
|
2024-02-13 16:33:19 +11:00
|
|
|
version = "0.5.40"
|
2023-09-22 21:57:39 -05:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-02-13 16:33:19 +11:00
|
|
|
checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
|
2023-09-22 21:57:39 -05:00
|
|
|
dependencies = [
|
|
|
|
|
"memchr",
|
|
|
|
|
]
|
|
|
|
|
|
2024-03-23 15:45:55 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "winnow"
|
|
|
|
|
version = "0.6.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "dffa400e67ed5a4dd237983829e66475f0a4a26938c4b04c21baede6262215b8"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"memchr",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "winreg"
|
|
|
|
|
version = "0.50.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"cfg-if",
|
|
|
|
|
"windows-sys 0.48.0",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-28 14:58:24 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "wyz"
|
|
|
|
|
version = "0.5.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"tap",
|
|
|
|
|
]
|
|
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "x25519-dalek"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "2.0.1"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "c7e468321c81fb07fa7f4c636c3972b9100f0346e5b6a9f2bd0603a52f7ed277"
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
dependencies = [
|
|
|
|
|
"curve25519-dalek",
|
|
|
|
|
"rand_core 0.6.4",
|
|
|
|
|
"serde",
|
|
|
|
|
"zeroize",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "x509-parser"
|
|
|
|
|
version = "0.15.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "7069fba5b66b9193bd2c5d3d4ff12b839118f6bcbef5328efafafb5395cf63da"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"asn1-rs",
|
|
|
|
|
"data-encoding",
|
|
|
|
|
"der-parser",
|
|
|
|
|
"lazy_static",
|
|
|
|
|
"nom",
|
|
|
|
|
"oid-registry",
|
|
|
|
|
"ring 0.16.20",
|
|
|
|
|
"rusticata-macros",
|
|
|
|
|
"thiserror",
|
|
|
|
|
"time",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-25 13:41:04 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "yaml-rust"
|
|
|
|
|
version = "0.4.5"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"linked-hash-map",
|
|
|
|
|
]
|
|
|
|
|
|
2023-08-18 19:37:52 +10:00
|
|
|
[[package]]
|
|
|
|
|
name = "yansi"
|
|
|
|
|
version = "0.5.1"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
|
2023-09-12 14:59:40 -07:00
|
|
|
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
[[package]]
|
|
|
|
|
name = "yasna"
|
|
|
|
|
version = "0.5.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "e17bb3549cc1321ae1296b9cdc2698e2b6cb1992adfa19a8c72e5b7a738f44cd"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"time",
|
|
|
|
|
]
|
|
|
|
|
|
2023-10-24 11:24:59 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "zerocopy"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.7.32"
|
2023-10-24 11:24:59 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
|
2023-10-24 11:24:59 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"zerocopy-derive",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "zerocopy-derive"
|
2024-03-23 15:45:55 -07:00
|
|
|
version = "0.7.32"
|
2023-10-24 11:24:59 -07:00
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
2024-03-23 15:45:55 -07:00
|
|
|
checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
|
2023-10-24 11:24:59 -07:00
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
Grackle (KCL to EP compiler) (#1270)
* Start Grackle (KCL-to-EP compiler)
This begins work on a second, different executor. The old executor is a tree-walk interpreter, this executor compiles the KCL programs into the Execution Plan virtual machine defined in its [own crate](https://github.com/KittyCAD/modeling-api/tree/main/execution-plan). This executor is called "Grackle", after an Austin bird, and it's got its own module in wasm-lib so that I can keep merging small PRs and developing incrementally, rather than building a complete executor which replaces the old executor in one PR.
Grackle's "Planner" walks the AST, like the tree-walk executor. But it doesn't actually execute code. Instead, as it walks each AST node, it outputs a sequence of Execution Plan instructions which, when run, can compute that node's value. It also notes which Execution Plan virtual machine address will eventually contain each KCL variable.
Done:
- Storing KCL variables
- Computing primitives, literals, binary expressions
- Calling native (i.e. Rust) functions from KCL
- Storing arrays
Todo:
- KCL functions (i.e. user-defined functions)
- Member expressions
- Port over existing executor's native funtions (e.g. `lineTo`, `extrude` and `startSketchAt`)
2024-01-11 09:25:10 -06:00
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "zeroize"
|
|
|
|
|
version = "1.7.0"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"zeroize_derive",
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
[[package]]
|
|
|
|
|
name = "zeroize_derive"
|
|
|
|
|
version = "1.4.2"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"proc-macro2",
|
|
|
|
|
"quote",
|
2024-03-27 10:16:56 -07:00
|
|
|
"syn 2.0.55",
|
2023-10-24 11:24:59 -07:00
|
|
|
]
|
|
|
|
|
|
2024-03-12 23:57:43 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "zip"
|
|
|
|
|
version = "0.6.6"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "760394e246e4c28189f19d488c058bf16f564016aefac5d32bb1f3b51d5e9261"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"byteorder",
|
|
|
|
|
"crc32fast",
|
|
|
|
|
"crossbeam-utils",
|
|
|
|
|
]
|
|
|
|
|
|
2023-09-12 14:59:40 -07:00
|
|
|
[[package]]
|
|
|
|
|
name = "zune-inflate"
|
|
|
|
|
version = "0.2.54"
|
|
|
|
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
|
|
|
checksum = "73ab332fe2f6680068f3582b16a24f90ad7096d5d39b974d1c0aff0125116f02"
|
|
|
|
|
dependencies = [
|
|
|
|
|
"simd-adler32",
|
|
|
|
|
]
|