From a5f03d96eee482cd84861fc8cefff9eb451c0cad Mon Sep 17 00:00:00 2001 From: xleroy Date: Sun, 29 Mar 2009 09:47:11 +0000 Subject: Cleaned up configure script. Distribution of CIL as an expanded source tree with changes applied (instead of original .tar.gz + patches to be applied at config time). git-svn-id: https://yquem.inria.fr/compcert/svn/compcert/trunk@1020 fca1b0fc-160b-0410-b1d3-a4f43f01ea2e --- cil/doc/api/Pretty.html | 268 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 268 insertions(+) create mode 100644 cil/doc/api/Pretty.html (limited to 'cil/doc/api/Pretty.html') diff --git a/cil/doc/api/Pretty.html b/cil/doc/api/Pretty.html new file mode 100644 index 00000000..c9c48c8e --- /dev/null +++ b/cil/doc/api/Pretty.html @@ -0,0 +1,268 @@ + + + + + + + + + + + + + + + + + + + + + + + + +CIL API Documentation (version 1.3.5) : Pretty + + +
 Up + Next +
+

Module Pretty

+
+
module Pretty: sig .. end
Utility functions for pretty-printing. The major features provided by + this module are + + Pretty-printing occurs in two stages: + + The formatting algorithm is not optimal but it does a pretty good job while + still operating in linear time. The original version was based on a pretty + printer by Philip Wadler which turned out to not scale to large jobs.
+
+
+API
+
type doc
+
+The type of unformated documents. Elements of this type can be + constructed in two ways. Either with a number of constructor shown below, + or using the Pretty.dprintf function with a printf-like interface. + The Pretty.dprintf method is slightly slower so we do not use it for + large jobs such as the output routines for a compiler. But we use it for + small jobs such as logging and error messages.
+
+ +
+Constructors for the doc type.
+
val nil : doc
+Constructs an empty document
+
+
val (++) : doc -> doc -> doc
+Concatenates two documents. This is an infix operator that associates to + the left.
+
+
val concat : doc -> doc -> doc
val text : string -> doc
+A document that prints the given string
+
+
val num : int -> doc
+A document that prints an integer in decimal form
+
+
val real : float -> doc
+A document that prints a real number
+
+
val chr : char -> doc
+A document that prints a character. This is just like Pretty.text + with a one-character string.
+
+
val line : doc
+A document that consists of a mandatory newline. This is just like (text + "\n"). The new line will be indented to the current indentation level, + unless you use Pretty.leftflush right after this.
+
+
val leftflush : doc
+Use after a Pretty.line to prevent the indentation. Whatever follows + next will be flushed left. Indentation resumes on the next line.
+
+
val break : doc
+A document that consists of either a space or a line break. Also called + an optional line break. Such a break will be + taken only if necessary to fit the document in a given width. If the break + is not taken a space is printed instead.
+
+
val align : doc
+Mark the current column as the current indentation level. Does not print + anything. All taken line breaks will align to this column. The previous + alignment level is saved on a stack.
+
+
val unalign : doc
+Reverts to the last saved indentation level.
+
+
val mark : doc
+Mark the beginning of a markup section. The width of a markup section is + considered 0 for the purpose of computing identation
+
+
val unmark : doc
+The end of a markup section
+
+
+Syntactic sugar
+
val indent : int -> doc -> doc
+Indents the document. Same as ((text " ") ++ align ++ doc ++ unalign), + with the specified number of spaces.
+
+
val markup : doc -> doc
+Prints a document as markup. The marked document cannot contain line + breaks or alignment constructs.
+
+
val seq : sep:doc -> doit:('a -> doc) -> elements:'a list -> doc
+Formats a sequence. sep is a separator, doit is a function that + converts an element to a document.
+
+
val docList : ?sep:doc -> ('a -> doc) -> unit -> 'a list -> doc
+An alternative function for printing a list. The unit argument is there + to make this function more easily usable with the Pretty.dprintf + interface. The first argument is a separator, by default a comma.
+
+
val d_list : string -> (unit -> 'a -> doc) -> unit -> 'a list -> doc
+sm: Yet another list printer. This one accepts the same kind of + printing function that Pretty.dprintf does, and itself works + in the dprintf context. Also accepts + a string as the separator since that's by far the most common.
+
+
val docArray : ?sep:doc ->
       (int -> 'a -> doc) -> unit -> 'a array -> doc
+Formats an array. A separator and a function that prints an array + element. The default separator is a comma.
+
+
val docOpt : ('a -> doc) -> unit -> 'a option -> doc
+Prints an 'a option with None or Some
+
+
val d_int32 : int32 -> doc
+Print an int32
+
+
val f_int32 : unit -> int32 -> doc
val d_int64 : int64 -> doc
val f_int64 : unit -> int64 -> doc
module MakeMapPrinter: 
functor (Map : sig
type key 

+
+
type 'a t 

+
+
val fold : (key -> 'a -> 'b -> 'b) ->
       'a t -> 'b -> 'b
end) -> sig .. end
+Format maps. +
+
module MakeSetPrinter: 
functor (Set : sig
type elt 

+
+
type t 

+
+
val fold : (elt -> 'a -> 'a) ->
       t -> 'a -> 'a
end) -> sig .. end
+Format sets. +
+
val insert : unit -> doc -> doc
+A function that is useful with the printf-like interface
+
+
val dprintf : ('a, unit, doc, doc) format4 -> 'a
+This function provides an alternative method for constructing + doc objects. The first argument for this function is a format string + argument (of type ('a, unit, doc) format; if you insist on + understanding what that means see the module Printf). The format string + is like that for the printf function in C, except that it understands a + few more formatting controls, all starting with the @ character. +

+ + See the gprintf function if you want to pipe the result of dprintf into + some other functions. +

+ + The following special formatting characters are understood (these do not + correspond to arguments of the function):

+ + In addition to the usual printf % formatting characters the following two + new characters are supported: + +
dprintf "Name=%s, SSN=%7d, Children=@[%a@]\n"
+             pers.name pers.ssn (docList (chr ',' ++ break) text)
+             pers.children
+

+ + The result of dprintf is a Pretty.doc. You can format the document and + emit it using the functions Pretty.fprint and Pretty.sprint.
+

+
val gprintf : (doc -> 'a) -> ('b, unit, doc, 'a) format4 -> 'b
+Like Pretty.dprintf but more general. It also takes a function that is + invoked on the constructed document but before any formatting is done. The + type of the format argument means that 'a is the type of the parameters of + this function, unit is the type of the first argument to %a and %t + formats, doc is the type of the intermediate result, and 'b is the type of + the result of gprintf.
+
+
val fprint : Pervasives.out_channel -> width:int -> doc -> unit
+Format the document to the given width and emit it to the given channel
+
+
val sprint : width:int -> doc -> string
+Format the document to the given width and emit it as a string
+
+
val fprintf : Pervasives.out_channel -> ('a, unit, doc) Pervasives.format -> 'a
+Like Pretty.dprintf followed by Pretty.fprint
+
+
val printf : ('a, unit, doc) Pervasives.format -> 'a
+Like Pretty.fprintf applied to stdout
+
+
val eprintf : ('a, unit, doc) Pervasives.format -> 'a
+Like Pretty.fprintf applied to stderr
+
+
val withPrintDepth : int -> (unit -> unit) -> unit
+Invokes a thunk, with printDepth temporarily set to the specified value
+
+
+The following variables can be used to control the operation of the printer
+
val printDepth : int Pervasives.ref
+Specifies the nesting depth of the align/unalign pairs at which + everything is replaced with ellipsis
+
+
val printIndent : bool Pervasives.ref
+If false then does not indent
+
+
val fastMode : bool Pervasives.ref
+If set to true then optional breaks are taken only when the document + has exceeded the given width. This means that the printout will looked + more ragged but it will be faster
+
+
val flushOften : bool Pervasives.ref
+If true the it flushes after every print
+
+
val countNewLines : int Pervasives.ref
+Keep a running count of the taken newlines. You can read and write this + from the client code if you want
+
+
val auto_printer : string -> 'a
+A function that when used at top-level in a module will direct + the pa_prtype module generate automatically the printing functions for a + type
+
+ \ No newline at end of file -- cgit