# axString

Name:
<h4><span class="ruleid">Rule Analysis-GlobalOptions</span> <span class="ruletext">Global configuration options for analysis</span></h4>


Name:
<h4><span class="ruleid">Rule StaticSemanticAnalysis</span> <span class="ruletext">Classic semantic analysis involving pointers, data-flow, numerical values. This analysis always analyses the whole program.</span></h4>Some checks require a more involved analysis of the possible runtime
        effects and values. These properties are undecidable in nature and the
        attempt to approximate them typically requires a lot more runtime and
        memory than other checks and often produces some false positives.
        


Name:
<h4><span class="ruleid">Rule CodeAnnotations</span> <span class="ruletext">Markup comments to influence analysis</span></h4>


Name:
<h4><span class="ruleid">Rule NextLine</span> <span class="ruletext">Affects style violations on the next line.</span></h4>Code annotations are special comments that can be used to suppress
        issues and/or to assign a justification to an issue. This rule
        describes comments that can be used for such code annotations. Each code
        annotation rule specifies the syntax for such a comment (option
        <a href="#./format">format</a>).
        The code annotation rule can limit the affected issues by, for example:
        <ul>
        <li>the code portion (<a href="#./scope">scope</a>) where an issue is
        reported</li>
        <li>the issue <a href="#./kind">kind(s)</a> like style violations vs. metric
        issues</li>
        <li>the <a href="#./rule">rule</a> which reports the issue,</li>
        <li>the <a href="#./message">message</a>,
        <a href="#./message_key">message key</a> or <a href="#./entity">entity</a>
        being reported in the issue</li>
        </ul>
        These options have a similar structure: First, you set their <code>group</code>
        attribute to the regular expression group in the format string which defines
        the relevant portion of the comment for this field (group 0 is the complete
        comment, group 1 the first group in parens, etc.). Then choose as
        <code>value</code> attribute how the required information should be extracted
        from the selected comment portion, or provide that information directly.

        You can define your own comment format by copying the rule and changing
        options as required, e.g. to use your company's name instead of
        <code>Axivion</code> in the comments.
            <p>
            Assuming the default settings for this rule, a code annotation example
            comment using this rule would be:<p>
            /* AXIVION Next Line MisraC2012-20.5: my justification */
            
            <p>
Note that for architecture suppressions, line-based suppressions may also affect additional lines that cause the creation of the same source dependency edges.<br />
For example:
<pre><code>
void f()
{
    /* AXIVION Next Line Architecture-GravisArchitecture: my justification */
    g(); // will be suppressed
    g(); // will also be suppressed, because the same source dependency edge is affected
}
</code></pre>
<p>
            


Name:
<h4><span class="ruleid">Rule EntryPoints-EntriesByMacro</span> <span class="ruletext">Consider routines where the signature comes from a macro expansion of selected macros as externally called entry points.</span></h4>
<p>This rule identifies additional entry points based on macros
used to expand the routine declaration.</p>
<p>This rule typically is used to easily add entry points where
your code uses a macro to form the declaration of functions
which are IRQ handlers or similar.
For example:</p>
<pre>
#define ISR(name) my_##name
void ISR(interrupt)();
</pre>
<p>Configuration of entry points is required for
<a href="#DeadCodeDetection">dead code analysis</a> and
<a href="#StaticSemanticAnalysis">static semantic analysis</a>.</p>


Name:
<h4><span class="ruleid">Rule EntryPoints-EntriesByName</span> <span class="ruletext">Consider routines matching the given name pattern as externally called entry points.</span></h4>
<p>This rule identifies additional entry points based on their name.</p>
<p>This rule typically is used to easily add entry points where
your code has no special markup for these entry points. You can
simply enumerate the relevant functions here (globbing patterns
are supported). The name used in this rule is the qualified name
of the function, that is, it includes enclosing scope information.
If you need higher precision (e.g, to distinguish overloads), you
can instead use
<a href="#EntryPoints-EntriesByLinkname">EntryPoints-EntriesByLinkname</a>.
For example:</p>
<pre>
void my_interrupt();
void my_other_interrupt();
</pre>
<p>Cases like these would be found by this rule when you add
<code>*interrupt*</code> to the names.</p>
<p>Configuration of entry points is required for
<a href="#DeadCodeDetection">dead code analysis</a>
and <a href="#StaticSemanticAnalysis">static semantic analysis</a>.</p>


Name:
<h4><span class="ruleid">Rule Externals-AbstractReferenceTypes</span> <span class="ruletext">User-provided list of smartpointer and iterator types for which information is tracked by specialized analyses.</span></h4>This rule specifies types that are used as smart pointer or iterator types abstractions (both being
         refered to as abstract references) in the analyzed code.
         Analyses specialized in tracking values for smart pointers and iterators (e.g. those checking for null pointer
         dereferences) can track additional information about instances of these types. Additionally, the behaviour of methods
         influencing the value of abstract references (e.g. <code>operator==()</code> for <code>std::shared_ptr</code>)
         can be specified by providing conditions in the <code>postcondition</code> option of
         the corresponding external rule for the method to get precise results. For more information about
         configuring the analysis see TODO in the documentation.


Name:
<h4><span class="ruleid">Rule Externals-C++STL.FindOperations</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-C++STL.LockGuard</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-C++STL.NonNullAllocator</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-C++STL.NonThrowingAllocator</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-C++STL.PMRDeallocator</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-C++STL.StringConverters</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdBitSet.BitSet</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdBitSet.BitSetFromCharArray</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdBitSet.BitSetFromString</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdBitSet.Flip</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdBitSet.Reset</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdBitSet.Set</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdBitSet.Test</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdBitSet.ToULLong</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdBitSet.ToULong</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdList.At</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdList.Begin</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdList.CBegin</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdList.CEnd</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdList.End</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdList.Find</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdList.RBegin</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdList.REnd</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdMap.At</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdMap.Begin</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdMap.CBegin</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdMap.CEnd</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdMap.End</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdMap.Find</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdMap.RBegin</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdMap.REnd</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdReverseIterator</span> <span class="ruletext"></span></h4>


