 |
» |
|
|
|
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 “How a File Becomes a Running
Program on HP-UX ” shows how a file
named prog.p becomes a running program on HP-UX. This section explains: 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 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,
-Dname
Defines name is as if
it has been set (with $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: -Dname=bool +Q
dfile 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 for PA-RISC 1.0 architecture
or higher. This is the default for all Series 800 models. - 1.1
Generates object code for PA-RISC 1.1 architecture.
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. See the file /usr/lib/sched.models
for model numbers and their architectures. You can use the command
uname -m to determine
the model number of your system. +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 one implementation of
PA-RISC 1.0. - 1.1
Perform scheduling tuned to one implementation of
PA-RISC 1.1.
See the file /usr/lib/sched.models
for model numbers and their architectures. The compiler determines
the default scheduling 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 sudden 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
“ARITRAP and HPENBLTRAP Intrinsics ” or 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: The directory containing the source file. Directories specified with the -I
option. The current working directory. 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 unsharable (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 [,arg2,... argn]
Cause arg1 through argn
to be handed off to subprocess c. The arg
parameters are of the form: 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: 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: it is equivalent to the statement: 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: 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 “Error Recovery and Debugging ”, 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 “Error Recovery and Debugging ”. 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. |
Printable version
