From 122cafbc2ba39df624634a456d2aa51fd3e55b25 Mon Sep 17 00:00:00 2001 From: Sasha Koshka Date: Thu, 8 Feb 2024 16:06:00 -0500 Subject: [PATCH] Unexport generator.resultMode --- generator/blockmanager.go | 4 +-- generator/expression-multiplex.go | 46 +++++++++++++++---------------- generator/expression.go | 8 +++--- 3 files changed, 29 insertions(+), 29 deletions(-) diff --git a/generator/blockmanager.go b/generator/blockmanager.go index 3ef0308..c8b4951 100644 --- a/generator/blockmanager.go +++ b/generator/blockmanager.go @@ -8,7 +8,7 @@ import "git.tebibyte.media/sashakoshka/fspl/entity" type loopEntry struct { value llvm.Value stub *llvm.Block - mode ResultMode + mode resultMode 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 } this.loops = append(this.loops, entry) return entry diff --git a/generator/expression-multiplex.go b/generator/expression-multiplex.go index 084efe4..dbadb79 100644 --- a/generator/expression-multiplex.go +++ b/generator/expression-multiplex.go @@ -4,18 +4,18 @@ import "fmt" import "git.tebibyte.media/sashakoshka/fspl/llvm" import "git.tebibyte.media/sashakoshka/fspl/entity" -type ResultMode int; const ( - ResultModeAny ResultMode = iota - ResultModeVal - ResultModeLoc +type resultMode int; const ( + resultModeAny resultMode = iota + resultModeVal + resultModeLoc ) -func (mode ResultMode) String () string { +func (mode resultMode) String () string { switch(mode) { - case ResultModeAny: return "ResultModeAny" - case ResultModeVal: return "ResultModeVal" - case ResultModeLoc: return "ResultModeLoc" - default: return fmt.Sprintf("ResultMode(%d)", mode) + case resultModeAny: return "resultModeAny" + case resultModeVal: return "resultModeVal" + case resultModeLoc: return "resultModeLoc" + 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 ( expression entity.Expression, - mode ResultMode, + mode resultMode, ) ( register llvm.Value, location bool, err error, ) { switch mode { - case ResultModeAny: + case resultModeAny: return this.generateExpressionAny(expression) - case ResultModeVal: + case resultModeVal: val, err := this.generateExpressionVal(expression) return val, false, err - case ResultModeLoc: + case resultModeLoc: loc, err := this.generateExpressionLoc(expression) 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 case *entity.Block: - return this.generateBlock(expression, ResultModeAny) + return this.generateBlock(expression, resultModeAny) case *entity.IfElse: - return this.generateIfElse(expression, ResultModeAny) + return this.generateIfElse(expression, resultModeAny) case *entity.Loop: - return this.generateLoop(expression, ResultModeAny) + return this.generateLoop(expression, resultModeAny) // we get nothing from these case *entity.Assignment: @@ -148,13 +148,13 @@ func (this *generator) generateExpressionVal (expression entity.Expression) (llv case *entity.Operation: return this.generateOperationVal(expression) case *entity.Block: - loc, _, err := this.generateBlock(expression, ResultModeVal) + loc, _, err := this.generateBlock(expression, resultModeVal) return loc, err case *entity.IfElse: - loc, _, err := this.generateIfElse(expression, ResultModeVal) + loc, _, err := this.generateIfElse(expression, resultModeVal) return loc, err case *entity.Loop: - loc, _, err := this.generateLoop(expression, ResultModeVal) + loc, _, err := this.generateLoop(expression, resultModeVal) return loc, err case *entity.LiteralInt: return this.generateLiteralInt(expression) @@ -217,13 +217,13 @@ func (this *generator) generateExpressionLoc (expression entity.Expression) (llv case *entity.MemberAccess: return this.generateMemberAccessLoc(expression) case *entity.Block: - loc, _, err := this.generateBlock(expression, ResultModeLoc) + loc, _, err := this.generateBlock(expression, resultModeLoc) return loc, err case *entity.IfElse: - loc, _, err := this.generateIfElse(expression, ResultModeLoc) + loc, _, err := this.generateIfElse(expression, resultModeLoc) return loc, err case *entity.Loop: - loc, _, err := this.generateLoop(expression, ResultModeLoc) + loc, _, err := this.generateLoop(expression, resultModeLoc) return loc, err case *entity.LiteralArray: return this.generateLiteralArrayLoc(expression, nil) diff --git a/generator/expression.go b/generator/expression.go index b4dd7b3..b6ab147 100644 --- a/generator/expression.go +++ b/generator/expression.go @@ -5,7 +5,7 @@ import "git.tebibyte.media/sashakoshka/fspl/llvm" import "git.tebibyte.media/sashakoshka/fspl/entity" // 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 } lastIndex := len(block.Steps) - 1 @@ -41,7 +41,7 @@ func (this *generator) generateReturn (ret *entity.Return) (llvm.Value, error) { 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) if err != nil { return nil, false, err } 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 !this.blockManager.Terminated() { this.blockManager.NewBr(exitBlock) } - if mode == ResultModeAny { + if mode == resultModeAny { // discard results of statements previous.NewCondBr(condition, trueBlock, falseBlock) 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 body := this.blockManager.newBlock() previous.NewBr(body)