6 Additions to ANSI C and C++


Preprocessor predefined macros 121
Preprocessor directives 123
#assert and #unassert preprocessor directives 123
#error preprocessor directive 124
#ident preprocessor directive 124
#import preprocessor directive 125
#info, #inform, and #informing preprocessor directives 125
#warn and #warning preprocessor directives 125
Pragmas 126
align pragma 126
error pragma 126
global_register pragma 127
hdrstop pragma 128
ident pragma 128
info pragma 128
inline pragma 128
interrupt pragma 129
no_alias pragma 130
no_pch pragma 130
no_return pragma 130
no_side_effects pragma 131
option pragma 131
pack pragma 132
pure_function pragma 136
section pragmas 137
use_section pragma 137
warning pragma 137
weak pragma 138
Keywords 138
__asm and asm keywords 139
extended keyword (C only) 140
__inline__ and inline keywords 140
__interrupt__ and interrupt keywords (C only) 141
long long 142
__packed__ and packed (C only) 142
pascal keyword (C only) 143
Other additions 144
C++ comments permitted 144
Dynamic memory allocation with alloca 144
Assigning global variables to registers 144
__ERROR__ function 145
Intrinsic functions 146
sizeof extension 147


This section describes additions to the ANSI C and C++ standards implemented in Diab C/C++.


Preprocessor predefined macros

The following preprocessor macros are predefined. The macros not starting with two underscores ("__") will not be defined if option -Xdialect-strict-ansi is given.

Table 6-1   Predefined macros  

__bool  

The constant 1 if type bool is defined when compiling C++ code, otherwise undefined. Option -Xbool-off disables the bool, true, and false keywords. C++ only.  

__cplusplus  

The constant 199711 when compiling C++ code, otherwise undefined.  

__DATE__  

The current date in "Mmm dd yyyy" format; it cannot be undefined.  

__DCC__  

The constant 1.  

__DCPLUSPLUS__  

The constant 1 when compiling C++ code, otherwise undefined.  

_DIAB_TOOL  

Diab tool.  

__EABI__  

ELF ABI object format.  

__ETOA__  

Indicates that full ANSI C++ is supported. Not defined when compiling C code or when an older version of the compiler is invoked.  

__ETOA_IMPLICIT_USING_STD

 

Defined if -Xusing-std-on is enabled. Indicates that runtime library declarations are automatically searched for in the std namespace (not in global scope), regardless of whether using namespace std; is specified.  

__ETOA_NAMESPACES

 

Defined if the runtime library uses namespaces.  

__EXCEPTIONS  

Exceptions are enabled (C++ only).  

__FILE__  

The current file name; it cannot be undefined.  

__hardfp  

Hardware floating point support.  

__LDBL__  

The constant 1 if the type long double is different from double.  

__LINE__  

The current source line; it cannot be undefined.  

__lint  

This macro is not predefined; instead, define this when compiling to select pure-ANSI code in Diab header files, avoiding use of any non-ANSI extensions.  

__nofp  

No floating point support.  

__ppc  

Target flag used by various tools.  

__RTTI  

Run-time type information is enabled (C++ only).  

__SIGNED_CHARS__  

C++ only. Defined as 1 if plain char is signed. (See -Xchar-signed, p.68.)  

__softfp  

Software floating point support.  

__STDC__  

The constant 0 if -Xdialect-ansi and the constant 1 if -Xdialect-strict-ansi is given. It cannot be undefined if -Xdialect-strict-ansi is set. For C++ modules it is defined as 0 in all other cases.  

__STRICT_ANSI__  

The constant 1 if -Xdialect-strict-ansi.  

__TIME__  

The current time in "hh:mm:ss" format; it cannot be undefined.  

__VEC__  

The constant 10205 when DFP=V (see Selecting a Target and Its Components, p.25), defined in accordance with the AltiVec Technology Programming Interface Manual.  

__wchar_t  

The constant 1 if type wchar_t is defined when compiling C++ code, otherwise undefined. Option -X-wchar-off disables the wchar_t keyword.  


Preprocessor directives

The following additional preprocessor directives are recognized by Diab C and C++.

#assert and #unassert preprocessor directives

The #assert and #unassert directives allow definition of preprocessor variables that do not conflict with names in the program name space. These variables can be used to direct conditional compilation. The C and C++ preprocessors recognize slightly different syntax for #assert and #unassert.

