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

Unexport generator.resultMode

Browse Source
This commit is contained in:
Sasha Koshka 2024-02-08 16:06:00 -05:00
parent 4089765633
commit e60a6e246f
3 changed files with 29 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
generator/blockmanager.go
View File

@ -8,7 +8,7 @@ import "git.tebibyte.media/sashakoshka/fspl/entity"
type loopEntry struct { type loopEntry struct {
value llvm.Value value llvm.Value
stub *llvm.Block stub *llvm.Block
mode ResultMode mode resultMode
loc bool loc bool
} }
@ -46,7 +46,7 @@ func (this *generator) popBlockManager () {
} }
} }
func (this *blockManager) pushLoop (mode ResultMode) *loopEntry { func (this *blockManager) pushLoop (mode resultMode) *loopEntry {
entry := &loopEntry { mode: mode } entry := &loopEntry { mode: mode }
this.loops = append(this.loops, entry) this.loops = append(this.loops, entry)
return entry return entry

46
generator/expression-multiplex.go
View File

@ -4,18 +4,18 @@ import "fmt"
import "git.tebibyte.media/sashakoshka/fspl/llvm" import "git.tebibyte.media/sashakoshka/fspl/llvm"
import "git.tebibyte.media/sashakoshka/fspl/entity" import "git.tebibyte.media/sashakoshka/fspl/entity"
type ResultMode int; const ( type resultMode int; const (
ResultModeAny ResultMode = iota resultModeAny resultMode = iota
ResultModeVal resultModeVal
ResultModeLoc resultModeLoc
) )
func (mode ResultMode) String () string { func (mode resultMode) String () string {
switch(mode) { switch(mode) {
case ResultModeAny: return "ResultModeAny" case resultModeAny: return "resultModeAny"
case ResultModeVal: return "ResultModeVal" case resultModeVal: return "resultModeVal"
case ResultModeLoc: return "ResultModeLoc" case resultModeLoc: return "resultModeLoc"
default: return fmt.Sprintf("ResultMode(%d)", mode) default: return fmt.Sprintf("resultMode(%d)", mode)
} }
} }
@ -33,22 +33,22 @@ func (this *generator) locationToValue (pointer llvm.Value, ty entity.Type) (llv
func (this *generator) generateExpression ( func (this *generator) generateExpression (
expression entity.Expression, expression entity.Expression,
mode ResultMode, mode resultMode,
) ( ) (
register llvm.Value, register llvm.Value,
location bool, location bool,
err error, err error,
) { ) {
switch mode { switch mode {
case ResultModeAny: case resultModeAny:
return this.generateExpressionAny(expression) return this.generateExpressionAny(expression)
case ResultModeVal: case resultModeVal:
val, err := this.generateExpressionVal(expression) val, err := this.generateExpressionVal(expression)
return val, false, err return val, false, err
case ResultModeLoc: case resultModeLoc:
loc, err := this.generateExpressionLoc(expression) loc, err := this.generateExpressionLoc(expression)
return loc, true, err return loc, true, err
default: panic("unknown ResultMode") default: panic("unknown resultMode")
} }
} }
@ -90,11 +90,11 @@ func (this *generator) generateExpressionAny (expression entity.Expression) (reg
// these are capable of giving us both // these are capable of giving us both
case *entity.Block: case *entity.Block:
return this.generateBlock(expression, ResultModeAny) return this.generateBlock(expression, resultModeAny)
case *entity.IfElse: case *entity.IfElse:
return this.generateIfElse(expression, ResultModeAny) return this.generateIfElse(expression, resultModeAny)
case *entity.Loop: case *entity.Loop:
return this.generateLoop(expression, ResultModeAny) return this.generateLoop(expression, resultModeAny)
// we get nothing from these // we get nothing from these
case *entity.Assignment: case *entity.Assignment:
@ -148,13 +148,13 @@ func (this *generator) generateExpressionVal (expression entity.Expression) (llv
case *entity.Operation: case *entity.Operation:
return this.generateOperationVal(expression) return this.generateOperationVal(expression)
case *entity.Block: case *entity.Block:
loc, _, err := this.generateBlock(expression, ResultModeVal) loc, _, err := this.generateBlock(expression, resultModeVal)
return loc, err return loc, err
case *entity.IfElse: case *entity.IfElse:
loc, _, err := this.generateIfElse(expression, ResultModeVal) loc, _, err := this.generateIfElse(expression, resultModeVal)
return loc, err return loc, err
case *entity.Loop: case *entity.Loop:
loc, _, err := this.generateLoop(expression, ResultModeVal) loc, _, err := this.generateLoop(expression, resultModeVal)
return loc, err return loc, err
case *entity.LiteralInt: case *entity.LiteralInt:
return this.generateLiteralInt(expression) return this.generateLiteralInt(expression)
@ -217,13 +217,13 @@ func (this *generator) generateExpressionLoc (expression entity.Expression) (llv
case *entity.MemberAccess: case *entity.MemberAccess:
return this.generateMemberAccessLoc(expression) return this.generateMemberAccessLoc(expression)
case *entity.Block: case *entity.Block:
loc, _, err := this.generateBlock(expression, ResultModeLoc) loc, _, err := this.generateBlock(expression, resultModeLoc)
return loc, err return loc, err
case *entity.IfElse: case *entity.IfElse:
loc, _, err := this.generateIfElse(expression, ResultModeLoc) loc, _, err := this.generateIfElse(expression, resultModeLoc)
return loc, err return loc, err
case *entity.Loop: case *entity.Loop:
loc, _, err := this.generateLoop(expression, ResultModeLoc) loc, _, err := this.generateLoop(expression, resultModeLoc)
return loc, err return loc, err
case *entity.LiteralArray: case *entity.LiteralArray:
return this.generateLiteralArrayLoc(expression, nil) return this.generateLiteralArrayLoc(expression, nil)

8
generator/expression.go
View File

@ -5,7 +5,7 @@ import "git.tebibyte.media/sashakoshka/fspl/llvm"
import "git.tebibyte.media/sashakoshka/fspl/entity" import "git.tebibyte.media/sashakoshka/fspl/entity"
// import "git.tebibyte.media/sashakoshka/fspl/analyzer" // import "git.tebibyte.media/sashakoshka/fspl/analyzer"
func (this *generator) generateBlock (block *entity.Block, mode ResultMode) (llvm.Value, bool, error) { func (this *generator) generateBlock (block *entity.Block, mode resultMode) (llvm.Value, bool, error) {
if len(block.Steps) == 0 { return nil, false, nil } if len(block.Steps) == 0 { return nil, false, nil }
lastIndex := len(block.Steps) - 1 lastIndex := len(block.Steps) - 1
@ -41,7 +41,7 @@ func (this *generator) generateReturn (ret *entity.Return) (llvm.Value, error) {
return nil, nil return nil, nil
} }
func (this *generator) generateIfElse (ifelse *entity.IfElse, mode ResultMode) (llvm.Value, bool, error) { func (this *generator) generateIfElse (ifelse *entity.IfElse, mode resultMode) (llvm.Value, bool, error) {
condition, err := this.generateExpressionVal(ifelse.Condition) condition, err := this.generateExpressionVal(ifelse.Condition)
if err != nil { return nil, false, err } if err != nil { return nil, false, err }
previous := this.blockManager.Block previous := this.blockManager.Block
@ -70,7 +70,7 @@ func (this *generator) generateIfElse (ifelse *entity.IfElse, mode ResultMode) (
if err != nil { return nil, false, err } if err != nil { return nil, false, err }
if !this.blockManager.Terminated() { this.blockManager.NewBr(exitBlock) } if !this.blockManager.Terminated() { this.blockManager.NewBr(exitBlock) }
if mode == ResultModeAny { if mode == resultModeAny {
// discard results of statements // discard results of statements
previous.NewCondBr(condition, trueBlock, falseBlock) previous.NewCondBr(condition, trueBlock, falseBlock)
this.blockManager.Block = exitBlock this.blockManager.Block = exitBlock
@ -94,7 +94,7 @@ func (this *generator) generateIfElse (ifelse *entity.IfElse, mode ResultMode) (
} }
} }
func (this *generator) generateLoop (loop *entity.Loop, mode ResultMode) (llvm.Value, bool, error) { func (this *generator) generateLoop (loop *entity.Loop, mode resultMode) (llvm.Value, bool, error) {
previous := this.blockManager.Block previous := this.blockManager.Block
body := this.blockManager.newBlock() body := this.blockManager.newBlock()
previous.NewBr(body) previous.NewBr(body)