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

Rename generateExpression to generateExpressionVal

Browse Source
This commit is contained in:
Sasha Koshka 2024-01-27 08:39:05 +00:00
parent 8dedae5cb9
commit cfc894ff29
6 changed files with 42 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
generator/assignment.go
View File

@ -69,7 +69,7 @@ func (this *generator) generateAssignmentSource (
// conversion from pointer to interface // conversion from pointer to interface
case *entity.TypePointer: case *entity.TypePointer:
// assign data // assign data
source, err := this.generateExpression(from) source, err := this.generateExpressionVal(from)
if err != nil { return nil, err } if err != nil { return nil, err }
fromData := this.blockManager.NewLoad(new(llvm.TypePointer), source) fromData := this.blockManager.NewLoad(new(llvm.TypePointer), source)
this.blockManager.NewStore(fromData, toDataField) this.blockManager.NewStore(fromData, toDataField)
@ -119,13 +119,13 @@ func (this *generator) generateAssignmentSource (
case *entity.TypeSlice: case *entity.TypeSlice:
switch fromBase := analyzer.ReduceToBase(from.Type()).(type) { switch fromBase := analyzer.ReduceToBase(from.Type()).(type) {
case *entity.TypeArray: case *entity.TypeArray:
source, err := this.generateExpression(from) source, err := this.generateExpressionVal(from)
if err != nil { return nil, err } if err != nil { return nil, err }
return this.generateSliceDefinedLength(to, source, int64(fromBase.Length)) return this.generateSliceDefinedLength(to, source, int64(fromBase.Length))
} }
} }
source, err := this.generateExpression(from) source, err := this.generateExpressionVal(from)
if err != nil { return nil, err } if err != nil { return nil, err }
return source, nil return source, nil
} }

8
generator/expression-multiplex.go
View File