Name:
<h4><span class="ruleid">Rule Externals-StdReverseIterator.Deref</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdReverseIterator.Eq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdReverseIterator.IncrementOperations</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdReverseIterator.NotEq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdSharedPtr.Assign</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdSharedPtr.Deref</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdSharedPtr.MakeShared</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdSharedPtr.OperatorNullptrEqualLeft</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdSharedPtr.OperatorNullptrEqualRight</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdSharedPtr.OperatorNullptrNotEqualLeft</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdSharedPtr.OperatorNullptrNotEqualRight</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdSharedPtr.SharedPtr</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdSharedPtr.ToBool</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdString.Append</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdString.Assign</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdString.At</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdString.CStr</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdString.Copy</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdString.Erase</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdString.Insert</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdString.PushBack</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdString.Replace</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdString.Reserve</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdString.Resize</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdString.SubStr</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdSharedPtr.MakeUnique</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUniquePtr.Assign</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUniquePtr.Deref</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUniquePtr.OperatorNullPtrEqualLeft</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUniquePtr.OperatorNullPtrEqualRight</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUniquePtr.OperatorNullPtrNotEqualLeft</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUniquePtr.OperatorNullPtrNotEqualRight</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUniquePtr.ToBool</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUniquePtr.UniquePtr</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUnorderedMap.At</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUnorderedMap.Begin</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUnorderedMap.CBegin</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUnorderedMap.CEnd</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUnorderedMap.End</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUnorderedMap.Find</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUnorderedMap.RBegin</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdUnorderedMap.REnd</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdVector.At</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdVector.Begin</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdVector.End</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdVector.Find</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdVector.RBegin</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdVector.REnd</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdVector.Reserve</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-StdVector.Resize</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-CStdLib.Allocator</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-CStdLib.Errno</span> <span class="ruletext">Configuration of the implementation of the global &#x27;errno&#x27; variable provided in the C stdlib.</span></h4>
        <p>The <em>number of last error</em> of C system library calls is provided by
        the symbol <code>errno</code>. This symbol can be implemented in different ways
        in the header <code>errno.h</code>, e.g. as a global variable or as a macro
        dereferencing the result of a function call. E.g.:</p>
        <ul>
        <li><code>errno_t errno;</code></li>
        <li><code>#define errno (*_errno())</code></li>
        </ul>
        <p>Please use this configuration rule to adapt the detection mechanism to the
        project's standard library's <code>errno.h</code>.</p>
        <p>In addition, the predefined set of
        <a href="#./out_of_band_error_funcs">out-of-band</a> and
        <a href="#./in_band_error_funcs">in-band</a> <code>errno</code> setting
        functions may be adapted.</p>


Name:
<h4><span class="ruleid">Rule Externals-CStdLib.Memcpy</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-CStdLib.Memset</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-CStdLib.NoReturn</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-CStdLib.NonNullReturn</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-CStdLib.Read</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-CStdLib.Strcpy</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-Clang.Iter.Deref</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-Clang.Iterators.Eq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-Clang.Iterators.IncrementOperations</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-Clang.Iterators.NotEq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.CXX11List.Iterator.BeginOperations</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.CXX11List.Iterator.EndOperations</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.Node.Iterator.Deref</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.Node.Iterator.Eq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.Node.Iterator.IncrementOperations</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.Node.Iterator.NotEq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.NormalIterator.Deref</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.NormalIterator.Eq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.NormalIterator.IncrementOperations</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.NormalIterator.NotEq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.RbTreeConstIterator.CopyConstrutor</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.RbTreeConstIterator.Deref</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.RbTreeConstIterator.Eq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.RbTreeConstIterator.IncrementOperations</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.RbTreeConstIterator.NotEq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.RbTreeIterator.CopyConstrutor</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.RbTreeIterator.Deref</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.RbTreeIterator.Eq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.RbTreeIterator.IncrementOperations</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.RbTreeIterator.NotEq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.SharedPtr.DerefInternal</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.SharedPtr.OperatorNullptrEqualLeftInternal</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-GNU.SharedPtr.OperatorNullptrEqualRightInternal</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-BuiltinExpect</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.BasicString.Destructor</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Container.Begin</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Container.CBegin</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Container.CEnd</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Container.End</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Container.Find</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Container.RBegin</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Container.REnd</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.List.Iterator.CopyConstructor</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.List.Iterator.Deref</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.List.Iterator.Destructor</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.List.Iterator.Eq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.List.Iterator.NotEq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Tree.Iterator.Deref</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Tree.Iterator.Eq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Tree.Iterator.NotEq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Vector.Iterator.Deref</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Vector.Iterator.Destructor</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Vector.Iterator.Eq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Vector.Iterator.IncrementOperations</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-MSVC.Vector.Iterator.NotEq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-QSharedPointerDeref</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Externals-QSharedPointerEq</span> <span class="ruletext">User-provided summary of relevant effects of a function.</span></h4>This rule describes the effects of a function specifically for
        pointer/semantic analysis and several error checks. This can, for example,
        be used to tell the analysis about relevant effects of calls to the function
        if the function body itself is unknown to the analysis because it is only
        linked into the project as binary code and thus not seen during analysis
        (e.g. functions from third-party libraries that your project links against).
        


Name:
<h4><span class="ruleid">Rule Resources-C++ArrayHeapMemory</span> <span class="ruletext">Representation of heap memory as allocated by array-new operator new[].</span></h4>This rule describes a resource which can by dynamically allocated
        and released in the program being analyzed. Together with the corresponding
        configuration of the allocator/deallocator functions under the
        <a href="#Externals">Externals</a>
        rulegroup, this knowledge is used by the pointer/semantic analysis and several
        error checks. To add your own resource, proceed as follows:
        <ul>
            <li>Copy an existing resource rule and rename the copy appropriately.
                For example, copy
                <a href="#Resources-CustomResource">Resources-CustomResource</a> and
                name the new rule <code>Resources-AdditionalResource</code>.</li>
            <li>Set the options of this new resource rule, especially the names
                of allocator and deallocator functions. In our example, let us assume
                that you have to call a function called
                <code>allocate_additional_resource</code>
                in order to create an instance of the resource, and that a call to
                <code>deallocate_additional_resource</code> is needed to release it
                again.
                Then you would set <code>Resources-AdditionalResource/allocators</code>
                to a set containing just <code>allocate_additional_resource</code>, and
                you would set <code>Resources-AdditionalResource/deallocators</code>
                to the set consisting of <code>deallocate_additional_resource</code>.
                If the analysis includes the implementation of the (de)allocator
                functions, option
                <code>Resources-AdditionalResource/allow_defined_functions</code>
                should be set.</li>
            <li>Create external function summaries for the allocator and deallocator
                functions (copy or edit existing rules). These summaries provide details
                about the specific function, e.g. whether they always return a fresh
                allocation or also sometimes <code>nullptr</code>, the semantics of
                their parameters, etc.
                With those summaries you can also distinguish different overloads,
                e.g. for <code>operator new</code>.
                If there is no external function summary for the (de)allocators,
                a default behavior is assumed (freeing the first argument, returning
                a freshly allocated object).
                In our example we just add <code>allocate_additional_resource</code> to
                option
                <a href="#Externals-C++STL.NonNullAllocator/functions">Externals-C++STL.NonNullAllocator/functions</a>
                to signal that this function returns a freshly created instance, and
                that it cannot return <code>nullptr</code>; for the deallocation we use
                the default behavior and thus do not have to modify any rule.
                </li>
            <li>Add the new resource to the set of resources being checked at those
                checks that should respect it. In our example we want to include
                the additional resource in check
                <a href="#MisraC2023Directive-4.1">MisraC2023Directive-4.1</a>
                and thus add the resource name <code>AdditionalResource</code> to the
                already existing list of resources in option
                <a href="#MisraC2023Directive-4.1/resources">MisraC2023Directive-4.1/resources</a>.</li>
        </ul>
        The name of the resource is the rule name (after the last hyphen, if any).
        


