DEC C
User's Guide for OpenVMS Systems


Previous Contents Index

This program produces the following output:


$ CC  EXAMPLE.C[Return]
$ LINK  EXAMPLE.OBJ[Return]
$ RUN  EXAMPLE.EXE[Return]
I'm being compiled with DEC C on an OpenVMS system.
$ CC/UNDEFINE="<double_uscore>DECC" EXAMPLE [Return]
$ LINK  EXAMPLE.OBJ[Return]
$ RUN  EXAMPLE.EXE[Return]
I'm being compiled on some other compiler.

/[NO]DIAGNOSTICS[=file-spec]

Creates a file containing compiler messages and diagnostic information. The default file extension for a diagnostics file is .DIA. The diagnostics file is used with the DEC Language-Sensitive Editor (LSE). To display a diagnostics file, enter the command REVIEW/FILE=file-spec while in LSE. For more information, see Appendix C. The default is /NODIAGNOSTICS.

/ENDIAN=option (ALPHA ONLY)

This qualifier takes the options BIG or LITTLE.

It controls whether big or little endian ordering of bytes is carried out in character constants. For example, consider the following declaration:


int foo = 'ABCD'; 

Specifying /ENDIAN=LITTLE places 'A' in the first byte, 'B' in the second byte, and so on.

Specifying /ENDIAN=BIG places 'D' in the first byte, 'C' in the second byte, and so on.

The default is /ENDIAN=LITTLE.

/[NO]ERROR_LIMIT[=n]

This qualifier limits the number of Error-level diagnostic messages that are acceptable during program compilation. Compilation terminates when the limit n is exceeded. /NOERROR_LIMIT specifies that there is no limit on error messages.

The default is /ERROR_LIMIT=30, which specifies that compilation terminates after 31 error messages.

/EXTERN_MODEL=option

In conjunction with the /[NO]SHARE_GLOBALS qualifier, controls the initial compiler model for external objects. Conceptually, the compiler behaves as if the first line of the program being compiled was a #pragma extern_model with the model and psect name, if any, specified by the /EXTERN_MODEL qualifier and with the shr or noshr keyword specified by the /[NO]SHARE_GLOBALS qualifier.

For example, assume the command line contains the following qualifiers:


/EXTERN_MODEL=STRICT_REFDEF="MYDATA"/NOSHARE 

The compiler will behave as if the program begins with the following line:


#pragma extern_model strict_refdef "MYDATA" noshr 

Table 1-6 describes the /EXTERN_MODEL qualifier options.

Table 1-6 /EXTERN_MODEL Qualifier Options
Option Usage
COMMON_BLOCK Sets the compiler's extern_model to the common_block model. This is the model traditionally used for extern data by VAX C.
RELAXED_REFDEF Sets the compiler's extern_model to the relaxed_refdef model. Some declarations are references and some are definitions. Multiple uninitialized definitions for the same object are allowed and are resolved into one by the linker. However, a reference requires that at least one definition exist.

This is the model used by the portable C compiler ( pcc ) on UNIX systems.

STRICT_REFDEF [=" name"] Sets the compiler's extern_model to the strict_refdef model. Some declarations are references and some are definitions. There must be exactly one definition in the program for any symbol referenced. The optional name, in quotation marks, is the name of the psect for any definitions.

This is the model specified by ANSI C. Use it in a program that is to be a strict ANSI C conforming program.

This model is the preferred alternative to the nonstandard storage-class keywords globaldef and globalref .

GLOBALVALUE Sets the compiler's extern_model to the globalvalue model. This model is similar to the strict_refdef model except that these global objects have no storage; instead, they are link-time constant values. There are two cases:
  • If the declaration is an ANSI C reference, the same object file records are produced as VAX C would produce for an uninitialized globalvalue .
  • If the declaration is an ANSI C definition, the same object records are produced as VAX C would produce for an initialized globalvalue .

