Static Analysis Light

SA0033: Unused variables

SA0028: Overlapping memory areas

Sample:

In the following sample both variables use byte 21, i.e. the memory areas of the variables overlap.

PROGRAM MAIN
VAR
    nVar1 AT%QB21  : INT;        // => SA0028 
    nVar2 AT%QD5   : DWORD;      // => SA0028 
END_VAR

SA0006: Write access from several tasks

See also rule SA0103.

Call corresponds to write access Please note that calls are interpreted as write access. For example, calling a method for a function block instance is regarded as a write access to the function block instance. A more detailed analysis of accesses and calls is not possible, e.g. due to virtual calls (pointers, interface). To deactivate rule SA0006 for a variable (e.g. for a function block instance), the following attribute can be inserted above the variable declaration: {attribute 'analysis' := '-6'}

Examples:

The two global variables nVar and bVar are written by two tasks.

Global variable list:

VAR_GLOBAL
    nVar  : INT;
    bVar  : BOOL;
END_VAR

Program MAIN_Fast, called from the task PlcTaskFast:

nVar := nVar + 1;                // => SA0006 
bVar := (nVar > 10);             // => SA0006

Program MAIN_Slow, called from the task PlcTaskSlow:

nVar := nVar + 2;                // => SA0006 
bVar := (nVar < -50);            // => SA0006

SA0004: Multiple write access on output

This rule cannot be disabled via a pragma or attribute! For more information on attributes, see Pragmas and attributes.

Sample:

Global variable list:

VAR_GLOBAL
    bVar     AT%QX0.0 : BOOL;
    nSample  AT%QW5   : INT;
END_VAR

MAIN program:

PROGRAM MAIN
VAR
    nCondition        : INT;
END_VAR

IF nCondition < INT#0 THEN
    bVar    := TRUE;             // => SA0004
    nSample := INT#12;           // => SA0004 
END_IF
 
CASE nCondition OF
    INT#1:
        bVar := FALSE;           // => SA0004
 
    INT#2:
        nSample := INT#11;       // => SA0004 
 
ELSE
     bVar    := TRUE;            // => SA0004
     nSample := INT#9;           // => SA0004 
END_CASE

SA0027: Multiple usage of name

Sample:

The following sample generates error/warning SA0027, since the library Tc2_Standard is referenced in the project, which provides the function block TON.

PROGRAM MAIN
VAR
    ton  : INT;                  // => SA0027
END_VAR

SA0167: Report temporary FunctionBlock instances

Examples:

Method FB_Sample.SampleMethod:

METHOD SampleMethod : INT
VAR_INPUT
END_VAR
VAR
    fbTrigger : R_TRIG;          // => SA0167
END_VAR

Function F_Sample:

FUNCTION F_Sample : INT
VAR_INPUT
END_VAR
VAR
    fbSample  : FB_Sample;       // => SA0167
END_VAR

MAIN program:

PROGRAM MAIN
VAR_TEMP
    fbSample  : FB_Sample;       // => SA0167
    nReturn   : INT;
END_VAR

nReturn := F_Sample();

SA0175: Suspicious operation on string

Examples:

VAR
    sVar  : STRING;
    pVar  : POINTER TO STRING;
    nVar  : INT;
END_VAR

// 1) SA0175: Suspicious operation on string: Index access
sVar[2];                         // => SA0175
 
// 2) SA0175: Suspicious operation on string: Possible index access
pVar := ADR(sVar);               // => SA0175
 
// 3) SA0175: Suspicious operation on string: Possible index access
nVar := FIND(sVar, 'a');         // => SA0175
 
// 4) SA0175: Suspicious operation on string: Literal '<...>' contains Non-ASCII character
sVar := '99€';                   // => SA0175
sVar := 'Ä';                     // => SA0175

Pragma {analysis ...}

You can use the pragma {analysis -/+<rule number>} in the implementation part of a programming block in order to disregard individual coding rules for the following code lines. Coding rules are deactivated by specifying the rule numbers preceded by a minus sign ("-"). For activation they are preceded by a plus sign ("+"). You can specify any number of rules in the pragma with the help of comma separation.

Insertion location:

• Deactivation of rules: In the implementation part of the first code line from which the code analysis is disabled with {analysis - ...}.
• Activation of rules: After the last line of the deactivation with {analysis + ...}.
• For rule SA0164, the pragma can also be inserted in the declaration part before a comment.

Syntax:

• Deactivation of rules:
• one rule: {analysis -<rule number>}
• several rules: {analysis -<rule number>, -<further rule number>, -<further rule number>}
• Activation of rules:
• one rule: {analysis +<rule number>}
• several rules: {analysis +<rule number>, +<further rule number>, +<further rule number>}

Samples:

Rule 24 (only typed literals permitted) is to be disabled for one line (i.e. in these lines it is not necessary to write "nTest := DINT#99") and then enabled again:

{analysis -24}
nTest := 99;
{analysis +24}
nVar := INT#2;

Specification of several rules:

{analysis -10, -24, -18}

Attribute {attribute 'analysis' := '...'}

You can use the attribute {attribute 'analysis' := '-<rule number>'} to switch off certain rules for individual declarations or for a complete programming object. The code rule is deactivated by specifying the rule number(s) with a minus sign in front. You can specify any number of rules in the attribute.

Insertion location:

above the declaration of a programming object or in the line above a variable declaration

Syntax:

• one rule: {attribute 'analysis' := '-<rule number>'}
• several rules: {attribute 'analysis' := '-<rule number>, -<further rule number>, -<further rule number>'}

Samples:

Rule 33 (unused variables) is to be disabled for all variables of the structure.

{attribute 'analysis' := '-33'}
TYPE ST_Sample :
STRUCT
    bMember  : BOOL;
    nMember  : INT;
END_STRUCT
END_TYPE

Checking of rules 28 (overlapping memory areas) and 33 (unused variables) is to be disabled for variable nVar1.

PROGRAM MAIN
VAR
    {attribute 'analysis' := '-28, -33'}
    nVar1 AT%QB21  : INT;
    nVar2 AT%QD5   : DWORD; 
 
    nVar3 AT%QB41  : INT;
    nVar4 AT%QD10  : DWORD;
END_VAR

Rule 6 (concurrent access) is to be disabled for a global variable, so that no error message is generated if write access to the variable occurs from more than one task.

VAR_GLOBAL
    {attribute 'analysis' := '-6'}
    nVar  : INT;
    bVar  : BOOL;
END_VAR

Attribute {attribute 'no-analysis'}

You can use the {attribute 'no-analysis'} attribute to exclude an entire programming object from the static analysis check. For this programming object no checks are carried out for the coding rules, naming conventions and forbidden symbols.

Insertion location:

above the declaration of a programming object

Syntax:

{attribute 'no-analysis'}

Samples:

{attribute 'qualified_only'}
{attribute 'no-analysis'}
VAR_GLOBAL
    …
END_VAR

{attribute 'no-analysis'}
PROGRAM MAIN
VAR
    …
END_VAR