Skip to end of metadata
Go to start of metadata

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 18 Next »

According to ISO/IEC 9899:TC3 Section 7.1.3 on reserved identifiers,

  • All identifiers that begin with an underscore and either an uppercase letter or another underscore are always reserved for any use
  • All identifiers that begin with an underscore are always reserved for use as identifiers with file scope in both the ordinary and tag name spaces
  • Each macro name in any of the subclauses (including the future library directions) is reserved for use as specified if any of its associated headers is included, unless explicitly stated otherwise
  • All identifiers with external linkage(including future library directions) are always reserved for use as identifiers with external linkage
  • Each identifier with file scope listed in any of the above subclauses (including the future library directions) is reserved for use as a macro name and as an identifier with file scope in the same name space if any of its associated headers is included

No other identifiers are reserved. A the behavior of a program that declares or defines an identifier in a context in which it is reserved or defines a reserved identifier as a macro name, is undefined . See also undefined behavior 100 of Annex J of C99. Trying to define a reserved identifier can result in its name conflicting with that used in implementation, which may or may not be detected at compile time.

Noncompliant Code Example (Header Guard)

A common but noncompliant practice is to choose a reserved name for a macro used in a preprocessor conditional guarding against multiple inclusion of a header file. See also PRE06-C. Enclose header files in an inclusion guard. The name may clash with reserved names defined by the implementation of the C standard library in its headers, or with reserved names implicitly predefined by the compiler even when no C standard library header is included.

#ifndef _MY_HEADER_H_
#define _MY_HEADER_H_

/* contents of <my_header.h> */

#endif /* _MY_HEADER_H_ */

Compliant Solution (Header Guard)

This compliant solution avoids using leading or trailing underscores in the name of the header guard.

#ifndef MY_HEADER_H
#define MY_HEADER_H

/* contents of <my_header.h> */

#endif /* MY_HEADER_H */

Noncompliant Code Example (File Scope Objects)

In this noncompliant code example, the names of the file scope objects _max_limit and _limit both begin with an underscore. Since it is static, the declaration of _max_limit might seem to be impervious to clashes with names defined by the implementation. However, since the header <stddef.h> is included in order to define size_t a potential for a name clash exists. Thus it is unsafe to start the name of any file scope identifier with an underscore, even if its linkage limits its visibility to a single translation unit.

#include <stddef.h>   /* for size_t */

static const size_t _max_limit = 1024;
size_t _limit = 100;

unsigned int getValue(unsigned int count) {
  return count < _limit ? count : _limit;
}

Compliant Solution (File Scope Objects)

In this compliant solution, names of no file scope objects begin with an underscore and, hence, do not encroach on the reserved name space.

#include <stddef.h>   /* for size_t */

static const size_t max_limit = 1024;
size_t limit = 100;

unsigned int getValue(unsigned int count){
  return count < limit ? count : limit;
}

Noncompliant Code Example (Reserved Macros)

In the noncompliant code example below, since the C standard library header <inttypes.h> is specified to include <stdint.h>, the name MAX_SIZE conflicts with the name of the <stdint.h> header macro used to denote the upper limit of size_t. In addition, while the name INTFAST16_LIMIT_MAX isn't defined by the C standard library, since it begins with the INT prefix and ends with the _MAX suffix it encroaches on the reserved name space (see section 8.26.8 of C99).

#include <inttypes.h>   /* for int_fast16_t and PRIdFAST16 */

static const int_fast16_t INTFAST16_LIMIT_MAX = 12000;

void print_fast16(int_fast16_t val) {
    enum { MAX_SIZE = 80 };
    char buf [MAX_SIZE];
    if (INTFAST16_LIMIT_MAX < val)
      sprintf(buf, "The value is too large");
    else
      snprintf(buf, MAX_SIZE, "The value is %" PRIdFAST16, val);
    /* ... */
}

Compliant Solution (Reserved Macros)

The compliant solution below avoids redefining reserved names or using reserved prefixes and suffixes.

#include <inttypes.h>   /* for int_fast16_t and PRIdFAST16 */

static const int_fast16_t MY_INTFAST16_UPPER_LIMIT = 12000;

void print_fast16(int_fast16_t val) {
    enum { BUFSIZE = 80 };
    char buf [BUFSIZE];
    if (MY_INTFAST16_UPPER_LIMIT < val)
      sprintf(buf, "The value is too large");
    else
      snprintf(buf, BUFSIZE, "The value is %" PRIdFAST16, val);
    /* ... */
}

Noncompliant Code Example (Identifiers With External Linkage)

In addition to symbols defined as functions in each C standard library header, identifiers with external linkage include, among many others, errno, math_errhandling, setjmp(), and va_end(), regardless of whether any of them is masked by a macro of the same name or not.

The noncompliant example below provides definitions for the C standard library functions malloc() and free(). While this practice is permitted by many traditional implementations of UNIX (see, for example, the Dmalloc library), doing so is disallowed by the C99 standard as it need not generally portable and may lead to undefined behavior. In addition, even on systems where replacing malloc() is allowed, doing so without also replacing calloc() and realloc() is likely to cause problems as well.

#include <stddef.h>

void* malloc(size_t nbytes) {
  void *ptr;
  /* allocate storage from own pool and set ptr */
  return ptr;
}

void free(void *ptr) {
  /* return storage to own pool */
}

Compliant Solution (Identifiers With External Linkage)

The compliant, portable solution avoids redefining any C standard library identifiers with external linkage. In addition, it provides definitions for all memory allocation functions.

#include <stddef.h>

void* my_malloc(size_t nbytes) {
  void *ptr;
  /* allocate storage from own pool and set ptr */
  return ptr;
}

void* my_calloc(size_t nelems, size_t elsize) {
  void *ptr;
  /* allocate storage from own pool and set ptr */
  return ptr;
}

void* my_realloc(void *ptr, size_t nbytes) {
  /* reallocate storage from own pool and set ptr */
  return ptr;
}

void my_free(void *ptr) {
  /* return storage to own pool */
}

Noncompliant Code Example (Redefinition of Reserved Library Identifier)

Legacy code is apt to include an incorrect declaration such as the following.

extern int errno;

Compliant Solution (Redefinition of Reserved Library Identifier)

The correct way to declare errno is to include the header <errno.h>.

#include <errno.h>

Implementations conforming to C99 are required to declare errno in <errno.h>, although some historic implementations failed to do so.

Risk Assessment

Using reserved identifiers can lead to incorrect program operation.

Rule

Severity

Likelihood

Remediation Cost

Priority

Level

DCL37-C

low

unlikely

low

P3

L3

Automated Detection

A module written in Compass/ROSE can detect violations of this rule.

References

[[ISO/IEC 9899:1999]] Section 7.1.3, "Reserved Identifiers"


  • No labels