stred-go

subexast.go (13554B)

---

 package subex
 
 import (
 	"fmt"
 	"main/walk"
 )
 
 // A node in the AST of a subex
 type SubexAST interface {
 	compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState
 }
 
 // Process the first subex, then the second, splitting the input text in two
 type SubexASTConcat struct {
 	First, Second SubexAST
 }
 func (ast SubexASTConcat) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return ast.First.compileWith(ast.Second.compileWith(next, slotMap, runic), slotMap, runic)
 }
 func (ast SubexASTConcat) String() string {
 	return fmt.Sprintf("(%v)(%v)", ast.First, ast.Second)
 }
 
 // Processing a subex and storing the output in a slot instead of outputting it
 type SubexASTStore struct {
 	Match SubexAST
 	Slot rune
 }
 func (ast SubexASTStore) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	id := slotMap.getId(ast.Slot)
 	newNext := ast.Match.compileWith(&SubexStoreEndState {
 		slot: id,
 		next: next,
 	}, slotMap, runic)
 
 	if !runic {
 		return &SubexCaptureBeginState {
 			next: newNext,
 		}
 	} else {
 		return &SubexCaptureRunesBeginState {
 			next: newNext,
 		}
 	}
 }
 func (ast SubexASTStore) String() string {
 	return fmt.Sprintf("$%c(%v)", ast.Slot, ast.Match)
 }
 
 // Try to run the first subex, if it fails then backtrack and use the second
 type SubexASTOr struct {
 	First, Second SubexAST
 }
 func (ast SubexASTOr) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexGroupState {
 		ast.First.compileWith(next, slotMap, runic),
 		ast.Second.compileWith(next, slotMap, runic),
 	}
 }
 func (ast SubexASTOr) String() string {
 	return fmt.Sprintf("(%v)|(%v)", ast.First, ast.Second)
 }
 
 type ConvexRange struct {
 	Start, End int
 }
 func (cr ConvexRange) minmax() (int, int) {
 		if cr.Start == -1 {
 			return cr.End, -1
 		} else if cr.End == -1 {
 			return cr.Start, -1
 		} else if cr.Start < cr.End {
 			return cr.Start, cr.End
 		} else {
 			return cr.End, cr.Start
 		}
 }
 func (cr ConvexRange) decrement() ConvexRange {
 	if cr.Start == -1 {
 		return ConvexRange{-1, cr.End - 1}
 	} else if cr.End == -1 {
 		return ConvexRange{cr.Start - 1, -1}
 	} else {
 		return ConvexRange{cr.Start - 1, cr.End - 1}
 	}
 }
 func (cr ConvexRange) compile(content SubexAST, next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	min, _ := cr.minmax()
 	if min != 0 {
 		return content.compileWith(cr.decrement().compile(content, next, slotMap, runic), slotMap, runic)
 	}
 	if cr.Start == -1 {
 		state := &SubexGroupState {nil, next}
 		state.first = content.compileWith(state, slotMap, runic)
 		return state
 	}
 	if cr.End == -1 {
 		state := &SubexGroupState {next, nil}
 		state.second = content.compileWith(state, slotMap, runic)
 		return state
 	}
 
 	if cr.End == 0 {
 		state := next;
 		for i := 0; i < cr.Start; i += 1 {
 			state = &SubexGroupState {
 				content.compileWith(state, slotMap, runic),
 				next,
 			}
 		}
 		return state
 	} else {
 		state := next;
 		for i := 0; i < cr.End; i += 1 {
 			state = &SubexGroupState {
 				next,
 				content.compileWith(state, slotMap, runic),
 			}
 		}
 		return state
 	}
 }
 
 // Try to run the subex a number of times that is one of the numbers in the acceptable range
 // Prioritising the left
 type SubexASTRepeat struct {
 	Content SubexAST
 	Acceptable []ConvexRange
 }
 func (ast SubexASTRepeat) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	var state SubexState = &SubexDeadState{}
 	for _, convex := range ast.Acceptable {
 		state = &SubexGroupState {state, convex.compile(ast.Content, next, slotMap, runic)}
 	}
 	return state
 }
 func (ast SubexASTRepeat) String() string {
 	return fmt.Sprintf("(%v){...}", ast.Content)
 }
 
 // Read in a single specific Atom and output it unchanged
 type SubexASTCopyScalar struct {
 	Scalar walk.Scalar
 }
 func (ast SubexASTCopyScalar) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexCopyState{
 		filter: selectScalarFilter {ast.Scalar},
 		next: next,
 	}
 }
 func (ast SubexASTCopyScalar) String() string {
 	return fmt.Sprintf("a")
 }
 
 type SubexASTCopyAnyRune struct {}
 func (ast SubexASTCopyAnyRune) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexCopyRuneState {
 		next: next,
 		filter: anyRuneFilter{},
 	}
 }
 
 type SubexASTCopyRune struct {
 	rune rune
 }
 func (ast SubexASTCopyRune) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexCopyRuneState {
 		next: next,
 		filter: selectRuneFilter {ast.rune},
 	}
 }
 
 // Read in a single atom that must be a boolean and output it unchanged
 type SubexASTCopyBool struct {}
 func (ast SubexASTCopyBool) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexCopyState {
 		next: next,
 		filter: anyBoolFilter{},
 	}
 }
 func (ast SubexASTCopyBool) String() string {
 	return "?"
 }
 
 // Read in a single atom that must be a number and output it unchanged
 type SubexASTCopyNumber struct {}
 func (ast SubexASTCopyNumber) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexCopyState {
 		next: next,
 		filter: anyNumberFilter{},
 	}
 }
 func (ast SubexASTCopyNumber) String() string {
 	return "%"
 }
 
 // Read in a full string value and copy it out unchanged
 // # is equivalent to "_{-0}"
 // TODO
 // type SubexASTCopyString struct {}
 // func (ast SubexASTCopyString) compileWith(next SubexState, slotMap *SlotMap) SubexState {
 // 	stringAtomState := &SubexCopyStringAtomState {
 // 		next: nil,
 // 	}
 // 	stringContentState := &SubexGroupState {
 // 		&SubexCopyScalarState {
 // 			scalar: walk.NewAtomStringTerminal(),
 // 			next: next,
 // 		},
 // 		stringAtomState,
 // 	}
 // 	stringAtomState.next = stringContentState
 // 	return &SubexCopyScalarState {
 // 		scalar: walk.NewAtomStringTerminal(),
 // 		next: stringContentState,
 // 	}
 // }
 // func (ast SubexASTCopyString) String() string {
 // 	return "#"
 // }
 
 // Read in any single Atom and output it unchanged
 type SubexASTCopyAnyValue struct {}
 func (ast SubexASTCopyAnyValue) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexCopyState {
 		next: next,
 		filter: anyValueFilter{},
 	}
 }
 func (ast SubexASTCopyAnyValue) String() string {
 	return "."
 }
 
 type OutputContentAST interface {
 	compile(slotMap *SlotMap) OutputContent
 }
 
 type OutputLoadAST struct {
 	slot rune
 }
 func (ast OutputLoadAST) compile(slotMap *SlotMap) OutputContent {
 	return OutputLoad {slotMap.getId(ast.slot)}
 }
 
 type OutputValueLiteralAST struct {
 	atom walk.Value
 }
 func (ast OutputValueLiteralAST) compile(slotMap *SlotMap) OutputContent {
 	return OutputValueLiteral {ast.atom}
 }
 
 type OutputRuneLiteralAST struct {
 	rune walk.StringRuneAtom
 }
 func (ast OutputRuneLiteralAST) compile(slotMap *SlotMap) OutputContent {
 	return OutputRuneLiteral {ast.rune}
 }
 
 // Output a series of Atoms without reading anything from input
 type SubexASTOutput struct {
 	Replacement []OutputContentAST
 }
 func (ast SubexASTOutput) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	var content []OutputContent
 	for _, el := range ast.Replacement {
 		content = append(content, el.compile(slotMap))
 	}
 	return &SubexOutputState{
 		content: content,
 		next: next,
 	}
 }
 func (ast SubexASTOutput) String() string {
 	return "=...="
 }
 
 // Read in a repeated subex separated by a delimiter. Greedy
 type SubexASTJoin struct {
 	Content, Delimiter SubexAST
 }
 func (ast SubexASTJoin) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	afterContentState := &SubexGroupState {
 		nil,
 		next,
 	}
 	manyContentsState := ast.Content.compileWith(afterContentState, slotMap, runic)
 	afterContentState.first = ast.Delimiter.compileWith(manyContentsState, slotMap, runic)
 	return &SubexGroupState {
 		manyContentsState,
 		next,
 	}
 }
 func (ast SubexASTJoin) String() string {
 	return fmt.Sprintf("(%v);(%v)", ast.Content, ast.Delimiter)
 }
 
 // Run each input Atom through a map to produce an output Atom
 // Atoms not in the map cause this to not match
 // type SubexASTRange struct {
 // 	Parts map[walk.Atom]walk.Atom
 // }
 // func (ast SubexASTRange) compileWith(next SubexState, slotMap *SlotMap) SubexState {
 // 	return &SubexRangeState {
 // 		parts: ast.Parts,
 // 		next: next,
 // 	}
 // }
 // func (ast SubexASTRange) String() string {
 // 	return fmt.Sprintf("[abc=xyz]")
 // }
 
 // Run content, if content is a list of booleans, OR them, if all values are castable to numbers, sum them and output the total
 // Reject if neither of these cases match
 type SubexASTSum struct {
 	Content SubexAST
 }
 func (ast SubexASTSum) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexCaptureBeginState {
 		next: ast.Content.compileWith(&SubexArithmeticEndState {
 			next: next,
 			calculate: sumValues,
 		}, slotMap, runic),
 	}
 }
 func (ast SubexASTSum) String() string {
 	return fmt.Sprintf("(%v)+", ast.Content)
 }
 
 // Like sum but for AND and product
 type SubexASTProduct struct {
 	Content SubexAST
 }
 func (ast SubexASTProduct) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexCaptureBeginState {
 		next: ast.Content.compileWith(&SubexArithmeticEndState {
 			next: next,
 			calculate: multiplyValues,
 		}, slotMap, runic),
 	}
 }
 func (ast SubexASTProduct) String() string {
 	return fmt.Sprintf("(%v)*", ast.Content)
 }
 
 // Runs the content Subex, if all outputted atoms can be cast to numbers, outputs them all negated
 // Rejects if this fails
 type SubexASTNegate struct {
 	Content SubexAST
 }
 func (ast SubexASTNegate) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexCaptureBeginState {
 		next: ast.Content.compileWith(&SubexArithmeticEndState {
 			next: next,
 			calculate: negateValues,
 		}, slotMap, runic),
 	}
 }
 func (ast SubexASTNegate) String() string {
 	return fmt.Sprintf("(%v)-", ast.Content)
 }
 
 // Runs the content Subex and collects the output
 // If it is a list of atoms castable to numbers, it takes the reciprocal of them all and outputs them
 // Else it rejects
 type SubexASTReciprocal struct {
 	Content SubexAST
 }
 func (ast SubexASTReciprocal) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexCaptureBeginState {
 		next: ast.Content.compileWith(&SubexArithmeticEndState {
 			next: next,
 			calculate: reciprocalValues,
 		}, slotMap, runic),
 	}
 }
 func (ast SubexASTReciprocal) String() string {
 	return fmt.Sprintf("(%v)/", ast.Content)
 }
 
 // Runs the content Subex and collects the output
 // Maps over the values in the output, casting each to a boolean, notting each and then outputs them
 // Rejects if it cannot cast to boolean
 type SubexASTNot struct {
 	Content SubexAST
 }
 func (ast SubexASTNot) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexCaptureBeginState {
 		next: ast.Content.compileWith(&SubexArithmeticEndState {
 			next: next,
 			calculate: notValues,
 		}, slotMap, runic),
 	}
 }
 func (ast SubexASTNot) String() string {
 	return fmt.Sprintf("(%v)!", ast.Content)
 }
 
 // Runs the content Subex and collects the output
 // Replaces it with true if all output values are equal and false otherwise
 type SubexASTEqual struct {
 	Content SubexAST
 }
 func (ast SubexASTEqual) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexCaptureBeginState {
 		next: ast.Content.compileWith(&SubexArithmeticEndState {
 			next: next,
 			calculate: equalValues,
 		}, slotMap, runic),
 	}
 }
 
 // Does nothing
 type SubexASTEmpty struct {}
 func (ast SubexASTEmpty) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return next
 }
 func (ast SubexASTEmpty) String() string {
 	return "()"
 }
 
 // Discards the output from the content subex
 type SubexASTDiscard struct {
 	Content SubexAST
 }
 func (ast SubexASTDiscard) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	newNext := ast.Content.compileWith(&SubexDiscardState {next}, slotMap, runic)
 	if !runic {
 		return &SubexCaptureBeginState {
 			next: newNext,
 		}
 	} else {
 		return &SubexCaptureRunesBeginState {
 			next: newNext,
 		}
 	}
 }
 func (ast SubexASTDiscard) String() string {
 	return fmt.Sprintf("(%v)$_", ast.Content)
 }
 
 // Go into an array, pass the content each of the values in the array to eat and then leave the array
 type SubexASTEnterArray struct {
 	Content SubexAST
 }
 func (ast SubexASTEnterArray) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexCaptureBeginState {
 		next: &SubexIncrementNestState {
 			next: &SubexCopyState {
 				filter: anyArrayFilter{},
 				next: &SubexDiscardState {
 					next: &SubexCaptureBeginState {
 						next: ast.Content.compileWith(
 							&SubexDiscardTerminalState {
 								terminal: walk.ArrayEndTerminal{},
 								next: &SubexDecrementNestState {
 									next: &SubexConstructArrayState {next: next},
 								},
 							},
 							slotMap,
 							runic,
 						),
 					},
 				},
 			},
 		},
 	}
 }
 
 type SubexASTEnterString struct {
 	Content SubexAST
 }
 func (ast SubexASTEnterString) compileWith(next SubexState, slotMap *SlotMap, runic bool) SubexState {
 	return &SubexCaptureBeginState {
 		next: &SubexIncrementNestState {
 			next: &SubexCopyState {
 				filter: anyStringFilter{},
 				next: &SubexDiscardState {
 					next: &SubexCaptureRunesBeginState {
 						next: ast.Content.compileWith(
 							&SubexDecrementNestState {
 								next: &SubexDiscardTerminalState {
 									terminal: walk.StringEndTerminal{},
 									next: &SubexConstructStringState {next: next},
 								},
 							},
 							slotMap,
 							true,
 						),
 					},
 				},
 			},
 		},
 	}
 }