107 lines
3.4 KiB
Go
107 lines
3.4 KiB
Go
package generator
|
|
|
|
import "fmt"
|
|
import "errors"
|
|
import "git.tebibyte.media/sashakoshka/fspl/llvm"
|
|
import "git.tebibyte.media/sashakoshka/fspl/entity"
|
|
import "git.tebibyte.media/sashakoshka/fspl/analyzer"
|
|
|
|
func (this *generator) generateLiteralInt (literal *entity.LiteralInt) (llvm.Value, error) {
|
|
irType, err := this.generateType(analyzer.ReduceToBase(literal.Type()))
|
|
if err != nil { return nil, err }
|
|
return llvm.NewConstInt(irType.(*llvm.TypeInt), int64(literal.Value)), nil
|
|
}
|
|
|
|
func (this *generator) generateLiteralFloat (literal *entity.LiteralFloat) (llvm.Value, error) {
|
|
irType, err := this.generateType(analyzer.ReduceToBase(literal.Type()))
|
|
if err != nil { return nil, err }
|
|
return llvm.NewConstFloat(irType.(*llvm.TypeFloat), literal.Value), nil
|
|
}
|
|
|
|
func (this *generator) generateLiteralArrayLoc (literal *entity.LiteralArray) (llvm.Value, error) {
|
|
ty := analyzer.ReduceToBase(literal.Type())
|
|
|
|
makeData := func (elementType entity.Type) (llvm.Value, error) {
|
|
irArrayType, err := this.generateType(&entity.TypeArray {
|
|
Element: elementType,
|
|
Length: len(literal.Elements),
|
|
})
|
|
if err != nil { return nil, err }
|
|
array := this.blockManager.newAllocaFront(irArrayType)
|
|
for index, element := range literal.Elements {
|
|
irElement, err := this.generateAssignmentSource (
|
|
element,
|
|
elementType)
|
|
if err != nil { return nil, err }
|
|
elementPointer := this.blockManager.NewGetElementPtr (
|
|
irArrayType, array,
|
|
llvm.NewConstInt(llvm.I32, 0),
|
|
llvm.NewConstInt(llvm.I32, int64(index)))
|
|
this.blockManager.NewStore(irElement, elementPointer)
|
|
}
|
|
return array, nil
|
|
}
|
|
|
|
switch ty := ty.(type) {
|
|
case *entity.TypeArray:
|
|
return makeData(ty.Element)
|
|
|
|
case *entity.TypeSlice:
|
|
array, err := makeData(ty.Element)
|
|
if err != nil { return nil, err }
|
|
irType, err := this.generateTypeSlice(ty)
|
|
if err != nil { return nil, err }
|
|
slice := this.blockManager.newAllocaFront(irType)
|
|
data := this.blockManager.NewGetElementPtr (
|
|
irType, slice,
|
|
llvm.NewConstInt(llvm.I32, 0),
|
|
llvm.NewConstInt(llvm.I32, 0))
|
|
this.blockManager.NewStore(array, data)
|
|
length := this.blockManager.NewGetElementPtr (
|
|
irType, slice,
|
|
llvm.NewConstInt(llvm.I32, 0),
|
|
llvm.NewConstInt(llvm.I32, 1))
|
|
sizeType, err := this.typedef("Size")
|
|
if err != nil { return nil, err }
|
|
this.blockManager.NewStore (
|
|
llvm.NewConstInt (
|
|
sizeType.(*llvm.TypeInt),
|
|
int64(len(literal.Elements))),
|
|
length)
|
|
return slice, nil
|
|
|
|
case *entity.TypePointer:
|
|
array, err := makeData(ty.Referenced)
|
|
if err != nil { return nil, err }
|
|
return this.valueToLocation(array), nil
|
|
|
|
default:
|
|
return nil, errors.New(fmt.Sprintln("array can't be used as ", ty))
|
|
}
|
|
}
|
|
|
|
func (this *generator) generateLiteralStructLoc (literal *entity.LiteralStruct) (llvm.Value, error) {
|
|
ty := analyzer.ReduceToBase(literal.Type())
|
|
irType, err := this.generateType(ty)
|
|
if err != nil { return nil, err }
|
|
|
|
structure := this.blockManager.newAllocaFront(irType)
|
|
|
|
for index, member := range literal.Members {
|
|
irMember, err := this.generateExpression(member.Value)
|
|
if err != nil { return nil, err }
|
|
|
|
elementPointer := this.blockManager.NewGetElementPtr (
|
|
irType, structure,
|
|
llvm.NewConstInt(llvm.I32, 0),
|
|
llvm.NewConstInt(llvm.I32, int64(index)))
|
|
this.blockManager.NewStore(irMember, elementPointer)
|
|
}
|
|
|
|
return structure, nil
|
|
}
|
|
|
|
func (this *generator) generateLiteralBoolean (literal *entity.LiteralBoolean) (llvm.Value, error) {
|
|
return llvm.NewConstBool(bool(*literal.Value)), nil
|
|
}
|