| AHEF | Attribute hiding effectiveness factor | Classes that do access attributes / Classes that can access attributes. |
| AHF | Attribute hiding factor | Measures how class attributes (variables) are hidden from other classes. |
| AIF | Attribute inheritance factor | The sum of inherited variables divided by the total number of variables in a project. |
| CALLDENS | Call density | Average number of calls on a code line. Measures the modularity or structuredness. CALLDENS=CALLS/LLOC |
| CALLS | Number of procedure calls | Number of procedure call statements, including calls to subs, functions and declares, accesses to properties and the raising of events. Implicit calls (such as Form_Load) are not counted. |
| CBO | Coupling between Object Classes | Number of classes to which a class is coupled. Coupling is defined as method call or variable access. |
| CC | Cyclomatic complexity | McCabe cyclomatic complexity equals the number of execution paths through a procedure. Also known as V(C). |
| CC2 | Cyclomatic complexity with Booleans | CC2 equals the regular CC metric but each Boolean operator within a branching statement causes complexity to increase by one. Also called Extended cyclomatic complexity (ECC). |
| CC3 | Cyclomatic complexity without Cases | CC3 equals the regular CC metric, but each Select Case block is counted as one branch, not as multiple branches. |
| CF | Coupling factor | Measures the actual couplings among classes in relation to the maximum number of possible couplings. Also known as COF. |
| CIS | Class interface size | Size of class interface measured by number of non-private methods and variables. CIS=WMCnp + VARSnp |
| CLS | Number of classes | Number of classes defined in project. |
| CLSa | Number of abstract classes | Number of abstract classes defined in project. In VB.NET, an abstract class is declared MustOverride. In VB Classic, it's a skeleton class that defines an interface class for Implements. |
| CLSc | Number of concrete classes | Number of concrete classes defined in project. A concrete class is one that is not abstract (see CLSa). CLSc=CLS-CLSa |
| CONSTS | Number of consts | Number of constants, excluding enum constants. |
| CSZ | Class size | Size of class measured by number of methods and variables. CSZ=WMC + VARS |
| CTORS | Constructors | Constructors defined by class. VB.NET Sub New is a constructor, whereas VB Classic Class_Initialize is an event. |
| CTRL | Control density | Control density measures the amount of control statements. It equals the number of control statements divided by the number of all executable statements. CTRL=STMTc/STMTx |
| DATADENS | Data access density | Average number of variable access instructions per logical line of code. DATADENS=TRW/LLOC |
| DATE | Project date | Date of newest file in project. |
| DATEF | File date | File date. |
| DATEF | Average file date | Average file date. |
| DAYS | Days passed | Days passed between versions. |
| DC | Data complexity | Measures the internal complexity of a procedure. Calculated by dividing the number of input/output variables by SFOUT+1. Defined by Card & Agresti, also known as D(i). Used to calculate SYSC. DC=IOVariables/(SFOUT+1) |
| DCALLT | Depth of call tree | Maximum number of nested procedure calls from a procedure. Recursive calls are not counted. |
| DCOND | Depth of conditional nesting | Maximum number of nested conditional statements in a procedure. |
| dCONSTS | Number of dead consts | Number of unused constants. |
| DEAD | Deadness index | Evaluates the average percentage of dead code. DEAD=(dPROCS + dVARS + dCONSTS) / (PROCS + VARS + CONSTS) |
| DECDENS | Decision density | Indicates the density of decision statements in the code. Calculated as sum of procedural cyclomatic complexity divided by logical lines of code. DECDENS=Sum(CC)/LLOC |
| dENUMCS | Number of dead Enum constants | Number of unused enumeration constants. |
| dENUMS | Number of dead Enums | Number of unused enumeration names. |
| DIT | Depth of Inheritance Tree | Number of ancestor classes. |
| dLINES | Dead lines | Physical lines in dead procedures. |
| DLOOP | Depth of looping | Maximum number of nested loop statements in a procedure. |
| dPROCS | Number of dead procedures | Number of unused procedures. |
| dUDTS | Number of dead user-defined types | Number of unused user-defined types, that is, Type and/or Structure blocks. |
| dVARS | Number of dead variables | Number of unused variables. |
| ENUMCS | Number of Enum constants | Number of enumeration constant names. |
| ENUMR | Enum ratio | The percentage of Enum constants among all constants. ENUMR=ENUMCS/(ENUMCS+CONSTS) |
| ENUMS | Number of Enums | Number of enumeration names. |
| ENUMSZ | Average Enum size | Average number of constants in an Enum block. ENUMSZ=ENUMCS/ENUMS |
| EVENTS | Events | Events defined by class. This metric counts the event definitions, not event handlers. |
| FILES | Number of files | Number of files in project. |
| FLOWS | Data flows | Number of data flows into and out of a variable. FLOWS=READS*WRITES |
| FORMS | Number of forms | Number of real forms excluding any UserControls. |
| IC1 | Informational complexity | Fan-in multiplied by fan-out multiplied by procedure length (logical lines of code). IC1=IFIO*LLOC |
| IFIN | Informational fan-in | Amount of data read. Procedures called + parameters read + global variables read. |
| IFIO | Informational fan-in x fan-out | Fan-in multiplied by fan-out. IFIO=IFIN*IFOUT |
| IFOUT | Informational fan-out | Amount of data written. Procedures that call this procedure + ByRef parameters written to + global variables written to. |
| IIF | Internal inheritance factor | The relative amount of internal inheritance. Internal inheritance happens when a class inherits another class in the same system (not an external class). |
| IMPL | Implemented interfaces | Number of interfaces implemented by class. |
| INTERFS | Number of Interface definitions | Number of Interfaces defined in project. |
| IOg | Global I/O | Number of global and module-level variables accessed by a procedure. |
| IOg% | Global I/O ratio | Amount of data flow via global and module-level variables versus procedure parameters and function return values. IOg%=Sum(IOg) / Sum(IOg+IOp) |
| IOp | Parameter I/O | Number of parameters used or returned by a procedure. The function return value counts as one parameter (output parameter). |
| IOvars | Input and output variables | Total number of input and output variables for a procedure, including parameters and function return value. IOvars=IOg+IOp |
| kB | File size | File size in kilobytes. |
| kB | Project size | Project size in kilobytes. Includes all source files included in the analysis, excluding referenced files. |
| LCCi | Loose Class Cohesion | LCCi is 'LCC with inheritance'. LCC describes the connectedness of the methods in a class. LCC<1 indicates a non-cohesive class. LCC=1 indicates a cohesive class." |
| LCCl | Loose Class Cohesion (local) | LCCl is 'LCC without inheritance'. LCC describes the connectedness of the methods in a class. LCC<1 indicates a non-cohesive class. LCC=1 indicates a cohesive class." |
| LCOM1 | Lack of Cohesion of Methods (1) | A zero value indicates a cohesive class. A positive value indicates a class that should be split. Also known as LCOM. Defined by Chidamber & Kemerer. |
| LCOM2 | Lack of Cohesion of Methods (2) | The percentage of methods that do not access a specific attribute averaged over all attributes in the class. |
| LCOM3 | Lack of Cohesion of Methods (3) | Also known as LCOM*. Defined by Henderson-Sellers. Values of 1 and greater are considered extreme lack of cohesion. |
| LCOM4 | Lack of Cohesion of Methods (4) | Defined by Hitz & Montazeri. Value 1 indicates a good, cohesive class. Values 2 and greater are considered bad (lack of cohesion). Such a class should be split. LCOM4 is more suitable for VB than the other LCOMx variants. |
| LEAFS | Number of leaf classes | Number of leaf classes defined in project. A leaf class has no descendants. |
| LEN | Length of names | Average length of names defined in VB files, including everything in LENV, LENC and LENP, plus Types, Enums, Type fields, Enum constants, controls, classes, structures and modules. Excludes compiler constants. |
| LENC | Length of constant names | Average length of all constant names defined in VB files. Excludes enum constants and compiler constants. |
| LENP | Length of procedure name | Length of procedure name in characters. |
| LENP | Length of procedure names | Average length of procedure names defined in VB files, excluding event handlers and implementing procedures. Each property is counted only once. This metric may differ from the other LENP, which is defined for a slightly different set of procedures. |
| LENV | Length of variable and parameter names | Average length of names of variables, arrays and parameters defined in VB files, excluding parameters in event handlers and implementing procedures. |
| LENVgm | Length of variable name | Length of variable name in characters. |
| LINES | Physical lines | Physical source lines, including code, comments, empty comments and empty lines. This metric is what you would see with a simple text editor or line count program. |
| LLINES | Logical lines | Logical source lines, including code, comments, empty comments and empty lines. One logical line may be split on several physical lines by a line continuation character. LLINES=LLOC + LLOC' + LLOW |
| LLOC | Logical lines of code | Code lines count. One logical line may be split on several physical lines by a line continuation character. |
| LLOC' | Logical lines of comment | Comment lines count. All full-line comments count, even if empty. End-of-codeline comments not included. One logical line may be split on several physical lines by a line continuation character. |
| LLOC% | Code percentage | Percentage of code lines. Counted from logical lines. LLOC%=LLOC/LLINES |
| LLOC'% | Comment percentage | Percentage of comment lines. Counted as full-line comments per logical lines. LLOC'%=LLOC/LLINES |
| LLOCt | Lines in call tree | Logical lines of code in call tree. The number of lines that may potentially execute in a call to this procedure. Includes all procedures that may execute. |
| LLOW | Logical lines of whitespace | Logical lines of whitespace. This is mostly equal to physical lines of whitespace, that is lines that have no other content than spaces, tabs and the line continuation character. |
| LLOW% | Whitespace percentage | Percentage of whitespace lines. Counted from logical lines. LLOW%=LLOW/LLINES |
| maxDCALLT | Maximum depth of call tree | The depth of the largest call tree in the system: number of levels in the tree. maxDCALLT=Max(DCALLT) |
| maxDIT | Maximum depth of inheritance tree | maxDIT is the depth of the deepest inheritance tree. maxDIT=max(DIT) |
| maxSCALLT | Maximum size of call tree | The size of the largest call tree in the system: number of distinct procedures in the tree. maxSCALLT=Max(SCALLT) |
| MCOMM | Meaningful comments | Full-line and end-of-line comments that have meaningful content. |
| MCOMM% | Comment density | Meaningful comments divided by number of logical lines of code. MCOMM%=MCOMM/LLOC |
| MDLS | Number of standard modules | Number of standard modules: .bas files and Module blocks. |
| MHF | Method hiding factor | Measures how class methods are hidden from other classes. |
| MIF | Method inheritance factor | The sum of inherited methods divided by the total number of methods in a project. |
| MPC | Message-Passing Coupling | Number of procedure calls going outside of a class. Each call is counted once, whether it's early bound, late bound or polymorphic. |
| NOC | Number of Children | Number of immediate sub-classes that inherit from a class. |
| OHEF | Operation hiding effectiveness factor | Classes that do access operations / Classes that can access operations. |
| PARAMS | Procedure parameters | Number of formal parameters defined in procedure header. |
| PF | Polymorphism factor | Percentage of actual polymorphic definitions of all possible polymorphic definitions. Also known as POF. |
| PPF | Parametric polymorphism factor | Percentage of parameterized classes (generic classes). |
| PROCS | Number of procedures | Number of procedures, including subs, functions, property blocks, API declarations and events. |
| RB | Reuse benefit | Reuse benefit RB is the extent to which you reuse your procedures. A procedure that is being called at several locations is said to be reused. A procedure that is called just once or not at all is not reused. RB measures the overall amount of reuse in the entire system. |
| Rc | Reuse of constants | The average number of times you reuse your constants and enum constants. Rc=uses/count - 1 |
| READS | Reads from variable | Number of read instructions from variable. |
| RFC | Response for a Class First step | Number of methods that can potentially be executed in response to a message received a class. Counts only the first level of the call tree. |
| RFC' | Response for a Class | Number of methods that can potentially be executed in response to a message received a class. Counts the full call tree. |
| ROOTS | Number of root classes | Number of root classes defined in project. |
| RSYSC | Relative system complexity | Average system complexity among procedures. RSYSC=avg(SYSC) |
| RW | Reads and writes | Number of reads and writes. A single instruction may count both as a read and as a write. RW=READS+WRITES |
| S | Specialization ratio | Specialization ratio for classes. A class is specialized if it inherits from a parent class. In a project without superclasses, S is undefined. S=subclasses/superclasses |
| SC | Structural complexity | Measures the external complexity of a procedure. Equals the number of other procedures called squared. Defined by Card & Agresti, also known as S(i). Used to calculate SYSC. SC=SFOUT^2 |
| SCALLT | Size of call tree | Number of distinct procedures in the call tree of a procedure, not counting the procedure itself. |
| SDENS | Statement density | Average number of statements per logical line. SDENS=STMT/LLOC |
| SFIN | Structural fan-in | Number of procedures that call a procedure. |
| SFIN | Structural fan-in | Number of files that use a file. |
| SFOUT | Structural fan-out | Number of procedures that a procedure calls. |
| SFOUT | Structural fan-out | Number of files that a file uses. |
| STMT | Number of statements | Total number of all statements. |
| STMTc | Control statements | Number of control statements. A control statement is an executable statement that can alter the order in which statements are executed. |
| STMTd | Declarative statements | Number of declarative statements, which are: procedure headers, variable and constant declarations, all statements outside procedures. |
| STMTnc | Non-control statements | Number of non-control statements, which are executable statements that are neither control nor declarative statements. STMTnc=STMTx-STMTc |
| STMTx | Executable statements | Number of executable statements. A statement is executable if it is not declarative. Executable statements can only exist within procedures. STMTx=STMT-STMTd |
| SYSC | System complexity | Composite measure of complexity inside procedures and between them. Defined by Card & Agresti, also known as C(i), or design complexity. SYSC=SC+DC |
| SYSC | System complexity | Sum of SYSC over all procedures. Measures the total complexity of a project. SYSC=Sum(SYSC) over all procedures |
| TCC | Total cyclomatic complexity | Total cyclomatic complexity equals the total number of decisions + 1. TCC=Sum(CC)-Count(CC)+1 |
| TCCi | Tight Class Cohesion | TCCi is 'TCC with inheritance'. TCC tells the connection density of the methods in a class. TCC varies from 0 (totally non-cohesive) to 1 (maximally cohesive). |
| TCCl | Tight Class Cohesion (local) | TCCl is 'TCC without inheritance'. TCC tells the connection density of the methods in a class. TCC varies from 0 (totally non-cohesive) to 1 (maximally cohesive). |
| TREADS | Total variable reads | Number of read instructions from global and module-level variables. TREADS=Sum(READS) |
| TRW | Total variable reads+writes | Number of reads from and writes to global and module-level variables. TRW=TREADS+TWRITES |
| TWRITES | Total variable writes | Number of write instructions to global and module-level variables. TWRITES=Sum(WRITES) |
| U | Reuse ratio | Reuse ratio for classes. A class is reused if it has descendants. U=(CLS-LEAFS)/CLS |
| UDTS | Number of user-defined types | Number of user-defined types, that is, Type and/or Structure blocks. |
| UNIQ | Name uniqueness ratio | Number of unique names divided by the total number of names. All the names in LEN are counted. |
| VARS | Variables defined by class | Number of variables defined by class. Does not include inherited variables. |
| VARS | Number of variables | Number of variables, including arrays, parameters and local variables. |
| VARSgm | Global and module-level variables | Total number of global and module-level variables and arrays. |
| VARSi | Variables defined+inherited | Number of variables defined and inherited by class. |
| VARSloc | Local variables | Total number of procedure local variables and arrays, excluding parameters. |
| VARSloc | Local variables | Number of procedure local variables and arrays, excluding parameters. |
| VARSnp | Non-private variables | Number of non-private variables defined by class. VARS excluding private variables. |
| VARUSR | Variable users | Number of modules that use a variable. |
| WMC | Weighted Methods Per Class | Number of subs, functions and property procedures in class. |
| WMCi | Methods defined and inherited by class | WMC including inherited methods. |
| WMCnp | Non-private methods defined by class | WMC excluding private methods. |
| WRITES | Writes to variable | Number of write instructions to variable. |
| XQT | Executability | Executability measures the amount of executable statements. It equals the number of executable statements divided by the number of all statements. XQT=STMTx/STMT |