Name:
<h4><span class="ruleid">Rule Resources-C++HeapMemory</span> <span class="ruletext">Representation of heap memory as allocated by operator new.</span></h4>This rule describes a resource which can by dynamically allocated
        and released in the program being analyzed. Together with the corresponding
        configuration of the allocator/deallocator functions under the
        <a href="#Externals">Externals</a>
        rulegroup, this knowledge is used by the pointer/semantic analysis and several
        error checks. To add your own resource, proceed as follows:
        <ul>
            <li>Copy an existing resource rule and rename the copy appropriately.
                For example, copy
                <a href="#Resources-CustomResource">Resources-CustomResource</a> and
                name the new rule <code>Resources-AdditionalResource</code>.</li>
            <li>Set the options of this new resource rule, especially the names
                of allocator and deallocator functions. In our example, let us assume
                that you have to call a function called
                <code>allocate_additional_resource</code>
                in order to create an instance of the resource, and that a call to
                <code>deallocate_additional_resource</code> is needed to release it
                again.
                Then you would set <code>Resources-AdditionalResource/allocators</code>
                to a set containing just <code>allocate_additional_resource</code>, and
                you would set <code>Resources-AdditionalResource/deallocators</code>
                to the set consisting of <code>deallocate_additional_resource</code>.
                If the analysis includes the implementation of the (de)allocator
                functions, option
                <code>Resources-AdditionalResource/allow_defined_functions</code>
                should be set.</li>
            <li>Create external function summaries for the allocator and deallocator
                functions (copy or edit existing rules). These summaries provide details
                about the specific function, e.g. whether they always return a fresh
                allocation or also sometimes <code>nullptr</code>, the semantics of
                their parameters, etc.
                With those summaries you can also distinguish different overloads,
                e.g. for <code>operator new</code>.
                If there is no external function summary for the (de)allocators,
                a default behavior is assumed (freeing the first argument, returning
                a freshly allocated object).
                In our example we just add <code>allocate_additional_resource</code> to
                option
                <a href="#Externals-C++STL.NonNullAllocator/functions">Externals-C++STL.NonNullAllocator/functions</a>
                to signal that this function returns a freshly created instance, and
                that it cannot return <code>nullptr</code>; for the deallocation we use
                the default behavior and thus do not have to modify any rule.
                </li>
            <li>Add the new resource to the set of resources being checked at those
                checks that should respect it. In our example we want to include
                the additional resource in check
                <a href="#MisraC2023Directive-4.1">MisraC2023Directive-4.1</a>
                and thus add the resource name <code>AdditionalResource</code> to the
                already existing list of resources in option
                <a href="#MisraC2023Directive-4.1/resources">MisraC2023Directive-4.1/resources</a>.</li>
        </ul>
        The name of the resource is the rule name (after the last hyphen, if any).
        


Name:
<h4><span class="ruleid">Rule Resources-C++PMR</span> <span class="ruletext">Representation of heap memory as managed by memory_resources from std::pmr.</span></h4>This rule describes a resource which can by dynamically allocated
        and released in the program being analyzed. Together with the corresponding
        configuration of the allocator/deallocator functions under the
        <a href="#Externals">Externals</a>
        rulegroup, this knowledge is used by the pointer/semantic analysis and several
        error checks. To add your own resource, proceed as follows:
        <ul>
            <li>Copy an existing resource rule and rename the copy appropriately.
                For example, copy
                <a href="#Resources-CustomResource">Resources-CustomResource</a> and
                name the new rule <code>Resources-AdditionalResource</code>.</li>
            <li>Set the options of this new resource rule, especially the names
                of allocator and deallocator functions. In our example, let us assume
                that you have to call a function called
                <code>allocate_additional_resource</code>
                in order to create an instance of the resource, and that a call to
                <code>deallocate_additional_resource</code> is needed to release it
                again.
                Then you would set <code>Resources-AdditionalResource/allocators</code>
                to a set containing just <code>allocate_additional_resource</code>, and
                you would set <code>Resources-AdditionalResource/deallocators</code>
                to the set consisting of <code>deallocate_additional_resource</code>.
                If the analysis includes the implementation of the (de)allocator
                functions, option
                <code>Resources-AdditionalResource/allow_defined_functions</code>
                should be set.</li>
            <li>Create external function summaries for the allocator and deallocator
                functions (copy or edit existing rules). These summaries provide details
                about the specific function, e.g. whether they always return a fresh
                allocation or also sometimes <code>nullptr</code>, the semantics of
                their parameters, etc.
                With those summaries you can also distinguish different overloads,
                e.g. for <code>operator new</code>.
                If there is no external function summary for the (de)allocators,
                a default behavior is assumed (freeing the first argument, returning
                a freshly allocated object).
                In our example we just add <code>allocate_additional_resource</code> to
                option
                <a href="#Externals-C++STL.NonNullAllocator/functions">Externals-C++STL.NonNullAllocator/functions</a>
                to signal that this function returns a freshly created instance, and
                that it cannot return <code>nullptr</code>; for the deallocation we use
                the default behavior and thus do not have to modify any rule.
                </li>
            <li>Add the new resource to the set of resources being checked at those
                checks that should respect it. In our example we want to include
                the additional resource in check
                <a href="#MisraC2023Directive-4.1">MisraC2023Directive-4.1</a>
                and thus add the resource name <code>AdditionalResource</code> to the
                already existing list of resources in option
                <a href="#MisraC2023Directive-4.1/resources">MisraC2023Directive-4.1/resources</a>.</li>
        </ul>
        The name of the resource is the rule name (after the last hyphen, if any).
        


Name:
<h4><span class="ruleid">Rule Resources-CalendarTime</span> <span class="ruletext">Representation of the result of gmtime() or localtime().</span></h4>This rule describes a resource which can by dynamically allocated
        and released in the program being analyzed. Together with the corresponding
        configuration of the allocator/deallocator functions under the
        <a href="#Externals">Externals</a>
        rulegroup, this knowledge is used by the pointer/semantic analysis and several
        error checks. To add your own resource, proceed as follows:
        <ul>
            <li>Copy an existing resource rule and rename the copy appropriately.
                For example, copy
                <a href="#Resources-CustomResource">Resources-CustomResource</a> and
                name the new rule <code>Resources-AdditionalResource</code>.</li>
            <li>Set the options of this new resource rule, especially the names
                of allocator and deallocator functions. In our example, let us assume
                that you have to call a function called
                <code>allocate_additional_resource</code>
                in order to create an instance of the resource, and that a call to
                <code>deallocate_additional_resource</code> is needed to release it
                again.
                Then you would set <code>Resources-AdditionalResource/allocators</code>
                to a set containing just <code>allocate_additional_resource</code>, and
                you would set <code>Resources-AdditionalResource/deallocators</code>
                to the set consisting of <code>deallocate_additional_resource</code>.
                If the analysis includes the implementation of the (de)allocator
                functions, option
                <code>Resources-AdditionalResource/allow_defined_functions</code>
                should be set.</li>
            <li>Create external function summaries for the allocator and deallocator
                functions (copy or edit existing rules). These summaries provide details
                about the specific function, e.g. whether they always return a fresh
                allocation or also sometimes <code>nullptr</code>, the semantics of
                their parameters, etc.
                With those summaries you can also distinguish different overloads,
                e.g. for <code>operator new</code>.
                If there is no external function summary for the (de)allocators,
                a default behavior is assumed (freeing the first argument, returning
                a freshly allocated object).
                In our example we just add <code>allocate_additional_resource</code> to
                option
                <a href="#Externals-C++STL.NonNullAllocator/functions">Externals-C++STL.NonNullAllocator/functions</a>
                to signal that this function returns a freshly created instance, and
                that it cannot return <code>nullptr</code>; for the deallocation we use
                the default behavior and thus do not have to modify any rule.
                </li>
            <li>Add the new resource to the set of resources being checked at those
                checks that should respect it. In our example we want to include
                the additional resource in check
                <a href="#MisraC2023Directive-4.1">MisraC2023Directive-4.1</a>
                and thus add the resource name <code>AdditionalResource</code> to the
                already existing list of resources in option
                <a href="#MisraC2023Directive-4.1/resources">MisraC2023Directive-4.1/resources</a>.</li>
        </ul>
        The name of the resource is the rule name (after the last hyphen, if any).
        


