Notes:
<sup>1. These enumerations are too large to the particular enum=1|2|4|8 option.  The size of the enum is increased to hold the entire range of values.  It is recommended that you change the enum option to match the size of the enum required.
2. These enumerations are too large for the enum=int option.  It is recommended that you change reduce the range of the values of the enumerations or change the enum option to enum=intlong.</sup>

The following are invalid enumerations or invalid usage of #pragma options enum=:

• You cannot change the storage allocation of an enum using a #pragma options enum= within the declaration of an enum. The following code segment generates a warning and the second occurrence of the enum option is ignored: |
  
      #pragma options enum=small
      enum e_tag { 
        a,
        b,
      #pragma options enum=int /* error: cannot be within a declaration */
        c
      } e_var;
      #pragma options enum=reset /* second reset isn't required */
• The range of enum constants must fall within the range of either unsigned int or int (signed int). For example, the following code segments contain errors:

    #pragma options enum=small
      enum e_tag { a=-1,
                   b=2147483648   /* error: larger than maximum int */
                 } e_var;
    #pragma options enum=reset

• The enum constant range does not fit within the range of an unisgned int.

    #pragma options enum=small
      enum e_tag { a=0,
                   b=4294967296 /* error: larger than maximum int */
                 } e_var;
    #pragma options enum=reset

A -qenum=reset option corresponding to the #pragma options enum=reset directive does not exist. Attempting to use -qenum=reset generates a warning message and the option is ignored.

Examples

1. One typical use for the reset suboption is to reset the enumeration size set at the end of an include file that specifies an enumeration storage different from the default in the main file. For example, the following include file, small_enum.h, declares various minimum-sized enumerations, then resets the specification at the end of the include file to the last value on the option stack:

   #ifndef small_enum_h
   #define small_enum_h 1
   /*
    * File small_enum.h
    * This enum must fit within an unsigned char type
    */
   #pragma options enum=small
      enum e_tag {a, b=255};
      enum e_tag u_char_e_var; /* occupies 1 byte of storage */
 
   /* Reset the enumeration size to whatever it was before */
   #pragma options enum=reset
   #endif

The following source file, int_file.c, includes small_enum.h:

   /*
    * File int_file.c
    * Defines 4 byte enums
    */
   #pragma options enum=int
   enum testing {ONE, TWO, THREE};
   enum testing test_enum;

   /* various minimum-sized enums are declared */
   #include "small_enum.h"
 
   /* return to int-sized enums. small_enum.h has reset the
    * enum size
    */
   enum sushi {CALIF_ROLL, SALMON_ROLL, TUNA, SQUID, UNI};
   enum sushi first_order = UNI;

The enumerations test_enum and test_order both occupy 4 bytes of storage and are of type int. The variable u_char_e_var defined in small_enum.h occupies 1 byte of storage and is represented by an unsigned char data type.

2. If the following C fragment is compiled with the enum=small option:

     enum e_tag {a, b, c} e_var;

the range of enum constants is 0 through 2. This range falls within all of the ranges described in the table above. Based on priority, the compiler uses predefined type unsigned char.

3. If the following C code fragment is compiled with the enum=small option:

      enum e_tag {a=-129, b, c} e_var;

the range of enum constants is -129 through -127. This range only falls within the ranges of short (signed short) and int (signed int). Because short (signed short) smaller, it will be used to represent the enum.

4. If you compile a file myprogram.c using the command:

     xlC myprogram.c -qenum=small

assuming file myprogram.c does not contain #pragma options=int statements, all enum variables within your source file will occupy the minimum amount of storage.

5. If you compile a file yourfile.c that contains the following lines:

       enum testing {ONE, TWO, THREE};
       enum testing test_enum;
 
     #pragma options enum=small
       enum sushi {CALIF_ROLL, SALMON_ROLL, TUNA, SQUID, UNI};
       enum sushi first_order = UNI;
 
     #pragma options enum=int
       enum music {ROCK, JAZZ, NEW_WAVE, CLASSICAL};
       enum music listening_type;

using the command:

     xlC yourfile.c

only the enum variable first_order will be minimum-sized (that is, enum variable first_order will only occupy 1 byte of storage). The other two enum variables test_enum and listening_type will be of type int and occupy 4 bytes of storage.

List of Batch Compiler Options and Their Defaults
Equivalent Batch Compile-Link and Incremental Build Options