Executed after container analysis has been run, it adds the
type of a contained object to the list of types contained
inside the container associated with the current variable
beginLine and beginColumn describe the position of the first character
of this token; endLine and endColumn describe the position of the
last character of this token.
beginLine and beginColumn describe the position of the first character
of this token; endLine and endColumn describe the position of the
last character of this token.
Class CA10Rule implements the rule CA10 (Do not use asm (the assembler macro facility of C++))
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CA11Rule implements the rule CA11 (Do not use the keyword struct)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CA12Rule implements the rule CA12 (Do not use file scope
objects; use class scope instead)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CA13Rule implements the rule CA13 (Use the bool type of C++ for booleans)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CA14Rule implements the rule CA14 (Avoid pointer arithmetic)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CA1Rule implements the rule CA1 (Use new and delete instead
of malloc, calloc, realloc and free)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CA2Rule implements the rule CA2 (Use the iostream functions
rather than those defined in stdio)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CA3Rule implements the rule CA3 (Do not use the ellipsis
notation for function arguments)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CA4Rule implements the rule CA4 (Do not use preprocessor
macros, except for system provided macros)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CA5Rule implements the rule CA5 (The only permissible use of
#ifdef is to precede a block of non-portable code and to allow the
template declaration as CT1)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CA7Rule implements the rule CA7 (Use the integer constant 0
for the null pointer; don't use NULL)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CA9Rule implements the rule CA9 (Do not use union types)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CB1Rule implements the rule CB1 (Do not declare data members
to be public)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CB2Rule implements the rule CB2 (If a class has at least one
virtual method then it must have a public virtual destructor, or
(exceptionally) a protected destructor)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CB3Rule implements the rule CB3 (Always re-declare virtual functions as virtual in derived classes.)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CB4Rule implements the rule CB4 (Avoid multiple inheritance, except for abstract interfaces.)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CB5Rule implements the rule CB5 (Avoid the use of friend
declarations)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CC2Rule implements the rule CC2 (Use the new cast operators
(dynamic_cast and static_cast) instead of the C-Style casts)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CC3Rule implements the rule CC3 (Do not convert const objects to non-const)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CC4Rule implements the rule CC4 (Do not use \"reinterpret_cast\")
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CF1Rule implements the rule CF1 (Do not change a loop variable inside a for loop block)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CF2Rule implements the rule CF2 (All switch statements must have a default clause)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CF3Rule implements the rule CF3 (Each clause of a switch statement must end with "break".)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CF4Rule implements the rule CF4 (All "if statements" which do
not fit in one line must have brackets around the conditional
statement)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CH5Rule implements the rule CH5 (Use exception specification
to declare which exceptions might be thrown from a function.)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CI2Rule implements the rule CI2 (Functions which have a
return value must not modify their arguments nor have any side
effects)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CI3Rule implements the rule CI3 ((1) Pass by value
arguments which are not to be modified and are built-in-types or
small objects, (2) otherwise pass arguments of class types by
reference or, if necessary, by pointer)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CI4Rule implements the rule CI4 (Have operator= return *this)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CI5Rule implements the rule CI5 (Declare a pointer or
reference argument, passed to a function, as const if the function
does not change the object bound to it.)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CI6Rule implements the rule CI6 (The argument to a copy
constructor and to an assignment operator must be a const
reference)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CI7Rule implements the rule CI7 (In a class method do not
return pointer or non-const references to private data members)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CI8Rule implements the rule CI8 (Declare as const a member
function that does not affect the state of the object)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CI9Rule implements the rule CI9 (Do not let const member
functions change the state of the program)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CL10Rule implements the rule CL10 (Assignment member
functions must work correctly when the left and right operands are
the same object)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CL1Rule implements the rule CL1 (Declare each variable with
the smallest possible scope and initialize at the same time)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CL2Rule implements the rule CL2 (Do not use literals in expressions)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CL4Rule implements the rule CL4 (Do not use the same variable name in outer and inner scope)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CL5Rule implements the rule CL5 (Let the order in the
initializer list be the same as the order of the declarations in
the header file: first base classes, then data members.)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CL6Rule implements the rule CL6 (A function must never
return, or in any other way give access to, references or pointers
to local variables outside the scope in which they are declared)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CL8Rule implements the rule CL8 (A copy constructor is
mandatory, together with an assignment operator, if a class has a
built-in pointer member data)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CN2Rule implements the rule CN2 (A function must not use the
delete operator on any pointer passed to it as an argument)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CN3Rule implements the rule CN3 (Do not access or reference to a deleted object)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CN4Rule implements the rule CN4 (After deleting a pointer assign it to zero)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CO1Rule implements the rule CO1 (Header file must begin and end
with multiple-inclusion protection.)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CO2Rule implements the rule CO2 (Use forward declaration
instead of including a header file, if this is sufficient)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CO3Rule implements the rule CO3 (Each header file must
contain one class (or embedded or very tightly coupled classes)
declaration only
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CO4Rule implements the rule CO4 (Implementation files must
hold the member function definitions for a single class (or
embedded or very tightly coupled classes) as defined in the
corresponding header file)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CP10Rule implements the rule CP10 (Use long (not int) and
double (not float))
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CP8Rule implements the rule CP8 (Do not depend on the order
of evaluation of arguments to a function, in particular never use
++ and -- operators on method arguments in function calls)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CR1Rule implements the rule CR1 (Avoid duplicated code)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CR3Rule implements the rule CR3 (Typedefs are discouraged)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CS1Rule implements the rule CS1 (Do not declare global variables)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CS2Rule implements the rule CS2 (Use global functions only
for symmetric binary operators)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class CT1Rule implements the rule CT1 (Declare a template in a .h
file, as for any other class, but conditionally include the
definition at the end.)
It extends the abstract class Rule and implements the abstract method
check(Module module).
beginLine and beginColumn describe the position of the first character
of this token; endLine and endColumn describe the position of the
last character of this token.
beginLine and beginColumn describe the position of the first character
of this token; endLine and endColumn describe the position of the
last character of this token.
Look for the variable declaration whose name is "nameToBeFound" and
return the ScopeManager in which it is defined (if found),
filling "typeToBeFound" with the variable type.
Look for the variable declaration whose name is "nameToBeFound" and
return the ScopeManager in which it is defined (if found),
filling "typeToBeFound" with the variabl type.
Look for the variable declaration whose name is "nameToBeFound" and
return the ScopeManager in which it is defined (if found),
filling "typeToBeFound" with the variable type.
Look for the variable declaration whose name is "nameToBeFound" and
return the ScopeManager in which it is defined (if found),
filling "typeToBeFound" with the variable type.
Look for the variable declaration whose name is "nameToBeFound" and
return the ScopeManager in which it is defined (if found),
filling "typeToBeFound" with the variable type.
Look for the variable declaration whose name is "nameToBeFound" and
return the ScopeManager in which it is defined (if found),
filling "typeToBeFound" with the variable type.
Look for the variable declaration whose name is "name" and
return the ScopeManager in which it is defined (if found),
filling "type" with the variabl type.
Class GC1Rule implements the rule GC1 (Exceptions and templates
should be used carefully)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class GC2Rule implements the rule GC2 (When only referring to
pointers or references to types defined in the header file it is
often not necessary to include that file.
Class NC5Rule implements the rule NC5 (Start class names, typedefs
and enum types with an uppercase letter)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class NC6Rule implements the rule NC6 (Start names of variables and functions with a lowercase letter)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class NC7Rule implements the rule NC7 (In names that consist of
more than one word, write the words together, and start each
word that follows the first with an upper case letter)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class NF1Rule implements the rule NF1 (The name of the header file
must be the same of the class it defines, with a suffix ".h"
appended.)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class NF2Rule implements the rule NF2 (The name of the implementation file
must be the same of the class it implements, with a suffix ".cxx"
appended.)
It extends the abstract class Rule and implements the abstract method
check(Module module)
Class NI1Rule implements the rule NI1 (Do not create very similar names)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class NI2Rule implements the rule NI2 (Do not use identifiers that
begin with an underscore)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Inserts a name into the table to say that it is the name of a variable
and therefore it is NOT the name of a type, thus overriding any outer
type definition with the same name.
Processes a file created with the methods
dumpBaseClassGraphForDotty or dumpCompleteClassGraphForDotty,
adding triangles and diamonds for the generalization and
aggregation (composition, containment) relations.
Class RC10Rule implements the rule RC10 (A class that has a member
datum with a type which is a built-in pointer should have a copy
constructor and an assignment operator)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class RC12Rule implements the rule RC12 (Dummy argument names in
member function declarations should be always provided, apart for
arguments that are not used.)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class RC14Rule implements the rule RC14 (Data member should be
declared as "private" or "protected")
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class RC16Rule implements the rule RC16 (Data member of a class
must not be redefined in derived classes)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class RC3Rule implements the rule RC3 (Header file begin and end
with multiple-inclusion protection, only \"_\" are allowed)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class RC5Rule implements the rule RC5 (Implementation files should
hold all the member functions for a single class (or embedded
classes) as defined in the corresponding header file)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class RC7Rule implements the rule RC7 (Global variables should be avoided)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class RC8Rule implements the rule RC8 (The usage of friend classes
should be avoided apart from I/O overloading where it is needed)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class RC9Rule implements the rule RC9 (All classes containing at
least one virtual function must have a virtual destructor
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class RN13Rule implements the rule RN13 (Local variables names
start with a lower case letter)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class RN15Rule implements the rule RN15 (Global variables names
start with a prefix "gAli")
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class RN17Rule implements the rule RN17 (Constants, including names
in enumeration types and constant statics start with a prefix "k")
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class RN3Rule implements the rule RN3 (No special characters in
names are allowed (_, #, $, &, @, -, %))
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class RN5Rule implements the rule RN5 (Implementation file names are
derived from the class name and have the suffix ".cxx")
It extends the abstract class Rule and implements the abstract method
check(Module module)
Class RN6Rule implements the rule RN6
(Class names start with the prefix "Ali")
It extends the abstract class Rule and implements the abstract method
check(Module module)
Class RS1Rule implements the rule RS1 (Each class contains a
description of the class functionality placed at the beginning of
the class header file and an extensive description at the beginning
of the class implementation file).
Class RS2Rule implements the rule RS2 (All data members of a class
are described by a short comment following the data member
declaration on the same line).
Class RS3Rule implements the rule RS3 (Member functions comments
should be put on the new line after the first "{")
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class RS4Rule implements the rule RS4 (Header files should not have
methods bodies inside the class definitions in case they do not fit
on one or two lines or when the inline function has unused
arguments).
Class RS5Rule implements the rule RS5 (There is no need to use the
keyword "inline" when defining the body of a function in the class
definition)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class SC1Rule implements the rule SC1 (Use \"//\" for comments)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class SG2Rule implements the rule SG2 (Keep the ordering of methods
in the header file and in the source file identical.)
It extends the abstract class Rule and implements the abstract method
check(Module module).
Class SG4Rule implements the rule SG4 (Limit line length to 120
character positions (including white space and expanded tabs))
It extends the abstract class Rule and implements the abstract method
check(Module module).
The class StateAnalyzer does not produce a diagram, but supports
its manual creation through a text file containing the class fields
and the methods that modify these fields (file
stateDiagram.txt).