Previous  Up  Next

Module Parser


module Parser: sig  end
Parser
exception Error of string
Parser raises Error if it is unable to parse the given string.

type 'a t = {
   lex : Lexing.lexbuf -> 'a;
   deparse : 'a -> string;
   complete : Lexing.lexbuf -> string list;
   accept : 'a -> 'a;
   desc : string;
}
A type of information that can be processed by the parser. It knows which values are acceptable and sometimes knows how to complete a word. Some such types will also know how to display themselves in the menu.
val int : ?max:int -> ?min:int -> unit -> int t
Simple command and variable params
val float : unit -> float t
val unit : unit t
val bool : bool t
val string : string t
val option : 'a t -> 'a option t
For optional parameters in commands
val pair : 'a t -> 'b t -> ('a * 'b) t
For functions with more arguments
val triple : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
val quadruple : 'a t ->
       'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t
val pentuple : 'a t ->
       'b t ->
       'c t ->
       'd t -> 'e t -> ('a * 'b * 'c * 'd * 'e) t
val accept_only : 'a list -> 'a t -> 'a t
If we want to accept only some arguments of the given type
val callback : ('a -> unit) -> 'a t -> 'a t
Adds a callback to a change.
val command : (unit -> unit) t
For commands or variables taking commands as parameters. The command can be a simple command (not taking arguments) or a one in {such} brackets with params inside. Completes to a command and returns the parsed command as argument
val variable : string t
For commands that can take variable names as parameters.
val add_command : string -> 'a t -> string -> ('a -> unit) -> unit
add_command name type description handler adds the command to the list of commands. Examples of usage in MLGame:

Parser.add_command "exec" Parser.string "executes the given script" exec

Parser.add_command "bind_global" (Parser.pair Key.parser Parser.command) "Bind_global binds..." my_function;;

Parser.add_command "disconnect" Net.local_player_parser "This fun.." fun;;

val add_variable : string -> 'a t -> 'a -> 'a Pervasives.ref
val get : string -> string
val set : string -> string -> unit
val parse : string -> unit -> unit
parse expression Parses a given string and returns a simple function that executes the parsed expression.
Raises Error if something went wrong.
val available_completions : string -> string list
Returns available command completions of given string
val create_log : string -> string -> bool -> string -> unit
create_log name prefix init creates a debug logger that can be switched on and off via the parser.
val sextuple : 'a t ->
       'b t ->
       'c t ->
       'd t ->
       'e t -> 'f t -> ('a * 'b * 'c * 'd * 'e * 'f) t
val septuple : 'a t ->
       'b t ->
       'c t ->
       'd t ->
       'e t ->
       'f t -> 'g t -> ('a * 'b * 'c * 'd * 'e * 'f * 'g) t
val octuple : 'a t ->
       'b t ->
       'c t ->
       'd t ->
       'e t ->
       'f t ->
       'g t ->
       'h t -> ('a * 'b * 'c * 'd * 'e * 'f * 'g * 'h) t
val nonuple : 'a t ->
       'b t ->
       'c t ->
       'd t ->
       'e t ->
       'f t ->
       'g t ->
       'h t ->
       'i t -> ('a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i) t