package fmlib

You can search for identifiers within the package.

in-package search v0.2.0

fmlib
- Fmlib

Legend:
Library
Module
Module type
Parameter
Class
Class type

The final parser.

include Interfaces.PARSER
  with type token = Token.t
   and type final = Final.t
   and type expect = Expect.t
   and type semantic = Semantic.t
   and type state = State.t

A parser p is a sink of token. As long as it signals needs_more p more token can be pushed into the parser via put token p or the input stream can be ended via put_end p.

If the parser does not need more token (has_ended p is equivalent to not (needs_more p)), then it has either succeeded or failed.

If it has succeeded the final value is available via final p.

There are two types of failure:

Syntax error: In that case failed_expectations p returns the list of failed expectations.

Semantic error: In that case failed_semantic p returns the encountered semantic error.

The function state returns the user state.

The function lookaheads returns a pair. The first part of the pair is an array of unprocessed lookahead token and the second part is a flag indicating if the endtoken has been received via put_end.

type token = Token.t

Token type.

type state = State.t

User state.

type final = Final.t

Type of the final object constructed in case of success.

type expect = Expect.t

Type of a failed expectation.

type semantic = Semantic.t

Type a semantic error.

type t

Type of the final parser.

val needs_more : t -> bool

needs_more p Does the parser p need more token?

val has_ended : t -> bool

has_ended p Has the parser p ended parsing and either succeeded or failed?

has_ended p is the same as not (needs_more p)

val put : token -> t -> t

put token p Push token into the parser p.

Even if the parser has ended, more token can be pushed into the parser. The parser stores the token as lookahead token.

val put_end : t -> t

put_end p Push and end token into the parser p.

val has_succeeded : t -> bool

has_succeeded p Has the parser p succeeded?

val has_failed_syntax : t -> bool

has_failed_syntax p Has the parser p failed with a syntax error?

val has_failed_semantic : t -> bool

has_failed_semantic p Has the parser p failed with a semantic error?

val final : t -> final

final p The final object constructed by the parser p in case of success.

Precondition: has_succeeded p

val failed_expectations : t -> expect list

failed_expectations p The failed expectations due to a syntax error.

Precondition: has_failed_syntax p

val failed_semantic : t -> semantic

failed_semantic p The failed semantic error.

Precondition: has_failed_semantic p

val state : t -> state

state p The user state of the parser p.

Can be called at any time.

val lookaheads : t -> token array * bool

lookaheads p The lookahead token and and end flag of the parser p.

The end flag indicates, if the end token has already been received via put_end p.