Unexport generator.resultMode

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

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)

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)