HP 3000 SPL software Reference manual

PDF

ドキュメント

Table of Contents

Systems Programming Language Reference Manual

Systems Programming Language Reference Manual : COPYRIGHT NOTICE

SPL STRUCTURE

1-2. CONVENTIONS

1-3. SOURCE PROGRAM FORMAT

1-4. DELIMITERS

1-5. COMMENTS

1-6. PROGRAM STRUCTURE

1-7. PROGRAM

1-8. SUBPROGRAM

1-9. INTRODUCTION TO HP 3000 HARDWARE CONCEPTS

1-10. CODE SEGMENTS

1-11. DATA SEGMENTS

1-12. PROCEDURES

1-13. SUBROUTINES

1-14. INTRINSICS

1-15. COMPOUND STATEMENTS

1-16. ENTRY POINTS

BASIC ELEMENTS

2-2. INTEGER FORMAT

2-3. DOUBLE INTEGER FORMAT

2-4. REAL FORMAT

2-5. LONG FORMAT*

2-6. BYTE FORMAT

2-7. LOGICAL FORMAT

2-8. CONSTANT TYPES

2-9. INTEGER CONSTANTS

2-10. DOUBLE INTEGER CONSTANTS

2-11. BASED CONSTANTS

2-12. COMPOSITE CONSTANTS

2-13. EQUATED INTEGERS

2-14. REAL CONSTANTS

2-15. LONG CONSTANTS

2-16. LOGICAL CONSTANTS

2-17. STRING CONSTANTS

2-18. IDENTIFIERS

2-19. ARRAYS

2-20. POINTERS

2-21. LABELS

2-22. SWITCHES

GLOBAL DATA DECLARATIONS

3-2. SIMPLE VARIABLE DECLARATIONS

3-3. ARRAY DECLARATION

3-4. POINTER DECLARATION

3-5. LABEL DECLARATION

3-6. SWITCH DECLARATION

3-7. ENTRY DECLARATION

3-8. DEFINE DECLARATION AND REFERENCE

3-9. EQUATE DECLARATION AND REFERENCE

3-10. DATASEG DECLARATION

EXPRESSIONS, ASSIGNMENT, AND SCAN STATEMENTS

4-2. VARIABLES

4-3. TOS

4-4. ADDRESSES (@) AND POINTERS

4-5. ABSOLUTE ADDRESSES

4-6. FUNCTION DESIGNATOR

4-7. BIT OPERATIONS

4-8. BIT EXTRACTION

4-9. Bit Concatenation (Merging)

4-10. BIT SHIFTS

4-11. ARITHMETIC EXPRESSIONS

4-12. SEQUENCE OF OPERATIONS

4-14. LOGICAL EXPRESSIONS

4-15. SEQUENCE OF OPERATIONS

4-16. TYPE MIXING

4-17. COMPARING BYTE STRINGS

4-18. CONDITION CLAUSES

4-19. IF EXPRESSIONS

4-20. ASSIGNMENT STATEMENT

4-21. MOVE STATEMENT

4-21A. MOVEX STATEMENT

4-22. SCAN STATEMENT

PROGRAM CONTROL STATEMENTS

5-2. GO TO STATEMENT

5-3. DO STATEMENT

5-4. WHILE STATEMENT

5-5. FOR STATEMENT

5-6. IF STATEMENT

5-7. CASE STATEMENT

5-8. PROCEDURE CALL STATEMENT

5-9. STACKING PARAMETERS

5-10. MISSING PARAMETERS IN PROCEDURE CALLS

5-11. PASSING LABELS AS PARAMETERS

5-12. PASSING PROCEDURES AS PARAMETERS

5-13. SUBROUTINE CALL STATEMENT

5-14. RETURN STATEMENT

MACHINE LEVEL CONSTRUCTS

6-2. DELETE STATEMENT

6-3. PUSH STATEMENT

6-4. SET STATEMENT

6-5. WITH STATEMENT

PROCEDURES, INTRINSICS, AND SUBROUTINES

7-2. PROCEDURE DECLARATION

7-3. DATA TYPE

7-4. PARAMETERS

7-5. OPTIONS

7-14. LOCAL DECLARATIONS

7-16. LOCAL SIMPLE VARIABLE DECLARATIONS

7-20. LOCAL ARRAY DECLARATIONS

7-24. LOCAL POINTER DECLARATIONS

7-28. LABEL DECLARATIONS

7-29. SWITCH DECLARATIONS

7-30. ENTRY DECLARATION

7-31. DEFINE DECLARATION AND REFERENCE

7-32. EQUATE DECLARATION AND REFERENCE

7-33. PROCEDURE BODY

7-34. INTRINSIC DECLARATIONS

7-35. SUBROUTINE DECLARATION

INPUT OUTPUT

8-2. OPENING A NEW DISC FILE

8-3. READING A FILE IN SEQUENTIAL ORDER

8-4. WRITING RECORDS INTO A FILE IN SEQUENTIAL ORDER

8-5. UPDATING A FILE

8-6. NUMERIC DATA INPUT OUTPUT

8-7. FILE EQUATIONS

COMPILER COMMANDS

9-1. USE AND FORMAT OF COMPILER COMMANDS

9-2. $CONTROL COMMAND

9-3. $IF COMMAND (CONDITIONAL COMPILATION)

9-4. $SET COMMAND (SOFTWARE SWITCHES FOR CONDITIONAL COMPILATION)

9-5. $TITLE COMMAND (PAGE TITLE IN STANDARD LISTING)

9-6. $PAGE COMMAND (PAGE TITLE AND EJECTION)

9-7. $EDIT COMMAND (SOURCE TEXT MERGING AND EDITING)

9-9. CHECKING SEQUENCE FIELDS

9-10. EDITING

9-11. $SPLIT $NOSPLIT COMMANDS

9-12. $COPYRIGHT COMMAND

9-14. $INCLUDE COMMAND

MPE COMMANDS

10-2. SPECIFYING FILES FOR PROGRAMS

10-3. SPECIFYING FILES AS COMMAND PARAMETERS

10-9. SPECIFYING FILES BY DEFAULT

10-10. COMPILING, PREPARING, AND EXECUTING SPL SOURCE PROGRAMS

10-11. :SPL COMMAND

10-12. RUN SPL.PUB.SYS COMMAND

10-13. ENTERING PROGRAM SOURCE INTERACTIVELY

10-14. :SPLPREP COMMAND

10-15. :SPLGO COMMAND

10-16. :PREP COMMAND

10-17. :PREPRUN COMMAND

10-18. :RUN COMMAND

10-19. USING EXTERNAL PROCEDURE LIBRARIES

10-22. SEGMENTED LIBRARIES

ASCII CHARACTER SET

RESERVED WORDS

BUILDING AN INTRINSIC FILE

MPE INTRINSICS

COMPILER ERROR MESSAGES

CALLING SPL FROM OTHER LANGUAGES

Systems Programming Language Reference Manual

Printed in U.S.A.

HP Part No. 30000-90024

Printed Feb 1084

The information contained in this document is subject to change without notice.

HEWLETT-PACKARD 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. Hewlett-Packard 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.

Hewlett-Packard assumes no responsibility for the use or reliability of its software on equipment that is not furnished by Hewlett-Packard.

This document contains proprietary information which is protected by copyright. All rights are reserved. No part of this document may be photocopied, reproduced or translated to another language without the prior written consent of Hewlett-Packard Company.

Ó 1976-1984

PRINTING HISTORY

New editions are complete revisions of the manual. Update packages, which are issued between editions, contain additional and replacement pages to be merged into the manual by the customer. The dates on the title page change only when a new edition or a new update is published.

No information is incorporated into a reprinting unless it appears as a prior update; the edition does not change when an update is incorporated.

The software code printed alongside the data indicates the version level of the software product at the time the manual or update was issued.

Many product updates and fixes do not require manual changes and, conversely, manual corrections may be done without accompanying product changes. Therefore, do not expect a one-to-one correspondence between product updates and manual updates.

First Edition | Jun 1976 |

Second Edition | Sep 1976 |

Update #1 Incorporated | Dec 1976 |

Update #2 | Feb 1977 |

Update #2 Incorporated | Dec 1977 |

Third Edition | Feb 1984 | 32100A.08.04