Name:
<h4><span class="ruleid">Rule Resources-Environment</span> <span class="ruletext">Representation of the result of getenv().</span></h4>This rule describes a resource which can by dynamically allocated
        and released in the program being analyzed. Together with the corresponding
        configuration of the allocator/deallocator functions under the
        <a href="#Externals">Externals</a>
        rulegroup, this knowledge is used by the pointer/semantic analysis and several
        error checks. To add your own resource, proceed as follows:
        <ul>
            <li>Copy an existing resource rule and rename the copy appropriately.
                For example, copy
                <a href="#Resources-CustomResource">Resources-CustomResource</a> and
                name the new rule <code>Resources-AdditionalResource</code>.</li>
            <li>Set the options of this new resource rule, especially the names
                of allocator and deallocator functions. In our example, let us assume
                that you have to call a function called
                <code>allocate_additional_resource</code>
                in order to create an instance of the resource, and that a call to
                <code>deallocate_additional_resource</code> is needed to release it
                again.
                Then you would set <code>Resources-AdditionalResource/allocators</code>
                to a set containing just <code>allocate_additional_resource</code>, and
                you would set <code>Resources-AdditionalResource/deallocators</code>
                to the set consisting of <code>deallocate_additional_resource</code>.
                If the analysis includes the implementation of the (de)allocator
                functions, option
                <code>Resources-AdditionalResource/allow_defined_functions</code>
                should be set.</li>
            <li>Create external function summaries for the allocator and deallocator
                functions (copy or edit existing rules). These summaries provide details
                about the specific function, e.g. whether they always return a fresh
                allocation or also sometimes <code>nullptr</code>, the semantics of
                their parameters, etc.
                With those summaries you can also distinguish different overloads,
                e.g. for <code>operator new</code>.
                If there is no external function summary for the (de)allocators,
                a default behavior is assumed (freeing the first argument, returning
                a freshly allocated object).
                In our example we just add <code>allocate_additional_resource</code> to
                option
                <a href="#Externals-C++STL.NonNullAllocator/functions">Externals-C++STL.NonNullAllocator/functions</a>
                to signal that this function returns a freshly created instance, and
                that it cannot return <code>nullptr</code>; for the deallocation we use
                the default behavior and thus do not have to modify any rule.
                </li>
            <li>Add the new resource to the set of resources being checked at those
                checks that should respect it. In our example we want to include
                the additional resource in check
                <a href="#MisraC2023Directive-4.1">MisraC2023Directive-4.1</a>
                and thus add the resource name <code>AdditionalResource</code> to the
                already existing list of resources in option
                <a href="#MisraC2023Directive-4.1/resources">MisraC2023Directive-4.1/resources</a>.</li>
        </ul>
        The name of the resource is the rule name (after the last hyphen, if any).
        


Name:
<h4><span class="ruleid">Rule Resources-FileHandle</span> <span class="ruletext">Representation of a file handle.</span></h4>This rule describes a resource which can by dynamically allocated
        and released in the program being analyzed. Together with the corresponding
        configuration of the allocator/deallocator functions under the
        <a href="#Externals">Externals</a>
        rulegroup, this knowledge is used by the pointer/semantic analysis and several
        error checks. To add your own resource, proceed as follows:
        <ul>
            <li>Copy an existing resource rule and rename the copy appropriately.
                For example, copy
                <a href="#Resources-CustomResource">Resources-CustomResource</a> and
                name the new rule <code>Resources-AdditionalResource</code>.</li>
            <li>Set the options of this new resource rule, especially the names
                of allocator and deallocator functions. In our example, let us assume
                that you have to call a function called
                <code>allocate_additional_resource</code>
                in order to create an instance of the resource, and that a call to
                <code>deallocate_additional_resource</code> is needed to release it
                again.
                Then you would set <code>Resources-AdditionalResource/allocators</code>
                to a set containing just <code>allocate_additional_resource</code>, and
                you would set <code>Resources-AdditionalResource/deallocators</code>
                to the set consisting of <code>deallocate_additional_resource</code>.
                If the analysis includes the implementation of the (de)allocator
                functions, option
                <code>Resources-AdditionalResource/allow_defined_functions</code>
                should be set.</li>
            <li>Create external function summaries for the allocator and deallocator
                functions (copy or edit existing rules). These summaries provide details
                about the specific function, e.g. whether they always return a fresh
                allocation or also sometimes <code>nullptr</code>, the semantics of
                their parameters, etc.
                With those summaries you can also distinguish different overloads,
                e.g. for <code>operator new</code>.
                If there is no external function summary for the (de)allocators,
                a default behavior is assumed (freeing the first argument, returning
                a freshly allocated object).
                In our example we just add <code>allocate_additional_resource</code> to
                option
                <a href="#Externals-C++STL.NonNullAllocator/functions">Externals-C++STL.NonNullAllocator/functions</a>
                to signal that this function returns a freshly created instance, and
                that it cannot return <code>nullptr</code>; for the deallocation we use
                the default behavior and thus do not have to modify any rule.
                </li>
            <li>Add the new resource to the set of resources being checked at those
                checks that should respect it. In our example we want to include
                the additional resource in check
                <a href="#MisraC2023Directive-4.1">MisraC2023Directive-4.1</a>
                and thus add the resource name <code>AdditionalResource</code> to the
                already existing list of resources in option
                <a href="#MisraC2023Directive-4.1/resources">MisraC2023Directive-4.1/resources</a>.</li>
        </ul>
        The name of the resource is the rule name (after the last hyphen, if any).
        


Name:
<h4><span class="ruleid">Rule Resources-HeapMemory</span> <span class="ruletext">Representation of standard C heap memory.</span></h4>This rule describes a resource which can by dynamically allocated
        and released in the program being analyzed. Together with the corresponding
        configuration of the allocator/deallocator functions under the
        <a href="#Externals">Externals</a>
        rulegroup, this knowledge is used by the pointer/semantic analysis and several
        error checks. To add your own resource, proceed as follows:
        <ul>
            <li>Copy an existing resource rule and rename the copy appropriately.
                For example, copy
                <a href="#Resources-CustomResource">Resources-CustomResource</a> and
                name the new rule <code>Resources-AdditionalResource</code>.</li>
            <li>Set the options of this new resource rule, especially the names
                of allocator and deallocator functions. In our example, let us assume
                that you have to call a function called
                <code>allocate_additional_resource</code>
                in order to create an instance of the resource, and that a call to
                <code>deallocate_additional_resource</code> is needed to release it
                again.
                Then you would set <code>Resources-AdditionalResource/allocators</code>
                to a set containing just <code>allocate_additional_resource</code>, and
                you would set <code>Resources-AdditionalResource/deallocators</code>
                to the set consisting of <code>deallocate_additional_resource</code>.
                If the analysis includes the implementation of the (de)allocator
                functions, option
                <code>Resources-AdditionalResource/allow_defined_functions</code>
                should be set.</li>
            <li>Create external function summaries for the allocator and deallocator
                functions (copy or edit existing rules). These summaries provide details
                about the specific function, e.g. whether they always return a fresh
                allocation or also sometimes <code>nullptr</code>, the semantics of
                their parameters, etc.
                With those summaries you can also distinguish different overloads,
                e.g. for <code>operator new</code>.
                If there is no external function summary for the (de)allocators,
                a default behavior is assumed (freeing the first argument, returning
                a freshly allocated object).
                In our example we just add <code>allocate_additional_resource</code> to
                option
                <a href="#Externals-C++STL.NonNullAllocator/functions">Externals-C++STL.NonNullAllocator/functions</a>
                to signal that this function returns a freshly created instance, and
                that it cannot return <code>nullptr</code>; for the deallocation we use
                the default behavior and thus do not have to modify any rule.
                </li>
            <li>Add the new resource to the set of resources being checked at those
                checks that should respect it. In our example we want to include
                the additional resource in check
                <a href="#MisraC2023Directive-4.1">MisraC2023Directive-4.1</a>
                and thus add the resource name <code>AdditionalResource</code> to the
                already existing list of resources in option
                <a href="#MisraC2023Directive-4.1/resources">MisraC2023Directive-4.1/resources</a>.</li>
        </ul>
        The name of the resource is the rule name (after the last hyphen, if any).
        


