HP OpenVMS Systems

Command_Parameters                     



 file-spec,...



     One or more Compaq C source files separated by plus signs or

     commas.  If plus signs are used, the input files are

     concatenated into a single object file.  If commas are used,

     each file is compiled separately to create separate object

     files.  If no input file extension is specified, Compaq C

     assumes the .C default file extension.



 library-file-spec



     A text library containing #include modules referenced in one or

     more of the source files.  A library file specification must be

     concatenated with a file specification with a plus sign and

     qualified using the /LIBRARY qualifier.  If the input file

     extension is not specified, Compaq C assumes the .TLB default

     file extension.



Qualifiers                              



 Indicate special actions to be performed by the compiler or special

 input file properties.  Compiler qualifiers can apply to either the

 CC command or to the specification of the file being compiled.

 When a qualifier follows the CC command, it applies to all the

 files listed.  When a qualifier follows the file specification, it

 applies only to the file immediately preceding it.



 The following list shows all the qualifiers available with the CC

 command:





  o  /ACCEPT(option[,...])



  o  /[NO]ANALYSIS_DATA[=file-spec]



  o  /ASSUME=(option[,...])



  o  /COMMENTS={AS_IS | SPACE}



  o  /[NO]CROSS_REFERENCE



  o  /[NO]DEBUG[=(option[,...])]



  o  /DECC



  o  /[NO]DEFINE=(identifier[=definition][,...])



  o  /[NO]DIAGNOSTICS[=file-spec]



  o  /ERROR_LIMIT[=number]



  o  /EXTERN_MODEL=option



  o  /FLOAT=option



  o  /[NO]G_FLOAT



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



  o  /LIBRARY



  o  /[NO]LINE_DIRECTIVES



  o  /[NO]LIST[=file-spec]



  o  /[NO]MACHINE_CODE[=option]



  o  /[NO]MEMBER_ALIGNMENT



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



  o  /NAMES=(option1,option2)



  o  /NESTED_INCLUDE_DIRECTORY[=option]



  o  /[NO]OBJECT[=file-spec]



  o  /[NO]OPTIMIZE[=option]



  o  /PRECISION={SINGLE | DOUBLE}



  o  /[NO]PREFIX_LIBRARY_ENTRIES



  o  /[NO]PREPROCESS_ONLY[=filename]



  o  /[NO]PROTOTYPE[=(option[,...])]



  o  /REPOSITORY=option



  o  /[NO]SHARE_GLOBALS



  o  /SHOW[=(option[,...])]



  o  /[NO]STANDARD=(option)



  o  /[NO]UNDEFINE=(identifier[,...])



  o  /[NO]UNSIGNED_CHAR



  o  /VAXC



  o  /[NO]VERSION



  o  /[NO]WARNINGS[=(option[,...])]





/ACCEPT                                

    /ACCEPT=(option[,option])



 Allows the compiler to accept C language syntax that it might not

 normally accept.



 Compaq C accepts slightly different syntax depending upon the

 compilation mode specified with the /STANDARD qualifier.  The

 /ACCEPT qualifier can fine tune the language syntax accepted by

 each /STANDARD mode.



 Specify one of the following qualifier options:



  [NO]C99_KEYWORDS      Controls whether or not the C99 Standard

                        keywords inline and restrict (which are are

                        in the C89 namespace for user identifiers)

                        are accepted without double leading

                        underscores.  The spelling with two leading

                        underscores (__inline, __restrict) is in the

                        namespace reserved to the compiler

                        implementation and is always recognized as a

                        keyword regardless of this option.



                        In /STANDARD=RELAXED_ANSI89 mode, the

                        default is C99_KEYWORDS.  In all other

                        compiler modes, the default is

                        NOC99_KEYWORDS.



  [NO]GCCINLINE         The gcc compiler implements an inline

                        function qualifier for functions with

                        external linkage that gives similar

                        capabilites as the C9x extern inline feature

                        for functions, but the usage details are

                        somewhat different:  the combination of

                        extern and inline keywords makes an inline

                        definition, instead of the exlusive use of

                        the inline keyword without the extern

                        keyword.  This option controls which

                        variation of the feature is implemented.



                        In all compiler modes, the default is

                        NOGCCINLINE.



  [NO]VAXC_KEYWORDS     Controls whether or not the compiler

                        recognizes the VAX C keywords (such as

                        "readonly") regardless of the /STANDARD mode

                        used.



  [NO]RESTRICT_KEYWORD  Controls whether or not the compiler

                        recognizes the C9x standard restrict keyword

                        regardless of the /STANDARD mode used.



                        This only affects recognition of the

                        spelling of the keyword as proposed for

                        inclusion in the C9x standard.  The spelling

                        with two leading underscores, __restrict, is

                        in the namespace reserved to the compiler

                        implementation, and it is always recognized

                        as a keyword regardless of this option.



                        Note that [NO]RESTRICT_KEYWORD is a subset

                        of [NO]C99_KEYWORDS.  They have the same

                        compiler-mode defaults.



The default values are based upon the settings of the /STANDARD

qualifier:



For /STANDARD=RELAXED_ANSI89, the default is:

 /ACCEPT=(VAXC_KEYWORDS,C99_KEYWORDS,NOGCCINLINE)



For /STANDARD=VAXC, the default is:

 /ACCEPT=(VAXC_KEYWORDS,NOC99_KEYWORDS,NOGCCINLINE)



In all other modes, the default is:

 /ACCEPT=(NOVAXC_KEYWORDS,NOC99_KEYWORDS,NOGCCINLINE)





/ANALYSIS_DATA                         

    /ANALYSIS_DATA[=file-spec]

    /NOANALYSIS_DATA (D)



 Controls whether the compiler generates a file of source code

 analysis information.  The default file name is the file name of

 the primary source file; the default file type is .ANA.