Assertions can also be made on the command line through the -A option.

To display information about assertions at compile time, use the -Xcpp-dump-symbols option (p.72).

To make an assertion with a preprocessor directive, use the syntax:

In the first form, name is given the value value. In the second form, name is defined but not given a value. Whitespace is allowed only where shown. Examples:

#assert system(unix)
#assert system

To make an assertion on the command line, use:

Examples:

dcc -A "system(unix)" test.c    (UNIX)
dcc -A system\(unix\) test.c    (UNIX)
dcc -A system(unix) test.c      (Windows)

Assertions can be tested in an #if or #elif preprocessor directive with the syntax:

A statement of the first form evaluates to true if an assertion of that name with that value has appeared and has not been removed. (A name can have more than one value at the same time.) A statement of the second form evaluates to true if an assertion of that name with any value has appeared.

Examples:

#if #system(unix)
#if #system

An assertion can be removed with the #unassert directive:

The first form removes all definitions of name. The other forms remove only the specified definition.

Examples:

#unassert system
#unassert system(unix)
#unassert #system(unix)

#error preprocessor directive

The #error preprocessor directive displays a string on standard error and halts compilation. Its syntax is:

Example:

#error "Feature not yet implemented."

See also #info, #inform, and #informing preprocessor directives, p.125 and #warn and #warning preprocessor directives, p.125.

#ident preprocessor directive

The #ident preprocessor directive inserts a comment into the generated object file. The syntax is:

Example:

#ident "version 1.2"

The text string is forwarded to the assembler in an ident pseudo-operator and the assembler outputs the text in the .comment section.

#import preprocessor directive

The #import preprocessor directive is equivalent to the #include directive, except that if a file has already been included, it is not included again. The same effect can be achieved by wrapping all header files with protective #ifdefs, but using #import is much more efficient since the compiler does not have to open the file. Using the -Ximport command line option will cause all #include directives to behave like #import.

#info, #inform, and #informing preprocessor directives

The #info, #inform, and #informing preprocessor directives display a string on standard error and continue compilation. Their syntax is:

Example:

#info "Feature not yet implemented."

See also #error preprocessor directive, p.124 and #warn and #warning preprocessor directives, p.125.

#warn and #warning preprocessor directives

The #warn and #warning preprocessor directives display a string on standard error and continue compilation. Their syntax is:

Example:

#warn "Feature not yet implemented."

See also #error preprocessor directive, p.124 and #info, #inform, and #informing preprocessor directives, p.125.


Pragmas

This section describes the pragmas supported by Diab C/C++. A warning is issued for unrecognized pragmas.

Pragma directives are not preprocessed. Comments are allowed on pragmas.

In C++ modules, a pragma naming a function affects all functions with the same name, independently of the types and number of parameters--that is, independently of overloading.

align pragma

#pragma align [ ([[max_member_alignment], [min_structure_alignment] [, byte-swap]])]

The align pragma, provided for portability, is a synonym for pack. See pack pragma, p.132.

error pragma

#pragma error string

Display string on standard error as an error and halt compilation. See also info pragma, p.128 and warning pragma, p.137.

global_register pragma

#pragma global_register identifier=register ,...

This pragma forces a global or static variable to be allocated to a specific register. This can increase execution speed considerably when a global variable is used frequently, e.g., the "program counter" variable in an interpreter.

identifier gives the name of a variable. register gives the name of the selected register in the target processor. See Register use, p.181 for a list of valid register names.

The following rules apply:

Examples:

#pragma global_register counter=register-name
char *counter;         /* allocated to the named register */

/* Force the compiler to avoid a named register. */
#pragma global_register __dummy=register-name

hdrstop pragma

#pragma hdrstop

C++ only. Suppress generation of precompiled headers. Headers included after #pragma hdrstop are not saved in a parsed state. See Precompiled headers, p.231 for more information.

ident pragma

#pragma ident string

Insert a comment into the generated object file.

Example:

#pragma ident "version 1.2"

The text string is forwarded to the assembler in an ident pseudo-operator and the assembler outputs the text in the .comment section.

info pragma

#pragma info string

Display string on standard error and continue compilation. See also error pragma, p.126 and warning pragma, p.137.

inline pragma

#pragma inline func ,...

