move to a direct byte code compiler (#8)

* chore: refactor to keep only the new parser and bytecode vm

* scanner: remove Token.value field

* scanner: remove scanner.kind field

* chore: move language specification in lang package

This avoid a cyclic dependency in scanner_test which can now use
the golang/GoSpec language specification for Go.

* clean code

* scanner: export scanner fields

Also parser now generate function calls, including externals.

* chore: fix lint issues

* parser: handle strings

* wip

* parser: implement support for 'if, else, else if' statements

Resolving labels in the compiler still in progress.

* parser: support if statements, improve compiler

* improve handling of functions

* improve support of local variables

* scanner: trim leading and trailing spaces

* fixes to make fibonacci work

* parser: improve README, fix function parameters parsing

1 files changed, 0 insertions, 38 deletions

diff --git a/vm1/README.md b/vm1/README.md
deleted file mode 100644
index a06dd34..0000000
--- a/vm1/README.md
+++ /dev/null
@@ -1,38 +0,0 @@
-# vm1
-
-`vm1` is a bytecode based stack machine.
-
-The purpose of `vm1` is to provide a simple, fast, embeddable and
-portable Go execution environment.
-
-```mermaid
-graph LR
-s[ ] --> |source| a(scanner)
---> |tokens| b(parser)
---> |AST| c(codegen)
---> |bytecode| d[vm]
-subgraph vm1
-    d
-end
-style s height:0px;
-```
-
-The bytecode consists of a dozen of instructions, each taking 0 or 1
-immediate argument (non-immediate arguments are only passed through the
-stack). Only a few operators for a few types are implemented. I expect
-to have 1 instruction per operator per numerical type, all with the same
-pattern, which would be generated from a template. Estimate is around 20
-operators and 10 numerical types, so around 200 instructions in final.
-
-Structurally, the vm implements logical and arithmetic operators,
-condional jumps for `if`, `for` and `switch` control flow, and function
-call, return and frame management.
-
-the memory state of the vm is a slice of Go interfaces (`[]any`).
-
-The whole vm is coded in a single function of 80 lines with no
-dependencies. The size will grow as we add missing instructions, but the
-code complexity will remain the same.
-
-the vm1 package is totally standalone and could be used for any purpose
-outside of parscan and/or gno.