| (++) [Pretty] |
Concatenates two documents.
|
A | |
| addAttribute [Cil] |
Add an attribute.
|
| addAttributes [Cil] |
Add a list of attributes.
|
| addOffset [Cil] | addOffset o1 o2 adds o1 to the end of o2.
|
| addOffsetLval [Cil] |
Add an offset at the end of an lvalue.
|
| additiveLevel [Cil] | |
| addrOfLevel [Cil] | |
| align [Pretty] |
Mark the current column as the current indentation level.
|
| alignOf_int [Cil] |
The minimum alignment (in bytes) for a type.
|
| allStmts [Cfg] |
Return all statements in a file - valid after computeFileCfg only
|
| append [Clist] |
Append two clists
|
| argsToList [Cil] |
Obtain the argument list ([] if None)
|
| arrowLevel [Cil] | |
| attributeHash [Cil] |
This table contains the mapping of predefined attributes to classes.
|
| auto_printer [Pretty] |
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
|
B | |
| bitsOffset [Cil] |
Give a type of a base and an offset, returns the number of bits from the
base address and the width (also expressed in bits) for the subobject
denoted by the offset.
|
| bitsSizeOf [Cil] |
The size of a type, in bits.
|
| bitwiseLevel [Cil] | |
| blueEscStr [Errormsg] | |
| break [Pretty] |
A document that consists of either a space or a line break.
|
| bug [Cil] |
Like
Errormsg.bug except that Cil.currentLoc is also printed
|
| bug [Errormsg] |
Similar to
error except that its output has the form Bug: ...
|
| builtinFunctions [Cil] |
A list of the built-in functions for the current compiler (GCC or
MSVC, depending on
!msvcMode).
|
| builtinLoc [Cil] |
This is used as the location of the prototypes of builtin functions.
|
| bytesSizeOfInt [Cil] |
The size in bytes of the given int kind.
|
C | |
| cExp [Formatcil] |
Constructs an expression based on the program and the list of arguments.
|
| cInstr [Formatcil] |
Constructs an instruction based on the program and the list of arguments.
|
| cLval [Formatcil] |
Constructs an lval based on the program and the list of arguments.
|
| cStmt [Formatcil] | |
| cStmts [Formatcil] |
Constructs a list of statements
|
| cType [Formatcil] |
Constructs a type based on the program and the list of arguments.
|
| cfgFun [Cfg] |
Compute a control flow graph for fd.
|
| charConstPtrType [Cil] |
char const *
|
| charConstToInt [Cil] |
Given the character c in a (CChr c), sign-extend it to 32 bits.
|
| charPtrType [Cil] |
char *
|
| charType [Cil] |
char
|
| char_is_unsigned [Cil] |
Whether "char" is unsigned.
|
| checkBeforeAppend [Clist] |
A useful check to assert before an append.
|
| children [Dominators] |
Return a list of statements dominated by the argument
|
| chr [Pretty] |
A document that prints a character.
|
| cilVersion [Cil] |
These are the CIL version numbers.
|
| cilVersionMajor [Cil] | |
| cilVersionMinor [Cil] | |
| cilVersionRevision [Cil] | |
| cilint_to_int [Cil] |
Convert a cilint int to an OCaml int, or raise an exception if that
can't be done.
|
| clearCFGinfo [Cfg] |
clear the sid, succs, and preds fields of each statment in a function
|
| clearFileCFG [Cfg] |
clear the sid, succs, and preds fields of each statement.
|
| colorFlag [Errormsg] |
Set to true if you want error and warning messages to be colored
|
| combinePredecessors [Dataflow.ForwardsTransfer] |
Take some old data for the start of a statement, and some new data for
the same point.
|
| combineStmtStartData [Dataflow.BackwardsTransfer] |
When the analysis reaches the start of a block, combine the old data
with the one we have just computed.
|
| combineSuccessors [Dataflow.BackwardsTransfer] |
Take the data from two successors and combine it
|
| commonIntKind [Cil] |
Return the common integer kind of the two integer arguments, as
defined in ISO C 6.3.1.8 ("Usual arithmetic conversions")
|
| compFullName [Cil] |
Get the full name of a comp
|
| compactStmts [Cil] |
Try to compress statements so as to get maximal basic blocks.
|
| comparativeLevel [Cil] | |
| compareLoc [Cil] |
Comparison function for locations.
|
| compute [Dataflow.BackwardsDataFlow] |
Fill in the T.stmtStartData, given a number of initial statements to
start from (the sinks for the backwards data flow).
|
| compute [Dataflow.ForwardsDataFlow] |
Fill in the T.stmtStartData, given a number of initial statements to
start from.
|
| computeCFGInfo [Cil] |
Compute the CFG information for all statements in a fundec and return a
list of the statements.
|
| computeDomTree [Dominators] |
returns the IDoms and a map from statement ids to
the set of statements that are dominated
|
| computeFileCFG [Cfg] |
Compute the CFG for an entire file, by calling cfgFun on each function.
|
| computeFirstPredecessor [Dataflow.ForwardsTransfer] |
Give the first value for a predecessors, compute the value to be set
for the block
|
| computeIDom [Dominators] |
Invoke on a code after filling in the CFG info and it computes the
immediate dominator information.
|
| concat [Pretty] | |
| constFold [Cil] |
Do constant folding on an expression.
|
| constFoldBinOp [Cil] |
Do constant folding on a binary operation.
|
| constFoldVisitor [Cil] |
A visitor that does constant folding.
|
| convertInts [Cil] | |
| copy [Dataflow.ForwardsTransfer] |
Make a deep copy of the data
|
| copyCompInfo [Cil] |
Makes a shallow copy of a
Cil.compinfo changing the name and the key.
|
| copyFunction [Cil] |
Create a deep copy of a function.
|
| copyVarinfo [Cil] |
Make a shallow copy of a
varinfo and assign a new identifier
|
| countCalls [Stats] |
Flag to indicate whether or not to count the number of calls of
to
Stats.repeattime or Stats.time for each label.
|
| countNewLines [Pretty] |
Keep a running count of the taken newlines.
|
| currentGlobal [Cil] |
A reference to the current global being visited
|
| currentLoc [Cil] |
A reference to the current location.
|
| cyanEscStr [Errormsg] | |
D | |
| dExp [Formatcil] |
Deconstructs an expression based on the program.
|
| dExp [Cil] |
Generate an
Cil.exp to be used in case of errors.
|
| dGlobal [Cil] |
Generate a
Cil.global to be used in case of errors.
|
| dInstr [Formatcil] |
Deconstructs an instruction based on the program.
|
| dInstr [Cil] |
Generate an
Cil.instr to be used in case of errors.
|
| dLval [Formatcil] |
Deconstructs an lval based on the program.
|
| dType [Formatcil] |
Deconstructs a type based on the program.
|
| d_attr [Cil] |
Pretty-print an attribute using
Cil.defaultCilPrinter
|
| d_attrlist [Cil] |
Pretty-print a list of attributes using
Cil.defaultCilPrinter
|
| d_attrparam [Cil] |
Pretty-print an argument of an attribute using
Cil.defaultCilPrinter
|
| d_binop [Cil] |
Pretty-print a binary operator
|
| d_block [Cil] |
Pretty-print a block using
Cil.defaultCilPrinter.
|
| d_const [Cil] |
Pretty-print a constant
|
| d_exp [Cil] |
Pretty-print an expression using
Cil.defaultCilPrinter
|
| d_fkind [Cil] |
Pretty-print a floating-point kind
|
| d_formatarg [Cil] |
Pretty-prints a format arg
|
| d_global [Cil] |
Pretty-print the internal representation of a global using
Cil.defaultCilPrinter.
|
| d_hloc [Errormsg] | |
| d_ikind [Cil] |
Pretty-print an integer of a given kind
|
| d_init [Cil] |
Pretty-print an initializer using
Cil.defaultCilPrinter.
|
| d_instr [Cil] |
Pretty-print an instruction using
Cil.defaultCilPrinter
|
| d_int32 [Pretty] |
Print an int32
|
| d_int64 [Pretty] | |
| d_label [Cil] |
Pretty-print a label using
Cil.defaultCilPrinter
|
| d_list [Pretty] |
sm: Yet another list printer.
|
| d_loc [Cil] |
Pretty-print a location
|
| d_loc [Errormsg] | |
| d_lval [Cil] |
Pretty-print an lvalue using
Cil.defaultCilPrinter
|
| d_map [Pretty.MakeMapPrinter] |
Format a map, analogous to d_list.
|
| d_offset [Cil] |
Pretty-print an offset using
Cil.defaultCilPrinter, given the pretty
printing for the base.
|
| d_plainexp [Cil] |
Pretty-print the internal representation of an expression
|
| d_plaininit [Cil] |
Pretty-print the internal representation of an integer
|
| d_plainlval [Cil] |
Pretty-print the internal representation of an lvalue
|
| d_plaintype [Cil] |
Pretty-print the internal representation of a type
|
| d_set [Pretty.MakeSetPrinter] |
Format a set, analogous to d_list.
|
| d_shortglobal [Cil] |
Pretty-print a short description of the global.
|
| d_stmt [Cil] |
Pretty-print a statement using
Cil.defaultCilPrinter.
|
| d_storage [Cil] |
Pretty-print storage-class information
|
| d_thisloc [Cil] |
Pretty-print the
Cil.currentLoc
|
| d_type [Cil] |
Pretty-print a type using
Cil.defaultCilPrinter
|
| d_typsig [Cil] |
Print a type signature
|
| d_unop [Cil] |
Pretty-print a unary operator
|
| dd_exp [Cil] |
Pretty-print an expression while printing descriptions rather than names
of temporaries.
|
| dd_lval [Cil] | |
| debug [Dataflow.BackwardsTransfer] |
Whether to turn on debugging
|
| debug [Dataflow.ForwardsTransfer] |
Whether to turn on debugging
|
| debugFlag [Errormsg] |
If set then print debugging info
|
| defaultCilPrinter [Cil] | |
| derefStarLevel [Cil] | |
| descriptiveCilPrinter [Cil] | |
| dn_attr [Cil] | |
| dn_attrlist [Cil] | |
| dn_attrparam [Cil] | |
| dn_exp [Cil] |
Versions of the above pretty printers, that don't print #line directives
|
| dn_global [Cil] | |
| dn_init [Cil] | |
| dn_instr [Cil] | |
| dn_lval [Cil] | |
| dn_stmt [Cil] | |
| dn_type [Cil] | |
| doGuard [Dataflow.ForwardsTransfer] |
Generate the successor to an If statement assuming the given expression
is nonzero.
|
| doInstr [Dataflow.BackwardsTransfer] |
The (backwards) transfer function for an instruction.
|
| doInstr [Dataflow.ForwardsTransfer] |
The (forwards) transfer function for an instruction.
|
| doStmt [Dataflow.BackwardsTransfer] |
The (backwards) transfer function for a branch.
|
| doStmt [Dataflow.ForwardsTransfer] |
The (forwards) transfer function for a statement.
|
| docAlphaTable [Alpha] |
Split the name in preparation for newAlphaName.
|
| docArray [Pretty] |
Formats an array.
|
| docCList [Clist] |
A document for printing a clist (similar to
docList)
|
| docList [Pretty] |
An alternative function for printing a list.
|
| docMap [Pretty.MakeMapPrinter] |
Format a map, analogous to docList.
|
| docOpt [Pretty] |
Prints an
'a option with None or Some
|
| docSet [Pretty.MakeSetPrinter] |
Format a set, analogous to docList.
|
| domTreeIter [Dominators] |
Iterate over a dominator tree
|
| dominates [Dominators] |
Check whether one statement dominates another.
|
| doubleType [Cil] |
double
|
| dprintf [Pretty] |
This function provides an alternative method for constructing
doc objects.
|
| dropAttribute [Cil] |
Remove all attributes with the given name.
|
| dropAttributes [Cil] |
Remove all attributes with names appearing in the string list.
|
| dummyFile [Cil] |
A dummy file
|
| dummyFunDec [Cil] |
A dummy function declaration handy when you need one as a placeholder.
|
| dummyInstr [Cil] |
A instr to serve as a placeholder
|
| dummyStmt [Cil] |
A statement consisting of just
dummyInstr
|
| dumpBlock [Cil] |
Dump a block to a file using a given indentation.
|
| dumpFile [Cil] |
Pretty-print an entire file.
|
| dumpGlobal [Cil] |
Pretty-print a global.
|
| dumpInit [Cil] |
Dump an initializer to a file using a given indentation.
|
| dumpStmt [Cil] |
Dump a statement to a file using a given indentation.
|
E | |
| empty [Clist] |
The empty clist
|
| emptyFunction [Cil] |
Make an empty function
|
| endsWith [Cil] |
return true if the first is a suffix of the second string
|
| envMachine [Cil] |
Machine model specified via CIL_MACHINE environment variable
|
| eprintf [Pretty] |
Like
Pretty.fprintf applied to stderr
|
| error [Cil] |
Like
Errormsg.error except that Cil.currentLoc is also printed
|
| error [Errormsg] |
Prints an error message of the form
Error: ....
|
| errorLoc [Cil] |
Like
Cil.error except that it explicitly takes a location argument,
instead of using the Cil.currentLoc
|
| existsType [Cil] |
Scans a type by applying the function on all elements.
|
| expToAttrParam [Cil] |
Convert an expression into an attrparam, if possible.
|
F | |
| f_int32 [Pretty] | |
| f_int64 [Pretty] | |
| fastMode [Pretty] |
If set to
true then optional breaks are taken only when the document
has exceeded the given width.
|
| filterAttributes [Cil] |
Retains attributes with the given name
|
| filterStmt [Dataflow.BackwardsTransfer] |
Whether to put this predecessor block in the worklist.
|
| filterStmt [Dataflow.ForwardsTransfer] |
Whether to put this statement in the worklist.
|
| findNaturalLoops [Dominators] |
Compute the start of the natural loops.
|
| findOrCreateFunc [Cil] |
Find a function or function prototype with the given name in the file.
|
| find_stmts [Dataflow] |
Returns (all_stmts, sink_stmts), where all_stmts is a list of the
statements in a function, and sink_stmts is a list of the return statments
(including statements that fall through the end of a void function).
|
| finishParsing [Errormsg] | |
| fitsInInt [Cil] |
True if the integer fits within the kind's range
|
| floatKindForSize [Cil] |
The float kind for a given size.
|
| flushOften [Pretty] |
If true the it flushes after every print
|
| foldGlobals [Cil] |
Fold over all globals, including the global initializer
|
| foldLeftCompound [Cil] |
Fold over the list of initializers in a Compound (not also the nested
ones).
|
| fold_left [Clist] |
A version of fold_left that works on clists
|
| forgcc [Cil] |
Return the string 's' if we're printing output for gcc, suppres
it if we're printing for CIL to parse back in.
|
| fprint [Pretty] |
Format the document to the given width and emit it to the given channel
|
| fprintf [Pretty] |
Like
Pretty.dprintf followed by Pretty.fprint
|
| fromList [Clist] |
Convert an ordinary list to a clist
|
| funcExitData [Dataflow.BackwardsTransfer] |
The data at function exit.
|
G | |
| gccBuiltins [Cil] | |
| getAlphaPrefix [Alpha] | |
| getCompField [Cil] |
Return a named fieldinfo in compinfo, or raise Not_found
|
| getGlobInit [Cil] |
Get the global initializer and create one if it does not already exist.
|
| getHPosition [Errormsg] |
high-level position
|
| getIdom [Dominators] |
This is like Inthash.find but gives an error if the information is
Not_found
|
| getInteger [Cil] |
If the given expression is an integer constant or a CastE'd
integer constant, return that constant's value.
|
| getLocation [Errormsg] | |
| getParenthLevel [Cil] |
Parentheses level.
|
| getPosition [Errormsg] | |
| get_globalLoc [Cil] |
Return the location of a global, or locUnknown
|
| get_instrLoc [Cil] |
Return the location of an instruction
|
| get_stmtLoc [Cil] |
Return the location of a statement, or locUnknown
|
| gprintf [Pretty] |
Like
Pretty.dprintf but more general.
|
| greenEscStr [Errormsg] | |
H | |
| hadErrors [Errormsg] |
This is set whenever one of the above error functions are called.
|
| hasAttribute [Cil] |
True if the named attribute appears in the attribute list.
|
I | |
| i64_to_int [Cil] |
Convert a 64-bit int to an OCaml int, or raise an exception if that
can't be done.
|
| increm [Cil] |
Increment an expression.
|
| indent [Pretty] |
Indents the document.
|
| indexLevel [Cil] | |
| initCIL [Cil] |
Call this function to perform some initialization.
|
| insert [Pretty] |
A function that is useful with the
printf-like interface
|
| insertImplicitCasts [Cil] |
Do insert implicit casts (default true)
|
| intKindForSize [Cil] |
The signed integer kind for a given size (unsigned if second argument
is true).
|
| intKindForValue [Cil] |
Return the smallest kind that will hold the integer's value.
|
| intPtrType [Cil] |
int *
|
| intRank [Cil] |
Return the integer conversion rank of an integer kind
|
| intType [Cil] |
int
|
| integer [Cil] |
Construct an integer of kind IInt.
|
| invalidStmt [Cil] |
An empty statement.
|
| isArithmeticType [Cil] |
True if the argument is an arithmetic type (i.e.
|
| isArrayType [Cil] |
True if the argument is an array type
|
| isCompleteType [Cil] |
Returns true if this is a complete type.
|
| isConstant [Cil] |
True if the expression is a compile-time constant
|
| isConstantOffset [Cil] |
True if the given offset contains only field nanmes or constant indices.
|
| isFunctionType [Cil] |
True if the argument is a function type
|
| isInteger [Cil] | |
| isIntegralType [Cil] |
True if the argument is an integral type (i.e.
|
| isPointerType [Cil] |
True if the argument is a pointer type
|
| isScalarType [Cil] |
True if the argument is a scalar type
|
| isSigned [Cil] |
Returns true if and only if the given integer type is signed.
|
| isVoidPtrType [Cil] |
is the given type "void *"?
|
| isVoidType [Cil] |
is the given type "void"?
|
| isZero [Cil] |
True if the given expression is a (possibly cast'ed) integer or character
constant with value zero
|
| iter [Clist] |
A version of iter that works on clists
|
| iterGlobals [Cil] |
Iterate over all globals, including the global initializer
|
K | |
| kindOfSizeOf [Cil] |
The integer kind of
Cil.typeOfSizeOf.
|
| kinteger [Cil] |
Construct an integer of a given kind.
|
| kinteger64 [Cil] |
Construct an integer of a given kind, using OCaml's int64 type.
|
| kintegerCilint [Cil] |
Construct an integer of a given kind, from a cilint.
|
L | |
| lastTime [Stats] | |
| leftflush [Pretty] |
Use after a
Pretty.line to prevent the indentation.
|
| lenOfArray [Cil] |
Call to compute the array length as present in the array type, to an
integer.
|
| length [Clist] |
Find the length of a clist
|
| line [Pretty] |
A document that consists of a mandatory newline.
|
| lineDirectiveStyle [Cil] |
How to print line directives
|
| lineLength [Cil] |
The length used when wrapping output lines.
|
| little_endian [Cil] |
Whether the machine is little endian.
|
| loadBinaryFile [Cil] |
Read a
Cil.file in binary form from the filesystem.
|
| locUnknown [Cil] |
Represents a location that cannot be determined
|
| locUnknown [Errormsg] |
An unknown location for use when you need one but you don't have one
|
| log [Errormsg] |
Print something to
logChannel
|
| logChannel [Errormsg] |
A channel for printing log messages
|
| logg [Errormsg] |
same as
Errormsg.log but do not wrap lines
|
| longType [Cil] |
long
|
| lookupTime [Stats] |
Return the cumulative time of all calls to
Stats.time and
Stats.repeattime with the given label.
|
| lowerConstants [Cil] |
Do lower constants (default true)
|
| lowerEnumVisitor [Cillower] |
Replace enumeration constants with integer constants
|
M | |
| makeFormalVar [Cil] |
Make a formal variable for a function.
|
| makeGlobalVar [Cil] |
Make a global variable.
|
| makeLocalVar [Cil] |
Make a local variable and add it to a function's slocals (only if insert =
true, which is the default).
|
| makeTempVar [Cil] |
Make a temporary variable and add it to a function's slocals.
|
| makeVarinfo [Cil] |
Make a varinfo.
|
| makeZeroInit [Cil] |
Make a initializer for zero-ing a data type
|
| map [Clist] |
Map a function over a clist.
|
| mapGlobals [Cil] |
Map over all globals, including the global initializer and change things
in place
|
| mapNoCopy [Cil] |
Like map but try not to make a copy of the list
|
| mapNoCopyList [Cil] |
Like map but each call can return a list.
|
| mark [Pretty] |
Mark the beginning of a markup section.
|
| markup [Pretty] |
Prints a document as markup.
|
| missingFieldName [Cil] |
This is a constant used as the name of an unnamed bitfield.
|
| mkAddrOf [Cil] |
Make an AddrOf.
|
| mkAddrOrStartOf [Cil] |
Like mkAddrOf except if the type of lval is an array then it uses
StartOf.
|
| mkBlock [Cil] |
Construct a block with no attributes, given a list of statements
|
| mkCast [Cil] |
Like
Cil.mkCastT but uses typeOf to get oldt
|
| mkCastT [Cil] |
Construct a cast when having the old type of the expression.
|
| mkCilint [Cil] |
Construct a cilint from an integer kind and int64 value.
|
| mkCompInfo [Cil] |
Creates a a (potentially recursive) composite type.
|
| mkEmptyStmt [Cil] |
Returns an empty statement (of kind
Instr)
|
| mkFor [Cil] |
Make a for loop for(start; guard; next) { ...
|
| mkForIncr [Cil] |
Make a for loop for(i=start; i<past; i += incr) { ...
|
| mkMem [Cil] |
Make a Mem, while optimizing AddrOf.
|
| mkStmt [Cil] |
Construct a statement, given its kind.
|
| mkStmtOneInstr [Cil] |
Construct a statement consisting of just one instruction
|
| mkString [Cil] |
Make an expression that is a string constant (of pointer type)
|
| mkWhile [Cil] |
Make a while loop.
|
| mone [Cil] |
-1
|
| msvcBuiltins [Cil] | |
| msvcMode [Cil] |
Whether the pretty printer should print output for the MS VC compiler.
|
N | |
| name [Dataflow.BackwardsTransfer] |
For debugging purposes, the name of the analysis
|
| name [Dataflow.ForwardsTransfer] |
For debugging purposes, the name of the analysis
|
| newAlphaName [Alpha] |
Create a new name based on a given name.
|
| newHline [Errormsg] | |
| newVID [Cil] |
Generate a new variable ID.
|
| new_sid [Cil] | |
| newline [Errormsg] | |
| nil [Pretty] |
Constructs an empty document
|
| noMemoize [Formatcil] |
If set then will not memoize the parsed patterns
|
| null [Errormsg] |
Do not actually print (i.e.
|
| num [Pretty] |
A document that prints an integer in decimal form
|
| num64 [Pretty] |
A document that prints a 64-bit int in decimal form
|
O | |
| oldstyleExternInline [Cil] |
Set this to true to get old-style handling of gcc's extern inline C extension:
old-style: the extern inline definition is used until the actual definition is
seen (as long as optimization is enabled)
new-style: the extern inline definition is used only if there is no actual
definition (as long as optimization is enabled)
Note that CIL assumes that optimization is always enabled ;-)
|
| one [Cil] |
1
|
P | |
| parseInt [Cil] |
Convert a string representing a C integer literal to an expression.
|
| parse_error [Errormsg] | |
| partitionAttributes [Cil] |
Partition the attributes into classes:name attributes, function type,
and type attributes
|
| peepHole1 [Cil] |
Similar to
peepHole2 except that the optimization window consists of
one instruction, not two
|
| peepHole2 [Cil] |
A peephole optimizer that processes two adjacent instructions and possibly
replaces them both.
|
| plainCilPrinter [Cil] | |
| popContext [Errormsg] |
Removes the last registered context printing function
|
| prepareCFG [Cil] |
Prepare a function for CFG information computation by
Cil.computeCFGInfo.
|
| pretty [Dataflow.BackwardsTransfer] |
Pretty-print the state
|
| pretty [Dataflow.ForwardsTransfer] |
Pretty-print the state
|
| print [Stats] |
Print the current stats preceeded by a message
|
| printAttr [Cil] |
Print an attribute given a pretty printer
|
| printAttrs [Cil] |
Print a set of attributes given a pretty printer
|
| printBlock [Cil] |
Print a block given a pretty printer.
|
| printCfgChannel [Cfg] |
print control flow graph (in dot form) for fundec to channel
|
| printCfgFilename [Cfg] |
Print control flow graph (in dot form) for fundec to file
|
| printCilAsIs [Cil] |
Whether to print the CIL as they are, without trying to be smart and
print nicer code.
|
| printDepth [Pretty] |
Specifies the nesting depth of the
align/unalign pairs at which
everything is replaced with ellipsis
|
| printExp [Cil] |
Print an expression given a pretty printer
|
| printGlobal [Cil] |
Print a global given a pretty printer
|
| printIndent [Pretty] |
If false then does not indent
|
| printInit [Cil] |
Print an initializer given a pretty printer.
|
| printInstr [Cil] |
Print an instruction given a pretty printer
|
| printLval [Cil] |
Print an lvalue given a pretty printer
|
| printStmt [Cil] |
Print a statement given a pretty printer.
|
| printType [Cil] |
Print a type given a pretty printer
|
| print_CIL_Input [Cil] |
Whether we print something that will only be used as input to our own
parser.
|
| printerForMaincil [Cil] |
zra: This is the pretty printer that Maincil will use.
|
| printf [Pretty] |
Like
Pretty.fprintf applied to stdout
|
| purpleEscStr [Errormsg] | |
| pushContext [Errormsg] |
Registers a context printing function
|
| pushGlobal [Cil] |
CIL keeps the types at the beginning of the file and the variables at the
end of the file.
|
R | |
| readingFromStdin [Errormsg] |
Records whether the stdin is open for reading the goal *
|
| real [Pretty] |
A document that prints a real number
|
| redEscStr [Errormsg] | |
| registerAlphaName [Alpha] |
Register a name with an alpha conversion table to ensure that when later
we call newAlphaName we do not end up generating this one
|
| removeOffset [Cil] |
Remove ONE offset from the end of an offset sequence.
|
| removeOffsetLval [Cil] |
Remove ONE offset from the end of an lvalue.
|
| repeattime [Stats] |
repeattime is like time but runs the function several times until the total
running time is greater or equal to the first argument.
|
| reset [Stats] |
Resets all the timings and specifies the method to use for future timings.
|
| resetEscStr [Errormsg] | |
| rev [Clist] |
Reverse a clist.
|
S | |
| s [Errormsg] |
Stop the execution by raising an Error.
|
| saveBinaryFile [Cil] |
Write a
Cil.file in binary form to the filesystem.
|
| saveBinaryFileChannel [Cil] |
Write a
Cil.file in binary form to the filesystem.
|
| separateStorageModifiers [Cil] |
Separate out the storage-modifier name attributes
|
| seq [Pretty] |
Formats a sequence.
|
| setCurrentFile [Errormsg] | |
| setCurrentLine [Errormsg] | |
| setFormals [Cil] |
Update the formals of a
fundec and make sure that the function type
has the same information.
|
| setFunctionType [Cil] |
Set the types of arguments and results as given by the function type
passed as the second argument.
|
| setFunctionTypeMakeFormals [Cil] |
Set the type of the function and make formal arguments for them
|
| setHFile [Errormsg] | |
| setHLine [Errormsg] | |
| setMaxId [Cil] |
Update the smaxid after you have populated with locals and formals
(unless you constructed those using
Cil.makeLocalVar or
Cil.makeTempVar.
|
| setTypeAttrs [Cil] | |
| setTypeSigAttrs [Cil] |
Replace the attributes of a signature (only at top level)
|
| showContext [Errormsg] |
Show the context stack to stderr
|
| signedVersionOf [Cil] |
Give the signed kind corresponding to any integer kind
|
| single [Clist] |
Create a clist containing one element
|
| sizeOf [Cil] |
The size of a type, in bytes.
|
| splitFunctionType [Cil] |
Given a function type split it into return type,
arguments, is_vararg and attributes.
|
| splitFunctionTypeVI [Cil] | |
| sprint [Pretty] |
Format the document to the given width and emit it as a string
|
| startParsing [Errormsg] | |
| startParsingFromString [Errormsg] | |
| start_id [Cfg] |
Next statement id that will be assigned.
|
| startsWith [Cil] |
sm: return true if the first is a prefix of the second string
|
| stmtStartData [Dataflow.BackwardsTransfer] |
For each block id, the data at the start.
|
| stmtStartData [Dataflow.ForwardsTransfer] |
For each statement id, the data at the start.
|
| stripCasts [Cil] |
Removes casts from this expression, but ignores casts within
other expression constructs.
|
| stripUnderscores [Cil] |
If string has leading and trailing __, strip them.
|
T | |
| test [Formatcil] |
Just a testing function
|
| text [Pretty] |
A document that prints the given string
|
| time [Stats] |
Time a function and associate the time with the given string.
|
| timethis [Stats] |
Time a function and set lastTime to the time it took
|
| toList [Clist] |
Convert a clist to an ordinary list
|
| truncateCilint [Cil] |
Represents an integer as for a given kind.
|
| truncateInteger64 [Cil] | |
| typeAddAttributes [Cil] |
Add some attributes to a type
|
| typeAttrs [Cil] |
Returns all the attributes contained in a type.
|
| typeOf [Cil] |
Compute the type of an expression
|
| typeOfLval [Cil] |
Compute the type of an lvalue
|
| typeOfSizeOf [Cil] |
An unsigned integer type that is the type of sizeof.
|
| typeOffset [Cil] |
Compute the type of an offset from a base type
|
| typeRemoveAttributes [Cil] |
Remove all attributes with the given names from a type.
|
| typeSig [Cil] |
Compute a type signature
|
| typeSigAttrs [Cil] |
Get the top-level attributes of a signature
|
| typeSigWithAttrs [Cil] |
Like
Cil.typeSig but customize the incorporation of attributes.
|
U | |
| uintPtrType [Cil] |
unsigned int *
|
| uintType [Cil] |
unsigned int
|
| ulongType [Cil] |
unsigned long
|
| unalign [Pretty] |
Reverts to the last saved indentation level.
|
| underscore_name [Cil] |
Whether the compiler generates assembly labels by prepending "_" to the
identifier.
|
| undoAlphaChanges [Alpha] |
Undo the changes to a table
|
| unimp [Cil] |
Like
Errormsg.unimp except that Cil.currentLocis also printed
|
| unimp [Errormsg] |
Similar to
error except that its output has the form Unimplemented: ...
|
| uniqueVarNames [Cil] |
Assign unique names to local variables.
|
| unmark [Pretty] |
The end of a markup section
|
| unrollType [Cil] |
Unroll a type until it exposes a non
TNamed.
|
| unrollTypeDeep [Cil] |
Unroll all the TNamed in a type (even under type constructors such as
TPtr, TFun or TArray.
|
| unsignedVersionOf [Cil] |
Give the unsigned kind corresponding to any integer kind
|
| upointType [Cil] |
An unsigned integer type that fits pointers.
|
| useLogicalOperators [Cil] |
Whether to use the logical operands LAnd and LOr.
|
V | |
| var [Cil] |
Makes an lvalue out of a given variable
|
| verboseFlag [Errormsg] | |
| visitCilAttributes [Cil] |
Visit a list of attributes
|
| visitCilBlock [Cil] |
Visit a block
|
| visitCilExpr [Cil] | |
| visitCilFile [Cil] |
Visit a file.
|
| visitCilFileSameGlobals [Cil] |
A visitor for the whole file that does not change the globals (but maybe
changes things inside the globals).
|
| visitCilFunction [Cil] |
Visit a function definition
|
| visitCilGlobal [Cil] |
Visit a global
|
| visitCilInit [Cil] |
Visit an initializer, pass also the global to which this belongs and the
offset.
|
| visitCilInitOffset [Cil] |
Visit an initializer offset
|
| visitCilInstr [Cil] |
Visit an instruction
|
| visitCilLval [Cil] |
Visit an lvalue
|
| visitCilOffset [Cil] |
Visit an lvalue or recursive offset
|
| visitCilStmt [Cil] |
Visit a statement
|
| visitCilType [Cil] |
Visit a type
|
| visitCilVarDecl [Cil] |
Visit a variable declaration
|
| voidPtrType [Cil] |
void *
|
| voidType [Cil] |
void
|
W | |
| warn [Cil] |
Like
Errormsg.warn except that Cil.currentLoc is also printed
|
| warn [Errormsg] |
Like
Errormsg.error but does not raise the Errormsg.Error
exception.
|
| warnContext [Cil] |
Like
Errormsg.warn except that Cil.currentLoc and context
is also printed
|
| warnContextOpt [Cil] |
Like
Errormsg.warn except that Cil.currentLoc and context is also
printed.
|
| warnFlag [Errormsg] |
Set to true if you want to see all warnings.
|
| warnLoc [Cil] |
Like
Cil.warn except that it explicitly takes a location argument,
instead of using the Cil.currentLoc
|
| warnOpt [Cil] |
Like
Errormsg.warnOpt except that Cil.currentLoc is also printed.
|
| warnOpt [Errormsg] |
Like
Errormsg.warn but optional.
|
| warnTruncate [Cil] |
Emit warnings when truncating integer constants (default true)
|
| wcharKind [Cil] |
wchar_t (depends on architecture) and is set when you call
Cil.initCIL.
|
| wcharType [Cil] | |
| whiteEscStr [Errormsg] | |
| withContext [Errormsg] |
To ensure that the context is registered and removed properly, use the
function below
|
| withPrintDepth [Pretty] |
Invokes a thunk, with printDepth temporarily set to the specified value
|
Y | |
| yellowEscStr [Errormsg] | |
Z | |
| zero [Cil] |
0
|