PREFACE

This publication is the reference manual for the HP 3000 Computer System

Systems Programming Language (SPL).

This publication contains the following sections:

Section I is an introduction to SPL source format and the HP 3000

Computer System.

identifiers, arrays, and pointers.

Section III describes the global declarations.

Section IV describes arithmetic and logical expressions, assignment, MOVE, and SCAN statements.

Section V describes the various program control statements including GO TO, DO, WHILE, FOR, IF, CASE, procedure call, subroutine call, and RETURN statements.

Section VI describes the machine level constructs including the

ASSEMBLE statement (to use any machine instruction), the

DELETE statement, the PUSH statement (for saving registers), and the SET statement (for setting registers).

Section VII describes the subprogram units (procedures, intrinsics, and subroutines) and the local declarations.

Section VIII discusses some of the more common MPE intrinsics for performing input/ output.

Section IX discusses the various compiler commands.

Section X discusses the MPE commands used to compile, prepare, and execute an SPL source program together with some introductory material on using the Segmenter.

Appendix A lists the ASCII character set.

Appendix B lists the reserved words in SPL.

Appendix C describes how to build your own intrinsic file.

Appendix D lists the MPE Operating System intrinsic procedures.

Appendix E lists the diagnostic messages which can be generated by the SPL compiler.

Appendix F explains how to call SPL from other languages.

Other publications which should be available for reference when using this manual are:

Systems Programming Language Textbook (30000-90025)

MPE Commands Reference Manual (30000-90009)

MPE Intrinsics Reference Manual (30000-90010)

MPE Segmenter Reference Manual (30000-90011)

Machine Instruction Set Reference Manual (30000-90022)

System Reference Manual (30000-90020)

Compiler Library Reference Manual (30000-90028)

EDIT/3000 Reference Manual (03000-90012)

CONVENTIONS USED IN THIS MANUAL

NOTATION DESCRIPTION

contain no blanks and be delimited by a non-alphabetic character (usually a blank).

KEYWORDS Literal keywords, which are entered optionally but exactly as specified, appear in CAPITAL LETTERS.

parameter Required parameters, for which you must substitute a value, appear in bold italics.

parameter Optional parameters, for which you may substitute a value, appear in standard italics.

[ ] An element inside brackets is optional. Several elements stacked inside a pair of brackets means the user may select any one or none of these elements.

Example: [ A ]

[ B ] user may select A or B or neither.

When brackets are nested, parameters in inner brackets can only be specified if parameters in outer brackets or comma place-holders are specified.

Example: [parm1[,parm2[,parm3] ] ] may be entered as parm1,parm2,parm3 or parm1,,parm3 or

,,parm3 ,etc.

{ } When several elements are stacked within braces the user must select one of these elements.

Example: { A }

{ B } user must select A or B or C.

{ C }

... An ellipsis indicates that a previous bracketed element may be repeated, or that elements have been omitted.

user input In examples of interactive dialog, user input is underlined.

Example: NEW NAME? ALPHA1 superscriptc Control characters are indicated by a superscriptc.

Example: Yc. (Press Y and the CNTL key simultaneously.)

[[RETURN]] [[RETURN]] indicates the carriage return key.

Chapter 1 SPL STRUCTURE

1-1. INTRODUCTION TO SPL

SPL (Systems Programming Language for the HP 3000 Computer System) is a high-level, machine dependent programming language that is particularly well suited for the development of compilers, operating systems, subsystems, monitors, supervisors, etc.

SPL has many features normally found only in high-level languages such as

PL/I or ALGOL: free-form structure, arithmetic and logical expressions, high-level statements (IF, FOR, GOTO, CASE, DO- UNTIL, WHILE-DO, MOVE,

SCAN, procedure call, assignment, and compound statements), recursive procedures and subroutines, and variables and arrays of six data types

(byte, integer, logical, double integer, real, and long real). In addition, IF, FOR, CASE, DO-UNTIL, and WHILE-DO statements can be indefinitely nested within each other and themselves. These features significantly reduce the time required to write programs and make them much easier to read and update.

In addition, SPL provides machine-level constructs that insure the programmer has complete control of the machine when he needs it. These constructs include direct register references; branches based on actual hardware conditions; bit extracts, deposits, and shifts; delete statements; register push/set statements; and an ASSEMBLE statement to generate any sequence of machine instructions.

1-2. CONVENTIONS

In the HP 3000, the bits of a word are numbered from left to right starting with bit 0. Thus, the sign, or most significant, bit of a single word is bit 0 and the least significant bit is bit 15.

------------------------------------------------------------------------------------

| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 1

------------------------------------------------------------------------------------

1-3. SOURCE PROGRAM FORMAT

An SPL source program can contain both program text and compiler commands in 80 column records. Program text is entered in free format in columns

1-72. A statement is terminated with a semicolon (;) and may continue to successive lines without an explicit continuation indicator. Statement labels are identifiers followed by a colon (:) preceding the statement.

For example,

START: SCAN BUF WHILE TEST;

Any compilation is bracketed by BEGIN and END statements. A period is required after the final END. For example,

BEGIN

INTEGER I;

I:= 2*373+ 275;

END.

Compiler commands are denoted by a $ in column 1 and may be interspersed with program text lines. However, unlike program text lines, compiler commands which are to be continued must contain an ampersand (&) as the last non-blank character of the line. If using EDIT/3000 to enter text, you must explicitly enter a space following the ampersand and before pressing return. In addition, the continuation lines must contain a $ in column 1. For example,

$CONTROL LIST,SOURCE,WARN,MAP,&

$CODE,LlNES= 36

A compiler command line must never be separated from its continuation line by a program text line. Refer to section IX for a discussion of all the SPL compiler commands.

1-4. DELIMITERS

Blanks are always recognized as delimiters in SPL, except within character strings (see paragraph 2-17 for the format of string constants). Therefore, blanks cannot be embedded in the following items:

Reserved words (see Appendix B).

Identifiers

:= assignment

<< start of a comment

>> end of a comment

Special characters can also act as delimiters:

Punctuation : ; , . "

Relational Operators = < >

Parentheses ()

Operators + -* /^

Brackets [ ]

1-5. COMMENTS

A comment is used to document a program but has no effect upon the functioning of the program itself; that is, a comment does not generate any code.

Comments may take either of the following forms in SPL:

Format 1: COMMENT[comment];

Format 2: <<[comment]>>

EXAMPLES:

<<comment>>

COMMENT CONTROL: MESSAGE;

<<This is a comment >>

!This is a comment

COMMENT

THIS

COMMENT

; where comment is any sequence of ASCII characters except a semicolon in Format 1 and >> in Format 2. The ASCII character set is listed in Appendix A.

Format 1 is equivalent to a null statement and can be used anywhere a statement or declaration is expected. Format 2 can be used anywhere in a program except in an identifier.

The characters within a comment are ignored by the compiler; they are not upshifted (changed to uppercase) if lowercase,

When the special character '!' is encountered outside a comment, define, or string, the rest of the source line following the exclamation point will be regarded as a comment.

1-6. PROGRAM STRUCTURE

SPL is a block structured language which takes advantage of the virtual memory scheme of the HP 3000 to provide program segmentation its a user option. Thus, by using procedures and segmentation, the programmer can organize his program in such that the entire program does not have to reside in memory at the same time. The system automatically gets procedure segments from auxiliary memory and loads them into main memory when necessary.

Additionally, SPL uses the stack architecture of the HP 3000 to handle both global and local variables. Global variables may be referenced anywhere in the program except in procedures where a local variable has the same identifier. Local variables are allocated memory locations upon entering a procedure and can only be referenced within the procedure in which they are declared. The memory locations assigned to local variables are released when the procedure is exited. When one procedure calls another procedure, the local variables of the calling procedure are not available to the called procedure unless they are passed as parameters; however, their memory locations are saved so that upon returning to the original procedure, the local variables contain the same values as before the procedure call.

Similarly, both global and local subroutines are allowed in SPL. However, unlike global variables, global subroutines can only be called within the main program and not within a procedure. Local subroutines may be called only within the procedure in which they are declared.

The SPL compiler accepts either complete programs or subprograms as source input. A program consists of both declarations and a main body of executable statements. The declaration portion may contain variable, procedure, intrinsic, and/or global subroutine declarations.

