_iterate -> iterate_state

_iterate -> iterate_state

src/assertions.jl

@@ -6,7 +6,7 @@ Parsers that do not consume any input can inherit `Assertion{S,T}`.
 abstract type Assertion{S,T} <: CombinedParser{S,T} end
 @inline _leftof(str,i,parser::Assertion,x...) = i
 @inline _rightof(str,i,parser::Assertion,x...) = i
-@inline _iterate(t::Assertion{MatchState}, str, till, posi, next_i, state::MatchState) = nothing
+@inline iterate_state(t::Assertion{MatchState}, str, till, posi, next_i, state::MatchState) = nothing
 
 """
     Base.get(parser::Assertion{MatchState, <:Assertion}, sequence, till, after, i, state)
@@ -33,7 +33,7 @@ re"^"
 """
 struct AtStart <: Assertion{MatchState,AtStart} end
 regex_inner(x::AtStart) = "^"
-_iterate(parser::AtStart, sequence, till, posi, next_i, state::Nothing) =
+iterate_state(parser::AtStart, sequence, till, posi, next_i, state::Nothing) =
     next_i == 1 ? (next_i, MatchState()) : nothing
 
 print_constructor(io::IO, x::AtStart) = print(io,"AtStart")
@@ -51,7 +51,7 @@ re"\$"
 """
 struct AtEnd <: Assertion{MatchState,AtEnd} end
 regex_inner(x::AtEnd) = "\$"
-_iterate(parser::AtEnd, sequence, till, posi, next_i, state::Nothing) =
+iterate_state(parser::AtEnd, sequence, till, posi, next_i, state::Nothing) =
     next_i > till ? (next_i, MatchState()) : nothing
 print_constructor(io::IO, x::AtEnd) = print(io,"AtEnd")
 
@@ -73,7 +73,7 @@ struct Never <: Assertion{MatchState,Never} end
 regex_prefix(x::Never) = "(*"
 regex_inner(x::Never) = "FAIL"
 regex_suffix(x::Never) = ")"
-_iterate(x::Never,str,posi, next_i,till,state::Nothing) =
+iterate_state(x::Never,str,posi, next_i,till,state::Nothing) =
     nothing
 
 
@@ -97,9 +97,8 @@ children(x::Union{Never,Always}) = tuple()
 regex_prefix(x::Always) = ""
 regex_inner(x::Always) = ""
 regex_suffix(x::Always) = ""
-_iterate(parser::Always, str, till, posi, next_i, s::Nothing) =
+iterate_state(parser::Always, str, till, posi, next_i, s::Nothing) =
     next_i, MatchState()
-##_iterate(parser::Never, str, till, posi, next_i, s) = nothing
 
 
 Base.show(io::IO, x::Union{AtStart,AtEnd,Never,Always}) =
@@ -147,8 +146,8 @@ julia> parse(la*AnyChar(),"peek")
         end
 end
 regex_prefix(x::PositiveLookahead) = "(?="*regex_prefix(x.parser)
-function _iterate(t::PositiveLookahead, str, till, posi, next_i, state)
-    r = _iterate(t.parser, str, till, posi, tuple_pos(state,posi), tuple_state(state))
+function iterate_state(t::PositiveLookahead, str, till, posi, next_i, state)
+    r = iterate_state(t.parser, str, till, posi, tuple_pos(state,posi), tuple_state(state))
     if r === nothing
         nothing
     else
@@ -186,8 +185,8 @@ julia> parse(la*AnyChar(),"seek")
         end
 end
 regex_prefix(x::NegativeLookahead) = "(?!"*regex_prefix(x.parser)
-function _iterate(t::NegativeLookahead, str, till, posi, next_i, state::Nothing)
-    r = _iterate(t.parser, str, till, posi, next_i, nothing)
+function iterate_state(t::NegativeLookahead, str, till, posi, next_i, state::Nothing)
+    r = iterate_state(t.parser, str, till, posi, next_i, nothing)
     if r === nothing
         next_i,MatchState()
     else

src/caseless.jl

@@ -50,5 +50,5 @@ Match parser on [`CharMappedString`](https://github.com/gkappler/LazyStrings.jl)
 end
 children(x::MappedSequenceParser) = tuple(x.parser, x.f)
 
-@inline _iterate(parser::MappedSequenceParser, sequence, till, posi,after,state) =
-    _iterate(parser.parser, lmap(parser.f,sequence), till,posi,after,state)
+@inline iterate_state(parser::MappedSequenceParser, sequence, till, posi,after,state) =
+    iterate_state(parser.parser, lmap(parser.f,sequence), till,posi,after,state)

src/constant.jl

@@ -41,13 +41,13 @@ _lowercase(x::CombinedParser) = x
 
 _lowercase(x::ConstantParser) = ConstantParser(lowercase(x.parser))
 
-@inline _iterate(parser::ConstantParser, sequence, till, posi, next_i, state::Nothing) =
-    _iterate_constant(parser,sequence,till,posi, next_i, state)
+@inline iterate_state(parser::ConstantParser, sequence, till, posi, next_i, state::Nothing) =
+    iterate_state_constant(parser,sequence,till,posi, next_i, state)
 
-@inline _iterate_constant(parser::ConstantParser, sequence, till, posi, next_i, state) =
-    _iterate_constant(parser.parser,sequence,till,posi, next_i, state, _ncodeunits(parser))
+@inline iterate_state_constant(parser::ConstantParser, sequence, till, posi, next_i, state) =
+    iterate_state_constant(parser.parser,sequence,till,posi, next_i, state, _ncodeunits(parser))
 
-@inline function _iterate_constant(p::AbstractString, sequence, till, posi, next_i, state::Nothing,L)
+@inline function iterate_state_constant(p::AbstractString, sequence, till, posi, next_i, state::Nothing,L)
     till, posi, next_i
     j::Int = next_i
     k::Int = 1
@@ -62,7 +62,7 @@ _lowercase(x::ConstantParser) = ConstantParser(lowercase(x.parser))
     return j, MatchState()
 end
 
-@inline function _iterate_constant(parser, sequence, till, posi, next_i, state::Nothing, L)
+@inline function iterate_state_constant(parser, sequence, till, posi, next_i, state::Nothing, L)
     state !== nothing || next_i>till || next_i < 1 && return nothing
     if next_i<=till && ismatch(sequence[next_i],parser)
         next_i+L, MatchState()

src/deepmap.jl

@@ -215,7 +215,7 @@ substitute(name::Symbol) =
     Substitution(name)
 substitute(name::AbstractString) = 
     Substitution(Symbol(name))
-CombinedParsers._iterate(parser::Substitution, a...) = error(" call substitute")
+CombinedParsers.iterate_state(parser::Substitution, a...) = error(" call substitute")
 function CombinedParsers.print_constructor(io::IO, x::Substitution)
     printstyled(io, x.name, color=:red)
     print(io, " call substitute!")

src/indexed_captures.jl

@@ -22,14 +22,14 @@ function print_constructor(io::IO, x::ParserWithCaptures)
           ( length(x.subroutines)>0 ? " with $(length(x.subroutines)) capturing groups" : "" ) )
 end
 """
