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 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), &SubexCopyNonStringAtomState {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) }