Inline the given function whenever possible. The pragma must appear before the definition of the function. Note that a function can be inlined only in the module in which it is defined. Calls from other modules are not inlined.

In C++ modules, the inline function specifier is normally used instead. This specifier will however also make the function local to the file, without external linkage. Conversely, the #pragma inline directive provides a hint to inline the code directly to the code optimizer, without any effect on the linkage scope.

Example:

#pragma inline swap

void swap(int *a, int *b) { 
    int tmp; 
    tmp = *a; *a = *b; *b = tmp; 
}

interrupt pragma

#pragma interrupt function ,...

Designate function as an interrupt function. Code is generated to save all general purpose scratch registers and to use a different return instruction.

This pragma is available in C modules only.

 Important interrupt pragma notes  

Example:

#pragma interrupt trap

void trap () {
    /* this is an interrupt function */
}

no_alias pragma

#pragma no_alias { var1 | *var2 } ,...

Promise that the variable var1 is not accessed in any manner (through pointers etc.) other than through the variable name; promise that the data at *var2 is only accessed through the pointer var2. This allows the compiler to better optimize references to such variables.

The pragma must appear after the definition of the variable and before its first use.

Example:

add(double *d, double *s1, double *s2, int n)
#pragma no_alias *d, *s1, *s2
{
    int i;

    for (i = 0; i < n; i++) {
        /* "s1 + s2" will move outside  the loop */
        d[i] = *s1 + *s2;
    }
}

Without the pragma, either s1 or s2 might point into d and the assignment might then set s1 or s2. See also option -Xargs-not-aliased (-X65) on p.63.

no_pch pragma

#pragma no_pch

Suppress all generation of precompiled headers from the file where #pragma no_pch occurs. See Precompiled headers, p.231 for more information.

no_return pragma

#pragma no_return function ,...

Promise that each function never returns. Helps the compiler generate better code.

This pragma must appear before the first use of the function. A convenient method is to put it with a prototype declaration for the function, perhaps in a header file.

Example:

#pragma no_return exit, abort, longjmp

no_side_effects pragma

#pragma no_side_effects descriptor ,...

where each descriptor has one of the following forms and meanings:

This pragma must appear before the first use of the function. A convenient method is to put it with a prototype declaration for the function, e.g. in a header file.

Contrast with pragma pure_function (p.136) which also promises that a function does not use any global or static variables.

Example:

#pragma no_side_effects strcmp(1), sin(errno), \
            my_func(1, 2, my_global)

option pragma

#pragma option option [option ...]

