| | |
|---|
envp argument to main()
| Allows envp as third argument to main().
| Allows this third argument; however, this usage is not strictly conforming
to the ISO C standard.
|
Keywords
| Treats the identifiers const, volatile,
and signed as ordinary identifiers.
| const, volatile, and signed are
keywords.
|
extern and static functions declarations
inside a block
| Promotes these function declarations to file scope.
| The ISO standard does not guarantee that block scope function declarations
are promoted to file scope.
|
Identifiers
| Allows dollar signs ($) in identifiers.
| $ not allowed.
|
long float types
| Accepts long float declarations and treats these
as double.
| Does not accept these declarations.
|
Multi-character character-constants
| int mc = ’abcd’; yields: abcd
| int mc = ’abcd’; yields: dcba
|
Integer constants
| Accepts 8 or 9 in octal escape sequences.
| Does not accept 8 or 9 in octal escape sequences.
|
Assignment operators
| Treats the following operator pairs as two tokens and, as a consequence,
permits white space between them: *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=
| Treats them as single tokens, and therefore disallows white space in
between.
|
Unsigned preserving semantics for expressions
| Supports unsigned preserving, that is, unsigned char/shorts are
converted into unsigned int.
| Supports value-preserving, that is, unsigned char/short(s) are converted into int.
|
Single/double precision calculations
| Promotes the operands of floating-point expressions to double. Functions that are declared to return floats always
promote their return values to doubles.
| Allows operations on floats to be performed in single
precision calculations. Allows float return types for these functions.
|
Name spaces of struct/union members
| Allows struct, union, and arithmetic
types using member selection operators (’.’, ’->’) to work on members of other structs or unions.
| Requires that every unique struct/union have
its own unique name space.
|
A cast as an lvalue
| Supports casts of integral and pointer types as lvalues.
For example: (char *)ip = &char;
| Does not support this feature.
|
Implied int declarations
| Supports declarations without an explicit type specifier. A declaration
such as num; is treated as implied int.
For example: num; /*num implied as an int*/ int num2; /* num2 explicitly*/ /* declared an int */
| The num; declaration (without the explicit type specifier int) is not supported, and generates a syntax error.
|
Empty declarations
| Allows empty declarations, for example: int;
| Except for tags, disallows empty declarations.
|
Type specifiers on type definitions
| Allows type specifiers such as unsigned, short, long on typedefs declarations. For example: typedef short small; unsigned small x;
| Does not allow type specifiers to modify typedef declarations.
|
Types allowed on bit fields
| Allows bit fields of all integral types, including unnamed bit fields. The ABI requires support of unnamed bit fields and the other integral
types.
| Supports bit-fields only of the type int, unsigned
int and signed int. Other types are undefined.
|
Treatment of tags in incomplete declarations
| Ignores the incomplete type declaration. In the following example, f1 refers to the outer struct: struct x { . . . } s1; {struct x; struct y {struct x f1; } s2; struct x { . . . };}
| In an ISO-conforming implementation, an incomplete struct or union type specifier hides an enclosing declaration with the same
tag.
|
Mismatch on struct/union/enum declarations
| Allows a mismatch on the struct/enum/union type of
a tag in nested struct/union declarations. In the following
example, the second declaration is treated as a struct: struct x {. . . }s1; {union x s2;. . .}
| Treats the inner declaration as a new declaration, hiding the outer
tag.
|
Labels in expressions
| Treats labels as (void *) lvalues.
| Does not allow labels in expressions.
|
switch condition type
| Allows floats and doubles by converting
them to ints.
| Evaluates only integral types (int, char, and enumerated)
for the switch condition type.
|
Syntax of conditional inclusion directives
| The preprocessor ignores trailing tokens after an #else or #endif directive.
| Disallows such constructs.
|
Token-pasting and the ## preprocessor operator
| Does not recognize the ## operator. Token-pasting
is accomplished by placing a comment between the two tokens being pasted: #define PASTE(A,B) A/*any comment*/B
| Defines ## as the preprocessor operator that performs
token-pasting, for example: #define PASTE(A,B) A##B Furthermore, the preprocessor does not recognize the method. Instead, it treats the comment
between the two tokens as white space.
|
Preprocessor rescanning
| The preprocessor recursively substitutes: #define F(X) X(arg) F(F) yields arg(arg)
| A macro is not replaced if it is found in the replacement list during
the rescan: #define F(X)X(arg)F(F) yields: F(arg)
|
typedef names in formal parameter lists
| You can use typedef names as formal parameter names
in a function declaration. “Hides” the typedef declaration.
| Disallows the use of an identifier declared as a typedef name
as a formal parameter.
|
Implementation specific initializations of aggregates
| Uses a bottom-up algorithm when parsing and processing partially elided
initializers within braces: struct{ int a[3]; int b; }\ w[]={{1},2}; yields sizeof(w)=16 w[0].a=1,0,0 w[0].b=2
| Uses a top-down parsing algorithm. For example: struct{int a[3];int b;}\ w[]={{1},2}; yields sizeof(w)=32w[0].a=1,0,0w[0].=0w[1].a=2,0,0w[1].b=0
|
Comments spanning include files
| Allows comments that start in an #include file to
be terminated by the file that includes the first file.
| Comments are replaced by a white-space character in the translation
phase of the compilation, which occurs before the #include directive
is processed.
|
Formal parameter substitution within a character constant
| Substitutes characters within a character constant when it matches the
replacement list macro: #define charize(c)’c’ charize(Z) yields: ’Z’
| The character is not replaced: #define charize(c) ’c’charize(Z) yields: ’c’
|
Formal parameter substitution within a string constant
| The preprocessor substitutes a formal parameter when enclosed within
a string constant: #define stringize(str) ’str’ stringize(foo) yields: ”foo”
| The # preprocessor operator should be used: #define stringize(str) ’str’ stringize(foo) yields: ”str”
|
Preprocessor built into the compiler “front-end”
| Compiler invokes cpp(1) followed by all the other
components of the compilation system depending on the options specified.
| The ISO C translation phases 1-4, which cover the processing of preprocessor directives, is
built directly into acomp, so cpp is not directly invoked during compilation,
except in -Xs mode.
|
Line concatenation with backslash
| Does not recognize the backslash character in this context.
| Requires that a newline character immediately preceded by a backslash
character be spliced together.
|
Trigraphs in string literals
| Does not support this ISO C feature.
|
|
asm keyword
| asm is a keyword.
| asm is treated as an ordinary identifier.
|
Linkage of identifiers
| Does not treat uninitialized static declarations
as tentative declarations. As a consequence, the second declaration will generate
a ’redeclaration’ error, as in: static int i = 1; static int i;
| Treats uninitialized static declarations as tentative
declarations.
|
Name spaces
| Distinguishes only three: struct/union/enum tags,
members of struct/union/enum, and everything else.
| Recognizes four distinct name spaces: label names, tags (the names that
follow the keywords struct, union or enum),
members of struct/union/enum, and ordinary identifiers.
|
long double type
| Not supported.
| Allows long double type declaration.
|
Floating point constants
| The floating point suffixes, f, l, F, and L, are not supported.
|
|
Unsuffixed integer constants can have different types
| The integer constant suffixes u and U are not supported.
|
|
Wide character constants
| Does not accept the ISO C syntax for wide character constants, as in: wchar_t wc = L’x’;
| Supports this syntax.
|
’\a’ and ’\x’
| Treats them as the characters ’a’ and ’x’.
| Treats ’\a’ and ’\x’ as
special escape sequences.
|
Concatenation of string literals
| Does not support the ISO C concatenation of adjacent string literals.
|
|
Wide character string literal syntax
| Does not support the ISO C wide character, string literal syntax shown
in this example: wchar_t *ws = L"hello";
| Supports this syntax.
|
Pointers: void * versus char *
| Supports the ISO C void * feature.
|
|
Unary plus operator
| Does not support this ISO C feature.
|
|
Function prototypes— ellipses
| Not supported.
| ISO C defines the use of ellipses "..." to denote a variable argument
parameter list.
|
Type definitions
| Disallows typedefs to be redeclared in an inner block
by another declaration with the same type name.
| Allows typedefs to be redeclared in an inner block
by another declaration with the same type name.
|
Initialization of extern variables
| Does not support the initialization of variables explicitly declared
as extern.
| Treats the initialization of variables explicitly declared as extern, as definitions.
|
Initialization of aggregates
| Does not support the ISO C initialization of unions or automatic structures.
|
|
Prototypes
| Does not support this ISO C feature.
|
|
Syntax of preprocessing directive
| Recognizes only those directives with a # in the
first column.
| ISO C allows leading white-space characters before a # directive.
|
The # preprocessor operator
| Does not support the ISO C # preprocessor operator.
|
|
#error directive
| Does not support this ISO C feature.
|
|
Preprocessor directives
| Supports two pragmas, unknown_control_flow and makes_regs_inconsistent along with the #ident directive.
The preprocessor issues warnings when it finds unrecognized pragmas.
| Does not specify its behavior for unrecognized pragmas.
|
Predefined macro names
| These ISO C-defined macro names are not defined: __STDC__ __DATE__ __TIME__ __LINE__
|
|