Module Grammar: extensible grammars

 

type g;;

The type for grammars, holding entries.

val create : Token.lexer -> g;;

Create a new grammar, without keywords, using the lexer given as parameter.

val keywords : g -> (string * int) list;;

Return the current list of keywords of the grammar (the integer is the number of times it is used).

module Entry :
  sig
    type 'a e;;
    val create : g -> string -> 'a e;;
    val parse : 'a e -> char Stream.t -> 'a;;
    val parse_token : 'a e -> Token.t Stream.t -> 'a;;
    val name : 'a e -> string;;
    val of_parser : g -> string -> (Token.t Stream.t -> 'a) -> 'a e;;
    val print : 'a e -> unit;;
    val find : 'a e -> string -> Obj.t e;;
    external obj : 'a e -> Gramext.g_entry = "%identity";;
  end
;;

Module to handle entries.
* Entry.e is the type for entries returning values of type 'a.
* Entry.create g n creates a new entry named n in the grammar g.
* Entry.parse e returns the stream parser of the entry e.
* Entry.parse_token e returns the token parser of the entry e.
* Entry.name e returns the name of the entry e.
* Entry.of_parser g n p makes an entry from a token stream parser.
* Entry.print e displays the entry e using Format.
* Entry.find e s finds the entry named s in e's rules.
* Entry.obj e converts an entry into a Gramext.g_entry allowing
to see what it holds (Gramext is visible, but not documented).

val of_entry : 'a Entry.e -> g;;

Return the grammar associated with an entry.

val warning_verbose : bool ref;;

Flag for displaying warnings while extension; default = True

val strict_parsing : bool ref;;

Flag to apply strict parsing, without trying to recover errors; default = False

Clearing grammars and entries

module Unsafe :
  sig
    val reinit_gram : g -> Token.lexer -> unit;;
    val clear_entry : 'a Entry.e -> unit;;
  end
;;

Module for clearing grammars and entries. To be manipulated with care, because: 1) reinitializing a grammar destroys all keywords and its entries may not work any more; 2) clearing an entry does not destroy the keywords used only by itself.
* Unsafe.reinit_gram g lex removes the keywords of the grammar
and sets lex as a new lexer for g. Warning: the lexer
itself is not reinitialized.
* Unsafe.clear_entry e removes all rules of the entry e.

Functions called by statements EXTEND and DELETE RULE

These functions are not to be used directly. The statements EXTEND and DELETE_RULE use these functions generating type constraints which ensure the typing consistency.

val extend :
  (Gramext.g_entry * Gramext.position option *
     (string option * Gramext.g_assoc option *
        (Gramext.g_symbol list * Gramext.g_action) list)
       list)
    list ->
    unit;;
val delete_rule : 'a Entry.e -> Gramext.g_symbol list -> unit;;

Functorial interface

Alternative for grammars use. Grammars are not yet Ocaml values: there is no type for them. Modules generated preserve the rule "an entry cannot call an entry of another grammar" by normal Ocaml typing.

module type LexerType = sig val lexer : Token.lexer;; end;;

The input signature for the functor Grammar.Make. lexer is the lexer used.

module type S =
  sig
    type parsable;;
    val parsable : char Stream.t -> parsable;;
    val keywords : unit -> (string * int) list;;
    module Entry :
      sig
        type 'a e;;
        val create : string -> 'a e;;
        val parse : 'a e -> parsable -> 'a;;
        val parse_token : 'a e -> Token.t Stream.t -> 'a;;
        val name : 'a e -> string;;
        val of_parser : string -> (Token.t Stream.t -> 'a) -> 'a e;;
        val print : 'a e -> unit;;
        external obj : 'a e -> Gramext.g_entry = "%identity";;
      end
    ;;
    module Unsafe :
      sig
        val reinit_gram : Token.lexer -> unit;;
        val clear_entry : 'a Entry.e -> unit;;
      end
    ;;
    val extend :
      'a Entry.e -> Gramext.position option ->
        (string option * Gramext.g_assoc option *
           (Gramext.g_symbol list * Gramext.g_action) list)
          list ->
        unit;;
    val delete_rule : 'a Entry.e -> Gramext.g_symbol list -> unit;;
  end
;;

Signature type of the functor Grammar.Make. The types and functions are almost the same than in generic interface, but:
* Grammars are not values. Functions holding a grammar as parameter
do not have this parameter yet.
* The type parsable is used in function parse instead of
the char stream, avoiding the possible loss of tokens.

module Make : functor (L : LexerType) -> S;;