-    _iterate(p::ParserWithCaptures, sequence::SequenceWithCaptures,a...)
+    iterate_state(p::ParserWithCaptures, sequence::SequenceWithCaptures,a...)
 
 `Base.empty!(sequence)` before iteration.
 (Why?)
 """
-function _iterate(p::ParserWithCaptures, sequence::SequenceWithCaptures,a...)
+function iterate_state(p::ParserWithCaptures, sequence::SequenceWithCaptures,a...)
     Base.empty!(sequence)
-    _iterate(p.parser, sequence, a...)
+    iterate_state(p.parser, sequence, a...)
 end
 
 """
@@ -49,8 +49,6 @@ function ParserWithCaptures(x)
     isempty(r.subroutines) ? r.parser : r
 end
 
-# _iterate(parser::ParserWithCaptures, sequence::AbstractString, till, next_i, after, state::Nothing) =
-#     _iterate(parser, sequence, till, next_i, next_i, state)
 
 SequenceWithCaptures(x,cs::CombinedParser) = x
 function SequenceWithCaptures(x,cs::ParserWithCaptures)

src/match.jl

@@ -45,8 +45,8 @@ Base.eltype(T::Type{<:MatchesIterator{P,S}}) where {P,S} =
 Base.IteratorSize(::Type{<:MatchesIterator}) =
     Base.SizeUnknown()
 
