fspl/fspl
fspl
/
fspl
1
0
Fork 0
Code Issues 16 Pull Requests Packages Projects 1 Releases 6 Wiki Activity

Generator no longer generates constants because I assumed untrue things

This commit is contained in:
Sasha Koshka 2024-04-21 11:01:07 -04:00
parent f05efb749d
commit f4480fe6b1
7 changed files with 97 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
generator/constant-multiplex.go Normal file
View File

@ -0,0 +1,28 @@
package generator
import "fmt"
import "git.tebibyte.media/fspl/fspl/llvm"
import "git.tebibyte.media/fspl/fspl/entity"
func (this *generator) generateConstant (constant entity.Expression) (llvm.Const, error) {
switch constant := constant.(type) {
case *entity.LiteralInt:
return this.generateConstantInt(constant)
case *entity.LiteralFloat:
return this.generateConstantFloat(constant)
case *entity.LiteralString:
return this.generateConstantString(constant)
case *entity.LiteralArray:
return this.generateConstantArray(constant)
case *entity.LiteralStruct:
return this.generateConstantStruct(constant)
case *entity.LiteralBoolean:
return this.generateConstantBoolean(constant)
case *entity.LiteralNil:
return this.generateConstantNil(constant)
default:
panic(fmt.Sprintf (
"BUG: generator doesnt know about constant %v, ty: %T",
constant, constant))
}
}

50
generator/constant.go Normal file
View File

@ -0,0 +1,50 @@
package generator
import "fmt"
import "errors"
import "git.tebibyte.media/fspl/fspl/llvm"
import "git.tebibyte.media/fspl/fspl/entity"
import "git.tebibyte.media/fspl/fspl/analyzer"
func (this *generator) generateConstantInt (literal *entity.LiteralInt) (llvm.Const, error) {
irType, err := this.generateType(analyzer.ReduceToBase(literal.Type()))
if err != nil { return nil, err }
base := analyzer.ReduceToBase(literal.Type())
switch base.(type) {
case *entity.TypeInt, *entity.TypeWord:
return llvm.NewConstInt(irType.(*llvm.TypeInt), int64(literal.Value)), nil
case *entity.TypeFloat:
return llvm.NewConstFloat(irType.(*llvm.TypeFloat), float64(literal.Value)), nil
default:
return nil, errors.New(fmt.Sprintln("int can't be used as", base))
}
}
func (this *generator) generateConstantFloat (literal *entity.LiteralFloat) (llvm.Const, 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) generateConstantString (literal *entity.LiteralString) (llvm.Const, error) {
}
func (this *generator) generateConstantArray (literal *entity.LiteralArray) (llvm.Const, error) {
}
func (this *generator) generateConstantStruct (literal *entity.LiteralStruct) (llvm.Const, error) {
}
func (this *generator) generateConstantBoolean (literal *entity.LiteralBoolean) (llvm.Const, error) {
return llvm.NewConstBool(bool(literal.Value)), nil
}
func (this *generator) generateConstantNil (literal *entity.LiteralNil) (llvm.Const, error) {
ty, err := this.generateType(literal.Type())
if err != nil { return nil, err }
return llvm.NewConstZeroInitializer(ty), nil
}

14
generator/expression-multiplex.go
View File