/ASSUME                          

    /ASSUME=(option[,...])



 Controls compiler assumptions.  You may select the following

 options:



    [NO]EXACT_CDD_OFFSETS



       Controls the alignment of Control Data Dictionary records.



       If /ASSUME=EXACT_CDD_OFFSETS is specified, the records input

       from the CDD are given the exact alignment (relative to the

       start of the record) specified by the CDD definition.  This

       alignment is independent of the current compiler

       member-alignment setting.



       If /ASSUME=NOEXACT_CDD_OFFSETS is specified, the compiler may

       modify the offsets specified in a CDD record according to the

       current member-alignment setting.



       The default is /ASSUME=NOEXACT_CDD_OFFSETS.



    [NO]HEADER_TYPE_DEFAULT



       Specifies whether the default file-type mechanism (.h) for

       header files is enabled (HEADER_TYPE_DEFAULT) or disabled

       (NOHEADER_TYPE_DEFAULT).



       The default is /ASSUME=HEADER_TYPE_DEFAULT.



    [NO]WRITABLE_STRING_LITERALS



       Stores string constants in a writable psect.  Otherwise, such

       constants will be placed in non-writable psect.



       For /STANDARD=VAXC or /STANDARD=COMMON, the default is

       /ASSUME=WRITABLE_STRING_LITERALS.  For all other compiler

       modes, the default is /ASSUME=NOWRITABLE_STRING_LITERALS.





/COMMENTS                                   

    /COMMENTS={AS_IS | SPACE}

    /COMMENTS=SPACE (D) (ANSI89, RELAXED_ANSI89, and MIA compiler

modes)

    /NOCOMMENTS (D) (all other compiler modes)



 Governs whether or not comments appear in preprocess output files

 and, if they are to appear, whether they appear themselves or are

 replaced by a single space.  Specify one of the following qualifier

 options:



  AS_IS     Specifies that the comment appears in the output file.



  SPACE     Specifies that a single space replaces the comment in

            the output file.



NOCOMMENTS specifies that nothing replaces the comment in the output

file.  This can result in inadvertent token pasting.



The Compaq C preprocessor might replace a comment at the end of a

line or on a line by itself with nothing, even if /COMMENTS=SPACE is

specified.  Doing so does not change the meaning of the program.



The default is /COMMENTS=SPACE for the ANSI89, RELAXED_ANSI89, and

MIA compiler modes.  The default is /NOCOMMENTS for all other

compiler modes.



Specifying just /COMMENTS defaults to /COMMENTS=AS_IS.





/CROSS_REFERENCE                       

    /NOCROSS_REFERENCE (D)



 Specifies whether the compiler generates cross-references.  If you

 specify /CROSS_REFERENCE, the compiler lists, for each variable

 referenced in the procedure, the line numbers of the lines on which

 the variable is referenced.  You must use the /CROSS_REFERENCE

 qualifier with either the /SHOW=SYMBOLS or the /SHOW=BRIEF

 qualifiers.  To obtain any type of listing, you must specify /LIST.



/DEBUG                                            

    /DEBUG[=(option[,...])]

    /DEBUG=(TRACEBACK,NOINLINE,NOSYMBOLS) (D)

    /NODEBUG



 Includes information in the object module for use by the OpenVMS

 Debugger.  You can select the following options:



 ALL            Includes all possible debugging information.



                On Alpha systems, /DEBUG=ALL is equivalent to

                /DEBUG=(TRACEBACK,SYMBOLS).



                On VAX systems, /DEBUG=ALL is equivalent to

                /DEBUG=(TRACEBACK,SYMBOLS,INLINE).



 INLINE         Causes a STEP command to STEP/INTO an inlined

                function call.



 NOINLINE       Causes a STEP command to STEP/OVER an inlined

                function call.



 NONE           Excludes any debugging information.



 NOSYMBOLS      Suppresses generation of symbol table records.



 SYMBOLS        Generates symbol table records.



 NOTRACEBACK    Suppresses generation of traceback records.



 TRACEBACK      Generates traceback records.



 Specifying /DEBUG with no options is equivalent to specifying

 /DEBUG=ALL.



 If the /DEBUG qualifier is not specified, the default is

 /DEBUG=(TRACEBACK,NOINLINE,NOSYMBOLS).



/DECC                                      



 The CC command is used to invoke either the VAX C or Compaq C

 compiler.  If your system has a VAX C compiler already installed on

 it, the Compaq C installation procedure provides the option of

 specifying which compiler will be invoked by default when just the

 CC command verb is used.  To invoke the compiler that is not the

 default, use the CC command with the appropriate qualifier:

 CC/DECC for the Compaq C compiler, or CC/VAXC for the VAX C

 compiler.



 If your system does not already have a VAX C compiler installed on

 it, the CC command will invoke the Compaq C compiler.



/DEFINE                                     

    /DEFINE=(identifier[=definition][,...])

    /NODEFINE (D)



 Performs the same function as the #define preprocessor directive.

 That is, /DEFINE defines a token string or macro to be substituted

 for every occurrence of a given identifier in the program.



 DCL converts all input to uppercase unless it is enclosed in

 quotation marks.



 The simplest form of a /DEFINE definition is:



 /DEFINE=true



 This results in a definition like the one that would result from

 the following definition:



 #define TRUE 1



 Macro definitions must be enclosed in quotation marks as shown in

 the following definition:



 /DEFINE="funct(a)=a+sin(a)"



 This definition produces the same results as the following

 definition:



 #define funct(a) a+sin(a)



 When more than one /DEFINE is present on the CC command line or in

 a single compilation unit, only the last /DEFINE is used.



 When both /DEFINE and /UNDEFINE are present in a command line,

 /DEFINE is evaluated before /UNDEFINE.



 The default is /NODEFINE.