where option is any of the -g, -O, or -X options (including the leading `-' character). This option makes it possible to set these options from within a source file.

These options must be at the beginning of the source file before any other source lines. The effect of other placement is undefined.

Note that some -X options are consumed by driver or compiler command line processing before a source file is read. If an -X option does not appear to have the intended effect, try it on the command line. If effective there, that option can not be used as a pragma.

pack pragma

#pragma pack [ ([[max_member_alignment], [min_structure_alignment] [, byte-swap]]) ]

The pack directive specifies that all subsequent structures are to use the alignments given by max_member_alignment and min_structure_alignment where:

If neither max_member_alignment nor min_structure_alignment are given, they are both set to 1. If either max_member_alignment or min_structure_alignment is zero, the corresponding default alignment is used. If max_member_alignment is non-zero and min_structure_alignment is not given it will default to 1.

The form #pragma pack is equivalent to #pragma pack(1,1,0). The form #pragma pack() is equivalent to #pragma pack(0,0,0).

The align pragma, provided for portability, is an exact synonym for pack.

An alternative method of specifying structure padding is by using the __packed__ keyword (see p.142).

Default values for max_member_alignment and min_structure_alignment can be set by using the -Xmember-max-align and the -Xstruct-min-align options. The order of precedence is values -X options lowest, then the packed pragma, and __packed__ or packed keyword highest.

 Restrictions and additional information  

Note that if a structure is not packed, the compiler will insert extra padding to assure that no alignment exception occurs when accessing multi-byte members if required by the selected processor, that is, if -Xalign-min > 1 (see p.62).

When a structure is packed, if the processor requires that multi-byte values be aligned (-Xalign-min > 1), the following restrictions apply:

In addition, for packed structures, an enum member will use the smallest type sufficient to represent the range (equivalent to -Xenum-is-best, see p.78).

 Examples  

Later examples depend on earlier examples in some cases.

#pragma pack(2,2)
struct s0 {
    char a;              1 byte at offset 0, 1 byte padding 
    short b;             2 bytes at offset 2 
    char c;              1 byte at offset 4 
    char d;              1 byte at offset 5 
    int e;               4 bytes at offset 6 
    char f;              1 byte at offset 10 
};                       total size 11, alignment 2 

If two such structures are in a section beginning at offset 0xF000, the layout would be:

#pragma pack(1)          Same as #pragma pack(1,1), no padding.
struct S1 {
    char c1;             1 byte at offset 0
    long i1;             4 bytes at offset 1
    char d1;             1 byte at offset 5
};                       total size 6, alignment 1

#pragma pack(8)          Use "natural" packing for largest member.
struct S2 {
    char c2;             1 byte at offset 0, 3 bytes padding
    long i2;             4 bytes at offset 4
    char d2;             1 byte at offset 8, 3 bytes padding
};                       total size 12, alignment 4

#pragma pack(2,2)        Typical packing on machines which cannot
struct S3 {              access multi-byte values on odd-bytes.
    char  c3;            1 byte at offset 0, 1 byte padding
    long i3;             4 bytes at offset 2
    char d3;             1 byte at offset 6, byte padding
};                       total size 8, alignment 2

struct S4 {              Using pragma from prior example.
    char c4;             1 byte at offset 0, 1 byte padding
};                       total size 2, alignment 2 since
                         min_member_alignment is 2 above

#pragma pack(8)          "Natural" packing because S3 is 8 bytes long.
struct S {
    char e1;             1 byte at offset 0
    struct S1 s1;        6 bytes at offset 1, 1 byte padding
    struct S2 s2;        12 bytes at offset 8
    char e2;             1 byte at offset 20, 1 byte padding
    struct S3 s3;        8 bytes, at offset 22, 2 bytes padding alignment 2
};                       total size 32, alignment 4

#pragma pack(0)          Set to default packing.

pure_function pragma

#pragma pure_function function ,...

Promises that each function does not modify or use any global or static data. Helps the compiler generate better code, for example, in optimization of common sub-expressions containing identical function calls. Contrast with pragma no_side_effects (p.131) which only promises that a function does not modify global variables.

This pragma must appear before the first use of the function. A convenient method is to put it with a prototype declaration for the function, perhaps in a header file.

Example:

#pragma pure_function sum
int sum(int a, int b) {
    return a+b;
}

section pragmas

#pragma section class_name [istring [ustring]] [addr_mode] [acc_mode] [address=x]

The #pragma section defines sections into which variables and code can be placed. It also defines how objects in sections are addressed and accessed.

This pragma must appear before the declaration (for functions, before the prototype if present) of all variables and all functions to which it is to apply.

The section pragma is discussed in detail in 14, Locating Code and Data, Addressing, and Access, p.235.

use_section pragma

#pragma use_section class_name variable ,...

Selects the section class into which a variable or function is placed. A section class is defined by #pragma section.

The use_section pragma is available in C modules only; not C++.

This pragma must appear before the declaration (for functions, before the prototype if present) of all variables and all functions to which it is to apply.

The use_section pragma is discussed in detail in 14, Locating Code and Data, Addressing, and Access, p.235.

warning pragma

#pragma warning string

Display string on standard error as a warning and continue compilation. See also error pragma, p.126 and info pragma, p.128.

weak pragma

#pragma weak symbol

Mark symbol as weak.

When a #pragma weak for a symbol is given in the module defining the symbol, it is a weak definition. When the #pragma weak is in a module using but not defining it, it is a weak reference.

Because this pragma is ultimately processed by the assembler, it may appear anywhere in the source file.

A weak symbol resembles a global symbol with two differences:

Note while a symbol may be defined in more than one module as long as at most one of the definitions is global or common while the rest (or all) are weak, the linker will resolve references to the first instance of the symbol it encounters. In particular, if two libraries contain a weak definition and a global definition of a symbol, and the library containing the weak symbol is searched first, the module containing the weak symbol will be linked.


Keywords

The following additional keywords are recognized by Diab C/C++.

__asm and asm keywords

Used to embed assembly language (see 7, Embedding assembly code, p.149) and to assign variables to registers (see Assigning global variables to registers, p.144).

__attribute__ keyword

Available in C only, __attribute__ specifies packing or alignment for variables and data structures. The syntax is:

__attribute__ (( packed ))
__attribute__ (( aligned(n) ))
__attribute__ (( aligned(n) , packed ))

where n is a power of two. For non-structure fields, __attribute__ can be placed anywhere before or immediately following the identifier name. Examples:

__attribute__ ((aligned(8))) int foo;
int __attribute__ ((aligned(8))) foo;
int foo __attribute__ ((aligned(8)));

The type modifier is left-associative. Thus

int foo, bar __attribute__ ((aligned(8)));

forces alignment for bar, but not for foo.

For structures, __attribute__ can be placed anywhere before the struct or union keyword, or immediately following the closing braces for struct or union. Examples:

/* align structure on 8 and pack it */
__attribute__ (( aligned(8),packed )) struct a {
     char b;
     int a;
} str;

/* structure packed */
struct b {
     char b;
     int a ;
}  __attribute__ ((packed)) str1;

/* structure element with special alignment */
struct c {
     int k;
     __attribute__ ((aligned(8))) char a;
} str2;

Special alignment for members of a packed structure is ignored. For example:

struct c {
     int k;
     __attribute__ ((aligned (8))) char a; /* alignment ignored */
} __attribute__((packed)) str4;

The __attribute__ keyword can also be used in a typedef.

extended keyword (C only)

If the option -Xkeywords=x is used with the least significant bit set in x (e.g., -Xkeywords=0x1), the compiler recognizes the keyword extended as a synonym for long double.

Example:

extended e;         /* the same as long double e; */

__inline__ and inline keywords

The __inline__ and inline keywords provide a way to replace a function call with an inlined copy of the function body. The __inline__ keyword is intended for use in C modules but is disabled in strict-ANSI mode. The inline keyword is normally used in C++ modules but can also be used in C if the option -Xkeywords=0x4 is given (see p.89).

__inline__ and inline make the function local (static) to the file by default. Conversely, the #pragma inline directive provides a hint to inline the code directly to the code optimizer, without any effect on the linkage scope. Use extern to make an inline function public.

Example:

__inline__ void inc(int *p)  {
    *p = *p+1;
}

    inc(&x);

The function call will be replaced with

    x = x+1;

__interrupt__ and interrupt keywords (C only)

The __interrupt__ keyword provides a way to define a function as an interrupt function. The difference between an interrupt function and a normal function is that all registers are saved, not just the those which are volatile, and a special return instruction is used. __interrupt__ works like the #pragma interrupt directive (see p.129). The keyword interrupt can also be used if the option -Xkeywords=0x10 is given (see p.89).

Example:

__interrupt__ void trap() {
    /* this is an interrupt function */
}

For more information about interrupts, see the -Xinterrupt... and -Xnested-interrupts compiler options.

long long

The Diab compilers support 64-bit integers for all PowerPC microprocessors. A variable declared long long or unsigned long long is an 8 byte integer. To specify a long long constant, use the LL or ULL suffixes. A suffix is required because constants are of type int by default.

long long mask_nibbles (long long x)
{
    return (x & 0xf0f0f0f0f0f0f0f0LL);
}

Note: bit-fields are not permitted in variables of type long long.

__packed__ and packed (C only)

__packed__ ([[max_member_alignment], [min_structure_alignment] [, byte-swap]])

The __packed__ keyword defines how a structure should be padded between members and at the end. The keyword packed can also be used if the option -Xkeywords=0x8 is given. See #pragma pack on p.132 for treatment of 0 values, defaults, and restrictions.

The max_member_alignment value specifies the maximum alignment of any member in the structure. If the natural alignment of a member is less than max_member_alignment, the natural alignment is used. See 8, Internal Data Representation, p.161 for more information about alignments and padding.

The min_structure_alignment value specifies the minimum alignment of the structure. If any member has a greater alignment, the highest value is used.

Default values for max_member_alignment and min_structure_alignment can be set by using the -Xmember-max-align and the -Xstruct-min-align options. The order of precedence is values -X options lowest, then the packed pragma , and __packed__ or packed keyword highest.

The byte-swapped option enables swapping of bytes in structure members as they are accessed. If 0 or absent, bytes are taken as is; if 1, bytes are swapped as they are transferred between byte-swapped structure members and registers or non-byte-swapped memory.

See #pragma pack on p.132 for defaults for missing parameters and for additional examples.

Examples:

__packed__ struct s1 {            No padding between members.
    char c;
    int  i;                       starts at offset 1
};                                total size is 5 bytes

__packed__(2,2) struct s2 {       Maximum alignment is 2.
    char c;
    int  i;                       starts at offset 2
};                                total size is 6 bytes

__packed__(4) struct s3 {         Maximum alignment is 4.
    char c;
    int  i;                       starts at offset 4
};                                total size is 8 bytes

__packed__(4,2) struct s4 {       Minimum alignment is 2.
    char c;
};                                total size is 2 bytes 

pascal keyword (C only)

If the option -Xkeywords=x is used with bit 1 set in x (e.g., -Xkeywords=0x2), the compiler recognizes the keyword pascal. This keyword is a type modifier that affects functions in the following way:


Other additions

C++ comments permitted

C++ style comments beginning with // are allowed by default. To disable this feature, use -Xdialect-strict-ansi. Example:

int number1bits (int i)    // Count the number of 1 bits
{                          // in "i".
    int n = 0;

    while (i != 0) {
        i &= (i - 1);
        n ++;
    }
    return n;
}

Dynamic memory allocation with alloca

The alloca(size) and __alloca(size) functions are provided to dynamically allocate temporary stack space inside a function. Example:

char *alloca();
char *p;

p = alloca(1000);

The pointer p points to an allocated area of 1000 bytes on the stack. This area is valid only until the current function returns. The use of alloca( ) typically increases the entry/exit code needed in the function and turns off some optimizations such as tail recursion.

See Intrinsic functions, p.146 for additional details.

Assigning global variables to registers

You can assign a global variable to a preserved register by placing asm("register-name") or __asm("register-name") immediately after the variable name in the declaration. For example,

int some_global_var asm("r11");

assigns the variable some_global_var to r11. Local variables cannot be assigned in this way.

__ERROR__ function

The __ERROR__( ) function produces a compile-time error or warning if it is seen by the code generator. This is useful for making compile-time checks beyond those possible with the preprocessor--e.g. ensuring that the sizes of two structures are the same, as shown in the example below. If the __ERROR__( ) function is placed after an if statement that is not executed unless the assertion fails, the optimizer removes the __ERROR__( ) function and no error is generated. (The optimizer must be enabled (at any level) for this technique to work.)

The syntax of the __ERROR__( ) function:

where error-string is the error message to be generated and the optional value defines whether the error should be:

If no value is given, the default value of 1 is used.

Example:

extern void __ERROR__(char *, ...);

#define CASSERT(test) \
    if (!(test)) __ERROR__("C assertion failed: " #test)
.
.
.
CASSERT(sizeof(struct a) == sizeof(struct b));

When __ERROR__( ) is used in C++ code, it must be declared like this:

extern "C" void __ERROR__(char *, ...);

Intrinsic functions

The compiler implements the following intrinsic functions to give access to specific PowerPC instructions. See the processor manufacturer's documentation for details on machine instructions.

Intrinsic functions can be selectively disabled with the -Xintrinsic-mask=n (-X154=n) option, where n is a bit mask that can be given in hex; mask bits can be OR-ed to select more than one. n defaults to 0xf for most targets, or, when -tPPCEV is selected, to 0x1f; for PPC405 and PPC440, n defaults to 0x2f.

Note:

Intrinsic functions are also provided for the 24 multiply-accumulate instructions available in the PPC405 (-Xintrinsic-mask=0x20). To access an instruction, add two underscores before its mnemonic and pass three arguments for a mac* instruction or two arguments for a mul* instruction. Example:

int foo(int a, int b, int c, unsigned int d, unsigned int e)
{
    return __macchw(a,b,c) + __mullhwu(d,e);
}

AltiVec instructions are similarly supported by intrinsic functions (-Xintrinsic-mask=0x10). See the AltiVec Technology Programming Environments Manual for information.

sizeof extension

The sizeof operator has been extended to incorporate the following syntax:

where int-const is an integer constant between 0 and 2 with the following semantics:  

Examples:

i = sizeof(long ,2)        /* type of long: i = 6 */
j = sizeof(short,1)        /* alignment of short: j = 2 */

 

support@windriver.com
Copyright © 2002, Wind River Systems, Inc. All rights reserved.