A subprogram consists of only the declaration portion and does not contain a main body. In a subprogram compilation, global declarations

(that is, declarations for variables which can be referenced throughout the entire program) do not allocate any space and global subroutines are

ignored if present.

A subprogram compilation generates code for procedures and local subroutines only and must be linked to a separately compiled main program before being executed. For example,

BEGIN

INTEGER A; <<global data declaration>> <--------------

PROCEDURE B(A); |

INTEGER A; <<procedure declaration>> |

A:= A+1 main progra

SUBROUTINE C(A); |

INTEGER A; <<global subroutine declaration>>

A:= B(A): <--------------

C(A); <<main body>>

END.

1-7. PROGRAM

A program is an organized collection of declarations and statements designed to solve a specific problem. A main program consists of global data declarations and subroutines and a main body.

The form for a program is:

BEGIN

[global data declarations]

[procedures/intrinsics]

[global-subroutines]

[main-body]

END.

where global data are statements defining the attributes of the global declarations identifiers used in the program (see section III).

procedures/ are statements which define all the procedures and intrinsics intrinsics used in the program (see section VII). A procedure definition includes data declarations for parameters and local variables followed by the executable statements of the procedure.

globalsubroutines are the subroutines used by the main program.

main-body is a sequence of statements separated by semicolons statement [;...;statement] statement is an executable statement.

The program elements must be in the order shown above.

For example,

BEGIN

INTEGER A:= 0,B,C:=1; <<global data declaration>>

PROCEDURE N(X,Y,Z); <<procedure>>

INTEGER X,Y,Z; <<local data declaration>>

X:= X* (Y+ Z);

FOR B:=1 UNTIL 20 DO <<main program>>

N(A,B,C);

END.

1-8. SUBPROGRAM

A subprogram is a portion of a program which can be compiled by itself but must be linked to a main program for execution. A $CONTROL

SUBPROGRAM compiler command is used before the subprogram text to put the compiler in subprogram mode. See section IX for the compiler commands used to link a subprogram to a main program for execution.

The form of a subprogram is the same as a program except that a subprogram does not have a main body.

The form for a subprogram is:

BEGIN

[global data declarations]

[procedures/intrinsics]

[global-subroutines]

END.

where global data are statements defining the attributes of the global declarations identifiers used in the program (see section III).

procedures/ are statements which define all the procedures and intrinsics intrinsics used in the program (see section VII). A procedure definition includes data declarations for the parameters and local variables followed by the executable statements of the procedure.

globalare the subroutines used by the main program. The subroutines global-subroutines can be omitted since the compiler ignores them in subprogram compilations.

For example,

$CONTROL SUBPROGRAM

BEGIN

INTEGER N,M,O; <<does not allocate space>>

EQUATE A:=101, B:=202;

PROCEDURE C;

BEGIN

END;

PROCEDURE D;

BEGIN

END;

END.

1-9. INTRODUCTION TO HP 3000 HARDWARE CONCEPTS

A process is the unique execution of a program. If the same program is run by several users, it becomes several processes. If the same user runs the program several times, each execution is a distinct process. A process consists of a code domain (the machine instructions of the program) and a data area called a "stack." The code and data in the HP

3000 are always separated logically. The code may always be shared, but the data stack cannot. The MPE Operating System schedules and dispatches a process for execution. See the MPE General Information Manual for a further discussion of processes and the stack.

1-10. CODE SEGMENTS

All machine instructions within the HP 3000 are organized into variable length segments accessed through a hardware-known table called the Code

Segment Table (CST). Since the hardware detects references to segments which are not in main memory, the code domain of a process is not limited to the size of main memory. Segments are brought from disc into main memory as needed. A process can execute only one code segment at a time.

The process "escapes" from its current code segment by executing a

Procedure Call (PCAL) instruction. A PCAL can reference procedures in different code segments from the current one and cause control to be transferred to a different code segment. A PCAL instruction is generated by either a function designator (see paragraph 4-6) or a procedure call statement (see paragraph 5-8).

The current code segment of a process is defined by three hardware address registers:

1. PB--Program Base register. Contains the absolute address of the starting location of the segment in main memory.

2. PL--Program Limit register. Contains the absolute address of the last location of the code segment.

3. P--Program counter. Contains the absolute address of the instruction currently being executed.

The relationship of the three current code segment registers is shown in

Figure 1.1. The central processor checks all instructions to insure that they stay within the bounds of the current code segment. All addresses within a current code segment are relative to these registers. The operating system can relocate the segment anywhere in main memory; only the three registers have to be changed to define the segment's locations.

BOX

Figure 1.1. Code Segment Registers

Code segmentation is controlled by using the SEGMENT parameter on

$CONTROL commands (see section IX). The segment name stays in effect until another segment name is specified. For procedures, the $CONTROL

SEGMENT command must precede the procedure declaration of the first procedure in the segment. If a new segment is to be specified for the main program, the $CONTROL SEGMENT command follows the procedure and intrinsic declarations and precedes the global subroutines and main body.

Global subroutines must be in the same segment as the main body. See

Figure 1.2 for a sample SPL program which has two procedures in one segment and a global subroutine with the main body in another.

BOX

00000 0 $CONTROL USLINIT,MAIN=MAINLINE

00000 0 BEGIN

00000 1 INTEGER LENGTH,TIME;

00000 1 ARRAY BUFFER(0:35);

00000 1 INTRINSIC PRINT,READ;

00000 1

00000 1 $CONTROL SEGMENT=PROC'A'SEG

00000 1 PROCEDURE PROC'A(LEN);

00000 1 VALUE LEN;

00000 1 INTEGER LEN;

00000 1 PRINT (BUFFER,=LEN,0);

00000 1

00000 1 PROCEDURE PROC'B(LEN);

00000 1 VALUE LEN;

00000 1 PRINT(BUFFER,=LEN%320);

00000 1

00000 1 $CONTROL SEGMENT=MAINLINESEG

00000 1

00000 1 SUBROUTINE READ'A'LINE;

00000 1 LENGTH:=READ(BUFFER,- 72);

00006 1

00006 1 << START OF MAINLINE >>

00006 1

00006 1 LOOP:

00006 1

00006 1 READ'A'LINE;

00010 1 IF LENGTH <> 0 THEN

00013 1 BEGIN

00013 2 IF ((TIME:=TIME+1) MOD 2)=0 THEN PROC'A(LENGTH)

00022 2 ELSE PROC'B(LENGTH);

00026 2 GO TO LOOP:

00027 2 END;

00027 1 END.

MAINLINESEG 0

NAME STT CODE ENTRY SEG

MAINLINE 1 0 6

READ 2 ?

PROC'A 3 1

PROC'B 4 1

TERMINATE' 5 ?

SEGMENT LENGTH 40

PROC'A'SEG 1

NAME STT CODE ENTRY SEG

PROC'B 1 0 0

PRINT 3 ?

PROC'A 2 6 6

SEGMENT LENGTH 20

Figure 1.2. Sample Segmented Program

1-11. DATA SEGMENTS

Each process has a completely private storage area for its data. This storage area is called a stack or a data segment. When the process is executing, its stack must be in main memory. A stack is delimited by two stack addressing registers:

1. DL--Data Limit register. Contains the absolute address of the first word of main memory available in the stack.

2. Z--Stack limit register. Contains the absolute address of the last word of main memory available in the stack.

Between DL and Z, there are separate and distinct areas set off by three other stack addressing registers:

1. DB--Data Base register. Contains the absolute address of the first location of the direct address global area of the stack.

2. Q--Stack marker register. Contains the absolute address of the current stack marker being used within the stack.

3. S--Top-of-stack register. Contains the absolute address of the top element of the stack. Manipu- lated by hardware to produce a last-in, first-out stack. The top four words may be kept in hardware registers.

The relationship of the five data addressing registers is shown in Figure

1.3. Each process is also described by a status register that contains its segment number and status, and a program-accessed, one-word index register used for array indexing and other computing functions.

There is only one set of these hardware registers; their content is established for a process when it starts executing.

BOX

Figure 1.3. Data Stack Registers

Instructions are provided to access all regions indicated in this diagram except S to Z. The four top-of-stack registers are not shown.