/DIAGNOSTICS                           

    /DIAGNOSTICS[=file-spec]

    /NODIAGNOSTICS (D)



 Creates a file containing compiler diagnostic messages.  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.



/ERROR_LIMIT                              

    /ERROR_LIMIT[=number]

    /NOERROR_LIMIT



 Limits the number of Error-level diagnostic messages that are

 acceptable during program compilation.  Compilation terminates when

 the limit (number) 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                                              

    /EXTERN_MODEL=option

    /EXTERN_MODEL=RELAXED_REFDEF (D)



 In conjunction with the /SHARE_GLOBALS qualifier, controls the

 initial extern model of the compiler.  Conceptually, the compiler

 behaves as if the first line of the program being compiled was a

 #pragma extern_model directive with the model and psect name, if

 any, specified by the /EXTERN_MODEL qualifier and with the shr or

 noshr keyword specified by the /SHARE_GLOBALS qualifier.



 For example, assume the command line contains the following

 qualifier:



      /EXTERN_MODEL=STRICT_REFDEF="MYDATA"/NOSHARE



 The compiler will act as if the program began with the following

 line:



      #pragma extern_model strict_refdef "MYDATA" noshr



 See also #pragma extern_model.



 The /EXTERN_MODEL qualifier takes the following options, which have

 the same meaning as for the #pragma extern_model directive:



 COMMON_BLOCK



 RELAXED_REFDEF



 STRICT_REFDEF



 STRICT_REFDEF="NAME"



 GLOBALVALUE



 The default model on Compaq C is relaxed/refdef with the noshare

 attribute.  This is different from the model used by VAX C, which

 is common block, share.



/FLOAT                                     

    /FLOAT=option



 Controls the format of floating-point variables.  On OpenVMS VAX

 systems, if you omit both /FLOAT and /G_FLOAT from the command

 line, double variables are represented in D_FLOAT format (unless

 /MIA is specified, in which case the default format is G_FLOAT).



 If you are linking against object-module libraries, a program

 compiled with G_FLOAT format must be linked with the object library

 VAXCRTLG.OLB.



 Options:



  D_FLOAT         Double variables are represented in D_FLOAT

                  format.



  G_FLOAT         Double variables are represented in G_FLOAT

                  format.



/G_FLOAT                                 

    /G_FLOAT

    /NOG_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 /NOG_FLOAT, double variables are represented in

 D_floating format.  On OpenVMS VAX systems, if you omit both /FLOAT

 or /G_FLOAT from the command line, double variables are represented

 in D_FLOAT format (unless /MIA is specified, in which case the

 default format is G_FLOAT).



 If you are linking against object-module libraries, a program

 compiled with G_FLOAT format must be linked with the object library

 VAXCRTLG.OLB.



/INCLUDE_DIRECTORY                 

    /INCLUDE_DIRECTORY=(place[,...])

    /NOINCLUDE_DIRECTORY (D)



 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:



  o  OpenVMS file-spec to be used as a default file-spec to RMS file

     services (example:  DISK$:[directory])



  o  UNIX style pathname in quotation marks (example:  "/sys")



  o  Empty string ("")





 If one of the places is specified as an empty string, the compiler

 is not to search any of its conventionally-named places

 (DECC$USER_INCLUDE, DECC$SYSTEM_INCLUDE, DECC$LIBRARY_INCLUDE,

 SYS$COMMON:[DECC$LIB.INCLUDE.*], DECC$TEXT_LIBRARY,

 DECC$RTLDEF.TLB, SYS$STARLET_C.TLB).  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).



 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.



 All forms of header-file inclusion are affected:



  o  In quotes (example:  "stdio.h")



  o  In angle brackets (example:  <stdio.h>)



  o  An identifier to be treated as a text-module name (example:

     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),

 with a file-spec consisting of the name in the #include directive

 without enclosing delimiters.  The search terminates successfully

 as soon as a file can be opened for reading.



 For the quoted form, the search order is:



 1.  One of the following:



      o  If /NESTED_INCLUDE_DIRECTORY=INCLUDE_FILE (the default) is

         in effect, search the directory containing the file in

         which the #include directive itself occurred.  The meaning

         of "directory containing" is:  the RMS "resultant string"

         obtained when the file in which the #include occurred was

         opened, except that the filename and subsequent components

         are replaced by the default file type for headers (".H", or

         just "." if /ASSUME=NOHEADER_TYPE_DEFAULT is in effect).

         The "resultant string" will not have translated any

         concealed device logical.



      o  If /NESTED_INCLUDE_DIRECTORY=PRIMARY_FILE is in effect,

         search the default file type for headers using the context

         of the primary source file.  This means that just the file

         type (".H" or ".") is used for the default file-spec but,

         in addition, the chain of "related file-specs" used to

         maintain the sticky defaults for processing the next

         top-level source file is applied when searching for the

         include file.



      o  If /NESTED_INCLUDE_DIRECTORY=NONE is in effect, this entire

         step (Step 1) is bypassed.





 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 (that is, 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.



 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.





 For the angle-bracketed form, 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 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



     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.



     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 ".H" or ".":



            SYS$LIBRARY:DECC$RTLDEF.TLB

            SYS$LIBRARY:SYS$STARLET_C.TLB



          For any file type other then ".H" or ".":



            SYS$LIBRARY:SYS$STARLET_C.TLB



 7.  If the previous step fails, search:



     SYS$LIBRARY:.H



     Under /ASSUME=NOHEADER_TYPE_DEFAULT, the default file type is

     modified as usual.





For the text-module (non-portable) form of #include:



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





/LIBRARY                               



 Indicates that the associated input file is a library containing

 source text modules specified in #include directives.  The compiler

 searches the specified library for all #include module names that

 are not enclosed in angle brackets or quotation marks.  The name of

 the library must be concatenated with the file specification using

 a plus sign.  For example:



 CC DATAB/LIBRARY+APPLIC



/LINE_DIRECTIVES                  

    /LINE_DIRECTIVES (D)

    /NOLINE_DIRECTIVES



 Controls whether or not #line directives appear in preprocess

 output files.



/LIST                                 

    /LIST[=file-spec] (Batch default)

    /NOLIST (Interactive default)



 Controls whether a listing file is produced.  The default output

 file extension is .LIS.



 (Note:  To suppress compiler messages to the terminal or to a batch

 log file, use the /SHOW=NOTERMINAL qualifier.)



/MACHINE_CODE                         

    /MACHINE_CODE[=option]

    /NOMACHINE_CODE (D)



 Controls whether the listing produced by the compiler includes the

 machine language code generated during the compilation.  If you use

 this qualifier you also need to use the /LIST qualifier.  You can

 select the following options:



 AFTER          The machine code produced during compilation prints

                after the source code listing.



 BEFORE         The machine code prints before the source code

                listing.



 INTERSPERSED   The lines of machine code print alternately with the

                lines of source code.



 The default option is INTERSPERSED.



/MEMBER_ALIGNMENT                        

    /MEMBER_ALIGNMENT (D)

    /NOMEMBER_ALIGNMENT



 Directs the compiler to naturally align data structure members.

 This 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).



 For OpenVMS Alpha systems, the default is /MEMBER_ALIGNMENT.



 For OpenVMS VAX systems, the default is /NOMEMBER_ALIGNMENT.



