MISRA Discussion Forums - 6.17 Pointers and Arrays

MISRA2004 Rule 17.4 How to solve the Rule violation

Tue, 19 Feb 2019 04:17:03 +0000

I have an issue regarding the rule violation in which I'm using a 2D array inside a structure and apparently The Rule 17.4 says it isn't compliant. Is Declaring arryas inside a structure/union not compliant and why is it so? What exactly is the alternative for it?
Help would be appreciated ASAP. Following is the example code. Thanks in advance.

Code:
#include 

void func1(unsigned char abc);

typedef struct teststructure

{

    float buf[5][3];

}teststruct;

int main()

{

    unsigned char abc;

    func1(abc);

}

void func1(unsigned char abc)

{

    teststruct TEST;

    float fData = 54.0;

    TEST.buf[2][1] = fData;

}

About 17.4 Question?

Thu, 05 May 2016 09:36:39 +0000

I need read some parameters from EEPROM. My Code as below:

typedef struct
{
Uint16 ErrorCode;
Uint16 ErrDCVoltage;
Uint16 ErrMCUState;
Uint8 ErrMotorModeCmd;
Uint8 ErrDriveState;
Uint16 ErrTorqueCmd;
Uint16 ErrTorqueFed;
Uint16 ErrSpeedSet;
Uint16 ErrSpeed;
Uint8 ErrIGBTTemp;
Uint8 ErrMotorTemp;
Uint16 ErrUd;
Uint16 ErrUq;
Uint16 ErrIdRef;
Uint16 ErrIqRef;
Uint16 ErrIdFed;
Uint16 ErrIqFed;
Uint16 ErrState;
Uint8 Err12V;
Uint8 Angle;
Uint8 AngleInit;
Uint8 ErrMCUTemp;
Uint16 DC_Cur;
}ErrorLog_t;