-@inline _iterate(mi::MatchesIterator,a...) =
-    _iterate(mi.parser, mi.sequence, mi.till, a...)
+@inline iterate_state(mi::MatchesIterator, posi, a...) =
+    iterate_state(mi.parser, mi.sequence, mi.till, posi, a...)
 
 Base.get(x::MatchesIterator, a...)=
     get(x.parser,x.sequence,x.till, a...)
@@ -152,8 +152,8 @@ end
 
 
 result_type(::Type{<:ParseMatch{P}}) where P = result_type(P)
-@inline _iterate(m::ParseMatch) =
-    _iterate(m.parsings,m.offset,m.after,m.state)
+@inline iterate_state(m::ParseMatch) =
+    iterate_state(m.parsings,m.offset,m.after,m.state)
 
 """
     Base.get(x::ParseMatch{<:MatchTuple})
@@ -183,10 +183,10 @@ Base.IteratorSize(::Type{<:ParseMatch}) = Base.SizeUnknown()
 """
     Base.iterate(x::ParseMatch[, m::ParseMatch=x])
 
-Returns next [`ParseMatch`](@ref) at `m.offset` after `m.state`, see [`_iterate`](@ref)(m).
+Returns next [`ParseMatch`](@ref) at `m.offset` after `m.state`, see [`iterate_state`](@ref)(m).
 """
 function Base.iterate(x::ParseMatch, m=x)
-    i = _iterate(m)
+    i = iterate_state(m)
     parsematch_tuple(m.parsings,m.offset,i)
 end
 
@@ -219,12 +219,12 @@ Return first next [`ParseMatch`](@ref) (as return value and state) or `nothing`
 @inline function Base.iterate(m::MatchesIterator, s::ParseMatch)
     offset,after = s.offset, s.after
     stop = m.stop
-    state = _iterate(m,offset,after,s.state)
+    state = iterate_state(m,offset,after,s.state)
     while offset <= stop+1 && state===nothing
         # state = iterate(m.parsings,(offset,nothing))
         offset > stop && break
         offset = _nextind(m.sequence,offset)
-        state = _iterate(m,offset,offset,nothing)
+        state = iterate_state(m,offset,offset,nothing)
     end
     parsematch_tuple(m,offset,state)
 end
@@ -290,7 +290,7 @@ function Base.tryparse(p::AbstractToken, s, pos...; kw...)
 end
 
 function tryparse_pos(p,s, idx=firstindex(s), till=lastindex(s); kw...)
-    i = _iterate(wrap(p; kw...),s,till,idx,idx,nothing)
+    i = iterate_state(wrap(p; kw...),s,till,idx,idx,nothing)
     i === nothing && return nothing
     get(p,s,till,tuple_pos(i),1,tuple_state(i)), tuple_pos(i)
 end

src/memoize.jl

@@ -44,20 +44,14 @@ end
 _deepmap_parser(f::Function,mem::AbstractDict,x::MemoizingParser,a...;kw...) =
     MemoizingParser(deepmap_parser(f,mem,x.parser,a...;kw...))
 
-@inline function _iterate(parser::MemoizingParser, sequence::String, till, posi,after,state)
+@inline function iterate_state(parser::MemoizingParser, sequence, till, posi,after,state)
     error("for memoizing, wrap sequence in WithMemory. Todo: automize wrapping in root parser with optimize")
-    _iterate(parser.parser, sequence, till,posi,after,state)
+    iterate_state(parser.parser, sequence, till,posi,after,state)
 end
 
-@inline Base.@propagate_inbounds function _iterate(parser::MemoizingParser, sequence::WithMemory, till, posi,after,state)
+@inline Base.@propagate_inbounds function iterate_state(parser::MemoizingParser, sequence::WithMemory, till, posi,after,state)
     get!(sequence.mem,(parser.parser,posi,state)) do
-        copy(_iterate(parser.parser, sequence,till,posi,after,state))
-    end
-end
-
-@inline Base.@propagate_inbounds function _iterate(parser, sequence::WithMemory, till, posi,after,state)
-    get!(sequence.mem,(parser,posi,state)) do
-        copy(_iterate(parser, sequence,till,posi,after,state))
+        copy(iterate_state(parser.parser, sequence,till,posi,after,state))
     end
 end
 

src/pcre.jl

@@ -96,7 +96,7 @@ end
 Base.isascii(x::CharWithOptions) = isascii(x.x)
 Base.isprint(x::CharWithOptions) = isprint(x.x)
 
-@inline function _iterate(p::CharWithOptions, sequence, till, posi, next_i, state::Nothing, nc=0)
+@inline function iterate_state(p::CharWithOptions, sequence, till, posi, next_i, state::Nothing, nc=0)
     @inbounds sc,j=iterate(sequence,posi)
     if ismatch(p,sc)
         j, MatchState()
@@ -292,8 +292,8 @@ end
         till, after, i, state)
 
 
-@inline function _iterate(parser::ParserOptions, sequence, till, posi, next_i, state)
-    _iterate(parser.parser,
+@inline function iterate_state(parser::ParserOptions, sequence, till, posi, next_i, state)
+    iterate_state(parser.parser,
              with_options(parser.set_flags,parser.unset_flags,sequence),
              till, posi, next_i, state)
 end
@@ -425,8 +425,8 @@ Either(
 on_options(flags::Integer,p) =
     OnOptionsParser(parser(p),UInt32(flags))
 
-@inline function _iterate(parser::OnOptionsParser, sequence, till, posi, next_i, state)
-    _iterate(parser.parser,
+@inline function iterate_state(parser::OnOptionsParser, sequence, till, posi, next_i, state)
+    iterate_state(parser.parser,
              (if_options(parser.flags,sequence)), till, posi, next_i, state)
 end
 

src/re.jl

@@ -12,7 +12,7 @@ import LazyStrings: reversed, reverse_index
 
 import ..CombinedParsers: LeafParser, WrappedParser, CombinedParser, ConstantParser, Either, SideeffectParser
 import ..CombinedParsers: parser, prune_captures, deepmap_parser, _deepmap_parser, print_constructor
-import ..CombinedParsers: _iterate, _iterate_constant
+import ..CombinedParsers: iterate_state, iterate_state_constant
 import ..CombinedParsers: regex_prefix, regex_suffix, regex_inner, _regex_string, regex_string, _log_names
 import ..CombinedParsers: state_type, leftof, tuple_pos, tuple_state
 import ..CombinedParsers: _prevind, _nextind, _leftof, _rightof
@@ -26,7 +26,7 @@ include("pcre.jl")
 SequenceWithCaptures ensapsulates a sequence to be parsed, and parsed captures.
 
 This struct will allow for captures a sequence-level state.
-For next version, a match-level state passed as `iterate_state` argument is considered.
+For next version, a match-level state passed as iterate_state argument is considered.
 
 See also [`ParserWithCaptures`](@ref)
 """
