genlex(3) [centos man page]

Genlex(3)							   OCaml library							 Genlex(3)

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 OCaml, 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 | ...

       One should notice that the use of the parser keyword and associated notation for streams are only available through camlp4 extensions. This
       means that one has to preprocess its sources e. g. by using the -pp command-line switch of the compilers.

       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							    2014-06-09								 Genlex(3)

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)