C/C++ Programmer's Guide (G06.27+, H06.03+)
Table Of Contents
- What’s New in This Manual
- About This Guide
- 1 Introduction to HP C and C++ for NonStop Systems- TNS C Language System
- TNS C++ Language System
- TNS/R Native C and C++ Language System- TNS/R Native C Compiler
- TNS/R Native C++ Compiler
- TNS/R Native C Run-Time Library
- C++ Run-Time Library and Standard C++ Library
- TNS/R Native Linkers (nld and ld Utilities)
- Inspect Symbolic Debugger
- Visual Inspect Symbolic Debugger
- TNS/R Native Object File Tool (noft Utility)
- NonStop SQL/MP Compiler and NonStop SQL/MX Compiler
- TNS/R Native C and C++ Migration Tool
 
- Features of TNS/R Native C and C++
- TNS/E Native C and C++ Language System- TNS/E Native C Compiler
- TNS/E Native C++ Compiler
- TNS/E Native C Run-Time Library
- C++ Run-Time Library and Standard C++ Library
- TNS/E Native Linker (eld Utility)
- Native Inspect Symbolic Debugger
- Visual Inspect Symbolic Debugger
- TNS/E Native Object File Tool (enoft Utility)
- NonStop SQL/MP Compiler and NonStop SQL/MX Compiler
- TNS/E Native C and C++ Migration Tool
 
- Features of TNS/E Native C and C++
- Writing Portable Programs
- Porting Programs to HP C and C++ for NonStop Systems
- Porting Without Data Alignment Problems
- Guardian and OSS Environment Interoperability
 
- 2 C and C++ Extensions
- 3 Interfacing to Guardian Procedures and OSS Functions
- 4 Using the C Run-Time Library
- 5 Using the Standard C++ Library
- 6 Accessing Middleware Using HP C and C++ for NonStop Systems
- 7 Mixed-Language Programming for TNS Programs
- 8 Mixed-Language Programming for TNS/R and TNS/E Native Programs
- 9 System-Level Programming
- 10 Converting C-Series TNS Programs to Use the Current TNS Compiler
- 11 Migrating Programs to TNS/R or TNS/E Native Mode
- 12 Preprocessor Directives and Macros
- 13 Compiler Pragmas- ALLOW_CPLUSPLUS_COMMENTS
- ALLOW_EXTERN_EXPLICIT_INSTANTIATION
- ANSICOMPLY
- ANSISTREAMS
- BUILD_NEUTRAL_LIBRARY
- CALL_SHARED
- CHECK
- COLUMNS
- CPATHEQ
- CPPONLY
- CSADDR
- ELD(arg)
- ENV
- ERRORFILE
- ERRORS
- EXTENSIONS
- EXTERN_DATA
- FIELDALIGN
- FORCE_VTBL
- FORCE_STATIC_TYPEINFO
- FORCE_STATIC_VTBL
- FUNCTION
- HEADERS
- HEAP
- HIGHPIN
- HIGHREQUESTERS
- ICODE
- IEEE_FLOAT
- INLINE
- INLINE_COMPILER_GENERATED_FUNCTIONS
- INLINE_LIMIT
- INLINE_STRING_LITERALS
- INNERLIST
- INSPECT
- KR
- LARGESYM
- LD(arg)
- LINES
- LINKFILE
- LIST
- LMAP
- MAP
- MAPINCLUDE
- MAXALIGN
- MIGRATION_CHECK
- NEST
- NEUTRAL
- NLD(arg)
- NOEXCEPTIONS
- NON_SHARED
- OLDCALLS
- OLIMIT
- ONCE
- OPTFILE
- OPTIMIZE
- OVERFLOW_TRAPS
- PAGE
- POOL_STRING_LITERALS
- POP
- PUSH
- REFALIGNED
- REMARKS
- RUNNABLE
- RUNNAMED
- RVU
- SAVEABEND
- SEARCH
- SECTION
- SHARED
- SQL
- SQLMEM
- SRL
- SRLExportClassMembers
- SRLExports
- SRLName
- SSV
- STDFILES
- STRICT
- SUPPRESS
- SUPPRESS_VTBL
- SYMBOLS
- SYNTAX
- SYSTYPE
- TANDEM_FLOAT
- TRIGRAPH
- VERSION1
- VERSION2
- VERSION3
- WARN
- WIDE
- XMEM
- XVAR
 