In the HP 3000, memory reference instructions specify an address relative to one of the hardware registers. Each register has its own addressing range as indicated below:

-----------------------------------------

| | + | |

-----------------------------------------

| P register | 255 | 255 |

-----------------------------------------

| DB register | 255 | ***** |

-----------------------------------------

| Q register | 127 | 63 |

-----------------------------------------

| S register | ***** | 63 |

-----------------------------------------

Note that the DB register cannot be directly addressed with a negative range and that the S register cannot be addressed with a positive range, indexing. The S positive area is undefined since S points to the top of the stack.

Any memory reference instruction specifies a displacement within the range of one of these registers. This location is used as the operand; if another address is required, it is implicitly assumed to be the top of

stack (S-0).

The basic addressing mode in the HP 3000 is word addressing (one word =

16 bits); however, there are also instructions to load and store bytes

(half words--8 bits) and doublewords (32 bits).

Many HP 3000 instructions use the top of the stack (the absolute address in the S register) as an implicit operand. For example, the ADD instruction always uses the values in S-0 and S-1 for its operands. The

S register is constantly changing in a last-in, first-out manner such that data is "pushed" onto the stack "popped" off the stack.

1-12. PROCEDURES

A procedure is a self-contained section of code which is called to perform a function. Some of the features of procedures are:

* Procedures can be passed parameters (either call-by-value or call-by-reference).

* Procedures can declare local variables and reference global variables.

* Procedures can return a value.

* Procedures can call themselves.

* Procedures can be called from either procedures or the main body.

* Procedures can have local subroutines (sections of code which can only be called from within the procedure).

Procedure declarations precede the main body of the program and contain the local declarations and the procedure body.

For example, a procedure to compute N factorial is

INTEGER PROCEDURE FACT(N); VALUE N; INTEGER N;

BEGIN

END;

FACT:= IF N= 0 THEN 1

ELSE N*FACT(N- 1);

For a complete explanation of procedure declarations, see section VII.

1-13. SUBROUTINES

An SPL subroutine is a simpler and less powerful section of code than the procedure. Subroutines can have parameters, can be typed functions and can be called recursively. A subroutine is called with an

SCAL instruction instead of a PCAL instruction, SCAL does not provide a

4-word stack marker to save the environment; therefore,

* Values in the Q and index registers remain unchanged.

* A PB-relative return address is placed on the top of the stack.

* Subroutines cannot have local variables.

* Subroutines must be located in the same segment as the caller since the SCAL and SXIT instructions do not bridge segment boundaries.

* Subroutines can be entered and exited faster than procedures since there is much less work for the instructions to do.

* Subroutines can be declared within procedures and can reference procedure-local variables.

Global subroutines can be called only within the main body. Global subroutine declarations must appear after the procedure and intrinsic declarations.

Local subroutines can be called only from the procedure in which they are declared. They are declared in the body of the procedure, after any local data declarations, but before the executable statements of the procedure body. For a complete description of subroutine declarations, see section VII.

1-14. INTRINSICS

An intrinsic is a procedure which has previously been defined, either as part of the MPE Operating System or in a user's own intrinsic file. The advantage of using intrinsics is that you do not have to include the complete procedure in your program, but merely declare the name of the intrinsic in an intrinsic declaration.

MPE intrinsics are available to:

* Access and alter files.

* Manage program libraries.

* Obtain date, time, and accounting information.

* Determine job status.

* Determine device status.

* Obtain device file information.

* Transmit messages.

* Insert comments in command stream.

* Perform ASCII/binary number conversion.

* Perform input/output on job/session standard devices.

* Obtain system timer information.

* Obtain the user's access mode and attributes.

* Search arrays and format parameters.

* Execute MPE commands programmatically.

Intrinsics must be declared with an intrinsic declaration (See section

VII). Appendix C shows how to build your own intrinsic file. Appendix D contains a list of the MPE intrinsics. Refer to the MPEIntrinsics

Reference Manual for a complete description of the system intrinsics.

1-15. COMPOUND STATEMENTS

BEGIN and END are used as a delimiting pair and are matched much like parentheses. Within the body of a main program or a procedure, a

BEGIN-END pair can be used to combine several statements into one compound statement. Compound statements are useful in IF, FOR, CASE,

DO-UNTIL, and WHILE-DO statements.

The form of a compound statement is:

BEGIN

[statement;... ;statement]

END where statement is any SPL executable statement (including compound statements).

For example,

IF A<B THEN

BEGIN

A:=B;

B:=D;

E:=F

END;

Note that a semicolon is not required before the END statement. If it is included, it is a null statement.

1-16. ENTRY POINTS

Both main programs and procedures can have multiple entry points. The first executable statement of a main program or procedure is an implicit entry point. Alternate entry points are labeled statements whose labels are declared in an entry declaration (see paragraph 3-7 for the format of an entry declaration). An entry point cannot be the object of a GO TO statement.

A program may be started at an alternate entry point with a parameter on the :RUN or :PREPRUN command. An alternate entry point for a procedure is equivalent to another name for the procedure that can be called with the same formal parameters. Local variables are set up and initialized regardless of which entry point is used. For example, assume the following program has been compiled and prepared (:SPLPREP) and the program file is $OLDPASS.

BEGIN

ENTRY P1,P2,P3;

P1: A:=100;

P2: A:=200;

P3: A:=300;

END.

To start execution at P2, use the command

:RUN $OLDPASS,P2

Chapter 2 BASIC ELEMENTS

2-1. DATA STORAGE FORMATS

SPL processes six types of data: integer, double integer, real, long

(extended precision real), byte, and logical. Each data type has its own representation in memory. The following paragraphs describe the data types and discuss the manner in which they are stored in memory.

2-2. INTEGER FORMAT

Integers are whole numbers containing no fractional part. Integer values are stored in one 16-bit computer word. The leftmost bit (bit 0) represents the arithmetic sign of the number (1= negative, 0= positive).

The remaining 15 bits represent the binary value of the number. Integer numbers are represented in two's complement form and range from -32768 to

+32767.

Decimal | Two's

Value | Complement

+ 32767 | %077777

: | :

+ 1 | %000001

0 | %000000

-1 | %177777

-2 | %177776

: | :

-32768 | %100000

2-3. DOUBLE INTEGER FORMAT

When you wish to use integer values with magnitudes greater than the integer format allows, you may use double integers. Double integers use

2 computer words for a total of 32 bits. The leftmost bit of the first word (bit 0) is the sign bit (1=negative, 0=positive). The remaining 31 bits represent the binary value of the number. Double integer numbers are represented in two's complement form and range from -2,147,483,648 to

+2,147,483,647.

2-4. REAL FORMAT

Real numbers are represented in memory by 32 bits (two consecutive 16-bit words) with three fields. The fields are the sign, the exponent, and the mantissa. The format is that known as excess 256--exponents are biased by +256. Thus, a real number consists of:

Sign(S) Bit 0 of the first word (positive=0, negative=1). A value X and its negative, - X, differ only in the sign bit.

Exponent(E) Bits 1 through 9 of the first word. The exponent ranges from 0 to 777 octal (511 decimal). This number represents a binary exponent, biased by 400 octal (256 decimal). The true exponent is E- 256; it ranges from

-256 to +255.

Fraction(F) A binary number of the form 1.xxx, where xxx is represented by 22 bits, stored in bits 10 through 15 of the first word and all of the second word. Note that the 1. is not actually stored, there is an assumed 1.

to the left of the binary point. Floating-point zero is the only exception--it is represented by all 32 bits being zero.

The range of the magnitude of non-zero real values is from 8.63617* 10-78 to 1.157921 * 10-77. Real numbers are accurate to 6.9 decimal places.

The internal representation for real numbers is:

The formula for computing the decimal value of a floating-point representation is:

Decimal value = (-1)S * F * 2(E-256) which is equivalent to:

Decimal value = (-1)S * (1.0 + (xxx * 2-22)) * 2(E-256)

For example, 7.0 is represented as

Sign (S) = 0 (positive)

Exponent (E) = 402 (octal) = 258 (decimal)

Fraction (F) = 1.11 (binary) = (1 x 20) + (1 x 2 -1) + (1 x 2-2)

= 1 + 1/2 + 1/4