This model is the preferred alternative to the nonstandard storage-class keyword globalvalue .

The default is /EXTERN_MODEL=RELAXED_REFDEF. This is different from VAX C, which uses the common block model for external objects.

/FLOAT=option

Controls the format of floating-point variables.

On OpenVMS Alpha systems, representation of double variables defaults to G_floating format if not overridden by another format specified with the /FLOAT or /[NO]G_FLOAT qualifier.

If you are linking against object-module libraries, and /PREFIX=ALL is not specified on the command line:

The VAXCRTLX.OLB, VAXCRTLDX.OLB, and VAXCRTLTX.OLB libraries are used for the same floating-point formats, respectively, but include support for X_FLOAT format (/L_DOUBLE_SIZE=128). (ALPHA ONLY)

If /PREFIX=ALL is specified, then there is no need to link to the above-mentioned *.OLB object libraries. All the symbols you need are in STARLET.OLB. (ALPHA ONLY)

On OpenVMS VAX systems, representation of double variables defaults to D_floating format if not overridden by another format specified with the /FLOAT or /[NO]G_FLOAT qualifier. There is one exception: if /STANDARD=MIA is specified, G_floating is the default. If you are linking against object-module libraries, a program compiled with G_floating format must be linked with the object library DECCRTLG.OLB. (VAX ONLY)

Table 1-7 describes the /FLOAT qualifier options.

Table 1-7 /FLOAT Qualifier Options
Option Usage
D_FLOAT double variables are represented in D_floating format.
G_FLOAT double variables are represented in G_floating format.
IEEE_FLOAT (ALPHA ONLY) float and double variables are represented in IEEE floating-point format (S_float and T_float, respectively). Use the /IEEE_MODE qualifier for controlling the handling of IEEE exceptional values. If /IEEE_MODE is not specified, the default behavior is /IEEE_MODE=FAST.

/[NO]G_FLOAT

Controls the format of floating-point variables. The /[NO]G_FLOAT qualifier is replaced by the /FLOAT qualifier, but is retained for compatibility.

If you specify /G_FLOAT, double variables are represented in G_floating format.

If you specify /NOG_FLOAT, double variables are represented in D_floating format. (See Section 4.5 for more information on the floating formats.)

On OpenVMS Alpha systems, representation of double variables defaults to G_floating format if not overridden by another format specified with the /FLOAT or /[NO]G_FLOAT qualifier.

If you are linking against object-module libraries, and /PREFIX=ALL is not specified on the command line:

The VAXCRTLX.OLB, VAXCRTLDX.OLB, and VAXCRTLTX.OLB libraries are used for the same floating-point formats, respectively, but include support for X_FLOAT format (/L_DOUBLE_SIZE=128). (ALPHA ONLY)

If /PREFIX=ALL is specified, then there is no need to link to the above-mentioned *.OLB object libraries. All the symbols you need are in STARLET.OLB. (ALPHA ONLY)

On OpenVMS VAX systems, representation of double variables defaults to D_floating format if not overridden by another format specified with the /FLOAT or /[NO]G_FLOAT qualifier. There is one exception: if /STANDARD=MIA is specified, G_floating is the default. If you are linking against object-module libraries, a program compiled with G_floating format must be linked with the object library DECCRTLG.OLB. (VAX ONLY)

/GRANULARITY=option (ALPHA ONLY)

Determines how much memory to effectively cache for memory reference, depending on the compiler and the underlying system. For example, quadword granularity may require that the system cache quadword values in registers. If access to data in the same granularity unit occurs simultaneously, corruption (by storing back stale values) can occur.

Granularity has two aspects: references inside a particular data segment and references between data segments.

The options are:

The default is /GRANULARITY=QUADWORD.

/IEEE_MODE=option (ALPHA ONLY)

Selects the IEEE floating-point mode to be used if /FLOAT=IEEE_FLOAT is specified.