Name:
<h4><span class="ruleid">Rule Resources-Locale</span> <span class="ruletext">Representation of the current locale.</span></h4>This rule describes a resource which can by dynamically allocated
        and released in the program being analyzed. Together with the corresponding
        configuration of the allocator/deallocator functions under the
        <a href="#Externals">Externals</a>
        rulegroup, this knowledge is used by the pointer/semantic analysis and several
        error checks. To add your own resource, proceed as follows:
        <ul>
            <li>Copy an existing resource rule and rename the copy appropriately.
                For example, copy
                <a href="#Resources-CustomResource">Resources-CustomResource</a> and
                name the new rule <code>Resources-AdditionalResource</code>.</li>
            <li>Set the options of this new resource rule, especially the names
                of allocator and deallocator functions. In our example, let us assume
                that you have to call a function called
                <code>allocate_additional_resource</code>
                in order to create an instance of the resource, and that a call to
                <code>deallocate_additional_resource</code> is needed to release it
                again.
                Then you would set <code>Resources-AdditionalResource/allocators</code>
                to a set containing just <code>allocate_additional_resource</code>, and
                you would set <code>Resources-AdditionalResource/deallocators</code>
                to the set consisting of <code>deallocate_additional_resource</code>.
                If the analysis includes the implementation of the (de)allocator
                functions, option
                <code>Resources-AdditionalResource/allow_defined_functions</code>
                should be set.</li>
            <li>Create external function summaries for the allocator and deallocator
                functions (copy or edit existing rules). These summaries provide details
                about the specific function, e.g. whether they always return a fresh
                allocation or also sometimes <code>nullptr</code>, the semantics of
                their parameters, etc.
                With those summaries you can also distinguish different overloads,
                e.g. for <code>operator new</code>.
                If there is no external function summary for the (de)allocators,
                a default behavior is assumed (freeing the first argument, returning
                a freshly allocated object).
                In our example we just add <code>allocate_additional_resource</code> to
                option
                <a href="#Externals-C++STL.NonNullAllocator/functions">Externals-C++STL.NonNullAllocator/functions</a>
                to signal that this function returns a freshly created instance, and
                that it cannot return <code>nullptr</code>; for the deallocation we use
                the default behavior and thus do not have to modify any rule.
                </li>
            <li>Add the new resource to the set of resources being checked at those
                checks that should respect it. In our example we want to include
                the additional resource in check
                <a href="#MisraC2023Directive-4.1">MisraC2023Directive-4.1</a>
                and thus add the resource name <code>AdditionalResource</code> to the
                already existing list of resources in option
                <a href="#MisraC2023Directive-4.1/resources">MisraC2023Directive-4.1/resources</a>.</li>
        </ul>
        The name of the resource is the rule name (after the last hyphen, if any).
        


Name:
<h4><span class="ruleid">Rule Resources-MSAlignedHeapMemory</span> <span class="ruletext">Representation of MS aligned heap memory.</span></h4>This rule describes a resource which can by dynamically allocated
        and released in the program being analyzed. Together with the corresponding
        configuration of the allocator/deallocator functions under the
        <a href="#Externals">Externals</a>
        rulegroup, this knowledge is used by the pointer/semantic analysis and several
        error checks. To add your own resource, proceed as follows:
        <ul>
            <li>Copy an existing resource rule and rename the copy appropriately.
                For example, copy
                <a href="#Resources-CustomResource">Resources-CustomResource</a> and
                name the new rule <code>Resources-AdditionalResource</code>.</li>
            <li>Set the options of this new resource rule, especially the names
                of allocator and deallocator functions. In our example, let us assume
                that you have to call a function called
                <code>allocate_additional_resource</code>
                in order to create an instance of the resource, and that a call to
                <code>deallocate_additional_resource</code> is needed to release it
                again.
                Then you would set <code>Resources-AdditionalResource/allocators</code>
                to a set containing just <code>allocate_additional_resource</code>, and
                you would set <code>Resources-AdditionalResource/deallocators</code>
                to the set consisting of <code>deallocate_additional_resource</code>.
                If the analysis includes the implementation of the (de)allocator
                functions, option
                <code>Resources-AdditionalResource/allow_defined_functions</code>
                should be set.</li>
            <li>Create external function summaries for the allocator and deallocator
                functions (copy or edit existing rules). These summaries provide details
                about the specific function, e.g. whether they always return a fresh
                allocation or also sometimes <code>nullptr</code>, the semantics of
                their parameters, etc.
                With those summaries you can also distinguish different overloads,
                e.g. for <code>operator new</code>.
                If there is no external function summary for the (de)allocators,
                a default behavior is assumed (freeing the first argument, returning
                a freshly allocated object).
                In our example we just add <code>allocate_additional_resource</code> to
                option
                <a href="#Externals-C++STL.NonNullAllocator/functions">Externals-C++STL.NonNullAllocator/functions</a>
                to signal that this function returns a freshly created instance, and
                that it cannot return <code>nullptr</code>; for the deallocation we use
                the default behavior and thus do not have to modify any rule.
                </li>
            <li>Add the new resource to the set of resources being checked at those
                checks that should respect it. In our example we want to include
                the additional resource in check
                <a href="#MisraC2023Directive-4.1">MisraC2023Directive-4.1</a>
                and thus add the resource name <code>AdditionalResource</code> to the
                already existing list of resources in option
                <a href="#MisraC2023Directive-4.1/resources">MisraC2023Directive-4.1/resources</a>.</li>
        </ul>
        The name of the resource is the rule name (after the last hyphen, if any).
        