@ -16,9 +16,9 @@ func (this *generator) locationToValue (pointer llvm.Value, ty entity.Type) (llv
return this.blockManager.NewLoad(irType, pointer), nil return this.blockManager.NewLoad(irType, pointer), nil
} }
// generateExpression generates an expression and returns a register // generateExpressionVal generates an expression and returns a register
// representing the result. // representing the result.
func (this *generator) generateExpression (expression entity.Expression) (llvm.Value, error) { func (this *generator) generateExpressionVal (expression entity.Expression) (llvm.Value, error) {
// we get an address from these, so we need to load the value // we get an address from these, so we need to load the value
switch expression := expression.(type) { switch expression := expression.(type) {
case *entity.Dereference, case *entity.Dereference,
@ -98,7 +98,7 @@ func (this *generator) generateExpressionLoc (expression entity.Expression) (llv
*entity.LiteralBoolean, *entity.LiteralBoolean,
*entity.LiteralNil: *entity.LiteralNil:
value, err := this.generateExpression(expression) value, err := this.generateExpressionVal(expression)
if err != nil { return nil, err } if err != nil { return nil, err }
return this.valueToLocation(value), nil return this.valueToLocation(value), nil
@ -143,7 +143,7 @@ func (this *generator) generateStatement (statement entity.Statement) (llvm.Valu
case *entity.Assignment: case *entity.Assignment:
return this.generateAssignment(statement) return this.generateAssignment(statement)
case entity.Expression: case entity.Expression:
return this.generateExpression(statement) return this.generateExpressionVal(statement)
default: default:
panic(fmt.Sprintf ( panic(fmt.Sprintf (
"BUG: generator doesnt know about statement %v, ty: %T", "BUG: generator doesnt know about statement %v, ty: %T",

56
generator/expression.go
View File

@ -69,7 +69,7 @@ func (this *generator) generateMethodCall (call *entity.MethodCall) (llvm.Value,
if sourceType, ok := pointerType.Referenced.(*entity.TypeNamed); ok { if sourceType, ok := pointerType.Referenced.(*entity.TypeNamed); ok {
method, err := this.method(sourceType.Name, call.Name) method, err := this.method(sourceType.Name, call.Name)
if err != errNotFound { if err != errNotFound {
source, err := this.generateExpression(call.Source) source, err := this.generateExpressionVal(call.Source)
if err != nil { return nil, err } if err != nil { return nil, err }
args[0] = source args[0] = source
return this.blockManager.NewCall(method, method.Signature, args...), nil return this.blockManager.NewCall(method, method.Signature, args...), nil
@ -141,7 +141,7 @@ func (this *generator) generateLength (length *entity.Length) (llvm.Value, error
func (this *generator) generateValueCast (cast *entity.ValueCast) (llvm.Value, error) { func (this *generator) generateValueCast (cast *entity.ValueCast) (llvm.Value, error) {
generateFrom := func () (llvm.Value, error) { generateFrom := func () (llvm.Value, error) {
return this.generateExpression(cast.Value) return this.generateExpressionVal(cast.Value)
} }
generateFromLoc := func () (llvm.Value, error) { generateFromLoc := func () (llvm.Value, error) {
return this.generateExpressionLoc(cast.Value) return this.generateExpressionLoc(cast.Value)
@ -155,7 +155,7 @@ func (this *generator) generateValueCast (cast *entity.ValueCast) (llvm.Value, e
// Attempt to short circuit if types are equal to avoid LLVM bitching at // Attempt to short circuit if types are equal to avoid LLVM bitching at
// us // us
if llvm.TypesEqual(irFromType, irToType) { if llvm.TypesEqual(irFromType, irToType) {
return this.generateExpression(cast.Value) return this.generateExpressionVal(cast.Value)
} }
fail := func () (llvm.Value, error) { fail := func () (llvm.Value, error) {
@ -225,7 +225,7 @@ func (this *generator) generateValueCast (cast *entity.ValueCast) (llvm.Value, e
// cast from pointer to pointer: // cast from pointer to pointer:
// basic forceful value assignment // basic forceful value assignment
// (all IR pointer types are equal) // (all IR pointer types are equal)
return this.generateExpression(cast.Value) return this.generateExpressionVal(cast.Value)
default: return fail() default: return fail()
} }
@ -235,7 +235,7 @@ func (this *generator) generateValueCast (cast *entity.ValueCast) (llvm.Value, e
// cast from slice to slice: // cast from slice to slice:
// basic forceful value assignment // basic forceful value assignment
// (assume structural equivalence) // (assume structural equivalence)
return this.generateExpression(cast.Value) return this.generateExpressionVal(cast.Value)
default: return fail() default: return fail()
} }
@ -245,7 +245,7 @@ func (this *generator) generateValueCast (cast *entity.ValueCast) (llvm.Value, e
// cast from array to array: // cast from array to array:
// basic forceful value assignment // basic forceful value assignment
// (assume structural equivalence) // (assume structural equivalence)
return this.generateExpression(cast.Value) return this.generateExpressionVal(cast.Value)
default: return fail() default: return fail()
} }
@ -255,7 +255,7 @@ func (this *generator) generateValueCast (cast *entity.ValueCast) (llvm.Value, e
// cast from struct to struct: // cast from struct to struct:
// basic forceful value assignment // basic forceful value assignment
// (assume structural equivalence) // (assume structural equivalence)
return this.generateExpression(cast.Value) return this.generateExpressionVal(cast.Value)
default: return fail() default: return fail()
} }
@ -272,10 +272,10 @@ func (this *generator) generateBitCast (cast *entity.BitCast) (llvm.Value, error
// Attempt to short circuit if types are equal to avoid LLVM bitching at // Attempt to short circuit if types are equal to avoid LLVM bitching at
// us // us
if llvm.TypesEqual(irFromType, irToType) { if llvm.TypesEqual(irFromType, irToType) {
return this.generateExpression(cast.Value) return this.generateExpressionVal(cast.Value)
} }
from, err := this.generateExpression(cast.Value) from, err := this.generateExpressionVal(cast.Value)
if err != nil { return nil, err } if err != nil { return nil, err }
return this.blockManager.NewBitCast(from, irToType), nil return this.blockManager.NewBitCast(from, irToType), nil
} }
@ -283,10 +283,10 @@ func (this *generator) generateBitCast (cast *entity.BitCast) (llvm.Value, error
func (this *generator) generateOperation (operation *entity.Operation) (llvm.Value, error) { func (this *generator) generateOperation (operation *entity.Operation) (llvm.Value, error) {
nSameType := func (binary func (x, y llvm.Value) llvm.Value) (llvm.Value, error) { nSameType := func (binary func (x, y llvm.Value) llvm.Value) (llvm.Value, error) {
irX, err := this.generateExpression(operation.Arguments[0]) irX, err := this.generateExpressionVal(operation.Arguments[0])
if err != nil { return nil, err } if err != nil { return nil, err }
for _, argument := range operation.Arguments[1:] { for _, argument := range operation.Arguments[1:] {
irY, err := this.generateExpression(argument) irY, err := this.generateExpressionVal(argument)
if err != nil { return nil, err } if err != nil { return nil, err }
irX = binary(irX, irY) irX = binary(irX, irY)
} }
@ -354,7 +354,7 @@ func (this *generator) generateOperation (operation *entity.Operation) (llvm.Val
} }
case entity.OperatorIncrement: case entity.OperatorIncrement:
irX, err := this.generateExpression(operation.Arguments[0]) irX, err := this.generateExpressionVal(operation.Arguments[0])
if err != nil { return nil, err } if err != nil { return nil, err }
irType := irType.(*llvm.TypeInt) irType := irType.(*llvm.TypeInt)
@ -370,7 +370,7 @@ func (this *generator) generateOperation (operation *entity.Operation) (llvm.Val
} }
case entity.OperatorDecrement: case entity.OperatorDecrement:
irX, err := this.generateExpression(operation.Arguments[0]) irX, err := this.generateExpressionVal(operation.Arguments[0])
if err != nil { return nil, err } if err != nil { return nil, err }
irType := irType.(*llvm.TypeInt) irType := irType.(*llvm.TypeInt)
@ -405,7 +405,7 @@ func (this *generator) generateOperation (operation *entity.Operation) (llvm.Val
// logic // logic
case entity.OperatorLogicalNot: case entity.OperatorLogicalNot:
irX, err := this.generateExpression(operation.Arguments[0]) irX, err := this.generateExpressionVal(operation.Arguments[0])
if err != nil { return nil, err } if err != nil { return nil, err }
return this.blockManager.NewICmp(llvm.IPredicateEQ, irX, llvm.NewConstBool(false)), nil return this.blockManager.NewICmp(llvm.IPredicateEQ, irX, llvm.NewConstBool(false)), nil
@ -414,7 +414,7 @@ func (this *generator) generateOperation (operation *entity.Operation) (llvm.Val
exit := this.blockManager.newBlock() exit := this.blockManager.newBlock()
for index, argument := range operation.Arguments { for index, argument := range operation.Arguments {
irX, err := this.generateExpression(argument) irX, err := this.generateExpressionVal(argument)
if err != nil { return nil, err } if err != nil { return nil, err }
incomings[index] = &llvm.Incoming { incomings[index] = &llvm.Incoming {
@ -440,7 +440,7 @@ func (this *generator) generateOperation (operation *entity.Operation) (llvm.Val
exit := this.blockManager.newBlock() exit := this.blockManager.newBlock()
for index, argument := range operation.Arguments { for index, argument := range operation.Arguments {
irX, err := this.generateExpression(argument) irX, err := this.generateExpressionVal(argument)
if err != nil { return nil, err } if err != nil { return nil, err }
incomings[index] = &llvm.Incoming { incomings[index] = &llvm.Incoming {
@ -471,7 +471,7 @@ func (this *generator) generateOperation (operation *entity.Operation) (llvm.Val
// bit manipulation // bit manipulation
case entity.OperatorNot: case entity.OperatorNot:
irX, err := this.generateExpression(operation.Arguments[0]) irX, err := this.generateExpressionVal(operation.Arguments[0])
if err != nil { return nil, err } if err != nil { return nil, err }
return this.blockManager.NewXor ( return this.blockManager.NewXor (
irX, irX,
@ -493,16 +493,16 @@ func (this *generator) generateOperation (operation *entity.Operation) (llvm.Val
}) })
case entity.OperatorLeftShift: case entity.OperatorLeftShift:
irX, err := this.generateExpression(operation.Arguments[0]) irX, err := this.generateExpressionVal(operation.Arguments[0])
if err != nil { return nil, err } if err != nil { return nil, err }
irY, err := this.generateExpression(operation.Arguments[1]) irY, err := this.generateExpressionVal(operation.Arguments[1])
if err != nil { return nil, err } if err != nil { return nil, err }
return this.blockManager.NewShl(irX, irY), nil return this.blockManager.NewShl(irX, irY), nil
case entity.OperatorRightShift: case entity.OperatorRightShift:
irX, err := this.generateExpression(operation.Arguments[0]) irX, err := this.generateExpressionVal(operation.Arguments[0])
if err != nil { return nil, err } if err != nil { return nil, err }
irY, err := this.generateExpression(operation.Arguments[1]) irY, err := this.generateExpressionVal(operation.Arguments[1])
if err != nil { return nil, err } if err != nil { return nil, err }
if analyzer.IsUnsigned(ty) { if analyzer.IsUnsigned(ty) {
return this.blockManager.NewLShr(irX, irY), nil return this.blockManager.NewLShr(irX, irY), nil
@ -630,7 +630,7 @@ func (this *generator) generateBlock (block *entity.Block) (llvm.Value, error) {
} }
func (this *generator) generateIfElse (ifelse *entity.IfElse, loc bool) (llvm.Value, error) { func (this *generator) generateIfElse (ifelse *entity.IfElse, loc bool) (llvm.Value, error) {
condition, err := this.generateExpression(ifelse.Condition) condition, err := this.generateExpressionVal(ifelse.Condition)
if err != nil { return nil, err } if err != nil { return nil, err }
previous := this.blockManager.Block previous := this.blockManager.Block
@ -643,7 +643,7 @@ func (this *generator) generateIfElse (ifelse *entity.IfElse, loc bool) (llvm.Va
if loc { if loc {
tru, err = this.generateExpressionLoc(ifelse.True) tru, err = this.generateExpressionLoc(ifelse.True)
} else { } else {
tru, err = this.generateExpression(ifelse.True) tru, err = this.generateExpressionVal(ifelse.True)
} }
if err != nil { return nil, err } if err != nil { return nil, err }
if !this.blockManager.Terminated() { this.blockManager.NewBr(exitBlock) } if !this.blockManager.Terminated() { this.blockManager.NewBr(exitBlock) }
@ -654,7 +654,7 @@ func (this *generator) generateIfElse (ifelse *entity.IfElse, loc bool) (llvm.Va
if loc { if loc {
fals, err = this.generateExpressionLoc(ifelse.False) fals, err = this.generateExpressionLoc(ifelse.False)
} else { } else {
fals, err = this.generateExpression(ifelse.False) fals, err = this.generateExpressionVal(ifelse.False)
} }
if err != nil { return nil, err } if err != nil { return nil, err }
if !this.blockManager.Terminated() { this.blockManager.NewBr(exitBlock) } if !this.blockManager.Terminated() { this.blockManager.NewBr(exitBlock) }
@ -667,7 +667,7 @@ func (this *generator) generateIfElse (ifelse *entity.IfElse, loc bool) (llvm.Va
if loc { if loc {
fals, err = this.generateExpressionLoc(ifelse.False) fals, err = this.generateExpressionLoc(ifelse.False)
} else { } else {
fals, err = this.generateExpression(ifelse.False) fals, err = this.generateExpressionVal(ifelse.False)
} }
if err != nil { return nil, err } if err != nil { return nil, err }
if !this.blockManager.Terminated() { this.blockManager.NewBr(exitBlock) } if !this.blockManager.Terminated() { this.blockManager.NewBr(exitBlock) }
@ -700,7 +700,7 @@ func (this *generator) generateLoop (loop *entity.Loop, loc bool) (llvm.Value, e
loopEntry := this.blockManager.pushLoop(loc) loopEntry := this.blockManager.pushLoop(loc)
defer this.blockManager.popLoop() defer this.blockManager.popLoop()
_, err := this.generateExpression(loop.Body) _, err := this.generateExpressionVal(loop.Body)
if err != nil { return nil, err } if err != nil { return nil, err }
this.blockManager.NewBr(body) this.blockManager.NewBr(body)
@ -717,7 +717,7 @@ func (this *generator) generateLoop (loop *entity.Loop, loc bool) (llvm.Value, e
func (this *generator) generateBreak (brk *entity.Break) (llvm.Value, error) { func (this *generator) generateBreak (brk *entity.Break) (llvm.Value, error) {
loopEntry := this.blockManager.topLoop() loopEntry := this.blockManager.topLoop()
if brk.Value != nil { if brk.Value != nil {
value, err := this.generateExpression(brk.Value) value, err := this.generateExpressionVal(brk.Value)
if err != nil { return nil, err } if err != nil { return nil, err }
loopEntry.value = value loopEntry.value = value
} }
@ -730,7 +730,7 @@ func (this *generator) generateReturn (ret *entity.Return) (llvm.Value, error) {
if ret.Value == nil { if ret.Value == nil {
this.blockManager.NewRet(nil) this.blockManager.NewRet(nil)
} else { } else {
value, err := this.generateExpression(ret.Value) value, err := this.generateExpressionVal(ret.Value)
if err != nil { return nil, err } if err != nil { return nil, err }
this.blockManager.NewRet(value) this.blockManager.NewRet(value)
} }

4
generator/function.go
View File

@ -32,7 +32,7 @@ func (this *generator) generateFunction (
defer this.popBlockManager() defer this.popBlockManager()
this.blockManager.addFunctionArgumentDeclarations(function) this.blockManager.addFunctionArgumentDeclarations(function)
body, err := this.generateExpression(function.Body) body, err := this.generateExpressionVal(function.Body)
if err != nil { return nil, err } if err != nil { return nil, err }
if function.Signature.Return == nil { if function.Signature.Return == nil {
@ -76,7 +76,7 @@ func (this *generator) generateMethod (
defer this.popBlockManager() defer this.popBlockManager()
this.blockManager.addFunctionArgumentDeclarations(method) this.blockManager.addFunctionArgumentDeclarations(method)
body, err := this.generateExpression(method.Body) body, err := this.generateExpressionVal(method.Body)
if err != nil { return nil, err } if err != nil { return nil, err }
if method.Signature.Return == nil { if method.Signature.Return == nil {

2
generator/literal.go
View File

@ -206,7 +206,7 @@ func (this *generator) generateLiteralStructLoc (literal *entity.LiteralStruct)
for index, member := range ty.Members { for index, member := range ty.Members {
var irMember llvm.Value var irMember llvm.Value
if pair, ok := literal.MemberMap[member.Name]; ok { if pair, ok := literal.MemberMap[member.Name]; ok {
irMember, err = this.generateExpression(pair.Value) irMember, err = this.generateExpressionVal(pair.Value)
if err != nil { return nil, err } if err != nil { return nil, err }
} else { } else {
irMemberType, err := this.generateType(member.Type()) irMemberType, err := this.generateType(member.Type())

8
generator/location-expression.go
View File

@ -24,11 +24,11 @@ func (this *generator) generateSliceLoc (slice *entity.Slice) (llvm.Value, error
} }
if slice.Start != nil { if slice.Start != nil {
start, err = this.generateExpression(slice.Start) start, err = this.generateExpressionVal(slice.Start)
if err != nil { return nil, err } if err != nil { return nil, err }
} }
if slice.End != nil { if slice.End != nil {
end, err = this.generateExpression(slice.End) end, err = this.generateExpressionVal(slice.End)
if err != nil { return nil, err } if err != nil { return nil, err }
} }
@ -93,7 +93,7 @@ func (this *generator) generateSliceLoc (slice *entity.Slice) (llvm.Value, error
func (this *generator) generateSubscriptLoc (subscript *entity.Subscript) (llvm.Value, error) { func (this *generator) generateSubscriptLoc (subscript *entity.Subscript) (llvm.Value, error) {
source, err := this.generateExpressionLoc(subscript.Slice) source, err := this.generateExpressionLoc(subscript.Slice)
if err != nil { return nil, err } if err != nil { return nil, err }
offset, err := this.generateExpression(subscript.Offset) offset, err := this.generateExpressionVal(subscript.Offset)
if err != nil { return nil, err } if err != nil { return nil, err }
var elementType entity.Type var elementType entity.Type
@ -127,7 +127,7 @@ func (this *generator) generateSubscriptLoc (subscript *entity.Subscript) (llvm.
} }
func (this *generator) generateDereferenceLoc (dereference *entity.Dereference) (llvm.Value, error) { func (this *generator) generateDereferenceLoc (dereference *entity.Dereference) (llvm.Value, error) {
return this.generateExpression(dereference.Pointer) return this.generateExpressionVal(dereference.Pointer)
} }
func (this *generator) generateMemberAccessLoc (access *entity.MemberAccess) (llvm.Value, error) { func (this *generator) generateMemberAccessLoc (access *entity.MemberAccess) (llvm.Value, error) {