This guide is for programmers who are using the SPLash! Compiler
to migrate SPL code to the MPE/iX platform or who want to
continue writing code in SPL and have Native Mode performance.
This document assumes a firm foundation in SPL syntax and
methodology. Much of the information in this document stresses
the differences between SPLash! and SPL, so you may want to
prepare for your compilation project by studying your SPL
documentation in addition to this manual. Reference documents for
SPL are listed in the section called "Other Sources of
Information" in the first chapter of this manual.
ALLEGRO CONSULTANTS, INC. MAKES NO WARRANTY OF ANY KIND WITH
REGARD TO THIS MATERIAL, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE. Allegro Consultants, Inc. shall not be liable
for errors contained herein or for incidental or consequential
damages in connection with the furnishing, performance or use of
this material.
The SPLash! Native Mode Compiler is a compiler for SPL (Systems
Programming Language), Hewlett-Packard's powerful block-structured
programming language. SPL was originally developed to run under the
MPE V operating system and to take advantage of the hardware features
of the original family of HP3000 computers. With the advent of
Hewlett-Packard Precision Architecture and a new generation of
HP3000s, SPLash! offers the features of the original SPL language and
the opportunity to take advantage of the full native mode
capabilities of the new machines.
SPLash! is a powerful tool for migrating existing SPL applications to
Hewllett-Packard's Precision Architecture (HPPA). With SPLash!,
there is no need to recode your programs using a different language,
nor do you need to maintain original and translated versions of your
object code. SPLash! gives you access to native mode performance on
HP Precision Architecture machines.
SPLash! was designed for maximum compatibility with its MPE V
counterpart. Since the original SPL language was highly dependent on
the hardware environment of the MPE V-based HP3000, SPLash!
emulates the addressing scheme of these older machines. All
constructs supported by SPL are supported by SPLash!, including
most ASSEMBLEs, all stack references (such as TOS and stack
decrements), and all other statements. The features that SPLash!
does not support generally depend on the old 16-bit architecture or
other hardware features that do not exist in HP Precision
Architecture. Throughout the manual, these differences are discussed
as they arise.
Program development with SPLash! involves the usual cycles
of editing, compiling, linking, and testing. There are two approaches
to choose from in compiling your programs. One approach is based on
UDCs that are provided with the product. The second approach is to
use command files in the same manner that you would use for any HP
compiler product. These approaches are discussed next.
When SPLash! was designed, one of the primary objectives was to
achieve maximum compatibility with the MPE V based HP3000
environment. Almost all hardware dependent features were
implemented, including:
As good as SPLash! is at maintaining the MPE V-based HP3000
environment, some facets of the traditional HP3000 architecture were
not implemented because they were too specific, required too much overhead
at run time, depended upon a property which is non-existent or meaningless
in Hewlett-Packard Precision Architecture, or were obsolete.
SPLash! will flag these few constructs, should they
exist in your code, and outline ways in which you might change your
code in order for it to compile and execute in native mode.
The next examples illustrate this process using the UPSHIFT module
and the program UPPER.SOURCE for both the UDC and the command file
approaches to compilation.
To run XREF on a source file and its $INCLUDE files, you would need
to specify bit 15 which reads INCLUDE files. The number in the far
right column is the value to assign to the parm variable. For
example:
The parm setting is the sum of the decimal settings for bit 15 which
has a decimal value of 1 and bit 9 which has a decimal value of 64.
Using Other Languages
This table maps data types between SPLash!, Pascal/iX, and C/iX. Some
types map exactly. For inexact maps, equivalent SPLash! (or
Pascal/iX) datatypes are suggested.
SPLash! Pascal/iX C/iX note:
Exact:
byte char char #6
integer shortint short
double integer int (or long)
real real real
long longreal double
array array array #1
pointer ^^ * #4
fullvirtual ptr ^^$extnaddr$ ^^
procedure procedure ?
logical "0..65535" unsigned short #2
Inexact:
"double array" longint ? #3
"long array" longreal ? #3
"byte array" string -
"double" set ?
"byte array" record struct
No mappings known:
label - - #5
1
SPL and SPLash ! allow only single dimensioned
arrays.
2
Pascal/iX may not result in a 16-bit variable,
"integer" may be a better equivalent.
3
When Pascal/iX passes a longint or a longreal by value,
it really passes the address of a copy of the data.
A longint is a 64-bit integer, a longreal is a 128 bit real.
4
The SPLash! "pointer" data type assumes either a "virtual
pointer" or an ordinary pointer within a Native-mode procedure.
Such pointers, like the "^" pointers in Pascal/iX, are 32 bits
in size. An ordinary pointer in a splash-mode procedure would
be 16 bits in size and cannot be passed by reference to a
Native-mode procedure.
5
A "label" in SPLash! can be passed into a procedure as a
parameter. It currently takes 48 bits on the stack, just as
in SPL.
6
A "byte" variable passed by value to a procedure is handled
specially in SPL and SPLash !. In and in SPLash!
splash-mode procedures, the 8 bits of data is found in the
UPPER 8 bits of a 16-bit halfword. In SPLash!, Native-mode
procedures and in all other native mode languages, the 8
bits of data is found in the lower 8 bits of a (typically)
32-bit word.
In addition to data type differences, the programmer should be
aware of the ways a parameter can be passed to a procedure within
Pascal/iX, and their reflections in SPLash! Pascal/iX allows
parameters to be passed: (1) by value; (2) by "var"; (3) by
"anyvar"; (4) by "readonly"; and (5) by "uncheckable anyvar".
The following describes how to pass SPLash! data into Pascal/iX
procedures using each of the four methods.
value
The programmer should be aware that Pascal/iX never truly
passes by value data that is bigger than 64 bits. Instead,
a copy of the data is made and the address of the copy is
passed. Thus, for all simple variables (except longint and
longreal), simply declaring them as "value" in SPLash!
suffices. Larger variables (or records) must be declared
in the external-declaration as being passed by reference.
"var"
"var" is by reference, where the address passed is a 32-bit
short pointer. Simply declaring the parameters to be
reference in SPLash! suffices. (Remember: reference is the
default in SPL and SPLash! if the "value" statement is
not used.)
"anyvar"
"anyvar" is a variation on the "var" mechanism. In addition
to passing the address of the variable, a hidden following
parameter is passed which tells the size of the actual
parameter in bytes. At present, SPLash! does not support
"anyvar". As a workaround, TWO formal parameters should be
declared: first, the reference parameter; second, a double
by value. When the procedure is called, the double by value
should be given the size (in bytes) of the first parameter.
"readonly"
"readonly" is identical to "var" and tells
Pascal/iX that the programmer will not be
changing the data.
Simply declaring the parameters to be
reference in SPLash! suffices.
"uncheckable anyvar"
This is another variation on "var". From the SPLash!'s
viewpoint, it should be treated as a "var".
At present, SPLash! will not correctly pass a pointer variable to
a parameter that is marked "uncheckable anyvar" or "anyvar"
unless the formal parameter is also a pointer. This restriction
makes it necessary to fool the compiler when calling intrinsics
that expect arbitrary parameters, some of which may be pointers
by reference. The only example of this kind of intrinsic, at
present, is HPFOPEN. If the programmer wants to use item # 21,
which requests that a fullvirtual pointer be passed back, the
following calling sequence would not work in the current version:
fullvirtual byte pointer ptr;
procedure hpfopen ( ..., item5, uany5, ...);
value item5, uany5;
integer item5;
virtual byte pointer uany5;
...
hpfopen ( ... , 21, ptr, ...);
In the above call, SPLash! would try to pass the VALUE in ptr
instead of the address of ptr. A workaround is:
double ptr'dummy = ptr;
...
hpfopen ( ..., 21, ptr'dummy, ...);
Method I. Intrinsic Intercept
This approach involves replacing HP3000 intrinsic declarations with
functionally equivalent C or Pascal code on the HP9000. In your SPL
program, include external declarations (instead of intrinsic
declarations) for any HP3000 intrinsics that your program uses. Then,
on the HP9000 intercept the external calls and replace them with C or
Pascal functional equivalents.
Step 1: Include the following declarations in the SPL source
$set x8=on ! Denotes HP-UX compilation
$native
$if x8=on
$unix
$endif
begin
byte array msg(0:79);
integer i;
$if x8=off
intrinsic print;
$else
procedure print(buffer,len,cctl);
value len,cctl;
integer len,cctl;
byte array buffer;
option external, native, uppercase;
$endif
i := move msg := (13,10,"Hello world");
print (msg, -i, 0);
end.
Step 2: Compile the SPL on the HP3000 to create HPPA Assembly Language
! compile with SPLash, then transfer hello.asm to the HP9000
SPLXL hello, hello.asm, $null
Step 3: Intercept Intrinsic calls on the HP9000 using the C Intercept
Library
! assemble
as hello.asm hello.o
! compile C intercept library
cc -Aa -c mpeint.c mpeint.o
! link into executable
ld /lib/crt0.o hello.o mpeint.o -ohello.exe
! hello.exe is the ported SPL!
The C Intercept Library
The C intercept library and its associated files can be found in the
SPLASH account. This intercept library contains C code for many
commonly used HP3000 intrinsics. As it stands today, the intercept
library is not exhaustive. Over time, however, it will eventually
evolve into a complete, comprehensive library that provides
equivalent intrinsic functionality for all HP3000 intrinsics for
which a C equivalent can be created.
The following files are provided to assist in intercepting HP3000 intrinsics:
MPEINT.EXT
Include this file in your SPL source, it contains external
declarations for several HP3000 intrinsics.
$native
$if x8=on
$unix
$endif
begin
...
$if x8=off
intrinsic print, quit, ...
$else
$include mpeint.ext.splash ! external declarations
$endif
To compile...
:SPLXL source,,$null info="x8=on"
MPEINT.H
Header file for MPEINT.C
FSERR.H
Include file for MPEINT.C
SSTYPES.H
Include file for MPEINT.C
MPEINT.C
C source code. Contains intercept routines for all of the
external declarations in MPEINT.EXT, plus several other
general purpose functions. These functions are discussed next.
C Functions
The file MPEINT.C contains the following intrinsic
intercept functions:
CCODE FREADDIR PRINTFILEINFO
FCHECK FWRITE QUIT
FCLOSE FWRITEDIR READX
FOPEN HPSETCCODE TERMINATE
FREAD PRINT
Plus, the following general purpose functions:
mpeint_erase_fid,
mpeint_filename_to_unix,
mpeint_initialize
The general purpose functions are used internally (by the
intercept functions). If you write additional intercept functions
you will probably need to use them as well.
In several cases, a simple C library function that can be used to
replace an intrinsic call may not exist. In this case, you will be
required to follow a port path of Intrinsic Replacement.
Method II. Intrinsic Replacement
The Intrinsic Replacement method is, as its name suggests, a porting
approach that involves replacing HP3000 intrinsic calls with calls
into the C or Pascal libraries. This approach to porting is more
coding intensive than the previous approach. But, because HP has both
a C and Pascal compiler available on both systems (HP3000 & HP9000),
porting and testing can be performed to a large degree on the HP3000 and then
transferred to the HP9000 for final development & testing.
When you use this approach, the C or Pascal replacement code should be
constructed as subprograms and then linked with the NMOBJ file produced
during the assembly phase of the SPLash! compilation.
Successful porting of a SPL program through this method will result in a
SPL source with very little dependence on the environment in which it is run.
Method III. Code Replacement
An SPL to C translator is being actively developed as an extension to
the SPLash! compiler. No release date has been announced. This will
probably be a several pass process where the SPLash! compiler is the
front end, followed by several processor passes until usable C code
is produced. Call Allegro if you are interested in more information on
this methodology.
SPLash! run time error recovery includes intrinsic-based trap support
and TRY-RECOVER blocks. These methods are discussed next.
The following intrinsics provide trap support for run time error
recovery: XLIBTRAP, XARITRAP, and XCODETRAP. See the MPE/iX
intrinsics manual for an explanation of how these work.
SPLash! supports TRY-RECOVER blocks used for building efficient run
time error handling into an application.
The TRY-RECOVER block begins with the keyword TRY. Following the TRY
keyword can be any valid SPL statements. If a run time error occurs
after a TRY statement has been encountered, control is passed to the
associated RECOVER block. Syntactically associated TRY and RECOVER
statements must reside in the same SPL procedure. TRY-RECOVER blocks
can be nested, however.
To use a TRY-RECOVER block in your program, include the control statement
$TRY at the beginning of your source module. $NOTRY is the default.
When $TRY is active, the words TRY, RECOVER, ESCAPE, and ESCAPECODE become
reserved keywords and can only be used in the context of a TRY-RECOVER block.
The components of a TRY-RECOVER block include the ESCAPE procedure,
the ESCAPECODE function, and the TRY-RECOVER block.
The TRY keyword defines the beginning of the TRY-RECOVER block.
Any run time errors or calls to escape from within this section will
result in program control being passed to the RECOVER block.
The TRY section can contain any valid SPL statements including
compound statements, procedure calls, and TRY-RECOVER blocks.
Note
—The TRY-RECOVER mechanism is implemented like a
stack. The last TRY-RECOVER block will be the first one called when
an escape call is made.
The RECOVER keyword defines the beginning of the RECOVER block. This
is the section of code that gets control when an escape is executed.
Like the TRY section, the RECOVER section can contain any valid SPL
statements including compound statements and other TRY-RECOVER
blocks.
Note
—If a run time error or escape is executed
within a RECOVER block, this will result in a program abort unless
the current TRY-RECOVER block is contained within another TRY-RECOVER
block.
In MPE V/E "low" memory is referred to as "bank 0". This bank of
128KB contains many interesting tables and values. PM code can
access this data via the following opcodes:
In the list above; "Single" means a 16-bit value, "Double" means a 32-bit
value. "Extended Address" means a 16-bit bank number and a 16-bit
half-word offset within the bank. "Half-word" means a 16-bit word.
If a SPLash! program was compiled with $BREAK=ALL, then conditional
breakpoints are emitted at the entry and exit of every procedure and
subroutine, at every label (e.g., LOOP:), and at the entry/exit
of the program.
When the program is run, these conditional breakpoints
cause the code to be interrupted, and the debugger is
invoked (quietly). The debugger determines which type of
conditional breakpoint was encountered. It then checks if the
user wanted that breakpoint to interrupt the program (i.e.,
is that type of trap ARMed?), and (if armed) falls into the
debug code.
Using DEBUG on MPE/iX
This is a brief summary of the more basic commands available in
Debug/iX. Debug/iX can be used to debug
native mode (NM) code or compatibility mode (CM) code.
Debug/iX has an extensive amount of help information available. The HELP
command describes the basic help facility. Using the HELP command,
along with the CMDLIST, FUNCLIST, and ENVLIST commands, will generate
information on almost any feature you are looking for.
The topics discussed in this section cover things like; using the
LIST command to generate information, which commands can be used for
displaying data, and how you can use the Singlestep and Breakpoint
instructions for controlling the execution of your program. Lastly,
an abbreviated list of commonly used Debug/iX commands is presented.
The LIST Command
The LIST Command, and it's variations, can be used to generate
command names for functions that you may wish to use.
Frequently, commands ending with the letters "LIST" follow a similar
pattern: the "IST" can be abbreviated (i.e., CMDL is equivalent to
CMDLIST), and the first parameter is a wildcard, via the LISTF
command (CMDLIST @Z@).
CMDLIST
cmdpattern [category] [what]
The CMDLIST command lists all of the commands known to Debug/iX.
Examples:
| CMDLIST | Lists all commands |
| CMDLIST @Z@ | List all commands with a "Z" in the name |
| CMDLIST @R@, window | List all window commands with an "R" in the name |
| CMDLIST @Z@, , ALL | Print Help text for commands with a "Z" in the name |
FUNCLIST
funcpattern [catogory] [what]
The FUNCList command lists all of the built-in functions known to
Debug/iX.
Examples:
FUNCLIST Lists all functions
FUNCL @Z@ List all functions with a "Z" in the name
ENVLIST
envpattern [category]
Debug/iX has a set of about 200 predefined variables you can access.
These variables are called "environmental variables." All of the
variables can be "read", and most can be changed (written). Some
require that the user have PM to change their values. The category
parameter selects the type of environmental variable you want to have
listed. The default is NOSTATE, which excludes variables that refer
to hardware registers (e.g., R21, DP, SR1).
Examples:
ENVLIST Lists most environmental variables
ENVLIST, STATE List the "state" oriented variables
ENVLIST, ALL List all environmental variables
For a complete list of commands that "list" things, try:
CMDLIST
@LIST
or
ALIASLIST @LIST
.
The ALIASLIST command is used because Debug/iX supports a synonym
feature that it refers to as an "alias". The CMDLIST command is
actually an alias for the CMDL command. Indeed, most of the apparent
commands ending in "LIST" are simply predefined aliases for commands
ending in "L".
Displaying Data
The DISPLAY commands display information on your screen in a variety
of formats.
DV
address [#words] [base] [recw] [recb]
$ or H Hex output
# or D Decimal output
% or O Octal output
A ASCII output (4 bytes, then a blank)
B Both Hex and ASCII output
C Code output (disassembled NM code)
S String output (one long continuous string of ASCII output)
Examples:
DV DP+8 Display first global Pascal/iX variable.
DV [DP+8], 3 Fetch a 32-bit address from DP+8, then display 3 words of
memory at that address.
DDB
dbaddr [#halfs] [base]
The DDB command displays the specified number of 16-bit words from
the CM stack starting at the desired DB relative address.
DQ qaddr [#halfs] [base]
DS saddr {#halfs] [base]
The DQ and DS commands display data from the CM stack Q-relative and
S-relative, respectively.
DR
dr [register]
If used by itself, Display Registers (DR) displays all of the
"hardware" registers for your current execution mode. To see the
registers for the other mode, combine with the CM and NM commands.
Examples:
DR Displays all registers
CM; DR Displays all CM "registers"
CM; DR; NM; DR Displays all registers for both modes.
Singlestep & Breakpoint
These instructions are useful for controlling the execution of your
program.
Ss
[#instructions]
The Singlestep command (S or s) executes the desired number of
instructions and then returns to the debugger (assuming the
program has not terminated prior to that point). You may return
to the debugger immediately, whenever a breakpoint is encountered.
B
address [count] [<LOUD] | QUIET>] [cmd]
The Breakpoint instruction establishes a breakpoint at the
specified address. For example, to setup a breakpoint at the
second instruction after the current program counter (in NM) you
would use the following command:
By default, breakpoints are permanent (for the life of the process).
To setup a one-shot breakpoint (called temporary breakpoint in MPE V),
use the following command:
The count option, which defaults to 1, means: pop up into the
debugger every "count" times through this point. Thus, if a FOR loop
had a breakpoint with a count of "2", then every second time through
the loop you would enter the debugger.
The LOUD/QUIET options (default is LOUD) tell the debugger whether
it should announce the fact that you just entered Debug/iX.
The cmd option (default is none) is a command to be executed when
you pop up into the debugger. If the "C" command is not part of the
commands executed, then you will remain in the debugger after
the commands execute.
Examples:
-
To set a breakpoint at the entry to FOPEN use:
nmdebug > b FOPEN
-
To set a breakpoint at address 5100 in my program use:
nmdebug > b 5100
-
To set a temporary breakpoint at 24 bytes beyond the
"PROGRAM" start use:
nmdebug > b PROGRAM+24,-1
-
To set a breakpoint 8 bytes after the current program counter,
and conditionally continue execution based on the value of a
virtual memory location use:
nmdebug > b pc+8,,,{if [dp+8]<>0 then c}
BD
[@]
The BD command deletes breakpoints. If "@" is specified, all
breakpoints are deleted. If a number is specified (for example BD 3),
then that specific breakpoint is deleted. If no parameters are
specified, Debug/iX will prompt for permission to delete each breakpoint
(the default answer is NO).
Miscellaneous Debug/iX Commands
C
(and Exit)
The Continue command resumes executing your program.
ABORT
Aborts your program, immediately. If you have PM and are
debugging inside of system code, the debugger will not let you
abort if your process is critical or hold a SIR.
SET CRON
Tells Debug/iX that, until cancelled, an empty line of input
means: repeat the last non-empty line. One application for this is in
single stepping.
For Example:
SET CROFF
Disables the SET CRON command.
WHELP
Displays several screens of help text about windows.
WON
WOFF
RED
Redraws the windows, useful if your program sent an escape
sequence that cleared the screen.
VW virtaddr [name]
Opens a window looking at the specified virtual address. When
windows are on (WON), this window will appear after the default
windows.
VK [virtualwindow#]
Kills a virtual window (deletes it from the window display and
forgets about it).
Appendix F : Sample Code
SPLash! Sample Code
The code samples presented in this section include Dynamic
Procedures, the MYCOMMAND intrinsic, and the LOADPROC intrinsic.
These code samples were selected as models because they reflect the
kind of information that
SPLash! users commonly request when coding for the native mode
platform.
Dynamic Procedures
! dynamic.inc 88/03/02 cap = ia, pm, ba
! Purpose:
! Exercise dynamic procedure calling.
!
! PM:
! Since 1.1 of MPE XL, privmode is needed to usefully call
! printfileinfo on files 1..8
!
! Method:
! HPGETPROCPLABEL is used to get an NM plabel for PRINTFILEINFO.
! PRINTFILEINFO is then called for file numbers [0]..8
! (PARM is used for the lower limit.).
! PRINTFILEINFO is called in 4 different ways, dictated by
! file# mod 4:
! 0: pcal 0: tos := plabel; assemble (pcal 0, native)
! 1: dynamic pcal: pfi(fid);
! 2: pcal of dynamic proc: assemble (pcal pfi)
! 3: dynamic pcal, stacked parm: pfi(*)
! NOTE: not all of the 8 files are open!!!!!
!
! Success:
! 9 file "tombstones", some of which are for non-open files.
!
! Failure:
! program abort, or no file "tombstones".
$control stmt
begin
double
d := 0d,
dummy,
plabel := 0d,
status := 0d;
integer array
buf (0 : 40);
integer
fid,
len,
new'sreg,
old'sreg,
parm = q - 4;
byte array
buf' (*) = buf,
procname (0 : 40);
intrinsic
ascii,
getprivmode,
getusermode,
hpgetprocplabel,
print,
quit;
<<*************************************************************>>
procedure pfi (fid);
value fid;
integer fid;
option dynamic, native, nocc;
! Note: the above allocates 32 bits of storage, for a variable
! called "pfi". Once "pfi" has been assigned a value (a plabel),
! it can be called just like any other procedure.
!
! NOTE: do NOT use LOADPROC to get a value for "pfi" ... LOADPROC
! quite nicely loads a CM-plabel (16 bits), which is very useful
! when you are writing SWITCH code, but not at all useful for
! calling from ANY native mode program!
<<*************************************************************>>
! Note: the "intrinsic hpgetprocplabel;" results in:
!
! procedure hpgetprocplabel (procname, plabel, status, first'file',
! case'sensitive);
! value case'sensitive;
! double dummy1, dummy2, status, plabel;
! byte array procname, first'file';
! logical case'sensitive;
! option external, native, extensible, uppercase, nocc,
! variable, intrinsic;
<<*************************************************************>>
move procname := "-PRINTFILEINFO-";
hpgetprocplabel (procname, plabel, status);
if status <> 0d then ! 0d = ok
quit (1); ! or, use new catalog stuff
! to display error.
! NOTE: the second parameter to hpgetprocplabel, plabel,
! is a scratch 32-bit integer and NOT the name of the
! option-dynamic routine! If you tried to use the name of
! that routine (pfi) as the actual parameter, then SPLash! would
! interpret it as an attempt to call pfi.
!
! OK, we now have the 32-bit plabel for the routine, let's
! associate it with our "dynamic" procedure...
@pfi := plabel;
getprivmode; ! so we can call printfileinf (1..8)
! Now, let's call it in four different ways:
for fid := parm until 8 do
begin
push (s);
old'sreg := tos; ! remember where S was, to check for
! stack problems (Stan's debugging)
print (buf, 0, 0); ! blank line
len := move buf' := "FILE # ";
len := len + ascii (fid, 10, buf'(len));
len := len + move buf'(len) := "...";
print (buf, -len, 0);
! demonstrate 4 methods of calling dynamically loaded
! procedures...
case fid mod 4 of
begin
begin
! an "assemble pcal" of a native-mode procedure works
! ONLY if the programmer manually loads the parameters
! into the correct registers/nm-stack cells ... very
! difficult!
print (buf, -move buf' := "Do: assemble(pcal 0,native)", 0);
tos := double (fid); ! put first parameter onto stack
set (26); ! and move it into R26
tos := @pfi;
assemble (pcal 0, native);
end;
begin
! The high-level, recommended way of calling dynamic
! procedures...the compiler maps the parameters correctly.
print (buf, -move buf' := "Do: dynamic pcal", 0);
pfi (fid);
end;
begin
! This way usually works, if you have pushed the right
! parameters onto the SPLash! stack, but isn't recommended.
! If an address was by reference, we have to assume that you
! pushed a 32-bit address (or 64-bit address!) onto the stack!
print (buf, -move buf' := "Do: assemble(pcal pfi)", 0);
tos := fid;
assemble (pcal pfi);
end;
begin
! This way works too, with same caveats as "assemble pcal pfi"
! I.e.: not recommended.
print (buf, -move buf' := "Do: pfi (*)", 0);
tos := fid;
pfi (*);
end;
end;
! Note: both the "assemble (pcal pfi)" and the "pfi (*)" can be
! fooled by a programmer playing around with 32-bit versus 16-bit
! stacked reference parameters. The safest way (and the easiest
! to read & maintain) is to use dynamic procedures with their actual
! parameters (not stacked parameters).
print (buf, -move buf' := "Back from pcal", 0);
print (buf, 0, 0);
! check to see if any bugs in compiler left stuff on stack...
push (s);
new'sreg := tos;
if old'sreg <> new'sreg then
begin
print (buf, -move buf' := "***STACK PROBLEMS***", 0);
quit (new'sreg - old'sreg);
end;
end;
end.
MYCOMMAND Intrinsic
! mycomman.inc 90/02/20
! Status: apparently working
integer procedure mycommand (comimage, delimiters, maxparms,
numparms, parms'd, dict, defn);
value maxparms;
integer maxparms, numparms;
byte array comimage, delimiters, dict;
double array parms'd;
byte pointer defn;
option variable, splash;
begin
double
lims;
integer array
buf (0 : 40);
logical
parmcount = q-4,
lastflag := false,
lmaxparms = maxparms,
start,
endx,
crblank := %6440,
status = q-1;
integer
length = endx,
lims'lower = lims,
lims'upper = lims + 1,
new's, ! value of S at exit
save's, ! value of S at entry
s0 = s - 0,
xreg = x;
byte array
buf' (*) = buf,
default'delims (0 : 3);
byte pointer
command = start,
pntr = comimage;
define
cc = status.(6:2) #,
cce = 2 #,
ccg = 0 #,
ccl = 1 #;
label
exit'cce,
exit'ccg,
exit'ccl;
intrinsic
ascii,
debug,
print,
quit;
<<--------------------->>
subroutine fail (n);
value n;
integer n;
begin
print (buf, - move buf' := "Fail # ", %320);
print (buf, - ascii (n, 10, buf'), 0);
debug;
end <<fail sub>>;
<<--------------------->>
push (s);
save's := tos;
move default'delims := (",=;", %15);
tos := 0;
push (q);
lims := tos;
if not (0 <= maxparms <= %20000) then
fail (1); ! maxparms not in range
xreg := @parms'd + (maxparms & asl(1)) - 1;
if parmcount.(14:1) then
begin <<extract command>>
tos := @pntr;
assemble (dup, dup);
@command := tos;
move * := * while ans, 0;
@pntr := tos;
length := tos - @command;
if parmcount then
tos := search (command, length, dict, defn)
else
tos := search (command, length, dict);
if (mycommand := tos) = 0 then
go exit'ccl;
end
else
mycommand := 0;
if not (parmcount.(10:1)) then
@delimiters := @default'delims;
<<format parameters...>>
xreg := 0;
nextparm:
scan pntr while crblank, 1;
assemble (dup, dup);
@pntr := tos;
start := tos;
tos := 0;
go scanalphnum;
doblank:
scan pntr while crblank, 1;
@pntr := tos;
if < then
go checkfunny;
dospecial:
tos := tos lor %40;
scanalphnum:
tos := pntr;
assemble (del);
if = then
begin <<alphabetic>>
alph:
tos := tos lor %200;
tos := @pntr;
assemble (dup);
move * := * while as, 1;
@pntr := tos;
end;
if > then ! SPLash! problem here at ">"
begin <<numeric>>
tos := tos lor %100;
tos := @pntr;
assemble (dup);
move * := * while n, 1;
@pntr := tos;
end;
if = then
go alph;
endx := @pntr;
! possibilities now:
! 1. a delimeter,
! 2. a blanks-field within parameter,
! 3. a blanks-field just before delimeter, or
! 4. a special character that's part of parameter.
checkfunny:
scan delimiters until (%6400 lor logical(pntr)), 1;
if carry then
begin
! 1. character is cr,
! 2. character is special or blank.
tos := pntr;
if s0 <> %15 then
begin
assemble (delb);
@pntr := @pntr + 1;
if tos = " " then
go doblank;
go dospecial;
end;
lastflag := tos;
tos := xreg;
tos := lims;
tos := @pntr & lsr (1);
assemble (ddup, cmp);
if < then tos.(00:01) := 1;
xreg := tos;
if not (tos <= xreg <= tos) then !rrorexit (mycommandhang, 6, 1);
fail (2);
xreg := tos;
end;
<< a delimiter found >>
tos := tos - @delimiters; ! delimiter position in <delimiters>.
if logical (s0) > 31 then !rrorexit (mycommandhang, 6, 2);
fail (3);
tos := endx - start; ! parameter length
<<special case: no parameters in image>>
if = and lastflag and xreg = 0 then
go exit'cce;
if logical (s0) > 255 then !rrorexit (mycommandhang, 20, 1);
fail (4);
tos := tos lor (tos lor (tos & lsl(8)));
if xreg >= maxparms then
begin
ddel;
go exit'ccg;
end;
parms'd (xreg) := tos;
xreg := xreg + 1;
@pntr := @pntr + 1;
if not (lastflag) then
go nextparm;
exit'cce:
cc := cce;
if false then
exit'ccl:
cc := ccl;
if false then
exit'ccg:
cc := ccg;
if parmcount.(12:01) then
numparms := xreg;
push (s);
new's := tos;
if new's <> save's and numparms > 0 then
begin
print (buf, - move buf' := "Stack-error: old S = ", %320);
ascii (save's, 8, buf');
print (buf, -6, %320);
print (buf, - move buf' := ", new S = ", %320);
ascii (new's, 8, buf');
print (buf, -6, 0);
fail (-1);
end;
end <<mycommand proc>>;
LOADPROC Intrinsic
! loadproc.inc 88/12/07
integer procedure loadproc'nm (procname, library, plabel);
value library;
integer library;
double plabel;
byte array procname; ! terminated by a special char
! note: mapping of library (0,1,2,3,4) to xl:
! 0 nl.pub.sys
! 1,2,3,4 first xl loaded with
!
! return value: 0 = ok, non-0 = failure
! note that this differs from mpe v's loadproc result!
begin
equate
max'len = 63;
double
original'case := 0d,
status := 0d;
integer
len := 0,
status'1 = status,
status'2 = status + 1;
logical
my'status'reg = q-1;
byte array
buf' (0 : max'len + 2),
firstfile' (0 : 29);
byte
term'char;
virtual byte pointer
ptr'firstfile',
ptr'procname';
define
my'cc = my'status'reg.(06:02) #;
label
end'proc;
Procedure hpgetprocplabel (a, b, c, d, e);
byte array a, d;
double b, c, e;
option native, variable, external, uppercase, intrinsic,
extensible, nocc;
Procedure hpfirstlibrary (a, b, c);
byte array a;
double b, c;
option native, variable, external, uppercase, extensible,
intrinsic, nocc;
<<------------------------->>
subroutine fail (n);
value n;
integer n;
begin
loadproc'nm := n; ! error result
go end'proc;
end <<fail sub>>;
<<------------------------>>
loadproc'nm := 999; ! unknown error
plabel := 0d;
my'cc := 1; ! ccl
! handle old and new style procedure names...
if procname = alpha or procname = "_" then
begin ! old style, 1 terminator at end.
! we need to determine length of proc name, and then
! copy into a local buffer...
len := 0;
while (len <= max'len) and
((procname (len) <> special) lor (procname (len) = "_") ) do
len := len + 1;
if len > max'len then
fail (-502); ! "entry name too long"
move buf'(1) := procname, (len);
buf' := " "; ! leading terminator
buf'(len + 1) := " "; ! trailing terminator
! remember where local buffer is...
@ptr'procname' := virtual (@buf');
end
else ! new style (term at start & end)
begin
! use caller's buffer...
@ptr'procname' := virtual (@procname);
end;
! determine if we need to lookup a library name...
if library = 0 then
@ptr'firstfile' := 0d
else
begin
hpfirstlibrary (firstfile', status);
if status <> 0d then
fail (-123); ! "invalid HPFIRSTLIBRARY"
@ptr'firstfile' := virtual(@firstfile');
end;
original'case := 0d;
hpgetprocplabel (ptr'procname', plabel, status, ptr'firstfile',
original'case);
if status <> 0d then
loadproc'nm := \status'1\ ! return top word
else
begin
my'cc := 2; ! cce .. ok!
loadproc'nm := 0; ! no error
end;
end'proc:
end <<loadproc'nm proc>>;
Chapter 1, Introduction,
describes SPLash! at
a high level. It also lists relevant Hewlett Packard publications
that you may want to review as companions to this document.
Top of Stack references.
