Updates for v1.2.0 and v1.0.1:

 Velvet v1.2.0
  * Added the new flag 'showvars' that dumps the variable each cycle/instruction
  * Added the 'allocInitList' function

 Velvc v1.0.1
  * Reached 1.0.0, as Velvc is now in a usable state
  * Fixed the offset added to label positions so it aligns with the Info sections current size

Author: voidwyrm-2

.gitignore

@@ -10,3 +10,5 @@ bin/
 obj/
 .zig-cache
 .zig-out
+
+*.cvelv

instructions.md

@@ -6,6 +6,9 @@
 1. ret
 2. halt (int8)
 3. call (fn)
+    **Flags**<br>
+    default: Treats the instruction arguments as an address and length for the name of a function
+    1. Ignores the instruction arguments and instead pops off a function from the stack and runs it
 4. push (literal)
 
     **Flags**<br>
@@ -18,7 +21,7 @@
 6. dup
 7. swap
 8. rot
-9. set (int8)
+9. set (int16)
 
     **Flags**<br>
     default: Instruction sets the variable of the given index to the stack item
@@ -27,10 +30,10 @@
 
     **Flags**<br>
     default: Instruction acts like an unconditional jump
-    1. Instruction acts only jumps if the stack item is `true`
-    2. Instruction acts only jumps if the stack item is `false`
-    3. Instruction acts only jumps if the error flag is true (a previous function call errored out)
-    4. Instruction acts only jumps if the error flag is false (a previous function call did not error out)
+    1. Instruction only jumps if the stack item is `true`
+    2. Instruction only jumps if the stack item is `false`
+    3. Instruction only jumps if the error flag is true (a previous function call errored out)
+    4. Instruction only jumps if the error flag is false (a previous function call did not error out)
 
 # Function Instructions
 
@@ -51,7 +54,7 @@ These instructions don't actually exist, but are converted into function calls d
 * `div` -> `y, x = pop(), pop(); push(x / y)`
 * `pow` -> `y, x = pop(), pop(); push(pow(x, y))`
 * `log` -> `y, x = pop(), pop(); push(log(x, y))`
-* `log` -> `x = pop(); push(x!)`
+* `neg` -> `x = pop(); push(x!)`
 * `and` -> `y, x = pop(), pop(); push(x & y)`
 * `or` -> `y, x = pop(), pop(); push(x | y)`
 * `xor` -> `y, x = pop(), pop(); push(x ^ y)`

velvc/generation/emitter/emitter.go

@@ -209,10 +209,15 @@ func (va *VelvetAsm) CreateLabel(name string) {
 	if _, ok := va.labels[name]; ok {
 		panic(fmt.Sprintf("label '%s' already exists", name))
 	}
-	va.labels[name] = uint32(20 + len(va.instructions)*7)
+	va.labels[name] = uint32(32 + len(va.instructions)*7)
 }
 