Table 1-8 describes the /IEEE_MODE options.

Table 1-8 /IEEE_MODE Options
Option Usage
FAST During program execution, only finite values (no infinities, NaNs, or denorms) are created. Underflows and denormal values are flushed to zero. Exceptional conditions, such as floating-point overflow, divide-by-zero, or use of an IEEE exceptional operand are fatal. This is the default option.
UNDERFLOW_TO_ZERO Generate infinities and NaNs. Flush denormalized results and underflow to zero without exceptions.
DENORM_RESULTS Same as UNDERFLOW_TO_ZERO, except that denorms are generated.
INEXACT Same as DENORM_RESULTS, except that inexact values are trapped. This is the slowest mode, and is not appropriate for any sort of general-purpose computations.

The default is /IEEE_MODE=FAST.

/[NO]INCLUDE_DIRECTORY=(pathname[,...])

Provides similar functionality to the -i option of the cc command on Digital UNIX systems. This qualifier allows you to specify additional places to search for include files. A place can be one of the following:

If one of the places is specified as an empty string, the compiler does not search any of its conventionally-named places:

Instead, it searches only places specified explicitly on the command line by the /INCLUDE_DIRECTORY and /LIBRARY qualifiers (or by the location of the primary source file, depending on the /NESTED_INCLUDE_DIRECTORY qualifier). This behavior is similar to that obtained by specifying -I without a directory name to the Digital UNIX cc command.

The basic search order depends on the form of the header-file name (after macro expansion). Additional aspects of the search order are controlled by other command-line qualifiers and the presence or absence of logical name definitions.

Only the portable forms of the #include directive are affected by the pathnames specified on an /INCLUDE_DIRECTORY qualifier:

