Systems Programming Language
| Company type | Programming language |
|---|---|
| Industry | Computer programming |
| Founded | 1972 |
| Founder | Hewlett-Packard |
| Products | SPL, ZSPL, Micro-SPL |
Systems Programming Language, commonly abbreviated as SPL or SPL/3000, is a procedural programming language created by Hewlett-Packard specifically for the HP 3000 minicomputer series, first introduced in 1972. This language was instrumental in developing the HP 3000's core operating system, the Multi-Programming Executive (MPE). The term "system programming language" was also used generically for similar languages on other platforms, which sometimes caused confusion.
Initially called Alpha Systems Programming Language after the development project for the 3000 series, SPL was tailored to exploit the stack-oriented processor design of the Alpha architecture. Its foundation was the ESPOL, an ALGOL-based language utilized in Burroughs B5000 mainframe computers, which had influenced several programming languages from the 1960s era, including PL360 and JOVIAL.
During the mid-1970s, SPL gave rise to several variants such as ZSPL for the Zilog Z80 CPU and Micro-SPL designed for the Xerox Alto. The latter played a role in inspiring Action!, developed for Atari 8-bit computers, which adopted a Pascal-like syntax to streamline some of SPL’s distinctive constructs.
SPL enjoyed widespread use throughout the original 16-bit HP 3000 generation. However, in the 1980s, when HP reimplemented the HP 3000 and MPE on PA-RISC-based HP 9000 hardware through emulation, Pascal became HP’s recommended system programming language, and no official SPL compiler was provided. This shift created challenges in maintaining legacy SPL codebases, which were later mitigated by third-party SPL compiler solutions.
History
Hewlett-Packard introduced its initial line of minicomputers with the HP 2100 series in 1967, primarily aimed at industrial embedded control applications. The attractive cost-to-performance ratio soon allowed it to penetrate business computing markets.
In 1968, HP released the HP 2000 system, comprising two interconnected 2100-series units running HP Time-Shared BASIC, an environment combining an operating system with BASIC programming capabilities. The success of this system influenced many early microcomputer BASIC implementations.
Seeing opportunities beyond existing hardware platforms, HP assembled a larger design team in 1968 to develop a new mid-range architecture. This effort incorporated knowledge from both Burroughs and IBM, adopting a stack machine architecture inspired by Burroughs B5000 to facilitate multiprogramming.
Two architectural proposals were evaluated: a 32-bit "Omega" mainframe and a 16-bit "Alpha" system. After canceling Omega in 1970, development concentrated on Alpha, aiming to create an advanced OS supporting batch processing, interactive use, and real-time tasks—an evolution from prior multi-machine configurations.
The Alpha architecture demanded a sophisticated bus design featuring extensive direct memory access (DMA) capabilities alongside an operating system engineered for rapid user interaction. Taking inspiration from B5000’s high-level language OS implemented in ESPOL (an ALGOL derivative), HP developed its own ALGOL-based language initially named Alpha Systems Programming Language—later known simply as SPL.
Following several years of development, Alpha debuted as the HP 3000 in 1972 but encountered early reliability problems that necessitated a product recall. A subsequent release in late 1973 incorporated enhanced hardware and the MPE-C operating system, restoring customer confidence and enabling strong sales throughout the late 1970s.
SPL’s adoption matched that of HP BASIC from earlier product lines and spawned derivatives such as Micro-SPL for Xerox Alto workstations. Frustration with BCPL on Alto led Henry Baker and Clinton Parker to create Micro-SPL in 1979; Parker subsequently evolved it into Action! for Atari platforms in 1983.
When HP transitioned the HP 3000 series to PA-RISC processors running MPE/iX, native software required recompilation using Pascal compilers since no official SPL compiler was supplied by HP. To facilitate this migration, Allegro Consultants developed "SPLash!", an SPL-compatible compiler that generated code executable both within the emulator environment and natively on PA-RISC systems.
Fundamental Syntax
SPL adopts syntax conventions largely inspired by ALGOL 60, making it familiar to programmers experienced with ALGOL derivatives such as Pascal and Modula-2. Statements may extend over several lines and must conclude with a semicolon. Comments are introduced either by the keyword or enclosed within << and >> delimiters.
Code blocks are encapsulated using BEGIN and END; a program terminates with an END followed by a period. Unlike Pascal, SPL does not employ a PROGRAM keyword, which permits any code segment to function as an independent program or be compiled as a library module. This behavior is governed by the compiler directive placed at the beginning of the source file.
The keyword streamlines the declaration of external procedures by removing the need for explicit parameter lists. This mechanism facilitates access to system-level services such as file operations and communication interfaces, while also allowing users to extend the list with their own procedures. This method resembles but refines the inclusion approach found in C’s #include.
In contrast to Pascal’s distinct variable and procedure sections, SPL uses a C-style approach where any identifier preceded by a type specifier is treated as a function. Parameter types follow the parameter names; for example:
INTEGER PROCEDURE FACT(N); VALUE N; INTEGER N;
Here, FACT is declared as an integer-returning function accepting an integer N passed by value. The function’s return value is assigned directly to its name:
FACT := expression;
Labels used in loops and statements must be declared beforehand using the keyword. Additionally, SPL introduces the statement, which exposes labels as callable "entry points" from the command line (e.g., ), enabling modular construction of command-line utilities within programs.
Data Types
SPL’s data types are tailored to the HP 3000 architecture, which employs a 16-bit big-endian word format.
The INTEGER type represents a signed 16-bit integer with one sign bit and fifteen bits for value. The DOUBLE type is a 32-bit integer rather than floating-point. The REAL type is a 32-bit floating-point number featuring 22 mantissa bits and 9 exponent bits, while LONG denotes 64-bit floating-point numbers with a 54-bit mantissa and 9-bit exponent.
For character handling, BYTE is defined as a 16-bit word containing an 8-bit character in its lower byte; arrays of BYTE pack two characters per word. The LOGICAL type is an unsigned 16-bit integer used primarily in conditional expressions, evaluating to true if its least significant bit equals one. It supports unsigned arithmetic operations where overflow is ignored. Unlike Pascal’s PACKED bit fields, LOGICAL consumes more memory when storing single bits, though SPL provides alternative bit string manipulation capabilities.
SPL employs weak typing similar to C, permitting mixing of variable storage with direct memory addressing. Variables can be accessed through explicit memory locations, offering flexibility suited for systems programming. For instance:
INTEGER A,B,C LOGICAL D=A+2
declares three INTEGER variables alongside a LOGICAL D that references the same memory location as C (offset A+2), allowing the same data to be interpreted under different types.
This design aids in defining variables that point to table entries so that updating a base address automatically adjusts related pointers accordingly.
Pointer declarations involve appending the POINTER modifier; dereferencing is performed using the @ symbol. For example, INTEGER POINTER P:=@A declares P as a pointer storing A’s address. Assignments involving '@' differentiate between assigning addresses or values, enabling precise control over memory management.
Arrays in SPL resemble those in C but use parentheses for indexing instead of brackets and support one-dimensional arrays indexed by word offsets. Variables can be marked as GLOBAL, indicating external linkage similar to C's extern keyword.
Literals default to INTEGER unless suffixed: D indicates DOUBLE, E specifies REAL, and L denotes LONG literals. String literals are enclosed in double quotes, with internal quotation marks escaped by doubling them.
Variable declarations may include initializations, such as INTEGER A:=10. Compile-time textual substitutions are defined using the EQUATE keyword, functioning similarly to C’s const.
Memory segmentation
The HP 3000 structured its physical memory into banks of 64K (65,536) 16-bit words (equivalent to 128K bytes), configurable as 1, 2, 4, 8, or 16 such banks. Code segments, which were shared and immutable, and data segments were stored separately, each segment having a variable length up to 32K words. Within a process, data addresses functioned as 16-bit offsets relative to a base register (DB) or as relative offsets from pointer registers (Q or S) located within the process's data area, commonly referred to as the stack. Although the architecture was primarily word-oriented, it supported byte-level addressing by manipulating the word address and adding either 0 or 1 to select the lower or upper byte. This differentiation between byte and word addressing frequently led to bugs in both system and application code, necessitating careful treatment of byte addresses as unsigned values to prevent errors in calculating lengths or offsets.
Each process had the capability to access as many as 254 code segments, each with a maximum size of 32K words. These segments were categorized into 191 "system" segments shared universally among all processes and 63 "user" segments shared among all instances executing the same program. Control transfers could specify either a routine number within the current segment or an external segment number combined with a routine number; entry points were maintained in a small table located at the end of each segment.
A process’s executable code operated on data contained within a private stack segment that could be up to 32K words in size. Unlike conventional stacks, this stack stored global variables, preserved state information, procedure-local variables supporting nested and reentrant calls, and numeric computations. The operating system also allowed access to additional memory-resident data segments beyond the stack; however, these segments required explicit data transfer operations since they were not directly addressable by instructions.
To simplify segmentation management and abstract it from programmers, SPL provided support utilities. The primary mechanism was a compiler directive used to declare which segment subsequent code belonged to. By default, code was assigned to the main segment, but developers could define multiple named segments for better organization of their code.
Other features
SPL incorporated a "bit-extraction" capability designed to streamline bit-level manipulation within words. Any single bit or contiguous range of bits inside a word could be accessed using syntax of the form , where x and y are compile-time constants ranging from 0 to 15; for instance, would extract the lower byte of A. This feature enabled efficient splitting and combining of bits. Additional operations included shifts and rotations applied using notation such as , which enhanced low-level data processing flexibility.
Example
The following example from the 1984 SPL reference manual illustrates fundamental aspects of SPL programming.
The program is wrapped between the keywords and . It declares global variables A, B, and C; defines one procedure; and invokes this procedure twenty times. The procedure itself does not include its own BEGIN and END statements because it consists of a single assignment statement: . The line specifying parameter types is considered part of the procedure’s declaration rather than executable instructions.
BEGIN
INTEGER A:=0, B, C:=1;
PROCEDURE N(X,Y,Z);
INTEGER X,Y,Z;
X:=X*(Y+Z);
FOR B:=1 UNTIL 20 DO
N(A,B,C);
END.