Name:
<h4><span class="ruleid">Rule Resources-Mutex</span> <span class="ruletext">Representation of a mutex.</span></h4>This rule describes a resource which can by dynamically allocated
        and released in the program being analyzed. Together with the corresponding
        configuration of the allocator/deallocator functions under the
        <a href="#Externals">Externals</a>
        rulegroup, this knowledge is used by the pointer/semantic analysis and several
        error checks. To add your own resource, proceed as follows:
        <ul>
            <li>Copy an existing resource rule and rename the copy appropriately.
                For example, copy
                <a href="#Resources-CustomResource">Resources-CustomResource</a> and
                name the new rule <code>Resources-AdditionalResource</code>.</li>
            <li>Set the options of this new resource rule, especially the names
                of allocator and deallocator functions. In our example, let us assume
                that you have to call a function called
                <code>allocate_additional_resource</code>
                in order to create an instance of the resource, and that a call to
                <code>deallocate_additional_resource</code> is needed to release it
                again.
                Then you would set <code>Resources-AdditionalResource/allocators</code>
                to a set containing just <code>allocate_additional_resource</code>, and
                you would set <code>Resources-AdditionalResource/deallocators</code>
                to the set consisting of <code>deallocate_additional_resource</code>.
                If the analysis includes the implementation of the (de)allocator
                functions, option
                <code>Resources-AdditionalResource/allow_defined_functions</code>
                should be set.</li>
            <li>Create external function summaries for the allocator and deallocator
                functions (copy or edit existing rules). These summaries provide details
                about the specific function, e.g. whether they always return a fresh
                allocation or also sometimes <code>nullptr</code>, the semantics of
                their parameters, etc.
                With those summaries you can also distinguish different overloads,
                e.g. for <code>operator new</code>.
                If there is no external function summary for the (de)allocators,
                a default behavior is assumed (freeing the first argument, returning
                a freshly allocated object).
                In our example we just add <code>allocate_additional_resource</code> to
                option
                <a href="#Externals-C++STL.NonNullAllocator/functions">Externals-C++STL.NonNullAllocator/functions</a>
                to signal that this function returns a freshly created instance, and
                that it cannot return <code>nullptr</code>; for the deallocation we use
                the default behavior and thus do not have to modify any rule.
                </li>
            <li>Add the new resource to the set of resources being checked at those
                checks that should respect it. In our example we want to include
                the additional resource in check
                <a href="#MisraC2023Directive-4.1">MisraC2023Directive-4.1</a>
                and thus add the resource name <code>AdditionalResource</code> to the
                already existing list of resources in option
                <a href="#MisraC2023Directive-4.1/resources">MisraC2023Directive-4.1/resources</a>.</li>
        </ul>
        The name of the resource is the rule name (after the last hyphen, if any).
        


Name:
<h4><span class="ruleid">Rule Resources-StrError</span> <span class="ruletext">Representation of the result of strerror().</span></h4>This rule describes a resource which can by dynamically allocated
        and released in the program being analyzed. Together with the corresponding
        configuration of the allocator/deallocator functions under the
        <a href="#Externals">Externals</a>
        rulegroup, this knowledge is used by the pointer/semantic analysis and several
        error checks. To add your own resource, proceed as follows:
        <ul>
            <li>Copy an existing resource rule and rename the copy appropriately.
                For example, copy
                <a href="#Resources-CustomResource">Resources-CustomResource</a> and
                name the new rule <code>Resources-AdditionalResource</code>.</li>
            <li>Set the options of this new resource rule, especially the names
                of allocator and deallocator functions. In our example, let us assume
                that you have to call a function called
                <code>allocate_additional_resource</code>
                in order to create an instance of the resource, and that a call to
                <code>deallocate_additional_resource</code> is needed to release it
                again.
                Then you would set <code>Resources-AdditionalResource/allocators</code>
                to a set containing just <code>allocate_additional_resource</code>, and
                you would set <code>Resources-AdditionalResource/deallocators</code>
                to the set consisting of <code>deallocate_additional_resource</code>.
                If the analysis includes the implementation of the (de)allocator
                functions, option
                <code>Resources-AdditionalResource/allow_defined_functions</code>
                should be set.</li>
            <li>Create external function summaries for the allocator and deallocator
                functions (copy or edit existing rules). These summaries provide details
                about the specific function, e.g. whether they always return a fresh
                allocation or also sometimes <code>nullptr</code>, the semantics of
                their parameters, etc.
                With those summaries you can also distinguish different overloads,
                e.g. for <code>operator new</code>.
                If there is no external function summary for the (de)allocators,
                a default behavior is assumed (freeing the first argument, returning
                a freshly allocated object).
                In our example we just add <code>allocate_additional_resource</code> to
                option
                <a href="#Externals-C++STL.NonNullAllocator/functions">Externals-C++STL.NonNullAllocator/functions</a>
                to signal that this function returns a freshly created instance, and
                that it cannot return <code>nullptr</code>; for the deallocation we use
                the default behavior and thus do not have to modify any rule.
                </li>
            <li>Add the new resource to the set of resources being checked at those
                checks that should respect it. In our example we want to include
                the additional resource in check
                <a href="#MisraC2023Directive-4.1">MisraC2023Directive-4.1</a>
                and thus add the resource name <code>AdditionalResource</code> to the
                already existing list of resources in option
                <a href="#MisraC2023Directive-4.1/resources">MisraC2023Directive-4.1/resources</a>.</li>
        </ul>
        The name of the resource is the rule name (after the last hyphen, if any).
        


Name:
<h4><span class="ruleid">Rule Resources-TextualTime</span> <span class="ruletext">Representation of the result of asctime() or ctime().</span></h4>This rule describes a resource which can by dynamically allocated
        and released in the program being analyzed. Together with the corresponding
        configuration of the allocator/deallocator functions under the
        <a href="#Externals">Externals</a>
        rulegroup, this knowledge is used by the pointer/semantic analysis and several
        error checks. To add your own resource, proceed as follows:
        <ul>
            <li>Copy an existing resource rule and rename the copy appropriately.
                For example, copy
                <a href="#Resources-CustomResource">Resources-CustomResource</a> and
                name the new rule <code>Resources-AdditionalResource</code>.</li>
            <li>Set the options of this new resource rule, especially the names
                of allocator and deallocator functions. In our example, let us assume
                that you have to call a function called
                <code>allocate_additional_resource</code>
                in order to create an instance of the resource, and that a call to
                <code>deallocate_additional_resource</code> is needed to release it
                again.
                Then you would set <code>Resources-AdditionalResource/allocators</code>
                to a set containing just <code>allocate_additional_resource</code>, and
                you would set <code>Resources-AdditionalResource/deallocators</code>
                to the set consisting of <code>deallocate_additional_resource</code>.
                If the analysis includes the implementation of the (de)allocator
                functions, option
                <code>Resources-AdditionalResource/allow_defined_functions</code>
                should be set.</li>
            <li>Create external function summaries for the allocator and deallocator
                functions (copy or edit existing rules). These summaries provide details
                about the specific function, e.g. whether they always return a fresh
                allocation or also sometimes <code>nullptr</code>, the semantics of
                their parameters, etc.
                With those summaries you can also distinguish different overloads,
                e.g. for <code>operator new</code>.
                If there is no external function summary for the (de)allocators,
                a default behavior is assumed (freeing the first argument, returning
                a freshly allocated object).
                In our example we just add <code>allocate_additional_resource</code> to
                option
                <a href="#Externals-C++STL.NonNullAllocator/functions">Externals-C++STL.NonNullAllocator/functions</a>
                to signal that this function returns a freshly created instance, and
                that it cannot return <code>nullptr</code>; for the deallocation we use
                the default behavior and thus do not have to modify any rule.
                </li>
            <li>Add the new resource to the set of resources being checked at those
                checks that should respect it. In our example we want to include
                the additional resource in check
                <a href="#MisraC2023Directive-4.1">MisraC2023Directive-4.1</a>
                and thus add the resource name <code>AdditionalResource</code> to the
                already existing list of resources in option
                <a href="#MisraC2023Directive-4.1/resources">MisraC2023Directive-4.1/resources</a>.</li>
        </ul>
        The name of the resource is the rule name (after the last hyphen, if any).
        


