Builtin_Functions                 
 Built-in functions allow you to directly access hardware and
 machine instructions to perform operations that are cumbersome,
 slow, or impossible in pure C.

 These functions are very efficient because they are built into the
 C++ compiler.  This means that a call to one of these functions
 does not result in a reference to a function in the C run-time
 library or in your programs.  Instead, the compiler generates the
 machine instructions necessary to carry out the function directly
 at the call site.  Because most of these built-in functions closely
 correspond to single VAX or Alpha machine instructions, the result
 is small, fast code.

 Some of these functions (such as those that operate on strings or
 bits) are of general interest.  Others (such as the functions
 dealing with process context) are of interest if you are writing
 device drivers or other privileged software.  Some of the functions
 are privileged and unavailable to user mode programs.

 Be sure to include the <builtins.h> header file in your source
 program to access these built-in functions.

 C++ supports the #pragma builtins preprocessor directive for
 compatibility with VAX C, but it is not required.

 Some of the built-in functions have optional arguments or allow a
 particular argument to have one of many different types.  To
 describe different valid combinations of arguments, the description
 of each built-in function may list several different prototypes for
 the function.  As long as a call to a built-in function matches one
 of the prototypes listed, the call is valid.  Furthermore, any
 valid call to a built-in function acts as if the corresponding
 prototype was in scope, so the compiler performs the argument
 checking and argument conversions specified by that prototype.

 The majority of the built-in functions are named after the machine
 instruction that they generate.  For more information on these
 built-in functions, see the documentation on the corresponding
 machine instruction.  In particular, see that reference for the
 structure of queue entries manipulated by the queue built-in
 functions.

Additional Information on:

Variable_Length_Argument_Lists               
 The set of functions and macros defined and declared in the
 <varargs.h> and the <stdarg.h> header files provide a method of
 accessing variable-length argument lists.  (Note that the
 <stdarg.h> functions are defined by the ANSI C++ standard and are,
 therefore, portable as compared with those defined in <varargs.h>.)

 The C++ RTL functions such as printf and execl, for example, use
 variable-length argument lists.  User-defined functions with
 variable-length argument lists that do not use <varargs.h> or
 <stdarg.h> are not portable due to the different argument-passing
 conventions of various machines.

 To use these functions and macros in <stdarg.h>, you must include
 the <stdarg.h> header file with the following preprocessor
 directive:

      #include <stdarg.h>

 The <stdarg.h> header file declares a type (va_list) and three
 macros (va_start, va_arg, and va_end) for advancing through a list
 of function arguments of varying number and type.  The macros have
 the following syntax:

      void va_start(va_list ap, parmN);

      type va_arg(va_list ap, type);

      void va_end(va_list ap);

 The va_start macro initializes the object ap of type va_list for
 subsequent use by va_arg and va_end.  The va_start macro must be
 invoked before any access to the unnamed arguments.  The parameter
 parmN is the identifier of the rightmost parameter in the variable
 parameter list of the function definition.  If parmN is declared
 with the register storage class, with a function or array type, or
 with a type that is not compatible with the type that results after
 application of the default arguments promotions, the behavior is
 undefined.  The va_start macro returns no value.

 The va_arg macro expands to an expresion that has the type and
 value of the next argument in the call.  The parameter ap is the
 same as the one initialized by va_start.  Each invocation of va_arg
 modifies ap so that the values of successive arguments are returned
 in turn.  The parameter "type" is a type name specified such that
 the type of a pointer to an object that has the specified type can
 be obtained by postfixing an asterisk (*) to "type".  If there is
 no actual next argument, or if type is not compatible with the type
 of the next actual argument (as promoted according to the default
 argument promotions), the behavior is undefined.  The first
 invocation of va_arg after that of va_start returns the value of
 the argument after that specified by parmN.  Successive invocations
 return the values of the remaining arguments in turn.

 The va_end macro facilitates a normal return from the function
 whose variable argument list was referred to by the expansion of
 va_start that initialized the va_list ap object.  The va_end macro
 can modify ap) so that it can no longer be used (without an
 intervening invocation of va_start).  If there is no corresponding
 invocation of va_start or if va_end is not invoked before the
 return, the behavior is undefined.  The va_end macro returns no
 value.

Preprocessor             
 The C++ preprocessor uses directives to affect the compilation of
 a source file.  For C++ on OpenVMS systems, these directives are
 processed by an early phase of the compiler, not by a separate
 program.

 The preprocessor directives begin with a number sign (#) and do not
 end with a semicolon.  The number sign must appear in the first
 column of the source line.

Additional Information on:

Predefined_Macros
 C++ provides the following predefined macros:

Additional Information on:

System_Identification_Macros

Version_Number_Macros

Alpha_System_Macros

Floating_Point_Macros

Implementation_Compatibility_Macros

_BOOL_EXISTS

CC$gfloat

__DATE__

__FILE__

__LINE__

__TIME__

_WCHAR_T

privacy and legal statement