path: root/subex/subexast.go

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,
						),
					},
				},
			},
		},
	}
}