Name:
<h4><span class="ruleid">Rule Resources-Thread</span> <span class="ruletext">Representation of a thread.</span></h4>This rule describes a resource which can by dynamically allocated
        and released in the program being analyzed. Together with the corresponding
        configuration of the allocator/deallocator functions under the
        <a href="#Externals">Externals</a>
        rulegroup, this knowledge is used by the pointer/semantic analysis and several
        error checks. To add your own resource, proceed as follows:
        <ul>
            <li>Copy an existing resource rule and rename the copy appropriately.
                For example, copy
                <a href="#Resources-CustomResource">Resources-CustomResource</a> and
                name the new rule <code>Resources-AdditionalResource</code>.</li>
            <li>Set the options of this new resource rule, especially the names
                of allocator and deallocator functions. In our example, let us assume
                that you have to call a function called
                <code>allocate_additional_resource</code>
                in order to create an instance of the resource, and that a call to
                <code>deallocate_additional_resource</code> is needed to release it
                again.
                Then you would set <code>Resources-AdditionalResource/allocators</code>
                to a set containing just <code>allocate_additional_resource</code>, and
                you would set <code>Resources-AdditionalResource/deallocators</code>
                to the set consisting of <code>deallocate_additional_resource</code>.
                If the analysis includes the implementation of the (de)allocator
                functions, option
                <code>Resources-AdditionalResource/allow_defined_functions</code>
                should be set.</li>
            <li>Create external function summaries for the allocator and deallocator
                functions (copy or edit existing rules). These summaries provide details
                about the specific function, e.g. whether they always return a fresh
                allocation or also sometimes <code>nullptr</code>, the semantics of
                their parameters, etc.
                With those summaries you can also distinguish different overloads,
                e.g. for <code>operator new</code>.
                If there is no external function summary for the (de)allocators,
                a default behavior is assumed (freeing the first argument, returning
                a freshly allocated object).
                In our example we just add <code>allocate_additional_resource</code> to
                option
                <a href="#Externals-C++STL.NonNullAllocator/functions">Externals-C++STL.NonNullAllocator/functions</a>
                to signal that this function returns a freshly created instance, and
                that it cannot return <code>nullptr</code>; for the deallocation we use
                the default behavior and thus do not have to modify any rule.
                </li>
            <li>Add the new resource to the set of resources being checked at those
                checks that should respect it. In our example we want to include
                the additional resource in check
                <a href="#MisraC2023Directive-4.1">MisraC2023Directive-4.1</a>
                and thus add the resource name <code>AdditionalResource</code> to the
                already existing list of resources in option
                <a href="#MisraC2023Directive-4.1/resources">MisraC2023Directive-4.1/resources</a>.</li>
        </ul>
        The name of the resource is the rule name (after the last hyphen, if any).
        


Name:
<h4><span class="ruleid">Rule EDGFormat</span> <span class="ruletext">The matcher configuration for the edg format.</span></h4>
        <p>This rule configures regular expressions, used to match against the output of
        external/3rd-party analysis tools. Using these matchers, parts of a message
        can be extracted and transformed into a style-violation issue.
        <p>
        Please refer to the documentation of the parent rulegroup for further details.
        </p>


Name:
<h4><span class="ruleid">Rule AxivionFormat</span> <span class="ruletext">The matcher configuration for the axivion format.</span></h4>
        <p>This rule configures regular expressions, used to match against the output of
        external/3rd-party analysis tools. Using these matchers, parts of a message
        can be extracted and transformed into a style-violation issue.
        <p>
        Please refer to the documentation of the parent rulegroup for further details.
        </p>


Name:
<h4><span class="ruleid">Rule DiabFormat</span> <span class="ruletext">The matcher configuration for the diab format.</span></h4>
        <p>This rule configures regular expressions, used to match against the output of
        external/3rd-party analysis tools. Using these matchers, parts of a message
        can be extracted and transformed into a style-violation issue.
        <p>
        Please refer to the documentation of the parent rulegroup for further details.
        </p>


Name:
<h4><span class="ruleid">Rule DoxygenFormat</span> <span class="ruletext">The matcher configuration for the doxygen format.</span></h4>
        <p>This rule configures regular expressions, used to match against the output of
        external/3rd-party analysis tools. Using these matchers, parts of a message
        can be extracted and transformed into a style-violation issue.
        <p>
        Please refer to the documentation of the parent rulegroup for further details.
        </p>


Name:
<h4><span class="ruleid">Rule FxCopFormat</span> <span class="ruletext">The matcher configuration for the fxcop format.</span></h4>
        <p>This rule configures regular expressions, used to match against the output of
        external/3rd-party analysis tools. Using these matchers, parts of a message
        can be extracted and transformed into a style-violation issue.
        <p>
        Please refer to the documentation of the parent rulegroup for further details.
        </p>


Name:
<h4><span class="ruleid">Rule GCCFormat</span> <span class="ruletext">The matcher configuration for the gcc format.</span></h4>
        <p>This rule configures regular expressions, used to match against the output of
        external/3rd-party analysis tools. Using these matchers, parts of a message
        can be extracted and transformed into a style-violation issue.
        <p>
        Please refer to the documentation of the parent rulegroup for further details.
        </p>


Name:
<h4><span class="ruleid">Rule GenericFormat</span> <span class="ruletext">The matcher configuration for the generic format.</span></h4>
        <p>This rule configures regular expressions, used to match against the output of
        external/3rd-party analysis tools. Using these matchers, parts of a message
        can be extracted and transformed into a style-violation issue.
        <p>
        Please refer to the documentation of the parent rulegroup for further details.
        </p>


Name:
<h4><span class="ruleid">Rule GNATFormat</span> <span class="ruletext">The matcher configuration for the gnat format.</span></h4>
        <p>This rule configures regular expressions, used to match against the output of
        external/3rd-party analysis tools. Using these matchers, parts of a message
        can be extracted and transformed into a style-violation issue.
        <p>
        Please refer to the documentation of the parent rulegroup for further details.
        </p>


Name:
<h4><span class="ruleid">Rule LintFormat</span> <span class="ruletext">The matcher configuration for the lint format.</span></h4>
        <p>This rule configures regular expressions, used to match against the output of
        external/3rd-party analysis tools. Using these matchers, parts of a message
        can be extracted and transformed into a style-violation issue.
        <p>
        Please refer to the documentation of the parent rulegroup for further details.
        </p>


Name:
<h4><span class="ruleid">Rule MSBuildFormat</span> <span class="ruletext">The matcher configuration for the msbuild format.</span></h4>
        <p>This rule configures regular expressions, used to match against the output of
        external/3rd-party analysis tools. Using these matchers, parts of a message
        can be extracted and transformed into a style-violation issue.
        <p>
        Please refer to the documentation of the parent rulegroup for further details.
        </p>


