Unofficial Autosar C++ Guidelines Reference

This project has the aim to provide an easier access to the document [1]. Instead of a PDF file, the contents are transferred to a searchable online book using mdbook.

Due to the automatic generation of this book, please expect wrongly formatted content, content in the wrong section or even missing content.

The source for this book is available at [2].

Content Generation

To generate the content of this page, a lot of regex logic is used to extract the relevant information out of the PDF document [1].

Download the document [1] from the official source
Convert the document to a txt format using e.g. Cloudconvert
Place the txt file in the script dicrectory and call ./convert.sh [name].txt

convert.sh uses the following commands to extract and format the content from the txt source:

sed
csplit
prettier

At the end, Markdown files are generated and copied to the src folder to be published by mdbook.

ToDo

Format C++ code blocks automatically
Improve regex to close code blocks

License

This project utilizes the work [1] without any modification for informational purposes only in accordance with its disclaimer.

The parts of this repository that do not originate from [1] are licensed with the GPL 3.0 license. Also see LICENSE.

[1] Guidelines for the use of the C++14 language in critical and safety-related systems AUTOSAR AP Release 19-03

[2] GitHub

Rule M0-1-1 (required, implementation, automated)

A project shall not contain unreachable code.

See MISRA C++ 2008 [7]

Rule M0-1-2 (required, implementation, automated)

A project shall not contain infeasible paths.

See MISRA C++ 2008 [7]

Note: A path can also be infeasible because of a call to constexpr function which returned value, known statically, will never fulfill the condition of a condition statement.

Rule M0-1-3 (required, implementation, automated)

A project shall not contain unused variables.

See MISRA C++ 2008 [7]

Rule M0-1-4 (required, implementation, automated)

A project shall not contain non-volatile POD variables having only one use.

See MISRA C++ 2008 [7]

Rule A0-1-1 (required, implementation, automated)

A project shall not contain instances of non-volatile variables being given values that are not subsequently used.

Known as a DU dataflow anomaly, this is a process whereby there is a data flow in which a variable is given a value that is not subsequently used. At best this is inefficient, but may indicate a genuine problem. Often the presence of these constructs is due to the wrong choice of statement aggregates such as loops.

See: DU-Anomaly.

Exception

Loop control variables (see Section 6.6.5) are exempt from this rule.

Example

//% $Id: A0-1-1.cpp 289436 2017-10-04 10:45:23Z michal.szczepankiewicz $
#include <array>
#include <cstdint>
std::uint8_t Fn1(std::uint8_t param) noexcept
{
    std::int32_t x{
        0}; // Non-compliant - DU data flow anomaly; Variable defined,
            // but not used
    if (param > 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
std::int32_t Fn2() noexcept
{
    std::int8_t x{10U}; // Compliant - variable defined and will be used
    std::int8_t y{20U}; // Compliant - variable defined and will be used
    std::int16_t result = x + y; // x and y variables used

    x = 0; // Non-compliant - DU data flow anomaly; Variable defined, but x is
           // not subsequently used and goes out of scope
    y = 0; // Non-compliant - DU data flow anomaly; Variable defined, but y is
           // not subsequently used and goes out of scope
    return result;
}
std::int32_t Fn3(std::int32_t param) noexcept
{
    std::int32_t x{param +
        1}; // Compliant - variable defined, and will be used in
            // one of the branches
            // However, scope of x variable could be reduced
    if (param > 20)
    {
        return x;
    }
    return 0;
}
std::int32_t Fn4(std::int32_t param) noexcept

{
    std::int32_t x{param +

        1}; // Compliant - variable defined, and will be used in
            // some of the branches

    if (param > 20)
    {
        return x + 1;
    }
    else if (param > 10)
    {
        return x;
    }
    else
    {
        return 0;
    }
}
void Fn5() noexcept
{
    std::array<std::int32_t, 100> arr{};
    arr.fill(1);

    constexpr std::uint8_t limit{100U};
    std::int8_t x{0};
    for (std::uint8_t i{0U}; i < limit; ++i) // Compliant by exception - on the
                                             // final loop, value of i defined will
                                             // not be used
    {
        arr[i] = arr[x];
        ++x; // Non-compliant - DU data flow anomaly on the final loop, value
             // defined and not used
    }

}