Lint sees that ownership of allocated memory is taken by a constructor if the owning object isn't "new'd". But if the owning object is "new'd", then Lint does not understand this. See the example below, which works in the online demo.

This was discussed in this thread, as well as several others:
http://www.gimpel.com/Discussion.cfm?ThreadID=808

//lint -e438, -e529, -e1502, -e1712, -e1788, -e714

include <memory>

struct A { A(char ){}; };
void g( )
{
// This results in a 429 warning.
char * ptr1 = (char ) malloc(10);
A *a1 = new A(ptr1);

// This does not result in a 429 warning.
char * ptr2 = (char *) malloc(10);
A a2(ptr2);
}

We are linting our complete software with different rulesets for its different SW-parts (because some are safety relevant and some are not, i.e. the rulesets differ, but the code analysis must check the software as a whole).

Each SW-part's rulesets has its own active rules/errors + specific messages for the errors, which are added via the "-append()" option.
In the course of action we use the save/restore options to get back to a basic common, global configuration.

I.e. the complete command line is something like:

lint-nt.exe

<output file>

<global base cfg>

<msg output format cfg>.lnt

(n-times) x [

<SW-part specific cfg => first option: -save>.lnt

<SW-part specific includes>.lnt

<SW-part specific target files (.c, .h) => last option: -restore >.lnt

]

While this works well for the error inhibition, with this command call structure finally in the PC-lint log, the latter SW-parts get also all appended messages from the previous ones, i.e. the "-append()" options are not saved/restored with the active errors.

For example in the following PC-lint-log-snippet only the last MISRA category should be added:
>>

FINDING_DETAILS§"d:\80-Software\src\Module12345.c"§8002§80§Note§9033§Impermissible cast of composite expression (wider essential type for the destination) §MISRA-C:2012 Rule 10.8§ required, §MISRA-C:2012 Rule 10.8§ advisory, §MISRA-C:2012 Rule 10.8§ obligatory)

<<

We had a construction like;
len = strlen(value);
p = malloc(len)
strcpy(p, value)

since we allocate 1 byte too little the strcpy will always cause a buffer overrun. But lint 9.00k did not detect it. Since this was only called with data read from files, it was detected when I added a call where value was a string literal

It seems like lint is good in arithmetic and less good in algebra
When it have a string literal of a known length it correct calculates the overrun, but if value is of unknown length it can't deduct that the overrun happens.

Rgds Lars

Although an explicite cast looks like the programmer knew, the intended behaviour may need two casts.
I wanted to "infinitely" accumulate possibly small, possibly negative increments (float i) in a modulo counter consisting of an unsigned integer variable (uint32_t n) and a real variable (float f) for the fractional part.

f += i;
n += (uint32t)f; // should read n += (uint32t)(int32t)f;
f -= (int32t)f;

worked with several compilers for PC platforms (gcc, lcc32, VS C++) and with TI''s c6000 compiler for an OMAP L138, but the counter failed to decrease with TI's ARM5.1 compiler for the 7R4 core.

This is implementation defined behaviour as of C99 6.3.1.4, but none of the compilers emitted a warning nor does lint.

Sometimes it would be nice to suppress a message for all derived classes.

For example:

class X
{
virtual void f() = 0;
};

class Y : public X
{
void f() {}
};

class Z : public X
{
int i;
void f(){++i;}
};

I would like to be able to put the following comment with the declaration of X:
//lint -esym(1961,[X]::f) //1961 - virtual member function 'Symbol' could be made const

Where I use [X] as syntax to define X and all classes derived from it.
So when a sub class dos not use the function f to the full extend lint knows from the comments that came with X

Also for other messages it would be nice to inhibit it for a family of classes.