hrszpuk / remeta Goto Github PK

When we register an new typo symbol the generate need to keep track in case a function/method uses a Container type symbol (other we keep generating global data type lookups?)

The compunit.GlobalDataTypeRegister["Vector3"] need to be replaced with a reference to the type symbol &Vector3TypoSymbol in this case.

// example from Vector3
func Vector3Add(v1, v2 Vector3) Vector3 {
	return Vector3{
		x: v1.x + v2.x,
		y: v1.y + v2.y,
		z: v1.z + v2.z,
	}
}

v1 and v2 are of the same type and they are parsed differently from the Go compiler than if the parameters were written like v1 Vector3, v2 Vector3.

This causes the function to generate like so:

func Vector3Add(args []any) any {
        v1 := args[0].(Vector3)
        return Vector3Add(v1)
}

v2 isn't found.

Constructing containers from the field list.
This needs to generate both the method registration and the method's implementation (should be able to modify the GenerateFunctionImplementation to allow methods too).

Currently function and method implementations are generated using the pure names from the source. This is bad because conflict can happen. To avoid this... All functions should be appended with "Func" and all methods will be appended with "Meth".
This also means function reigstration needs to use the postfix names (not the original source code ones).

Check for structures and convert them to Containers (no methods for now).

So we need to check if the instance is nil, cast the instance, and a field look ups.

from the hot dog example.go:

func Hotdog_Constructor(instance any, args []any) any {
	if instance == nil { // instance checking
		return nil
	}

	con := instance.(*evalobjects.ContainerInstance) // type assertion
	con.Fields["name"] = args[0].(string) // field look up (+ assignment)

	return nil
}

Scan the Go file for imports and include them all in an import declaration.

All of the registration needs to be done in the Load[PackageName] function.

How to use Remeta? Git clone into go_packages, run the tool, add the load function to load.go:Load(). (expanded ofc)

Can't believe I forgot about this but each module needs to import the following:

import (
	"bytespace.network/rerect/compunit"
	"bytespace.network/rerect/eval_objects"
	"bytespace.network/rerect/symbols"
)

These are required for the generated functions to work in go_packages

Y'know... The actual functions that the interpreter will run. The functions pointers?

The primary way of installation will just be building + adding to PATH.
On Linux/MacOS adding to PATH can be done automatically, on Window it will have to be manual.

Get package declarations generating.
This means the pcakge go_package at the top of the file.