Module Character_parser.Advanced

Advanced Parser.

Parameters

Signature

Modules and Types

module Context : CONTEXT with type msg = Context_msg.t
type final = Final.t
type token = char option

Combinators

include COMBINATORS with type expect = Expect.t and type semantic = Semantic.t and type state = State.t and type context = Context_msg.t

Basic Combinators

include Generic_parser.COMBINATORS with type expect = Expect.t with type semantic = Semantic.t
type 'a t
type expect = Expect.t
type semantic = Semantic.t
val return : 'a -> 'a t
val succeed : 'a -> 'a t
val unexpected : expect -> 'a t
val fail : semantic -> 'a t
val consumer : 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
val (<|>) : 'a t -> 'a t -> 'a t
val (<?>) : 'a t -> expect -> 'a t
val backtrackable : 'a t -> expect -> 'a t
val not_followed_by : 'a t -> expect -> unit t
val optional : 'a t -> 'a option t
val one_of : 'a t list -> 'a t
val zero_or_more : 'a t -> 'a list t
val one_or_more : 'a t -> 'a list t
val one_or_more_separated : 'a t -> _ t -> 'a list t
val zero_or_more_separated : 'a t -> _ t -> 'a list t
val skip_zero_or_more : 'a t -> int t
val skip_one_or_more : 'a t -> int t
val (|=) : ('a -> 'b) t -> 'a t -> 'b t
val (|.) : 'a t -> _ t -> 'a t

Position and State Combinators

val get_position : Position.t t
val located : 'a t -> 'a Located.t t
type state = State.t
val get_state : state t
val update : (state -> state) -> unit t

Indentation Combinators

val absolute : 'a t -> 'a t
val indented : bool -> 'a t -> 'a t
val detached : 'a t -> 'a t
val get_bounds : (int * int option) t
val one_or_more_aligned : 'a t -> 'a list t
val zero_or_more_aligned : 'a t -> 'a list t
val skip_one_or_more_aligned : 'a t -> int t
val skip_zero_or_more_aligned : 'a t -> int t

Context Combinator

type context = Context_msg.t
val in_context : context -> 'a t -> 'a t

Character Combinators

val expect : (char -> bool) -> expect -> char t
val expect_end : expect -> unit t
val whitespace_char : expect -> char t
val whitespace : expect -> int t
val one_of_chars : string -> expect -> unit t
val string : string -> (int -> expect) -> unit t
val char : char -> expect -> unit t
val space : expect -> unit t
val letter : expect -> char t
val digit : expect -> char t
val word : (char -> bool) -> (char -> bool) -> expect -> string t

Parser

During Parsing

include PARSER
type parser

Parser Type

val needs_more : parser -> bool

Does the parser need more tokens (i.e. either put_char or put_end)?

val has_ended : parser -> bool

Has the parser terminated (opposite of needs_more p)?

val has_succeeded : parser -> bool

Has the parser succeeded

val position : parser -> Position.t

The current position.

val line : parser -> int

The current line.

val column : parser -> int

The current column.

val put_char : parser -> char -> parser

put_char p c feeds the parser p with the character token c. Only possible if needs_more p is valid.

val put_end : parser -> parser

put_end p signals to the parser p the end of stream. Only possible if needs_more p is valid.

val state : parser -> State.t

The state of the parser.

Terminated Parser

val result : parser -> final option

The result the parser has produced which is either a final value or a list of dead ends. Only valid if the parser has terminated.

val error : parser -> Error.t
val lookahead : parser -> token list

The list of tokens (i.e. optional characters) which the parser has not processed at the point of termination.

Create and Run the Parser

val make : final t -> State.t -> parser

make pc st makes a parser from a parser combinator pc and the initial state st.

val run : final t -> State.t -> string -> parser

run pc st str makes a parser from the combinator pc and the initial state st and runs the parser on the string str.