void LoadError(ErrorLog_t* Err,Uint16 Index)
{
Uint16 i;
Uint16 *PrErrLog;
PrErrLog = (uint16 *)Err;
for(i=0u;iErrorCode = ReadEeprom(0u);
Err->ErrDCVoltage = ReadEeprom(1u);
Err->ErrMCUState = ReadEeprom(2u);
....

if my struct has more than 100 items, What can I do?

Rule 17.4 - can I reference to an array, inside a struct?

Fri, 23 Aug 2013 17:38:53 +0000

I want to define a list of actions in ROM, so it cannot get corrupted. An array of struct, in ROM, where each struct contains enough information to define what the MCU should do.

One of the actions is to read some info from an exernal device. So it needs to go into a buffer, and the buffer is obviously in RAM.

The problem I have is, how do I make a typedef for a struct, where one member of the struct is a reference to the buffer? I will need to use the buffer as an array, and referring to an array element by index is of course not allowed, if a pointer type is used for the array.

Code:
typedef s_SomeStruct

{

  uint8_t *buf;  /* not ok, because SomeStruct.buf[x] will not be compliant */

  size_t bufsize;

} TSomeStruct;

But I cannot find a way to use an array type. For function parameters, I could have foo(uint8_t buf[]) but it's not going to compile in a structure definition

Code:
typedef s_SomeStruct

{

  uint8_t buf[]; /* you wha'? */

  size_t bufsize;

} TSomeStruct;

Is there a known way around this, other than creating a deviation?

Thanks

Frank

Rule 17.4 - array elements contained inside structure def

Mon, 21 Jan 2013 08:08:31 +0000

â€¢ MISRA C rule 17.4 says arithmetic operations shall not be performed on pointers, as they may result into referencing to non-existing addresses.
â€¢ Alternative to this is to catch a pointer being received as an argument into the respective type of an array, for e.g. catch â€˜&arrâ€™ into â€˜arr[]â€™, and use array indexing to access its elements. This works well for pointers of basic data types.
â€¢ Problem arises in the case of accessing array elements contained by a structure.
â€¢ e.g.
struct message
{
int address;
int length;
int data[50];
}m1,m2;

â€¢ Now, the statement â€œsource_node = m1.data[SOURCE_NODE_INDEX]â€ triggers this 17.4 non-compliance note.
â€¢ This happens when accessing only the array elements, and not for single variables of a structure definition.
â€¢ So the question I have is, what is the best way to access individual array elements contained inside a structure definition?

MISRA rule 17.4 violation ?

Thu, 26 Jan 2012 08:14:51 +0000

Hello,

my compiler find in the following code a MISRA violation 17.4 at the last view code lines. Is this correct? If yes, please tell me how to solve the above mentioned code. In my opinion there is no MISRA rule 17.4 violation.

Code:
#define BUF_LEN1     (512u)

/* this violates rule 8.7, but this is intentionaly. It is only a rule 17.4 example */

static uint32_t buf1[BUF_LEN1];

static struct TestStruct

{

  uint32_t *buf;

  uint32_t len;

} data1 = {NULL, 0u};

static void InitStruct(uint32_t _len, uint32_t _buf[]);

static void UseStruct(struct TestStruct * data);

int32_t main( void )

{

    InitStruct(BUF_LEN1, buf1);

    UseStruct(&data1);

    return 0;

}

static void InitStruct(uint32_t _len, uint32_t _buf[])

{

  data1.len = _len;

  data1.buf = _buf;

}

static void UseStruct(struct TestStruct * data)

{

  uint32_t i;

  for (i=0u; ilen; i++)

  {

    /* process data in any way ... */

    /* this code line causes a MISRA 17.4 violation error by the compiler */

    data->buf[i] = 1u;

  }

}

Many thanks in advance and best regards,

Michael

Rule 17.1 compatibility

Wed, 05 Oct 2011 07:54:26 +0000

Dear all,

below, you find code that shall be full MISRA-C:2004 compatible except MISRA rule 17.1 (according to my compiler). I removed the header file module.h for readability.

[code]
/* now module.c begins */
float32_t Defaults[6];

void misra17_1test(const float32_t in[6])
{
uint32_t s = 0u;
float32_t mythreshold = 0.0f;
float32_t tmpMax = 0.0f;
for (s = 0u; s < 6u; s++) {
mythreshold = in[s]; /* a MISRA 17.1 violation is detected here by compiler */

/* do something */

if (tmpMax > mythreshold) {
/* do something */
}
else {
/* do something */
}
}
}
*-----------------------------------------------------------------------------------------*/
/* now the main.c module begins */
extern float32_t Defaults[6];

int32_t main(void)
{
int32_t j = 0;
for(j=0; j

Would strlen() be possible with Rule 17.4?

Thu, 29 Sep 2011 21:59:06 +0000

Small function I am trying to write is to take a string literal, and copy [part of] it to an array.

The array is fine, declared as an array and only accessed using indexing. But I cannot figure out how to search the string for particular sequences of char.

It's a string literal, so passed into the function as
foo("Hello World");
So the parameter is const char_t *. So how could I do anything with that, even find the length of it? I can't step the pointer through it, I can't even access it by index. Is such a thing as a string literal even legal?

void foo(const Octet *p)
{
/* ...Now what? p[n] is not legal because Octet * is not an array type,
and p++ would be a definite no-no.
*/
}

If I declared it as
void foo(const char_t c[])
would that be legitimate? It's legal C, I think, and it looks like an array declaration, but I don't see the difference between that and the previous. I can call it with
char_t *p;
...
foo(p);
or even
foo(NULL);
without a compiler warning (using gcc -ansi -pedantic -Wall; I'm sure PC-Lint would notice, but I don't have it here at home). So if the previous declaration was illegal, would this be also?

If I understand correctly, then it seems to me that even a simple function like strlen() could not be written, in a way that would be compliant. Is that, in fact, the case?

Frank

Function returning pointer to array - Rule 17.4

Thu, 24 Jun 2010 13:24:11 +0000

I have a function returning a pointer to an array, not an uncommon situation I would think.
How can I reference elements in that array without violating Rule 17.4 ?.
1. Indexing is not compliant as the return type is not an array.
2. Pointer arithmetic is not compliant.
So it looks like returning pointers to arrays is effectively banned by this rule, is that the case?.

Rule 17.4

Wed, 31 Mar 2010 07:25:11 +0000

Hi,
I am finding a violation (with IBM logiscope) when i use an array within a structure.

so my structure is:

Code:
typedef struct

{

unsigned char a;

unsigned char b;

unsigned char c[10];

unsigned char d;

}mID;

and my main:

mID tester;

Code:
int main(void)

{

tester.a = 0x01;

tester.c[2] = 0x02;

tester.c[3] = 0x06;

tester.c[4] = 0x05;

return 0;

}

for each assignment to .c i am told "pointer arithmetic only with array indexing"

thanks for any advice

matt

Clarification of Rule 17.4

Tue, 24 Apr 2007 12:14:33 +0000

According to the description of the rule 17.4:

Quote:Array indexing shall only be applied to objects defined as an array type.

.
Given this I do not understand why the following is allowed:

Code:
uint8_t a[10];

uint8_t *p;

p = a;

p[5] = 0; /* why is this compliant? */

Arithmetic on Pointers are MISRA compliant ?

Mon, 31 Oct 2005 16:35:46 +0000

The rules 17.1 to 17.3 give some possibilities to manipulate pointers (arithmetic, substraction, comparison) whereas the rule 17.4 doesn't authorize pointer manipulation in any way other than array indexing.

Should it be possible to explain me where I make a mistake in my understanding?

In particular, I would like to know if the following code is MISRA 2004 compliant concerning pointer manipulation:

Code:
    unsigned int tab[10];

    void test(void)

    {

        unsigned int *ptr;

        ptr = &tab[2];

        *ptr = 33;

        ptr++;                         /*  MISRA Compliant ? */

        *ptr = 11;

    }

I thank you in advance.

Best regards.

Dynamic memory allocation using malloc()/calloc()

Mon, 22 Nov 2004 09:21:10 +0000

Hi,

I have a few queries with respect to \"dynamic memory allocation\". As per the rule we are not supposed to use functions like \"malloc()\", \"free()\", \"calloc()\" etc. But malloc() is a very common requirement. Most of the embedded system applications use their own application level memory managers so as to make the allocation and de-allocation fast. Do you have any suggestions to get around this problem ( if we can't use malloc, any other way )?

One possible solution I can think of right now it to do a static allocation of a big chunk of memory and redirecting all the dynamic memory requirements to that chunk ( basically a kind of memory manager ). But here also we are stuck with one problem. If we write an application level memory manager, it has to cater to all data types. This will require conversion from any data type to \"void*\" and from \"void*\" to any data type ( say \"char*\" ). But Rule No: 45 of MISRA C ( Typecasting from any type to or from pointers shall not be used ) prohibits me doing that also.

The third problem is with writing portable code. Its quite common to use codes like (X*)0->data1 to get the offset to data1 , where X is a structure ( struct X { }; ) and data1 is a member within that structure. Are we not supposed to use these types of casts too [ (X*)0 ] ???

It would be great if someone could give some possible solutions to these kind of issues.

- Thanks
- Raveendran V.