-func (va *VelvetAsm) GetLabel(name string) uint32 {
+func (va VelvetAsm) HasLabel(name string) bool {
+	_, ok := va.labels[name]
+	return ok
+}
+
+func (va VelvetAsm) GetLabel(name string) uint32 {
 	if addr, ok := va.labels[name]; !ok {
 		panic(fmt.Sprintf("label '%s' does not exist", name))
 	} else {
@@ -258,6 +263,17 @@ func (va *VelvetAsm) Halt(code int8) {
 	va.Emit(Halt, 0, uint16(code), 0)
 }
 
+func (va *VelvetAsm) DoDirective(name string, args ...any) {
+	switch name {
+	case "vars":
+		va.vars = uint16(args[0].(int))
+	case "entry":
+		va.SetEntry(uint32(args[0].(int)))
+	default:
+		panic("unknown directive '" + name + "'")
+	}
+}
+
 func (va *VelvetAsm) SetEntry(entryOffset uint32) {
 	va.programEntry = entryOffset
 }

velvc/generation/generation.go

@@ -0,0 +1,11 @@
+package generation
+
+import (
+	"github.com/voidwyrm-2/velvet-vm/velvc/generation/emitter"
+	"github.com/voidwyrm-2/velvet-vm/velvc/parser/nodes"
+)
+
+type Generator struct {
+	nodes []nodes.Node
+	ve    emitter.VelvetAsm
+}

velvc/lexer/tokens/tokens.go

@@ -1,6 +1,10 @@
 package tokens
 
-import "fmt"
+import (
+	"errors"
+	"fmt"
+	"strconv"
+)
 
 type TokenType uint8
 
@@ -42,6 +46,13 @@ func New(kind TokenType, lit string, start, ln int) Token {
 	return Token{kind: kind, lit: lit, start: start, ln: ln}
 }
 
+func NewLit(kind TokenType, lit string) Token {
+	t := Empty()
+	t.kind = kind
+	t.lit = lit
+	return t
+}
+
 func Empty() Token {
 	return New(None, "", -1, -1)
 }
@@ -50,6 +61,10 @@ func (t Token) GetKind() TokenType {
 	return t.kind
 }
 
+func (t Token) GetLit() string {
+	return t.lit
+}
+
 func (t Token) GetLn() int {
 	return t.ln
 }
@@ -62,6 +77,22 @@ func (t Token) IsLit(lit string) bool {
 	return t.lit == lit
 }
 
+func (t Token) Convert() (any, error) {
+	switch t.kind {
+	case Number, Address:
+		return strconv.Atoi(t.lit)
+	case String:
+		return t.lit, nil
+	case Bool:
+		return t.lit == "true", nil
+	}
+	panic("invalid kind: " + t.Str())
+}
+
 func (t Token) Str() string {
 	return fmt.Sprintf("{%s, '%s', %d, %d}", t.kind.Str(), t.lit, t.start, t.ln)
 }
+
+func (t Token) Err(format string, a ...any) error {
+	return errors.New(fmt.Sprintf("error on line %d, col %d: ", t.ln, t.start) + fmt.Sprintf(format, a...))
+}

velvc/main.go

@@ -7,7 +7,9 @@ import (
 	"os"
 	"strings"
 
+	"github.com/voidwyrm-2/velvet-vm/velvc/generation/emitter"
 	"github.com/voidwyrm-2/velvet-vm/velvc/lexer"
+	"github.com/voidwyrm-2/velvet-vm/velvc/parser"
 	"github.com/voidwyrm-2/velvet-vm/velvc/sectioner"
 )
 
@@ -23,8 +25,11 @@ func readFile(fileName string) (string, error) {
 }
 
 func main() {
-	showTokens := flag.Bool("tokens", false, "Print the generated tokens")
+	showTokens := flag.Bool("tokens", false, "Print the generated lexer tokens")
 	showSectioned := flag.Bool("sectioned", false, "Print the sectioned tokens")
+	showNodes := flag.Bool("nodes", false, "Print the generated parser nodes")
+
+	output := flag.String("o", "out", "The name of the output file")
 
 	flag.Parse()
 
@@ -64,4 +69,30 @@ func main() {
 		}
 		fmt.Println(strings.Join(formatted, "\n"))
 	}
+
+	parser := parser.New(sectionedTokens)
+
+	nodes, err := parser.Parse()
+	if err != nil {
+		fmt.Println(err.Error())
+		os.Exit(1)
+	} else if *showNodes {
+		for _, n := range nodes {
+			fmt.Println(n.Str())
+		}
+	}
+
+	ve := emitter.New(0)
+
+	for _, n := range nodes {
+		if err := n.Generate(&ve); err != nil {
+			fmt.Println(err.Error())
+			os.Exit(1)
+		}
+	}
+
+	if err := ve.Write(*output + ".cvelv"); err != nil {
+		fmt.Println(err.Error())
+		os.Exit(1)
+	}
 }

velvc/parser/nodes/directive/directive.go

@@ -0,0 +1,44 @@
+package directive
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/voidwyrm-2/velvet-vm/velvc/generation/emitter"
+	"github.com/voidwyrm-2/velvet-vm/velvc/lexer/tokens"
+)
+
+type DirectiveNode struct {
+	name tokens.Token
+	args []tokens.Token
+}
+
+func New(name tokens.Token, args []tokens.Token) DirectiveNode {
+	return DirectiveNode{name: name, args: args}
+}
+
+func (dn DirectiveNode) Generate(ve *emitter.VelvetAsm) error {
+	a := []any{}
+	for _, arg := range dn.args {
+		if v, err := arg.Convert(); err != nil {
+			return err
+		} else if ok := ve.HasLabel(arg.GetLit()); arg.IsKind(tokens.Ident) {
+			if !ok {
+				return arg.Err("label '%s' does not exist", arg.GetLit())
+			}
+			a = append(a, int(ve.GetLabel(arg.GetLit())))
+		} else {
+			a = append(a, v)
+		}
+	}
+	ve.DoDirective(dn.name.GetLit(), a...)
+	return nil
+}
+
+func (dn DirectiveNode) Str() string {
+	formatted := []string{}
+	for _, t := range dn.args {
+		formatted = append(formatted, t.Str())
+	}
+	return fmt.Sprintf("{ins: %s, args: %s}", dn.name.Str(), strings.Join(formatted, ", "))
+}

velvc/parser/nodes/halt/halt.go

@@ -0,0 +1,30 @@
+package halt
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/voidwyrm-2/velvet-vm/velvc/generation/emitter"
+	"github.com/voidwyrm-2/velvet-vm/velvc/lexer/tokens"
+)
+
+func assert[T any](v T, _ error) T {
+	return v
+}
+
+type HaltNode struct {
+	instruction, exitCode tokens.Token
+}
+
+func New(instruction, exitCode tokens.Token) HaltNode {
+	return HaltNode{instruction: instruction, exitCode: exitCode}
+}
+
+func (hn HaltNode) Generate(ve *emitter.VelvetAsm) error {
+	ve.EmitNF32(emitter.Halt, uint32(assert(strconv.Atoi(hn.exitCode.GetLit()))))
+	return nil
+}
+
+func (hn HaltNode) Str() string {
+	return fmt.Sprintf("{ins: %s, exitCode: %s}", hn.instruction.Str(), hn.exitCode.Str())
+}