However, an empty string also affects the text-module form specific to OpenVMS systems (example: #include stdio ).

Except where otherwise specified, searching a "place" means that the string designating the place is used as the default file-spec in a call to an RMS system service (for example, $SEARCH/$PARSE). The file-spec consists of the name in the #include directive without enclosing delimiters. The search terminates successfully as soon as a file can be opened for reading.

Note

Prior to OpenVMS VAX Version 7.1, the operating system did not provide a SYS$LIBRARY:SYS$STARLET_C.TLB nor the headers contained therein. Instead, the compiler installation generated these headers and placed them in SYS$LIBRARY:DECC$RTLDEF.TLB.

Quoted Form

For the quoted form of inclusion, the search order is:

  1. One of the following:
  2. Search the places specified in the /INCLUDE_DIRECTORY qualifier, if any. A place that can be parsed successfuly as an OpenVMS file-spec and that does not contain an explicit file type or version specification is edited to append the default header file type specification (".h" or ".").
    A place containing a "/" character is considered to be a UNIX-style name. If the name in the #include directive also contains a "/" character that is not the first character and is not preceded by a "!" character (it is not an absolute UNIX-style pathname), then the name in the #include directive is appended to the named place, separated by a "/" character, before applying the decc$to_vms pathname translation function. The result of the decc$to_vms translation is then used as the filespec to try to open.
  3. If DECC$USER_INCLUDE is defined as a logical name, search DECC$USER_INCLUDE:.H, or just DECC$USER_INCLUDE:. if /ASSUME=NOHEADER_TYPE_DEFAULT is in effect.
  4. If the file is not found, follow the steps for the angle-bracketed form of inclusion.

    Angle-Bracketed Form

    For the angle-bracketed form of inclusion, the search order is:

    1. Search the place "/". This is a UNIX-style name that can combine only with UNIX names specified explicitly in the #include directive. It causes a specification like <sys/types.h> to be considered first as /sys/types.h, which is translated by decc$to_vms to SYS:TYPES.H.
    2. Search the places specified in the /INCLUDE_DIRECTORY qualifier, exactly as in Step 2 for the quoted form of inclusion.
    3. If DECC$SYSTEM_INCLUDE is defined as a logical name, search DECC$SYSTEM_INCLUDE:.H, or just DECC$SYSTEM_INCLUDE:. if /ASSUME=NOHEADER_TYPE_DEFAULT is in effect.
    4. If DECC$LIBRARY_INCLUDE is defined as a logical name and DECC$SYSTEM_INCLUDE is not defined as a logical name, search DECC$LIBRARY_INCLUDE:.H, or just DECC$LIBRARY_INCLUDE:. if /ASSUME=NOHEADER_TYPE_DEFAULT is in effect.
    5. If neither DECC$LIBRARY_INCLUDE nor DECC$SYSTEM_INCLUDE are defined as logical names, then search the default list of places for plain text-file copies of compiler header files as follows:
      • SYS$COMMON:[DECC$LIB.INCLUDE.DECC$RTLDEF].H
      • SYS$COMMON:[DECC$LIB.INCLUDE.SYS$STARLET_C].H

      Note

      The compiler installation does not create these directories of header files. Instead, it creates [DECC$LIB.REFERENCE] for your convenience. But if you choose to create and populate SYS$COMMON:[DECC$LIB.INCLUDE.DECC$RTLDEF] or SYS$COMMON:[DECC$LIB.INCLUDE.SYS$STARLET_C].H, the compiler will search them.

      If the file is not found, perform the text library search described in the next step.
    6. Extract the simple filename and file type from the #include specification and use the filename as the module name to search a list of text libraries associated with that file type.
      For any file type, the initial text libraries searched consist of those named on the command line with /LIBRARY qualifiers, searched in left-to-right order.
      If the /INCLUDE_DIRECTORY qualifier contained an empty string, no further text libraries are searched. Otherwise, DECC$TEXT_LIBRARY is searched for all file types.
      If DECC$LIBRARY_INCLUDE is defined as a logical name, then no further text libraries are searched. Otherwise, the subsequent libraries searched for each file type are:
      • For a file type of ".h" or ".":
        • SYS$LIBRARY:DECC$RTLDEF.TLB
        • SYS$LIBRARY:SYS$STARLET_C.TLB
      • For a file type other then ".h" or ".":
        • SYS$LIBRARY:SYS$STARLET_C.TLB
    7. If the previous step fails, search the following:
      • SYS$LIBRARY:.H

      Under /ASSUME=NOHEADER_TYPE_DEFAULT, the default file type is modified as usual.

      Text-Module Form

      For the text-module (nonportable) form of inclusion, the name can only be an identifier. It, therefore, has no associated file type.

      The identifier is used as a module name to search the following:

      1. The text libraries named on the command line with /LIBRARY qualifiers, in left-to-right order.
      2. The following list of text libraries in the order shown (unless the /INCLUDE_DIRECTORY qualifier contains an empty string, in which case no further text libraries are searched):
        • DECC$TEXT_LIBRARY
        • SYS$LIBRARY:DECC$RTLDEF.TLB
        • SYS$LIBRARY:SYS$STARLET_C.TLB

        The default for this qualifer is /NOINCLUDE_DIRECTORY.

        /INSTRUCTION_SET=[NO]FLOATING_POINT (ALPHA ONLY)

        The /INSTRUCTION_SET=NOFLOATING_POINT qualifier suppresses the generation of floating-point instructions for integer operations.

        The default is /INSTRUCTION_SET=FLOATING_POINT.

        /L_DOUBLE_SIZE=option (ALPHA ONLY)

        Determines how the compiler interprets the long double type. The qualifier options are 64 and 128.

        Specifying /L_DOUBLE_SIZE=64 treats all long double references as G_FLOAT, D_FLOAT, or T_FLOAT, depending on the value of the /FLOAT qualifier.

        Specifying /L_DOUBLE_SIZE=128 treats all long double references as X_FLOAT.

        The default is /L_DOUBLE_SIZE=128.

        /LIBRARY

        Indicates that the associated input file is a library containing modules of DEC C source text. If the library specification does not include a file extension, the CC command line assumes the .TLB default type. You must join the /LIBRARY qualifier with a file specification in a compilation unit using a plus sign (+); you cannot place the qualifier at other places on the CC command line. No matter where you place the /LIBRARY qualifier in a compilation unit, all files in the unit may make reference to modules within that library. Consider the following example:


        $ CC  ONE + TWO + THREE/LIBRARY[Return]
        

        Files ONE.C and TWO.C can contain references to modules in THREE.TLB. Consider the following example:


        $ CC  ONE + TWO + THREE/LIBRARY, FOUR[Return]
        

        The file FOUR.C cannot contain references to modules in THREE.TLB since FOUR.C is located in a separate compilation unit separated by a comma. The placement of the library file specification does not matter. The following command lines are equivalent:


        $ CC  THREE/LIBRARY + ONE + TWO[Return]
        $ CC  ONE + THREE/LIBRARY + TWO[Return]
        $ CC  ONE + TWO + THREE/LIBRARY[Return]
        

        /[NO]LINE_DIRECTIVES

        Governs whether or not #line directives appear in preprocess output files.

        The default is /LINE_DIRECTIVES.

        /[NO]LIST[=file-spec]

        Produces a source program listing. You must specify this qualifier to get a listing. None of the other qualifiers use /LIST by default.

        By default, /LIST creates a listing file with the same name as the source file and with a file extension of .LIS. If you include a file specification with the /LIST qualifier, the compiler uses that specification to name the listing file.

        In interactive mode, the default is /NOLIST. In batch mode, the default is /LIST. See the descriptions of the qualifiers /[NO]MACHINE_CODE, and /SHOW for related information. (For example, to suppress compiler messages to the terminal or to a batch log file, use the /SHOW=NOTERMINAL qualifier.)

        /[NO]MACHINE_CODE[=option]

        Lists the generated machine code in the listing file. To produce the listing file, you must also specify /LIST.

        On OpenVMS VAX systems, several formats exist to list machine code. Table 1-9 describes the /MACHINE_CODE qualifier options.

        Table 1-9 /MACHINE_CODE Qualifier Options (VAX ONLY)
        Option Usage
        AFTER Causes the lines of machine code produced during compilation to print after all the source code in the listing.
        BEFORE Causes lines of machine code produced during compilation to print before any source code in the listing.
        INTERSPERSED Produces a listing consisting of lines of source code followed by the corresponding lines of machine code. This is the default option.

        On OpenVMS Alpha sytems, the format of the generated machine code listing is similar to what you would get using the AFTER keyword on OpenVMS VAX systems.

        The default is /NOMACHINE_CODE.

        /[NO]MEMBER_ALIGNMENT

        Controls whether the compiler naturally aligns data structure members. Natural alignment means that data structure members are aligned on the next boundary appropriate to the type of the member, rather than on the next byte. For instance, a long variable member is aligned on the next longword boundary; a short variable member is aligned on the next word boundary.

        Any use of the #pragma member_alignment or #pragma nomember_alignment directives within the source code overrides the setting established by this qualifier. Specifying /NOMEMBER_ALIGNMENT causes data structure members to be byte-aligned (with the exception of bit-field members).

        On OpenVMS Alpha systems, the default is /MEMBER_ALIGNMENT.

        On OpenVMS VAX systems, the default is /NOMEMBER_ALIGNMENT.

        See the description of #pragma [no]member_alignment in Section 5.4.10.

        /[NO]MMS_DEPENDENCIES[=(option[,...])]

        Directs the compiler to produce a dependency file. Dependency files list all source files and included files for each object module. The dependency file format is:


        object_file_name :<tab><source file name>) 
        object_file_name :<tab><full path to first include file>) 
        object_file_name :<tab><full path to second include file>) 
        


        Previous Next Contents Index