package subex import ( "fmt" "main/walk" ) // A node in the AST of a subex type SubexAST interface { compileWith(next SubexState) 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) SubexState { return ast.First.compileWith(ast.Second.compileWith(next)) } 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) SubexState { return &SubexCaptureBeginState { next: ast.Match.compileWith(&SubexStoreEndState { slot: ast.Slot, next: next, }), } } 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) SubexState { return &SubexGroupState { ast.First.compileWith(next), ast.Second.compileWith(next), } } 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) SubexState { min, _ := cr.minmax() if min != 0 { return content.compileWith(cr.decrement().compile(content, next)) } if cr.Start == -1 { state := &SubexGroupState {nil, next} state.first = content.compileWith(state) return state } if cr.End == -1 { state := &SubexGroupState {next, nil} state.second = content.compileWith(state) return state } if cr.End == 0 { state := next; for i := 0; i < cr.Start; i += 1 { state = &SubexGroupState { content.compileWith(state), next, } } return state } else { state := next; for i := 0; i < cr.End; i += 1 { state = &SubexGroupState { next, content.compileWith(state), } } 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) SubexState { var state SubexState = &SubexDeadState{} for _, convex := range ast.Acceptable { state = &SubexGroupState {state, convex.compile(ast.Content, next)} } return state } // Read in a single specific Atom and output it unchanged type SubexASTCopyAtom struct { Atom walk.Atom } func (ast SubexASTCopyAtom) compileWith(next SubexState) SubexState { return &SubexCopyAtomState{ atom: ast.Atom, next: next, } } // Read in a single atom that must be a boolean and output it unchanged type SubexASTCopyBool struct {} func (ast SubexASTCopyBool) compileWith(next SubexState) SubexState { return &SubexCopyBoolState {next} } // Read in a single atom that must be a number and output it unchanged type SubexASTCopyNumber struct {} func (ast SubexASTCopyNumber) compileWith(next SubexState) SubexState { return &SubexCopyNumberState {next} } // Read in a single atom that must be a string atom and output it unchanged type SubexASTCopyStringAtom struct {} func (ast SubexASTCopyStringAtom) compileWith(next SubexState) SubexState { return &SubexCopyStringAtomState {next} } // Read in a full string value and copy it out unchanged // # is equivalent to "_{-0}" type SubexASTCopyString struct {} func (ast SubexASTCopyString) compileWith(next SubexState) SubexState { stringAtomState := &SubexCopyStringAtomState { next: nil, } stringContentState := &SubexGroupState { &SubexCopyAtomState { atom: walk.StringTerminal{}, next: next, }, stringAtomState, } stringAtomState.next = stringContentState return &SubexCopyAtomState { atom: walk.StringTerminal{}, next: stringContentState, } } // Read in a value and copy it out unchanged // , is equivalent to `null`|?|%|#|[`{}[]`] type SubexASTCopyValue struct {} func (ast SubexASTCopyValue) compileWith(next SubexState) SubexState { return &SubexGroupState { SubexASTCopyString{}.compileWith(next), &SubexCopyNonStringAtomState {next}, } } // Read in any single Atom and output it unchanged type SubexASTCopyAny struct {} func (ast SubexASTCopyAny) compileWith(next SubexState) SubexState { return &SubexCopyAnyState{next} } func (ast SubexASTCopyAny) String() string { return "." } // Output a series of Atoms without reading anything from input type SubexASTOutput struct { Replacement []OutputContent } func (ast SubexASTOutput) compileWith(next SubexState) SubexState { return &SubexOutputState{ content: ast.Replacement, next: next, } } // Read in a repeated subex separated by a delimiter. Greedy type SubexASTJoin struct { Content, Delimiter SubexAST } func (ast SubexASTJoin) compileWith(next SubexState) SubexState { afterContentState := &SubexGroupState { nil, next, } manyContentsState := ast.Content.compileWith(afterContentState) afterContentState.first = ast.Delimiter.compileWith(manyContentsState) return &SubexGroupState { manyContentsState, next, } } // 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) SubexState { return &SubexRangeState { parts: ast.Parts, next: next, } } // 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) SubexState { return &SubexCaptureBeginState { next: ast.Content.compileWith(&SubexArithmeticEndState { next: next, calculate: sumValues, }), } } // Like sum but for AND and product type SubexASTProduct struct { Content SubexAST } func (ast SubexASTProduct) compileWith(next SubexState) SubexState { return &SubexCaptureBeginState { next: ast.Content.compileWith(&SubexArithmeticEndState { next: next, calculate: multiplyValues, }), } } // 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) SubexState { return &SubexCaptureBeginState { next: ast.Content.compileWith(&SubexArithmeticEndState { next: next, calculate: negateValues, }), } } // 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) SubexState { return &SubexCaptureBeginState { next: ast.Content.compileWith(&SubexArithmeticEndState { next: next, calculate: reciprocalValues, }), } } // 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) SubexState { return &SubexCaptureBeginState { next: ast.Content.compileWith(&SubexArithmeticEndState { next: next, calculate: notValues, }), } } // Does nothing type SubexASTEmpty struct {} func (ast SubexASTEmpty) compileWith(next SubexState) SubexState { return next }