Name:
<h4><span class="ruleid">Rule PMDFormat</span> <span class="ruletext">The matcher configuration for the pmd format.</span></h4>
        <p>This rule configures regular expressions, used to match against the output of
        external/3rd-party analysis tools. Using these matchers, parts of a message
        can be extracted and transformed into a style-violation issue.
        <p>
        Please refer to the documentation of the parent rulegroup for further details.
        </p>


Name:
<h4><span class="ruleid">Rule QMLLintFormat</span> <span class="ruletext">The matcher configuration for the qmllint format.</span></h4>
        <p>This rule configures regular expressions, used to match against the output of
        external/3rd-party analysis tools. Using these matchers, parts of a message
        can be extracted and transformed into a style-violation issue.
        <p>
        Please refer to the documentation of the parent rulegroup for further details.
        </p>


Name:
<h4><span class="ruleid">Rule TASKINGFormat</span> <span class="ruletext">The matcher configuration for the tasking format.</span></h4>
        <p>This rule configures regular expressions, used to match against the output of
        external/3rd-party analysis tools. Using these matchers, parts of a message
        can be extracted and transformed into a style-violation issue.
        <p>
        Please refer to the documentation of the parent rulegroup for further details.
        </p>


Name:
<h4><span class="ruleid">Rule Architecture-Dependencies</span> <span class="ruletext">Analyse dependencies in IR and create a dependency graph (RFG) for it.</span></h4>
        This rule allows configuring the automatic creation of an RFG
        from the IR.
        <p>
        The automatic creation of the RFG is enabled if all the following conditions
        apply:
        <ul>
        <li>An IR is configured in option <a href="#/Project//ir">/Project/ir</a></li>
        <li>Option <a href="#/Project//rfg">/Project/rfg</a> is left unconfigured
        (no existing RFG)</li>
        <li>The RFG is required by another active rule (e.g. any other
        <a href="#Architecture">Architecture</a> rule, the
        <a href="#SaveRFG">SaveRFG</a> rule,
        <a href="#CycleDetection">CycleDetection</a>,
        <a href="#DeadCodeDetection">DeadCodeDetection</a> and most
        <a href="#Metrics">Metrics</a>).</li>
        </ul>
        


Name:
<h4><span class="ruleid">Rule Architecture-GravisArchitecture</span> <span class="ruletext">Architecture check using GXL files for architecture and mapping.</span></h4><p>This rule performs a Gravis-based architecture analysis
         using GXL files for model and mapping information. Steps for using it:
          <ul>
          <li> model architecture in Gravis,
          <li> manually map source code in Gravis,
          <li> export architecture and mapping into GXL files within Gravis and
          <li> provide the correct view names and file paths to the rule.
         </ul></p>


Name:
<h4><span class="ruleid">Rule CloneDetection</span> <span class="ruletext">Find cloned code parts using the IR.</span></h4>


Name:
<h4><span class="ruleid">Rule CycleDetection-CallgraphCycles</span> <span class="ruletext">Find cycles in the callgraph and report them as violations.</span></h4><p>This rule identifies cycles in the callgraph.</p>
        <p>A cycle in the call graph bears the risk of infinite recursion at runtime if
        the termination of the calls is not guaranteed. As a consequence, the entire
        cycle has to be understood and all conditions must be managed simultaneously as
        to not induce runtime failure. At the same time, cycles impede understandability
        of the code for a developer.</p>
        <p>If you want to include dynamic calls for function pointers and virtual calls,
        then manually activate
        <a href="#StaticSemanticAnalysis">StaticSemanticAnalysis</a>.</p>
        <p>If you need more advanced cycle detection features, use the rules inside the
        <code>Graph-based Analyses/Cycles</code> section in the
        <a href="#Architecture">Architecture group</a>.</p>


Name:
<h4><span class="ruleid">Rule DeadCodeDetection</span> <span class="ruletext">Find dead functions in the RFG.</span></h4><p>This rule identifies dead routines</p>
        <p>Dead code reduces code readability and maintainability.</p>
        <p>This rule does not modify the RFG
        (use <a href="#Architecture-DeadCodeView">Architecture-DeadCodeView</a> to
        generate a <code>Dead Code</code> view).</p>


Name:
<h4><span class="ruleid">Rule Metrics</span> <span class="ruletext">Compute metric values and violations of thresholds.</span></h4>


Name:
<h4><span class="ruleid">Rule TokenMetrics</span> <span class="ruletext">Metrics counting specific tokens.</span></h4>


Name:
<h4><span class="ruleid">Rule Metric-TokenMetric.Fixme</span> <span class="ruletext">Lines containing FIXME token.</span></h4>Counts lines
that contain one or more times the configured token 'Fixme' (inside
a comment or as language token). The lookup itself is case insensitive, so that Fixme,
fixme, and FIXME are all counted.


Name:
<h4><span class="ruleid">Rule Metric-TokenMetric.Todo</span> <span class="ruletext">Lines containing TODO token.</span></h4>Counts lines
that contain one or more times the configured token 'Todo' (inside
a comment or as language token). The lookup itself is case insensitive, so that Todo,
todo, and TODO are all counted.


Name:
<h4><span class="ruleid">Rule Stylechecks</span> <span class="ruletext">Checks regarding coding style, including Misra and other checks.</span></h4>


Name:
<h4><span class="ruleid">Rule FaultDetection-EscapingLocalAddress</span> <span class="ruletext">The address of a local variable should not escape its function.</span></h4>This check detects functions where the address of a local variable
        might escape into the caller, risking the danger of accessing the address there
        where the variable no longer exists.
        


Name:
<h4><span class="ruleid">Rule Generic-EntityMarker</span> <span class="ruletext">Reports a (suppressed) issue per entity of a configurable type.</span></h4>
This rule generates one issue per entity under analysis and immediately suppresses the
issue.  Relevant entities can be selected with a set of Physical IR types.
The rule is useful for checking completeness of the analysis. Note that you have to
import the suppressed issues via
<a href="#/Results/Dashboard/import_suppressed_issues">/Results/Dashboard/import_suppressed_issues</a>
into the database.


Name:
<h4><span class="ruleid">Rule Generic-Filemarker</span> <span class="ruletext">Reports a (suppressed) issue per entity of a configurable type.</span></h4>
This rule generates one issue per entity under analysis and immediately suppresses the
issue.  Relevant entities can be selected with a set of Physical IR types.
The rule is useful for checking completeness of the analysis. Note that you have to
import the suppressed issues via
<a href="#/Results/Dashboard/import_suppressed_issues">/Results/Dashboard/import_suppressed_issues</a>
into the database.


Name:
<h4><span class="ruleid">Rule Generic-NoTabs</span> <span class="ruletext">Do not use tabs.</span></h4>Only if you prefer spaces over tabs
        <a href="https://en.wikipedia.org/wiki/Indentation_style#Tab_vs._space">
        https://en.wikipedia.org/wiki/Indentation_style#Tab_vs._space</a> this rule is for you!
        Inconsistent use or hardly visible differences of spaces or tabs should be avoided.
        Use your editor setting to ensure consistent whitespaces.


# axExtraInfo

Name:
<dl><dt>Context</dt><dd><SLoc filename="src/erosionSmoker.cpp" line="139" column="14">setting value here [p]</SLoc></dd><dd><SLoc filename="src/erosionSmoker.cpp" line="140" column="5">setting value here [return value]</SLoc></dd></dl>