= 1.75 (decimal)

So, the decimal value of the real value is:

(-1)0 x 1.75 x 2(258-256) = 1 x 1.75 x 22

= 7.0

2-5. LONG FORMAT*

Long numbers are represented in memory by 64 bits (four consecutive

16-bit words) with three fields. The fields are the sign, the exponent, and the mantissa. The format is that known as excess 256--exponents are biased by + 256. Thus, a long number consists of.

Sign(S) Bit 0 of the first word (positive= 0, negative= 1). A value X and its negative, -X, differ only in the sign bit.

-256 to +255.

Fraction(F) A binary number of the form 1.xxx, where xxx is represented by 54 bits, stored in bits 10 through 15 of the first word and all of the second, third, and fourth words. Note that the 1. is not actually stored, there is an assumed 1. to the left of the binary point.

Floating-point zero is the only exception--it is represented by all 64 bits being zero.

________________________________________________________________________

NOTE *Throughout this discussion the following changes apply to

Pre-Series II Systems: Long numbers are 48 bits (three words) accurate to 11.7 decimal places. The decimal value of a floating point representation of a long value is (-1)S * (1.0 + (xxx *

2-38)) * 2(E-256)

________________________________________________________________________

The range of the magnitude of non-zero long values is from

8.636168555094445 * 10-78 to 1.157920892373162 * 1077. Long numbers are accurate to 16.5 decimal places. The formula for computing the decimal value of a floating-point representation is:

Decimal value = (-1)S * F * 2(E-256) which, for long values, is equivalent to:

Decimal value = (-1)S (1.0 + (xxx * 2-54)) * 2(E-256)

The internal representation for long numbers is:

2-6. BYTE FORMAT

Character strings are stored using byte format. Character values are represented bv 8-bit ASCII codes, two characters packed in one 16-bit computer word. The number of words used to represent a character value depends on the actual number of characters in the string. Appendix A shows the ASCII characters and their octal codes.

The internal representation of byte values is:

2-7. LOGICAL FORMAT

Logical values are stored in one 16-bit computer word. They are treated as unsigned integer values ranging from 0 to 65,535. A value is considered true if it is odd and false if it is even (i.e., only bit 15 is checked). When a value is set to TRUE, a word of all ones is used (%

177777). A value set to FALSE is all zeros.

The internal representation of a logical value is:

2-8. CONSTANT TYPES

Constants are literal values that stand for themselves. There are two basic types of constants in SPL: numeric constants and string constants.

Numeric constants are broken down into five types:

1. Integer (16 bits--includes 1 sign bit)

2. Double integer (32 bits--includes 1 sign bit)

3. Real (32 bit floating point)

4. Long (64 bit floating point)

5. Logical (16 bits--no sign bit)

String constants are made up of ASCII characters which are packed two

8-bit characters to a word.

In SPL, constants are merely bit patterns that occupy a given number of bits. A given 16-bit pattern can have many constant interpretations (two characters, an integer, a logical value, etc.). Note that hardware instructions provide arithmetic capability for all of the constant types mentioned here.

2-9. INTEGER CONSTANTS

Integers are signed whole numbers containing no fractional part. Decimal integer constants use the decimal digits 0 through 9. They can contain a leading plus (+) or minus (-) sign. A number without a leading sign is positive. The range of an integer constant is from -32768 to +32767.

The form of a decimal integer constant is,

[sign] integer where sign is + or -.

integer is a string of the digits 0 through 9.

For example,

12345

-31766

+12384

2-10. DOUBLE INTEGER CONSTANTS

Double integers are signed whole numbers containing no fractional part.

Decimal double integer constants use the decimal digits 0 through 9 followed by a D. They can contain a leading plus (+) or minus (-) sign.

A number without a leading sign is positive. The range of a double integer constant is from -2,147,483,648 to +2,147,483,647. The form of a decimal double integer constant is:

[sign] integer D where sign is + or integer is a string of the digits 0 through 9.

For example,

-123456D

+99999999D

312735D

0 D

2-11. BASED CONSTANTS

SPL allows you to use any base from 2 (binary) through 16 (hexadecimal) in constants. A based constant can contain a leading sign and/or a trailing type designator. A leading per cent sign (%) denotes a based constant. The base is enclosed in parentheses following the per cent sign. If a base is not specified, the constant is octal (base 8). The letters A,B,C,D,E, and F represent the values 10,11,12,13,14, and 15 respectively in bases greater than 10. If a type designator is used with a base greater than 10, a space must precede the type designator.

The form of a based constant is:

[sign] %[(base)] integer [type-designator] where sign is + or -.

base is any integer between 2 and 16. If the % is used without a base being specified, base 8 (octal) is assumed.

integer is a string of digits, where digit is between 0 and base-1.

type-designator is D,E, or L for DOUBLE, REAL, or LONG respectively. If a type-designator is not specified, the constant will be a single-word constant which can be used as type

INTEGER, LOGICAL, or BYTE.

For REAL and LONG based constants, the bit pattern of the based integer is used directly as a right justified real number--it is not converted to floating point form. A leading minus sign will generate the two's complement form of single-word and type DOUBLE based constants, but will only reverse the sign bit for REAL and LONG based constants.

For example,

+%777

-%(2)10101010

%(16)ABC D <<type DOUBLE>>

%(16)ABCD <<single-word>>

2-12. COMPOSITE CONSTANTS

Composite constants are a convenient way of representing specific bit patterns for tables and special numbers such as the lowest possible real number. A composite constant consists of a series of bit fields separated by commas which is enclosed in brackets ([]). Each bit field contains a field length and an unsigned integer value separated by a slash. The integer value may be an unsigned composite integer; thus, composite integers may be nested within a composite constant. Composite constants may contain a leading sign and/or a trailing type designator.

The form of a composite constant is:

[sign] composite-integer [ type-designator] where sign is + or -.

compositeinteger is of the form:

[length/value,...,length/value]

_______________________________________________________

NOTE The brackets [ ] in this case are literal symbols which are part of the syntax for composite integers--they do not represent the symbols used to denote optional items in this manual.

_______________________________________________________ length is an unsigned non-zero decimal, based, composite, or equated integer constant. The sum of the lengths for a composite constant cannot exceed the number of bits used to represent the constant type. If the sum of the lengths is greater than 16, a type-designator is required.

value is any unsigned decimal, based, composite, or equated integer constant. Type-designators are not allowed.

type-designator is D,E, or L for DOUBLE, REAL, or LONG respectively. If a type-designator is not specified, the constant will be a single-word constant which can be used as type

INTEGER, LOGICAL, or BYTE.

Composite constants are formed by left-to-right concatenation of binary bit fields. Within each bit field, unspecified leading bits are set to zero and bits exceeding the field size are truncated on the left. The resulting composite integer is right justified with leading bits set to zero. If a minus sign is used with a single-word or a type DOUBLE composite constant, the two's complement will be generated. If a minus sign is used with a REAL or LONG composite constant, the sign bit will be reversed and the other bits will be unchanged--no conversion to floating point form occurs with ccmposite constants.

For example,

[32/1] D = %00000000001

-[32/1]D = %37777777777

-[32/1]E = %10000000001

[3/2,12/%5252] = %25252

[2/211,15/[3/%(2)101,12/0],10/123] D = %720000173

-[3/2,12/%5252] = %152526

2-13. EQUATED INTEGERS

Equated integers are used to assign an integer value to an identifier for compile-time only. An equated integer does not allocate any storage, but merely provides a form of abbreviation for constants. When an equated identifier is used, the appropriate constant is substituted in its place.

When Equate declarations are used instead of actual constants, programs can be changed simply; instead of replac- ing every occurrence of a constant, only the EQUATE declaration need be changed. An equated integer reference may be preceded by a plus (+) or minus (-) sign. The value assigned to an identifier in an EQUATE declaration must be a single-word value; however a D may be used after the identifier to convert the single-word value to a double-word value whose first word is all zeros. If a D is used, a space must separate the identifier from the

The form of an equated integer constant is

[sign] identifier [D] where sign is + or -.

identifier is a legal SPL identifier which has been declared in an

EQUATE declaration (see paragraph 3-9).

2-14. REAL CONSTANTS