@ -67,7 +67,8 @@ func (this *generator) generateExpressionAny (expression entity.Expression) (reg
*entity.LiteralString,
*entity.LiteralStruct,
*entity.Variable,
*entity.Declaration:
*entity.Declaration,
*entity.Constant:
pointer, err := this.generateExpressionLoc(expression)
return pointer, true, err
@ -101,8 +102,6 @@ func (this *generator) generateExpressionAny (expression entity.Expression) (reg
return this.generateLoop(expression, resultModeAny)
case *entity.For:
return this.generateFor(expression, resultModeAny)
case *entity.Constant:
return this.generateConstant(expression, resultModeAny)
// we get nothing from these
case *entity.Assignment:
@ -134,7 +133,8 @@ func (this *generator) generateExpressionVal (expression entity.Expression) (llv
*entity.LiteralString,
*entity.LiteralStruct,
*entity.Variable,
*entity.Declaration:
*entity.Declaration,
*entity.Constant:
pointer, err := this.generateExpressionLoc(expression)
if err != nil { return nil, err }
@ -173,9 +173,6 @@ func (this *generator) generateExpressionVal (expression entity.Expression) (llv
case *entity.For:
val, _, err := this.generateFor(expression, resultModeVal)
return val, err
case *entity.Constant:
val, _, err := this.generateConstant(expression, resultModeVal)
return val, err
case *entity.LiteralInt:
return this.generateLiteralInt(expression)
case *entity.LiteralFloat:
@ -255,8 +252,7 @@ func (this *generator) generateExpressionLoc (expression entity.Expression) (llv
loc, _, err := this.generateFor(expression, resultModeLoc)
return loc, err
case *entity.Constant:
loc, _, err := this.generateConstant(expression, resultModeLoc)
return loc, err
return this.generateConstantLoc(expression)
case *entity.LiteralArray:
return this.generateLiteralArrayLoc(expression, nil)
case *entity.LiteralString:

7
generator/expression.go
View File

@ -429,10 +429,3 @@ func (this *generator) generateFor (loop *entity.For, mode resultMode) (llvm.Val
}
return irValue, loopEntry.loc, nil
}
func (this *generator) generateConstant (constant *entity.Constant, mode resultMode) (llvm.Value, bool, error) {
// TODO for strings arrays and structs, make constant data in the
// module.
value := constant.Declaration.Value
return this.generateExpression(value, mode)
}

12
generator/generator.go
View File

@ -32,6 +32,8 @@ type generator struct {
types map[entity.Key] llvm.Type
functions map[entity.Key] *llvm.Function
constantsVal map[entity.Key] llvm.Value
constantsLoc map[entity.Key] llvm.Value
managerStack []*blockManager
blockManager *blockManager
@ -45,12 +47,16 @@ func (this Target) Generate (tree analyzer.Tree) (*llvm.Module, error) {
module: new(llvm.Module),
target: this,
tree: tree,
types: make(map[entity.Key] llvm.Type),
functions: make(map[entity.Key] *llvm.Function),
types: make(map[entity.Key] llvm.Type),
functions: make(map[entity.Key] *llvm.Function),
constantsVal: make(map[entity.Key] llvm.Value),
constantsLoc: make(map[entity.Key] llvm.Value),
}).generate()
}
func (this *generator) generate () (*llvm.Module, error) {
// TODO: generate constants here
// generate functions
functions := sortKeyedMapKeys(this.tree.Functions)
for _, key := range functions {
@ -98,7 +104,7 @@ func (this *generator) method (key entity.Key) (*llvm.Function, error) {
return this.generateMethod(method)
}
return nil, errNotFound("method " + key.String())
}
}
func (this *generator) function (key entity.Key) (*llvm.Function, error) {
function, exists := this.functions[key]

23
generator/literal.go
View File

@ -7,24 +7,11 @@ import "git.tebibyte.media/fspl/fspl/entity"
import "git.tebibyte.media/fspl/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 }
base := analyzer.ReduceToBase(literal.Type())
switch base.(type) {
case *entity.TypeInt, *entity.TypeWord:
return llvm.NewConstInt(irType.(*llvm.TypeInt), int64(literal.Value)), nil
case *entity.TypeFloat:
return llvm.NewConstFloat(irType.(*llvm.TypeFloat), float64(literal.Value)), nil
default:
return nil, errors.New(fmt.Sprintln("int can't be used as", base))
}
return this.generateConstant(literal)
}
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
return this.generateConstant(literal)
}
// generateLiteralArrayLoc generates an array literal. irDestLoc specifies the
@ -269,11 +256,9 @@ func (this *generator) generateLiteralStructLoc (literal *entity.LiteralStruct,
}
func (this *generator) generateLiteralBoolean (literal *entity.LiteralBoolean) (llvm.Value, error) {
return llvm.NewConstBool(bool(literal.Value)), nil
return this.generateConstant(literal)
}
func (this *generator) generateLiteralNil (literal *entity.LiteralNil) (llvm.Value, error) {
ty, err := this.generateType(literal.Type())
if err != nil { return nil, err }
return llvm.NewConstZeroInitializer(ty), nil
return this.generateConstant(literal)
}

1
generator/type-multiplex.go
View File

@ -18,6 +18,7 @@ func (this *generator) generateTypedef (
if err != nil { return nil, err }
irTypeDef := this.module.NewType(key.LinkName(), irType)
this.types[key] = irTypeDef
return irTypeDef, nil
}