genlex(3o) [debian man page]

Genlex(3o)							   OCaml library							Genlex(3o)

NAME

       Genlex - A generic lexical analyzer.

Module
       Module	Genlex

Documentation
       Module Genlex
	: sig end

       A generic lexical analyzer.

       This  module  implements a simple ``standard'' lexical analyzer, presented as a function from character streams to token streams. It imple-
       ments roughly the lexical conventions of Caml, but is parameterized by the set of keywords of your language.

       Example: a lexer suitable for a desk calculator is obtained by let lexer = make_lexer ["+";"-";"*";"/";"let";"="; ( ; ) ]

       The associated parser would be a function from token stream to, for instance, int , and would have rules such as:

       let parse_expr = parser [< 'Int n >] -> n | [< 'Kwd ( ; n = parse_expr; 'Kwd ) >] -> n | [< n1 = parse_expr; n2 = parse_remainder n1 >]	->
       n2 and parse_remainder n1 = parser [< 'Kwd + ; n2 = parse_expr >] -> n1+n2 | ...

       type token =
	| Kwd of string
	| Ident of string
	| Int of int
	| Float of float
	| String of string
	| Char of char

       The  type of tokens. The lexical classes are: Int and Float for integer and floating-point numbers; String for string literals, enclosed in
       double quotes; Char for character literals, enclosed in single quotes; Ident for identifiers (either sequences of letters,  digits,  under-
       scores  and quotes, or sequences of ``operator characters'' such as + , * , etc); and Kwd for keywords (either identifiers or single ``spe-
       cial characters'' such as ( , } , etc).

       val make_lexer : string list -> char Stream.t -> token Stream.t

       Construct the lexer function. The first argument is the list of keywords. An identifier s is returned as Kwd s if s belongs to  this  list,
       and  as	Ident  s  otherwise.   A  special character s is returned as Kwd s if s belongs to this list, and cause a lexical error (exception
       Parse_error ) otherwise. Blanks and newlines are skipped.  Comments delimited by (* and *) are skipped as well, and can be nested.

OCamldoc							    2012-06-26								Genlex(3o)

Stream(3)							   OCaml library							 Stream(3)

NAME

       Stream - Streams and parsers.

Module
       Module	Stream

Documentation
       Module Stream
	: sig end

       Streams and parsers.

       type 'a t

       The type of streams holding values of type 'a .

       exception Failure

       Raised by parsers when none of the first components of the stream patterns is accepted.

       exception Error of string

       Raised by parsers when the first component of a stream pattern is accepted, but one of the following components is rejected.

       === Stream builders ===

       val from : (int -> 'a option) -> 'a t

       Stream.from  f  returns	a  stream  built  from the function f .  To create a new stream element, the function f is called with the current
       stream count. The user function f must return either Some <value> for a value or None to specify the end of the stream.

       val of_list : 'a list -> 'a t

       Return the stream holding the elements of the list in the same order.

       val of_string : string -> char t

       Return the stream of the characters of the string parameter.

       val of_channel : Pervasives.in_channel -> char t

       Return the stream of the characters read from the input channel.

       === Stream iterator ===

       val iter : ('a -> unit) -> 'a t -> unit

       Stream.iter f s scans the whole stream s, applying function f in turn to each stream element encountered.

       === Predefined parsers ===

       val next : 'a t -> 'a

       Return the first element of the stream and remove it from the stream. Raise Stream.Failure if the stream is empty.

       val empty : 'a t -> unit

       Return () if the stream is empty, else raise Stream.Failure .

       === Useful functions ===

       val peek : 'a t -> 'a option

       Return Some of "the first element" of the stream, or None if the stream is empty.

       val junk : 'a t -> unit

       Remove the first element of the stream, possibly unfreezing it before.

       val count : 'a t -> int

       Return the current count of the stream elements, i.e. the number of the stream elements discarded.

       val npeek : int -> 'a t -> 'a list

       npeek n returns the list of the n first elements of the stream, or all its remaining elements if less than n elements are available.

OCamldoc							    2014-06-09								 Stream(3)