- 14 Compiling, Binding, and Accelerating TNS C Programs
- 15 Compiling, Binding, and Accelerating TNS C++ Programs
- 16 Compiling and Linking TNS/R Native C and C++ Programs
- 17 Compiling and Linking TNS/E Native C and C++ Programs
- 18 Using ETK and Native C/C++ Cross Compiler on the PC
- 19 Running and Debugging C and C++ Programs
- 20 TNS C Compiler Messages
- 21 Native C and C++ Compiler Messages
- 22 Run-Time Messages
- 23 Handling TNS Data Alignment
- A HP C Implementation-Defined Behavior- Implementation-Defined Behavior of Native C- G.3.1 Translation
- G.3.2 Environment
- G.3.3 Identifiers
- G.3.4 Characters
- G.3.5 Integers
- G.3.6 Floating Point
- G.3.7 Arrays and Pointers
- G.3.8 Registers
- G.3.9 Structures, Unions, Enumerations, and Bit Fields
- G.3.10 Qualifiers
- G.3.11 Declarators
- G.3.12 Statements
- G.3.13 Preprocessing Directives
- G.3.14 Library Functions
- G.4 Locale Behavior
- G.5 Common Extensions
 
- Translation Limits for Native C Compilers
- Implementation-Defined Behavior of TNS C- G.3.1 Translation
- G.3.2 Environment
- G.3.3 Identifiers
- G.3.4 Characters
- G.3.5 Integers
- G.3.6 Floating Point
- G.3.7 Arrays and Pointers
- G.3.8 Registers
- G.3.9 Structures, Unions, Enumerations and Bit Fields
- G.3.10 Qualifiers
- G.3.11 Declarators
- G.3.12 Statements
- G.3.13 Preprocessing Directives
- G.3.14 Library Functions
- G.4 Locale Behavior
- G.5 Common Extensions
 
 
- Implementation-Defined Behavior of Native C
- B TNS C++ ImplementationDefined Behavior
- C ASCII Character Set
- D Data Type Correspondence
- E Features and Keywords of Version2NativeC++
- F MIGRATION_CHECK Messages
- Glossary
- Index

Mixed-Language Programming for TNS/R and 
TNS/E Native Programs
HP C/C++ Programmer’s Guide for NonStop Systems—429301-010
8-3
Declaring External Routines
to declare an external function: using a function prototype and a FUNCTION pragma 
(the preferred method), and using an interface declaration (the traditional method).
Writing Interface Declarations
The interface declaration is an HP extension of the function declaration as defined by 
ISO/ANSI C. The interface declaration indicates the correct language or indicates 
unspecified if the language is unknown. If no language attribute specifier is provided, 
the external procedure is assumed to be written in the same language as the 
compilation.
After providing an interface declaration, your C or C++ program uses normal function 
calls to access the procedure written in the other language. However, remember that 
these calls cross language boundaries; therefore, there are restrictions beyond those 
of normal C function calls.
The interface declaration enables you to declare COBOL procedures and most types 
of pTAL procedures, including:
•
pTAL procedures defined with the VARIABLE or EXTENSIBLE attribute
•
Procedures whose names are not valid C identifiers
•
pTAL procedures that do not return a value but do return a condition code 
However, your C or C++ program cannot directly call a pTAL procedure that returns 
both a value and a condition code. The subsection pTAL Procedures That You Cannot 
Call Directly on page 8-11 presents techniques that enable your C or C++ program to 
access pTAL procedures that fall into this category.
Using a Function Prototype and a FUNCTION Pragma
The recommended method for declaring an external routine is to use a standard 
function prototype followed later by a FUNCTION pragma. 
For more details on syntax, see FUNCTION
 on page 13-35 and for illustrations of 
FUNCTION pragmas used in interface declarations, see Examples
 on page 8-5.
Using an Interface Declaration
The traditional method for declaring external routines is to use an interface declaration 
in which you declare the procedure as if it were a C function, except that you include:
•
A language attribute specifier (_cobol, _tal or _unspecified) to identify the 
language of the external procedure. For native C and C++, _tal denotes the pTAL 
language on both TNS/R and TNS/E systems.
•
An _alias attribute specifier to assign the external name, or rather the name as 
known to the other language. 
The syntax for these older-style interface declarations is described in Attribute Specifier 
on page 2-10. However, it is recommended that you use the FUNCTION pragma to 
declare external routines. 










