|
Class Summary |
| AnnotateNullable |
AnnotateNullable reads a Daikon invariant file and determines which
reference variables have seen any null values. |
| Chicory |
This is the main class for Chicory which transforms the class files
of a program to instrument it for Daikon. |
| Daikon |
The "main" method is the main entry point for the Daikon invariant detector. |
| Daikon.FileIOProgress |
Outputs FileIO progress information. |
| Daikon.FileOptions |
|
| DaikonSimple |
DaikonSimple reads a declaration file and trace file and outputs a list of
likely invariants using the simple incremental algorithm. |
| DaikonSimple.SimpleProcessor |
The SimpleProcessor class processes each sample in the dtrace file. |
| Debug |
Debug class used with the logger to create standardized output. |
| DiscReasonMap |
|
| DynamicConstants |
Class that implements dynamic constants optimization. |
| DynamicConstants.ConIndexComparator |
Compares two constants based on the vi_index of their variable. |
| DynamicConstants.Constant |
Class used to indicate, for each variable, whether it is constant (see
boolean field "constant"). |
| DynComp |
This is the main class for DynComp. |
| FileIO |
|
| FileIO.ParseState |
ParseState indicates:
Some global information about the state of the parser while reading
a decl or dtrace file. |
| FileIO.Processor |
Class used to specify the processor to use for sample data. |
| FileIO.VarDefinition |
Class that holds all of the information from the declaration record
concerning a particular variable |
| Global |
|
| LogHelper |
Standard methods for setting up logging. |
| LogHelper.DaikonLogFormatter |
|
| MemMonitor |
|
| MergeInvariants |
Merges invariants from multiple invariant files into a single invariant
file. |
| ModBitTracker |
ModBitTracker maintains a BitSet for each variable at a program point. |
| Ppt |
|
| Ppt.NameComparator |
|
| PptCombined |
A program point which consists of a number of program points. |
| PptCombined.PpSizeComparator |
Given a map, sort elements of the map according to the size of the mapped-to list. |
| PptConditional |
|
| PptMap |
Maps from a program point name (a String) to a PptTopLevel. |
| PptName |
PptName is an immutable ADT that represents naming data associated with a
given program point, such as the class or method. |
| PptRelation |
Class that builds and describes relations in the ppt hierachy. |
| PptSlice |
A Slice is a view of some of the variables for a program point. |
| PptSlice.ArityPptnameComparator |
This class is used for comparing PptSlice objects. |
| PptSlice.ArityVarnameComparator |
This class is used for comparing PptSlice objects. |
| PptSlice0 |
|
| PptSlice1 |
Contains all of the invariants over a particular set of 1 variables |
| PptSlice2 |
Contains all of the invariants over a particular set of 2 variables |
| PptSlice3 |
Contains all of the invariants over a particular set of 3 variables |
| PptSliceEquality |
Holds Equality invariants. |
| PptSliceEquality.EqualityComparator |
Order Equality invariants by the indices of leaders. |
| PptSplitter |
PptSplitter contains the splitter and its associated
PptConditional ppts. |
| PptTopLevel |
All information about a single program point. |
| PptTopLevel.Stats |
Stores various statistics about a ppt. |
| PptTopLevel.ViewsIteratorIterator |
An iterator whose elements are themselves iterators that return
invariants. |
| PrintInvariants |
|
| ProglangType |
Represents the type of a variable, for its declared, dtrace file
representation, and internal representations. |
| Quant |
The Quant library provides routines that operate on arrays and
collections. |
| Quantify |
Helper classes for quantification for various output formats |
| Quantify.Constant |
Represents a constant integer |
| Quantify.ESCQuantification |
Class that represents an ESC quantification over one or two variables |
| Quantify.FreeVar |
Free variable normally used for quantification |
| Quantify.Length |
Represents the length of a sequence and an optional offset |
| Quantify.QuantifyReturn |
|
| Quantify.SimplifyQuantification |
Class that represents an Simplify quantification over one or two variables |
| Quantify.Term |
Class the represents terms that can be used in variable expressions. |
| Quantify.VarPlusOffset |
Represents a daikon variable with an optional integer offset. |
| Runtime |
The Runtime class provides methods for printing values to a Daikon data
trace file. |
| Runtime.Unique |
|
| SearchNodeUtility<T> |
|
| StackOffsets |
|
| StackOffsets.OffsetInfo |
|
| StackOffsets.Processor |
|
| StackOffsets.StackInfo |
|
| UnionInvariants |
UnionInvariants is a command-line tool that will read in one (or
more) .inv files (possibly gzipped) and write their union into a
new .inv file (possibly gzipped). |
| ValueTuple |
This data structure holds a tuple of values for a particular program
point. |
| VarComparability |
Represents the comparability of variables, including methods to
determine if two VarComparabilities are comparable. |
| VarComparabilityImplicit |
A VarComparabilityImplicit is an arbitrary integer, and comparisons
succeed exactly if the two integers are equal, except that negative
integers compare equal to everything. |
| VarComparabilityNone |
Used when no VarComparability information is available (in the .dtrace file). |
| VarInfo |
Represents information about a particular variable for a program
point. |
| VarInfo.IndexComparator |
Compare names by index. |
| VarInfo.Pair |
Class used to contain a pair of VarInfos and their sample count. |
| VarInfoAux |
Represents additional information about a VarInfo that frontends
tell Daikon. |
| VarInfoName |
VarInfoName represents the "name" of a variable. |
| VarInfoName.AbstractVisitor<T> |
Traverse the tree elements that have exactly one branch (so the
traversal order doesn't matter). |
| VarInfoName.Add |
An integer amount more or less than some other value, like "x+2". |
| VarInfoName.BooleanAndVisitor |
|
| VarInfoName.Elements |
The elements of a container, like "term[]". |
| VarInfoName.ElementsFinder |
Use to traverse a tree, find the first (elements ...) node, and
report whether it's in pre or post-state. |
| VarInfoName.Field |
A 'getter' operation for some field, like a.foo. |
| VarInfoName.Finder |
Finds if a given VarInfoName is contained in a set of nodes
in the VarInfoName tree using == comparison. |
| VarInfoName.FunctionOf |
A function over a term, like "sum(argument)". |
| VarInfoName.FunctionOfN |
A function of multiple parameters. |
| VarInfoName.InorderFlattener |
Use to collect all elements in a tree into an inorder-traversal
list. |
| VarInfoName.Intersection |
Intersection of two sequences. |
| VarInfoName.IsAllNonPoststateVisitor |
|
| VarInfoName.IsAllPrestateVisitor |
|
| VarInfoName.LexicalComparator |
Compare VarInfoNames alphabetically. |
| VarInfoName.NodeFinder |
Use to report whether a node is in a pre- or post-state context. |
| VarInfoName.NoReturnValue |
|
| VarInfoName.PostPreConverter |
Replace pre states by normal variables, and normal variables by
post states. |
| VarInfoName.Poststate |
The poststate value of a term, like "new(term)". |
| VarInfoName.Prestate |
The prestate value of a term, like "orig(term)" or "\old(term)". |
| VarInfoName.QuantHelper |
Helper for writing parts of quantification expressions. |
| VarInfoName.QuantHelper.FreeVar |
A FreeVar is very much like a Simple, except that it doesn't
care if it's in prestate or poststate for simplify formatting. |
| VarInfoName.QuantHelper.QuantifyReturn |
Record type for return value of the quantify method below. |
| VarInfoName.QuantifierVisitor |
A quantifier visitor can be used to search a tree and return all
unquantified sequences (e.g. a[] or a[i..j]). |
| VarInfoName.Replacer |
A Replacer is a Visitor that makes a copy of a tree, but
replaces some node (and its children) with another. |
| VarInfoName.Simple |
A simple identifier like "a", etc. |
| VarInfoName.SimpleNamesVisitor |
|
| VarInfoName.SizeOf |
The size of a contained sequence; form is like "size(sequence)"
or "sequence.length". |
| VarInfoName.Slice |
A slice of elements from a sequence, like "sequence[i..j]". |
| VarInfoName.Subscript |
An element from a sequence, like "sequence[index]". |
| VarInfoName.TypeOf |
The type of the term, like "term.getClass()" or "\typeof(term)". |
| VarInfoName.Union |
Union of two sequences. |