From 630de7a30cc820c9ad6591e2ed1feee7061e1c2b Mon Sep 17 00:00:00 2001 From: Mattia Giambirtone Date: Mon, 23 May 2022 23:15:09 +0200 Subject: [PATCH] Fixed typo --- .gitignore | 4 +- LICENSE | 222 ++++-- Makefile | 5 + README.md | 80 +- docs/bytecode.md | 72 ++ docs/grammar.md | 1 + docs/manual.md | 188 +++++ peon | Bin 0 -> 991584 bytes src/backend/types.nim | 54 ++ src/backend/vm.nim | 312 ++++++++ src/config.nim | 55 ++ src/frontend/compiler.nim | 1353 ++++++++++++++++++++++++++++++++ src/frontend/lexer.nim | 641 +++++++++++++++ src/frontend/meta/ast.nim | 701 +++++++++++++++++ src/frontend/meta/bytecode.nim | 228 ++++++ src/frontend/meta/errors.nim | 34 + src/frontend/meta/token.nim | 89 +++ src/frontend/parser.nim | 1155 +++++++++++++++++++++++++++ src/main.nim | 359 +++++++++ src/memory/allocator.nim | 87 ++ src/peon/stdlib/arithmetics.pn | 193 +++++ src/tests.pn | 5 + src/util/debugger.nim | 174 ++++ src/util/multibyte.nim | 61 ++ src/util/serializer.nim | 241 ++++++ tests/test.pn | 1 + 26 files changed, 6259 insertions(+), 56 deletions(-) create mode 100644 Makefile create mode 100644 docs/bytecode.md create mode 100644 docs/grammar.md create mode 100644 docs/manual.md create mode 100755 peon create mode 100644 src/backend/types.nim create mode 100644 src/backend/vm.nim create mode 100644 src/config.nim create mode 100644 src/frontend/compiler.nim create mode 100644 src/frontend/lexer.nim create mode 100644 src/frontend/meta/ast.nim create mode 100644 src/frontend/meta/bytecode.nim create mode 100644 src/frontend/meta/errors.nim create mode 100644 src/frontend/meta/token.nim create mode 100644 src/frontend/parser.nim create mode 100644 src/main.nim create mode 100644 src/memory/allocator.nim create mode 100644 src/peon/stdlib/arithmetics.pn create mode 100644 src/tests.pn create mode 100644 src/util/debugger.nim create mode 100644 src/util/multibyte.nim create mode 100644 src/util/serializer.nim create mode 100644 tests/test.pn diff --git a/.gitignore b/.gitignore index 750bcf3..45557ef 100644 --- a/.gitignore +++ b/.gitignore @@ -2,4 +2,6 @@ nimcache/ nimblecache/ htmldocs/ - +*.pbc # Peon bytecode files +stdin.pbc +tests.pbc diff --git a/LICENSE b/LICENSE index eb2e968..261eeb9 100644 --- a/LICENSE +++ b/LICENSE @@ -1,85 +1,201 @@ -The Artistic License 2.0 + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ -Copyright (c) 2000-2006, The Perl Foundation. + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION -Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. + 1. Definitions. -Preamble + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. -This license establishes the terms under which a given free software Package may be copied, modified, distributed, and/or redistributed. The intent is that the Copyright Holder maintains some artistic control over the development of that Package while still keeping the Package available as open source and free software. + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. -You are always permitted to make arrangements wholly outside of this license directly with the Copyright Holder of a given Package. If the terms of this license do not permit the full use that you propose to make of the Package, you should contact the Copyright Holder and seek a different licensing arrangement. + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. -Definitions + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. - "Copyright Holder" means the individual(s) or organization(s) named in the copyright notice for the entire Package. + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. - "Contributor" means any party that has contributed code or other material to the Package, in accordance with the Copyright Holder's procedures. + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. - "You" and "your" means any person who would like to copy, distribute, or modify the Package. + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). - "Package" means the collection of files distributed by the Copyright Holder, and derivatives of that collection and/or of those files. A given Package may consist of either the Standard Version, or a Modified Version. + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. - "Distribute" means providing a copy of the Package or making it accessible to anyone else, or in the case of a company or organization, to others outside of your company or organization. + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." - "Distributor Fee" means any fee that you charge for Distributing this Package or providing support for this Package to another party. It does not mean licensing fees. + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. - "Standard Version" refers to the Package if it has not been modified, or has been modified only in ways explicitly requested by the Copyright Holder. + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. - "Modified Version" means the Package, if it has been changed, and such changes were not explicitly requested by the Copyright Holder. + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. - "Original License" means this Artistic License as Distributed with the Standard Version of the Package, in its current version or as it may be modified by The Perl Foundation in the future. + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: - "Source" form means the source code, documentation source, and configuration files for the Package. + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and - "Compiled" form means the compiled bytecode, object code, binary, or any other form resulting from mechanical transformation or translation of the Source form. + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and -Permission for Use and Modification Without Distribution + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and -(1) You are permitted to use the Standard Version and create and use Modified Versions for any purpose without restriction, provided that you do not Distribute the Modified Version. + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. -Permissions for Redistribution of the Standard Version + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. -(2) You may Distribute verbatim copies of the Source form of the Standard Version of this Package in any medium without restriction, either gratis or for a Distributor Fee, provided that you duplicate all of the original copyright notices and associated disclaimers. At your discretion, such verbatim copies may or may not include a Compiled form of the Package. + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. -(3) You may apply any bug fixes, portability changes, and other modifications made available from the Copyright Holder. The resulting Package will still be considered the Standard Version, and as such will be subject to the Original License. + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. -Distribution of Modified Versions of the Package as Source + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. -(4) You may Distribute your Modified Version as Source (either gratis or for a Distributor Fee, and with or without a Compiled form of the Modified Version) provided that you clearly document how it differs from the Standard Version, including, but not limited to, documenting any non-standard features, executables, or modules, and provided that you do at least ONE of the following: + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. - (a) make the Modified Version available to the Copyright Holder of the Standard Version, under the Original License, so that the Copyright Holder may include your modifications in the Standard Version. - (b) ensure that installation of your Modified Version does not prevent the user installing or running the Standard Version. In addition, the Modified Version must bear a name that is different from the name of the Standard Version. - (c) allow anyone who receives a copy of the Modified Version to make the Source form of the Modified Version available to others under + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. - (i) the Original License or - (ii) a license that permits the licensee to freely copy, modify and redistribute the Modified Version using the same licensing terms that apply to the copy that the licensee received, and requires that the Source form of the Modified Version, and of any works derived from it, be made freely available in that license fees are prohibited but Distributor Fees are allowed. + END OF TERMS AND CONDITIONS -Distribution of Compiled Forms of the Standard Version or Modified Versions without the Source + APPENDIX: How to apply the Apache License to your work. -(5) You may Distribute Compiled forms of the Standard Version without the Source, provided that you include complete instructions on how to get the Source of the Standard Version. Such instructions must be valid at the time of your distribution. If these instructions, at any time while you are carrying out such distribution, become invalid, you must provide new instructions on demand or cease further distribution. If you provide valid instructions or cease distribution within thirty days after you become aware that the instructions are invalid, then you do not forfeit any of your rights under this license. + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. -(6) You may Distribute a Modified Version in Compiled form without the Source, provided that you comply with Section 4 with respect to the Source of the Modified Version. + Copyright [yyyy] [name of copyright owner] -Aggregating or Linking the Package + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at -(7) You may aggregate the Package (either the Standard Version or Modified Version) with other packages and Distribute the resulting aggregation provided that you do not charge a licensing fee for the Package. Distributor Fees are permitted, and licensing fees for other components in the aggregation are permitted. The terms of this license apply to the use and Distribution of the Standard or Modified Versions as included in the aggregation. + http://www.apache.org/licenses/LICENSE-2.0 -(8) You are permitted to link Modified and Standard Versions with other works, to embed the Package in a larger work of your own, or to build stand-alone binary or bytecode versions of applications that include the Package, and Distribute the result without restriction, provided the result does not expose a direct interface to the Package. - -Items That are Not Considered Part of a Modified Version - -(9) Works (including, but not limited to, modules and scripts) that merely extend or make use of the Package, do not, by themselves, cause the Package to be a Modified Version. In addition, such works are not considered parts of the Package itself, and are not subject to the terms of this license. - -General Provisions - -(10) Any use, modification, and distribution of the Standard or Modified Versions is governed by this Artistic License. By using, modifying or distributing the Package, you accept this license. Do not use, modify, or distribute the Package, if you do not accept this license. - -(11) If your Modified Version has been derived from a Modified Version made by someone other than you, you are nevertheless required to ensure that your Modified Version complies with the requirements of this license. - -(12) This license does not grant you the right to use any trademark, service mark, tradename, or logo of the Copyright Holder. - -(13) This license includes the non-exclusive, worldwide, free-of-charge patent license to make, have made, use, offer to sell, sell, import and otherwise transfer the Package with respect to any patent claims licensable by the Copyright Holder that are necessarily infringed by the Package. If you institute patent litigation (including a cross-claim or counterclaim) against any party alleging that the Package constitutes direct or contributory patent infringement, then this Artistic License to you shall terminate on the date that such litigation is filed. - -(14) Disclaimer of Warranty: -THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES. THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT PERMITTED BY YOUR LOCAL LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER OR CONTRIBUTOR WILL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..f953db0 --- /dev/null +++ b/Makefile @@ -0,0 +1,5 @@ +run: + nim --hints:off --warnings:off r src/test.nim + +pretty: + nimpretty src/*.nim src/backend/*.nim src/frontend/*.nim src/frontend/meta/*.nim src/memory/*.nim src/util/*.nim diff --git a/README.md b/README.md index b25d468..7eb6ec7 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,79 @@ -# peon +# The peon programming language -Peon is a simple, functional, async-first programming language with a focus on correctness and speed \ No newline at end of file +Peon is a simple, functional, async-first programming language with a focus on correctness and speed. + +[Go to the Manual](docs/manual.md) + + +## Project structure + +- `src/` -> Contains the entirety of peon's toolchain + - `src/memory/` -> Contains peon's memory allocator and GC (TODO) + - `src/frontend/` -> Contains the tokenizer, parser and compiler + - `src/frontend/meta/` -> Contains shared error definitions, AST node and token + declarations as well as the bytecode used by the compiler + - `src/backend/` -> Contains the peon VM and type system + - `src/util/` -> Contains utilities such as the bytecode debugger and serializer as well + as procedures to handle multi-byte sequences + - `src/config.nim` -> Contains compile-time configuration variables + - `src/main.nim` -> Ties up the whole toolchain together by tokenizing, + parsing, compiling, debugging, (de-)serializing and executing peon code +- `docs/` -> Contains documentation for various components of peon (bytecode, syntax, etc.) +- `tests/` -> Contains tests (both in peon and Nim) for the toolchain + + +## Credits + +- Araq, for creating the amazing language that is [Nim](https://nim-lang.org) +- The Nim community and contributors, for making Nim what it is today +- Bob Nystrom, for his amazing [book](https://craftinginterpreters.com) that inspired me + and taught me how to actually make a programming language +- [Njsmith](https://vorpus.org/), for his awesome articles on structured concurrency + + +## Project State + +**Disclaimer**: The project is still in its very early days: lots of stuff is not implemented, a work in progress or +otherwise outright broken. Feel free to report bugs! + +Also, yes: peon is yet another programming language inspired by Bob's book, but it is also **very** +different from Lox, which is an object-oriented, dynamically typed and very high level programming language, whereas +peon is a statically-typed, functional language which aims to allow low-level interfacing with C and Nim code while +being a breeze to use. + +Also, peon will feature [structured concurrency](https://vorpus.org/blog/notes-on-structured-concurrency-or-go-statement-considered-harmful/) with coroutines (think Futures/Fibers but without +callback hell). Since, unlike Lox, peon isn't a toy language, there's obviously plans to implement creature comforts +like an import system, exception handling, a package manager, etc. + + +### TODO List + +In no particular order, here's a list of stuff that's done/to do (might be incomplete/out of date): + +Toolchain: + + - Tokenizer (with dynamic symbol table) [x] + - Parser (with support for custom operators, even builtins) [x] + - Compiler [ ] (Work in Progress) + - VM [ ] (Work in Progress) + - Bytecode (de-)serializer [x] + - Static code debugger [x] + - Runtime debugger/inspection tool [ ] + +Type system: + + - Custom types [ ] + - Intrinsics [x] + - Generics [ ] (Work in Progress) + - Function calls [ ] (Work in Progress) + +Misc: + + - Pragmas [ ] (Work in Progress) + - Attribute resolution [ ] + - ... More? + +## The name + +The name for peon comes from my and [Productive2's](https://git.nocturn9x.space/prod2) genius and is a result of shortening +the name of the fastest animal on earth: the **Pe**regrine Falc**on**. I guess I wanted this to mean peon will be blazing fast \ No newline at end of file diff --git a/docs/bytecode.md b/docs/bytecode.md new file mode 100644 index 0000000..485ee15 --- /dev/null +++ b/docs/bytecode.md @@ -0,0 +1,72 @@ +# Peon - Bytecode Specification + +This document aims to document peon's bytecode as well as how it is (de-)serialized to/from files and +other file-like objects. + +## Code Structure + +A peon program is compiled into a tightly packed sequence of bytes that contain all the necessary information +the VM needs to execute said program. There is no dependence between the frontend and the backend outside of the +bytecode format (which is implemented in a separate serialiazer module) to allow for maximum modularity. + +A peon bytecode dump contains: + +- Constants +- The bytecode itself +- Debugging information +- File and version metadata + +## Encoding + +### Header + +A peon bytecode file starts with the header, which is structured as follows: + +- The literal string `PEON_BYTECODE` +- A 3-byte version number (the major, minor and patch versions of the compiler that generated the file as per the SemVer versioning standard) +- The branch name of the repository the compiler was built from, prepended with its length as a 1 byte integer +- The full commit hash (encoded as a 40-byte hex-encoded string) in the aforementioned branch from which the compiler was built from (particularly useful in development builds) +- An 8-byte UNIX timestamp (with Epoch 0 starting at 1/1/1970 12:00 AM) representing the exact date and time of when the file was generated +- A 32-byte, hex-encoded SHA256 hash of the source file's content, used to track file changes + +### Line data section + +The line data section contains information about each instruction in the code section and associates them +1:1 with a line number in the original source file for easier debugging using run-length encoding. The section's +size is fixed and is encoded at the beginning as a sequence of 4 bytes (i.e. a single 32 bit integer). The data +in this section can be decoded as explained in [this file](../src/frontend/meta/bytecode.nim#L28), which is quoted +below: +``` +[...] +## lines maps bytecode instructions to line numbers using Run +## Length Encoding. Instructions are encoded in groups whose structure +## follows the following schema: +## - The first integer represents the line number +## - The second integer represents the count of whatever comes after it +## (let's call it c) +## - After c, a sequence of c integers follows +## +## A visual representation may be easier to understand: [1, 2, 3, 4] +## This is to be interpreted as "there are 2 instructions at line 1 whose values +## are 3 and 4" +## This is more efficient than using the naive approach, which would encode +## the same line number multiple times and waste considerable amounts of space. +[...] +``` + +### Constant section + +The constant section contains all the read-only values that the code will need at runtime, such as hardcoded +variable initializers or constant expressions. It is similar to the `.rodata` section of Assembly files, although +the implementation is different. Constants are encoded as a linear sequence of bytes with no type information about +them whatsoever: it is the code that, at runtime, loads each constant (whose type is determined at compile time) onto +the stack accordingly. For example, a 32 bit integer constant would be encoded as a sequence of 4 bytes, which would +then be loaded by the appropriate `LoadInt32` instruction at runtime. The section's size is fixed and is encoded at +the beginning as a sequence of 4 bytes (i.e. a single 32 bit integer). The constant section may be empty, although in +real-world scenarios it's unlikely that it would. + +### Code section + +The code section contains the linear sequence of bytecode instructions of a peon program. It is to be read directly +and without modifications. The section's size is fixed and is encoded at the beginning as a sequence of 3 bytes +(i.e. a single 24 bit integer). \ No newline at end of file diff --git a/docs/grammar.md b/docs/grammar.md new file mode 100644 index 0000000..f87f5c1 --- /dev/null +++ b/docs/grammar.md @@ -0,0 +1 @@ +# TODO \ No newline at end of file diff --git a/docs/manual.md b/docs/manual.md new file mode 100644 index 0000000..07317b7 --- /dev/null +++ b/docs/manual.md @@ -0,0 +1,188 @@ +# Peon - Manual + +Peon is a functional, statically typed, garbage-collected, C-like programming language with +a focus on speed and correctness, but whose main feature is the ability to natively +perform highly efficient parallel I/O operations by implementing the [structured concurrency](https://vorpus.org/blog/notes-on-structured-concurrency-or-go-statement-considered-harmful/) +paradigm. + +__Note__: Peon is currently a WIP (Work In Progress), and much of the content of this manual is purely theoretical as +of now. If you want to help make this into a reality, feel free to contribute! + + +## Table of contents + +- [Manual](#peon---manual) +- [Design Goals](#design-goals) +- [Examples](#peon-by-example) +- [Grammar](grammar.md) +- [Bytecode](bytecode.md) + +## Design Goals + +While peon is inspired from Bob Nystrom's [book](https://craftinginterpreters.com), where he describes a simple toy language +named Lox, the aspiration for it is to become a programming language that could actually be used in the real world. For that +to happen, we need: + +- Exceptions (`try/except/finally`) +- An import system (with namespaces, like Python) +- Multithreading support (with a global VM lock when GC'ing) +- Built-in collections (list, tuple, set, etc.) +- Coroutines (w/ structured concurrency) +- Generators +- Generics +- C/Nim FFI +- A package manager + +Peon ~~steals~~ borrows many ideas from Python and Nim (the latter being the language peon itself is written in). + +## Peon by Example + +Here follow a few examples of peon code to make it clear what the end product should look like + +### Variable declarations + +``` +var x = 5; # Inferred type is int64 +var y = 3'u16; # Type is specified as uint16 +x = 6; # Works: type matches +x = 3.0; # Cannot assign float64 to x +var x = 3.14; # Cannot re-declare x +``` + +__Note__: Peon supports [name stropping](https://en.wikipedia.org/wiki/Stropping_(syntax)), meaning + that almost any ASCII sequence of characters can be used as an identifier, including language + keywords, but stropped names need to be enclosed by matching pairs of backticks (`\``) + +### Functions + +``` +fn fib(n: int): int { + if (n < 3) { + return n; + } + return fib(n - 1) + fib(n - 2); +} + +fib(30); +``` + +### Type declarations + +``` +type Foo = object { # Can also be "ref object" for reference types (managed automatically) + fieldOne*: int # Asterisk means the field is public outside the current module + fieldTwo*: int +} +``` + +### Operator overloading + +``` +operator `+`(a, b: Foo) { + return Foo(fieldOne: a.fieldOne + b.fieldOne, fieldTwo: a.fieldTwo + b.fieldTwo); +} + +Foo(fieldOne: 1, fieldTwo: 3) + Foo(fieldOne: 2, fieldTwo: 3); # Foo(fieldOne: 3, fieldTwo: 6) +``` + +__Note__: Custom operators (e.g. `foo`) can also be defined! The backticks around the plus sign serve to mark it +as an identifier instead of a symbol (which is a requirement for function names, since operators are basically +functions). In fact, even the built-in peon operators are implemented partially in peon (well, their forward +declarations are) and they are then specialized in the compiler to emit a single bytecode instruction. + +### Function calls + +``` +foo(1, 2 + 3, 3.14, bar(baz)); +``` + +__Note__: Operators can be called as functions too. Just wrap their name in backticks, like so: +``` +`+`(1, 2) +``` + +__Note__: Code the likes of `a.b()` is desugared to `b(a)` if there exists a function `b` whose + signature is compatible with the value of of `a` (assuming `a` doesn't have a `b` field, in + which case the attribute resolution takes precedence) + + +### Generic declarations + +``` +fn genericSum[T](a, b: T): T { # Note: "a, b: T" means that both a and b are of type T + return a + b; +} + +# This allows for a single implementation to be +# re-used multiple times without any code duplication! +genericSum(1, 2); +genericSum(3.14, 0.1); +genericSum(1'u8, 250'u8); +``` + +#### Multiple generics + +``` +fn genericSth[T, K](a: T, b: K) { # Note: no return type == void function! + # code... +} + +genericSth(1, 3.0); +``` + +__Note__: The `*` modifier to make a name visible outside the current module must be put +__before__ generics declarations, so only `fn foo*[T](a: T) {}` is the correct syntax + +### Forward declarations + +``` +fn someF: int; # Semicolon, no body! + +someF(); # This works! + +fn someF: int { + return 42; +} +``` + +### Generators + +``` +generator count(n: int): int { + while (n > 0) { + yield n; + n -= 1; + } +} + +foreach (n: count(10)) { + print(n); +} +``` + + +### Coroutines + +``` +import concur; +import http; + + +coroutine req(url: string): string { + return (await http.AsyncClient().get(url)).content; +} + + +coroutine main(urls: list[string]) { + pool = concur.pool(); # Creates a task pool: like a nursery in njsmith's article + for (var i = 0; i < urls.len(); i += 1) { + pool.spawn(req, urls[i]); + } + # The pool has internal machinery that makes the parent + # task wait until all child exit! When this function + # returns, ALL child tasks will have exited somehow +} + + +concur.run(main, newList[string]("https://google.com", "https://debian.org")) +``` \ No newline at end of file diff --git a/peon b/peon new file mode 100755 index 0000000000000000000000000000000000000000..04b46edfdf02f0af2697bdcd70e0afe457fbabb3 GIT binary patch literal 991584 zcmeFad3+RQ5T#0Oa74ahEcP9l$?5~xOzog6cSG$*%*xyK@-jgoM%fWgd{GE2k zW>R2({d7`aM$03C-zPUy1?{h&jV}` zPw@AbeFYq`zqY5jT^eUI`*V7ksei%7Q!rjUL;TMHwBD;J2N3)au z&a>Wsa@2n>o_o`A*WFt-{?+7R^D5R7hkB5PIQ%1w|Jgs%?}z`0BlgKFj#T9p_8^S% z@o&J+H|{iX%(%i~-z02z(gNSVTY$mVzI%JQ9v5NoyK}&=%mJU8gFodi#(%-Te*+L! z@5mf{Cgy;*=HT-{4*aD#@Vj!r>vHh9GY9;Q9DGW1;2)C%zaODON{2VX{^M|i`;B#(%-T^K#(dn*)9#80;Qog8R?$-&Tampp*rcSwPLS*8UsS_@l9+_5g$+U4ZBH%jd zqG>ZCV=tRfF27?j0*p7jr;VF(No3;G>EkaZQRK4nnd5;vvEmXBG-VRlM#{&drg7!v zGb0nH&zJz3@l&T?CIscvFN{nqpD=YQYMd|)l|=C0;sOGK-Qmra;(@pO_y#`5vtD)o<_I$_+* z2{R!G{+TZ9c{gSH`0}a3VaAoLL<=X*oG|V}*avr)OdkuS#+6T*eo17)tSJ!aikVZ& zX=|8y{KaF(Pri8U#Bo!=gI1deV0i>eq6E^EPnk9$0=rG)KzT5)#_QFwCmuKQsIdp^ zd*Fc)d%6EX?xlCN{~<2$Ko5GrzC-9lJ>-8IaV$00Juns$8g=g#$No#ao;k`ChZvi< z7#v4?Mi#>tZT|4YpZ<(tb(2Wiz;2cMo{?4NzW0zuP1J4BDvkZK706x#a z+XC>Ufja?sy@7WI;P)DMR{;Kifk%GOJl(d}V+NidfInm4g#q{q11}1|Uor6F0Q?;T z?;n7FZs3Ch@NW%#XaK(6z)J$~{G+se;{kY~ftLp0+Z%XU0G@Y(@|hff_cHJq0r)ls zJ}Us<$-t`u@I4K@HUQt>z*7PE2m`MVz>hcZh5&rDfj0%<=NWi&06x{gTLSP|2HqBc z&oOW(0IxIf&H(&o1MdpJ?=kSmx@(LjeAufj0)=j~RGV0RE(bHwWO047?=( zUvA(l1Mrmwo(aHTHt^K}`0EDV7J$EF;7$PEX5gIxc)Njj1>j#Ac%&=a|Gzcx`~bYm zzzYNLUktn`0FO-4epDQQ=Nowc0DMaW9~^-9G4P=Qc(H+(1mJracsu|fWZR>-VlH% z4ZJY`zumx_0`Pkcyg2}W(7;;)@W%{%WdQz+fwu+V=U%0L;soFq8hB>_KGndx0`PJJ zkNlYJ&sQ6GegJ-*ffokgDFZJG!2e?4#R2$(2Hrmaf5N~A2jGhhd}sikHt>=Fe3gO6 z1Ms&Eyfgs+*uc*Wz`r!`vH<)?1D_m#Z*;Y`%ZvcLmx0d;z_&B-ssMa<1FsFh_c8EP z0DiE6*9YJu4ZI-$A7$W;0r(jP-V}h3Gw|jB{2~Ky3BWHm@Rb30wSi{>@EZ+$bpZZn z18)n!?=f&E0DsWHI|J|q2Hq8bKV#sLpR)abnStjA;4d0@VF3P`ffohfZy9)T0KUe+ z`v>6d20l0d|JJ}u0`QV+)ZgL(c$tBh2H;f&UKW6-W-Fh`0r(69pAmqU%u)PV0eHsX zR|Vjyxr$#Kgd6-+0A5wC`1JvJgMl{$;GOdnzcBzWtWkJN0A6~t!dC|1GYmWvfTs++ zEdX!1Q~5Xnc*ejx1Mu?}D1KJ}eu05Ue$Mv8Nd}%DfKM~5O#D-66i0KeM6 z`v>6F20l0dztO;l2Hx*9PDX2A&GQ zTMWED0B5_;wlN zhXMFb2HqKf?{45-0eF7{kC^>xyAHOWf#(O{Lkzqy06*NoivsYG23{P1A7|kG1MpJ} zd~g7MmVplqz|S}Ek^p?XfyV>ziwwLp0Kd$@&kVq48+cg&eyxE|4#2N7@EHMk!oaHn z@UnJo$JzkA%D__rc!Po02jDFR-VlJd8F*s=9{F7BZ3@7P4ZJx3FEQ|z0KCk=R|eo! z2A&DP8w`AP0N!HYlLPxm_CB*-<0SXW{rl*veQ=i9zcwFy2Mffn|cowZu>UN;y$=N>p*y^4{nZF5F9zv2UpJ#aHPx!*A`OvWFK55 zQ}_%Yd`kt%zq5Ss0w27}2e*4WEUxvzxANhqd~pB1bG;9~jSs)U2j{sC``74$_pw0y zHu>P&`ryqz_;x;ciw|DpgRk_#xA(y_KKPD4_-Y^Ae;B0A2j`x>{d0WqT`Um4oj&-k zK6sZ8UhIQMOn;-RSAITdNo$o(qba|+VlBKI%xo>PzZCb?hEdrrOD8|403-g64lo|5~=dCw_WdzIWj z%zLJd?K9;5KHhT*(q1O_ck-T7kM>fzznS-(ac++WLkPBGex<^C$( zb869EDEBjY&nZQFMD8!*J*N`woxcIl?*iU)3enys_h<8-Q-}79+@H#OP8r%;QxCuaf({dC#dp`wY3?o%fsqw3o^K4!mdT z-(D*BTl1b%)%Fs(-;DR10<;g7`yRY!>fc^0_dmUYd#3#Dg>wH5@0seiN96u<-ZRB- z@BEeef5`h{-nYs9+q`E=-=2~CRlH{^-`*nkFY%r!e0!7JFXuf|_x1+4f0p-5+1pcc z|2XfNs<&6k{lmOxirzj$?(gG0Q}gyR+|z&e|Khm1*UpdEeHgF)xU+P0Z2y-1UyLV* zPq}5Y$of7VFZYUkH*w#BUFU%W^VQ_=7r`K&j8cyHu&(kxaQ#<+MAzSReOtk`=oq}cw+dc|3=^HGZ`RfJZ#$<9Sy|1^PczQeSV^M&HhJz?UR5z z20YMl2gmCwop@bETfA<}>UcWFbLx?J0@sOAZSh15Wv|5R(#{IlDqa`sO1=2Jp)3Yv z7brVH>3{S)_3^qa=WnwzkMi+>+&?LJ< zL6&g&2FRb^C3G-ctTCPtcc7ATorrWqo5=x;n@Phd9cUIB8lK9g)tf<(isxl6jXuMO z7>6a2v8H$(thchdEpJ{+dDPkRTcQG5({kmGa`7w#;oqDk!Um#U|DLdGvh~-!Nr69o zUs+Npg}m}_Kp@URtSlMbtGfyXmIXAbTiy}nIdoRv93PgMd4Mg1>$7!?uJL5)`i@QF z>E#qkaJ9CTYlO5uUfs3bwUJ@Ifj_NZZ+v*}+6Jk9@np(b_Y}v2 z?*4GWozkw&u+JuXxe_L80VVwbexXg2cD800LCIlcnvA}UC&I*!5;bIu%UYHmuBD4? zX*!k?BcSL=E&8i1s;;aZUvS;$@B|W;Xlb=AO@Lorte!<9v}m%wXqnR^{_OML_dj?3 z^6&e{*L@hT%ftyYVvJOhAuh=na05nL54c}E*}Dei5nd7ko1(Ge12XZv7BFZKL)%77 zxsB+2ppqV?yx*#~1^@-Rb$oal1(zdU>irVlvhkZpC(T-#2gAL1`(}}Xg&X&XCr7oR z#nB&Ls_j8F5f*9KxrVQG#ZGte1h`W)z3qk96dX<^6wdFQ2B{U`01bBCT|Qh zx!k)pT`U0#0V63*{^o5tntYVCohj*-d_uiuNrF15KVKTCmAa61lX=X}Xh@&p-Tpnwg))2gXtx@|~zK8dW8IB#99` zQKNw@?QHoY!r#|jA>nVI@7?fMy|xsiVKYXpP!7GawL#<%*DD`BP=gVY$lIA>lVTEGO29KuwT` zu9+!Q!A`J59AygXIKHxUoR$uOI7SllnWGPGmFBWP#0_JIEY;)bD@^5 zMY0I!>UcJTs57<$6_I4!YEqG8f|5LANf=wbgh8&mB@7dlrpD0Nj)1YRCEME?vja@q z=Td#6%@!I%hSszGLmc?G5k#A;`AtAgUtIqSeDMwR zgKoJ&!8fiiBDeLj#zK?4&cW0NhU}iaPDDXi@_G^pvXa-s4aAqc=4~2CUW)_=#*c1^ zD^H9vo4j`KuK)RyMj`Z$ReG7DyY9`QF&)!n6sEd|{U90ri;w6&1>Iml>KP630m!Vz zG&^UI0~;hUhKW^g$)1r|t?G1*SG{%vqE>pMUSX?%AZW5cemw`nVQXxu_yzqPVjklo zSfro>Ey#*FYi+1lo39Vk>2rD&~V-5`AqpT`rT=(2$kn}BTtvgGtDAv za=wJ?9+c)`qS0b?%&am$D)x~ETdW?S=nK(dRT{Lq6El&D-AMS8687|01NQd<8S^n` zAgbxs%O3jj_x1g4zU$8q>tzmqJ{z4Gg1FKCpDIv=N2IO}ZI%=o1UBN!zZTEjIZBhJjHfK+8d_(7^d@t!#zysd<5EV zb{zKyq+6x6&~MCT4m)nG(up0H3|1qyEmzk)943^pizZ6;sS|La7%bVRMQSK5bc2f6 zv82f8AUf@Z?hD&C#p^~EA(?HClyhc`4x*kyN8$sT5OR>U3b>4DR$!kZ0ltQ+H{w-t z$cX|-JMXojPoa*RKxejaS{@XU6N@}_Jb*lI#$yO})^B{Nl~$1QSpW;>EHy$RHAKDeyiCr}y3 z?(T+)dcyRu{6mF_sxa=jjYU9u$iEYzhWY{6&Ipo(4AcYufLzm*FO77Ots+#eX*%Ax za&ciAL_;hQ#~7~x=Y0#g9+I(#;Ws;h_><$a*I?MoK?AlS=U}(&0$;|E)q!=%eV`0N z&Hu}FNv>j6S9V6qkB7lJnT&H@%FAS&fv!tHGxRdA)2whN)Duz20wK$jrAsW>`Bo#V z*V@i{z*hG>#SRnAgi%@v<};90TQVf6kRZp5>QE z4A;GVpZ4Ur$W{?*v_Sqi+#(0E!SMXCz+nF$=Z|mJ*)XO_&<69zDIfdnpF`hQlp*bZ zmE|3(Z;t#i<`HRV`@hN`mwxp7lJ4tCnyEEb2$eLDKi=;lyAuAN<&V2{lP

