Compiling, Linking, and Running Your Program [ HP Pascal/iX Programmer's Guide ] MPE/iX 5.0 Documentation
HP Pascal/iX Programmer's Guide
Compiling, Linking, and Running Your Program
To make your HP Pascal program a valid HP-UX process, you must compile,
link (and load), and run it.
The HP-UX command pc coordinates the HP Pascal compiler
(/usr/lib/pascomp) and the HP-UX linker loader (/bin/ld).
The name of the file containing your source program must end with .p (for
example, prog.p). The extension .p causes the pc command to call the HP
Pascal compiler, which compiles your program and stores the resultant
code in an object file. The name of the object file ends in .o (if the
source file name is prog.p, the object file name is prog.o). If prog.p
is the only file parameter of a particular pc command, and it compiles
and links successfully, then the object file is not saved.
If the compiler does not find errors in the program, the pc command calls
the linker, ld, which links the object file with required library files
into a program file. The name of the program file is a.out (unless you
specify another name in the pc command) and it resides in the directory
from which pc was invoked. The program file is ready to run.
Figure B-1 shows how a file named prog.p becomes a running program on
HP-UX.
Click here to view figure.
Figure B-1. How a File Becomes a Running Program on HP-UX
This section explains:
* The HP-UX pc command.
* How to pass run-time parameters to your program.
* How HP-UX handles interrupts.
* How HP-UX handles run-time errors.
pc Command
The HP-UX command pc coordinates the HP Pascal compiler
(/usr/lib/pascomp) and the HP-UX linker loader (/bin/ld).
Additionally, the compiler looks for a system-wide file called
/usr/lib/pasopts. If the file exists and is not empty, the compiler
opens and reads the file. The file should contain only directives and
comments. If there is anything else in the file, the compiler emits an
error message. If the file is empty, which is the default, the compiler
does not attempt to open it. For more information on the system-wide
file, refer to the section on compiler options in the HP Pascal/HP-UX
Reference Manual.
Syntax
[REV BEG]
pc [file ] [...]
[option]
[REV END]
Parameters
file At least one file is required.
option Any of the following instructions to the compiler:
-A Produce warnings when non-ANSI Pascal features
are found (same as ANSI ON).
+a Cause the compiler to generate archived object
(.a) files instead of simple object (.o) files.
This option exists for compatibility with the
Series 300 pc command.
-C Suppress code generation. No object (.o) files
will be created and linking will be
suppressed. This is effectively a request for
syntax/semantics checking only (same as CODE
OFF).
+C Convert MPE/iX format file names in the compiler
options BUILDINT, INCLUDE, LISTINTR, SPLINTR,
and SYSINTR to HP-UX-format file names. Fully
qualified HP-UX-format file names (those that
begin with slash, like /mnt/srf/file) are not
converted. This option is the same as the
compiler option CONVERT_MPE_NAMES
This option assumes an HP-UX directory structure
that is modeled after the MPE/iX accounting
structure, in which all files reside in
group-level directories and groups are
subdirectories of accounts. This option
converts MPE/iX format file names to lower case
letters.
For example, assume the HP-UX directory
structure account/group, where group is a
directory containing the file f. If a Pascal
source program contains the statement
$INCLUDE 'F.Group.Account'$
then the compiler appends the appropriate path
information to f and searches for the resulting
name (for example, root/account/group/f, where
root is the parent of the account-level
directories).
-c Suppress linking and only produce object (.o)
files from source files.
-Dname=bool, Defines name is as if it has been set (with
-Dname $SET) to the nth line on the source file. bool
can be either TRUE or FALSE; if bool in not
specified, name is set to TRUE. name and bool
can be uppercase or lowercase. The order in
which the compiler encounters $SETs (regardless
of relative order on the command line) is:
1. -Dname=bool
2. +Q dfile
3. source file
The compiler overrides -Dname=bool with any
subsequent duplicate use of $SET, always taking
the last one and issuing a warning.
+DAmodel Generates object code for a specific version of
the PA-RISC architecture. model can be a model
number such as 750 or 870, or one of the
following architecture specifications:
1.0 Generates object code suitable for all
implementations of PA-RISC 1.0 or
higher. This is the default for all
Series 800 models.
1.1 Generates object code suitable for all
implementations of PA-RISC 1.1. This is
the default for all Series 700 models.
Note that object code generated for
PA-RISC 1.1 will not execute on PA-RISC
1.0 implementations.
+DAmodel also specifies the appropriate library
search path for HP-UX math libraries. If your
program calls any of the standard Pascal
Arithmetic functions, using +DA1.0 links the
PA-RISC 1.0 version of the math library and
using +DA1.1 links the PA-RISC 1.1 version of
the library. The PA-RISC 1.1 libraries have
performance enhancements and new routines that
the PA-RISC 1.0 libraries lack. See the HP-UX
Floating-Point Guide for more information about
using math libraries.
+DSmodel Perform instruction scheduling appropriate for a
specific implementation of the PA-RISC
architecture. model can be a model number such
as 750 or 870, or one of the following
architecture specifications:
1.0 Perform scheduling tuned to a model
representative of PA-RISC 1.0
implementations.
1.1 Perform scheduling tuned to a model
representative of PA-RISC 1.1
implementations.
The default scheduling is based on the model
number returned by uname(2).
This option affects only performance of the
object code by scheduling the code based on the
specific latencies of the target implementation.
The resulting code executes correctly on other
PA-RISC implementation, subject to the +DA
option.
+FPflag Specify how the run time environment for
floating-point operations should be initialized
at program start up. flag is a series of
upper or lower case letters from the set
[VvZzOoUuIiDd] with no embedded white-space. If
the upper-case letter is selected, that behavior
is enabled. If the lower-case letter is
selected or if the letter is not present in
flag, the behavior is disabled. The default is
that all behaviors are disabled. The list below
describes the behaviors:
V Trap on invalid floating-point
operations.
Z Trap on divide by zero.
O Trap on floating-point overflow.
U Trap on floating-point underflow.
I Trap on floating-point operations that
produce inexact results.
D Enable sudden underflow (flush to zero)
of denormalized values.
Enabling underflow is possible only on
implementations of PA-RISC 1.1 or
higher; it is not possible on PA-RISC
1.0.
To dynamically change these settings at run
time, refer to fpgetround(3M).
-G Prepare object files for profiling with the
gprof utility (see "GPROF" in the HP
Pascal/HP-UX Reference Manual).
-g Generate additional information for the symbolic
debugger, and ensure that the program is linked
as required for the symbolic debugger.
-Idir Add dir to the list of directories that search
for $INCLUDE files whose names do not begin with
/. The search is performed in the following
order:
1. The directory containing the source file.
2. Directories specified with the -I option.
3. The current working directory.
4. The standard directory /usr/include.
-L Write a program listing to stdout.
-lx Cause the linker to search the libx.sl or libx.a
libraries in an attempt to resolve currently
unresolved external references. Because a
library is searched when its name is
encountered, placement of a -l is significant.
If a file contains an unresolved external
reference, the library containing the definition
must be placed after the file on the command
line. See ld(1) for more information.
-N Cause the output file from the linker to be
marked as unshareable (see -n).
-n Cause the output file from the linker to be
marked as shareable (see -N).
-O Turn on optimization. The compiler performs
level 2 optimization. See +Oopt.
+Oarg Perform optimizations selected by arg. There
are two kinds of arguments to the +O
optimization option. Those in the first group
can have arg defined as:
1 Perform level 1 optimizations. These
include branch optimizations, dead code
elimination, instruction scheduling, and
peephole optimization.
2 Perform level 2 optimizations. These
include common subexpression
elimination, constant folding, loop
invariant code motion, coloring register
allocation, and store-copy optimization.
Level 2 optimizations are a superset of
level 1 optimizations. The -O option is
equivalent to the +O2 option.
3 Perform level 3 optimizations. These
include, but are not limited to,
interprocedural global optimizations.
Level 3 optimizations are a superset of
level 2 optimizations.
Those in the second group can have arg defines
as:
s Suppress optimizations which tend to
increase the generated code size.
Currently, these optimizations include
software pipelining and loop unrolling.
bbnum Specify the maximum number of basic
blocks allowed in a procedure that is to
be optimized at level 2. If a procedure
contains more than num basic blocks,
level 1 optimization is performed for
that procedure. The default value for
num is 500 (same as $OPTIMIZE
'BASIC_BLOCKSnum'$).
The arguments in the second group implicitly
request level 2 optimizations, but an argument
from the first group overrides the implicit
level 2 regardless of their relative positions
on the command line.
-o outfile Name the output file from the linker outfile
instead of a.out.
-P lines Allow lines lines per page of compiler listing,
including header or trailer (same as the LINES
compiler option).
-p Prepare object files for profiling with the prof
utility.
-Q Cause the output file from the linker to be
marked as not demand loadable (see -q).
-q Cause the output file from the linker to be
marked as demand loadable (see -Q).
+Q dfile Cause dfile to be read before compilation of
each source file. The file dfile can only
contain compiler options.
+R Turns off range checking (same as the compiler
option RANGE OFF).
-S Output an assembly file. This file is named
filename.s, where filename is the base name of
the source file.
-s Cause the output of the linker to be stripped of
symbol table information. See strip(1) in
linker documentation. This option is
incompatible with symbolic debugging.
-t x,name Substitute or insert subprocess x with
name where x is one or more of an
implementation-defined set of identifiers
indicating the subprocesses. This option works
in the following modes:
* If x is a single identifier, name
represents the full path name of the new
subprocess.
* If x is a set of identifiers, name
represents a prefix to which the standard
suffixes are concatenated to construct
the full pathname of the new
subprocesses.
The values x can assume are:
c Compiler body (standard suffix is pascomp).
0 Same as c.
l Linker (standard suffix is ld).
-v Enable verbose mode, producing a step-by-step
description of the compilation process on
stderr.
-w Turn off warning messages (same as the compiler
option WARN OFF).
-Wc,arg1 Cause arg1 through argn to be handed off to
[,arg2,... subprocess c. The arg parameters are of the
argn] form:
-argoption[,argvalue]
where argoption is the name of an option
recognized by subprocess c and argvalue is a
parameter for argoption (if it has one). The
parameter c can have these values:
Value Meaning
c Compiler body (standard suffix is
pascomp).
0 Same as c.
d Driver program.
l Linker (standard suffix is ld).
For example, the specification to pass the -r
option (preserve rotation information) to the
linker is -Wl,-r.
-Y Enable 16-bit Native Language Support when
parsing string literals and comments (same as
the compiler option NLS_SOURCE). Note that 8-bit
parsing is always supported.
Other options--instructions to the linker--are
also allowed. See pc(1) in the HP-UX Reference
for details.
-y Generate additional information needed by static
analysis tools and ensure that the program is
linked as required for static analysis. This
option is incompatible with optimization.
+z, +Z Both of these options cause the compiler to
generate position independent code (PIC) for use
in building shared libraries. However, you must
use +z to generate PIC, unless certain limits
are exceeded. Use +Z when limits are exceeded.
If both +z and +Z are specified, only the last
one encountered will apply. Note that +z is the
same as $SHLIB_CODE ON$ and +Z is the same as
$SHLIB_CODE 2$.
The options -G and -p are ignored if you use
either +Z or +z.
For more information about PIC , refer to
Programming on HP-UX.
file The name of a textfile that contains source code for an HP Pascal
program, or the name of an object file. The textfile name ends
with .p; the object file name ends with .o.
For each textfile, the pc command calls the HP Pascal compiler,
which tries to compile it. If the compiler compiles the textfile
named prog1.p without errors, it produces an object file named
prog1.o (which resides in the current directory).
If each textfile compiles successfully, the pc command calls the
HP-UX Linker Loader, ld, which links all of the object files (pc
command parameters and those resulting from compiles) into the
final program file.
If prog.p is the only file parameter of a particular pc command,
and it compiles and links successfully, then its object file,
prog.o, is not saved.
Example
The command:
pc main.p ext1.p ext2.p
compiles the object files main.o, ext1.o, and ext2.o, into the final
program file a.out. It is equivalent to the command sequence:
pc -c main.p
pc -c ext1.p
pc -c ext2.p
pc main.o ext1.o ext2.o
NOTE The HP Pascal compiler ignores the following Series 300 pc command
options without warning:
+X
+x
+M
+b
+bfpa
+f
+ffpa
Run-Time Parameters
You can pass run-time parameters to your program as HP-UX command-line
arguments when starting your program.
No arguments are automatically bound to program parameters. Even the
three pre-opened (standard) files, stdin, stdout, and stderr are only
bound to the HP Pascal textfiles input, output, and stderr if the program
heading declares the textfiles.
Other run-time parameters must be obtained from the command line
arguments by importing the predefined module arg and using the routines
that it exports, which are:
Function Return Value
argc The total number of program arguments. (This
integer is greater than or equal to one, because
every HP-UX program has at least one program
parameter, the program name.)
argn An HP Pascal string that contains the nth program
argument, where n is an argument to argn and must
be in the range 0..argc - 1. If n is outside this
range, the run-time library generates a range
error. The call argn(0) returns the program name.
argv A pointer to a null-terminated array of pointers,
each of which points to a null-terminated PAC that
contains an argument (see the export section of the
arg module, on the next page).
The module arg belongs to the default module library /usr/lib/paslib;
therefore, your program can import it without specifying a library with
the SEARCH compiler option.
The export section for the module arg is:
MODULE arg;
EXPORT
TYPE
arg_string1024 = string[1024];
arg_type = PACKED ARRAY[1..32000] OF char;
argarray = ARRAY[0..32000] OF ^argtype;
argarrayptr = ^argarray;
FUNCTION argv : argarrayptr;
FUNCTION argc : integer;
FUNCTION argn (n : integer) : arg_string1024;
IMPLEMENT
.
.
.
.
END.
Example
$STANDARD_LEVEL 'HP_MODCAL'$
PROGRAM arg_demo (input, output);
VAR
f : text;
line : string[255];
fname : string[80];
IMPORT arg;
BEGIN
IF argc > 1 THEN BEGIN {If a program argument was passed ...}
fname := argn(1); {assign it to fname ...}
reset(f,fname); {reset the file fname ...}
WHILE NOT eof(f) DO BEGIN {and list its contents.}
readln(f,line);
writeln(line);
END;
END; {IF}
END. {arg_demo}
Associating Program Header Files with Run-Time Parameters
On HP-UX, files defined in the program header are implicitly associated
with run-time parameters. For example, if the program header is:
PROGRAM myprog (input, output, file1, file2);
then when the program myprog is run with command-line arguments, file1 is
bound to the first argument, and file2 is bound to the second. The
predefined files input, output, and stderr are not subject to this
implicit association.
Other command-line arguments that are not subject to this implicit
association are those that begin with plus (+) and minus (-). For
example, if the compiled program produced from the above example is run
with the command:
a.out -opt1 arg1 +opt2 arg2 arg3
then file1 is bound to arg1 and file2 is bound to arg2. Therefore, if
the program executes the statement:
reset (file1);
it is equivalent to the statement:
reset (file1, 'arg1');
If there is no run-time argument for a program header file, then the
upshifted formal name of the file is implicitly associated with it. For
example, if the program above is run with the command:
a.out arg1
then there is no run-time argument for file2, so it is associated with
the file named FILE2. Of course, if you provide an explicit association,
it overrides this implicit association. Also, if the file is already
open before the statement executes, the usual rules apply (that is, the
previous association is maintained).
Interrupt Handling
Your program can trap HP-UX interrupts (SIGINT and SIGQUIT, for example).
The recommended way to trap these signals is to make explicit calls to
the HP-UX system routine signal.
NOTE The HP9000 series 200 run-time routine catch_signals is supported,
but a call to this routine will severely affect the error-handling
mechanisms described in Chapter 11 , because those depend on
trapping certain HP-UX signals themselves (namely, SIGILL, SIGFPE,
SIGBUS, SIGSEGV, and SIGSYS). Use of this routine is strongly
discouraged.
Example
PROGRAM prog;
CONST
BADSIG = -1;
SIG_DFL = 0;
SIG_IGN = 1;
SIG_INT = 2;
SIG_QUIT = 3;
VAR
Old_Action : integer;
FUNCTION signal (SignalNum : integer;
ProcAddress : integer) : integer; EXTERNAL;
The function signal accepts a signal number, SignalNum, and a procedure
address, ProcAddress. Whenever the signal with the number SignalNum is
raised, the function transfers control to the procedure with the address
ProcAddress. The function signal returns the old stored value of
ProcAddress.
PROCEDURE InterruptHandler (SignalNum : integer); EXTERNAL;
BEGIN
Old_Action := signal (SIGINT, Baddress (InterruptHandler));
IF Old_Action = SIG_IGN THEN
Old_Action := signal (SIGINT, SIG_IGN)
ELSE IF Old_Action = BADSIG THEN
{An invalid SignalNum or ProcAddress was passed};
Old_Action := signal (SIGQUIT, Baddress (InterruptHandler));
IF Old_Action = SIG_IGN THEN
Old_Action := signal (SIGQUIT, SIG_IGN)
ELSE IF Old_Action = BADSIG THEN
{An invalid SignalNum or ProcAddress was passed};
END.
When either of the signals SIGINT or SIGQUIT is raised (by entering
CONTROL C on the keyboard, for example), the procedure InterruptHandler
is called.
NOTE In the preceding example, if InterruptHandler is to return to the
main program, its first action must be to rearm the signal
mechanism (in the manner described above) for the signal that was
trapped. This is necessary because every time a signal is trapped,
the HP-UX operating system resets its action information (the
stored value of ProcAddress) to SIG_DFL (the default action). The
program cannot resume normal execution and trap interrupts again
unless it rearms the signal handler.
Run-Time Error Handling
If HP-UX detects a run-time error, it aborts the program unless the
program defines error recovery code. Error recovery code can catch
run-time errors that originate from:
* In-line compiled code (for example: range violation errors, nil
pointer errors, math overflow errors).
* Run-time support routines (for example: string, set, math).
* Pascal file system (I/O errors).
* HP-UX file system support (system errors).
* Hardware (signals), except the kill signal.
When compiling a program, the compiler generates code that will call the
predefined procedure escape if HP-UX detects a run-time error in the
compiled program. The procedure escape transfers control to the
program's error recovery code (if the program has no error recovery code,
the program aborts). For a complete explanation of error recovery code,
see Chapter 11 .
Run-time errors in in-line compiled code are unique in that they can be
suppressed--that is, you can tell the compiler not to generate code to
catch them (see the compiler option RANGE in the HP Pascal/HP-UX
Reference Manual). Run-time errors from other sources cannot be
suppressed.
Most run-time errors that arise from interaction between in-line compiled
code and run-time support routines are I/O errors. A few are system
errors.
MPE/iX 5.0 Documentation
HP 3000 Manuals