Real constants are represented by an integer part, a decimal point, and a decimal fraction. Either the integer part or the decimal fraction may be omitted (but not both) to indicate a zero value for that part only. A leading plus (+) or minus (-) sign may be used. A number without a sign is positive. The constant can contain a scale factor to indicate a power of ten by which the value is multiplied.

The forms of a real constant are

Format 1: [sign] based/composite-integer E

Format 2: [sign] decimal-number [E [sign] power]

Format 3: [sign] decimal-integer E [sign] power where sign is either + or -.

based/ is any unsigned based or composite integer constant.

compositedecimal-number is of one of the following three forms: n.n n.

(n being an unsigned decimal integer).

power is an unsigned decimal integer constant.

decimal-integer is an unsigned decimal integer constant.

Real numbers are accurate to 6.9 decimal digits of magnitude (0 can be represented exactly). The absolute value of non-zero real numbers can range from 8.63617 x 10-78 to 1.157921 x 1077. The E construct is used to indicate the scaling factor, if any. For example, 2.5E-2 means 2.5 x

10-2.

Note that when a composite or based integer is used, there is no power after the E, and that the E is required to indicate a real value. The bit pattern created for the integer is used directly as a right-justified real number; it is not converted to floating-point form. This construct is useful for creating special floating-point constants such as the smallest positive number. When the base is greater than 10, a space must precede the E.

For example,

+1.234

-.2024

-1.105E-21

10E-20

%(4)321000E

%(2)1111011110111E

[3/5,5/273,20/%(16)102AB39]E

Some examples of invalid real constants are

+10.E <<missing power>>

2E<<missing power>>

2-15. LONG CONSTANTS

Long constants are represented by an integer part, a decimal point, and a decimal fraction. Either the integer part or the decimal fraction may be omitted (but not both) to indicate a zero value for that part only. A leading plus (+) or minus (-) sign may be used. A number without a sign is positive. The constant can contain a scale factor to indicate a power of ten by which the value is multiplied.

The forms of a long constant are

Format 1: [sign] based/composite-integer L

Format 2: [sign] decimal-number [L[sign] power]

Format 3: [sign] decimal-integer L[sign] power where sign is either + or -.

based/ is any unsigned based or composite integer constant.

compositedecimal-number is of one of the following three forms: n.n n.

(n being an unsigned decimal integer).

is an unsigned decimal integer constant.

power decimal-integer is an unsigned decimal integer constant.

Long numbers are accurate to 16.5*decimal digits of magnitude (0 can be represented exactly). The absolute value of non-zero long numbers can range from 8.636168555094445 x 10-78 to 1.157920892373162 x 1077. The L construct is used to indicate the scaling factor, if any. For example,

2.5L-2 means 2.5 x 10-2.

Note that when a composite or based integer is used, there is no power after the L, and that the L is required to indicate a long value. The bit pattern created for the integer is used directly as a right-justified long number; it is not converted to floating-point form. This construct is useful for creating special floating-point constants such as the smallest positive number. When the base is greater than 10, a space must precede the L.

For example,

9321.678975L72

-.111015L-27

%(8)3777777777L

*11.7 with pre-Series II Systems

2-16. LOGICAL CONSTANTS

Logical constants are 16-bit positive integers. Hardware operations on logical values are defined for addition, subtraction, multiplication, division, and comparison.

Logical values can be represented by any of the following:

1. TRUE

2. FALSE

3. integer where

TRUE and FALSE are SPL Reserved words.

integer is any (single word) decimal, based, composite, or equated integer.

A logical value is considered true if its value is odd, false if its value is even (i.e., only bit 15 is checked). When the reserved words

TRUE and FALSE are used, they are equivalent to the integer values -1

(all ones) and 0 (all zeros) respectively, Since logical values are always assumed to be positive, they range from 0 to +65,535. When negative integers are used as logical values, they are interpreted as large positive numbers (e.g., -1 equals % 177777).

2-17. STRING CONSTANTS