/MMS_DEPENDENCIES                                

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

    /NOMMS_DEPENDENCIES (D)



 Directs the compiler to produce a dependency file.  The format of

 the dependency file is identical to that on OSF:



    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>



 You can specify none, one, or both of the following qualifier

 options:



  FILE[=filespec]        Specifies where to save the dependency

                         file.  The default file extension for a

                         dependency file is .mms.  Other than using

                         a different default extension, this

                         qualifier uses the same procedure that

                         /OBJECT and /LIST use for determining the

                         name of the output file.



  SYSTEM_INCLUDE_FILES   Specifies whether or not to include

                         dependency information about system include

                         files (that is, those included with

                         #include <filename>).  The default is to

                         include dependency information about system

                         include files.



                         Note that the /OBJECT qualifier has no

                         impact on the dependency file.



/NAMES                                    

    /NAMES=(option1,option2)

    /NAMES=(UPPERCASE,TRUNCATED) (D)



 Option1 converts all definitions and references of external symbols

 and psects to the specified case:



  o  /NAMES=UPPERCASE (default) converts to uppercase.



  o  /NAMES=LOWERCASE converts to lowercase.



  o  /NAMES=AS_IS leaves the case unchanged.



 Option2 controls whether or not long external names greater than 31

 characters get truncated or shortened:



  o  /NAMES=TRUNCATED (default) truncates long external names



  o  /NAMES=SHORTENED shortens long external names.



     A shortened name consists of the first 24 characters of the

     name followed by a 7-character Cyclic Redundancy Check (CRC)

     computed by looking at the full name.



 By default, the compiler issues a warning and truncates the name to

 31 characters.



 The /NAMES qualifier does not affect the names of the $CODE and

 $DATA psects.



/NESTED_INCLUDE_DIRECTORY                      

    /NESTED_INCLUDE_DIRECTORY[=option]

    /NESTED_INCLUDE_DIRECTORY=INCLUDE_FILE (D)



 Controls the first step in the search algorithm the compiler uses

 when looking for files included using the quoted form of the

 #include preprocessing directive:  #include "file-spec"



 /NESTED_INCLUDE_DIRECTORY has the following options:



 PRIMARY_FILE   Directs the compiler to search the default file type

                for headers using the context of the primary source

                file (the .C file).  This means that just the file

                type (".H" or ".") is used for the default file-spec

                but, in addition, the chain of "related file-specs"

                used to maintain the sticky defaults for processing

                the next top-level source file is applied when

                searching for the include file.



 INCLUDE_FILE   Directs the compiler to search the directory

                containing the file in which the #include directive

                itself occurred.  The meaning of "directory

                containing" is:  the RMS "resultant string" obtained

                when the file in which the #include occurred was

                opened, except that the filename and subsequent

                components are replaced by the default file type for

                headers (".H", or just "." if

                /ASSUME=NOHEADER_TYPE_DEFAULT is in effect).  The

                "resultant string" will not have translated any

                concealed device logical.



 NONE           Directs the compiler to skip the first step of

                processing #include "file.h" directives.  The

                compiler starts its search for the include file in

                the /INCLUDE_DIRECTORY directories.



 See also /INCLUDE_DIRECTORY.



/OBJECT                               

    /OBJECT[=file-spec] (D)

    /NOOBJECT



 Controls whether the compiler produces an output object module.

 The default output file extension is .OBJ.



 Note that the /OBJECT qualifier has no impact on the output file of

 the /MMS_DEPENDENCIES qualifier.



/OPTIMIZE                        

    /OPTIMIZE[=option] (D)

    /NOOPTIMIZE



 Controls whether or not the compiler performs code optimization.

 /OPTIMIZE has the following options:



 [NO]DISJOINT   Directs the compiler to optimize the generated

                machine code.



 [NO]INLINE     Specifies whether the compiler is allowed to perform

                the function inline optimization.









/PRECISION                       

    /PRECISION={SINGLE | DOUBLE}



 Controls whether floating-point operations on float variables are

 performed in single or double precision.



 The default is /PRECISION=DOUBLE for /STANDARD=VAXC and

 /STANDARD=COMMON modes.



 The default is /PRECISION=SINGLE for /STANDARD=ANSI89 and

 /STANDARD=RELAXED_ANSI89 modes.



/PREFIX_LIBRARY_ENTRIES                  



 Controls the Compaq C RTL name prefixing.



 The Compaq C Run-Time Library (RTL) shareable image (DECC$SHR.EXE)

 resides in IMAGELIB.OLB with a DECC$ prefix for its entry points.

 Every external name in IMAGELIB.OLB has a DECC$ prefix, and,

 therefore, has an OpenVMS conformant name space (a requirement for

 inclusion in IMAGELIB).  The /[NO]PREFIX_LIBRARY_ENTRIES qualifier

 lets you control the Compaq C RTL name prefixing.



 The qualifier options are:



 EXCEPT=(name,...)    The names specified are not prefixed.



 ALL_ENTRIES           All Compaq C RTL names are prefixed.



 ANSI_C89_ENTRIES     Only ANSI library names are prefixed.



 RTL="name"            Generates references to the C RTL indicated

                       by the "name" keyword.  If no keyword is

                       specified, then references to the Compaq C

                       RTL are generated by default.  To use an

                       alternate RTL, see its documentation for the

                       name to use.



 If you want no names prefixed, specify /NOPREFIX_LIBRARY_ENTRIES.



 The defaults on both OpenVMS Alpha and VAX systems are:



  o  For /STANDARD=ANSI89, the default is /PREFIX=ANSI_C89_ENTRIES.



  o  Alpha only:  For /STANDARD=C99 or /STANDARD=RELAXED_ANSI89, the

     default is /PREFIX=C99_ENTRIES.



  o  For all other compiler modes, the default is /PREFIX=ALL.





/PREPROCESS_ONLY                      

    /PREPROCESS_ONLY[=filename]

    /NOPREPROCESS_ONLY (D)



 Causes the compiler to perform only the actions of the preprocessor

 phase and write the resulting processed text out to a file.



/PROTOTYPE                           

    /PROTOTYPE[=(option[,...])]

    /NOPROTOTYPE (D)



 Creates an output file containing function prototypes for all

 global functions defined in the module being compiled.



 The qualifier options are:



 [NO]IDENTIFIERS       Indicates that identifier names are to be

                       included in the prototype declarations that

                       appear in the output file.  The default is

                       NOIDENTIFIERS.



 [NO]STATIC_FUNCTIONS  Indicates that prototypes for static function

                       definitions are to be included in the output

                       file.  The default is NOSTATIC_FUNCTIONS.



 FILE=filename         Specifies the output file name.  When not

                       specified, the output file name has the same

                       defaults as the listing file, except that the

                       file extension is .CH instead of .LIS.



 The default is /NOPROTOTYPES.



/REPOSITORY                                    



 Specifies a repository for the compiler to store shortened external

 name information.  When /NAMES=SHORTENED is specified, the compiler

 stores to the repository any external names that were shortened.

 The demangler utility can then be used to map the shortened names

 back to the names used in the original C program.



 By default, the qualifier is not active unless /NAMES=SHORTENED has

 been specified, in which case the default is

 /REPOSITORY=[.CXX_REPOSITORY].



 Note that the default name of the repository is the same as that

 used by the Compaq C++ compiler for decoding mangled names.  This

 is intentional.  A C++ mangled name cannot match a shortened name,

 so a single repository can be used by both the Compaq C and Compaq

 C++ compilers.



/SHARE_GLOBALS                        

    /NOSHARE_GLOBALS (D)



 Performs two functions:



  o  Controls whether the compiler treats declarations of objects

     with the globaldef keyword as shared or not shared.



  o  Controls whether the initial extern_model is shared or not

     shared (for those extern_models where it is allowed).  The

     initial extern_model of the compiler is a fictitious pragma

     constructed from the settings of the /EXTERN_MODEL and

     /SHARE_GLOBALS.



 The default value is /NOSHARE_GLOBALS.  This default value is

 different from VAX C (which treated externs as SHR by default), and

 has the following impact:



 1.  When linking old object files or object libraries with newly

     produced object files, you might get "conflicting attributes

     for psect" messages, which can be safely ignored as long as you

     are not building shareable libraries.



 2.  The /NOSHARE_GLOBALS default makes building shareable libraries

     easier.



 3.  When linking your extern symbols against FORTRAN common blocks,

     specify /SHARE_GLOBALS to suppress "conflicting attributes for

     psect" messages, which can otherwise be ignored.





/SHOW                                    

    /SHOW=(option[,...])

    /SHOW=SOURCE (D)



 Used with the /LIST qualifier to set or cancel specific listing

 options.  You can select the following options:



 ALL               Print all listing information.



 [NO]BRIEF         Print a brief symbol table, listing only those

                   identifiers that are referenced in the program.



 [NO]CROSS_REFERENCE

                   Specifies whether the compiler generates

                   cross-references.  If you specify

                   /SHOW=CROSS_REFERENCE, the compiler lists, for

                   each variable referenced in the procedure, the

                   line numbers of the lines on which the variable

                   is referenced.



                   You may use /SHOW=CROSS_REFERENCE with

                   /SHOW=SYMBOLS.  Otherwise, specifying

                   /SHOW=CROSS_REFERENCE also gives you /SHOW=BRIEF.

                   To obtain any type of listing, you must specify

                   /LIST.  /SHOW=CROSS_REFERENCE is the same as

                   specifying /[NO]CROSS_REFERENCE.  (D =

                   NOCROSS_REFERENCE)



 [NO]DICTIONARY    Print/do not print Common Data Dictionary

                   definitions.  (D = NODICTIONARY)



 [NO]EXPANSION     Print/do not print macro expansions.

                   (D = NOEXPANSION)



 [NO]HEADER        Print/do not print header lines at the top of

                   each page.  (D = HEADER)



 [NO]INCLUDE       Print/do not print contents of #include files.

                   (D = NOINCLUDE)



 [NO]INTERMEDIATE  Print/do not print intermediate macro.

                   expansions (D = NOINTERMEDIATE)



 [NO]MESSAGES      Print/do not print a list of all messages that

                   are in effect at compilation (based on the

                   settings of /STANDARD, /WARNINGS, and #pragma

                   message).  (D = NOMESSAGES)



 NONE              Print no listing information.



 [NO]SOURCE        Print/do not print source file statements.

                   (D = SOURCE)



 [NO]STATISTICS    Print/do not print compiler performance

                   statistics.  (D = NOSTATISTICS)



 [NO]SYMBOLS       Print/do not print symbol table information in

                   the listing file.  (D = NOSYMBOLS)



 [NO]TERMINAL      Display/do not display compiler messages at the

                   terminal.  If NOTERMINAL is specified, only the

                   summary message is displayed.  (D = TERMINAL)



 [NO]TRANSLATION   Display/do not display the translation of a UNIX*

                   system file specification to an OpenVMS file

                   specification.  (D = NOTRANSLATION)







----------

* UNIX is a trademark of The Open Group.



/STANDARD                            

    /STANDARD=(option)

    /STANDARD=RELAXED_ANSI89 (equivalent to /NOSTANDARD) (D)

    /NOSTANDARD (D)



 Defines the compilation mode.  You can select the following

 options:



 ANSI89            Places the compiler in strict ANSI C Standard 89

                   (C89) mode.  This mode compiles the C language as

                   defined by the American National Standard for C,

                   along with any extensions not prohibited by that

                   standard.



 C99               On OpenVMS Alpha systems, places the compiler in

                   strict ISO/IEC C Standard 99 (C99) mode.  This

                   mode accepts just the C99 language without

                   extensions, and diagnoses violations of the C99

                   standard.



                   On OpenVMS VAX systems, produces a warning and

                   places the compiler in /STANDARD=REALXED ANSI89

                   mode.



 RELAXED_ANSI89    Places the compiler in relaxed ANSI C Standard

                   mode.  The compiler accepts ANSI/ISO C Standard

                   C89 and C99 features, as well as nearly all

                   language extensions (such as additional Compaq C

                   keywords and predefined macros that do not begin

                   with an underscore).  It excludes only K&R

                   (COMMON mode), VAX C, and Microsoft features that

                   conflict with standard C.



                   This is the default mode of the compiler, and is

                   equivalent to /NOSTANDARD.



 MS                Places the compiler in Microsoft compatibility

                   mode, which interprets source programs according

                   to certain language rules followed by the C

                   compiler provided with the Microsoft Visual C++

                   compiler product.



 ISOC94            Places the compiler in ISO C 94 mode, which

                   enables digraph processing and defines the

                   predefined macro __STDC_VERSION__=199409.



                   This option can be specified alone or with any

                   other /STANDARD option except VAXC.  If it is

                   specified alone, the default major mode is

                   RELAXED_ANSI89.



 COMMON            Places the compiler in K & R language mode; that

                   is, compatibility with older UNIX compilers such

                   as pcc and gcc.  This mode is close to a subset

                   of /STANDARD=VAXC mode.



 VAXC              Places the compiler in VAX C mode.  There are

                   differences in the C language as implemented in

                   previous versions of VAX C and the C language as

                   defined by ANSI (the differences are primarily

                   concerned with how the preprocessor works).  This

                   mode provides compatibility for programs that

                   depend on old VAX C behavior.



 PORTABLE          Places the compiler in RELAXED_ANSI89 mode, and

                   enables the issuance of diagnostics that warn of

                   any nonportable usages encountered.



                   Note that /STANDARD=PORTABLE is supported for

                   VAX C compatibility only.  It is equivalent to

                   the recommended combination of qualifiers

                   /STANDARD=RELAXED_ANSI89

                   /WARNINGS=ENABLE=PORTABLE.



 MIA               Places the compiler in strict ANSI C mode with

                   the following behavior differences to conform to

                   the Multivendor Integration Architecture (MIA)

                   standard:



                   o  On OpenVMS VAX systems, G_FLOAT becomes the

                      default floating-point format for double

                      variables.  (On OpenVMS Alpha systems, G_FLOAT

                      is already the default.)



                   o  In structures, zero-length bit fields cause

                      the next bit field to start on an integer

                      boundary, rather than on a character boundary.





 The default is /NOSTANDARD, which is equivalent to

 /STANDARD=RELAXED_ANSI89.



 With one exception, the /STANDARD qualifier options are mutually

 exclusive.  Do not combine them.  The exception is that you can

 specify /STANDARD=ISOC94 with any other option except VAXC.



 Compaq C modules compiled in different modes can be linked and

 executed together.





/UNDEFINE                             

    /UNDEFINE=(identifier[,...])

    /NOUNDEFINE (D)



 Performs the same function as the #undef preprocessor directive:

 it cancels a macro definition.



 The /UNDEFINE qualifier is useful for undefining the predefined

 Compaq C preprocessor constants.  For example, if you use a

 preprocessor constant (such as vaxc, VAXC, VAX11C, or vms) to

 conditionally compile segments of code specific to Compaq C for

 OpenVMS Systems, you can undefine constants to see how the portable

 sections of your program execute.  For example:



 /UNDEFINE="vaxc"



 When both /DEFINE and /UNDEFINE are present on the CC command line,

 /DEFINE is evaluated before /UNDEFINE.



 The default is /NOUNDEFINE.



/UNSIGNED_CHAR                         

    /NOUNSIGNED_CHAR (D)



 Changes the default for all char types from signed to unsigned.

 This qualifier causes all plain char declarations to have the same

 representation and set of values as signed char declarations.  The

 default is /NOUNSIGNED_CHAR.



/VAXC                                      



 The CC command is used to invoke either the VAX C or Compaq C

 compiler.  If your system has a VAX C compiler already installed on

 it, the Compaq C installation procedure provides the option of

 specifying which compiler will be invoked by default when just the

 CC command verb is used.  To invoke the compiler that is not the

 default, use the CC command with the appropriate qualifier:

 CC/DECC for the Compaq C compiler, or CC/VAXC for the VAX C

 compiler.



 If your system does not already have a VAX C compiler installed on

 it, the CC command will invoke the Compaq C compiler.



/VERSION                                    

    /VERSION

    /NOVERSION (D)



 Directs the compiler to print out the compiler version and

 platform.  The compiler version is the same as in the listing file.



 This qualifier helps you to report what compiler you are using.



 When this qualifier is specified, the compiler just prints its

 version and exits.  No other qualifiers are processed, no source

 file is read, and no object module is produced.



 The syntax for using this qualifier is:



    CC/DECC/VERSION



 The default is /NOVERSION.



/WARNINGS                                     

    /WARNINGS[=(option[,...])]

    /WARNINGS (D)

    /NOWARNINGS



 Controls the issuance of compiler diagnostic messages, or groups of

 messages.  The default qualifier, /WARNINGS, enables all warning

 and informational messages for the compiler mode you are using.

 The /NOWARNINGS qualifier suppresses the informational and warning

 messages.  Also see the #pragma message preprocessor directive.



 The options are:



 DISABLE=msg-list          Suppresses the issuance of the indicated

                           messages.



                           Only messages of severity Warning (W) or

                           Information (I) can be disabled.  If the

                           message has severity of Error (E) or

                           Fatal (F), it is issued regardless of any

                           attempt to disable it.



 ENABLE=msg-list           Enables the issuance of the indicated

                           messages.



 NOINFORMATIONALS          Suppresses informational messages.



 EMIT_ONCE=msg-list        Emits the specified messages only once

                           per compilation.  Errors and Fatals are

                           always emitted.  You cannot set them to

                           EMIT_ONCE.



 EMIT_ALWAYS=msg-list      Emits the specified messages at every

                           occurrence of the condition.



 ERRORS=msg-list           Sets the severity of each message in the

                           message-list to Error.



                           Note that supplied Error messages and

                           Fatal messages cannot be made less

                           severe.  (Exception:  A message can be

                           upgraded from Error to Fatal, then later

                           downgraded to Error again, but it can

                           never be downgraded from Error.)



                           Warnings and Informationals can be made

                           any severity.



 FATALS=msg-list           Sets the severity of each message on the

                           message-list to Fatal.



 INFORMATIONALS=msg-list   Sets the severity of each message in the

                           message-list to Informational.  Note that

                           Fatal and Error messages cannot be made

                           less severe.



 WARNINGS=msg-list         Sets the severity of each message in the

                           message-list to Warning.  Note that Fatal

                           and Error messages cannot be made less

                           severe.



 VERBOSE                   Displays the full message information for

                           every compiler message encountered.  This

                           information includes the message

                           description and user action, as well as

                           the identifier, severity, and message

                           text.



                           When /WARNINGS=VERBOSE is used with

                           /LIST/SHOW=MESSAGES, a list of all

                           messages in effect at compilation are

                           added to the listing file, showing the

                           full information for each message.



 The msg-list can be any one of the following:



  o  A single message identifier (within parentheses, or not).  The

     message identifier is the name following the severity at the

     start of a line when a message is issued.  For example, in the

     following message, the message identifier is GLOBALEXT:



               %CC-W-GLOBALEXT, a storage class of globaldef,

               globalref, or globalvalue is a language extension.



  o  A single message-group name (within parentheses, or not).

     Message-group names are:



          ALL             All the messages in the compiler



          ALIGNMENT       Messages about unusual or inefficient data

                          alignment.



          C_TO_CXX        Messages reporting the use of C features

                          that would be invalid or have a different

                          meaning if compiled by a C++ compiler.



          CDD             Messages about CDD (Common Data

                          Dictionary) support.



          CHECK           Messages reporting code or practices that,

                          although correct and perhaps portable, are

                          sometimes considered ill-advised because

                          they can be confusing or fragile to

                          maintain.  For example, assignment as the

                          test expression in an "if" statement.



                          NOTE:  The check group gets defined by

                          enabling LEVEL5 messages.



          DEFUNCT         Messages reporting the use of obsolete

                          features:  ones that were commonly

                          accepted by early C compilers but were

                          subsequently removed from the language.



          NEWC99          Messages reporting the use of the new C99

                          Standard features.



          NOANSI          This is a deprecated message group.  It is

                          an obsolete synonym for NOC89.  Also see

                          message groups NEWC99, NOC89, NOC99.



          NOC89           Messages reporting the use of non-C89

                          Standard features.



          NOC99           Messages reporting the use of non-C99

                          Standard features.



          OBSOLESCENT     Messages reporting the use of features

                          that are valid in ANSI Standard C, but

                          which were identified in the standard as

                          being obsolescent and likely to be removed

                          from the language in a future version of

                          the standard.



          OVERFLOW        Messages that report assignments and/or

                          casts that can cause overflow or other

                          loss of data significance.



          PERFORMANCE     Messages reporting code that might result

                          in poor run-time performance.



          PORTABLE        Messages reporting the use of language

                          extensions or other constructs that might

                          not be portable to other compilers or

                          platforms.



          PREPROCESSOR    Messages reporting questionable or

                          non-portable use of preprocessing

                          constructs.



          QUESTCODE       Messages reporting questionable coding

                          practices.  Similar to the CHECK group,

                          but messages in this group are more likely

                          to indicate a programming error rather

                          than just a non-robust style.



                          Enabling the QUESTCODE group provides

                          lint-like checking.



          RETURNCHECKS    Messages related to function return

                          values.



          UNINIT          Messages related to using uninitialized

                          variables.



          UNUSED          Messages reporting expressions,

                          declarations, header files, CDD records,

                          static functions, and code paths that are

                          not used.



  o  A single message-level name (within parentheses, or not).



     Note:  There is a core of very important compiler messages that

     are enabled by default, regardless of what you specify with

     /WARNINGS or #pragma message.  Referred to as message level 0,

     it includes all messages issued in header files, and comprises

     what is known as the nostandard group.  All other message

     levels add additional messages to this core of enabled

     messages.



     You cannot modify level 0 (You cannot disable it, enable it,

     change its severity, or change its EMIT_ONCE characteristic).

     However, you can modify individual messages in level 0,

     provided such modification is allowed by the action.  For

     example, you can disable a warning or informational in level 0,

     or you can change an error in level 0 to a fatal, and so on.

     (See above restrictions on modifying individual messages.)



     Message-level names are:



          LEVEL1          Important messages.  These are less

                          important than the level 0 core messages,

                          because messages in this group are not

                          displayed if #pragma nostandard is active.



          LEVEL2          Moderately important messages.



          LEVEL3          Less important messages.  LEVEL3 is the

                          default message level.



          LEVEL4          Useful check/portable messages.



          LEVEL5          Not so useful check/portable messages.



          LEVEL6          Additional "noisy" messages.



       Enabling a level also enables all the messages in the levels

       below it.  So enabling LEVEL3 messages also enables messages

       in LEVEL2 and LEVEL1.



       Disabling a level also disables all the messages in the

       levels above it.  So disabling LEVEL4 messages also disables

       messages in LEVEL5 and LEVEL6.



  o  A comma-separated list of message identifiers, group names, and

     messages levels, freely mixed, enclosed in parentheses.



 The default is /WARNINGS.  This enables all diagnostic messages for

 the selected compiler mode.



 Notes:



  o  If a message is on both the enabled and disabled list, it is

     disabled.



  o  If a message is on both the EMIT_ONCE and the EMIT_ALWAYS list,

     it is considered to be on the EMIT_ONCE list.



  o  If a message is on more than one of the FATALS, ERRORS,

     WARNINGS, or INFORMATIONALS lists, the message is given the

     least severe level.



  o  The NOINFORMATIONALS option is not the negation of

     INFORMATIONALS=msg-list.  It is valid to say:



     /WARN=(INFORMATIONALS=message_list,NOINFORMATIONALS)



     This has the effect of making the messages on the message_list

     informationals, and causing the compiler to suppress any

     informational messages.





Message_Groups                          



Compaq C compiler message groups



The following tables list all compiler messages by message group.

For a description of each compiler message, see the Messages section

of this online help.

Additional Information on:

Messages                               



Compiler messages



Some compiler messages substitute information from the program into

the message text.  In this online help, the portion of the text to

be substituted is shown in angle brackets (<>).



Often, the same message is issued in different contexts within a

program.  In this online help, the message context is indicated by

the word <context> within the message.  The actual message issued by

the compiler will contain one of the following phrases substituted

for <context>:



     In this declaration,

     In the initializer for

     In the declaration of "<name>",

     In the definition of the function "<name>",

     In the declaration of an unnamed object,

     In this statement,



You can control the messages issued with the /[NO]WARNINGS command

line qualifier or the #pragma message preprocessor directive.  Note

that some messages are not produced directly by the compiler; they

are produced by other software that the compiler uses.  Messages not

produced directly by the compiler are not included in this list and

can not be controlled by /[NO]WARNINGS or #pragma message.

Additional Information on:

Language_topics                        



Compaq C language topics

Additional Information on:

Run-time_functions                           



 Note:  You might have a newer version of Compaq C that has header

 files and documentation for functions that are not supported on

 your older OpenVMS system.  For example, if your target operating

 system platform is OpenVMS Version 7.2, you cannot use Compaq C RTL

 functions that are introduced on OpenVMS Version 7.3, even though

 they are documented in this help and in the Compaq C RTL Reference

 manual.



 See Appendix of the Compaq C Run-Time Library Reference Manual for

 a series of tables that list what DEC C RTL functions are supported

 on recent OpenVMS versions.  This is helpful for determining the

 functions to avoid using on your target OpenVMS platforms.



 In the Curses Screen Management Package, there are pairs of

 functions and macros with equivalent functionality.  Many Curses

 functions and macros are expressed as follows:



      [w]addch

      [no]echo



 The descriptions of the addch macro and the waddch function are

 found under the heading, [w]addch.  The descriptions of the macros

 echo and noecho are found under the heading, [no]echo.  For more

 information about Curses Screen management functions and macros,

 see HELP CC RUN-TIME_FUNCTIONS CURSES and HELP CC LINK_LIBRARIES.



 All other library functions are listed alphabetically under

 separate headings.



 All library functions are reentrant unless explicitly stated

 otherwise.

Additional Information on:

Release_Notes                       

 The release notes for Compaq C are contained in the following

 files:



 SYS$HELP:CC064.RELEASE_NOTES



 SYS$HELP:CC064_RELEASE_NOTES.PS





Socket_Routines                             

      Socket routines are used in writing Internet application 

      programs for the DEC TCP/IP Services for OpenVMS product

      (formerly the VMS/ULTRIX Connection).

Additional Information on: