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) 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) SubexState {
	return ast.First.compileWith(ast.Second.compileWith(next, slotMap), slotMap)
}
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) SubexState {
	id := slotMap.getId(ast.Slot)
	return &SubexCaptureBeginState {
		next: ast.Match.compileWith(&SubexStoreEndState {
			slot: id,
			next: next,
		}, slotMap),
	}
}
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) SubexState {
	return &SubexGroupState {
		ast.First.compileWith(next, slotMap),
		ast.Second.compileWith(next, slotMap),
	}
}
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) SubexState {
	min, _ := cr.minmax()
	if min != 0 {
		return content.compileWith(cr.decrement().compile(content, next, slotMap), slotMap)
	}
	if cr.Start == -1 {
		state := &SubexGroupState {nil, next}
		state.first = content.compileWith(state, slotMap)
		return state
	}
	if cr.End == -1 {
		state := &SubexGroupState {next, nil}
		state.second = content.compileWith(state, slotMap)
		return state
	}

	if cr.End == 0 {
		state := next;
		for i := 0; i < cr.Start; i += 1 {
			state = &SubexGroupState {
				content.compileWith(state, slotMap),
				next,
			}
		}
		return state
	} else {
		state := next;
		for i := 0; i < cr.End; i += 1 {
			state = &SubexGroupState {
				next,
				content.compileWith(state, slotMap),
			}
		}
		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) SubexState {
	var state SubexState = &SubexDeadState{}
	for _, convex := range ast.Acceptable {
		state = &SubexGroupState {state, convex.compile(ast.Content, next, slotMap)}
	}
	return state
}
func (ast SubexASTRepeat) String() string {
	return fmt.Sprintf("(%v){...}", ast.Content)
}

// Read in a single specific Atom and output it unchanged
type SubexASTCopyAtom struct {
	Atom walk.Atom
}
func (ast SubexASTCopyAtom) compileWith(next SubexState, slotMap *SlotMap) SubexState {
	return &SubexCopyAtomState{
		atom: ast.Atom,
		next: next,
	}
}
func (ast SubexASTCopyAtom) String() string {
	return fmt.Sprintf("a")
}

// 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) SubexState {
	return &SubexCopyBoolState {next}
}
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) SubexState {
	return &SubexCopyNumberState {next}
}
func (ast SubexASTCopyNumber) String() string {
	return "%"
}

// Read in a single atom that must be a string atom and output it unchanged
type SubexASTCopyStringAtom struct {}
func (ast SubexASTCopyStringAtom) compileWith(next SubexState, slotMap *SlotMap) SubexState {
	return &SubexCopyStringAtomState {next}
}
func (ast SubexASTCopyStringAtom) String() string {
	return "_"
}

// Read in a full string value and copy it out unchanged
// # is equivalent to "_{-0}"
type SubexASTCopyString struct {}
func (ast SubexASTCopyString) compileWith(next SubexState, slotMap *SlotMap) SubexState {
	stringAtomState := &SubexCopyStringAtomState {
		next: nil,
	}
	stringContentState := &SubexGroupState {
		&SubexCopyAtomState {
			atom: walk.NewAtomStringTerminal(),
			next: next,
		},
		stringAtomState,
	}
	stringAtomState.next = stringContentState
	return &SubexCopyAtomState {
		atom: walk.NewAtomStringTerminal(),
		next: stringContentState,
	}
}
func (ast SubexASTCopyString) String() string {
	return "#"
}

// Read in a non-terminal value and copy it out unchanged
// , is equivalent to `null`|?|%|#
type SubexASTCopyValue struct {}
func (ast SubexASTCopyValue) compileWith(next SubexState, slotMap *SlotMap) SubexState {
	return &SubexGroupState {
		SubexASTCopyString{}.compileWith(next, slotMap),
		&SubexCopyNonStringNonTerminalAtomState {next},
	}
}
func (ast SubexASTCopyValue) String() string {
	return ","
}

// Read in any single Atom and output it unchanged
type SubexASTCopyAny struct {}
func (ast SubexASTCopyAny) compileWith(next SubexState, slotMap *SlotMap) SubexState {
	return &SubexCopyAnyState{next}
}
func (ast SubexASTCopyAny) 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 OutputAtomLiteralAST struct {
	atom walk.Atom
}
func (ast OutputAtomLiteralAST) compile(slotMap *SlotMap) OutputContent {
	return OutputAtomLiteral {ast.atom}
}

// Output a series of Atoms without reading anything from input
type SubexASTOutput struct {
	Replacement []OutputContentAST
}
func (ast SubexASTOutput) compileWith(next SubexState, slotMap *SlotMap) 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) SubexState {
	afterContentState := &SubexGroupState {
		nil,
		next,
	}
	manyContentsState := ast.Content.compileWith(afterContentState, slotMap)
	afterContentState.first = ast.Delimiter.compileWith(manyContentsState, slotMap)
	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) SubexState {
	return &SubexCaptureBeginState {
		next: ast.Content.compileWith(&SubexArithmeticEndState {
			next: next,
			calculate: sumValues,
		}, slotMap),
	}
}
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) SubexState {
	return &SubexCaptureBeginState {
		next: ast.Content.compileWith(&SubexArithmeticEndState {
			next: next,
			calculate: multiplyValues,
		}, slotMap),
	}
}
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) SubexState {
	return &SubexCaptureBeginState {
		next: ast.Content.compileWith(&SubexArithmeticEndState {
			next: next,
			calculate: negateValues,
		}, slotMap),
	}
}
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) SubexState {
	return &SubexCaptureBeginState {
		next: ast.Content.compileWith(&SubexArithmeticEndState {
			next: next,
			calculate: reciprocalValues,
		}, slotMap),
	}
}
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) SubexState {
	return &SubexCaptureBeginState {
		next: ast.Content.compileWith(&SubexArithmeticEndState {
			next: next,
			calculate: notValues,
		}, slotMap),
	}
}
func (ast SubexASTNot) String() string {
	return fmt.Sprintf("(%v)!", ast.Content)
}

// Does nothing
type SubexASTEmpty struct {}
func (ast SubexASTEmpty) compileWith(next SubexState, slotMap *SlotMap) 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) SubexState {
	return &SubexCaptureBeginState {
		next: ast.Content.compileWith(&SubexDiscardState {next}, slotMap),
	}
}
func (ast SubexASTDiscard) String() string {
	return fmt.Sprintf("(%v)$_", ast.Content)
}