velvc/parser/nodes/jump/jump.go

@@ -0,0 +1,25 @@
+package jump
+
+import (
+	"fmt"
+
+	"github.com/voidwyrm-2/velvet-vm/velvc/generation/emitter"
+	"github.com/voidwyrm-2/velvet-vm/velvc/lexer/tokens"
+)
+
+type JumpNode struct {
+	instruction, label tokens.Token
+}
+
+func New(instruction, label tokens.Token) JumpNode {
+	return JumpNode{instruction: instruction, label: label}
+}
+
+func (jn JumpNode) Generate(ve *emitter.VelvetAsm) error {
+	ve.Emit32(emitter.Jump, map[string]uint8{"j": 0, "jt": 1, "jf": 2, "je": 3, "jne": 4}[jn.instruction.GetLit()], ve.GetLabel(jn.label.GetLit()))
+	return nil
+}
+
+func (jn JumpNode) Str() string {
+	return fmt.Sprintf("{ins: %s, label: %s}", jn.instruction.Str(), jn.label.Str())
+}

velvc/parser/nodes/label/label.go

@@ -0,0 +1,25 @@
+package label
+
+import (
+	"fmt"
+
+	"github.com/voidwyrm-2/velvet-vm/velvc/generation/emitter"
+	"github.com/voidwyrm-2/velvet-vm/velvc/lexer/tokens"
+)
+
+type LabelNode struct {
+	name tokens.Token
+}
+
+func New(name tokens.Token) LabelNode {
+	return LabelNode{name: name}
+}
+
+func (ln LabelNode) Generate(ve *emitter.VelvetAsm) error {
+	ve.CreateLabel(ln.name.GetLit())
+	return nil
+}
+
+func (ln LabelNode) Str() string {
+	return fmt.Sprintf("{name: %s}", ln.name.Str())
+}