A string constant is a sequence of one or more ASCII characters bounded by quote marks ("). Each character is converted to its 8-bit representation and the characters are packed two per word.

The form of a string constant is

"character-string" where characterstring is a sequence of ASCII characters (see Appendix A).

A character string can contain from 1 to 127 ASCII characters. A quote

(") is represented within a character string by a pair of quotes ("" ) to avoid ambiguity with the string terminator.

For example,

"THE CHARACTER "" IS A QUOTE MARK."

"A NORMAL STRING WOULD LOOK LIKE THIS"

"lowercase letters are not UPSHIFTED in strings"

2-18. IDENTIFIERS

Identifiers are symbols used to name data and code constructs in an SPL program. They consist of uppercase letters and numbers, and are assigned uses by declarations. There is no implicit typing for identifiers.

The form of an identifier is letter [letter'digit-string] where letter is a letter of the alphabet (A-Z).

letter'digitis a string of letters (A-Z), digits (0-9), and string apostrophes (').

An identifier always starts with a letter and may contain from 1 to 15 characters (letters, digits, and apostrophes). Identifiers larger than

15 characters are truncated on the right (A123456789012345 =

A12345678901234). Lowercase letters are allowed, but are always converted to uppercase form (Aabc = AABC). If the listing device has upper and lowercase characters, a lowercase identifier is printed in lowercase, but SPL does not differentiate it from an uppercase identifier with the same characters. The attributes of an identifier are determined by a declaration, not by the form of the identifier.

Reserved words are combinations of characters that cannot be used as identifiers, since they have implied meanings in the language. (See

Appendix B for a list of SPL reserved words).

For example,

MATRIX

A""B

AN'IDENTIFIER

MAT123

2-19. ARRAYS

An array is a block of contiguous storage which is treated as an ordered sequence of variables having the same data type. These variables are accessed using a single identifier to denote the array and a subscript number to denote the particular variable (element) within the array.

Array elements are sometimes called subscripted variables.

SPL allows one-dimensional arrays (only one subscript is permitted) in all data types (integer, logical, real, byte, long, and double).

Subscripting automatically uses the index register to indicate the element number. Bounds checking is not done at either compile-time or run-time. Arrays can be initialized but do not have a default initialization value. Arrays can be located in any region of the user's domain which can be addressed relative to the DB, Q, S, or P registers.

Values in P-relative arrays are constants which cannot be changed at run-time.

2-20. POINTERS

A pointer is a type of variable which contains the 16-bit address of another data item in the program. The 16 bits of the pointer represent the address of a variable. A pointer can be changed dynamically to point to different data items during program execution. Pointers are declared in a pointer declaration (see paragraph 3-4 for global pointer declarations and paragraph 7-24 for local pointer declarations).

There are four contexts in which pointers can be used:

1. Anywhere that the object of the pointer could be used; this generates an automatic indirect reference to the object of the pointer.

2. On the left side of an assignment statement to change the value of the object of the pointer.

3. A pointer can be preceded by an @ to refer to the actual contents of the pointer (the data label), not the object of the pointer.

4. A pointer can implicitly reference the LST and SST instructions.

(Privileged mode only.) The pointer reference must always be subscripted and cannot be preceded by '@'. MAP indicates this addressing scheme by ST + number as shown in the example below.

Refer to the Machine Instructions Set Manual for more detailed information.

00000100 00000 0 $CONTROL INNERLIST,MAP,ADR

00001000 00000 0 BEGIN

00002000 00000 1 INTEGER POINTER SYSGLOB=0;

00002100 00000 1 INTEGER CONSOLE,.

DB+000

00003000 00000 1 CONSOLE:=SYSGLOB(%74);

00000 LDXI, 074 021474 01.05

00001 LDI , 000 021000 01.05

00002 LST , 000 030000 02.45

00003 STOR DB 000 051000 03.15

00004000 00004 l END.

00004 PCAL, 052 OOOOOO 14.90

IDENTIFIER CLASS TYPE ADDRESS

CONSOLE SIMP. VAR. INTEGER DB+000

SYSGLOB POINTER INTEGER ST+000

TERMINATE PROCEDURE

For example, assume the following data declarations

INTEGER A,B:=7,C:=300,DATA:=-1;

INTEGER POINTER PTR:=@DATA;

These declarations initialize the variables B, C, and DATA and set up PTR as a pointer to DATA as shown below.

Now, consider the statement

A:= PTR;

This statement assigns the object of the pointer PTR (i.e., DATA) to A.

Using the pointer on the left side of an assignment statement can change the value of the object of the pointer.

PTR:= B+C;

The object of the pointer PTR (i.e., DATA) is assigned the value of B+C.

Preceding the pointer variable with an @ references the address contained in the pointer instead of the value of the object of the pointer. Using this construct on the right side of an assignment statement assigns the

DB-relative address of the object of the pointer to a variable. For example,

A:=@PTR;

A is assigned the address contained in PTR (that is, the address of

DATA).

To change the pointer to point to a different data item, use the @ construct on the left side of an assignment statement as shown below.

@ PTR:=@A;

This statement changes PTR to point to A instead of DATA.

2-21. LABELS

Labels are used to identify statements for transfer of control and for documentation purposes. A label must always be followed by a colon (:) to separate it from the statement that it identifies. For consistency and documentation, labels may be declared with a label declaration; however, it is not necessary to do so since labels declare themselves automatically when they are used. A label can be used to identify only one statement within the scope of the identifier; that is, the same label can be used to identify two different statements as long as the statements are not both in the main body or both in the same procedure.

2-22. SWITCHES

The purpose of a switch is to transfer control to one of several labeled statements within a program. A switch is first declared with a switch declaration (see paragraph 3-6 for the format of a switch declaration).

The switch declaration defines an identifier to represent an ordered set of labels. Each label in the list (from left to right) is assigned a number from 0 to n- 1 (where n is the number of labels) which indicates the position of the label in the list. A switch of program control is accomplished by using a GO TO statement with the switch identifier and an index. The index is evaluated to an integer value and control is transferred to the switch label specified by that number. Bounds checking on the index to insure that the value has a corresponding labeled statement is optional. See paragraph 5-2 for the form of the GO

TO statement.

For example,

BEGIN

INTEGER INDX;

REAL A,B;

SWITCH SW:= L1,L2,L3,L4;

INDX:= -1;

LOOP: INDX:= INDX+1;

GO TO SW(INDX);

L1: A:=B;

GO TO LOOP;

L2: B:=A;

GO TO LOOP;

L3: A:=A+B;

GO TO Loop;

L4: B:=A+B;

END.

Chapter 3 GLOBAL DATA DECLARATIONS

3-1. TYPES OF DECLARATIONS

A declaration defines the attributes of an identifier before it is used in a program or procedure. All identifiers in SPL programs (with the exception of labels) must be explicitly declared once only within a single program or procedure. There are two possible levels of declarations in SPL:

Global (in a main program)

Local (in procedures)

Globally declared identifiers can be accessed throughout a program (even within procedures) and their declarations are grouped together at the beginning of the program. Locally declared identifiers can be accessed only within the procedure where declared and their declarations are grouped together at the beginning of the procedure body. This section covers global data declarations only; refer to section VII for local declarations.

Global data declarations immediately follow the opening BEGIN as shown below.

BEGIN

-----> [global-data-declarations]<-----

[procedures/intrinsics]

[global-subroutines]

[main-body]

END.

Global data declarations are composed of the following types of declarations (which are described individually later in this section):

* global simple variable declarations

* global array declarations

* global pointer declarations

* label declarations

* switch declarations

* entry declarations

* define declarations

* equate declarations

Global data identifiers (simple variables, arrays, and pointers) are either allocated space in the stack or use space in the stack allocated to another identifier. Normally, the next available DB-relative location is allocated for the identifier. However, a register-relative or identifier-relative location may be specified in the declaration to override the default allocation. In this case, the referenced location is used without being allocated. When using identifier or register references, the compiler only checks that the resulting address is within the direct address range of the register being used. You must insure that this location does not exceed the bounds of your data stack when the identifier is referenced at execution time. Additionally, when using a reference identifier, you must declare it before using it as a reference identifier. For example, the declarations:

INTEGER A,B,C;

LOGICAL D= A+ 2; indicate that D is a LOGICAL simple variable using the same location as the INTEGER variable C. The syntax for register and identifier references is described in the appropriate paragraphs for the type of identifier

(simple variable, array, or pointer) in this section. Data identifiers which are register or identifier referenced cannot be initialized.

3-2. SIMPLE VARIABLE DECLARATIONS

A simple variable declaration specifies the type, addressing mode, storage allocation, and initialization value for identifiers to be used as single data items. The type assigned to a variable determines the amount of space allocated to the variable and the set of HP 3000 instructions which can operate on the variable.

Two methods can be used to link global variables to variables in separately compiled procedures. The first method is to use the GLOBAL attribute in the global variable declaration and the EXTERNAL attribute in the local variable declaration (see paragraph 7-19). The identifiers in both declarations must be the same and the MPE Segmenter is responsible for making the correct linkages. (See the MPE Segmenter

Subsystem Reference Manual for a discussion of the Segmenter.) The second method is to include dummy global declarations at the beginning of subprogram compilations. All global declarations must be included, even for identifiers not referenced in the subprogram, and they must be in the same order as in the main program. It is possible, although not recommended, to use different identifiers for the same variable, but you are responsible for keeping them straight. The second method is faster and requires less space in the USL (User Subprogram Library) files, but does not protect you against improper linkages.

The form of a global simple variable declaration is:

[GLOBAL] type variable-declaration[,...,variable-declaration];

EXAMPLES:

INTEGER I,J:=1245;

DOUBLE II:=- 1234579 D;

REAL A,B,C:=1.321 E- 21,Z= DB+3;

LOGICAL INDX=X,LI=I,JI=J;

GLOBAL BYTE DOLLAR:="$"; where type specifies the data type of the variables in the declaration. The type may be INTEGER, LOGICAL, BYTE,

DOUBLE, REAL, or LONG.

variablecan be any of the following forms: declaration variable [:= initial-value] variable = register [sign offset] variable = reference-identifier [sign offset] variable is a legal SPL identifier.

initial-value is an SPL constant to be used as the value of the variable when program execution begins.

sign is + or -.

offset is an unsigned decimal, based, composite, or equated

referenceinteger constant.

is any legal SPL identifier which has been declared as a

Form 1 of the variable declaration allocates the next available

DB-relative location(s) for the variable. The amount of space allocated depends on the variable type. If an initial value is specified, the variable is initialized when execution starts.lf the constant used for the initial-value is too large, it is truncated on the left, except string constants which are truncated on the right. If no initial-value is specified, the variable is not initialized.

Form 2 of the variable declaration equivalences a variable either to the index register (X) or to a location relative to the contents of one of the base registers (DB, Q, or S). Since the index register is 16 bits, only variables of type INTEGER, LOGICAL, and BYTE may be equivalenced to this register.

Form 3 of the variable declaration equivalences a variable to a location relative to another variable. The reference-identifier must be declared first. For example, the declarations

LOGICAL A;

INTEGER B= A+ 5; equivalence B to the location 5 words past the location of A. Simple variables which are address referenced to arrays use either the location of the zero element of the array (if direct), or the location of the pointer to the zero element of the array (if indirect). Note that if the reference-identifier is an array, only the zero element may be used in a variable reference of a simple variable declaration. In any case, the final address must be within the direct address range.

DB, PB, Q, S, and X cannot be used as the identifier on the right side of an equals sign in a variable declaration, because they are interpreted as register references instead of variable references. For example, consider the declaration

INTEGER A,B,C,DB,D= DB+ 2;

The variable D is equivalenced to the location 2 cells past the cell to which the DB register points--not 2 cells past the location assigned to the variable DB,

The legal combinations of registers, signs, and offsets are shown below

--------------------------------------------------------------------------------

| Register | Sign | Offset |

--------------------------------------------------------------------------------

| DB | + | 0 to 255 |

--------------------------------------------------------------------------------

| Q | + | 0 to 127 |

--------------------------------------------------------------------------------

| Q | | 0 to 63 |

--------------------------------------------------------------------------------

| S | | 0 to 63 |

--------------------------------------------------------------------------------

| X | none | none |

--------------------------------------------------------------------------------

3-3. ARRAY DECLARATION

An array declaration specifies one or more identifiers to represent arrays of subscripted variables. An array is a block of contiguous storage which is treated as an ordered sequence of "variables" having the same data type. Each "variable" or element of the array is denoted by a unique subscript (SPL provides one-dimensional arrays only). An array declaration defines the following attributes of an array:

* The bounds specification (if any) which determines the size of the array and the legitimate range of indexing.

* The data type of the array elements.

* The storage allocation method.

* The initial values, if desired.

* The access mode (direct or indirect).

There are two types of access modes used for arrays: indirect and direct. An indirect array uses a pointer to the zero element of the array. Addressing an indirect array element uses both indirect addressing and indexing. If the array is a BYTE array, the pointer contains a DB-relative byte address. For all other data types, the pointer contains a DB-relative word address. A direct array uses a location within the direct address range of one of the registers (DB, Q, or S) as the zero element of the array and then uses indexing to address a specific array element. Figure 3.1 illustrates the differences between direct and indirect arrays.

The area in the stack between DB and the initial value of Q is divided into two areas: Primary DB Storage and Secondary DB Storage. The

Primary DB area is used for global storage of simple variables, direct arrays, and pointers to indirect global arrays. The Secondary DB area is used for global storage of indirect arrays. The Primary DB area cannot normally extend past DB+ 255. The only exception is when the last global data declaration is for a DB-relative direct array whose zero element falls between DB+0 and DB+255. Since the index register is used to address array elements, the array may extend past DB+255. The Secondary

DB area immediately follows the Primary DB area regardless of the size of the Primary DB area.

Figure 3.1. Accessing Array Elements

There are two methods which can be used to link global arrays to arrays in separately compiled procedures. The first method is to use the GLOBAL attribute in the global array declaration and the EXTERNAL attribute in the local array declaration (see paragraph 7-23). The identifiers in both declarations must be the same and the Segmenter is responsible for making the correct linkages. The second method is to include dummy global declarations at the beginning of subprogram compilations. All global declarations must be included, even for identifiers not referenced in the subprogram, and they must be in the same order as in the main program. It is possible, although not recommended, to use different identifiers for the same array, but you are responsible for keeping them straight. The second method is faster and requires less space in the USL

(User Subprogram Library) files, but does not protect you against improper linkages.

The form of a global array declaration is:

{global-array-dec}

{initialized-global-array-dec} where

GLOBAL is used for arrays which are referenced in procedures compiled separately.

type specifies the data type of the array. The type can be

INTEGER, LOGICAL, BYTE, DOUBLE, REAL, or LONG. If not specified, the array is type LOGICAL.

global-arraydec is one of the following forms:

1. array-name(lower:upper) [=DB]

This form is used for an uninitialized array with defined bounds. If = DB is not specified, the array is indirect and the next available DB

Primary location is allocated for the pointer to the zero element of the array. Storage for the array itself is allocated in the Secondary DB area. If = DB is specified, the array is direct and the next available n cells in the DB Primary area are allocated for the array (where n is the number of locations required to store the array).

The zero element of the array must be within the direct address range whether or not it is actually an element of the array. For example, consider the declaration:

INTEGER ARRAY A(- 20:- 10)= DB;

The next available DB primary location is allocated to A(-20), but all indexing is done relative to A(0) even though it is not an actual element of the array. The address which A(0) would have if it were in the array must be between DB+0 and DB+255.

2. array-name(@)= DB [+ offset]

This form is used for an indirect array with undefined bounds. If no offset is specified, the next available Primary DB location is used, without being allocated, as the pointer to the zero element of the array.

If an offset is specified, then that DB-relative cell is used, without being allocated, as the pointer to the zero element. In either case, space is not

allocated for the array in the Secondary DB area nor is initialization allowed.

3. array-name(*)= DB [+ offset]

This form is used for a direct array with undefined bounds. If no offset is specified, the next available Primary DB location is used,

without being allocated, as the zero element of the array. If an offset is specified, then that

DB-relative location is used, without being

either case, space is not allocated for the array nor is initialization allowed.

4. array-name(@)[= register sign offset]

This form is used for an indirect array with undefined bounds whose pointer is Q or

S-relative. If a base-register reference is not specified, the next available DB cell is allocated for the pointer to the zero element of the array. If a base-register reference is specified, then that Q-relative or S-relative cell is used, without being allocated, as the pointer to the zero element of the array. Space is not allocated for the array nor is initialization allowed.

5. array-name(*)

This form can be used for an indirect array with undefined bounds. The next available DB cell is allocated for the pointer to the zero element of the array. Space is not allocated for the array nor is initialization allowed. This form is equivalent to array-name(@) without a base-register reference.

6. array-name(*)= register sign offset

This form is used for direct arrays with undefined bounds which are Q-relative or

S-relative. The specified cell is used as the zero element of the array; however, space for the array is not actually allocated and the array cannot be initialized.

7. array-name(*)= reference-identifier [sign offset]

This form is used for an indirect array with undefined bounds whose pointer is Q- or

INTEGER B(*)A+ 10; would not be allowed because the direct address range for the DB register is 0 to 255. If the array is direct, the referenced location is used as the zero element of the array. If the array is indirect, the referenced location is used as the pointer to the zero element except when either the array or the reference-identifier (but not both) is type BYTE, in which case the next available DB-cell is allocated for the pointer to the zero element. Space is not allocated for the

array nor can the array be initialized. DB, PB,

Q, S, and X cannot be used as the referenceidentifer because they are interpreted as

8. array-name(*)= reference-identifier (index)

This form is used for equivalencing one array to another array. The reference-identifier may be either an array or a pointer variable and must be declared first. If the reference-identifier is a direct array, the array is a direct array whose zero element is the location of the referenced array element. If the reference-identifier is an indirect array or a pointer variable, the array is indirect. In this case, the next available DB cell is allocated for the pointer to the zero element of the array if a non-zero index is specified or if either the array or the reference-identifier (but not both) is type BYTE; otherwise, both use the same location for the pointer to the zero element. In any case, space is not allocated for the equivalenced array nor can the equivalenced array be initialized. DB,

PB, Q, S, and X cannot be used as the reference-identifier because they are interpreted as register references instead.

*Forms 4 through 8 are not allowed if the word GLOBAL is included in the declaration.

array-name is a legal SPL identifier.

referenceis any legal SPL identifier except DB,PB,Q,S, or X which identifier has been declared as a data item.

The register may be either Q or S.

sign is + or -.

offset is an unsigned decimal, based, composite, or equated

integer constant within the direct address range as shown below:

--------------------------------------------------------------------------------

| Register | Sign | Offset |

--------------------------------------------------------------------------------

| DB | + | 0 to 255 |

--------------------------------------------------------------------------------

| Q | + | 0 to 127 |

--------------------------------------------------------------------------------

| Q | | 0 to 63 |

--------------------------------------------------------------------------------

| S | | 0 to 63 |

-------------------------------------------------------------------------------initializedglobal-array is of the form: array-name(lower:upper) [=DB]:=

value-group[,...,value-group] lower specifies the lower bound of the array. It can be any

integer constant or constant expression.

upper specifies the upper bound of the array, It can be any decimal, based, composite, or equated single-word integer constant or constant expression.

index indicates the element of the referenced array to be used as the reference location. The index can be any decimal, based, composite, or equated single-word integer constant.

value-group is either of the following: initial-value repetition-factor (initial-value [,...,initial-value]

) initial-value is any SPL numeric or string constant.

repetitionfactor specifies the number of times the initial value list will be used to initialize the array elements. The repetition-factor can be any unsigned non-zero decimal, based, composite, or equated single-word integer constant.

Global arrays with defined bounds can be initialized. Initialization consists of a := followed by a list of numerical constants or strings. A group of constants can be surrounded by parentheses and preceded by a repetition factor (n) to specify that the constants in parentheses are to be used n times ininitializing the array before going on to the next item in the list. These repeat groups cannot be nested. Elements are initialized starting with the lowest subscript and continuing up until the constant list is exhausted. The initialization list cannot contain more values than there are elements in the array. If the constant used for the initial value is too large, it is truncated on the left except string constants which are truncated on the right. If no initial value is specified, the variable is not initialized. Only the last array in a declaration list can be initialized.

Table 3-1 summarizes the syntax and meanings for the various forms of global array declarations. Figure 3.2 shows a series of array declarations with the locations assigned to the identifiers.

Table 3-1. Global Array Declaration Summary