diff --git a/.gitignore b/.gitignore
index b2f817b..bca6aa2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,4 +3,6 @@
/target
.pre-commit-config.yaml
*.pdf
-*.png
+/docs/*.png
+/testfiles/gen/*
+!/testfiles/gen/.gitkeep
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a89a2d0..748fd03 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -14,7 +14,7 @@ Before we get started, thank you for thinking about doing so!
- How did you install iOwO?
- What version of iOwO are you running?
- What operating system are you running?
- In the case of a Linux distro, mention the specific distro and when you last update as well.
+ In the case of a Linux distro, mention the specific distro and when you last updated as well.
- If the bug causes a crash, try to get a backtrace or in worse cases, a coredump.
### Feature requests
@@ -67,7 +67,7 @@ Otherwise, we suggest these:
[The Rust Programming Language book]: https://doc.rust-lang.org/book/
[typst's excellent tutorial]: https://typst.app/docs/tutorial
-[Inkscape]: https://inkscape.org/
+[Inkscape]: https://inkscape.org/
[GIMP]: https://www.gimp.org/
[Blender]: https://www.blender.org/
[Penpot]: https://penpot.app/
diff --git a/Cargo.lock b/Cargo.lock
index 091f8a8..7447d0d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -63,6 +63,8 @@ dependencies = [
"ariadne",
"clap",
"dirs",
+ "eval",
+ "ir",
"owo-colors",
"ron",
"serde",
@@ -266,12 +268,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
[[package]]
-name = "executor"
+name = "eval"
version = "0.1.0"
dependencies = [
"clap",
"image",
- "rpl",
+ "ir",
+ "serde",
]
[[package]]
@@ -373,6 +376,15 @@ dependencies = [
"tiff",
]
+[[package]]
+name = "ir"
+version = "0.1.0"
+dependencies = [
+ "either",
+ "ron",
+ "serde",
+]
+
[[package]]
name = "itoa"
version = "1.0.10"
@@ -482,15 +494,6 @@ version = "4.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "caff54706df99d2a78a5a4e3455ff45448d81ef1bb63c22cd14052ca0e993a3f"
-[[package]]
-name = "pl-cli"
-version = "0.1.0"
-dependencies = [
- "clap",
- "executor",
- "rpl",
-]
-
[[package]]
name = "png"
version = "0.17.10"
@@ -589,14 +592,6 @@ dependencies = [
"serde_derive",
]
-[[package]]
-name = "rpl"
-version = "0.1.0"
-dependencies = [
- "ron",
- "serde",
-]
-
[[package]]
name = "ryu"
version = "1.0.16"
diff --git a/Cargo.toml b/Cargo.toml
index 1fc1618..6d7f53d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,20 +1,24 @@
[workspace]
-members = [
- "crates/app",
- "crates/executor",
- "crates/rpl"
+members = [
+ "crates/app",
+ "crates/eval",
+ "crates/ir",
]
resolver = "2"
[workspace.dependencies]
-clap = { version = "4", features = [ "derive" ] }
-serde = { version = "1.0", features = [ "derive" ] }
+clap = { version = "4", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
-[lints.rust]
+# to enable all the lints below, this must be present in a workspace member's Cargo.toml:
+# [lints]
+# workspace = true
+
+[workspace.lints.rust]
unsafe_code = "deny"
variant_size_differences = "warn"
-[lints.clippy]
+[workspace.lints.clippy]
branches_sharing_code = "warn"
clone_on_ref_ptr = "warn"
cognitive_complexity = "warn"
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..fc3bcbd
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,676 @@
+The main program and its libraries are licensed under the AGPL 3.0
+as listed below the separator line.
+
+Media samples in the testfiles folder are licensed under CC BY-SA 4.0.
+To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/4.0/
+The appropiate authors are given below, in the format of
+`- file/path: author (link to author)`
+
+- testfiles/rails.png: Schrottkatze (https://forge.katzen.cafe/schrottkatze)
+
+===============================================================================
+
+iOwO: media pipeline toolset
+Copyright (C) 2024 Schrottkatze, MultisampledNight and iOwO contributors
+
+ GNU AFFERO GENERAL PUBLIC LICENSE
+ Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc.
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+ Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+ A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate. Many developers of free software are heartened and
+encouraged by the resulting cooperation. However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+ The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community. It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server. Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+ An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals. This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU Affero General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+ To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+ 1. Source Code.
+
+ The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+ A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+ The Corresponding Source for a work in source code form is that
+same work.
+
+ 2. Basic Permissions.
+
+ All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+ No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+ When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+ 4. Conveying Verbatim Copies.
+
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+ 5. Conveying Modified Source Versions.
+
+ You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+ a) The work must carry prominent notices stating that you modified
+ it, and giving a relevant date.
+
+ b) The work must carry prominent notices stating that it is
+ released under this License and any conditions added under section
+ 7. This requirement modifies the requirement in section 4 to
+ "keep intact all notices".
+
+ c) You must license the entire work, as a whole, under this
+ License to anyone who comes into possession of a copy. This
+ License will therefore apply, along with any applicable section 7
+ additional terms, to the whole of the work, and all its parts,
+ regardless of how they are packaged. This License gives no
+ permission to license the work in any other way, but it does not
+ invalidate such permission if you have separately received it.
+
+ d) If the work has interactive user interfaces, each must display
+ Appropriate Legal Notices; however, if the Program has interactive
+ interfaces that do not display Appropriate Legal Notices, your
+ work need not make them do so.
+
+ A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+ 6. Conveying Non-Source Forms.
+
+ You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+ a) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by the
+ Corresponding Source fixed on a durable physical medium
+ customarily used for software interchange.
+
+ b) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by a
+ written offer, valid for at least three years and valid for as
+ long as you offer spare parts or customer support for that product
+ model, to give anyone who possesses the object code either (1) a
+ copy of the Corresponding Source for all the software in the
+ product that is covered by this License, on a durable physical
+ medium customarily used for software interchange, for a price no
+ more than your reasonable cost of physically performing this
+ conveying of source, or (2) access to copy the
+ Corresponding Source from a network server at no charge.
+
+ c) Convey individual copies of the object code with a copy of the
+ written offer to provide the Corresponding Source. This
+ alternative is allowed only occasionally and noncommercially, and
+ only if you received the object code with such an offer, in accord
+ with subsection 6b.
+
+ d) Convey the object code by offering access from a designated
+ place (gratis or for a charge), and offer equivalent access to the
+ Corresponding Source in the same way through the same place at no
+ further charge. You need not require recipients to copy the
+ Corresponding Source along with the object code. If the place to
+ copy the object code is a network server, the Corresponding Source
+ may be on a different server (operated by you or a third party)
+ that supports equivalent copying facilities, provided you maintain
+ clear directions next to the object code saying where to find the
+ Corresponding Source. Regardless of what server hosts the
+ Corresponding Source, you remain obligated to ensure that it is
+ available for as long as needed to satisfy these requirements.
+
+ e) Convey the object code using peer-to-peer transmission, provided
+ you inform other peers where the object code and Corresponding
+ Source of the work are being offered to the general public at no
+ charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+ If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+ The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+ 7. Additional Terms.
+
+ "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+ a) Disclaiming warranty or limiting liability differently from the
+ terms of sections 15 and 16 of this License; or
+
+ b) Requiring preservation of specified reasonable legal notices or
+ author attributions in that material or in the Appropriate Legal
+ Notices displayed by works containing it; or
+
+ c) Prohibiting misrepresentation of the origin of that material, or
+ requiring that modified versions of such material be marked in
+ reasonable ways as different from the original version; or
+
+ d) Limiting the use for publicity purposes of names of licensors or
+ authors of the material; or
+
+ e) Declining to grant rights under trademark law for use of some
+ trade names, trademarks, or service marks; or
+
+ f) Requiring indemnification of licensors and authors of that
+ material by anyone who conveys the material (or modified versions of
+ it) with contractual assumptions of liability to the recipient, for
+ any liability that these contractual assumptions directly impose on
+ those licensors and authors.
+
+ All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+ 8. Termination.
+
+ You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+ However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+ 9. Acceptance Not Required for Having Copies.
+
+ You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+ Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+ 11. Patents.
+
+ A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+ If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+ 13. Remote Network Interaction; Use with the GNU General Public License.
+
+ Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software. This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+ Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time. Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+
+ Copyright (C)
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see .
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source. For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code. There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+.
diff --git a/crates/app/Cargo.toml b/crates/app/Cargo.toml
index a0043ee..2caaaf4 100644
--- a/crates/app/Cargo.toml
+++ b/crates/app/Cargo.toml
@@ -6,11 +6,16 @@ edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
-clap = { workspace = true, features = [ "derive", "env" ] }
-serde = { workspace = true, features = [ "derive" ] }
-ron = "0.8"
-serde_json = "1.0"
ariadne = "0.4"
-time = { version = "0.3", features = [ "local-offset" ] }
+clap = { workspace = true, features = [ "derive", "env" ] }
dirs = "5"
+eval = { path = "../eval" }
+ir = { path = "../ir" }
owo-colors = "4"
+ron = "0.8"
+serde = { workspace = true, features = [ "derive" ] }
+serde_json = "1.0"
+time = { version = "0.3", features = [ "local-offset" ] }
+
+[lints]
+workspace = true
diff --git a/crates/app/src/config.rs b/crates/app/src/config.rs
index 9f2b15a..b4d1ed1 100644
--- a/crates/app/src/config.rs
+++ b/crates/app/src/config.rs
@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
use clap::Parser;
use self::{
@@ -10,6 +12,9 @@ mod config_file;
/// this struct may hold all configuration
pub struct Config {
+ pub source: PathBuf,
+ pub evaluator: eval::Available,
+
pub startup_msg: bool,
}
@@ -17,37 +22,37 @@ impl Config {
/// Get the configs from all possible places (args, file, env...)
pub fn read() -> Self {
let args = Args::parse();
- let config_path = if let Some(config_path) = args.config_path {
- Ok(config_path)
+ let config = if let Some(config) = args.config_path {
+ Ok(config)
} else {
find_config_file()
};
// try to read a maybe existing config file
- let file_config = if let Ok(config_path) = config_path {
- let file_config = Configs::read(config_path);
-
- match file_config {
- Ok(c) => Some(c),
- Err(e) => {
+ let config = config.ok().and_then(|path| {
+ Configs::read(path).map_or_else(
+ |e| {
eprintln!("Config error: {e:?}");
eprintln!("Proceeding with defaults or cli args...");
None
- }
- }
- } else {
- None
- };
+ },
+ Some,
+ )
+ });
- if let Some(file_config) = file_config {
+ if let Some(file) = config {
Self {
+ source: args.source,
+ evaluator: args.evaluator.and(file.evaluator).unwrap_or_default(),
// this is negated because to an outward api, the negative is more intuitive,
// while in the source the other way around is more intuitive
- startup_msg: !(args.no_startup_message || file_config.no_startup_message),
+ startup_msg: !(args.no_startup_message || file.no_startup_message),
}
} else {
Self {
+ source: args.source,
startup_msg: !args.no_startup_message,
+ evaluator: args.evaluator.unwrap_or_default(),
}
}
}
@@ -56,7 +61,7 @@ impl Config {
pub mod error {
/// Errors that can occur when reading configs
#[derive(Debug)]
- pub enum ConfigError {
+ pub enum Config {
/// The config dir doesn't exist
NoConfigDir,
/// We didn't find a config file in the config dir
@@ -73,19 +78,19 @@ pub mod error {
SerdeRonError(ron::error::SpannedError),
}
- impl From for ConfigError {
+ impl From for Config {
fn from(value: std::io::Error) -> Self {
Self::IoError(value)
}
}
- impl From for ConfigError {
+ impl From for Config {
fn from(value: serde_json::Error) -> Self {
Self::SerdeJsonError(value)
}
}
- impl From for ConfigError {
+ impl From for Config {
fn from(value: ron::error::SpannedError) -> Self {
Self::SerdeRonError(value)
}
diff --git a/crates/app/src/config/cli.rs b/crates/app/src/config/cli.rs
index bdf769e..1d9c57a 100644
--- a/crates/app/src/config/cli.rs
+++ b/crates/app/src/config/cli.rs
@@ -4,6 +4,14 @@ use clap::{builder::BoolishValueParser, ArgAction, Parser};
#[derive(Parser)]
pub(crate) struct Args {
+ /// What file contains the pipeline to evaluate.
+ pub source: PathBuf,
+
+ /// How to actually run the pipeline.
+ /// Overrides the config file. Defaults to the debug evaluator.
+ #[arg(short, long)]
+ pub evaluator: Option,
+
/// Read this config file.
#[arg(short, long)]
pub config_path: Option,
diff --git a/crates/app/src/config/config_file.rs b/crates/app/src/config/config_file.rs
index a0c4db1..15f660c 100644
--- a/crates/app/src/config/config_file.rs
+++ b/crates/app/src/config/config_file.rs
@@ -5,7 +5,7 @@ use std::{
use serde::{Deserialize, Serialize};
-use super::error::ConfigError;
+use super::error::Config;
#[derive(Debug, Serialize, Deserialize)]
pub struct Configs {
@@ -13,6 +13,7 @@ pub struct Configs {
pub example_value: i32,
#[serde(default)]
pub no_startup_message: bool,
+ pub evaluator: Option,
}
/// what the fuck serde why do i need this
@@ -21,9 +22,9 @@ fn default_example_value() -> i32 {
}
/// Find the location of a config file and check if there is, in fact, a file
-pub(super) fn find_config_file() -> Result {
+pub(super) fn find_config_file() -> Result {
let Some(config_path) = dirs::config_dir() else {
- return Err(ConfigError::NoConfigDir);
+ return Err(Config::NoConfigDir);
};
let ron_path = config_path.with_file_name("config.ron");
@@ -34,16 +35,19 @@ pub(super) fn find_config_file() -> Result {
} else if Path::new(&json_path).exists() {
Ok(json_path)
} else {
- Err(ConfigError::NoConfigFileFound)
+ Err(Config::NoConfigFileFound)
}
}
impl Configs {
- pub fn read(p: PathBuf) -> Result {
- match p.extension().map(|v| v.to_str().unwrap()) {
+ pub fn read(p: PathBuf) -> Result {
+ match p
+ .extension()
+ .map(|v| v.to_str().expect("config path to be UTF-8"))
+ {
Some("ron") => Ok(serde_json::from_str(&fs::read_to_string(p)?)?),
Some("json") => Ok(ron::from_str(&fs::read_to_string(p)?)?),
- e => Err(ConfigError::UnknownExtension(e.map(|v| v.to_owned()))),
+ e => Err(Config::UnknownExtension(e.map(str::to_owned))),
}
}
}
diff --git a/crates/app/src/error_reporting.rs b/crates/app/src/error_reporting.rs
index 33ffff6..bc4c44b 100644
--- a/crates/app/src/error_reporting.rs
+++ b/crates/app/src/error_reporting.rs
@@ -3,12 +3,12 @@ use std::process;
use ron::error::Position;
/// Report an `Error` from the `serde_json` crate
-pub fn report_serde_json_err(src: &str, err: serde_json::Error) -> ! {
+pub fn report_serde_json_err(src: &str, err: &serde_json::Error) -> ! {
report_serde_err(src, err.line(), err.column(), err.to_string())
}
/// Report a `SpannedError` from the `ron` crate
-pub fn report_serde_ron_err(src: &str, err: ron::error::SpannedError) -> ! {
+pub fn report_serde_ron_err(src: &str, err: &ron::error::SpannedError) -> ! {
let Position { line, col } = err.position;
report_serde_err(src, line, col, err.to_string())
}
@@ -23,8 +23,8 @@ fn report_serde_err(src: &str, line: usize, col: usize, msg: String) -> ! {
.with_message(msg)
.with_note("We'd like to give better errors, but serde errors are horrible to work with...")
.finish()
- .print(("test", Source::from(src)))
- .unwrap();
+ .eprint(("test", Source::from(src)))
+ .expect("writing error to stderr failed");
process::exit(1);
}
diff --git a/crates/app/src/main.rs b/crates/app/src/main.rs
index 1347572..58103a5 100644
--- a/crates/app/src/main.rs
+++ b/crates/app/src/main.rs
@@ -1,3 +1,5 @@
+use std::fs;
+
use config::Config;
use welcome_msg::print_startup_msg;
@@ -8,10 +10,18 @@ mod error_reporting;
mod welcome_msg;
fn main() {
- // TODO: proper error handling
+ // TODO: proper error handling across the whole function
+ // don't forget to also look inside `Config`
let cfg = Config::read();
if cfg.startup_msg {
print_startup_msg();
}
+
+ let source = fs::read_to_string(cfg.source).expect("can't find source file");
+ let ir = ir::from_ron(&source).expect("failed to parse source to graph ir");
+
+ let mut machine = cfg.evaluator.pick();
+ machine.feed(ir);
+ machine.eval_full();
}
diff --git a/crates/executor/Cargo.toml b/crates/eval/Cargo.toml
similarity index 70%
rename from crates/executor/Cargo.toml
rename to crates/eval/Cargo.toml
index fc01c27..b542d2f 100644
--- a/crates/executor/Cargo.toml
+++ b/crates/eval/Cargo.toml
@@ -1,5 +1,5 @@
[package]
-name = "executor"
+name = "eval"
version = "0.1.0"
edition = "2021"
@@ -8,4 +8,8 @@ edition = "2021"
[dependencies]
clap = { workspace = true, features = [ "derive" ] }
image = "0.24"
-rpl = { path = "../rpl" }
+ir = { path = "../ir" }
+serde = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/crates/eval/src/kind/debug/instr/mod.rs b/crates/eval/src/kind/debug/instr/mod.rs
new file mode 100644
index 0000000..77e4101
--- /dev/null
+++ b/crates/eval/src/kind/debug/instr/mod.rs
@@ -0,0 +1,45 @@
+pub mod read {
+ use image::{io::Reader as ImageReader, DynamicImage};
+ use ir::instruction::read::{Read, SourceType};
+
+ pub fn read(Read { source }: Read) -> DynamicImage {
+ // TODO: actual error handling
+ let img = ImageReader::open(match source {
+ SourceType::File(path) => path,
+ })
+ .expect("something went wrong :(((");
+
+ img.decode().expect("couldn't decode image")
+ }
+}
+
+pub mod write {
+ use image::{DynamicImage, ImageFormat};
+ use ir::instruction::write::{TargetFormat, TargetType, Write};
+
+ pub fn write(Write { target, format }: Write, input_data: &DynamicImage) {
+ // TODO: actual error handling
+ input_data
+ .save_with_format(
+ match target {
+ TargetType::File(path) => path,
+ },
+ match format {
+ TargetFormat::Jpeg => ImageFormat::Jpeg,
+ TargetFormat::Png => ImageFormat::Png,
+ },
+ )
+ .expect("couldn't save file");
+ }
+}
+
+pub mod filters {
+ pub mod invert {
+ use image::DynamicImage;
+
+ pub fn invert(mut input_data: DynamicImage) -> DynamicImage {
+ input_data.invert();
+ input_data
+ }
+ }
+}
diff --git a/crates/eval/src/kind/debug/mod.rs b/crates/eval/src/kind/debug/mod.rs
new file mode 100644
index 0000000..9b53ebe
--- /dev/null
+++ b/crates/eval/src/kind/debug/mod.rs
@@ -0,0 +1,105 @@
+use ir::{
+ id,
+ instruction::{Filter, Kind},
+ GraphIr, Instruction, Map,
+};
+
+use crate::value::Variant;
+mod instr;
+
+#[derive(Debug, Default)]
+pub struct Evaluator {
+ ir: GraphIr,
+
+ /// What the output of each individual streamer, and as result its output sockets, is.
+ /// Grows larger as evaluation continues,
+ /// as there's no mechanism for purging never-to-be-used-anymore instructions yet.
+ evaluated: Map,
+}
+
+impl crate::Evaluator for Evaluator {
+ fn feed(&mut self, ir: GraphIr) {
+ self.ir = ir;
+ self.evaluated.clear();
+ }
+
+ fn eval_full(&mut self) {
+ // GraphIr::topological_sort returns InstructionRefs, which are mostly cool
+ // but we'd like to have them owned, so we can call Self::step without lifetime hassle
+ let queue: Vec = self
+ .ir
+ .topological_sort()
+ .into_iter()
+ .map(Into::into)
+ .collect();
+
+ for instr in queue {
+ self.step(instr);
+ }
+ }
+}
+
+impl Evaluator {
+ #[allow(clippy::needless_pass_by_value)]
+ fn step(&mut self, instr: Instruction) {
+ // what inputs does this instr need? fetch them
+ let inputs: Vec<_> = instr
+ .input_sources()
+ .iter()
+ .map(|source| {
+ let source_socket = source
+ .as_ref()
+ .expect("all inputs to be connected when an instruction is ran");
+ self.evaluated
+ .get(source_socket)
+ .expect("toposort to yield later instrs only after previous ones")
+ })
+ .collect();
+
+ // then actually do whatever the instruction should do
+ // NOTE: makes heavy use of index slicing,
+ // on the basis that ir::instruction::Kind::socket_count is correct
+ // TODO: make this a more flexible dispatch-ish arch
+ let output = match instr.kind {
+ Kind::Read(details) => Some(Variant::Image(instr::read::read(details))),
+ Kind::Write(details) => {
+ #[allow(irrefutable_let_patterns)] // will necessarily change
+ let Variant::Image(input) = inputs[0] else {
+ panic!("cannot only write images, but received: `{:?}`", inputs[0]);
+ };
+ instr::write::write(details, input);
+ None
+ }
+ Kind::Math(_) => todo!(),
+ Kind::Blend(_) => todo!(),
+ Kind::Noise(_) => todo!(),
+ Kind::Filter(filter_instruction) => match filter_instruction {
+ Filter::Invert => {
+ #[allow(irrefutable_let_patterns)]
+ let Variant::Image(input) = inputs[0] else {
+ panic!(
+ "cannot only filter invert images, but received: `{:?}`",
+ inputs[0]
+ );
+ };
+
+ Some(Variant::Image(instr::filters::invert::invert(
+ input.clone(),
+ )))
+ }
+ },
+ };
+
+ if let Some(output) = output {
+ // TODO: very inaccurate, actually respect individual instructions.
+ // should be implied by a different arch
+ // TODO: all of those should not be public, offer some methods to get this on
+ // `Instruction` instead (can infer short-term based on Kind::socket_count)
+ let socket = id::Output(id::Socket {
+ belongs_to: instr.id,
+ idx: id::SocketIdx(0),
+ });
+ self.evaluated.insert(socket, output);
+ }
+ }
+}
diff --git a/crates/eval/src/kind/mod.rs b/crates/eval/src/kind/mod.rs
new file mode 100644
index 0000000..2f36523
--- /dev/null
+++ b/crates/eval/src/kind/mod.rs
@@ -0,0 +1 @@
+pub mod debug;
diff --git a/crates/eval/src/lib.rs b/crates/eval/src/lib.rs
new file mode 100644
index 0000000..c3a6c38
--- /dev/null
+++ b/crates/eval/src/lib.rs
@@ -0,0 +1,43 @@
+use ir::GraphIr;
+
+mod kind;
+mod value;
+
+/// Can collapse a [`GraphIr`] in meaningful ways and do interesting work on it.
+///
+/// It's surprisingly difficult to find a fitting description for this.
+pub trait Evaluator {
+ /// Take some [`GraphIr`] which will then be processed later.
+ /// May be called multiple times, in which the [`GraphIr`]s should add up.
+ // TODO: atm they definitely don't add up -- add some functionality to GraphIr to
+ // make it combine two graphs into one
+ fn feed(&mut self, ir: GraphIr);
+
+ /// Walk through the _whole_ [`GraphIr`] and run through each instruction.
+ fn eval_full(&mut self);
+
+ // TODO: for an LSP or the like, eval_single which starts at a given instr
+}
+
+/// The available [`Evaluator`]s.
+///
+/// Checklist for adding new ones:
+///
+/// 1. Create a new module under the [`kind`] module.
+/// 2. Add a struct and implement [`Evaluator`] for it.
+#[derive(Clone, Copy, Debug, Default, clap::ValueEnum, serde::Deserialize, serde::Serialize)]
+pub enum Available {
+ /// Runs fully on the CPU. Single-threaded, debug-friendly and quick to implement.
+ #[default]
+ Debug,
+}
+
+impl Available {
+ /// Selects the [`Evaluator`] corresponding to this label.
+ #[must_use]
+ pub fn pick(&self) -> Box {
+ match self {
+ Self::Debug => Box::new(kind::debug::Evaluator::default()),
+ }
+ }
+}
diff --git a/crates/eval/src/value/mod.rs b/crates/eval/src/value/mod.rs
new file mode 100644
index 0000000..b1d85d5
--- /dev/null
+++ b/crates/eval/src/value/mod.rs
@@ -0,0 +1,12 @@
+use image::DynamicImage;
+
+/// Any runtime value that an instruction can input or output.
+///
+/// The name is taken from [Godot's `Variant` type],
+/// which is very similar to this one.
+///
+/// [Godot's `Variant` type]: https://docs.godotengine.org/en/stable/classes/class_variant.html
+#[derive(Clone, Debug)]
+pub enum Variant {
+ Image(DynamicImage),
+}
diff --git a/crates/executor/src/cpu/mod.rs b/crates/executor/src/cpu/mod.rs
deleted file mode 100644
index e82d20a..0000000
--- a/crates/executor/src/cpu/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub(crate) struct CpuExecutor;
diff --git a/crates/executor/src/debug/instructions/mod.rs b/crates/executor/src/debug/instructions/mod.rs
deleted file mode 100644
index 0c4b611..0000000
--- a/crates/executor/src/debug/instructions/mod.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-pub mod read {
- use image::{io::Reader as ImageReader, DynamicImage};
- use rpl::instructions::read::{Read, SourceType};
-
- pub fn read(Read { source, format }: Read) -> DynamicImage {
- let mut img = ImageReader::open(match source {
- SourceType::File(path) => path,
- })
- .expect("something went wrong :(((");
-
- img.decode().expect("couldn't decode image")
- }
-}
-
-pub mod write {
- use image::{io::Reader as ImageReader, DynamicImage, ImageFormat};
- use rpl::instructions::write::{TargetFormat, TargetType, Write};
-
- pub fn write(Write { target, format }: Write, input_data: DynamicImage) {
- input_data.save_with_format(
- match target {
- TargetType::File(path) => path,
- },
- match format {
- TargetFormat::Jpeg => ImageFormat::Jpeg,
- TargetFormat::Png => ImageFormat::Png,
- },
- );
- }
-}
-
-pub mod filters {
- pub mod invert {
- use image::DynamicImage;
-
- pub fn invert(mut input_data: DynamicImage) -> DynamicImage {
- input_data.invert();
- input_data
- }
- }
-}
diff --git a/crates/executor/src/debug/mod.rs b/crates/executor/src/debug/mod.rs
deleted file mode 100644
index d56f546..0000000
--- a/crates/executor/src/debug/mod.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-use rpl::instructions::{FilterInstruction, Instruction};
-
-use crate::{value::DynamicValue, Executor};
-mod instructions;
-
-pub struct DebugExecutor;
-
-impl Executor for DebugExecutor {
- fn execute(instruction: Instruction, input: Option) -> Option {
- match instruction {
- Instruction::Read(read_instruction) => Some(DynamicValue::Image(
- instructions::read::read(read_instruction),
- )),
- Instruction::Write(write_instruction) => {
- instructions::write::write(
- write_instruction,
- match input {
- Some(DynamicValue::Image(img)) => img,
- _ => panic!("awawwawwa"),
- },
- );
- None
- }
- Instruction::Math(_) => todo!(),
- Instruction::Blend(_) => todo!(),
- Instruction::Noise(_) => todo!(),
- Instruction::Filter(filter_instruction) => match filter_instruction {
- FilterInstruction::Invert => Some(DynamicValue::Image(
- instructions::filters::invert::invert(match input {
- Some(DynamicValue::Image(img)) => img,
- _ => panic!("invalid value type for invert"),
- }),
- )),
- },
- }
- }
-}
diff --git a/crates/executor/src/lib.rs b/crates/executor/src/lib.rs
deleted file mode 100644
index fb55029..0000000
--- a/crates/executor/src/lib.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use rpl::instructions::Instruction;
-use value::DynamicValue;
-
-mod debug;
-mod value;
-
-/// The available executors
-/// unused in early dev.
-#[derive(Debug, Clone, Copy, clap::ValueEnum)]
-pub enum Executors {
- /// the debug executor is single threaded and really, *really* slow. And unstable. Don't use. Unless you're a dev working on this.
- Debug,
- /// the CPU executor primarily uses the CPU. Most likely most feature complete, and the fallback.
- Cpu,
- /// the Vulkan executor (obviously) uses vulkan. there's a good chance this isn't implemented yet as you're reading this.
- Vulkan,
-}
-
-trait Executor {
- fn execute(instruction: Instruction, input: Option) -> Option;
-}
-
-pub fn execute_all(instructions: Vec) {
- let mut tmp = None;
-
- for instruction in instructions {
- tmp = debug::DebugExecutor::execute(instruction, tmp);
- }
-}
-
-// scratchpad lol:
-// execution structure:
-// 1. take in rpl
-// 2. analyse/validate structure against allowed executors
-// 3. assign executors to instructions
-// 4. optimize
-// 5. prepare memory management patterns
-// 6. run
diff --git a/crates/executor/src/value/mod.rs b/crates/executor/src/value/mod.rs
deleted file mode 100644
index daf0dd2..0000000
--- a/crates/executor/src/value/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use image::DynamicImage;
-
-pub enum DynamicValue {
- Image(DynamicImage),
-}
diff --git a/crates/rpl/Cargo.toml b/crates/ir/Cargo.toml
similarity index 61%
rename from crates/rpl/Cargo.toml
rename to crates/ir/Cargo.toml
index b40a46e..77f8de4 100644
--- a/crates/rpl/Cargo.toml
+++ b/crates/ir/Cargo.toml
@@ -1,10 +1,14 @@
[package]
-name = "rpl"
+name = "ir"
version = "0.1.0"
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
-serde = { workspace = true, features = [ "derive" ] }
+either = "1.9"
ron = "0.8"
+serde = { version = "1.0.193", features = ["derive"] }
+
+[lints]
+workspace = true
diff --git a/crates/ir/src/id.rs b/crates/ir/src/id.rs
new file mode 100644
index 0000000..4834a4f
--- /dev/null
+++ b/crates/ir/src/id.rs
@@ -0,0 +1,84 @@
+//! Instance identification for instructions and their glue.
+//!
+//! Instructions as defined in [`crate::instruction::Kind`] and descendants are very useful,
+//! but they cannot be directly used as vertices in the graph IR,
+//! as there may easily be multiple instructions of the same kind in the same program.
+//!
+//! Instead, this module offers an alternative way to refer to specific instances:
+//!
+//! - [`Instruction`]s are effectively just a number floating in space,
+//! incremented each time a new instruction is referred to.
+//! - [`Socket`]s contain
+//! - what [`Instruction`] they belong to
+//! - which index they occupy on it
+//!
+//! The distinction between [`Input`] and [`Output`] is implemented
+//! as them being different types.
+
+use std::fmt;
+
+use serde::{Deserialize, Serialize};
+
+/// One specific instruction.
+///
+/// It does **not** contain what kind of instruction this is.
+/// Refer to [`crate::instruction::Kind`] for this instead.
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct Instruction(pub(super) u64);
+
+impl fmt::Debug for Instruction {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "InstrId {}", self.0)
+ }
+}
+
+/// On an **instruction**, accepts incoming data.
+///
+/// An **instruction** cannot run if any of these are not connected.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct Input(pub(super) Socket);
+
+impl Input {
+ #[must_use]
+ pub fn socket(&self) -> &Socket {
+ &self.0
+ }
+}
+
+/// On an **instruction**, returns outgoing data to be fed to [`Input`]s.
+///
+/// In contrast to [`Input`]s, [`Output`]s may be used or unused.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct Output(pub Socket); // TODO: Restrict publicness to super
+
+impl Output {
+ #[must_use]
+ pub fn socket(&self) -> &Socket {
+ &self.0
+ }
+}
+
+/// An unspecified socket on a specific **instruction**,
+/// and where it is on that **instruction**.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct Socket {
+ pub belongs_to: Instruction,
+ pub idx: SocketIdx,
+}
+
+/// Where a [`Socket`] is on one **instruction**.
+///
+/// Note that this does **not** identify a [`Socket`] globally.
+/// There may be multiple [`Socket`]s sharing the same [`SocketIdx`],
+/// but on different [`Instruction`]s.
+///
+/// This really only serves for denoting where a socket is,
+/// when it's already clear which instruction is referred to.
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct SocketIdx(pub u16); // TODO: Restrict publicness to super
+
+impl fmt::Debug for SocketIdx {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ self.0.fmt(f)
+ }
+}
diff --git a/crates/ir/src/instruction/mod.rs b/crates/ir/src/instruction/mod.rs
new file mode 100644
index 0000000..069fa4f
--- /dev/null
+++ b/crates/ir/src/instruction/mod.rs
@@ -0,0 +1,81 @@
+use serde::{Deserialize, Serialize};
+
+pub mod read;
+pub mod write;
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum Kind {
+ // TODO: `read::Read` and `write::Write` hold real values atm -- they should actually
+ // point to `Const` instructions instead (which are... yet to be done...)
+ Read(read::Read),
+ Write(write::Write),
+ Math(Math),
+ Blend(Blend),
+ Noise(Noise),
+ Filter(Filter),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum Math {
+ Add,
+ Subtract,
+ Multiply,
+ Divide,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum Blend {
+ Normal,
+ Multiply,
+ Additive,
+ Overlay,
+ Screen,
+ Subtractive,
+ Difference,
+ Darken,
+ Lighten,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum Noise {
+ Perlin,
+ Simplex,
+ Voronoi,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum Filter {
+ Invert,
+}
+
+// TODO: given that this basically matches on all instructions, we may need to use
+// the visitor pattern in future here, or at least get them behind traits
+// which should allow far more nuanced description
+impl Kind {
+ /// Returns how many sockets this kind of instruction has.
+ #[must_use]
+ pub fn socket_count(&self) -> SocketCount {
+ match self {
+ Self::Read(_) => (0, 1),
+ Self::Write(_) => (1, 0),
+ Self::Math(_) | Self::Blend(_) => (2, 1),
+ Self::Noise(_) => {
+ todo!("how many arguments does noise take? how many outputs does it have?")
+ }
+ Self::Filter(Filter::Invert) => (1, 1),
+ }
+ .into()
+ }
+}
+
+/// How many sockets are on an instruction?
+pub struct SocketCount {
+ pub inputs: u16,
+ pub outputs: u16,
+}
+
+impl From<(u16, u16)> for SocketCount {
+ fn from((inputs, outputs): (u16, u16)) -> Self {
+ Self { inputs, outputs }
+ }
+}
diff --git a/crates/ir/src/instruction/read.rs b/crates/ir/src/instruction/read.rs
new file mode 100644
index 0000000..2e4ab60
--- /dev/null
+++ b/crates/ir/src/instruction/read.rs
@@ -0,0 +1,12 @@
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct Read {
+ pub source: SourceType,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum SourceType {
+ File(PathBuf),
+}
diff --git a/crates/ir/src/instruction/write.rs b/crates/ir/src/instruction/write.rs
new file mode 100644
index 0000000..8e9311b
--- /dev/null
+++ b/crates/ir/src/instruction/write.rs
@@ -0,0 +1,19 @@
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct Write {
+ pub target: TargetType,
+ pub format: TargetFormat,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum TargetType {
+ File(PathBuf),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum TargetFormat {
+ Jpeg,
+ Png,
+}
diff --git a/crates/ir/src/lib.rs b/crates/ir/src/lib.rs
new file mode 100644
index 0000000..702244c
--- /dev/null
+++ b/crates/ir/src/lib.rs
@@ -0,0 +1,353 @@
+use std::num::NonZeroUsize;
+
+use instruction::SocketCount;
+use serde::{Deserialize, Serialize};
+
+pub mod id;
+pub mod instruction;
+pub mod semi_human;
+
+pub type Map = std::collections::BTreeMap;
+pub type Set = std::collections::BTreeSet;
+
+/// Gives you a super well typed graph IR for a given human-readable repr.
+///
+/// Look at [`semi_human::GraphIr`] and the test files in the repo at `testfiles/`
+/// to see what the RON should look like.
+/// No, we don't want you to write out [`GraphIr`] in full by hand.
+/// That's something for the machines to do.
+///
+/// # Errors
+///
+/// Returns an error if the parsed source is not a valid human-readable graph IR.
+pub fn from_ron(source: &str) -> ron::error::SpannedResult {
+ let human_repr: semi_human::GraphIr = ron::from_str(source)?;
+ Ok(human_repr.into())
+}
+
+/// The toplevel representation of a whole pipeline.
+///
+/// # DAGs
+///
+/// Pipelines may not be fully linear. They may branch out and recombine later on.
+/// As such, the representation for them which is currently used is a
+/// [**D**irected **A**cyclic **G**raph](https://en.wikipedia.org/wiki/Directed_acyclic_graph).
+///
+/// For those who are already familiar with graphs, a DAG is one, except that:
+///
+/// - It is **directed**: Edges have a direction they point to.
+/// In this case, edges point from the outputs of streamers to inputs of consumers.
+/// - It is **acyclic**: Those directed edges may not form loops.
+/// In other words, if one follows edges only in their direction, it must be impossible
+/// to come back to an already visited node.
+///
+/// Here, if an edge points from _A_ to _B_ (`A --> B`),
+/// then _A_ is called a **dependency** or an **input source** of _B_,
+/// and _B_ is called a **dependent** or an **output target** of _A_.
+///
+/// The DAG also enables another neat operation:
+/// [Topological sorting](https://en.wikipedia.org/wiki/Topological_sorting).
+/// This allows to put the entire graph into a linear list,
+/// where it's guaranteed that once a vertex is visited,
+/// all dependencies of it will have been visited already as well.
+///
+/// The representation used here in specific is a bit more complicated,
+/// since **instructions** directly aren't just connected to one another,
+/// but their **sockets** are instead.
+///
+/// So the vertices of the DAG are the **sockets**
+/// (which are either [`id::Input`] or [`id::Output`] depending on the direction),
+/// and each **socket** in turn belongs to an **instruction**.
+///
+/// # Usage
+///
+/// - If you want to build one from scratch,
+/// add a few helper methods like
+/// constructing an empty one,
+/// adding instructions and
+/// adding edges
+/// - If you want to construct one from an existing repr,
+/// maybe you want to use [`semi_human::GraphIr`].
+///
+/// # Storing additional data
+///
+/// Chances are the graph IR seems somewhat fit to put metadata in it.
+/// However, most likely you're interacting in context of some other system,
+/// and also want to manage and index that data on your own.
+///
+/// As such, consider using _secondary_ maps instead.
+/// That is, store in a data structure _you_ own a mapping
+/// from [`id`]s
+/// to whatever data you need.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Deserialize, Serialize)]
+pub struct GraphIr {
+ /// "Backbone" storage of all **instruction** IDs to
+ /// what **kind of instruction** they are.
+ instructions: Map,
+
+ /// How the data flows forward. **Dependencies** map to **dependents** here.
+ edges: Map>,
+ /// How the data flows backward. **Dependents** map to **dependencies** here.
+ rev_edges: Map,
+}
+
+// TODO: this impl block, but actually the whole module, screams for tests
+impl GraphIr {
+ /// Look "backwards" in the graph,
+ /// and find out what instructions need to be done before this one.
+ /// The input slots are visited in order.
+ ///
+ /// - The iterator returns individually [`Some`]`(`[`None`]`)` if the corresponding slot is
+ /// not connected.
+ ///
+ /// The same caveats as for [`GraphIr::resolve`] apply.
+ #[must_use]
+ pub fn input_sources(
+ &self,
+ subject: &id::Instruction,
+ ) -> Option> + '_> {
+ let (subject, kind) = self.instructions.get_key_value(subject)?;
+ let SocketCount { inputs, .. } = kind.socket_count();
+
+ Some((0..inputs).map(|idx| {
+ let input = id::Input(socket(subject, idx));
+ self.rev_edges.get(&input)
+ }))
+ }
+
+ /// Look "forwards" in the graph to see what other instructions this instruction feeds into.
+ ///
+ /// The output slots represent the top-level iterator,
+ /// and each one's connections are emitted one level below.
+ ///
+ /// Just [`Iterator::flatten`] if you are not interested in the slots.
+ ///
+ /// The same caveats as for [`GraphIr::resolve`] apply.
+ #[must_use]
+ pub fn output_targets(
+ &self,
+ subject: &id::Instruction,
+ ) -> Option>> + '_> {
+ let (subject, kind) = self.instructions.get_key_value(subject)?;
+ let SocketCount { outputs, .. } = kind.socket_count();
+
+ Some((0..outputs).map(|idx| {
+ let output = id::Output(socket(subject, idx));
+ self.edges.get(&output)
+ }))
+ }
+
+ /// Returns the instruction corresponding to the given ID.
+ /// Returns [`None`] if there is no such instruction in this graph IR.
+ ///
+ /// Theoretically this could be fixed easily at the expense of some memory
+ /// by just incrementing and storing some global counter,
+ /// however, at the moment there's no compelling reason
+ /// to actually have multiple [`GraphIr`]s at one point in time.
+ /// Open an issue if that poses a problem for you.
+ #[must_use]
+ pub fn resolve<'ir>(&'ir self, subject: &id::Instruction) -> Option> {
+ let (id, kind) = self.instructions.get_key_value(subject)?;
+
+ let input_sources = self.input_sources(subject)?.collect();
+ let output_targets = self.output_targets(subject)?.collect();
+
+ Some(InstructionRef {
+ id,
+ kind,
+ input_sources,
+ output_targets,
+ })
+ }
+
+ /// Returns the instruction this input belongs to.
+ ///
+ /// The same caveats as for [`GraphIr::resolve`] apply.
+ #[must_use]
+ pub fn owner_of_input<'ir>(&'ir self, input: &id::Input) -> Option> {
+ self.resolve(&input.socket().belongs_to)
+ }
+
+ /// Returns the instruction this output belongs to.
+ ///
+ /// The same caveats as for [`GraphIr::resolve`] apply.
+ #[must_use]
+ pub fn owner_of_output<'ir>(&'ir self, output: &id::Output) -> Option> {
+ self.resolve(&output.socket().belongs_to)
+ }
+
+ /// Returns the order in which the instructions could be visited
+ /// in order to ensure that all dependencies are resolved
+ /// before a vertex is visited.
+ ///
+ /// # Panics
+ ///
+ /// Panics if there are any cycles in the IR, as it needs to be a DAG.
+ #[must_use]
+ // yes, this function could probably return an iterator and be lazy
+ // no, not today
+ pub fn topological_sort(&self) -> Vec {
+ // count how many incoming edges each vertex has
+ let mut nonzero_input_counts: Map<_, NonZeroUsize> =
+ self.rev_edges
+ .iter()
+ .fold(Map::new(), |mut count, (input, _)| {
+ let _ = *count
+ .entry(input.socket().belongs_to.clone())
+ .and_modify(|count| *count = count.saturating_add(1))
+ .or_insert(NonZeroUsize::MIN);
+ count
+ });
+
+ // are there any unconnected ones we could start with?
+ // TODO: experiment if a VecDeque with some ordering fun is digested better by the executor
+ let no_inputs: Vec<_> = {
+ let nonzero: Set<_> = nonzero_input_counts.keys().collect();
+ let all: Set<_> = self.instructions.keys().collect();
+ all.difference(&nonzero).copied().cloned().collect()
+ };
+
+ // then let's find the order!
+ let mut order = Vec::new();
+ let mut active_queue = no_inputs;
+
+ while let Some(current) = active_queue.pop() {
+ // now that this vertex is visited and resolved,
+ // make sure all dependents notice that
+
+ let dependents = self
+ .output_targets(¤t)
+ .expect("graph to be consistent")
+ .flatten()
+ .flatten();
+
+ for dependent_input in dependents {
+ let dependent = &dependent_input.socket().belongs_to;
+
+ // how many inputs are connected to this dependent without us?
+ let count = nonzero_input_counts
+ .get_mut(dependent)
+ .expect("connected output must refer to non-zero input");
+
+ let new = NonZeroUsize::new(count.get() - 1);
+ if let Some(new) = new {
+ // aww, still some
+ *count = new;
+ continue;
+ }
+
+ // none, that means this one is free now! let's throw it onto the active queue then
+ let (now_active, _) = nonzero_input_counts
+ .remove_entry(dependent)
+ .expect("connected output must refer to non-zero input");
+ active_queue.push(now_active);
+ }
+
+ // TODO: check if this instruction is "well-fed", that is, has all the inputs it needs,
+ // and if not, panic
+ order.push(self.resolve(¤t).expect("graph to be consistent"));
+ }
+
+ assert!(
+ nonzero_input_counts.is_empty(),
+ concat!(
+ "topological sort didn't cover all instructions\n",
+ "either there are unconnected inputs, or there is a cycle\n",
+ "unresolved instructions:\n",
+ "{:#?}"
+ ),
+ nonzero_input_counts,
+ );
+
+ order
+ }
+}
+
+/// Constructs an [`id::Socket`] a bit more tersely.
+fn socket(id: &id::Instruction, idx: u16) -> id::Socket {
+ id::Socket {
+ belongs_to: id.clone(),
+ idx: id::SocketIdx(idx),
+ }
+}
+
+/// A full instruction bundeled in context, with its inputs and outputs.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Instruction {
+ pub id: id::Instruction,
+ pub kind: instruction::Kind,
+
+ // can't have these two public since then a user might corrupt their length
+ input_sources: Vec