elysium/types.go

package main

import (
	"errors"
	"slices"
	"strconv"
)

type Lang_I8 int8
type Lang_I16 int16
type Lang_I32 int32
type Lang_I64 int64

type Lang_U8 uint8
type Lang_U16 uint16
type Lang_U32 uint32
type Lang_U64 uint64

type Lang_Bool bool

var PRIMITIVE_TYPE_NAMES = []string{"i8", "i16", "i32", "i64", "u8", "u16", "u32", "u64", "f32", "f64", "bool"}

type PrimitiveType uint32

const (
	Primitive_I8 PrimitiveType = iota
	Primitive_I16
	Primitive_I32
	Primitive_I64
	Primitive_U8
	Primitive_U16
	Primitive_U32
	Primitive_U64
	Primitive_F32
	Primitive_F64
	Primitive_Bool
)

const STRING_TYPE_NAME = "string"

var STRING_TYPE = Type{Type: Type_Named, Value: STRING_TYPE_NAME}

const InvalidValue = 0xEEEEEE // Magic value

type CompilerError struct {
	Position uint64
	Message  string
}

func (e CompilerError) Error() string {
	return e.Message + " (at " + strconv.FormatUint(e.Position, 10) + ")"
}

func isSignedInt(primitiveType PrimitiveType) bool {
	switch primitiveType {
	case Primitive_I8, Primitive_I16, Primitive_I32, Primitive_I64:
		return true
	default:
		return false
	}
}

func isUnsignedInt(primitiveType PrimitiveType) bool {
	switch primitiveType {
	case Primitive_U8, Primitive_U16, Primitive_U32, Primitive_U64:
		return true
	default:
		return false
	}
}

func isFloatingPoint(primitiveType PrimitiveType) bool {
	switch primitiveType {
	case Primitive_F32, Primitive_F64:
		return true
	default:
		return false
	}
}

func getBits(primitiveType PrimitiveType) int {
	switch primitiveType {
	case Primitive_I8, Primitive_U8:
		return 8
	case Primitive_I16, Primitive_U16:
		return 16
	case Primitive_I32, Primitive_U32, Primitive_F32:
		return 32
	case Primitive_I64, Primitive_U64, Primitive_F64:
		return 64
	default:
		panic("Passed an invalid type (" + strconv.FormatUint(uint64(primitiveType), 10) + ") to getBits()")
	}
}

func getPrimitiveTypeByName(name string) (PrimitiveType, error) {
	idx := slices.Index(PRIMITIVE_TYPE_NAMES, name)
	if idx == -1 {
		return InvalidValue, errors.New("not a primitive type name")
	}

	return PrimitiveType(idx), nil
}

func isAssigmentOperator(operator Operator) bool {
	switch operator {
	case Operator_Equals, Operator_PlusEquals, Operator_MinusEquals, Operator_MultiplyEquals, Operator_DivideEquals, Operator_ModuloEquals:
		return true
	default:
		return false
	}
}

func getArithmeticOperation(operator Operator) ArithmeticOperation {
	switch operator {
	case Operator_Greater:
		return Arithmetic_Greater
	case Operator_Less:
		return Arithmetic_Less
	case Operator_Not:
		return Arithmetic_LogicalNot
	case Operator_Plus, Operator_PlusEquals:
		return Arithmetic_Add
	case Operator_Minus, Operator_MinusEquals:
		return Arithmetic_Sub
	case Operator_Multiply, Operator_MultiplyEquals:
		return Arithmetic_Mul
	case Operator_Divide, Operator_DivideEquals:
		return Arithmetic_Div
	case Operator_Modulo, Operator_ModuloEquals:
		return Arithmetic_Mod
	case Operator_EqualsEquals:
		return Arithmetic_Equals
	case Operator_GreaterEquals:
		return Arithmetic_GreaterEquals
	case Operator_LessEquals:
		return Arithmetic_LessEquals
	case Operator_NotEquals:
		return Arithmetic_NotEquals
	default:
		return InvalidValue
	}
}