char(3o) [sunos man page]

Char(3o)                                                           OCaml library                                                          Char(3o)

NAME

       Char - Character operations.

Module
       Module   Char

Documentation
       Module Char
        : sig end

       Character operations.

       val code : char -> int

       Return the ASCII code of the argument.

       val chr : int -> char

       Return the character with the given ASCII code.  Raise Invalid_argument Char.chr if the argument is outside the range 0--255.

       val escaped : char -> string

       Return a string representing the given character, with special characters escaped following the lexical conventions of Objective Caml.

       val lowercase : char -> char

       Convert the given character to its equivalent lowercase character.

       val uppercase : char -> char

       Convert the given character to its equivalent uppercase character.

       type t = char

       An alias for the type of characters.

       val compare : t -> t -> int

       The  comparison function for characters, with the same specification as Pervasives.compare .  Along with the type t , this function compare
       allows the module Char to be passed as argument to the functors Set.Make and Map.Make .

OCamldoc                                                            2012-06-26                                                            Char(3o)

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)