o#P+S4{S| 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%0AVjGwzc|K8+vn+{e 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

*3VHn0R+6}{|rBGM662dl$^2UoacNw$SU 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

)YV5+x7zJtO4&ComdC1KY>OkHk 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 z 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%0A>KixY^=FBwp5*xV^qJc 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 Hk01UYVZKy< literal 0 HcmV?d00001 diff --git a/src/backend/types.nim b/src/backend/types.nim new file mode 100644 index 0000000..c910c44 --- /dev/null +++ b/src/backend/types.nim @@ -0,0 +1,54 @@ +# Copyright 2022 Mattia Giambirtone & All Contributors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +type + ObjectKind* = enum + ## Enumeration of Peon + ## types + Int8, UInt8, Int16, UInt16, Int32, + UInt32, Int64, UInt64, Float32, Float64, + Char, Byte, String, Function, CustomType, + Nil, Nan, Bool, Inf + PeonObject* = object + ## A generic Peon object + case kind*: ObjectKind: + of Bool: + boolean*: bool + of Inf: + positive*: bool + of Byte: + `byte`*: byte + of Int8: + tiny*: uint8 + of UInt8: + uTiny*: uint8 + of Int16: + short*: int16 + of UInt16: + uShort*: uint16 + of Int32: + `int`*: int32 + of UInt32: + uInt*: uint32 + of Int64: + long*: int64 + of UInt64: + uLong*: uint64 + of Nil, Nan: + discard + of CustomType: + fields*: seq[PeonObject] + else: + discard # TODO diff --git a/src/backend/vm.nim b/src/backend/vm.nim new file mode 100644 index 0000000..22a0aa7 --- /dev/null +++ b/src/backend/vm.nim @@ -0,0 +1,312 @@ +# Copyright 2022 Mattia Giambirtone & All Contributors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +## The Peon runtime environment +import types +import strformat +import ../config +import ../frontend/meta/bytecode +import ../util/multibyte + + +type + PeonVM* = ref object + ## The Peon Virtual Machine + stack: seq[PeonObject] + ip: int # Instruction pointer + cache: array[6, PeonObject] # Singletons cache + chunk: Chunk # Piece of bytecode to execute + frames: seq[int] # Stores the initial index of stack frames + heapVars: seq[PeonObject] # Stores variables that do not have stack semantics (i.e. "static") + + +proc initCache*(self: PeonVM) = + ## Initializes the VM's + ## singletons cache + self.cache[0] = PeonObject(kind: Nil) + self.cache[1] = PeonObject(kind: Bool, boolean: true) + self.cache[2] = PeonObject(kind: Bool, boolean: false) + self.cache[3] = PeonObject(kind: ObjectKind.Inf, positive: true) + self.cache[4] = PeonObject(kind: ObjectKind.Inf, positive: false) + self.cache[5] = PeonObject(kind: ObjectKind.Nan) + + +proc newPeonVM*: PeonVM = + ## Initializes a new, blank VM + ## for executing Peon bytecode + new(result) + result.ip = 0 + result.frames = @[] + result.stack = newSeq[PeonObject]() + result.initCache() + + +## Getters for singleton types (they are cached!) + +proc getNil*(self: PeonVM): PeonObject = self.cache[0] + +proc getBool*(self: PeonVM, value: bool): PeonObject = + if value: + return self.cache[1] + return self.cache[2] + +proc getInf*(self: PeonVM, positive: bool): PeonObject = + if positive: + return self.cache[3] + return self.cache[4] + +proc getNan*(self: PeonVM): PeonObject = self.cache[5] + +## Stack primitives. Note: all stack accessing that goes +## through the get/set wrappers is frame-relative, meaning +## that the index is added to the current stack frame's +## bottom to obtain an absolute stack index. + +proc push(self: PeonVM, obj: PeonObject) = + ## Pushes a Peon object onto the + ## stack + self.stack.add(obj) + + +proc pop(self: PeonVM): PeonObject = + ## Pops a Peon object off the + ## stack, decreasing the stack + ## pointer. The object is returned + return self.stack.pop() + + +proc peek(self: PeonVM): PeonObject = + ## Returns the Peon object at the top + ## of the stack without consuming + ## it + return self.stack[^1] + + +proc get(self: PeonVM, idx: int): PeonObject = + ## Accessor method that abstracts + ## stack accessing through stack + ## frames + return self.stack[idx + self.frames[^1]] + + +proc set(self: PeonVM, idx: int, val: PeonObject) = + ## Setter method that abstracts + ## stack accessing through stack + ## frames + self.stack[idx + self.frames[^1]] = val + + +proc readByte(self: PeonVM): uint8 = + ## Reads a single byte from the + ## bytecode and returns it as an + ## unsigned 8 bit integer + inc(self.ip) + return self.chunk.code[self.ip - 1] + + +proc readShort(self: PeonVM): uint16 = + ## Reads two bytes from the + ## bytecode and returns them + ## as an unsigned 16 bit + ## integer + return [self.readByte(), self.readByte()].fromDouble() + + +proc readLong(self: PeonVM): uint32 = + ## Reads three bytes from the + ## bytecode and returns them + ## as an unsigned 32 bit + ## integer. Note however that + ## the boundary is capped at + ## 24 bits instead of 32 + return uint32([self.readByte(), self.readByte(), self.readByte()].fromTriple()) + + +proc readInt64(self: PeonVM, idx: int): PeonObject = + ## Reads a constant from the + ## chunk's constant table and + ## returns a Peon object. Assumes + ## the constant is an Int64 + var arr = [self.chunk.consts[idx], self.chunk.consts[idx + 1], + self.chunk.consts[idx + 2], self.chunk.consts[idx + 3], + self.chunk.consts[idx + 4], self.chunk.consts[idx + 5], + self.chunk.consts[idx + 6], self.chunk.consts[idx + 7], + ] + result = PeonObject(kind: Int64) + copyMem(result.long.addr, arr.addr, sizeof(arr)) + + +proc readUInt64(self: PeonVM, idx: int): PeonObject = + ## Reads a constant from the + ## chunk's constant table and + ## returns a Peon object. Assumes + ## the constant is an UInt64 + var arr = [self.chunk.consts[idx], self.chunk.consts[idx + 1], + self.chunk.consts[idx + 2], self.chunk.consts[idx + 3], + self.chunk.consts[idx + 4], self.chunk.consts[idx + 5], + self.chunk.consts[idx + 6], self.chunk.consts[idx + 7], + ] + result = PeonObject(kind: UInt64) + copyMem(result.uLong.addr, arr.addr, sizeof(arr)) + + +proc readUInt32(self: PeonVM, idx: int): PeonObject = + ## Reads a constant from the + ## chunk's constant table and + ## returns a Peon object. Assumes + ## the constant is an UInt32 + var arr = [self.chunk.consts[idx], self.chunk.consts[idx + 1], + self.chunk.consts[idx + 2], self.chunk.consts[idx + 3]] + result = PeonObject(kind: UInt32) + copyMem(result.uInt.addr, arr.addr, sizeof(arr)) + + +proc readInt32(self: PeonVM, idx: int): PeonObject = + ## Reads a constant from the + ## chunk's constant table and + ## returns a Peon object. Assumes + ## the constant is an Int32 + var arr = [self.chunk.consts[idx], self.chunk.consts[idx + 1], + self.chunk.consts[idx + 2], self.chunk.consts[idx + 3]] + result = PeonObject(kind: Int32) + copyMem(result.`int`.addr, arr.addr, sizeof(arr)) + + +proc dispatch*(self: PeonVM) = + ## Main bytecode dispatch loop + var instruction: OpCode + while true: + instruction = OpCode(self.readByte()) + when DEBUG_TRACE_VM: + echo &"IP: {self.ip}" + echo &"SP: {self.stack.high()}" + echo &"Stack: {self.stack}" + echo &"Instruction: {instruction}" + discard readLine stdin + case instruction: + # Constant loading + of LoadTrue: + self.push(self.getBool(true)) + of LoadFalse: + self.push(self.getBool(false)) + of LoadNan: + self.push(self.getNan()) + of LoadNil: + self.push(self.getNil()) + of LoadInf: + self.push(self.getInf(true)) + of LoadInt64: + self.push(self.readInt64(int(self.readLong()))) + of LoadUInt64: + self.push(self.readUInt64(int(self.readLong()))) + of LoadUInt32: + self.push(self.readUInt32(int(self.readLong()))) + of Call: + # Calls a function. The calling convention for peon + # functions is pretty simple: the return address sits + # at the bottom of the stack frame, then follow the + # arguments and all temporaries/local variables + let newIp = self.readLong() + # We do this because if we immediately changed + # the instruction pointer, we'd read the wrong + # value for the argument count. Storing it and + # changing it later fixes this issue + self.frames.add(int(self.readLong())) + self.ip = int(newIp) + of OpCode.Return: + # Returns from a void function or terminates the + # program entirely if we're at the topmost frame + if self.frames.len() > 1: + let frame = self.frames.pop() + for i in countdown(self.stack.high(), frame): + discard self.pop() + self.ip = int(self.pop().uInt) + else: + return + of ReturnValue: + # Returns from a function which has a return value, + # pushing it on the stack + let retVal = self.pop() + let frame = self.frames.pop() + for i in countdown(self.stack.high(), frame): + discard self.pop() + self.ip = int(self.pop().uInt) + self.push(retVal) + of StoreVar: + # Stores the value at the top of the stack + # into the given stack index + self.set(int(self.readLong()), self.pop()) + of StoreHeap: + self.heapVars.add(self.pop()) + of LoadHeap: + self.push(self.heapVars[self.readLong()]) + of LoadVar: + self.push(self.get(int(self.readLong()))) + of NoOp: + continue + of Pop: + discard self.pop() + of PopN: + for _ in 0.. 1".} +const PEON_VERSION* = (major: 0, minor: 4, patch: 0) +const PEON_RELEASE* = "alpha" +const PEON_COMMIT_HASH* = "ed79385e2a93100331697f26a4a90157e60ad27a" +when len(PEON_COMMIT_HASH) != 40: + {.fatal: "The git commit hash must be exactly 40 characters long".} +const PEON_BRANCH* = "master" +when len(PEON_BRANCH) > 255: + {.fatal: "The git branch name's length must be less than or equal to 255 characters".} +const DEBUG_TRACE_VM* = true # Traces VM execution +const DEBUG_TRACE_GC* = false # Traces the garbage collector (TODO) +const DEBUG_TRACE_ALLOCATION* = false # Traces memory allocation/deallocation +const DEBUG_TRACE_COMPILER* = false # Traces the compiler +const PEON_VERSION_STRING* = &"Peon {PEON_VERSION.major}.{PEON_VERSION.minor}.{PEON_VERSION.patch} {PEON_RELEASE} ({PEON_BRANCH}, {CompileDate}, {CompileTime}, {PEON_COMMIT_HASH[0..8]}) [Nim {NimVersion}] on {hostOS} ({hostCPU})" +const HELP_MESSAGE* = """The peon programming language, Copyright (C) 2022 Mattia Giambirtone & All Contributors + +This program is free software, see the license distributed with this program or check +http://www.apache.org/licenses/LICENSE-2.0 for more info. + +Basic usage +----------- + +$ peon Opens an interactive session (REPL) +$ peon file.pn Runs the given Peon source file + +Command-line options +-------------------- + +-h, --help Shows this help text and exits +-v, --version Prints the peon version number and exits +-s, --string Executes the passed string as if it was a file +-i, --interactive Enables interactive mode, which opens a REPL session after execution of a file or source string +-c, --nocache Disables dumping the result of bytecode compilation to files for caching +-d, --cache-delay Configures the bytecode cache invalidation threshold, in minutes (defaults to 60) +""" diff --git a/src/frontend/compiler.nim b/src/frontend/compiler.nim new file mode 100644 index 0000000..797fc10 --- /dev/null +++ b/src/frontend/compiler.nim @@ -0,0 +1,1353 @@ +# Copyright 2022 Mattia Giambirtone & All Contributors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import meta/token +import meta/ast +import meta/errors +import ../config +import ../util/multibyte + + +import strformat +import algorithm +import parseutils +import strutils +import sequtils +import os + + +export ast +export token +export multibyte + + +type + TypeKind* = enum + ## An enumeration of compile-time + ## types + Int8, UInt8, Int16, UInt16, Int32, + UInt32, Int64, UInt64, Float32, Float64, + Char, Byte, String, Function, CustomType, + Nil, Nan, Bool, Inf, Typedesc, Generic + Type* = ref object + ## A wrapper around + ## compile-time types + node*: ASTNode + case kind*: TypeKind: + of Function: + args*: seq[Type] + returnType*: Type + else: + discard + +# This way we don't have recursive dependency issues +import meta/bytecode +export bytecode + + +type + Name = ref object + ## A compile-time wrapper around + ## statically resolved names + + # Name of the identifier + name: IdentExpr + # Owner of the identifier (module) + owner: string + # Scope depth + depth: int + # Is this name private? + isPrivate: bool + # Is this a constant? + isConst: bool + # Can this name's value be mutated? + isLet: bool + # The name's type + valueType: Type + # For variables, the position in the bytecode + # where its StoreVar instruction was emitted. + # For functions, this marks where the function's + # code begins + codePos: int + Loop = object + ## A "loop object" used + ## by the compiler to emit + ## appropriate jump offsets + ## for continue and break + ## statements + + # Position in the bytecode where the loop starts + start: int + # Scope depth where the loop is located + depth: int + # Absolute jump offsets into our bytecode that we need to + # patch. Used for break statements + breakPos: seq[int] + + Compiler* = ref object + ## A wrapper around the Peon compiler's state + + # The bytecode chunk where we write code to + chunk: Chunk + # The output of our parser (AST) + ast: seq[Declaration] + # The current AST node we're looking at + current: int + # The current file being compiled (used only for + # error reporting) + file: string + # Compile-time "simulation" of the stack at + # runtime to load variables that have stack + # behavior more efficiently + names: seq[Name] + # Beginning of stack frames for function calls + frames: seq[int] + # The current scope depth. If > 0, we're + # in a local scope, otherwise it's global + scopeDepth: int + # The current function being compiled + currentFunction: FunDecl + # Are optimizations turned on? + enableOptimizations*: bool + # The current loop being compiled (used to + # keep track of where to jump) + currentLoop: Loop + # The current module being compiled + # (used to restrict access to statically + # defined variables at compile time) + currentModule: string + # Each time a defer statement is + # compiled, its code is emitted + # here. Later, if there is any code + # to defer in the current function, + # funDecl will wrap the function's code + # inside an implicit try/finally block + # and add this code in the finally branch. + # This sequence is emptied each time a + # function declaration is compiled and stores only + # deferred code for the current function (may + # be empty) + deferred: seq[uint8] + # List of closed-over variables + closedOver: seq[IdentExpr] + + + +proc newCompiler*(enableOptimizations: bool = true): Compiler = + ## Initializes a new Compiler object + new(result) + result.ast = @[] + result.current = 0 + result.file = "" + result.names = @[] + result.scopeDepth = 0 + result.currentFunction = nil + result.enableOptimizations = enableOptimizations + result.currentModule = "" + result.frames = @[] + + +## Forward declarations +proc expression(self: Compiler, node: Expression) +proc statement(self: Compiler, node: Statement) +proc declaration(self: Compiler, node: Declaration) +proc peek(self: Compiler, distance: int = 0): ASTNode +proc identifier(self: Compiler, node: IdentExpr) +proc varDecl(self: Compiler, node: VarDecl) +proc inferType(self: Compiler, node: LiteralExpr): Type +proc inferType(self: Compiler, node: Expression): Type +proc findByName(self: Compiler, name: string): seq[Name] +proc findByType(self: Compiler, name: string, kind: Type): seq[Name] +proc compareTypes(self: Compiler, a, b: Type): bool +proc patchReturnAddress(self: Compiler, retAddr: int) +## End of forward declarations + +## Public getter for nicer error formatting +proc getCurrentNode*(self: Compiler): ASTNode = (if self.current >= + self.ast.len(): self.ast[^1] else: self.ast[self.current - 1]) +proc getCurrentFunction*(self: Compiler): Declaration {.inline.} = self.currentFunction +proc getFile*(self: COmpiler): string {.inline.} = self.file +proc getModule*(self: COmpiler): string {.inline.} = self.currentModule + + +## Utility functions +proc peek(self: Compiler, distance: int = 0): ASTNode = + ## Peeks at the AST node at the given distance. + ## If the distance is out of bounds, the last + ## AST node in the tree is returned. A negative + ## distance may be used to retrieve previously + ## consumed AST nodes + if self.ast.high() == -1 or self.current + distance > self.ast.high() or + self.current + distance < 0: + result = self.ast[^1] + else: + result = self.ast[self.current + distance] + + +proc done(self: Compiler): bool = + ## Returns true if the compiler is done + ## compiling, false otherwise + result = self.current > self.ast.high() + + +proc error(self: Compiler, message: string) {.raises: [CompileError].} = + ## Raises a CompileError exception + raise CompileError(msg: message, node: self.getCurrentNode(), file: self.file, module: self.currentModule) + + +proc step(self: Compiler): ASTNode = + ## Steps to the next node and returns + ## the consumed one + result = self.peek() + if not self.done(): + self.current += 1 + + +proc emitByte(self: Compiler, byt: OpCode | uint8) = + ## Emits a single byte, writing it to + ## the current chunk being compiled + when DEBUG_TRACE_COMPILER: + echo &"DEBUG - Compiler: Emitting {$byt}" + self.chunk.write(uint8 byt, self.peek().token.line) + + +proc emitBytes(self: Compiler, bytarr: openarray[OpCode | uint8]) = + ## Handy helper method to write arbitrary bytes into + ## the current chunk, calling emitByte on each of its + ## elements + for b in bytarr: + self.emitByte(b) + + +proc makeConstant(self: Compiler, val: Expression, typ: Type): array[3, uint8] = + ## Adds a constant to the current chunk's constant table + ## and returns its index as a 3-byte array of uint8s + var v: int + discard parseInt(val.token.lexeme, v) + case typ.kind: + of UInt8, Int8: + result = self.chunk.writeConstant([uint8(v)]) + of Int16, UInt16: + result = self.chunk.writeConstant(v.toDouble()) + of Int32, UInt32: + result = self.chunk.writeConstant(v.toQuad()) + of Int64, UInt64: + result = self.chunk.writeConstant(v.toLong()) + else: + discard + + +proc emitConstant(self: Compiler, obj: Expression, kind: Type) = + ## Emits a LoadConstant instruction along + ## with its operand + case self.inferType(obj).kind: + of Int64: + self.emitByte(LoadInt64) + else: + discard # TODO + self.emitBytes(self.makeConstant(obj, kind)) + + +proc emitJump(self: Compiler, opcode: OpCode): int = + ## Emits a dummy jump offset to be patched later. Assumes + ## the largest offset (emits 4 bytes, one for the given jump + ## opcode, while the other 3 are for the jump offset which is set + ## to the maximum unsigned 24 bit integer). If the shorter + ## 16 bit alternative is later found to be better suited, patchJump + ## will fix this. This function returns the absolute index into the + ## chunk's bytecode array where the given placeholder instruction was written + self.emitByte(opcode) + self.emitBytes((0xffffff).toTriple()) + result = self.chunk.code.len() - 4 + + +proc patchJump(self: Compiler, offset: int) = + ## Patches a previously emitted relative + ## jump using emitJump. Since emitJump assumes + ## a long jump, this also shrinks the jump + ## offset and changes the bytecode instruction if possible + ## (i.e. jump is in 16 bit range), but the converse is also + ## true (i.e. it might change a regular jump into a long one) + var jump: int = self.chunk.code.len() - offset + if jump > 16777215: + self.error("cannot jump more than 16777216 bytecode instructions") + if jump < uint16.high().int: + case OpCode(self.chunk.code[offset]): + of LongJumpForwards: + self.chunk.code[offset] = JumpForwards.uint8() + of LongJumpBackwards: + self.chunk.code[offset] = JumpBackwards.uint8() + of LongJumpIfFalse: + self.chunk.code[offset] = JumpIfFalse.uint8() + of LongJumpIfFalsePop: + self.chunk.code[offset] = JumpIfFalsePop.uint8() + of LongJumpIfFalseOrPop: + self.chunk.code[offset] = JumpIfFalseOrPop.uint8() + else: + discard + self.chunk.code.delete(offset + 1) # Discards the first 8 bits of the jump offset (which are empty) + let offsetArray = (jump - 1).toDouble() # -1 since we got rid of 1 byte! + self.chunk.code[offset + 1] = offsetArray[0] + self.chunk.code[offset + 2] = offsetArray[1] + else: + case OpCode(self.chunk.code[offset]): + of JumpForwards: + self.chunk.code[offset] = LongJumpForwards.uint8() + of JumpBackwards: + self.chunk.code[offset] = LongJumpBackwards.uint8() + of JumpIfFalse: + self.chunk.code[offset] = LongJumpIfFalse.uint8() + of JumpIfFalsePop: + self.chunk.code[offset] = LongJumpIfFalsePop.uint8() + of JumpIfFalseOrPop: + self.chunk.code[offset] = LongJumpIfFalseOrPop.uint8() + else: + discard + let offsetArray = jump.toTriple() + self.chunk.code[offset + 1] = offsetArray[0] + self.chunk.code[offset + 2] = offsetArray[1] + self.chunk.code[offset + 3] = offsetArray[2] + + +proc resolve(self: Compiler, name: IdentExpr, + depth: int = self.scopeDepth): Name = + ## Traverses self.names backwards and returns the + ## first name object with the given name. Returns + ## nil when the name can't be found. This function + ## has no concept of scope depth, because getStackPos + ## does that job. Note that private names declared in + ## other modules will not be resolved! + for obj in reversed(self.names): + if obj.name.token.lexeme == name.token.lexeme: + if obj.isPrivate and obj.owner != self.currentModule: + continue # There may be a name in the current module that + # matches, so we skip this + return obj + return nil + + +proc getStackPos(self: Compiler, name: IdentExpr, + depth: int = self.scopeDepth): tuple[closedOver: bool, pos: int] = + ## Iterates the internal list of declared names backwards and + ## returns a tuple (closedOver, pos) that tells the caller whether the + ## the name is to be emitted as a closure as well as its predicted + ## stack/closure array position. Returns (false, -1) if the variable's + ## location can not be determined at compile time (this is an error!). + ## Note that private names declared in other modules will not be resolved! + var i: int = self.names.high() + for variable in reversed(self.names): + if name.name.lexeme == variable.name.name.lexeme: + if variable.isPrivate and variable.owner != self.currentModule: + continue + if variable.depth == depth or variable.depth == 0: + # variable.depth == 0 for globals! + return (false, i) + elif variable.depth > 0: + for j, closure in reversed(self.closedOver): + if closure.name.lexeme == name.name.lexeme: + return (true, j) + dec(i) + return (false, -1) + + +proc detectClosureVariable(self: Compiler, name: IdentExpr, + depth: int = self.scopeDepth) = + ## Detects if the given name is used in a local scope deeper + ## than the given one and modifies the code emitted for it + ## to store it as a closure variable if it is. Does nothing if the name + ## hasn't been declared yet or is unreachable (for example if it's + ## declared as private in another module). This function must be called + ## each time a name is referenced in order for closed-over variables + ## to be emitted properly, otherwise the runtime may behave + ## unpredictably or crash + let entry = self.resolve(name) + if entry == nil: + return + if entry.depth < depth: + # Ding! The given name is closed over: we need to + # change the StoreVar instruction that created this + # name entry into a StoreHeap. We don't need to change + # other pieces of code because self.identifier() already + # emits LoadHeap if it detects the variable is closed over, + # whether or not this function is called + self.closedOver.add(entry.name) + if self.closedOver.len() >= 16777216: + self.error("too many consecutive closed-over variables (max is 16777216)") + let idx = self.closedOver.high().toTriple() + self.chunk.code[entry.codePos] = StoreHeap.uint8 + self.chunk.code[entry.codePos + 1] = idx[0] + self.chunk.code[entry.codePos + 2] = idx[1] + self.chunk.code[entry.codePos + 3] = idx[2] + + +proc compareTypesWithNullNode(self: Compiler, a, b: Type): bool = + ## Compares two types without using information from + ## AST nodes + if a == nil: + return b == nil + elif b == nil: + return a == nil + if a.kind != b.kind: + return false + case a.kind: + of Function: + if a.args.len() != b.args.len(): + return false + elif not self.compareTypes(a.returnType, b.returnType): + return false + for (argA, argB) in zip(a.args, b.args): + if not self.compareTypes(argA, argB): + return false + return true + else: + discard + + +proc compareTypes(self: Compiler, a, b: Type): bool = + ## Compares two type objects + ## for equality (works with nil!) + if a == nil: + return b == nil + elif b == nil: + return a == nil + if a.kind != b.kind: + return false + case a.kind: + of Int8, UInt8, Int16, UInt16, Int32, + UInt32, Int64, UInt64, Float32, Float64, + Char, Byte, String, Nil, Nan, Bool, Inf: + return true + of Function: + if a.node == nil or b.node == nil: + return self.compareTypesWithNullNode(a, b) + let + a = FunDecl(a.node) + b = FunDecl(b.node) + if a.name.token.lexeme != b.name.token.lexeme: + return false + elif a.arguments.len() != b.arguments.len(): + return false + elif not self.compareTypes(self.inferType(a.returnType), self.inferType(b.returnType)): + return false + for (argA, argB) in zip(a.arguments, b.arguments): + if argA.mutable != argB.mutable: + return false + elif argA.isRef != argB.isRef: + return false + elif argA.isPtr != argB.isPtr: + return false + elif not self.compareTypes(self.inferType(argA.valueType), self.inferType(argB.valueType)): + return false + return true + else: + discard + + +proc toIntrinsic(name: string): Type = + ## Converts a string to an intrinsic + ## type if it is valid and returns nil + ## otherwise + if name in ["int", "int64", "i64"]: + return Type(kind: Int64) + elif name in ["uint64", "u64"]: + return Type(kind: UInt64) + elif name in ["int32", "i32"]: + return Type(kind: Int32) + elif name in ["uint32", "u32"]: + return Type(kind: UInt32) + elif name in ["int16", "i16"]: + return Type(kind: Int16) + elif name in ["uint16", "u16"]: + return Type(kind: UInt16) + elif name in ["int8", "i8"]: + return Type(kind: Int8) + elif name in ["uint8", "u8"]: + return Type(kind: UInt8) + elif name in ["f64", "float", "float64"]: + return Type(kind: Float64) + elif name in ["f32", "float32"]: + return Type(kind: Float32) + elif name == "byte": + return Type(kind: Byte) + elif name == "char": + return Type(kind: Char) + elif name == "nan": + return Type(kind: Nan) + elif name == "nil": + return Type(kind: Nil) + elif name == "inf": + return Type(kind: Inf) + elif name == "bool": + return Type(kind: Bool) + elif name == "type": + return Type(kind: Typedesc) + else: + return nil + + +proc inferType(self: Compiler, node: LiteralExpr): Type = + ## Infers the type of a given literal expression + if node == nil: + return nil + case node.kind: + of intExpr, binExpr, octExpr, hexExpr: + let size = node.token.lexeme.split("'") + if len(size) notin 1..2: + self.error("invalid state: inferValueType -> invalid size specifier (This is an internal error and most likely a bug!)") + if size.len() == 1: + return Type(node: node, kind: Int64) + let typ = size[1].toIntrinsic() + if not self.compareTypes(typ, nil): + return typ + else: + self.error(&"invalid type specifier '{size[1]}' for int") + of floatExpr: + let size = node.token.lexeme.split("'") + if len(size) notin 1..2: + self.error("invalid state: inferValueType -> invalid size specifier (This is an internal error and most likely a bug!)") + if size.len() == 1 or size[1] == "f64": + return Type(node: node, kind: Float64) + let typ = size[1].toIntrinsic() + if not self.compareTypes(typ, nil): + return typ + else: + self.error(&"invalid type specifier '{size[1]}' for float") + of nilExpr: + return Type(node: node, kind: Nil) + of trueExpr: + return Type(node: node, kind: Bool) + of falseExpr: + return Type(node: node, kind: Bool) + of nanExpr: + return Type(node: node, kind: TypeKind.Nan) + of infExpr: + return Type(node: node, kind: TypeKind.Inf) + else: + discard # TODO + + +proc toIntrinsic(self: Compiler, typ: Expression): Type = + ## Gets an expression's + ## intrinsic type, if possible + if typ == nil: + return nil + case typ.kind: + of trueExpr, falseExpr, intExpr, floatExpr: + return typ.token.lexeme.toIntrinsic() + of identExpr: + let inferred = self.inferType(typ) + if inferred == nil: + return typ.token.lexeme.toIntrinsic() + return inferred + else: + discard + + +proc inferType(self: Compiler, node: Expression): Type = + ## Infers the type of a given expression and + ## returns it + if node == nil: + return nil + case node.kind: + of identExpr: + let node = IdentExpr(node) + let name = self.resolve(node) + if name != nil: + return name.valueType + else: + return node.name.lexeme.toIntrinsic() + of unaryExpr: + return self.inferType(UnaryExpr(node).a) + of binaryExpr: + let node = BinaryExpr(node) + var a = self.inferType(node.a) + var b = self.inferType(node.b) + if not self.compareTypes(a, b): + return nil + return a + of {intExpr, hexExpr, binExpr, octExpr, + strExpr, falseExpr, trueExpr, infExpr, + nanExpr, floatExpr, nilExpr + }: + return self.inferType(LiteralExpr(node)) + else: + discard # Unreachable + + +proc typeToStr(self: Compiler, typ: Type): string = + ## Returns the string representation of a + ## type object + case typ.kind: + of Int8, UInt8, Int16, UInt16, Int32, + UInt32, Int64, UInt64, Float32, Float64, + Char, Byte, String, Nil, TypeKind.Nan, Bool, + TypeKind.Inf: + return ($typ.kind).toLowerAscii() + of Function: + result = "function (" + case typ.node.kind: + of funDecl: + var node = FunDecl(typ.node) + for i, argument in node.arguments: + result &= &"{argument.name.token.lexeme}: {self.typeToStr(self.inferType(argument.name))}" + if i < node.arguments.len() - 1: + result &= ", " + result &= ")" + of lambdaExpr: + var node = LambdaExpr(typ.node) + for i, argument in node.arguments: + result &= &"{argument.name.token.lexeme}: {argument.valueType}" + if i < node.arguments.len() - 1: + result &= ", " + result &= ")" + else: + discard # Unreachable + result &= &": {self.typeToStr(typ.returnType)}" + else: + discard + + +proc inferType(self: Compiler, node: Declaration): Type = + ## Infers the type of a given declaration + ## and returns it + if node == nil: + return nil + case node.kind: + of funDecl: + var node = FunDecl(node) + let resolved = self.resolve(node.name) + if resolved != nil: + return resolved.valueType + of NodeKind.varDecl: + var node = VarDecl(node) + let resolved = self.resolve(node.name) + if resolved != nil: + return resolved.valueType + else: + return self.inferType(node.value) + else: + return # Unreachable + +## End of utility functions + + +proc literal(self: Compiler, node: ASTNode) = + ## Emits instructions for literals such + ## as singletons, strings, numbers and + ## collections + case node.kind: + of trueExpr: + self.emitByte(LoadTrue) + of falseExpr: + self.emitByte(LoadFalse) + of nilExpr: + self.emitByte(LoadNil) + of infExpr: + self.emitByte(LoadInf) + of nanExpr: + self.emitByte(LoadNan) + of strExpr: + self.emitConstant(LiteralExpr(node), Type(kind: String)) + # TODO: Take size specifier into account! + of intExpr: + var x: int + var y = IntExpr(node) + try: + discard parseInt(y.literal.lexeme, x) + except ValueError: + self.error("integer value out of range") + self.emitConstant(y, Type(kind: Int64)) + of hexExpr: + var x: int + var y = HexExpr(node) + try: + discard parseHex(y.literal.lexeme, x) + except ValueError: + self.error("integer value out of range") + let node = newIntExpr(Token(lexeme: $x, line: y.token.line, + pos: (start: y.token.pos.start, + stop: y.token.pos.start + len($x)) + ) + ) + self.emitConstant(node, Type(kind: Int64)) + of binExpr: + var x: int + var y = BinExpr(node) + try: + discard parseBin(y.literal.lexeme, x) + except ValueError: + self.error("integer value out of range") + let node = newIntExpr(Token(lexeme: $x, line: y.token.line, + pos: (start: y.token.pos.start, + stop: y.token.pos.start + len($x)) + ) + ) + self.emitConstant(node, Type(kind: Int64)) + of octExpr: + var x: int + var y = OctExpr(node) + try: + discard parseOct(y.literal.lexeme, x) + except ValueError: + self.error("integer value out of range") + let node = newIntExpr(Token(lexeme: $x, line: y.token.line, + pos: (start: y.token.pos.start, + stop: y.token.pos.start + len($x)) + ) + ) + self.emitConstant(node, Type(kind: Int64)) + of floatExpr: + var x: float + var y = FloatExpr(node) + try: + discard parseFloat(y.literal.lexeme, x) + except ValueError: + self.error("floating point value out of range") + self.emitConstant(y, Type(kind: Float64)) + of awaitExpr: + var y = AwaitExpr(node) + self.expression(y.expression) + self.emitByte(OpCode.Await) + else: + self.error(&"invalid AST node of kind {node.kind} at literal(): {node} (This is an internal error and most likely a bug!)") + + +proc unary(self: Compiler, node: UnaryExpr) = + ## Compiles unary expressions such as decimal + ## and bitwise negation + let valueType = self.inferType(node.a) + let impl = self.findByType(node.token.lexeme, Type(kind: Function, returnType: valueType, node: nil, args: @[valueType])) + if impl.len() == 0: + self.error(&"cannot find a suitable implementation for '{node.token.lexeme}'") + elif impl.len() > 2: + var msg = &"multiple matching implementations of '{node.token.lexeme}' found:\n" + for fn in reversed(impl): + var node = FunDecl(fn.valueType.node) + discard self.typeToStr(fn.valueType) + msg &= &"- '{node.name.token.lexeme}' at line {node.token.line} of type {self.typeToStr(fn.valueType)}\n" + self.error(msg) + else: + # Pushes the return address + self.emitByte(LoadUInt32) + # We patch it later! + let idx = self.chunk.consts.len() + self.emitBytes(self.chunk.writeConstant((0xffffffff'u32).toQuad())) + self.expression(node.a) # Pushes the operand onto the stack + self.emitByte(Call) # Creates a stack frame + self.emitBytes(impl[0].codePos.toTriple()) + self.emitBytes(1.toTriple()) + self.patchReturnAddress(idx) + + +proc binary(self: Compiler, node: BinaryExpr) = + ## Compiles all binary expressions + # These two lines prepare the stack by pushing the + # opcode's operands onto it + self.expression(node.a) + self.expression(node.b) + # TODO: Find implementation of + # the given operator and call it + case node.operator.kind: + of NoMatch: + # a and b + self.expression(node.a) + var jump: int + if self.enableOptimizations: + jump = self.emitJump(JumpIfFalseOrPop) + else: + jump = self.emitJump(JumpIfFalse) + self.emitByte(Pop) + self.expression(node.b) + self.patchJump(jump) + of EndOfFile: + # a or b + self.expression(node.a) + let jump = self.emitJump(JumpIfTrue) + self.expression(node.b) + self.patchJump(jump) + else: + self.error(&"invalid AST node of kind {node.kind} at binary(): {node} (This is an internal error and most likely a bug!)") + + +proc declareName(self: Compiler, node: Declaration) = + ## Statically declares a name into the current scope + case node.kind: + of NodeKind.varDecl: + var node = VarDecl(node) + # Creates a new Name entry so that self.identifier emits the proper stack offset + if self.names.high() > 16777215: + # If someone ever hits this limit in real-world scenarios, I swear I'll + # slap myself 100 times with a sign saying "I'm dumb". Mark my words + self.error("cannot declare more than 16777216 variables at a time") + for name in self.findByName(node.name.token.lexeme): + if name.name.token.lexeme == node.name.token.lexeme: + self.error(&"attempt to redeclare '{node.name.token.lexeme}', which was previously defined in '{name.owner}' at line {name.valueType.node.token.line}") + self.names.add(Name(depth: self.scopeDepth, + name: node.name, + isPrivate: node.isPrivate, + owner: self.currentModule, + isConst: node.isConst, + valueType: Type(kind: self.inferType( + node.value).kind, node: node), + codePos: self.chunk.code.len(), + isLet: node.isLet)) + of NodeKind.funDecl: + var node = FunDecl(node) + # TODO: Emit some optional debugging + # metadata to let the VM know where a function's + # code begins and ends (similar to what gcc does with + # CFI in object files) to build stack traces + self.names.add(Name(depth: self.scopeDepth, + isPrivate: node.isPrivate, + isConst: false, + owner: self.currentModule, + valueType: Type(kind: Function, node: node, + returnType: self.inferType( + node.returnType), + args: @[]), + codePos: self.chunk.code.high(), + name: node.name, + isLet: false)) + let fn = self.names[^1] + for argument in node.arguments: + if self.names.high() > 16777215: + self.error("cannot declare more than 16777216 variables at a time") + # wait, no LoadVar?? Yes! That's because when calling functions, + # arguments will already be on the stack so there's no need to + # load them here + self.names.add(Name(depth: self.scopeDepth + 1, + isPrivate: true, + owner: self.currentModule, + isConst: false, + name: argument.name, + valueType: nil, + codePos: self.chunk.code.len(), + isLet: false)) + self.names[^1].valueType = self.inferType(argument.valueType) + # We check if the argument's type is a generic + if self.names[^1].valueType == nil and argument.valueType.kind == identExpr: + for gen in node.generics: + if gen.name == IdentExpr(argument.valueType): + self.names[^1].valueType = Type(kind: Generic) + break + # If it's still nil, it's an error! + if self.names[^1].valueType == nil: + self.error(&"cannot determine the type of argument '{self.names[^1].name.token.lexeme}'") + self.names[^1].valueType.node = argument.name + fn.valueType.args.add(self.names[^1].valueType) + else: + discard # Unreachable + + +proc identifier(self: Compiler, node: IdentExpr) = + ## Compiles access to identifiers + let s = self.resolve(node) + if s == nil: + self.error(&"reference to undeclared name '{node.token.lexeme}'") + elif s.isConst: + # Constants are emitted as, you guessed it, LoadConstant instructions + # no matter the scope depth. If optimizations are enabled, the compiler + # will reuse the same constant every time it is referenced instead of + # allocating a new one each time + self.emitConstant(node, self.inferType(node)) + else: + self.detectClosureVariable(s.name) + let t = self.getStackPos(node) + let index = t.pos + # We don't check if index is -1 because if it + # were, self.resolve() would have returned nil + if not t.closedOver: + # Static name resolution, loads value at index in the stack. Very fast. Much wow. + self.emitByte(LoadVar) + self.emitBytes((index - self.frames[^1]).toTriple()) + else: + if self.closedOver.len() == 0: + self.error("error: closure variable array is empty but LoadHeap would be emitted (this is an internal error and most likely a bug)") + # Heap-allocated closure variable. Stored in a separate "closure array" in the VM that does not have stack semantics. + # This makes closures work as expected and is not comparatively slower than indexing our stack (since they're both + # dynamic arrays at runtime anyway) + self.emitByte(LoadHeap) + self.emitBytes(self.closedOver.high().toTriple()) + + +proc findByName(self: Compiler, name: string): seq[Name] = + ## Looks for objects that have been already declared + ## with the given name. Returns all objects that apply + for obj in reversed(self.names): + if obj.name.token.lexeme == name: + result.add(obj) + + +proc findByType(self: Compiler, name: string, kind: Type): seq[Name] = + ## Looks for objects that have already been declared + ## with the given name and type + for obj in self.findByName(name): + if self.compareTypes(obj.valueType, kind): + result.add(obj) + + +proc assignment(self: Compiler, node: ASTNode) = + ## Compiles assignment expressions + case node.kind: + of assignExpr: + let node = AssignExpr(node) + let name = IdentExpr(node.name) + let r = self.resolve(name) + if r == nil: + self.error(&"assignment to undeclared name '{name.token.lexeme}'") + elif r.isConst: + self.error(&"cannot assign to '{name.token.lexeme}' (constant)") + elif r.isLet: + self.error(&"cannot reassign '{name.token.lexeme}'") + self.expression(node.value) + let t = self.getStackPos(name) + let index = t.pos + if index != -1: + if not t.closedOver: + self.emitByte(StoreVar) + else: + self.emitByte(StoreHeap) + self.emitBytes(index.toTriple()) + else: + self.error(&"reference to undeclared name '{node.token.lexeme}'") + of setItemExpr: + let node = SetItemExpr(node) + let typ = self.inferType(node) + if typ == nil: + self.error(&"cannot determine the type of '{node.name.token.lexeme}'") + # TODO + else: + self.error(&"invalid AST node of kind {node.kind} at assignment(): {node} (This is an internal error and most likely a bug)") + + +proc beginScope(self: Compiler) = + ## Begins a new local scope by incrementing the current + ## scope's depth + inc(self.scopeDepth) + + +proc endScope(self: Compiler) = + ## Ends the current local scope + if self.scopeDepth == 0: + self.error("cannot call endScope with scopeDepth == 0 (This is an internal error and most likely a bug)") + dec(self.scopeDepth) + var popped: int = 0 + for i, ident in reversed(self.names): + if ident.depth > self.scopeDepth: + inc(popped) + self.names.delete(self.names.len() - i) + if not self.enableOptimizations: + # All variables with a scope depth larger than the current one + # are now out of scope. Begone, you're now homeless! + self.emitByte(Pop) + if self.enableOptimizations and popped > 1: + # If we're popping less than 65535 variables, then + # we can emit a PopN instruction. This is true for + # 99.99999% of the use cases of the language (who the + # hell is going to use 65 THOUSAND local variables?), but + # if you'll ever use more then Peon will emit a PopN instruction + # for the first 65 thousand and change local variables and then + # emit another batch of plain ol' Pop instructions for the rest + if popped <= uint16.high().int(): + self.emitByte(PopN) + self.emitBytes(popped.toDouble()) + else: + self.emitByte(PopN) + self.emitBytes(uint16.high().int.toDouble()) + for i in countdown(self.names.high(), popped - uint16.high().int()): + if self.names[i].depth > self.scopeDepth: + self.emitByte(Pop) + elif popped == 1: + # We only emit PopN if we're popping more than one value + self.emitByte(Pop) + + +proc blockStmt(self: Compiler, node: BlockStmt) = + ## Compiles block statements, which create a new + ## local scope. + self.beginScope() + for decl in node.code: + self.declaration(decl) + self.endScope() + + +proc ifStmt(self: Compiler, node: IfStmt) = + ## Compiles if/else statements for conditional + ## execution of code + self.expression(node.condition) + var jumpCode: OpCode + if self.enableOptimizations: + jumpCode = JumpIfFalsePop + else: + jumpCode = JumpIfFalse + let jump = self.emitJump(jumpCode) + if not self.enableOptimizations: + self.emitByte(Pop) + self.statement(node.thenBranch) + self.patchJump(jump) + if node.elseBranch != nil: + let jump = self.emitJump(JumpForwards) + self.statement(node.elseBranch) + self.patchJump(jump) + + +proc emitLoop(self: Compiler, begin: int) = + ## Emits a JumpBackwards instruction with the correct + ## jump offset + var offset: int + case OpCode(self.chunk.code[begin + 1]): # The jump instruction + of LongJumpForwards, LongJumpBackwards, LongJumpIfFalse, + LongJumpIfFalsePop, LongJumpIfTrue: + offset = self.chunk.code.len() - begin + 4 + else: + offset = self.chunk.code.len() - begin + if offset > uint16.high().int: + if offset > 16777215: + self.error("cannot jump more than 16777215 bytecode instructions") + self.emitByte(LongJumpBackwards) + self.emitBytes(offset.toTriple()) + else: + self.emitByte(JumpBackwards) + self.emitBytes(offset.toDouble()) + + +proc whileStmt(self: Compiler, node: WhileStmt) = + ## Compiles C-style while loops and + ## desugared C-style for loops + let start = self.chunk.code.len() + self.expression(node.condition) + var jump: int + if self.enableOptimizations: + jump = self.emitJump(JumpIfFalsePop) + else: + jump = self.emitJump(JumpIfFalse) + self.emitByte(Pop) + self.statement(node.body) + self.patchJump(jump) + self.emitLoop(start) + + +proc expression(self: Compiler, node: Expression) = + ## Compiles all expressions + if self.inferType(node) == nil: + if node.kind != identExpr: + # So we can raise a more appropriate + # error in self.identifier() + self.error("expression has no type") + case node.kind: + of callExpr: + discard # TODO + of getItemExpr: + discard # TODO + # Note that for setItem and assign we don't convert + # the node to its true type because that type information + # would be lost in the call anyway. The differentiation + # happens in self.assignment() + of setItemExpr, assignExpr: + self.assignment(node) + of identExpr: + self.identifier(IdentExpr(node)) + of unaryExpr: + # Unary expressions such as ~5 and -3 + self.unary(UnaryExpr(node)) + of groupingExpr: + # Grouping expressions like (2 + 1) + self.expression(GroupingExpr(node).expression) + of binaryExpr: + # Binary expressions such as 2 ^ 5 and 0.66 * 3.14 + self.binary(BinaryExpr(node)) + of intExpr, hexExpr, binExpr, octExpr, strExpr, falseExpr, trueExpr, + infExpr, nanExpr, floatExpr, nilExpr: + # Since all of these AST nodes share the + # same overall structure and the kind + # field is enough to tell one from the + # other, why bother with specialized + # cases when one is enough? + self.literal(node) + else: + self.error(&"invalid AST node of kind {node.kind} at expression(): {node} (This is an internal error and most likely a bug)") + + +proc awaitStmt(self: Compiler, node: AwaitStmt) = + ## Compiles await statements. An await statement + ## is like an await expression, but parsed in the + ## context of statements for usage outside expressions, + ## meaning it can be used standalone. It's basically the + ## same as an await expression followed by a semicolon. + ## Await expressions are the only native construct to + ## run coroutines from within an already asynchronous + ## context (which should be orchestrated by an event loop). + ## They block in the caller until the callee returns + self.expression(node.expression) + self.emitByte(OpCode.Await) + + +proc deferStmt(self: Compiler, node: DeferStmt) = + ## Compiles defer statements. A defer statement + ## is executed right before its containing function + ## exits (either because of a return or an exception) + let current = self.chunk.code.len + self.expression(node.expression) + for i in countup(current, self.chunk.code.high()): + self.deferred.add(self.chunk.code[i]) + self.chunk.code.del(i) + + +proc returnStmt(self: Compiler, node: ReturnStmt) = + ## Compiles return statements. An empty return + ## implicitly returns nil + let returnType = self.inferType(node.value) + let typ = self.inferType(self.currentFunction) + ## Having the return type + if returnType == nil and typ.returnType != nil: + self.error(&"expected return value of type '{self.typeToStr(typ.returnType)}', but expression has no type") + elif typ.returnType == nil and returnType != nil: + self.error("empty return statement is not allowed in non-void functions") + elif not self.compareTypes(returnType, typ.returnType): + self.error(&"expected return value of type '{self.typeToStr(typ.returnType)}', got '{self.typeToStr(returnType)}' instead") + if node.value != nil: + self.expression(node.value) + self.emitByte(OpCode.ReturnValue) + else: + self.emitByte(OpCode.Return) + discard self.frames.pop() + + +proc yieldStmt(self: Compiler, node: YieldStmt) = + ## Compiles yield statements + self.expression(node.expression) + self.emitByte(OpCode.Yield) + + +proc raiseStmt(self: Compiler, node: RaiseStmt) = + ## Compiles yield statements + self.expression(node.exception) + self.emitByte(OpCode.Raise) + + +proc continueStmt(self: Compiler, node: ContinueStmt) = + ## Compiles continue statements. A continue statements + ## jumps to the next iteration in a loop + if self.currentLoop.start <= 65535: + self.emitByte(Jump) + self.emitBytes(self.currentLoop.start.toDouble()) + else: + if self.currentLoop.start > 16777215: + self.error("too much code to jump over in continue statement") + self.emitByte(LongJump) + self.emitBytes(self.currentLoop.start.toTriple()) + + +proc breakStmt(self: Compiler, node: BreakStmt) = + ## Compiles break statements. A continue statement + ## jumps to the next iteration in a loop + + # Emits dummy jump offset, this is + # patched later + discard self.emitJump(OpCode.Jump) + self.currentLoop.breakPos.add(self.chunk.code.high() - 4) + if self.currentLoop.depth > self.scopeDepth: + # Breaking out of a loop closes its scope + self.endScope() + + +proc patchBreaks(self: Compiler) = + ## Patches "break" opcodes with + ## actual jumps. This is needed + ## because the size of code + ## to skip is not known before + ## the loop is fully compiled + for brk in self.currentLoop.breakPos: + self.chunk.code[brk] = JumpForwards.uint8() + self.patchJump(brk) + + +proc assertStmt(self: Compiler, node: AssertStmt) = + ## Compiles assert statements (raise + ## AssertionError if the expression is falsey) + self.expression(node.expression) + self.emitByte(OpCode.Assert) + + +proc statement(self: Compiler, node: Statement) = + ## Compiles all statements + case node.kind: + of exprStmt: + var expression = ExprStmt(node).expression + self.expression(expression) + self.emitByte(Pop) # Expression statements discard their value. Their main use case is side effects in function calls + of NodeKind.ifStmt: + self.ifStmt(IfStmt(node)) + of NodeKind.assertStmt: + self.assertStmt(AssertStmt(node)) + of NodeKind.raiseStmt: + self.raiseStmt(RaiseStmt(node)) + of NodeKind.breakStmt: + self.breakStmt(BreakStmt(node)) + of NodeKind.continueStmt: + self.continueStmt(ContinueStmt(node)) + of NodeKind.returnStmt: + self.returnStmt(ReturnStmt(node)) + of NodeKind.importStmt: + discard + of NodeKind.whileStmt, NodeKind.forStmt: + ## Our parser already desugars for loops to + ## while loops! + let loop = self.currentLoop + self.currentLoop = Loop(start: self.chunk.code.len(), + depth: self.scopeDepth, breakPos: @[]) + self.whileStmt(WhileStmt(node)) + self.patchBreaks() + self.currentLoop = loop + of NodeKind.forEachStmt: + discard + of NodeKind.blockStmt: + self.blockStmt(BlockStmt(node)) + of NodeKind.yieldStmt: + self.yieldStmt(YieldStmt(node)) + of NodeKind.awaitStmt: + self.awaitStmt(AwaitStmt(node)) + of NodeKind.deferStmt: + self.deferStmt(DeferStmt(node)) + of NodeKind.tryStmt: + discard + else: + self.expression(Expression(node)) + + +proc varDecl(self: Compiler, node: VarDecl) = + ## Compiles variable declarations + let kind = self.toIntrinsic(node.valueType) + let typ = self.inferType(node.value) + if kind == nil and typ == nil: + self.error(&"cannot determine the type of '{node.name.token.lexeme}'") + elif typ != kind and kind != nil: + self.error(&"expected value of type '{self.typeToStr(kind)}', but '{node.name.token.lexeme}' is of type '{self.typeToStr(typ)}'") + self.expression(node.value) + self.declareName(node) + + +proc funDecl(self: Compiler, node: FunDecl) = + ## Compiles function declarations + # A function's code is just compiled linearly + # and then jumped over + let jmp = self.emitJump(Jump) + var function = self.currentFunction + self.declareName(node) + self.frames.add(self.names.high()) + # TODO: Forward declarations + if node.body != nil: + if BlockStmt(node.body).code.len() == 0: + self.error("Cannot declare function with empty body") + let fnType = self.inferType(node) + let impl = self.findByType(node.name.token.lexeme, fnType) + if impl.len() > 1: + # Oh-oh! We found more than one implementation of + # the same function! Error! + var msg = &"multiple matching implementations of '{node.name.token.lexeme}' found:\n" + for fn in reversed(impl): + var node = FunDecl(fn.valueType.node) + discard self.typeToStr(fn.valueType) + msg &= &"- '{node.name.token.lexeme}' at line {node.token.line} of type {self.typeToStr(fn.valueType)}\n" + self.error(msg) + # We store the current function + self.currentFunction = node + + # Since the deferred array is a linear + # sequence of instructions and we want + # to keep track to whose function's each + # set of deferred instruction belongs, + # we record the length of the deferred + # array before compiling the function + # and use this info later to compile + # the try/finally block with the deferred + # code + var deferStart = self.deferred.len() + + self.blockStmt(BlockStmt(node.body)) + # Yup, we're done. That was easy, huh? + # But after all functions are just named + # scopes, and we compile them just like that: + # we declare their name and arguments (before + # their body so recursion works) and then just + # handle them as a block statement (which takes + # care of incrementing self.scopeDepth so locals + # are resolved properly). There's a need for a bit + # of boilerplate code to make closures work, but + # that's about it + case self.currentFunction.kind: + of NodeKind.funDecl: + if not self.currentFunction.hasExplicitReturn: + let typ = self.inferType(self.currentFunction) + if self.currentFunction.returnType == nil and typ != nil: + self.error("non-empty return statement is not allowed in void functions") + if self.currentFunction.returnType != nil: + self.error("function has an explicit return type, but no explicit return statement was found") + self.emitByte(OpCode.Return) + of NodeKind.lambdaExpr: + if not LambdaExpr(Declaration(self.currentFunction)).hasExplicitReturn: + self.emitByte(OpCode.Return) + else: + discard # Unreachable + # Currently defer is not functional so we + # just pop the instructions + for i in countup(deferStart, self.deferred.len() - 1, 1): + self.deferred.delete(i) + + self.patchJump(jmp) + # This makes us compile nested functions correctly + self.currentFunction = function + + +proc patchReturnAddress(self: Compiler, retAddr: int) = + ## Patches the return address of a function + ## call. This is called at each iteration of + ## the compiler's loop + let address = self.chunk.code.len().toQuad() + self.chunk.consts[retAddr] = address[0] + self.chunk.consts[retAddr + 1] = address[1] + self.chunk.consts[retAddr + 2] = address[2] + self.chunk.consts[retAddr + 3] = address[3] + + +proc declaration(self: Compiler, node: Declaration) = + ## Compiles all declarations + case node.kind: + of NodeKind.varDecl: + self.varDecl(VarDecl(node)) + of NodeKind.funDecl: + self.funDecl(FunDecl(node)) + else: + self.statement(Statement(node)) + + +proc compile*(self: Compiler, ast: seq[Declaration], file: string): Chunk = + ## Compiles a sequence of AST nodes into a chunk + ## object + self.chunk = newChunk() + self.ast = ast + self.file = file + self.names = @[] + self.scopeDepth = 0 + self.currentFunction = nil + self.currentModule = self.file.extractFilename() + self.current = 0 + self.frames = @[0] + while not self.done(): + self.declaration(Declaration(self.step())) + if self.ast.len() > 0: + # *Technically* an empty program is a valid program + self.emitByte(OpCode.Return) # Exits the VM's main loop when used at the global scope + result = self.chunk + if self.ast.len() > 0 and self.scopeDepth != 0: + self.error(&"invalid state: invalid scopeDepth value (expected 0, got {self.scopeDepth}), did you forget to call endScope/beginScope?") diff --git a/src/frontend/lexer.nim b/src/frontend/lexer.nim new file mode 100644 index 0000000..04c2f80 --- /dev/null +++ b/src/frontend/lexer.nim @@ -0,0 +1,641 @@ +# Copyright 2022 Mattia Giambirtone & All Contributors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +## A simple and modular tokenizer implementation with arbitrary lookahead +## using a customizable symbol table + +import strutils +import parseutils +import strformat +import tables + + +import meta/token +import meta/errors + + +export token +export errors + + +type + SymbolTable* = ref object + ## A table of symbols used + ## to lex a source file + + # Although we don't parse keywords + # as symbols, but rather as identifiers, + # we keep them here for consistency + # purposes + keywords: TableRef[string, TokenType] + symbols: TableRef[string, TokenType] + Lexer* = ref object + ## A lexer object + symbols*: SymbolTable + source: string + tokens: seq[Token] + line: int + start: int + current: int + file: string + lines: seq[tuple[start, stop: int]] + lastLine: int + + +proc newSymbolTable: SymbolTable = + new(result) + result.keywords = newTable[string, TokenType]() + result.symbols = newTable[string, TokenType]() + + +proc addSymbol*(self: SymbolTable, lexeme: string, token: TokenType) = + ## Adds a symbol to the symbol table. Overwrites + ## any previous entries + self.symbols[lexeme] = token + + +proc removeSymbol*(self: SymbolTable, lexeme: string) = + ## Removes a symbol from the symbol table + ## (does nothing if it does not exist) + self.symbols.del(lexeme) + + +proc addKeyword*(self: SymbolTable, lexeme: string, token: TokenType) = + ## Adds a keyword to the symbol table. Overwrites + ## any previous entries + self.keywords[lexeme] = token + + +proc removeKeyword*(self: SymbolTable, lexeme: string) = + ## Removes a keyword from the symbol table + ## (does nothing if it does not exist) + self.keywords.del(lexeme) + + +proc existsSymbol*(self: SymbolTable, lexeme: string): bool {.inline.} = + ## Returns true if a given symbol exists + ## in the symbol table already + lexeme in self.symbols + + +proc existsKeyword*(self: SymbolTable, lexeme: string): bool {.inline.} = + ## Returns true if a given keyword exists + ## in the symbol table already + lexeme in self.keywords + + +proc getToken(self: Lexer, lexeme: string): Token = + ## Gets the matching token object for a given + ## string according to the symbol table or + ## returns nil if there's no match + let table = self.symbols + var kind = table.symbols.getOrDefault(lexeme, table.keywords.getOrDefault( + lexeme, NoMatch)) + if kind == NoMatch: + return nil + new(result) + result.kind = kind + result.lexeme = self.source[self.start.. result: + result = len(lexeme) + + +proc getSymbols(self: SymbolTable, n: int): seq[string] = + ## Returns all n-bytes symbols + ## in the symbol table + for lexeme in self.symbols.keys(): + if len(lexeme) == n: + result.add(lexeme) + +# Wrappers around isDigit and isAlphanumeric for +# strings +proc isDigit(s: string): bool = + for c in s: + if not c.isDigit(): + return false + return true + + +proc isAlphaNumeric(s: string): bool = + for c in s: + if not c.isAlphaNumeric(): + return false + return true + +proc incLine(self: Lexer) + +# Simple public getters used for error +# formatting and whatnot +proc getStart*(self: Lexer): int = self.start +proc getFile*(self: Lexer): string = self.file +proc getCurrent*(self: Lexer): int = self.current +proc getLine*(self: Lexer): int = self.line +proc getSource*(self: Lexer): string = self.source +proc getRelPos*(self: Lexer, line: int): tuple[start, stop: int] = + if self.tokens.len() == 0 or self.tokens[^1].kind != EndOfFile: + self.incLine() + return self.lines[line - 1] + + +proc newLexer*(self: Lexer = nil): Lexer = + ## Initializes the lexer or resets + ## the state of an existing one + new(result) + if self != nil: + result = self + result.source = "" + result.tokens = @[] + result.line = 1 + result.start = 0 + result.current = 0 + result.file = "" + result.lines = @[] + result.lastLine = 0 + result.symbols = newSymbolTable() + + +proc done(self: Lexer): bool = + ## Returns true if we reached EOF + result = self.current >= self.source.len + + +proc incLine(self: Lexer) = + ## Increments the lexer's line + ## and updates internal line + ## metadata + self.lines.add((self.lastLine, self.current)) + self.lastLine = self.current + self.line += 1 + + +proc step(self: Lexer, n: int = 1): string = + ## Steps n characters forward in the + ## source file (default = 1). A string + ## of at most n bytes is returned. If n + ## exceeds EOF, the string will be shorter + while len(result) < n: + if self.done() or self.current > self.source.high(): + break + else: + result.add(self.source[self.current]) + inc(self.current) + + +proc peek(self: Lexer, distance: int = 0, length: int = 1): string = + ## Returns a stream of characters of + ## at most length bytes from the source + ## file, starting at the given distance, + ## without consuming it. The distance + ## parameter may be negative to retrieve + ## previously consumed tokens. If the + ## distance and/or the length are beyond + ## EOF (even partially), the resulting string + ## will be shorter than length bytes + var i = distance + while len(result) < length: + if self.done() or self.current + i > self.source.high() or + self.current + i < 0: + break + else: + result.add(self.source[self.current + i]) + inc(i) + + +proc error(self: Lexer, message: string) = + ## Raises a lexing error with a formatted + ## error message + raise LexingError(msg: message, line: self.line, file: self.file, lexeme: self.peek()) + + +proc check(self: Lexer, s: string, distance: int = 0): bool = + ## Behaves like self.match(), without consuming the + ## token. False is returned if we're at EOF + ## regardless of what the token to check is. + ## The distance is passed directly to self.peek() + if self.done(): + return false + return self.peek(distance, len(s)) == s + + +proc check(self: Lexer, args: openarray[string], distance: int = 0): bool = + ## Calls self.check() in a loop with + ## each character from the given set of + ## strings and returns at the first match. + ## Useful to check multiple tokens in a situation + ## where only one of them may match at one time + for s in args: + if self.check(s, distance): + return true + return false + + +proc match(self: Lexer, s: string): bool = + ## Returns true if the next len(s) bytes + ## of the source file match the provided + ## string. If the match is successful, + ## len(s) bytes are consumed, otherwise + ## false is returned + if not self.check(s): + return false + discard self.step(len(s)) + return true + + +proc match(self: Lexer, args: openarray[string]): bool = + ## Calls self.match() in a loop with + ## each character from the given set of + ## strings and returns at the first match. + ## Useful to match multiple tokens in a situation + ## where only one of them may match at one time + for s in args: + if self.match(s): + return true + return false + + +proc createToken(self: Lexer, tokenType: TokenType) = + ## Creates a token object and adds it to the token + ## list. The lexeme and position of the token are + ## inferred from the current state of the tokenizer + var tok: Token = new(Token) + tok.kind = tokenType + tok.lexeme = self.source[self.start.. uint8.high().int: + self.error("escape sequence value too large (> 255)") + self.source[self.current] = cast[char](value) + of 'u', 'U': + self.error("unicode escape sequences are not supported (yet)") + of 'x': + var code = "" + var value = 0 + var i = self.current + while i < self.source.high() and (let c = self.source[ + i].toLowerAscii(); c in 'a'..'f' or c in '0'..'9'): + code &= self.source[i] + i += 1 + assert parseHex(code, value) == code.len() + if value > uint8.high().int: + self.error("escape sequence value too large (> 255)") + self.source[self.current] = cast[char](value) + else: + self.error(&"invalid escape sequence '\\{self.peek()}'") + + +proc parseString(self: Lexer, delimiter: string, mode: string = "single") = + ## Parses string literals. They can be expressed using matching pairs + ## of either single or double quotes. Most C-style escape sequences are + ## supported, moreover, a specific prefix may be prepended + ## to the string to instruct the lexer on how to parse it: + ## - b -> declares a byte string, where each character is + ## interpreted as an integer instead of a character + ## - r -> declares a raw string literal, where escape sequences + ## are not parsed and stay as-is + ## - f -> declares a format string, where variables may be + ## interpolated using curly braces like f"Hello, {name}!". + ## Braces may be escaped using a pair of them, so to represent + ## a literal "{" in an f-string, one would use {{ instead + ## Multi-line strings can be declared using matching triplets of + ## either single or double quotes. They can span across multiple + ## lines and escape sequences in them are not parsed, like in raw + ## strings, so a multi-line string prefixed with the "r" modifier + ## is redundant, although multi-line byte/format strings are supported + var slen = 0 + while not self.check(delimiter) and not self.done(): + if self.match("\n"): + if mode == "multi": + self.incLine() + else: + self.error("unexpected EOL while parsing string literal") + if mode in ["raw", "multi"]: + discard self.step() + elif self.match("\\"): + # This madness here serves to get rid of the slash, since \x is mapped + # to a one-byte sequence but the string '\x' is actually 2 bytes (or more, + # depending on the specific escape sequence) + self.source = self.source[0.. 1 and delimiter == "'": + self.error("invalid character literal (length must be one!)") + if mode == "multi": + if not self.match(delimiter.repeat(3)): + self.error("unexpected EOL while parsing multi-line string literal") + elif self.done() and self.peek(-1) != delimiter: + self.error("unexpected EOF while parsing string literal") + else: + discard self.step() + if delimiter == "\"": + self.createToken(String) + else: + self.createToken(Char) + + +proc parseBinary(self: Lexer) = + ## Parses binary numbers + while self.peek().isDigit(): + if not self.check(["0", "1"]): + self.error(&"invalid digit '{self.peek()}' in binary literal") + discard self.step() + + +proc parseOctal(self: Lexer) = + ## Parses octal numbers + while self.peek().isDigit(): + if self.peek() notin "0".."7": + self.error(&"invalid digit '{self.peek()}' in octal literal") + discard self.step() + + +proc parseHex(self: Lexer) = + ## Parses hexadecimal numbers + while self.peek().isAlphaNumeric(): + if not self.peek().isDigit() and self.peek().toLowerAscii() notin "a".."f": + self.error(&"invalid hexadecimal literal") + discard self.step() + + +proc parseNumber(self: Lexer) = + ## Parses numeric literals, which encompass + ## integers and floating point numbers. + ## Floats also support scientific notation + ## (i.e. 3e14), while the fractional part + ## must be separated from the decimal one + ## using a dot (which acts as the comma). + ## Float literals such as 32.5e3 are also supported. + ## The "e" for the scientific notation of floats + ## is case-insensitive. Binary number literals are + ## expressed using the prefix 0b, hexadecimal + ## numbers with the prefix 0x and octal numbers + ## with the prefix 0o. Numeric literals support + ## size specifiers, like so: 10'u8, 3.14'f32 + var kind: TokenType + case self.peek(): + of "b": + discard self.step() + kind = Binary + self.parseBinary() + of "x": + kind = Hex + discard self.step() + self.parseHex() + of "o": + kind = Octal + discard self.step() + self.parseOctal() + else: + kind = Integer + while isDigit(self.peek()) and not self.done(): + discard self.step() + if self.check(["e", "E"]): + kind = Float + discard self.step() + while self.peek().isDigit() and not self.done(): + discard self.step() + elif self.check("."): + # TODO: Is there a better way? + discard self.step() + if not isDigit(self.peek()): + self.error("invalid float number literal") + kind = Float + while isDigit(self.peek()) and not self.done(): + discard self.step() + if self.check(["e", "E"]): + discard self.step() + while isDigit(self.peek()) and not self.done(): + discard self.step() + if self.match("'"): + # Could be a size specifier, better catch it + while (self.peek().isAlphaNumeric() or self.check("_")) and + not self.done(): + discard self.step() + self.createToken(kind) + if kind == Binary: + # To make our life easier, we pad the binary number in here already + while (self.tokens[^1].lexeme.len() - 2) mod 8 != 0: + self.tokens[^1].lexeme = "0b" & "0" & self.tokens[^1].lexeme[2..^1] + + +proc parseBackticks(self: Lexer) = + ## Parses tokens surrounded + ## by backticks. This may be used + ## for name stropping as well as to + ## reimplement existing operators + ## (e.g. +, -, etc.) without the + ## parser complaining about syntax + ## errors + while not self.match("`") and not self.done(): + if self.peek().isAlphaNumeric() or self.symbols.existsSymbol(self.peek()): + discard self.step() + continue + self.error(&"unexpected character: '{self.peek()}'") + self.createToken(Identifier) + # Strips the backticks + self.tokens[^1].lexeme = self.tokens[^1].lexeme[1..^2] + + +proc parseIdentifier(self: Lexer) = + ## Parses keywords and identifiers. + ## Note that multi-character tokens + ## (aka UTF runes) are not supported + ## by design and *will* break things + while (self.peek().isAlphaNumeric() or self.check("_")) and not self.done(): + discard self.step() + let name: string = self.source[self.start.. 0: + for symbol in self.symbols.getSymbols(n): + if self.match(symbol): + # We've found the largest possible + # match! + self.tokens.add(self.getToken(symbol)) + return + dec(n) + # We just assume what we have in front of us + # is a symbol + discard self.step() + self.createToken(Symbol) + + +proc lex*(self: Lexer, source, file: string): seq[Token] = + ## Lexes a source file, converting a stream + ## of characters into a series of tokens + var symbols = self.symbols + discard self.newLexer() + self.symbols = symbols + self.source = source + self.file = file + self.lines = @[] + while not self.done(): + self.next() + self.start = self.current + self.tokens.add(Token(kind: EndOfFile, lexeme: "", + line: self.line, pos: (self.current, self.current))) + self.incLine() + return self.tokens diff --git a/src/frontend/meta/ast.nim b/src/frontend/meta/ast.nim new file mode 100644 index 0000000..5b3cc93 --- /dev/null +++ b/src/frontend/meta/ast.nim @@ -0,0 +1,701 @@ +# Copyright 2022 Mattia Giambirtone & All Contributors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +## An Abstract Syntax Tree (AST) structure for our recursive-descent +## top-down parser. For more info, check out docs/grammar.md + + +import strformat +import strutils + + +import token +export token + +type + NodeKind* = enum + ## Enumeration of the AST + ## node types, sorted by + ## precedence + + # Declarations + funDecl = 0'u8, + varDecl, + # Statements + forStmt, # Unused for now (for loops are compiled to while loops) + ifStmt, + returnStmt, + breakStmt, + continueStmt, + whileStmt, + forEachStmt, + blockStmt, + raiseStmt, + assertStmt, + tryStmt, + yieldStmt, + awaitStmt, + importStmt, + deferStmt, + # An expression followed by a semicolon + exprStmt, + # Expressions + assignExpr, + lambdaExpr, + awaitExpr, + yieldExpr, + setItemExpr, # Set expressions like a.b = "c" + binaryExpr, + unaryExpr, + sliceExpr, + callExpr, + getItemExpr, # Get expressions like a.b + # Primary expressions + groupingExpr, # Parenthesized expressions such as (true) and (3 + 4) + trueExpr, + falseExpr, + strExpr, + charExpr, + intExpr, + floatExpr, + hexExpr, + octExpr, + binExpr, + nilExpr, + nanExpr, + infExpr, + identExpr, # Identifier + pragmaExpr + + # Here I would've rather used object variants, and in fact that's what was in + # place before, but not being able to re-declare a field of the same type in + # another case branch is kind of a deal breaker long-term, so until that is + # fixed (check out https://github.com/nim-lang/RFCs/issues/368 for more info). + # I'll stick to using inheritance instead + + + # Generic AST node types + ASTNode* = ref object of RootObj + ## An AST node + kind*: NodeKind + # Regardless of the type of node, we keep the token in the AST node for internal usage. + # This is not shown when the node is printed, but makes it a heck of a lot easier to report + # errors accurately even deep in the compilation pipeline + token*: Token + # This weird inheritance chain is needed for the parser to + # work properly + Declaration* = ref object of ASTNode + ## A declaration + pragmas*: seq[Pragma] + generics*: seq[tuple[name: IdentExpr, cond: Expression]] + + Statement* = ref object of Declaration + ## A statement + Expression* = ref object of Statement + ## An expression + LiteralExpr* = ref object of Expression + # Using a string for literals makes it much easier to handle numeric types, as + # there is no overflow nor underflow or float precision issues during parsing. + # Numbers are just serialized as strings and then converted back to numbers + # before being passed to the VM, which also keeps the door open in the future + # to implementing bignum arithmetic that can take advantage of natively supported + # machine types, meaning that if a numeric type fits into a 64 bit signed/unsigned + # int then it is stored in such a type to save space, otherwise it is just converted + # to a bigint. Bigfloats with arbitrary-precision arithmetic would also be nice, + # although arguably less useful (and probably significantly slower than bigints) + literal*: Token + + IntExpr* = ref object of LiteralExpr + OctExpr* = ref object of LiteralExpr + HexExpr* = ref object of LiteralExpr + BinExpr* = ref object of LiteralExpr + FloatExpr* = ref object of LiteralExpr + StrExpr* = ref object of LiteralExpr + CharExpr* = ref object of LiteralExpr + + TrueExpr* = ref object of LiteralExpr + FalseExpr* = ref object of LiteralExpr + NilExpr* = ref object of LiteralExpr + NanExpr* = ref object of LiteralExpr + InfExpr* = ref object of LiteralExpr + + IdentExpr* = ref object of Expression + name*: Token + + GroupingExpr* = ref object of Expression + expression*: Expression + + GetItemExpr* = ref object of Expression + obj*: Expression + name*: IdentExpr + + SetItemExpr* = ref object of GetItemExpr + # Since a setItem expression is just + # a getItem one followed by an assignment, + # inheriting it from getItem makes sense + value*: Expression + + CallExpr* = ref object of Expression + callee*: Expression # The object being called + arguments*: tuple[positionals: seq[Expression], keyword: seq[tuple[ + name: IdentExpr, value: Expression]]] + + UnaryExpr* = ref object of Expression + operator*: Token + a*: Expression + + BinaryExpr* = ref object of UnaryExpr + # Binary expressions can be seen here as unary + # expressions with an extra operand so we just + # inherit from that and add a second operand + b*: Expression + + YieldExpr* = ref object of Expression + expression*: Expression + + AwaitExpr* = ref object of Expression + expression*: Expression + + LambdaExpr* = ref object of Expression + body*: Statement + arguments*: seq[tuple[name: IdentExpr, valueType: Expression, + mutable: bool, isRef: bool, isPtr: bool]] + defaults*: seq[Expression] + isGenerator*: bool + isAsync*: bool + isPure*: bool + returnType*: Expression + hasExplicitReturn*: bool + + + SliceExpr* = ref object of Expression + expression*: Expression + ends*: seq[Expression] + + AssignExpr* = ref object of Expression + name*: Expression + value*: Expression + + ExprStmt* = ref object of Statement + expression*: Expression + + ImportStmt* = ref object of Statement + moduleName*: IdentExpr + + AssertStmt* = ref object of Statement + expression*: Expression + + RaiseStmt* = ref object of Statement + exception*: Expression + + BlockStmt* = ref object of Statement + code*: seq[Declaration] + + ForStmt* = ref object of Statement + discard # Unused + + ForEachStmt* = ref object of Statement + identifier*: IdentExpr + expression*: Expression + body*: Statement + + DeferStmt* = ref object of Statement + expression*: Expression + + TryStmt* = ref object of Statement + body*: Statement + handlers*: seq[tuple[body: Statement, exc: IdentExpr]] + finallyClause*: Statement + elseClause*: Statement + + WhileStmt* = ref object of Statement + condition*: Expression + body*: Statement + + AwaitStmt* = ref object of Statement + expression*: Expression + + BreakStmt* = ref object of Statement + + ContinueStmt* = ref object of Statement + + ReturnStmt* = ref object of Statement + value*: Expression + + IfStmt* = ref object of Statement + condition*: Expression + thenBranch*: Statement + elseBranch*: Statement + + YieldStmt* = ref object of Statement + expression*: Expression + + VarDecl* = ref object of Declaration + name*: IdentExpr + value*: Expression + isConst*: bool + isPrivate*: bool + isLet*: bool + valueType*: Expression + + FunDecl* = ref object of Declaration + name*: IdentExpr + body*: Statement + arguments*: seq[tuple[name: IdentExpr, valueType: Expression, + mutable: bool, isRef: bool, isPtr: bool]] + defaults*: seq[Expression] + isAsync*: bool + isGenerator*: bool + isPrivate*: bool + isPure*: bool + returnType*: Expression + hasExplicitReturn*: bool + Pragma* = ref object of Expression + name*: IdentExpr + args*: seq[LiteralExpr] + + +proc isConst*(self: ASTNode): bool = + ## Returns true if the given + ## AST node represents a value + ## of constant type. All integers, + ## strings and singletons count as + ## constants + case self.kind: + of intExpr, hexExpr, binExpr, octExpr, strExpr, falseExpr, trueExpr, + infExpr, nanExpr, floatExpr, nilExpr: + return true + else: + return false + + +proc isLiteral*(self: ASTNode): bool {.inline.} = + ## Returns if the AST node represents a literal + self.kind in {intExpr, hexExpr, binExpr, octExpr, + strExpr, falseExpr, trueExpr, infExpr, + nanExpr, floatExpr, nilExpr + } + +## AST node constructors +proc newASTNode*(kind: NodeKind, token: Token): ASTNode = + ## Initializes a new generic ASTNode object + new(result) + result.kind = kind + result.token = token + + +proc newPragma*(name: IdentExpr, args: seq[LiteralExpr]): Pragma = + new(result) + result.kind = pragmaExpr + result.args = args + result.name = name + + +proc newIntExpr*(literal: Token): IntExpr = + result = IntExpr(kind: intExpr) + result.literal = literal + result.token = literal + + +proc newOctExpr*(literal: Token): OctExpr = + result = OctExpr(kind: octExpr) + result.literal = literal + result.token = literal + + +proc newHexExpr*(literal: Token): HexExpr = + result = HexExpr(kind: hexExpr) + result.literal = literal + result.token = literal + + +proc newBinExpr*(literal: Token): BinExpr = + result = BinExpr(kind: binExpr) + result.literal = literal + result.token = literal + + +proc newFloatExpr*(literal: Token): FloatExpr = + result = FloatExpr(kind: floatExpr) + result.literal = literal + result.token = literal + + +proc newTrueExpr*(token: Token): LiteralExpr = LiteralExpr(kind: trueExpr, + token: token, literal: token) +proc newFalseExpr*(token: Token): LiteralExpr = LiteralExpr(kind: falseExpr, + token: token, literal: token) +proc newNaNExpr*(token: Token): LiteralExpr = LiteralExpr(kind: nanExpr, + token: token, literal: token) +proc newNilExpr*(token: Token): LiteralExpr = LiteralExpr(kind: nilExpr, + token: token, literal: token) +proc newInfExpr*(token: Token): LiteralExpr = LiteralExpr(kind: infExpr, + token: token, literal: token) + + +proc newStrExpr*(literal: Token): StrExpr = + result = StrExpr(kind: strExpr) + result.literal = literal + result.token = literal + + +proc newCharExpr*(literal: Token): CharExpr = + result = CharExpr(kind: charExpr) + result.literal = literal + result.token = literal + + +proc newIdentExpr*(name: Token): IdentExpr = + result = IdentExpr(kind: identExpr) + result.name = name + result.token = name + + +proc newGroupingExpr*(expression: Expression, token: Token): GroupingExpr = + result = GroupingExpr(kind: groupingExpr) + result.expression = expression + result.token = token + + +proc newLambdaExpr*(arguments: seq[tuple[name: IdentExpr, valueType: Expression, + mutable: bool, isRef: bool, isPtr: bool]], defaults: seq[Expression], + body: Statement, isGenerator: bool, isAsync: bool, token: Token, + returnType: Expression, pragmas: seq[Pragma], + generics: seq[tuple[name: IdentExpr, cond: Expression]]): LambdaExpr = + result = LambdaExpr(kind: lambdaExpr) + result.body = body + result.arguments = arguments + result.defaults = defaults + result.isGenerator = isGenerator + result.isAsync = isAsync + result.token = token + result.returnType = returnType + result.isPure = false + result.pragmas = pragmas + result.generics = generics + + +proc newGetItemExpr*(obj: Expression, name: IdentExpr, + token: Token): GetItemExpr = + result = GetItemExpr(kind: getItemExpr) + result.obj = obj + result.name = name + result.token = token + + +proc newSetItemExpr*(obj: Expression, name: IdentExpr, value: Expression, + token: Token): SetItemExpr = + result = SetItemExpr(kind: setItemExpr) + result.obj = obj + result.name = name + result.value = value + result.token = token + + +proc newCallExpr*(callee: Expression, arguments: tuple[positionals: seq[ + Expression], keyword: seq[tuple[name: IdentExpr, value: Expression]]], + token: Token): CallExpr = + result = CallExpr(kind: callExpr) + result.callee = callee + result.arguments = arguments + result.token = token + + +proc newSliceExpr*(expression: Expression, ends: seq[Expression], + token: Token): SliceExpr = + result = SliceExpr(kind: sliceExpr) + result.expression = expression + result.ends = ends + result.token = token + + +proc newUnaryExpr*(operator: Token, a: Expression): UnaryExpr = + result = UnaryExpr(kind: unaryExpr) + result.operator = operator + result.a = a + result.token = result.operator + + +proc newBinaryExpr*(a: Expression, operator: Token, b: Expression): BinaryExpr = + result = BinaryExpr(kind: binaryExpr) + result.operator = operator + result.a = a + result.b = b + result.token = operator + + +proc newYieldExpr*(expression: Expression, token: Token): YieldExpr = + result = YieldExpr(kind: yieldExpr) + result.expression = expression + result.token = token + + +proc newAssignExpr*(name: Expression, value: Expression, + token: Token): AssignExpr = + result = AssignExpr(kind: assignExpr) + result.name = name + result.value = value + result.token = token + + +proc newAwaitExpr*(expression: Expression, token: Token): AwaitExpr = + result = AwaitExpr(kind: awaitExpr) + result.expression = expression + result.token = token + + +proc newExprStmt*(expression: Expression, token: Token): ExprStmt = + result = ExprStmt(kind: exprStmt) + result.expression = expression + result.token = token + + +proc newImportStmt*(moduleName: IdentExpr, token: Token): ImportStmt = + result = ImportStmt(kind: importStmt) + result.moduleName = moduleName + result.token = token + + +proc newYieldStmt*(expression: Expression, token: Token): YieldStmt = + result = YieldStmt(kind: yieldStmt) + result.expression = expression + result.token = token + + +proc newAwaitStmt*(expression: Expression, token: Token): AwaitStmt = + result = AwaitStmt(kind: awaitStmt) + result.expression = expression + result.token = token + + +proc newAssertStmt*(expression: Expression, token: Token): AssertStmt = + result = AssertStmt(kind: assertStmt) + result.expression = expression + result.token = token + + +proc newDeferStmt*(expression: Expression, token: Token): DeferStmt = + result = DeferStmt(kind: deferStmt) + result.expression = expression + result.token = token + + +proc newRaiseStmt*(exception: Expression, token: Token): RaiseStmt = + result = RaiseStmt(kind: raiseStmt) + result.exception = exception + result.token = token + + +proc newTryStmt*(body: Statement, handlers: seq[tuple[body: Statement, exc: IdentExpr]], + finallyClause: Statement, + elseClause: Statement, token: Token): TryStmt = + result = TryStmt(kind: tryStmt) + result.body = body + result.handlers = handlers + result.finallyClause = finallyClause + result.elseClause = elseClause + result.token = token + + +proc newBlockStmt*(code: seq[Declaration], token: Token): BlockStmt = + result = BlockStmt(kind: blockStmt) + result.code = code + result.token = token + + +proc newWhileStmt*(condition: Expression, body: Statement, + token: Token): WhileStmt = + result = WhileStmt(kind: whileStmt) + result.condition = condition + result.body = body + result.token = token + + +proc newForEachStmt*(identifier: IdentExpr, expression: Expression, + body: Statement, token: Token): ForEachStmt = + result = ForEachStmt(kind: forEachStmt) + result.identifier = identifier + result.expression = expression + result.body = body + result.token = token + + +proc newBreakStmt*(token: Token): BreakStmt = + result = BreakStmt(kind: breakStmt) + result.token = token + + +proc newContinueStmt*(token: Token): ContinueStmt = + result = ContinueStmt(kind: continueStmt) + result.token = token + + +proc newReturnStmt*(value: Expression, token: Token): ReturnStmt = + result = ReturnStmt(kind: returnStmt) + result.value = value + result.token = token + + +proc newIfStmt*(condition: Expression, thenBranch, elseBranch: Statement, + token: Token): IfStmt = + result = IfStmt(kind: ifStmt) + result.condition = condition + result.thenBranch = thenBranch + result.elseBranch = elseBranch + result.token = token + + +proc newVarDecl*(name: IdentExpr, value: Expression, isConst: bool = false, + isPrivate: bool = true, token: Token, isLet: bool = false, + valueType: Expression, pragmas: seq[Pragma]): VarDecl = + result = VarDecl(kind: varDecl) + result.name = name + result.value = value + result.isConst = isConst + result.isPrivate = isPrivate + result.token = token + result.isLet = isLet + result.valueType = valueType + result.pragmas = pragmas + + +proc newFunDecl*(name: IdentExpr, arguments: seq[tuple[name: IdentExpr, valueType: Expression, mutable: bool, isRef: bool, isPtr: bool]], defaults: seq[Expression], + body: Statement, isAsync, isGenerator: bool, + isPrivate: bool, token: Token, pragmas: seq[Pragma], + returnType: Expression, generics: seq[tuple[name: IdentExpr, cond: Expression]]): FunDecl = + result = FunDecl(kind: funDecl) + result.name = name + result.arguments = arguments + result.defaults = defaults + result.body = body + result.isAsync = isAsync + result.isGenerator = isGenerator + result.isPrivate = isPrivate + result.token = token + result.pragmas = pragmas + result.returnType = returnType + result.isPure = false + result.generics = generics + + +proc `$`*(self: ASTNode): string = + if self == nil: + return "nil" + case self.kind: + of intExpr, floatExpr, hexExpr, binExpr, octExpr, strExpr, trueExpr, + falseExpr, nanExpr, nilExpr, infExpr: + if self.kind in {trueExpr, falseExpr, nanExpr, nilExpr, infExpr}: + result &= &"Literal({($self.kind)[0..^5]})" + elif self.kind == strExpr: + result &= &"Literal({LiteralExpr(self).literal.lexeme[1..^2].escape()})" + else: + result &= &"Literal({LiteralExpr(self).literal.lexeme})" + of identExpr: + result &= &"Identifier('{IdentExpr(self).name.lexeme}')" + of groupingExpr: + result &= &"Grouping({GroupingExpr(self).expression})" + of getItemExpr: + var self = GetItemExpr(self) + result &= &"GetItem(obj={self.obj}, name={self.name})" + of setItemExpr: + var self = SetItemExpr(self) + result &= &"SetItem(obj={self.obj}, name={self.value}, value={self.value})" + of callExpr: + var self = CallExpr(self) + result &= &"""Call({self.callee}, arguments=(positionals=[{self.arguments.positionals.join(", ")}], keyword=[{self.arguments.keyword.join(", ")}]))""" + of unaryExpr: + var self = UnaryExpr(self) + result &= &"Unary(Operator('{self.operator.lexeme}'), {self.a})" + of binaryExpr: + var self = BinaryExpr(self) + result &= &"Binary({self.a}, Operator('{self.operator.lexeme}'), {self.b})" + of assignExpr: + var self = AssignExpr(self) + result &= &"Assign(name={self.name}, value={self.value})" + of exprStmt: + var self = ExprStmt(self) + result &= &"ExpressionStatement({self.expression})" + of breakStmt: + result = "Break()" + of importStmt: + var self = ImportStmt(self) + result &= &"Import({self.moduleName})" + of assertStmt: + var self = AssertStmt(self) + result &= &"Assert({self.expression})" + of raiseStmt: + var self = RaiseStmt(self) + result &= &"Raise({self.exception})" + of blockStmt: + var self = BlockStmt(self) + result &= &"""Block([{self.code.join(", ")}])""" + of whileStmt: + var self = WhileStmt(self) + result &= &"While(condition={self.condition}, body={self.body})" + of forEachStmt: + var self = ForEachStmt(self) + result &= &"ForEach(identifier={self.identifier}, expression={self.expression}, body={self.body})" + of returnStmt: + var self = ReturnStmt(self) + result &= &"Return({self.value})" + of yieldExpr: + var self = YieldExpr(self) + result &= &"Yield({self.expression})" + of awaitExpr: + var self = AwaitExpr(self) + result &= &"Await({self.expression})" + of ifStmt: + var self = IfStmt(self) + if self.elseBranch == nil: + result &= &"If(condition={self.condition}, thenBranch={self.thenBranch}, elseBranch=nil)" + else: + result &= &"If(condition={self.condition}, thenBranch={self.thenBranch}, elseBranch={self.elseBranch})" + of yieldStmt: + var self = YieldStmt(self) + result &= &"YieldStmt({self.expression})" + of awaitStmt: + var self = AwaitStmt(self) + result &= &"AwaitStmt({self.expression})" + of varDecl: + var self = VarDecl(self) + result &= &"Var(name={self.name}, value={self.value}, const={self.isConst}, private={self.isPrivate}, type={self.valueType})" + of funDecl: + var self = FunDecl(self) + result &= &"""FunDecl(name={self.name}, body={self.body}, type={self.returnType}, arguments=[{self.arguments.join(", ")}], defaults=[{self.defaults.join(", ")}], generics=[{self.generics.join(", ")}], async={self.isAsync}, generator={self.isGenerator}, private={self.isPrivate})""" + of lambdaExpr: + var self = LambdaExpr(self) + result &= &"""Lambda(body={self.body}, type={self.returnType}, arguments=[{self.arguments.join(", ")}], defaults=[{self.defaults.join(", ")}], generator={self.isGenerator}, async={self.isAsync})""" + of deferStmt: + var self = DeferStmt(self) + result &= &"Defer({self.expression})" + of sliceExpr: + var self = SliceExpr(self) + result &= &"""Slice({self.expression}, ends=[{self.ends.join(", ")}])""" + of tryStmt: + var self = TryStmt(self) + result &= &"TryStmt(body={self.body}, handlers={self.handlers}" + if self.finallyClause != nil: + result &= &", finallyClause={self.finallyClause}" + else: + result &= ", finallyClause=nil" + if self.elseClause != nil: + result &= &", elseClause={self.elseClause}" + else: + result &= ", elseClause=nil" + result &= ")" + else: + discard + + +proc `==`*(self, other: IdentExpr): bool {.inline.} = self.token == other.token diff --git a/src/frontend/meta/bytecode.nim b/src/frontend/meta/bytecode.nim new file mode 100644 index 0000000..ed010ef --- /dev/null +++ b/src/frontend/meta/bytecode.nim @@ -0,0 +1,228 @@ +# Copyright 2022 Mattia Giambirtone & All Contributors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +## Low level bytecode implementation details + +import strutils +import strformat + +import ../../util/multibyte + + +type + Chunk* = ref object + ## A piece of bytecode. + ## consts is used when serializing to/from a bytecode stream. + ## code is the linear sequence of compiled bytecode instructions. + ## lines maps bytecode instructions to line numbers using Run + ## Length Encoding. Instructions are encoded in groups whose structure + ## follows the following schema: + ## - The first integer represents the line number + ## - The second integer represents the count of whatever comes after it + ## (let's call it c) + ## - After c, a sequence of c integers follows + ## + ## A visual representation may be easier to understand: [1, 2, 3, 4] + ## This is to be interpreted as "there are 2 instructions at line 1 whose values + ## are 3 and 4" + ## This is more efficient than using the naive approach, which would encode + ## the same line number multiple times and waste considerable amounts of space. + consts*: seq[uint8] + code*: seq[uint8] + lines*: seq[int] + + OpCode* {.pure.} = enum + ## Enum of Peon's bytecode opcodes + + # Note: x represents the argument + # to unary opcodes, while a and b + # represent arguments to binary + # opcodes. Other variable names (c, d, ...) + # may be used for more complex opcodes. If + # an opcode takes any arguments at runtime, + # they come from either the stack or the VM's + # closure array. Some other opcodes (e.g. + # jumps), take arguments in the form of 16 + # or 24 bit numbers that are defined statically + # at compilation time into the bytecode + + # These push a constant onto the stack + LoadInt64 = 0u8, + LoadUInt64, + LoadInt32, + LoadUInt32, + LoadInt16, + LoadUInt16, + LoadInt8, + LoadUInt8, + LoadFloat64, + LoadFloat32, + LoadString, + ## Singleton opcodes (each of them pushes a constant singleton on the stack) + LoadNil, + LoadTrue, + LoadFalse, + LoadNan, + LoadInf, + ## Basic stack operations + Pop, # Pops an element off the stack and discards it + Push, # Pushes x onto the stack + PopN, # Pops x elements off the stack (optimization for exiting local scopes which usually pop many elements) + ## Name resolution/handling + LoadAttribute, # Pushes the attribute b of object a onto the stack + LoadVar, # Pushes the object at position x in the stack onto the stack + StoreVar, # Stores the value of b at position a in the stack + LoadHeap, # Pushes the object position x in the closure array onto the stack + StoreHeap, # Stores the value of b at position a in the closure array + ## Looping and jumping + Jump, # Absolute, unconditional jump into the bytecode + JumpForwards, # Relative, unconditional, positive jump in the bytecode + JumpBackwards, # Relative, unconditional, negative jump in the bytecode + JumpIfFalse, # Jumps to a relative index in the bytecode if x is false + JumpIfTrue, # Jumps to a relative index in the bytecode if x is true + JumpIfFalsePop, # Like JumpIfFalse, but also pops off the stack (regardless of truthyness). Optimization for if statements + JumpIfFalseOrPop, # Jumps to an absolute index in the bytecode if x is false and pops otherwise (used for logical and) + ## Long variants of jumps (they use a 24-bit operand instead of a 16-bit one) + LongJump, + LongJumpIfFalse, + LongJumpIfTrue, + LongJumpIfFalsePop, + LongJumpIfFalseOrPop, + LongJumpForwards, + LongJumpBackwards, + ## Functions + Call, # Calls a function and initiates a new stack frame + Return, # Terminates the current function without popping off the stack + ReturnValue, # Pops a return value off the stack and terminates the current function + ## Exception handling + Raise, # Raises exception x or re-raises active exception if x is nil + BeginTry, # Initiates an exception handling context + FinishTry, # Closes the current exception handling context + ## Generators + Yield, # Yields control from a generator back to the caller + ## Coroutines + Await, # Calls an asynchronous function + ## Misc + Assert, # Raises an AssertionFailed exception if x is false + NoOp, # Just a no-op + + +# We group instructions by their operation/operand types for easier handling when debugging + +# Simple instructions encompass instructions that push onto/pop off the stack unconditionally (True, False, Pop, etc.) +const simpleInstructions* = {OpCode.Return, LoadNil, + LoadTrue, LoadFalse, + LoadNan, LoadInf, + Pop, OpCode.Raise, + BeginTry, FinishTry, + OpCode.Yield, OpCode.Await, + OpCode.NoOp, OpCode.Return, + OpCode.ReturnValue} + +# Constant instructions are instructions that operate on the bytecode constant table +const constantInstructions* = {LoadInt64, LoadUInt64, + LoadInt32, LoadUInt32, + LoadInt16, LoadUInt16, + LoadInt8, LoadUInt8, + LoadFloat64, LoadFloat32, + LoadString} + +# Stack triple instructions operate on the stack at arbitrary offsets and pop arguments off of it in the form +# of 24 bit integers +const stackTripleInstructions* = {StoreVar, LoadVar, LoadHeap, StoreHeap} + +# Stack double instructions operate on the stack at arbitrary offsets and pop arguments off of it in the form +# of 16 bit integers +const stackDoubleInstructions* = {} + +# Argument double argument instructions take hardcoded arguments as 16 bit integers +const argumentDoubleInstructions* = {PopN, } + +# Argument double argument instructions take hardcoded arguments as 24 bit integers +const argumentTripleInstructions* = {} + +# Instructions that call functions +const callInstructions* = {Call, } + +# Jump instructions jump at relative or absolute bytecode offsets +const jumpInstructions* = {Jump, LongJump, JumpIfFalse, JumpIfFalsePop, + JumpForwards, JumpBackwards, + LongJumpIfFalse, LongJumpIfFalsePop, + LongJumpForwards, LongJumpBackwards, + JumpIfTrue, LongJumpIfTrue} + + +proc newChunk*: Chunk = + ## Initializes a new, empty chunk + result = Chunk(consts: @[], code: @[], lines: @[]) + + +proc `$`*(self: Chunk): string = &"""Chunk(consts=[{self.consts.join(", ")}], code=[{self.code.join(", ")}], lines=[{self.lines.join(", ")}])""" + + +proc write*(self: Chunk, newByte: uint8, line: int) = + ## Adds the given instruction at the provided line number + ## to the given chunk object + assert line > 0, "line must be greater than zero" + if self.lines.high() >= 1 and self.lines[^2] == line: + self.lines[^1] += 1 + else: + self.lines.add(line) + self.lines.add(1) + self.code.add(newByte) + + +proc write*(self: Chunk, bytes: openarray[uint8], line: int) = + ## Calls write in a loop with all members of the given + ## array + for cByte in bytes: + self.write(cByte, line) + + +proc write*(self: Chunk, newByte: OpCode, line: int) = + ## Adds the given instruction at the provided line number + ## to the given chunk object + self.write(uint8(newByte), line) + + +proc write*(self: Chunk, bytes: openarray[OpCode], line: int) = + ## Calls write in a loop with all members of the given + ## array + for cByte in bytes: + self.write(uint8(cByte), line) + + +proc getLine*(self: Chunk, idx: int): int = + ## Returns the associated line of a given + ## instruction index + if self.lines.len < 2: + raise newException(IndexDefect, "the chunk object is empty") + var + count: int + current: int = 0 + for n in countup(0, self.lines.high(), 2): + count = self.lines[n + 1] + if idx in current - count.. 0 local) + scopeDepth: int + operators: OperatorTable + # The AST node + tree: seq[Declaration] + + +proc newOperatorTable: OperatorTable = + ## Initializes a new OperatorTable + ## object + new(result) + result.tokens = @[] + result.precedence = newTable[Precedence, seq[string]]() + for prec in Precedence: + result.precedence[prec] = @[] + + +proc addOperator(self: OperatorTable, lexeme: string) = + ## Adds an operator to the table. Its precedence + ## is inferred from the operator's lexeme (the + ## criteria are similar to Nim's) + if lexeme in self.tokens: + return # We've already added it! + var prec = Precedence.high() + if lexeme.len() >= 2 and lexeme[^2..^1] in ["->", "~>", "=>"]: + prec = Arrow + elif lexeme.endsWith("=") and lexeme[0] notin {'<', '>', '!', '?', '~', '='}: + prec = Assign + elif lexeme[0] in {'$', } or lexeme == "**": + prec = Power + elif lexeme[0] in {'*', '%', '/', '\\'}: + prec = Multiplication + elif lexeme[0] in {'+', '-', '|', '~'}: + prec = Addition + elif lexeme[0] in {'<', '>', '=', '!'}: + prec = Compare + elif lexeme == "and": + prec = Precedence.And + elif lexeme == "or": + prec = Precedence.Or + self.tokens.add(lexeme) + self.precedence[prec].add(lexeme) + + +proc getPrecedence(self: OperatorTable, lexeme: string): Precedence = + ## Gets the precedence of a given operator + for (prec, operators) in self.precedence.pairs(): + if lexeme in operators: + return prec + + +proc newParser*: Parser = + ## Initializes a new Parser object + new(result) + result.current = 0 + result.file = "" + result.tokens = @[] + result.currentFunction = nil + result.currentLoop = LoopContext.None + result.scopeDepth = 0 + result.operators = newOperatorTable() + result.tree = @[] + + +# Public getters for improved error formatting +proc getCurrent*(self: Parser): int {.inline.} = self.current +proc getCurrentToken*(self: Parser): Token {.inline.} = (if self.getCurrent() >= + self.tokens.high() or + self.getCurrent() - 1 < 0: self.tokens[^1] else: self.tokens[self.current - 1]) +proc getCurrentFunction*(self: Parser): Declaration {.inline.} = self.currentFunction +proc getFile*(self: Parser): string {.inline.} = self.file +proc getModule*(self: Parser): string {.inline.} = self.getFile().extractFilename() + +# Handy templates to make our life easier, thanks nim! +template endOfFile: Token = Token(kind: EndOfFile, lexeme: "", line: -1) +template endOfLine(msg: string) = self.expect(Semicolon, msg) + + +proc peek(self: Parser, distance: int = 0): Token = + ## Peeks at the token at the given distance. + ## If the distance is out of bounds, an EOF + ## token is returned. A negative distance may + ## be used to retrieve previously consumed + ## tokens + if self.tokens.high() == -1 or self.current + distance > self.tokens.high( + ) or self.current + distance < 0: + result = endOfFile + else: + result = self.tokens[self.current + distance] + + +proc done(self: Parser): bool {.inline.} = + ## Returns true if we're at the + ## end of the file. Note that the + ## parser expects an explicit + ## EOF token to signal the end + ## of the file + result = self.peek().kind == EndOfFile + + +proc step(self: Parser, n: int = 1): Token = + ## Steps n tokens into the input, + ## returning the last consumed one + if self.done(): + result = self.peek() + else: + result = self.tokens[self.current] + self.current += 1 + + +proc error(self: Parser, message: string) {.raises: [ParseError].} = + ## Raises a ParseError exception + raise ParseError(msg: message, token: self.getCurrentToken(), file: self.file, module: self.getModule()) + + +# Why do we allow strings or enum members of TokenType? Well, it's simple: +# symbols like ":" and "=" are both valid operator names (therefore they are +# tokenized as symbols), but they are also used in a context where they are just +# separators (for example, the colon is used in type declarations). Since we can't +# tell at tokenization time which of the two contexts we're in, we just treat everything +# as a symbol and in the cases where we need a specific token we just match the string +# directly +proc check[T: TokenType or string](self: Parser, kind: T, + distance: int = 0): bool = + ## Checks if the given token at the given distance + ## matches the expected kind and returns a boolean. + ## The distance parameter is passed directly to + ## self.peek() + when T is TokenType: + self.peek(distance).kind == kind + else: + when T is string: + self.peek(distance).lexeme == kind + + +proc check[T: TokenType or string](self: Parser, kind: openarray[T]): bool = + ## Calls self.check() in a loop with each entry of + ## the given openarray of token kinds and returns + ## at the first match. Note that this assumes + ## that only one token may match at a given + ## position + for k in kind: + if self.check(k): + return true + return false + + +proc match[T: TokenType or string](self: Parser, kind: T): bool = + ## Behaves like self.check(), except that when a token + ## matches it is also consumed + if self.check(kind): + discard self.step() + result = true + else: + result = false + + +proc match[T: TokenType or string](self: Parser, kind: openarray[T]): bool = + ## Calls self.match() in a loop with each entry of + ## the given openarray of token kinds and returns + ## at the first match. Note that this assumes + ## that only one token may exist at a given + ## position + for k in kind: + if self.match(k): + return true + result = false + + +proc expect[T: TokenType or string](self: Parser, kind: T, + message: string = "") = + ## Behaves like self.match(), except that + ## when a token doesn't match, an error + ## is raised. If no error message is + ## given, a default one is used + if not self.match(kind): + if message.len() == 0: + self.error(&"expecting token of kind {kind}, found {self.peek().kind} instead") + else: + self.error(message) + + +proc expect[T: TokenType or string](self: Parser, kind: openarray[T], + message: string = "") = + ## Behaves like self.expect(), except that + ## an error is raised only if none of the + ## given token kinds matches + for k in kind: + if self.match(kind): + return + if message.len() == 0: + self.error(&"""expecting any of the following tokens: {kinds.join(", ")}, but got {self.peek().kind} instead""") + + +# Forward declarations +proc expression(self: Parser): Expression +proc expressionStatement(self: Parser): Statement +proc statement(self: Parser): Statement +proc varDecl(self: Parser, isLet: bool = false, + isConst: bool = false): Declaration +proc funDecl(self: Parser, isAsync: bool = false, isGenerator: bool = false, + isLambda: bool = false, isOperator: bool = false): Declaration +proc declaration(self: Parser): Declaration +# End of forward declarations + + +proc primary(self: Parser): Expression = + ## Parses primary expressions such + ## as integer literals and keywords + ## that map to builtin types (true, + ## false, nil, etc.) + case self.peek().kind: + of True: + result = newTrueExpr(self.step()) + of False: + result = newFalseExpr(self.step()) + of TokenType.NotANumber: + result = newNanExpr(self.step()) + of Nil: + result = newNilExpr(self.step()) + of Float: + result = newFloatExpr(self.step()) + of Integer: + result = newIntExpr(self.step()) + of Identifier: + result = newIdentExpr(self.step()) + of LeftParen: + let tok = self.step() + result = newGroupingExpr(self.expression(), tok) + self.expect(RightParen, "unterminated parenthesized expression") + of Yield: + let tok = self.step() + if self.currentFunction == nil: + self.error("'yield' cannot be used outside functions") + elif self.currentFunction.token.kind != Generator: + # It's easier than doing conversions for lambda/funDecl + self.error("'yield' cannot be used outside generators") + if not self.check([RightBrace, RightBracket, RightParen, Comma, Semicolon]): + # Expression delimiters + result = newYieldExpr(self.expression(), tok) + else: + # Empty yield + result = newYieldExpr(newNilExpr(Token()), tok) + of Await: + let tok = self.step() + if self.currentFunction == nil: + self.error("'await' cannot be used outside functions") + if self.currentFunction.token.kind != Coroutine: + self.error("'await' can only be used inside coroutines") + result = newAwaitExpr(self.expression(), tok) + of RightParen, RightBracket, RightBrace: + # This is *technically* unnecessary: the parser would + # throw an error regardless, but it's a little bit nicer + # when the error message is more specific + self.error(&"unmatched '{self.peek().lexeme}'") + of Hex: + result = newHexExpr(self.step()) + of Octal: + result = newOctExpr(self.step()) + of Binary: + result = newBinExpr(self.step()) + of String: + result = newStrExpr(self.step()) + of Infinity: + result = newInfExpr(self.step()) + of Function: + discard self.step() + result = Expression(self.funDecl(isLambda = true)) + of Coroutine: + discard self.step() + result = Expression(self.funDecl(isAsync = true, isLambda = true)) + of Generator: + discard self.step() + result = Expression(self.funDecl(isGenerator = true, + isLambda = true)) + else: + self.error("invalid syntax") + + +proc makeCall(self: Parser, callee: Expression): Expression = + ## Utility function called iteratively by self.call() + ## to parse a function call + let tok = self.peek(-1) + var argNames: seq[IdentExpr] = @[] + var arguments: tuple[positionals: seq[Expression], keyword: seq[tuple[ + name: IdentExpr, value: Expression]]] = (positionals: @[], + keyword: @[]) + var argument: Expression = nil + var argCount = 0 + if not self.check(RightParen): + while true: + if argCount >= 255: + self.error("call can not have more than 255 arguments") + break + argument = self.expression() + if argument.kind == assignExpr: + # TODO: This will explode with slices! + if IdentExpr(AssignExpr(argument).name) in argNames: + self.error("duplicate keyword argument in call") + argNames.add(IdentExpr(AssignExpr(argument).name)) + arguments.keyword.add((name: IdentExpr(AssignExpr( + argument).name), value: AssignExpr(argument).value)) + elif arguments.keyword.len() == 0: + arguments.positionals.add(argument) + else: + self.error("positional argument cannot follow keyword argument in call") + if not self.match(Comma): + break + argCount += 1 + self.expect(RightParen) + result = newCallExpr(callee, arguments, tok) + + +proc call(self: Parser): Expression = + ## Parses function calls, object field + ## accessing and slicing expressions + result = self.primary() + while true: + if self.match(LeftParen): + result = self.makeCall(result) + elif self.match(Dot): + self.expect(Identifier, "expecting attribute name after '.'") + result = newGetItemExpr(result, newIdentExpr(self.peek(-1)), + self.peek(-1)) + elif self.match(LeftBracket): + # Slicing such as a[1:2], which is then + # translated to `[]`(a, 1, 2) + let tok = self.peek(-1) + var ends: seq[Expression] = @[] + while not self.check(RightBracket) and not self.done(): + if self.check(":"): + ends.add(newNilExpr(Token(lexeme: "nil"))) + discard self.step() + else: + ends.add(self.expression()) + discard self.match(":") + self.expect(RightBracket, "expecting ']'") + result = newSliceExpr(result, ends, tok) + else: + break + +## Operator parsing handlers + +proc unary(self: Parser): Expression = + if self.peek().lexeme in self.operators.tokens: + result = newUnaryExpr(self.step(), self.unary()) + else: + result = self.call() + + +proc parsePow(self: Parser): Expression = + result = self.unary() + var operator: Token + var right: Expression + while self.operators.getPrecedence(self.peek().lexeme) == Power: + operator = self.step() + right = self.unary() + result = newBinaryExpr(result, operator, right) + + +proc parseMul(self: Parser): Expression = + result = self.parsePow() + var operator: Token + var right: Expression + while self.operators.getPrecedence(self.peek().lexeme) == Multiplication: + operator = self.step() + right = self.parsePow() + result = newBinaryExpr(result, operator, right) + + +proc parseAdd(self: Parser): Expression = + result = self.parseMul() + var operator: Token + var right: Expression + while self.operators.getPrecedence(self.peek().lexeme) == Addition: + operator = self.step() + right = self.parseMul() + result = newBinaryExpr(result, operator, right) + + +proc parseCmp(self: Parser): Expression = + result = self.parseAdd() + var operator: Token + var right: Expression + while self.operators.getPrecedence(self.peek().lexeme) == Compare: + operator = self.step() + right = self.parseAdd() + result = newBinaryExpr(result, operator, right) + + +proc parseAnd(self: Parser): Expression = + result = self.parseCmp() + var operator: Token + var right: Expression + while self.operators.getPrecedence(self.peek().lexeme) == Precedence.And: + operator = self.step() + right = self.parseCmp() + result = newBinaryExpr(result, operator, right) + + +proc parseOr(self: Parser): Expression = + result = self.parseAnd() + var operator: Token + var right: Expression + while self.operators.getPrecedence(self.peek().lexeme) == Precedence.Or: + operator = self.step() + right = self.parseAnd() + result = newBinaryExpr(result, operator, right) + + +proc parseAssign(self: Parser): Expression = + result = self.parseOr() + if self.operators.getPrecedence(self.peek().lexeme) == Assign: + let tok = self.step() + var value = self.expression() + case result.kind: + of identExpr, sliceExpr: + result = newAssignExpr(result, value, tok) + of getItemExpr: + result = newSetItemExpr(GetItemExpr(result).obj, GetItemExpr(result).name, value, tok) + else: + self.error("invalid assignment target") + + +proc parseArrow(self: Parser): Expression = + result = self.parseAssign() + var operator: Token + var right: Expression + while self.operators.getPrecedence(self.peek().lexeme) == Precedence.Or: + operator = self.step() + right = self.parseAssign() + result = newBinaryExpr(result, operator, right) + + +## End of operator parsing handlers + + +proc assertStmt(self: Parser): Statement = + ## Parses "assert" statements, which + ## raise an error if the expression + ## fed into them is falsey + let tok = self.peek(-1) + var expression = self.expression() + endOfLine("missing semicolon after assert statement") + result = newAssertStmt(expression, tok) + + +proc beginScope(self: Parser) = + ## Begins a new lexical scope + inc(self.scopeDepth) + + +proc endScope(self: Parser) = + ## Ends a new lexical scope + dec(self.scopeDepth) + + +proc blockStmt(self: Parser): Statement = + ## Parses block statements. A block + ## statement simply opens a new local + ## scope + self.beginScope() + let tok = self.peek(-1) + var code: seq[Declaration] = @[] + while not self.check(RightBrace) and not self.done(): + code.add(self.declaration()) + if code[^1] == nil: + code.delete(code.high()) + self.expect(RightBrace, "expecting '}'") + result = newBlockStmt(code, tok) + self.endScope() + + +proc breakStmt(self: Parser): Statement = + ## Parses break statements + let tok = self.peek(-1) + if self.currentLoop != Loop: + self.error("'break' cannot be used outside loops") + endOfLine("missing semicolon after break statement") + result = newBreakStmt(tok) + + +proc deferStmt(self: Parser): Statement = + ## Parses defer statements + let tok = self.peek(-1) + if self.currentFunction == nil: + self.error("'defer' cannot be used outside functions") + result = newDeferStmt(self.expression(), tok) + endOfLine("missing semicolon after defer statement") + + +proc continueStmt(self: Parser): Statement = + ## Parses continue statements + let tok = self.peek(-1) + if self.currentLoop != Loop: + self.error("'continue' cannot be used outside loops") + endOfLine("missing semicolon after continue statement") + result = newContinueStmt(tok) + + +proc returnStmt(self: Parser): Statement = + ## Parses return statements + let tok = self.peek(-1) + if self.currentFunction == nil: + self.error("'return' cannot be used outside functions") + var value: Expression + if not self.check(Semicolon): + # Since return can be used on its own too + # we need to check if there's an actual value + # to return or not + value = self.expression() + endOfLine("missing semicolon after return statement") + result = newReturnStmt(value, tok) + case self.currentFunction.kind: + of NodeKind.funDecl: + FunDecl(self.currentFunction).hasExplicitReturn = true + else: + LambdaExpr(self.currentFunction).hasExplicitReturn = true + + +proc yieldStmt(self: Parser): Statement = + ## Parses yield statements + let tok = self.peek(-1) + if self.currentFunction == nil: + self.error("'yield' cannot be outside functions") + elif self.currentFunction.token.kind != Generator: + self.error("'yield' can only be used inside generators") + if not self.check(Semicolon): + result = newYieldStmt(self.expression(), tok) + else: + result = newYieldStmt(newNilExpr(Token(lexeme: "nil")), tok) + endOfLine("missing semicolon after yield statement") + + +proc awaitStmt(self: Parser): Statement = + ## Parses await statements + let tok = self.peek(-1) + if self.currentFunction == nil: + self.error("'await' cannot be used outside functions") + if self.currentFunction.token.kind != Coroutine: + self.error("'await' can only be used inside coroutines") + result = newAwaitStmt(self.expression(), tok) + endOfLine("missing semicolon after await statement") + + +proc raiseStmt(self: Parser): Statement = + ## Parses raise statements + var exception: Expression + let tok = self.peek(-1) + if not self.check(Semicolon): + # Raise can be used on its own, in which + # case it re-raises the last active exception + exception = self.expression() + endOfLine("missing semicolon after raise statement") + result = newRaiseStmt(exception, tok) + + +proc forEachStmt(self: Parser): Statement = + ## Parses C#-like foreach loops + let tok = self.peek(-1) + var enclosingLoop = self.currentLoop + self.currentLoop = Loop + self.expect(LeftParen, "expecting '(' after 'foreach'") + self.expect(Identifier) + var identifier = newIdentExpr(self.peek(-1)) + self.expect(":") + var expression = self.expression() + self.expect(RightParen) + var body = self.statement() + result = newForEachStmt(identifier, expression, body, tok) + self.currentLoop = enclosingLoop + + +proc importStmt(self: Parser, fromStmt: bool = false): Statement = + ## Parses import statements + var tok: Token + if fromStmt: + tok = self.peek(-2) + else: + tok = self.peek(-1) + # TODO: New AST node + self.expect(Identifier, "expecting module name(s) after import statement") + result = newImportStmt(newIdentExpr(self.peek(-1)), tok) + endOfLine("missing semicolon after import statement") + + + +proc tryStmt(self: Parser): Statement = + ## Parses try/except/else/finally blocks + let tok = self.peek(-1) + var body = self.statement() + var handlers: seq[tuple[body: Statement, exc: IdentExpr]] = @[] + var finallyClause: Statement + var elseClause: Statement + var excName: Expression + var handlerBody: Statement + while self.match(Except): + excName = self.expression() + if excName.kind == identExpr: + handlerBody = self.statement() + handlers.add((body: handlerBody, exc: IdentExpr(excName))) + else: + excName = nil + if self.match(Else): + elseClause = self.statement() + if self.match(Finally): + finallyClause = self.statement() + if handlers.len() == 0 and elseClause == nil and finallyClause == nil: + self.error("expecting 'except', 'finally' or 'else' statement after 'try' block") + for i, handler in handlers: + if handler.exc == nil and i != handlers.high(): + self.error("catch-all exception handler with bare 'except' must come last in try statement") + result = newTryStmt(body, handlers, finallyClause, elseClause, tok) + + +proc whileStmt(self: Parser): Statement = + ## Parses a C-style while loop statement + let tok = self.peek(-1) + self.beginScope() + var enclosingLoop = self.currentLoop + self.currentLoop = Loop + self.expect(LeftParen, "expecting '(' before while loop condition") + var condition = self.expression() + self.expect(RightParen, "unterminated while loop condition") + result = newWhileStmt(condition, self.statement(), tok) + self.currentLoop = enclosingLoop + self.endScope() + + +proc forStmt(self: Parser): Statement = + ## Parses a C-style for loop + self.beginScope() + let tok = self.peek(-1) + var enclosingLoop = self.currentLoop + self.currentLoop = Loop + self.expect(LeftParen, "expecting '(' after 'for'") + var initializer: ASTNode = nil + var condition: Expression = nil + var increment: Expression = nil + if self.match(Semicolon): + discard + elif self.match(Var): + initializer = self.varDecl() + if not VarDecl(initializer).isPrivate: + self.error("cannot declare public for loop initializer") + else: + initializer = self.expressionStatement() + if not self.check(Semicolon): + condition = self.expression() + self.expect(Semicolon, "expecting ';' after for loop condition") + if not self.check(RightParen): + increment = self.expression() + self.expect(RightParen, "unterminated for loop increment") + var body = self.statement() + if increment != nil: + # The increment runs after each iteration, so we + # inject it into the block as the last statement + body = newBlockStmt(@[Declaration(body), newExprStmt(increment, + increment.token)], tok) + if condition == nil: + ## An empty condition is functionally + ## equivalent to "true" + condition = newTrueExpr(Token(lexeme: "true")) + # We can use a while loop, which in this case works just as well + body = newWhileStmt(condition, body, tok) + if initializer != nil: + # Nested blocks, so the initializer is + # only executed once + body = newBlockStmt(@[Declaration(initializer), Declaration(body)], tok) + # This desgugars the following code: + # for (var i = 0; i < 10; i += 1) { + # print(i); + # } + # To the semantically equivalent snippet + # below: + # { + # var i = 0; + # while (i < 10) { + # print(i); + # i += 1; + # } + # } + result = body + self.currentLoop = enclosingLoop + self.endScope() + + +proc ifStmt(self: Parser): Statement = + ## Parses if statements + let tok = self.peek(-1) + self.expect(LeftParen, "expecting '(' before if condition") + var condition = self.expression() + self.expect(RightParen, "expecting ')' after if condition") + var thenBranch = self.statement() + var elseBranch: Statement = nil + if self.match(Else): + elseBranch = self.statement() + result = newIfStmt(condition, thenBranch, elseBranch, tok) + + +template checkDecl(self: Parser, isPrivate: bool) = + ## Handy utility template that avoids us from copy + ## pasting the same checks to all declaration handlers + if not isPrivate and self.scopeDepth > 0: + self.error("cannot bind public names inside local scopes") + + +proc varDecl(self: Parser, isLet: bool = false, + isConst: bool = false): Declaration = + ## Parses variable declarations + var tok = self.peek(-1) + var value: Expression + self.expect(Identifier, &"expecting identifier after '{tok.lexeme}'") + var name = newIdentExpr(self.peek(-1)) + let isPrivate = not self.match("*") + self.checkDecl(isPrivate) + var valueType: IdentExpr + if self.match(":"): + # We don't enforce it here because + # the compiler may be able to infer + # the type later! + self.expect(Identifier, "expecting type name after ':'") + valueType = newIdentExpr(self.peek(-1)) + if self.match("="): + value = self.expression() + if isConst and not value.isConst(): + self.error("constant initializer is not a constant") + else: + if tok.kind != Var: + self.error(&"{tok.lexeme} declaration requires an initializer") + value = newNilExpr(Token(lexeme: "nil")) + self.expect(Semicolon, &"expecting semicolon after declaration") + case tok.kind: + of Var: + result = newVarDecl(name, value, isPrivate = isPrivate, token = tok, + valueType = valueType, pragmas = (@[])) + of Const: + result = newVarDecl(name, value, isPrivate = isPrivate, token = tok, + isConst = true, valueType = valueType, pragmas = (@[])) + of Let: + result = newVarDecl(name, value, isPrivate = isPrivate, token = tok, + isLet = isLet, valueType = valueType, pragmas = (@[])) + else: + discard # Unreachable + + +proc parseDeclArguments(self: Parser, arguments: var seq[tuple[name: IdentExpr, valueType: Expression, mutable: bool, isRef: bool, isPtr: bool]], + parameter: var tuple[name: IdentExpr, + valueType: Expression, mutable: bool, + isRef: bool, isPtr: bool], + defaults: var seq[Expression]) = + ## Helper to parse declaration arguments and avoid code duplication + while not self.check(RightParen): + if arguments.len > 255: + self.error("cannot have more than 255 arguments in function declaration") + self.expect(Identifier, "expecting parameter name") + parameter.name = newIdentExpr(self.peek(-1)) + if self.match(":"): + parameter.mutable = false + parameter.isPtr = false + parameter.isRef = false + if self.match(Var): + parameter.mutable = true + elif self.match(Ptr): + parameter.isPtr = true + elif self.match(Ref): + parameter.isRef = true + parameter.valueType = self.expression() + for i in countdown(arguments.high(), 0): + if arguments[i].valueType != nil: + break + arguments[i].valueType = parameter.valueType + arguments[i].mutable = parameter.mutable + else: + parameter.valueType = nil + if parameter in arguments: + self.error("duplicate parameter name in function declaration") + arguments.add(parameter) + if self.match("="): + defaults.add(self.expression()) + elif defaults.len() > 0: + self.error("positional argument cannot follow default argument in function declaration") + if not self.match(Comma): + break + self.expect(RightParen) + for argument in arguments: + if argument.valueType == nil: + self.error(&"missing type declaration for '{argument.name.token.lexeme}' in function declaration") + + +proc parseFunExpr(self: Parser): LambdaExpr = + ## Parses the return value of a function + ## when it is another function. Works + ## recursively + var arguments: seq[tuple[name: IdentExpr, valueType: Expression, + mutable: bool, isRef: bool, isPtr: bool]] = @[] + var defaults: seq[Expression] = @[] + result = newLambdaExpr(arguments, defaults, nil, isGenerator = self.peek(-1).kind == Generator, + isAsync = self.peek(-1).kind == Coroutine, token = self.peek(-1), + returnType = nil, pragmas = (@[]), generics=(@[])) + var parameter: tuple[name: IdentExpr, valueType: Expression, + mutable: bool, isRef: bool, isPtr: bool] + if self.match(LeftParen): + self.parseDeclArguments(arguments, parameter, defaults) + if self.match(":"): + if self.match([Function, Coroutine, Generator]): + result.returnType = self.parseFunExpr() + else: + result.returnType = self.expression() + + +proc parseGenerics(self: Parser, decl: Declaration) = + ## Parses generics in declarations + var gen: tuple[name: IdentExpr, cond: Expression] + while not self.check(RightBracket) and not self.done(): + self.expect(Identifier, "expecting generic type name") + gen.name = newIdentExpr(self.peek(-1)) + if self.match(":"): + gen.cond = self.expression() + decl.generics.add(gen) + if not self.match(Comma): + break + self.expect(RightBracket) + + +proc funDecl(self: Parser, isAsync: bool = false, isGenerator: bool = false, + isLambda: bool = false, isOperator: bool = false): Declaration = # Can't use just FunDecl because it can also return LambdaExpr! + ## Parses all types of functions, coroutines, generators and operators + ## (with or without a name, where applicable) + let tok = self.peek(-1) + var enclosingFunction = self.currentFunction + var arguments: seq[tuple[name: IdentExpr, valueType: Expression, + mutable: bool, isRef: bool, isPtr: bool]] = @[] + var defaults: seq[Expression] = @[] + var returnType: Expression + if not isLambda and self.match(Identifier): + # We do this extra check because we might + # be called from a context where it's + # ambiguous whether we're parsing a declaration + # or an expression. Fortunately anonymous functions + # are nameless, so we can sort the ambiguity by checking + # if there's an identifier after the keyword + self.currentFunction = newFunDecl(newIdentExpr(self.peek(-1)), arguments, defaults, newBlockStmt(@[], Token()), + isAsync = isAsync, + isGenerator = isGenerator, + isPrivate = true, + token = tok, pragmas = (@[]), + returnType = nil, + generics=(@[])) + if self.match("*"): + FunDecl(self.currentFunction).isPrivate = false + self.checkDecl(FunDecl(self.currentFunction).isPrivate) + if self.match(LeftBracket): + self.parseGenerics(self.currentFunction) + elif not isLambda and (self.check([LeftBrace, LeftParen]) or self.check(":")): + # We do a bit of hacking to pretend we never + # wanted to parse this as a declaration in + # the first place and pass control over to + # expressionStatement(), which will in turn + # go all the way up to primary(), which will + # call us back with isLambda=true, allowing us + # to actually parse the function as an expression + while not self.check(tok.kind): # We rewind back to the token that caused us to be called + dec(self.current) + result = Declaration(self.expressionStatement()) + self.currentFunction = enclosingFunction + return result + elif isLambda: + self.currentFunction = newLambdaExpr(arguments, defaults, newBlockStmt(@[], Token()), isGenerator = isGenerator, isAsync = isAsync, token = tok, + returnType = nil, pragmas = (@[]), generics=(@[])) + if self.match(":"): + # Function has explicit return type + if self.match([Function, Coroutine, Generator]): + # The function's return type is another + # function. We specialize this case because + # the type declaration for a function lacks + # the braces that would qualify it as an + # expression + returnType = self.parseFunExpr() + else: + returnType = self.expression() + if self.match(LeftParen): + var parameter: tuple[name: IdentExpr, valueType: Expression, + mutable: bool, isRef: bool, isPtr: bool] + self.parseDeclArguments(arguments, parameter, defaults) + if self.match(":"): + # Function's return type + if self.match([Function, Coroutine, Generator]): + returnType = self.parseFunExpr() + else: + returnType = self.expression() + if self.currentFunction.kind == funDecl: + if not self.match(Semicolon): + # If we don't find a semicolon, + # it's not a forward declaration + self.expect(LeftBrace) + FunDecl(self.currentFunction).body = self.blockStmt() + else: + # This is a forward declaration, so we explicitly + # nullify the function's body to tell the compiler + # to look for it elsewhere in the file later + FunDecl(self.currentFunction).body = nil + FunDecl(self.currentFunction).arguments = arguments + FunDecl(self.currentFunction).returnType = returnType + else: + self.expect(LeftBrace) + LambdaExpr(Expression(self.currentFunction)).body = self.blockStmt() + LambdaExpr(Expression(self.currentFunction)).arguments = arguments + LambdaExpr(Expression(self.currentFunction)).returnType = returnType + result = self.currentFunction + if isOperator: + if arguments.len() == 0: + self.error("cannot declare operator without arguments") + elif isLambda: + self.error("cannot declare anonymous operator") + for argument in arguments: + if argument.valueType == nil: + self.error(&"missing type declaration for '{argument.name.token.lexeme}' in function declaration") + self.currentFunction = enclosingFunction + + +proc expression(self: Parser): Expression = + ## Parses expressions + result = self.parseArrow() # Highest-level expression + + +proc expressionStatement(self: Parser): Statement = + ## Parses expression statements, which + ## are expressions followed by a semicolon + var expression = self.expression() + endOfLine("missing semicolon after expression") + result = Statement(newExprStmt(expression, expression.token)) + + +proc statement(self: Parser): Statement = + ## Parses statements + case self.peek().kind: + of If: + discard self.step() + result = self.ifStmt() + of Assert: + discard self.step() + result = self.assertStmt() + of Raise: + discard self.step() + result = self.raiseStmt() + of Break: + discard self.step() + result = self.breakStmt() + of Continue: + discard self.step() + result = self.continueStmt() + of Return: + discard self.step() + result = self.returnStmt() + of Import: + discard self.step() + result = self.importStmt() + of From: + # TODO + # from module import a [, b, c as d] + discard self.step() + result = self.importStmt(fromStmt = true) + of While: + discard self.step() + result = self.whileStmt() + of For: + discard self.step() + result = self.forStmt() + of Foreach: + discard self.step() + result = self.forEachStmt() + of LeftBrace: + discard self.step() + result = self.blockStmt() + of Yield: + discard self.step() + result = self.yieldStmt() + of Await: + discard self.step() + result = self.awaitStmt() + of Defer: + discard self.step() + result = self.deferStmt() + of Try: + discard self.step() + result = self.tryStmt() + else: + result = self.expressionStatement() + + +proc parsePragma(self: Parser): Pragma = + ## Parses pragmas + if self.scopeDepth == 0: + ## Pragmas used at the + ## top level are either + ## used for compile-time + ## switches or for variable + ## declarations + var decl: VarDecl + for node in self.tree: + if node.token.line == self.peek(-1).line and node.kind == varDecl: + decl = VarDecl(node) + break + else: + var decl = self.currentFunction + # TODO + + +proc declaration(self: Parser): Declaration = + ## Parses declarations + case self.peek().kind: + of Var, Const, Let: + let keyword = self.step() + result = self.varDecl(isLet = keyword.kind == Let, + isConst = keyword.kind == Const) + of Function: + discard self.step() + result = self.funDecl() + of Coroutine: + discard self.step() + result = self.funDecl(isAsync = true) + of Generator: + discard self.step() + result = self.funDecl(isGenerator = true) + of Operator: + discard self.step() + result = self.funDecl(isOperator = true) + of TokenType.Comment: + let tok = self.step() + if tok.lexeme.startsWith("#pragma["): + result = self.parsePragma() + of Type, TokenType.Whitespace, TokenType.Tab: + discard self.step() # TODO + else: + result = Declaration(self.statement()) + + +proc parse*(self: Parser, tokens: seq[Token], file: string): seq[Declaration] = + ## Parses a sequence of tokens into a sequence of AST nodes + self.tokens = @[] + # The parser is not designed to handle these tokens. + # Maybe create a separate syntax checker module? + for token in tokens: + if token.kind notin {TokenType.Whitespace, Tab}: + self.tokens.add(token) + self.file = file + self.current = 0 + self.currentLoop = LoopContext.None + self.currentFunction = nil + self.scopeDepth = 0 + self.operators = newOperatorTable() + self.tree = @[] + for i, token in self.tokens: + # We do a first pass over the tokens + # to find operators. Note that this + # relies on the lexer ending the input + # with an EOF token + if token.kind == Operator: + if i == self.tokens.high(): + self.error("invalid state: found malformed tokenizer input while looking for operators (missing EOF)") + self.operators.addOperator(self.tokens[i + 1].lexeme) + if i == self.tokens.high() and token.kind != EndOfFile: + # Since we're iterating this list anyway might as + # well perform some extra checks + self.error("invalid state: found malformed tokenizer input while looking for operators (missing EOF)") + while not self.done(): + self.tree.add(self.declaration()) + if self.tree[^1] == nil: + self.tree.delete(self.tree.high()) + result = self.tree \ No newline at end of file diff --git a/src/main.nim b/src/main.nim new file mode 100644 index 0000000..dccc4c6 --- /dev/null +++ b/src/main.nim @@ -0,0 +1,359 @@ +# Builtins & external libs +import strformat +import strutils +import terminal +import os +# Thanks art <3 +import jale/editor as ed +import jale/templates +import jale/plugin/defaults +import jale/plugin/editor_history +import jale/keycodes +import jale/multiline + + +# Our stuff +import frontend/lexer as l +import frontend/parser as p +import frontend/compiler as c +import backend/vm as v +import util/serializer as s + +# Forward declarations +proc fillSymbolTable(tokenizer: Lexer) +proc getLineEditor: LineEditor + +# Handy dandy compile-time constants +const debugLexer = false +const debugParser = false +const debugCompiler = true +const debugSerializer = false +const debugRuntime = false + +when debugSerializer: + import nimSHA2 + import times + +when debugCompiler: + import util/debugger + + +proc repl = + styledEcho fgMagenta, "Welcome into the peon REPL!" + var + keep = true + tokens: seq[Token] = @[] + tree: seq[Declaration] = @[] + compiled: Chunk + serialized: Serialized + tokenizer = newLexer() + parser = newParser() + compiler = newCompiler() + serializer = newSerializer() + vm = newPeonVM() + editor = getLineEditor() + input: string + tokenizer.fillSymbolTable() + editor.bindEvent(jeQuit): + stdout.styledWriteLine(fgGreen, "Goodbye!") + editor.prompt = "" + keep = false + editor.bindKey("ctrl+a"): + editor.content.home() + editor.bindKey("ctrl+e"): + editor.content.`end`() + while keep: + try: + input = editor.read() + if input.len() == 0: + continue + tokens = tokenizer.lex(input, "stdin") + if tokens.len() == 0: + continue + when debugLexer: + styledEcho fgCyan, "Tokenization step:" + for i, token in tokens: + if i == tokens.high(): + # Who cares about EOF? + break + styledEcho fgGreen, "\t", $token + echo "" + tree = parser.parse(tokens, "stdin") + if tree.len() == 0: + continue + when debugParser: + styledEcho fgCyan, "Parsing step:" + for node in tree: + styledEcho fgGreen, "\t", $node + echo "" + compiled = compiler.compile(tree, "stdin") + when debugCompiler: + styledEcho fgCyan, "Compilation step:" + styledEcho fgCyan, "\tRaw byte stream: ", fgGreen, "[", fgYellow, compiled.code.join(", "), fgGreen, "]" + styledEcho fgCyan, "\tConstant table: ", fgGreen, "[", fgYellow, compiled.consts.join(", "), fgGreen, "]" + styledEcho fgCyan, "\nBytecode disassembler output below:\n" + disassembleChunk(compiled, "stdin") + echo "" + + serializer.dumpFile(compiled, input, "stdin", "stdin.pbc") + serialized = serializer.loadFile("stdin.pbc") + when debugSerializer: + var hashMatches = computeSHA256(input).toHex().toLowerAscii() == serialized.fileHash + styledEcho fgCyan, "Serialization step: " + styledEcho fgBlue, &"\t- File hash: ", fgYellow, serialized.fileHash, fgBlue, " (", if hashMatches: fgGreen else: fgRed, if hashMatches: "OK" else: "Fail", fgBlue, ")" + styledEcho fgBlue, "\t- Peon version: ", fgYellow, &"{serialized.peonVer.major}.{serialized.peonVer.minor}.{serialized.peonVer.patch}", fgBlue, " (commit ", fgYellow, serialized.commitHash[0..8], fgBlue, ") on branch ", fgYellow, serialized.peonBranch + stdout.styledWriteLine(fgBlue, "\t- Compilation date & time: ", fgYellow, fromUnix(serialized.compileDate).format("d/M/yyyy HH:mm:ss")) + stdout.styledWrite(fgBlue, &"\t- Constants segment: ") + if serialized.chunk.consts == compiled.consts: + styledEcho fgGreen, "OK" + else: + styledEcho fgRed, "Corrupted" + stdout.styledWrite(fgBlue, &"\t- Code segment: ") + if serialized.chunk.code == compiled.code: + styledEcho fgGreen, "OK" + else: + styledEcho fgRed, "Corrupted" + stdout.styledWrite(fgBlue, "\t- Line info segment: ") + if serialized.chunk.lines == compiled.lines: + styledEcho fgGreen, "OK" + else: + styledEcho fgRed, "Corrupted" + when debugRuntime: + styledEcho fgCyan, "\n\nExecution step: " + vm.run(serialized.chunk) + except LexingError: + let exc = LexingError(getCurrentException()) + let relPos = tokenizer.getRelPos(exc.line) + let line = tokenizer.getSource().splitLines()[exc.line - 1].strip() + stderr.styledWriteLine(fgRed, "A fatal error occurred while parsing ", fgYellow, &"'{exc.file}'", fgRed, ", module ", + fgYellow, &"'{exc.file.extractFilename()}'", fgRed, ", line ", fgYellow, $exc.line, fgRed, " at ", fgYellow, &"'{exc.lexeme}'", + fgRed, ": ", fgGreen , getCurrentExceptionMsg()) + styledEcho fgBlue, "Source line: " , fgDefault, line + styledEcho fgCyan, " ".repeat(len("Source line: ")) & "^".repeat(relPos.stop - relPos.start) + except ParseError: + let exc = ParseError(getCurrentException()) + let lexeme = exc.token.lexeme + let lineNo = exc.token.line + let relPos = tokenizer.getRelPos(lineNo) + let fn = parser.getCurrentFunction() + let line = tokenizer.getSource().splitLines()[lineNo - 1].strip() + var fnMsg = "" + if fn != nil and fn.kind == funDecl: + fnMsg &= &"in function '{FunDecl(fn).name.token.lexeme}'" + stderr.styledWriteLine(fgRed, "A fatal error occurred while parsing ", fgYellow, &"'{exc.file}'", fgRed, ", module ", + fgYellow, &"'{exc.file}'", fgRed, ", line ", fgYellow, $lineNo, fgRed, " at ", fgYellow, &"'{lexeme}'", + fgRed, ": ", fgGreen , getCurrentExceptionMsg()) + styledEcho fgBlue, "Source line: " , fgDefault, line + styledEcho fgCyan, " ".repeat(len("Source line: ")) & "^".repeat(relPos.stop - relPos.start) + except CompileError: + let exc = CompileError(getCurrentException()) + let lexeme = exc.node.token.lexeme + let lineNo = exc.node.token.line + let relPos = tokenizer.getRelPos(lineNo) + let line = tokenizer.getSource().splitLines()[lineNo - 1].strip() + var fn = compiler.getCurrentFunction() + var fnMsg = "" + if fn != nil and fn.kind == funDecl: + fnMsg &= &"in function '{FunDecl(fn).name.token.lexeme}'" + stderr.styledWriteLine(fgRed, "A fatal error occurred while compiling ", fgYellow, &"'{exc.file}'", fgRed, ", module ", + fgYellow, &"'{exc.module}'", fgRed, ", line ", fgYellow, $lineNo, fgRed, " at ", fgYellow, &"'{lexeme}'", + fgRed, ": ", fgGreen , getCurrentExceptionMsg()) + styledEcho fgBlue, "Source line: " , fgDefault, line + styledEcho fgCyan, " ".repeat(len("Source line: ")) & "^".repeat(relPos.stop - relPos.start) + except SerializationError: + let exc = SerializationError(getCurrentException()) + stderr.styledWriteLine(fgRed, "A fatal error occurred while (de-)serializing", fgYellow, &"'{exc.file}'", fgGreen, ": ", getCurrentExceptionMsg()) + quit(0) + + +proc runFile(f: string) = + var + tokens: seq[Token] = @[] + tree: seq[Declaration] = @[] + compiled: Chunk + serialized: Serialized + tokenizer = newLexer() + parser = newParser() + compiler = newCompiler() + serializer = newSerializer() + vm = newPeonVM() + input: string + tokenizer.fillSymbolTable() + try: + input = readFile(f) + tokens = tokenizer.lex(input, f) + if tokens.len() == 0: + return + when debugLexer: + styledEcho fgCyan, "Tokenization step:" + for i, token in tokens: + if i == tokens.high(): + # Who cares about EOF? + break + styledEcho fgGreen, "\t", $token + echo "" + tree = parser.parse(tokens, f) + if tree.len() == 0: + return + when debugParser: + styledEcho fgCyan, "Parsing step:" + for node in tree: + styledEcho fgGreen, "\t", $node + echo "" + compiled = compiler.compile(tree, f) + when debugCompiler: + styledEcho fgCyan, "Compilation step:" + styledEcho fgCyan, "\tRaw byte stream: ", fgGreen, "[", fgYellow, compiled.code.join(", "), fgGreen, "]" + styledEcho fgCyan, "\tConstant table: ", fgGreen, "[", fgYellow, compiled.consts.join(", "), fgGreen, "]" + styledEcho fgCyan, "\nBytecode disassembler output below:\n" + disassembleChunk(compiled, f) + echo "" + + serializer.dumpFile(compiled, input, f, splitFile(f).name & ".pbc") + serialized = serializer.loadFile(splitFile(f).name & ".pbc") + when debugSerializer: + var hashMatches = computeSHA256(input).toHex().toLowerAscii() == serialized.fileHash + styledEcho fgCyan, "Serialization step: " + styledEcho fgBlue, &"\t- File hash: ", fgYellow, serialized.fileHash, fgBlue, " (", if hashMatches: fgGreen else: fgRed, if hashMatches: "OK" else: "Fail", fgBlue, ")" + styledEcho fgBlue, "\t- Peon version: ", fgYellow, &"{serialized.peonVer.major}.{serialized.peonVer.minor}.{serialized.peonVer.patch}", fgBlue, " (commit ", fgYellow, serialized.commitHash[0..8], fgBlue, ") on branch ", fgYellow, serialized.peonBranch + stdout.styledWriteLine(fgBlue, "\t- Compilation date & time: ", fgYellow, fromUnix(serialized.compileDate).format("d/M/yyyy HH:mm:ss")) + stdout.styledWrite(fgBlue, &"\t- Constants segment: ") + if serialized.chunk.consts == compiled.consts: + styledEcho fgGreen, "OK" + else: + styledEcho fgRed, "Corrupted" + stdout.styledWrite(fgBlue, &"\t- Code segment: ") + if serialized.chunk.code == compiled.code: + styledEcho fgGreen, "OK" + else: + styledEcho fgRed, "Corrupted" + stdout.styledWrite(fgBlue, "\t- Line info segment: ") + if serialized.chunk.lines == compiled.lines: + styledEcho fgGreen, "OK" + else: + styledEcho fgRed, "Corrupted" + when debugRuntime: + styledEcho fgCyan, "\n\nExecution step: " + vm.run(serialized.chunk) + except LexingError: + let exc = LexingError(getCurrentException()) + let relPos = tokenizer.getRelPos(exc.line) + let line = tokenizer.getSource().splitLines()[exc.line - 1].strip() + stderr.styledWriteLine(fgRed, "A fatal error occurred while parsing ", fgYellow, &"'{exc.file}'", fgRed, ", module ", + fgYellow, &"'{exc.file}'", fgRed, ", line ", fgYellow, $exc.line, fgRed, " at ", fgYellow, &"'{exc.lexeme}'", + fgRed, ": ", fgGreen , getCurrentExceptionMsg()) + styledEcho fgBlue, "Source line: " , fgDefault, line + styledEcho fgCyan, " ".repeat(len("Source line: ")) & "^".repeat(relPos.stop - relPos.start) + except ParseError: + let exc = ParseError(getCurrentException()) + let lexeme = exc.token.lexeme + let lineNo = exc.token.line + let relPos = tokenizer.getRelPos(lineNo) + let fn = parser.getCurrentFunction() + let line = tokenizer.getSource().splitLines()[lineNo - 1].strip() + var fnMsg = "" + if fn != nil and fn.kind == funDecl: + fnMsg &= &"in function '{FunDecl(fn).name.token.lexeme}'" + stderr.styledWriteLine(fgRed, "A fatal error occurred while parsing ", fgYellow, &"'{exc.file}'", fgRed, ", module ", + fgYellow, &"'{exc.file}'", fgRed, ", line ", fgYellow, $lineNo, fgRed, " at ", fgYellow, &"'{lexeme}'", + fgRed, ": ", fgGreen , getCurrentExceptionMsg()) + styledEcho fgBlue, "Source line: " , fgDefault, line + styledEcho fgCyan, " ".repeat(len("Source line: ")) & "^".repeat(relPos.stop - relPos.start) + except CompileError: + let exc = CompileError(getCurrentException()) + let lexeme = exc.node.token.lexeme + let lineNo = exc.node.token.line + let relPos = tokenizer.getRelPos(lineNo) + let line = tokenizer.getSource().splitLines()[lineNo - 1].strip() + var fn = compiler.getCurrentFunction() + var fnMsg = "" + if fn != nil and fn.kind == funDecl: + fnMsg &= &"in function '{FunDecl(fn).name.token.lexeme}'" + stderr.styledWriteLine(fgRed, "A fatal error occurred while compiling ", fgYellow, &"'{exc.file}'", fgRed, ", module ", + fgYellow, &"'{exc.module}'", fgRed, ", line ", fgYellow, $lineNo, fgRed, " at ", fgYellow, &"'{lexeme}'", + fgRed, ": ", fgGreen , getCurrentExceptionMsg()) + styledEcho fgBlue, "Source line: " , fgDefault, line + styledEcho fgCyan, " ".repeat(len("Source line: ")) & "^".repeat(relPos.stop - relPos.start) + except SerializationError: + let exc = SerializationError(getCurrentException()) + stderr.styledWriteLine(fgRed, "A fatal error occurred while (de-)serializing", fgYellow, &"'{exc.file}'", fgGreen, ": ", getCurrentExceptionMsg()) + except IOError: + stderr.styledWriteLine(fgRed, "An error occurred while trying to read ", fgYellow, &"'{f}'", fgGreen, &": {getCurrentExceptionMsg()}") + except OSError: + stderr.styledWriteLine(fgRed, "An error occurred while trying to read ", fgYellow, &"'{f}'", fgGreen, &": {osErrorMsg(osLastError())} [errno {osLastError()}]") + + +when isMainModule: + setControlCHook(proc () {.noconv.} = quit(0)) + let args = commandLineParams() + if args.len() == 0: + repl() + else: + runFile(args[0]) + + +proc fillSymbolTable(tokenizer: Lexer) = + ## Initializes the Lexer's symbol + ## table with the builtin symbols + ## and keywords + + # 1-byte symbols + tokenizer.symbols.addSymbol("{", LeftBrace) + tokenizer.symbols.addSymbol("}", RightBrace) + tokenizer.symbols.addSymbol("(", LeftParen) + tokenizer.symbols.addSymbol(")", RightParen) + tokenizer.symbols.addSymbol("[", LeftBracket) + tokenizer.symbols.addSymbol("]", RightBracket) + tokenizer.symbols.addSymbol(".", Dot) + tokenizer.symbols.addSymbol(",", Comma) + tokenizer.symbols.addSymbol(";", Semicolon) + # Keywords + tokenizer.symbols.addKeyword("type", TokenType.Type) + tokenizer.symbols.addKeyword("enum", Enum) + tokenizer.symbols.addKeyword("case", Case) + tokenizer.symbols.addKeyword("operator", Operator) + tokenizer.symbols.addKeyword("generator", Generator) + tokenizer.symbols.addKeyword("fn", TokenType.Function) + tokenizer.symbols.addKeyword("coroutine", Coroutine) + tokenizer.symbols.addKeyword("break", TokenType.Break) + tokenizer.symbols.addKeyword("continue", Continue) + tokenizer.symbols.addKeyword("while", While) + tokenizer.symbols.addKeyword("for", For) + tokenizer.symbols.addKeyword("foreach", Foreach) + tokenizer.symbols.addKeyword("if", If) + tokenizer.symbols.addKeyword("else", Else) + tokenizer.symbols.addKeyword("await", TokenType.Await) + tokenizer.symbols.addKeyword("defer", Defer) + tokenizer.symbols.addKeyword("try", Try) + tokenizer.symbols.addKeyword("except", Except) + tokenizer.symbols.addKeyword("finally", Finally) + tokenizer.symbols.addKeyword("raise", TokenType.Raise) + tokenizer.symbols.addKeyword("assert", TokenType.Assert) + tokenizer.symbols.addKeyword("const", Const) + tokenizer.symbols.addKeyword("let", Let) + tokenizer.symbols.addKeyword("var", Var) + tokenizer.symbols.addKeyword("import", Import) + tokenizer.symbols.addKeyword("yield", TokenType.Yield) + tokenizer.symbols.addKeyword("return", TokenType.Return) + # These are more like expressions with a reserved + # name that produce a value of a builtin type, + # but we don't need to care about that until + # we're in the parsing/ compilation steps so + # it's fine + tokenizer.symbols.addKeyword("nan", NotANumber) + tokenizer.symbols.addKeyword("inf", Infinity) + tokenizer.symbols.addKeyword("nil", TokenType.Nil) + tokenizer.symbols.addKeyword("true", True) + tokenizer.symbols.addKeyword("false", False) + tokenizer.symbols.addKeyword("ref", Ref) + tokenizer.symbols.addKeyword("ptr", Ptr) + for sym in [">", "<", "=", "~", "/", "+", "-", "_", "*", "?", "@", ":"]: + tokenizer.symbols.addSymbol(sym, Symbol) + + +proc getLineEditor: LineEditor = + result = newLineEditor() + result.prompt = "=> " + result.populateDefaults() + let history = result.plugHistory() + result.bindHistory(history) diff --git a/src/memory/allocator.nim b/src/memory/allocator.nim new file mode 100644 index 0000000..b6d93e8 --- /dev/null +++ b/src/memory/allocator.nim @@ -0,0 +1,87 @@ +# Copyright 2022 Mattia Giambirtone +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +## Memory allocator from JAPL + + +import segfaults +import ../config + +when DEBUG_TRACE_ALLOCATION: + import strformat + + +proc reallocate*(p: pointer, oldSize: int, newSize: int): pointer = + ## Wrapper around realloc/dealloc + try: + if newSize == 0 and p != nil: + when DEBUG_TRACE_ALLOCATION: + if oldSize > 1: + echo &"DEBUG - Memory manager: Deallocating {oldSize} bytes" + else: + echo "DEBUG - Memory manager: Deallocating 1 byte" + dealloc(p) + return nil + when DEBUG_TRACE_ALLOCATION: + if pointr == nil and newSize == 0: + echo &"DEBUG - Memory manager: Warning, asked to dealloc() nil pointer from {oldSize} to {newSize} bytes, ignoring request" + if oldSize > 0 and p != nil or oldSize == 0: + when DEBUG_TRACE_ALLOCATION: + if oldSize == 0: + if newSize > 1: + echo &"DEBUG - Memory manager: Allocating {newSize} bytes of memory" + else: + echo "DEBUG - Memory manager: Allocating 1 byte of memory" + else: + echo &"DEBUG - Memory manager: Resizing {oldSize} bytes of memory to {newSize} bytes" + result = realloc(p, newSize) + when DEBUG_TRACE_ALLOCATION: + if oldSize > 0 and pointr == nil: + echo &"DEBUG - Memory manager: Warning, asked to realloc() nil pointer from {oldSize} to {newSize} bytes, ignoring request" + except NilAccessDefect: + stderr.write("JAPL: could not manage memory, segmentation fault\n") + quit(139) # For now, there's not much we can do if we can't get the memory we need, so we exit + + +template resizeArray*(kind: untyped, pointr: pointer, oldCount, + newCount: int): untyped = + ## Handy macro (in the C sense of macro, not nim's) to resize a dynamic array + cast[ptr UncheckedArray[kind]](reallocate(pointr, sizeof(kind) * oldCount, + sizeof(kind) * newCount)) + + +template freeArray*(kind: untyped, pointr: pointer, oldCount: int): untyped = + ## Frees a dynamic array + reallocate(pointr, sizeof(kind) * oldCount, 0) + + +template free*(kind: untyped, pointr: pointer): untyped = + ## Frees a pointer by reallocating its + ## size to 0 + reallocate(pointr, sizeof(kind), 0) + + +template growCapacity*(capacity: int): untyped = + ## Handy macro used to calculate how much + ## more memory is needed when reallocating + ## dynamic arrays + if capacity < 8: + 8 + else: + capacity * ARRAY_GROW_FACTOR + + +template allocate*(castTo: untyped, sizeTo: untyped, count: int): untyped = + ## Allocates an object and casts its pointer to the specified type + cast[ptr castTo](reallocate(nil, 0, sizeof(sizeTo) * count)) diff --git a/src/peon/stdlib/arithmetics.pn b/src/peon/stdlib/arithmetics.pn new file mode 100644 index 0000000..63768f1 --- /dev/null +++ b/src/peon/stdlib/arithmetics.pn @@ -0,0 +1,193 @@ +## Builtin arithmetic operators for Peon + + +operator `+`(a, b: int): int { + #pragma[magic: AddInt64, pure] + return; +} + + +operator `+`(a, b: uint): uint { + #pragma[magic: AddUInt64, pure] + return; +} + + +operator `+`(a, b: int32): int32 { + #pragma[magic: AddInt32, pure] + return; +} + + +operator `+`(a, b: uint32): uint32 { + #pragma[magic: AddUInt32, pure] + return; +} + + +operator `+`(a, b: int16): int16 { + #pragma[magic: AddInt16, pure] + return; +} + + +operator `+`(a, b: uint16): uint16 { + #pragma[magic: AddUInt16, pure] + return; +} + + +operator `+`(a, b: int8): int8 { + #pragma[magic: AddInt8, pure] + return; +} + + +operator `+`(a, b: uint8): uint8 { + #pragma[magic: AddUInt8, pure] + return; +} + + +operator `-`(a, b: int): int { + #pragma[magic: SubInt64, pure] + return; +} + + +operator `-`(a, b: uint): uint { + #pragma[magic: SubUInt64, pure] + return; +} + + +operator `-`(a, b: int32): int32 { + #pragma[magic: SubInt32, pure] + return; +} + + +operator `-`(a, b: uint32): uint32 { + #pragma[magic: SubUInt32, pure] + return; +} + + +operator `-`(a, b: int16): int16 { + #pragma[magic: SubInt16, pure] + return; +} + + +operator `-`(a, b: uint16): uint16 { + #pragma[magic: SubUInt16, pure] + return; +} + + +operator `-`(a, b: int8): int8 { + #pragma[magic: SubInt8, pure] + return; +} + + +operator `-`(a, b: uint8): uint8 { + #pragma[magic: SubUInt8, pure] + return; +} + + +operator `*`(a, b: int): int { + #pragma[magic: MulInt64, pure] + return; +} + + +operator `*`(a, b: uint): uint { + #pragma[magic: MulUInt64, pure] + return; +} + + +operator `*`(a, b: int32): int32 { + #pragma[magic: MulInt32, pure] + return; +} + + +operator `*`(a, b: uint32): uint32 { + #pragma[magic: MulUInt32, pure] + return; +} + + +operator `*`(a, b: int16): int16 { + #pragma[magic: MulInt16, pure] + return; +} + + +operator `*`(a, b: uint16): uint16 { + #pragma[magic: MulUInt16, pure] + return; +} + + +operator `*`(a, b: int8): int8 { + #pragma[magic: MulInt8, pure] + return; +} + + +operator `*`(a, b: uint8): uint8 { + #pragma[magic: MulUInt8, pure] + return; +} + + +operator `/`(a, b: int): int { + #pragma[magic: DivInt64, pure] + return; +} + + +operator `/`(a, b: uint): uint { + #pragma[magic: DivUInt64, pure] + return; +} + + +operator `/`(a, b: int32): int32 { + #pragma[magic: DivInt32, pure] + return; +} + + +operator `/`(a, b: uint32): uint32 { + #pragma[magic: DivUInt32, pure] + return; +} + + +operator `/`(a, b: int16): int16 { + #pragma[magic: DivInt16, pure] + return; +} + + +operator `/`(a, b: uint16): uint16 { + #pragma[magic: DivUInt16, pure] + return; +} + + +operator `/`(a, b: int8): int8 { + #pragma[magic: DivInt8, pure] + return; +} + + +operator `/`(a, b: uint8): uint8 { + #pragma[magic: DivUInt8, pure] + return; +} \ No newline at end of file diff --git a/src/tests.pn b/src/tests.pn new file mode 100644 index 0000000..0ea5253 --- /dev/null +++ b/src/tests.pn @@ -0,0 +1,5 @@ +operator `+`(a: int): int { + return a; +} + ++1; # Works: defined for int64 diff --git a/src/util/debugger.nim b/src/util/debugger.nim new file mode 100644 index 0000000..6119b53 --- /dev/null +++ b/src/util/debugger.nim @@ -0,0 +1,174 @@ +# Copyright 2022 Mattia Giambirtone & All Contributors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import ../frontend/meta/bytecode +import multibyte + + +import strformat +import strutils +import terminal + + +proc nl = stdout.write("\n") + + +proc printDebug(s: string, newline: bool = false) = + stdout.styledWrite(fgMagenta, "DEBUG - Disassembler -> ") + stdout.styledWrite(fgGreen, s) + if newline: + nl() + + +proc printName(opcode: OpCode, newline: bool = false) = + stdout.styledWrite(fgRed, $opcode, " (", fgYellow, $uint8(opcode), fgRed, ")") + if newline: + nl() + + +proc printInstruction(instruction: OpCode, newline: bool = false) = + printDebug("Instruction: ") + printName(instruction) + if newline: + nl() + + +proc simpleInstruction(instruction: OpCode, offset: int): int = + printInstruction(instruction) + nl() + return offset + 1 + + +proc stackTripleInstruction(instruction: OpCode, chunk: Chunk, + offset: int): int = + ## Debugs instructions that operate on a single value on the stack using a 24-bit operand + var slot = [chunk.code[offset + 1], chunk.code[offset + 2], chunk.code[ + offset + 3]].fromTriple() + printInstruction(instruction) + stdout.styledWrite(fgGreen, &", points to index ") + stdout.styledWriteLine(fgYellow, &"{slot}") + return offset + 4 + + +proc stackDoubleInstruction(instruction: OpCode, chunk: Chunk, + offset: int): int = + ## Debugs instructions that operate on a single value on the stack using a 16-bit operand + var slot = [chunk.code[offset + 1], chunk.code[offset + 2]].fromDouble() + printInstruction(instruction) + stdout.write(&", points to index ") + stdout.styledWrite(fgGreen, &", points to index ") + stdout.styledWriteLine(fgYellow, &"{slot}") + return offset + 3 + + +proc argumentDoubleInstruction(instruction: OpCode, chunk: Chunk, offset: int): int = + ## Debugs instructions that operate on a hardcoded value on the stack using a 16-bit operand + var slot = [chunk.code[offset + 1], chunk.code[offset + 2]].fromDouble() + printInstruction(instruction) + stdout.styledWrite(fgGreen, &", has argument ") + stdout.styledWriteLine(fgYellow, $slot) + return offset + 3 + + +proc argumentTripleInstruction(instruction: OpCode, chunk: Chunk, offset: int): int = + ## Debugs instructions that operate on a hardcoded value on the stack using a 24-bit operand + var slot = [chunk.code[offset + 1], chunk.code[offset + 2], chunk.code[offset + 3]].fromTriple() + printInstruction(instruction) + stdout.styledWrite(fgGreen, ", has argument ") + stdout.styledWriteLine(fgYellow, $slot) + return offset + 4 + + +proc callInstruction(instruction: OpCode, chunk: Chunk, offset: int): int = + ## Debugs function calls + var slot = [chunk.code[offset + 1], chunk.code[offset + 2], chunk.code[offset + 3]].fromTriple() + var args = [chunk.code[offset + 4], chunk.code[offset + 5], chunk.code[offset + 6]].fromTriple() + printInstruction(instruction) + stdout.styledWrite(fgGreen, &", jumps to address ", fgYellow, $slot, fgGreen, " with ", fgYellow, $args, fgGreen, " argument") + if args > 1: + stdout.styledWrite(fgYellow, "s") + nl() + return offset + 7 + + +proc constantInstruction(instruction: OpCode, chunk: Chunk, offset: int): int = + ## Debugs instructions that operate on the constant table + var constant = [chunk.code[offset + 1], chunk.code[offset + 2], chunk.code[ + offset + 3]].fromTriple() + printInstruction(instruction) + stdout.styledWrite(fgGreen, &", points to constant at position ", fgYellow, $constant) + nl() + printDebug("Operand: ") + stdout.styledWriteLine(fgYellow, &"{chunk.consts[constant]}") + return offset + 4 + + +proc jumpInstruction(instruction: OpCode, chunk: Chunk, offset: int): int = + ## Debugs jumps + var jump: int + case instruction: + of Jump, JumpIfFalse, JumpIfTrue, JumpIfFalsePop, JumpForwards, JumpBackwards: + jump = [chunk.code[offset + 1], chunk.code[offset + 2]].fromDouble().int() + of LongJump, LongJumpIfFalse, LongJumpIfTrue, LongJumpIfFalsePop, + LongJumpForwards, LongJumpBackwards: + jump = [chunk.code[offset + 1], chunk.code[offset + 2], chunk.code[ + offset + 3]].fromTriple().int() + else: + discard # Unreachable + printInstruction(instruction, true) + printDebug("Jump size: ") + stdout.styledWrite(fgYellow, $jump) + nl() + return offset + 3 + + +proc disassembleInstruction*(chunk: Chunk, offset: int): int = + ## Takes one bytecode instruction and prints it + printDebug("Offset: ") + stdout.styledWriteLine(fgYellow, $offset) + printDebug("Line: ") + stdout.styledWriteLine(fgYellow, &"{chunk.getLine(offset)}") + var opcode = OpCode(chunk.code[offset]) + case opcode: + of simpleInstructions: + result = simpleInstruction(opcode, offset) + of constantInstructions: + result = constantInstruction(opcode, chunk, offset) + of stackDoubleInstructions: + result = stackDoubleInstruction(opcode, chunk, offset) + of stackTripleInstructions: + result = stackTripleInstruction(opcode, chunk, offset) + of argumentDoubleInstructions: + result = argumentDoubleInstruction(opcode, chunk, offset) + of argumentTripleInstructions: + result = argumentTripleInstruction(opcode, chunk, offset) + of callInstructions: + result = callInstruction(opcode, chunk, offset) + of jumpInstructions: + result = jumpInstruction(opcode, chunk, offset) + else: + echo &"DEBUG - Unknown opcode {opcode} at index {offset}" + result = offset + 1 + + +proc disassembleChunk*(chunk: Chunk, name: string) = + ## Takes a chunk of bytecode, and prints it + echo &"==== Peon Bytecode Debugger - Chunk '{name}' ====\n" + var index = 0 + while index < chunk.code.len: + index = disassembleInstruction(chunk, index) + echo "" + echo &"==== Debug session ended - Chunk '{name}' ====" + + diff --git a/src/util/multibyte.nim b/src/util/multibyte.nim new file mode 100644 index 0000000..4244cf5 --- /dev/null +++ b/src/util/multibyte.nim @@ -0,0 +1,61 @@ +# Copyright 2022 Mattia Giambirtone & All Contributors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +## Utilities to convert from/to our 16-bit and 24-bit representations +## of numbers + + +proc toDouble*(input: int | uint | uint16): array[2, uint8] = + ## Converts an unsigned integer + ## to an array[2, uint8] + result = cast[array[2, uint8]](uint16(input)) + + +proc toTriple*(input: uint | int): array[3, uint8] = + ## Converts an unsigned integer to an array[3, uint8] + result = cast[array[3, uint8]](uint(input)) + + +proc toQuad*(input: int | uint | uint16 | uint32): array[4, uint8] = + ## Converts an unsigned integer to an array[4, uint8] + result = cast[array[4, uint8]](uint(input)) + + +proc toLong*(input: int | uint | uint16 | uint32 | uint64): array[8, uint8] = + ## Converts an unsigned integer to an array[8, uint8] + result = cast[array[8, uint8]](uint(input)) + + +proc fromDouble*(input: array[2, uint8]): uint16 = + ## Rebuilds the output of toDouble into + ## an uint16 + copyMem(result.addr, unsafeAddr(input), sizeof(uint16)) + + +proc fromTriple*(input: array[3, uint8]): uint = + ## Rebuilds the output of toTriple into + ## an uint + copyMem(result.addr, unsafeAddr(input), sizeof(uint8) * 3) + + +proc fromQuad*(input: array[4, uint8]): uint = + ## Rebuilts the output of toQuad into + ## an uint + copyMem(result.addr, unsafeAddr(input), sizeof(uint32)) + + +proc fromLong*(input: array[8, uint8]): uint = + ## Rebuilts the output of toQuad into + ## an uint + copyMem(result.addr, unsafeAddr(input), sizeof(uint64)) \ No newline at end of file diff --git a/src/util/serializer.nim b/src/util/serializer.nim new file mode 100644 index 0000000..b8cd10a --- /dev/null +++ b/src/util/serializer.nim @@ -0,0 +1,241 @@ +# Copyright 2022 Mattia Giambirtone & All Contributors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import ../frontend/meta/errors +import ../frontend/meta/bytecode +import ../config +import multibyte +import ../frontend/compiler + +import strformat +import strutils +import nimSHA2 +import times + + +export ast + +type + Serializer* = ref object + file: string + filename: string + chunk: Chunk + Serialized* = ref object + ## Wrapper returned by + ## the Serializer.read* + ## procedures to store + ## metadata + fileHash*: string + peonVer*: tuple[major, minor, patch: int] + peonBranch*: string + commitHash*: string + compileDate*: int + chunk*: Chunk + + +proc `$`*(self: Serialized): string = + result = &"Serialized(fileHash={self.fileHash}, version={self.peonVer.major}.{self.peonVer.minor}.{self.peonVer.patch}, branch={self.peonBranch}), commitHash={self.commitHash}, date={self.compileDate}, chunk={self.chunk[]}" + + +proc error(self: Serializer, message: string) = + ## Raises a formatted SerializationError exception + raise SerializationError(msg: message, file: self.filename) + + +proc newSerializer*(self: Serializer = nil): Serializer = + new(result) + if self != nil: + result = self + result.file = "" + result.filename = "" + result.chunk = nil + + +## Basic routines and helpers to convert various objects from and to to their byte representation + +proc toBytes(self: Serializer, s: string): seq[byte] = + for c in s: + result.add(byte(c)) + + +proc toBytes(self: Serializer, s: int): array[8, uint8] = + result = cast[array[8, uint8]](s) + + +proc toBytes(self: Serializer, d: SHA256Digest): seq[byte] = + for b in d: + result.add(b) + + +proc bytesToString(self: Serializer, input: seq[byte]): string = + for b in input: + result.add(char(b)) + + +proc extend[T](s: var seq[T], a: openarray[T]) = + ## Extends s with the elements of a + for e in a: + s.add(e) + + +proc writeHeaders(self: Serializer, stream: var seq[byte], file: string) = + ## Writes the Peon bytecode headers in-place into a byte stream + stream.extend(self.toBytes(BYTECODE_MARKER)) + stream.add(byte(PEON_VERSION.major)) + stream.add(byte(PEON_VERSION.minor)) + stream.add(byte(PEON_VERSION.patch)) + stream.add(byte(len(PEON_BRANCH))) + stream.extend(self.toBytes(PEON_BRANCH)) + stream.extend(self.toBytes(PEON_COMMIT_HASH)) + stream.extend(self.toBytes(getTime().toUnixFloat().int())) + stream.extend(self.toBytes(computeSHA256(file))) + + +proc writeLineData(self: Serializer, stream: var seq[byte]) = + ## Writes line information for debugging + ## bytecode instructions + stream.extend(len(self.chunk.lines).toQuad()) + for b in self.chunk.lines: + stream.extend(b.toTriple()) + + +proc writeConstants(self: Serializer, stream: var seq[byte]) = + ## Writes the constants table in-place into the + ## given stream + stream.extend(self.chunk.consts.len().toQuad()) + for constant in self.chunk.consts: + stream.add(constant) + + +proc writeCode(self: Serializer, stream: var seq[byte]) = + ## Writes the bytecode from the given chunk to the + ## given source stream + stream.extend(self.chunk.code.len.toTriple()) + stream.extend(self.chunk.code) + + +proc readHeaders(self: Serializer, stream: seq[byte], serialized: Serialized): int = + ## Reads the bytecode headers from a given stream + ## of bytes + var stream = stream + if stream[0..