@@ -138,8 +138,8 @@ end
 Base.get(x::Capture, sequence, till, after, i, state) =
     get(x.parser, sequence, till, after, i, state)
 
-@inline function _iterate(parser::Capture, sequence, till, posi, next_i, state)
-    r = _iterate(parser.parser, sequence, till, posi, next_i, state)
+@inline function iterate_state(parser::Capture, sequence, till, posi, next_i, state)
+    r = iterate_state(parser.parser, sequence, till, posi, next_i, state)
     if r !== nothing ## set only if found (e.g. if repeated capture capture last)
         set_capture(sequence,parser.index,posi,_prevind(sequence,tuple_pos(r)))
     elseif state !== nothing
@@ -248,17 +248,17 @@ function capture_substring(p::Backreference, sequence::SequenceWithCaptures)
     SubString(sequence.x, sequence.captures[index][end])
 end
 
-@inline function _iterate(p::Union{Backreference,ParserOptions{<:Backreference}},
+@inline function iterate_state(p::Union{Backreference,ParserOptions{<:Backreference}},
                           sequence::SequenceWithCaptures, till,
                           posi, next_i, state::Nothing)
-    r = _iterate_constant(
+    r = iterate_state_constant(
         ConstantParser(capture_substring(p, sequence)),
         sequence, till, posi, next_i, state)
     r === nothing && return nothing
     tuple_pos(r), tuple_pos(r)-next_i
 end
 
-@inline function _iterate(p::Union{Backreference,ParserOptions{<:Backreference}},
+@inline function iterate_state(p::Union{Backreference,ParserOptions{<:Backreference}},
                           sequence::SequenceWithCaptures, till,
                           posi, next_i, state)
     return nothing
@@ -267,7 +267,7 @@ end
 
 
 
-_iterate_condition(p::Backreference, sequence, till, posi, next_i, state) =
+iterate_state_condition(p::Backreference, sequence, till, posi, next_i, state) =
     resolve_index(p, sequence)>0
 
 
@@ -310,7 +310,7 @@ regex_inner(x::Subroutine) = ""
 _deepmap_parser(::Function,mem::AbstractDict,x::Subroutine) = x
 
 
-function _iterate_condition(cond::Subroutine, sequence, till, posi, next_i, state)
+function iterate_state_condition(cond::Subroutine, sequence, till, posi, next_i, state)
     sequence.state === nothing && return false
     if cond.name === nothing && cond.index < 0
         true
@@ -342,8 +342,8 @@ Index of a subroutine.
 index(parser::Subroutine,sequence) =
     parser.index <= 0 ? first(sequence.names[parser.name]) : parser.index
 
-@inline function _iterate(parser::Subroutine, sequence::SequenceWithCaptures, till, posi, next_i, state)
-    _iterate(
+@inline function iterate_state(parser::Subroutine, sequence::SequenceWithCaptures, till, posi, next_i, state)
+    iterate_state(
         sequence.subroutines[index(parser,sequence)].parser,
         copy_captures(sequence,parser), till, posi, next_i, state)
 end
@@ -386,7 +386,7 @@ _deepmap_parser(f::Function,mem::AbstractDict,x::DupSubpatternNumbers, a...;kw..
 
 export Conditional
 """
-Conditional parser, `_iterate` cycles conditionally on `_iterate_condition` through matches in field `yes` and `no` respectively.
+Conditional parser, `iterate_state` cycles conditionally on `iterate_state_condition` through matches in field `yes` and `no` respectively.
 """
 @auto_hash_equals struct Conditional{C,Y,N,S,T} <: CombinedParser{S,T}
     condition::C
@@ -419,10 +419,10 @@ end
 @inline Base.get(parser::Conditional, sequence, till, after, i, state) =
     get(state.first == :yes ? parser.yes : parser.no, sequence, till, after, i, state.second)
 
-_iterate_condition(cond::WrappedParser, sequence, till, posi, next_i, state) =
-    _iterate_condition(cond.parser, sequence, till, posi, next_i, state)
-_iterate_condition(cond, sequence, till, posi, next_i, state) =
-    _iterate(cond, sequence, till, posi, next_i, state) !== nothing
+iterate_state_condition(cond::WrappedParser, sequence, till, posi, next_i, state) =
+    iterate_state_condition(cond.parser, sequence, till, posi, next_i, state)
+iterate_state_condition(cond, sequence, till, posi, next_i, state) =
+    iterate_state(cond, sequence, till, posi, next_i, state) !== nothing
 
 
 
@@ -434,17 +434,17 @@ end
     rightof(str,i,state.first == :yes ? parser.yes : parser.no, state.second)
 end
 
-@inline function _iterate(parser::Conditional, sequence, till, posi, next_i, state::Nothing)
-    c = _iterate_condition(parser.condition, sequence, till, posi, next_i, state)
+@inline function iterate_state(parser::Conditional, sequence, till, posi, next_i, state::Nothing)
+    c = iterate_state_condition(parser.condition, sequence, till, posi, next_i, state)
     cparse = c ? parser.yes : parser.no
-    s = _iterate(cparse,
+    s = iterate_state(cparse,
                  sequence, till, posi, next_i, state)
     s === nothing && return nothing
     tuple_pos(s), (c ? :yes : :no) => tuple_state(s)
 end
 
-@inline function _iterate(parser::Conditional, sequence, till, posi, next_i, state::Pair)
-    _iterate(state.first == :yes ? parser.yes : parser.no, sequence, till, posi, next_i, state.second)
+@inline function iterate_state(parser::Conditional, sequence, till, posi, next_i, state::Pair)
+    iterate_state(state.first == :yes ? parser.yes : parser.no, sequence, till, posi, next_i, state.second)
 end
 
 include("indexed_captures.jl")