Intel PASCAL-80 software User's Guide

PDF

Dokument

Annonce

•

PASCAL·SO

USER'S GUIDE

•

Manual Order Number: 9801015-02

•

Intel Corporation has carefully reviewed this Vendor Supplied Product for its suitability and operational characteristics when used with Intel products and believes that the product will operate and perform according to its published user manuals. HOWEVER, INTEL MAKES NO

WARRANTIES WITH RESPECT TO THE OPERATIOI\J AND USE OF THIS VENDOR SUPPLIED

PRODUCT. Successful use depends solely on customer's ability to install and use this product.

This Vendor Supplied Product is licensed on an "as is" basis and Intel Corporation does not guarantee any future enhancements or extensions to this product. The existence of this product does not imply its adaptation in any form as an Intel standard nor its compatibility with any other Intel product except as specifically stated in the published user manuals.

Intel will provide limited telephone assistance to the customer in the understanding of the operation of the product.

In addition, if a problem is encountered which the user diagnosis indicates is caused by a defect in this Vendor Supplied Product, the user is requested to fill out a Problem Report form and mail it to:

•

Intel Corporation

MCSD, Marketing

3065 Bowers Avenue

Santa Clara, CA 95051

Intel will use its best efforts to respond to Problem Reports in one of the following ways: 1)

Release information to correct the problem, 2) Offer a new revision, when available, with corrected code to fix the problem, or 3) Issue a notice of availability of a new revision with corrected code.

•

1...-_ _ _ _ _ _ _ _ 1 Intel Corporation, 3065 Bowers Avenue, Santa Clara, California 95051 11...-_ _ _ _ _ _ _ _

•

Additional copies of this manual or other Intel literature may be obtained from:

Literature Department

Intel Corporation

3065 Bowers A venue

Santa Clara, CA 95051

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

Intel Corporation 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. Intel Corporation assumes no responsibility for any errors that may appear in this document. Intel Corporation makes no commitment to update nor to keep current the information contained in this document.

Intel Corporation assumes no responsibility for the use of any circuitry other than circuitry embodied in an Intel product. No other circuit patent licenses are implied.

Intel software products are copyrighted by and shall remain the property of Intel Corporation. Use, duplication or disclosure is subject to restrictions stated in Intel's software license, or as defined in ASPR

7-104.9(a)(9).

No part of this document may be copied or reproduced in any form or by any means without the prior written consent of Intel Corporation.

The following are trademarks of Intel Corporation and may be used only to identify Intel products:

BXP

CREDIT i

ICE iCS

lnsite

Intel

Intelevision

Intellec iSBC iSBX

Library Manager

MCS

Megachassis

Micromap

Multibus

Multirnodule

PROMPT

Promware

RMX

UPI

~Scope and the combination of ICE, iCS, iSBC, iSBX, MCS, or RMX and a numerical suffix.

•

I

AZ35/780/5K/FL

I

•

• l

•

PREFACE

This manual describes the PASCAL-SO language for programming the SO SO and

SOS5 microcomputers. PASCAL-SO is based on the Pascal language invented in 1970 by Professor Niklaus Wirth of Zurich, and incorporates extensions designed to take advantage of both the microcomputer features of the SO SO and SOS5, and the system features of ISIS-II.

Each release of PASCAL-SO is characterized by a two-digit code in the form of:

"version number" . "release number within version"

Manual Organization

The PASCAL-SO language is a superset of the Pascal programming language, as defined in

PASCAL User Manual and Report,

Second Edition, by Kathleen] ensen and Niklaus Wirth (Springer-Verlag, 1974, Corrected Printing, 1975). This book defines "Standard Pascal" and will be referred to in the remainder of this manual as

PASCAL User Manual. Since PASCAL User Manual is a concise reference for the features of Standard Pascal, the programming language PASCAL-SO will be described only by its differences from, and extensions to, Standard Pascal, the assumption being that the reader is familiar with the contents of PASCAL User

Manual, and moderately conversant with Standard Pascal.

Chapters 1 through 3 describe the features of the PASCAL-80 language, and

Chapter 4 describes how to operate the PASCAL-SO System.

Chapter 5 presents example programs illustrating the features of PASCAL-SO. The appendices supply reference information for all aspects of program generation, compilation, and execution.

Audience

This manual is intended for programmers who are familiar with PASCAL. It contains the following chapters and appendices:

"Chapter 1. Introduction," which gives a general description of the PASCAL-SO system.

"Chapter 2. Language Features," which describes the data types, control constructs, and procedure and function declarations.

"Chapter 3. Predeclared Procedures," which describes the predeclared procedures and functions in PASCAL-80.

"Chapter 4. Operating Instructions," which describes how to generate, compile, and execute a PASCAL-SO program .

"Chapter 5. Example Programs," which presents four PASCAL-SO programs, complete with compiler listing and output.

"Chapter 6. Separate Compilation, Program Linkage, Relocation, and Execution," which gives general instructions for partitioning a Pascal program into separate compilation units, for linking to external non-Pascal object modules and for creating Load and Go versions of Pascal programs. iii

"Chapter 7. Preparing Programs to Run Under

RMX/SO,"

which gives information applicable to running Pascal programs in the

RMX/SO

environment.

"Chapter S. Run-Time Error Procedures," which gives instructions for declaring and using user-defined error procedures.

"Appendix A. Summary of Operations," which presents, in tabular form, the allowable operations among data types.

"Appendix

PASCAL-SO Vocabulary," which contains all of the operators and reserved words in the PASCAL-SO programming language.

"Appendix

Summary of Compiler Directives," which describes the directives for the compiler.

"Appendix D. Compiler Error Messages," which lists all errors that can be signaled during the compilation of a Pascal program.

"Appendix

Run-Time Errors," which is a listing of the error messages issued by the system default error procedure.

"Appendix F. ISIS-II Error Messages," which is a listing of the error messages issued by ISIS-II.

"Appendix

Syntax Summary," which summarizes the syntax of legal

PASCAL-SO programs.

"Appendix

Summary of Extensions to Standard Pascal," which summarizes all extensions to Standard Pascal provided by PASCAL-SO.

"Appendix I. Implementation Details," which presents the format of the predeclared data types in P ASCAL-80, lists certain implemtntation size limits, and summarizes the differences between P ASCAL-80 and Standard Pascal.

"Appendix]. Pascal Reference Texts," which lists a number of books that are of interest to the Pascal programmer.

"Appendix K. Directory of Release Diskettes," which lists the file directories of both the single density and double density release diskettes.

Related Publications

For additional information concerning ISIS-II and PASCAL-SO, refer to the following Intel documents:

ISIS-II User's Guide

808018085 Floating Point Arithmetic Library

User's Manual

ISIS-II CREDIT (CRT-Based Text Editor)

User's Guide

RMXISO User's Guide

RMXISO Interactive Configuration

Utility User's Guide

PLIM Programming Manual

ISIS-II PLIM Compiler

Operator's Manual

808018085 Assembly Language

Reference Manual

Order Number: 9800306

Order Number: 9800452

Order Number: 9S00902

Order Number: 9800522

Order Number: 142603

Order Number: 980026S

Order Number: 9S00300

Order Number: 9800301

•

ISIS-II SOSOlSOS5 Macro Assembler

Operator's Manual

FORTRAN-SO Programming Manual

ISIS-II FORTRAN-SO Compiler

Operator's Manual

Order Number: 9800292

Order Number: 9800481

Order Number: 9800480

Notation in this Manual

Throughout this manual, the following notation is used to describe the format of a

Pascal program:

1. Certain key words are reserved and cannot be used as identifiers. In this manual they are in capital letters. Refer to Appendix B for a list of reserved words.

2. Variable names are denoted by words in lower case.

3. Language features which exceed Standard Pascal are shaded.

• v

•

" n

•

CHAPTER!

INTRODUCTION

PAGE

General Description ............................ I-I

The P ASCAL-80 Language ...................... 1-2

System Structure ............................... \-2

Program Development Cycle ..................... \-2

•

CHAPTER 2 LANGUAGE FEATURES

Program Structure ............................. 2-\

Program Heading ............................ 2-1

Label Declaration Part ........................ 2-\

Constant Declaration Part ..................... 2-2

Type Declaration Part ........................ 2-2

Variable Declaration Part ..................... 2-2

Procedure and Function Declaration Part ........ 2-2

Data Types .................................... 2-2

The Boolean Type ............................ 2-3

The Integer Type ............................. 2-3

The Real Type ............................... 2-3

The Char Type ............................... 2-3

The ARRA Y Type ............................ 2-3

The RECORD Type .......................... 2-4

The String Type .............................. 2-5

The SET Type ............................... 2-5

The FILE Type .............................. 2-5

Untyped Files .............................. 2-6

INTERACTIVE Files ....................... 2-6

The POINTER Type .......................... 2-6

PROCEDUREs and FUNCTIONs ................ 2-7

SEGEMENT Procedures ...................... 2-7

•

CHAPTER 3 PREDECLARED PROCEDURES

File Manipulation Procedures .................... 3-1

File Manipulation Functions ..................... 3-4

Dynamic Allocation Procedures .................. 3-5

Arithmetic Functions ........................... 3-5

Predicates ..................................... 3-7

Transfer Functions ............................. 3-7

Miscellaneous Routines ......................... 3-7

String Manipulation Routines .................... 3-9

Character Array Manipulation Routines .......... 3-10

•

CHAPTER 4 OPERATING INSTRUCTIONS

Getting Started with PASCAL-80 ................. 4-1

Release Disks ................................ 4-1

Initial Steps ................................. 4-1

Compiler ................................... 4-2

Run-Time System ............................ 4-2

Libraries .................................... 4-2

Example Programs ........................... 4-2

PAGE

Figure Programs ............................. 4-2

Run-Time System Memory Layout .............. 4-2

Operating the P ASCAL-80 System ................ 4-3

Invoking PASCAL-80 ........................ 4-3

Command Line Syntax for PASCAL-80 ......... 4-4

Code Filename Specification ................. 4-4

Command Line Options ..................... 4-5

Program Tracing Facility ...................... 4-5

The TRACE Flag .......................... 4-5

Tracing Instructions ........................ 4-5

Run-Time Monitoring ........................ 4-6

Displaying the Statistics ....................... 4-6

Automatic Program Execution ................. 4-7

Interrupting Program Execution ................ 4-7

Operating the P ASCAL-80 Compiler .............. 4-7

Command Line Syntax for the Compiler ......... 4-7

Compiler Directives .......................... 4-8

Compiler Command Line Directives ............. 4-8

Excluded Combinations ..................... 4-9

Summary of Information on CRT .............. 4-9

Compiler Listing Format ..................... 4-10

Initial Compilat ions ......................... 4-10

CHAPTER 5 EXAMPLE PROGRAMS

Compiling the Example Programs ................ 5-\

Running the Demonstration Programs ............. 5-2

Addition and Subtraction of Numbers ........... 5-2

EX.PAS Program Listing ....................... 5-3

Bufferread and Bufferwrite Example ............ 5-4

BUFFER. PAS Program Listing .................. 5-4

ERROR. PAS Program Listing ................... 5-5

Example of Seek and Advanced Record Structure ... 5-6

Information Retrieval Program: SEEKEX.PAS ... 5-6

SEEKEX.P AS Program Listing ................ 5-7

CHAPTER 6 SEPARATE COMPILATION, PROGRAM

LINKAGE, RELOCATION, AND

EXECUTION

Partitioning a Pascal Program .................... 6-1

The Structure of a Partitioned Program .......... 6-1

Code File Construction ........................ 6-3

Linking with non-Pascal Modules ................. 6-4

P ASCAL-80 Extensions ....................... 6-4

Invoking an External Procedure or Function ...... 6-8

The External Reference Table .................. 6-8

Program Execution with External Objects .......... 6-9

Compile the Pascal Program ................... 6-9

Compile and/or Assemble the External Module(s) . 6-9

Link the Modules Together ................... 6-10 vii

viii

CONTENTS (Cont'd.)

I

•

PAGE

Locate the External Module ................... 6-10

Load the External Module into Memory and

Invoke the PASCAL-SO Run Time System .. 6-11

Load and Go Program Generation ............... 6-12

Generating the Relocatable Object Module ...... 6-12

Linking the Object Module ................... 6-13

Locating the Object Module .................. 6-13

Program Execution .......................... 6-13

CHAPTER 7 PREPARING PROGRAMS TO RUN

UNDER

RMX/SO

Program Structure Under

RMX/80 ...............

7-1

Initialization and Termination .................... 7-2

Input and Output .............................. 7-2

File Name Format ............................ 7-2

The Predeclared Files Input and Output .......... 7-3

DFS Service Operations ....................... 7-3

Run-Time Error Handling ....................... 7-3

P ASCAL-80 Extensions for

RMX/80 .............

7-3

Need for

RMX/80

Extensions .................. 7-4

The MESSAGE Data Type .................... 7-4

Predeclared Procedu'res and

Functions for

RMX/80 ..................

7-5

MESSAGE Manipulation Procedures ....... 7-5

RMX/80 Nucleus Operations .............. 7-5

Constructing an

RMX/80

System ................. 7-7

Generating the Relocatable Object Module ....... 7-7

The Interactive Configuration Utility ..... ;...... 7-7

CHAPTER 8 RUN-TIME ERROR PROCEDURES

APPENDIX A

SUMMARY OF OPERATIONS

APPENDIXB

PASCAL-80 VOCABULARY

APPENDIXC

SUMMARY OF COMPILER

DIRECTIVES

APPENDIXD

COMPILER ERROR MESSAGES

APPENDIXE

RUN-TIME ERROR MESSAGES

APPENDIXF

ISIS-II ERROR MESSAGES

APPENDIXG

SYNTAX SUMMARY

APPENDIXH

SUMMARY OF EXTENSIONS TO

STANDARD PASCAL

APPENDIX I

IMPLEMENTATION DETAILS

APPENDIXJ

PASCAL REFERENCE TEXTS

APPENDIXK

DIRECTORY OF RELEASE DISKETTES

•

~ n

•

TABLE

F-I

TITLE

Nonfatal Error Numbers Returned by

F-2

PAGE

System Calls ........................ F-3

Fatal Errors Issued by System Calls ....... F-3

TABLES

•

ILLUSTRATIONS

•

FIGURE

I-I

TITLE PAGE

Program Development Cycle ............. 1-3

3-1 Examples of Predeclared Procedures, reset, rewrite, get, put, and close ........ 3-2

3-2 Examples of Predeclared Procedures reset, seek, and get ................... 3-3

3-3

3-4

3-5

3-6

Examples of Predeclared Procedures read and readln ...................... 3-3

Examples of Predeclared Procedures new, mark, and release ................ 3-6

Examples of Predeclared Procedures ord and chr .......................... 3-7

Example of Predeclared Procedure exit .... 3-8

FIGURE

3-7

TITLE

Examples of String Manipulation

PAGE

Routines length, pos, concat, copy, insert, and delete .......................... 3-10

3-8

4-1

6-1

6-2

Example:; of Character Array Routines scan, moveleft, moveright, and fillchar . 3-11

Main Memory Layout for a 64KB System .. 4-3

A Partitioned Pascal Program ............ 6-3

6-3

8-1

Compiling and Joining a Partitioned'

Pascal Program ...................... 6-4

A Pascal Program With External Linkages . 6-7

Use of the errorset Procedure ............ 8-2

• ix

•

' n

General Description

CHAPTER 1 INTRODUCTION

Pascal is a highly structured computer programming language devised in 1970 by

Professor Niklaus Wirth of Zurich.

It is a very powerful high-level language which is now gaining wide acceptance as a useful programming tool.

PASCAL-SO is a Pascal language system designed for the Intel SOSO/SOS5 microcomputers under control of the ISIS-II Operating System.

It is designed to run on a 64K byte Intellec or Series II microcomputer development system plus CRT and floppy diskettes.

•

Although a minimum system would include only one single-density diskette, for maximum efficiency a system with at least two double-density diskettes is recommended.

The PASCAL-SO System is composed of a Run-Time System (RTS) and a compiler which itself executes on the Run-Time System. The PASCAL-SO compiler converts

Pascal source code into an intermediate P-Code (pseudo-code), which is then interpreted by the Run-Time System.

•

The ISIS-II text editor is used to create the Pascal source file(s). The PASCAL-SO compiler is then used to compile the source programs so that they may be executed on the RTS. A listing of the PASCAL-SO source program is provided by the compiler during compilation. Any error messages are included in this listing.

Complete operating instructions can be found in Chapter 4, along with a more complete description of the structure of the PASCAL-SO System. Chapter 5 presents four PASCAL-SO example programs, including a complex example, along with typical user interaction with these programs. All example programs are listed in the manual and are also present on the PASCAL··SO Release Disk in source form.

PASCAL-SO programs may be loaded and executed under control of the

PASCAL-SO Command Line Interpreter, as described in Chapter 4, or they may be converted to standard ISIS-II object modules and executed directly in the ISIS-II environment. The procedure for generating these Load and Go versions is described in Chapter 6. Also described in Chapter 6 are the PASCAL-SO extensions which allow a Pascal program to link with non-Pascal object modules coded in PLiM-SO,

FORTRAN-SO, or ASM-SO.

Chapter 7 describes the procedures necessary to generate an RMX/SO applications system which includes a Pascal task. The RMX/SO Interactive Configuration Utility, which automates much of this process, is also discussed.

•

A powerful feature of the PASCAL-SO System is the ability for a Pascal program to declare an error procedure which is invoked upon the detection of a run-time error.

Use of this facility, which is described in Chapter S, is extremely important in applications systems, since it allows a program to retain control over its execution, even in the event of run-time errors.

1-1

1-2

Introduction

The PASCAL-80 Language

The P ASCAL-80 language is a superset of the programming language Pascal, as defined in

PASCAL User Manual and Report,

Second Edition, by Kathleen Jensen and Niklaus Wirth (Springer-Verlag, 1974, Corrected Printing, 1978). This book defines "Standard Pascal" and will be referred to in the remainder of this manual as

PASCAL User Manual. Since PASCAL User Manual is a concise reference for the features of Standard Pascal, the programming language PASCAL-80 will be described only by its differences from, and extensions to, Standard Pascal, the assumption being that the reader is familiar with the contents of PASCAL User

Manual, and moderately conversant with Standard Pascal.

System Structure

As mentioned, the P ASCAL-80 Run-Time System is an interpreter, which executes

P-Code generated by the PASCAL-80 compiler. A detailed description of the structure of the P-Code can be found in Appendix I.

PASCAL-80 programs can be partitioned into SEGMENT (overlay) procedures, and, therefore, very large programs may be executed. This powerful PASCAL-80 extension is described in Chapter 2.

The PASCAL-SO System incorporates a powerful program tracing facility which allows the programmer to selectively monitor the execution of a Pascal program, and to interrupt execution at any point.

P ASCAL-80 allows a user error procedure to be specified, so that a program may retain control in the event of a run-time error, and perform error recovery procedures.

Program Development Cycle

The cycle for development and execution of PASCAL-80 application programs that must be performed by the programmer is as shown in figure 1-1.

PASCAL-80

•

PASCAL-80

The source program is created on diskette with the ISIS-II text editor.

EDITOR

-PASCAL

... Loads the Run-Time System which executes compiled PASCAL programs.

PASCAL·BO

RUN-TIME SYSTEM

PASCAL-BO

COMPILER

>COMPPROG ...

... Loads the eompiler to convert the source program into an interpreted object form known as intermediate code, or P-code.

)PROG ...

... Loads the intermediate code file into the Run-Time System, and executes it.

LOADED

APPLICATION

PROGRAM

Figure 1-1. Program Development Cycle

1015·1

Introduction

•

1-3

• !

•

CHAPTER 2 LANGUAGE FEATURES

As mentioned in the Introduction, PASCAL-SO is an extension of Standard Pascal, as defined in the PASCAL User Manual, and it is assumed that the reader is familiar with the structure and characteristics of Standard Pascal. In this chapter we will describe the features of PASCAL-SO in terms of Standard Pascal, and present examples of all language extensions.

Program Structure

The complete, detailed PASCAL-SO syntax is presented in Appendix G; the following briefly describes the overall structure of a Pascal program.

Every PASCAL-SO program consists of a heading, followed by a block, which in turn is followed by the program terminator, a ".". The block contains a number of declaration parts, which define all objects local to the block, followed by the statement part, which specifies the actions to be performed on the declared objects.

<block>

Program Heading

The program heading names the program, which allows the predeclared procedure

"exit«name>}" (described below) to force the program itself to cease execution.

Any file identifiers, if present in the heading, are ignored. or

::=

PROGRAM <identifier>

<program heading> ::= PROGRAM <identifier>l<file identifier list»

The following are legal program headings:

PROGRAM sort;

PROGRAM convert(input,output);

PROGRAM generate(listing);

Label Declaration Part

Any statement in a PASCAL-SO program may be labelled with an unsigned integer label followed by a colon. This allows references to this statement by go to statements. Any such label must be declared in the label declaration part, which has the form:

LABEL <label> {, <label>

I where <label> is an unsigned integer of at most four digits. Examples of label declarations are:

LABEL 1,2,3,4,5;

LABEL 1999,2999,6789;

2-1

2-2

Language Features

Constant Declaration Part

A constant declaration defines an identifier as a synonym for a constant. The general form for this declaration is:

CONST <identifier>

<constant>; ) where <constant> is either a number, a constant string, or a constant identifier.

Examples of constant declarations are:

CONST maxfiles

CONST version

'PASCAL-80 V1.0'; nfiles

= maxfiles;

Type Declaration Part

The type declaration part is a mechanism for creating new data types. The declaration determines a set of values for the new type and associates an identifier with that set. The general form for this declaration is:

TYPE <identifier> = <type>; {<identifier> = <type>;

Examples of type declarations are:

TYPE weekdays

(monday, tuesday, wednesday, thursday, friday);

TYPE filenumber

1 .. nfiles; filetype

(source,object);

Variable Declaration Part

Every variable used in a program statement must first be declared in the variable declaration part. This declaration associates both an identifier and a data type with the variable being declared. The general form of this declaration is:

VAR <identifier> \ ,<identifier» : <type>;

{<identifier> {,<identifier>

I :

<type>;

Examples of variable declarations are:

VAR alpha,beta,gamma: integer;

VAR name: string[30);

Procedure and Function Declaration Part

Every procedure and function must be defined before its use. A procedure declaration associates an identifier with a set of actions, which may then be invoked by referring to the identifier. Functions are similar to procedures but also yield a result value, and therefore can be referred to within expressions. Procedure and functions are discussed below in more detail.

Data Types

Every variable appearing in a Pascal program must be associated with one and only one data type. The following data types are predeclared in the PASCAL-SO System; using the type declaration facility, new data types of arbitrary complexity may be defined.

In the following discussion, a word is defined to be a two-byte quantity, aligned on an even byte boundary.

PASCAL-80

•

PASCAL-80

•

The Boolean Type

A variable of type boolean can have one of the values denoted by the predefined identifiers false and true. The definition of the type is:

TYPE boolean = (false, true);

It should be noted that under this definition, false<true.

A variable of type boolean requires two bytes of storage, although only the least significant bit is significant.

The Integer Type

The standard type integer is defined to be a subrange of whole numbers. In

PASCAL-80 its definition is:

TYPE integer = -32768 .. 32767;

There also exists a predefined standard variable of type integer named maxint which has the value 32767.

A variable of type integer occupies two bytes of storage.

The Real Type

Variables of type real have values which are elements of a subset of real numbers. In

PASCAL-80, a value, r, of type real will satisfy the following:

1.17*10E-38<=r<=3.40*10E38 (approximately) or -3.40*1 OE38<=r<=-1.17*1 OE-38 (approximately)

Further information concerning the characteristics of real values in PASCAL-80 can be obtained by consulting the Intel publication

808018085 Floating Point Arithmetic

Library User's Manual,

Publication Number 9800452.

A variable of type real occupies four bytes of storage.

The Char Type

A variable of type char has values which are elements of the finite set of characters.

In PASCAL-80, this set of values can be defined by:

TYPE char = chr(0) .. chr(255)

The ASCII control and graphic coding is employed, and therefore so is the ASCII collating sequence.

A variable of type char occupies two bytes of storage, although the most significant byte is always zero.

The ARRAY Type

A variable of type ARRAY has values which are composed of a fixed number of components, each one of which is of the same type, called the base type. In

PASCAL-80, the ARRA Y type is as specified in Standard Pascal.

Language Features

2-3

2-4

Language Features

If the ARRAY declaration is prefixed by the reserved word PACKED, the compiler will attempt to minimize storage requirements by packing more than one component into each word. However, this packing is subject to the following restrictions:

1. Packing will never cross word boundaries. This implies that an array will be packed only if any value of the base type can be represented in one byte or less, such as boolean, char, or 0 .. 73. Packing densities for various base type representations are as follows:

Bits to Represent Value Components/Word

3-8

9 and up

1 (no packing)

2. An array will be packed if and only if the prefix PACKED appears immediately preceding the last occurrence of the symbol ARRAY. In particular, a1: PACKED ARRAY[O .. 10] OF ARRAY[O .. 10] OF char; will not be packed, while a2: ARRAY[O .. 10] OF PACKED ARRAY[O .. 10] OF char; a3: PACKED ARRAY[O .. 10] OF PACKED ARRAY[O .. 10] OF char; a4: PACKED ARRAY[O .. 10,O .. 10] OF char; will all be packed two characters per word.

3. A components of a PACKED ARRAY may not be passed as a variable parameter to a FUNCTION or PROCEDURE.

It may, however, be passed as a value parameter.

PASCAL-SO

•

The RECORD Type

A variable of type RECORD has values which are composed of a fixed number of fields, with no restriction on the type of each field. In PASCAL-SO the RECORD type is as specified in Standard Pascal.

If the RECORD declaration is prefixed by the reserved word PACKED, the compiler will attempt to minimize storage requirements by packing more than one field into each word. However, this packing is subject to the following restrictions:

1. Packing will occur only with adjacent fields of subrange or scalar type. Any field which is of a structured type (ARRAY, RECORD, SET, string, or FILE) will always begin on a word boundary.

2. Packing will never cross word boundaries. This implies that two or more fields will be packed into a word only if the total number of bits required for their combined representation is less than 16.

3. The prefix PACKED must appear before every occurrence of RECORD or

ARRA Y in order for the fields themselves to be packed.

4. A field of a PACKED RECORD may not be passed as a variable parameter to a

FUNCTION or PROCEDURE. It may, however, be passed as a value parameter.

•

PASCAL-80

•

The String Type

P ASCAL-80 contains the predeclared data type string. this type is similar to a

PACKED ARRAY OF char, but it also incorporatesil dynamic length byte.

Therefore, even though the allocatedlepgth of a. string remains Jixed, its dynamic length can vary according to theassig~l11entsmade to it. ltjsonly. the dynamic length of a string which is involveqinanystringoperations.

~heal~pc~ted length of a string may be from 1

t0255

characters, 80 characters being the default length. In addition, the individual characters of a string may be referenced, using alfindex of I to the length of the string. The following examplesjllustrate the use of strings: ch: char; name: string [30]; address: string;

Thellariable name is of type stt'iOg, with a maximum length

()f30 characters

The variable address is of·type string,wittifimaximum lengthpf 80pharacters name:= 'George Washington'; read{input,address); ch := name[3];

Language Features

•

The SET Type

In PASCAL-80, as in Standard Pascal, the SET type defines the set of all subsets of values of a base type, which must be either a scalar type or subrange type.

The maximum number of elements in a set in PASCAL-80 is 4080, each one of which must satisfy the following: or~«element»

>=

The FILE Type

As in Standard Pascal, a FILE is a structure consisting of a sequence of identical

(i.e., of the same type) components. The type is distinguished from the ARRAY type in that the FILE type has a variable number of components.

In PASCAL-80, each structure of type FILE must be associated with an ISIS-II device or disk file, which are discussed in Chapter 2 of the ISIS-II User's Guide. This association is established by the reset or rewrite proced ures, described below, and is terminated by the close procedure, also described below .

Note that every open file allows for update acc(:ss i.e., each file is opened with an access mode value of 3. Standard Pascal does not allow a file to be opened for

"input only" or "output only".

As in Standard Pascal, the two textfiles input and output are predeclared in the surrounding environment. These files are automatically associated with the ISIS-II system console devices :CI: and :CO:, respectively, and do not have to be opened by the Pascal program.

P ASCAC80has.

Untyped files

.arid predeclared file typesw~ic:tl~I'~~"*~erisionsto StandardP~sCl¥:

ERACTIVE files. ..

2-5

2-6

Language Features

Untyped Files

Untyped files were introduced so that a program could perform efficient, unstructured block transfers to and from memory. These transfers are performed with the procedures blockread, block write, bufferread, and bufferwrite.

The following example program will copy file SSS to file DOD, using an 8K memory buffer: program tcopy; const size"" 8192; var s,d: file; sand d are untyped files buffer: packed array[1 .. sizeJ of char; length: integer; begin reset(s, 'SSS'); rewrite(d, 'DO~'); open SSSfor reading and create DOD if necessary length := bulferread(s,buffer,size); read in the first chunk white length

Odo begin length

;= bufferwfite(d,bufler,size); write full chunk length;= bufferread(s,buffer,size); and read the next end if length

<

0 then write out the last bitot the file length := bufferwrite(d,buffer,-iength) else writeln(output, 'Error in read ing file'); close(s); close(d); end.

PASCAL-SO

•

INTERACTIVE

Files

In the P ASCALUser Manual, the statement read(f,chlis defined to be ch:= f ;get(l) if f is of type TEXT (FILE of char). This defitlition implies that a getCf) is executed upon opening the file, sO that the first assignment from the buffer variable will be

Valid. This initial get(f) is a cllmbel'someconstraint when the file is opened to an interactive terminal, since a program

will

hang waiting for that initial character. In order to solve thisproblem, the file typeINTERAFTIVE exists. A file.of type

INTERACTIVE is similar to a file of JypeTEXT ioaU respects save that read(f ,ch) is defined to be get(f); ch :'" f ; andaget(f) isnot performed when theme iso:p.ened. The predeclared file input is of type INTERACTIVE.

•

The

POINTER Type

In PASCAL-SO, as in Standard Pascal, the POINTER type defines a seto! values pointing to elements of a given type.

•

PASCAL-SO

•

PROCEDUREs and FUNCTIONs

As in Standard Pascal, PASCAL-SO allows for a~,sociating an identi fier with a program part, and hence defining named PROCEDUREs and FUNCTIONs. The syntax for these declarations is the same as in Standard Pascal, except in one respect:

In PASCAL-SO, procedures and functions may not be used as arguments to other procedures or functions.

SEGMENT Procedures

In order to allow for the execution of very1arge programs which cannot fit into main memory, PASCAL-SO allows these programs to be partitioned into SEGMENT

PROCEDUREs or SEGMENT FUNCTIONs.

This

language construct allows for dynamic overlaying, in that a SEGMENT PROCEDURE(FUNCTION) is resident in memory only when it is a part of the dynamic execution thread. Once a SEG-

MENT PROCEDURE (FUNCTION) exits, the portion of memory which it occupied is now free for some other overlay.

A SEGMENT is declared as follows:

SEGMENT PROCEDURE initialize(firsttime: boolean); and

SEGMENT FUNCTION getcharacter: char;

Language Features

• where" ..... " denotes the body ofthePROCEDURE (FUNCTION) which has the same syntax as non-overlay program parts.

The main body of prograniis always resident, as is every procedure which is not a

SEGMENT. AU SEGMENT declarations must. occur before any of the resident procedure declarations or the main body of the program.

•

2-7

•

~ n

CHAPTER 3 PREDECLARED PROCEDURES

As in all implementations of the Pascal programming language, P ASCAL-80 contains a number of predeclared procedures and functions. These include the standard procedures as defined in the PASCAL User Manual, plus additional procedures which are extensions to Standard Pascal. These predeclared procedures and functions are declared in the Run-Time Environment surrounding each Pascal program, and may be redeclared with no conflict.

The predeclared procedures and functions include generally useful utility routines, data structure access routines, and routines designed to allow P ASCAL-80 programs access to the powerful system features of ISIS-II. The following discussion assumes that the reader is familiar with the characteristics of ISIS-II, as described in the Intel publication

ISIS-II User's Guide,

Publication Number 9800306.

•

File Manipulation Procedures reset(f)

Resets the current file position to the beginning of the file f, and positions the file pointers to the first record in the file. If f is not an INTERACTIVE file, a get(f) is performed. The function eof(f) becomes true if f is empty, otherwise eof(f) becomes false. See figun:s 3-1 and 3-3 for examples.

reset(f.<string»

Opens an existing lSIS-I1fi~eWith theJ1a:roe <string>,associatesf with

that file,and

thenperft>rms reset{f). See figux~3-2 fofanexample.

rewrite(f ,<string»

Creates.

an

IS .. Ufile ,_s$ociatesfwlth that file, and

sets thefUel'ointerstothe beginning ofthefile.

See

figure

3-1

for an example.

close(f)

Closes the file associated with f and removes that association. See figure 3-1 for an example.

put(f)

Writes the value of the buffer variable ft to the file at the current file position and advances the position to the next component. The procedure put(O is defined only for typed files. See figure 3-\ for an example.

get(f)

Assigns the value of the current component of the file f to the buffer variable ft, and advances the file pointers to point to the next component.

If no current component exists, eof(f) becomes true, and the value of ft is undefined. The function eof(f) must be false upon entry, and f must be a typed file. See figures 3-1 and 3-2 for examples.

3-1

3-2

Predeclared Procedures

(

This program illustrates the use of the predeclared procedures reset, rewrite, get, put, and close:

} program threel; var i: integer; datafile: file of integer; begin (3-1} rewrite(datafile,':Fl:DDATA.DAT'); for i := 0 to 10 do begin datafile" := i; put(datafile) ; end; reset(datafile); repeat writeln(datafile":5); get(datafile) ; until eof(datafile); close(datafile); end. {3-1} create DDATA.DAT on drive write O •• 10 onto the file re-position file to beginning} read in and display the integers

( and then close the file}

Executing this program will result in the following output:

10 o

Figure 3-1. Examples of Predeclared Procedures reset, rewrite, get, put, and close

PASCAL-SO

• read(f, v1 , ... , vj)

This procedure may be used only on TEXT or INTERACTIVE files. If f is omitted, input is assumed. Note that this construct is equivalent to: read(f,v1); ... ; read(f,vj)

If vi is of type string, read(f, vi) will read up to the end of the line and set eoln(f) true. See figure 3-3 for an example. readln(f, v1 , ... , vj)

This construct is equivalent to the sequence: read(f,v1, ... ,vj); readln(f) where readln(f) is used to read to, and subsequently skip past, the end of the current line. If the file is not exhausted, eof(f) and eoln(f) are set false. See figure 3-3 for an example.

•

PASCAL-SO

This program uses the data file created in program threel to illustrate the use of the predeclared procedures reset, seek, and get:

} program three2; var i: integer; datafile: file of integer; begin {3-2) rese t (da ta file, ' : F 1: DDATA. DAT' ) ; for i

:= 10 downto

6 do beg in

{ open the file DDATA.DAT on drive 1 } se e k (da ta f i 1 e , i ) ; get(datafile} ; write(output,'Record number;',i:3); seek to a record } get its value) and display the data write(output,

I writeln(output}; end; close (datafile); end. {3-2)

Record value:

,datafile .... :3)i

Predeclared Procedures

•

Executing this prog ram will result in the fa llowi ng output:

Reco rd number: 10

Record number:

Record

Record numbe r:

Record

Record number:

Record

Record value: 10 val ue :

9 value:

8 value:

7 value:

Figure 3-2. Examples of Predeclared

Proced~res

reset, seek, and get

{

This program illustrates the use of the predeclared procedures read and readln:

} program three3; var a,b,c,y,z: char; datafile: text; begin ( 3 - 3 ) rewrite (datafile,' :FI:TDATA.DAT'); writeln(datafile, 'A.B'}; writeln(datafile,'YZ'}; reset(datafile); a := y :=

, 1 b

' 2 c

;

; z :

I; read (datafile,a,b,c,y,z); writeln(a,b,c,y,z); reset(datafile} ; a b

•

I' ;

c 13 I;

I; z '9

I; readln (datafile ,a); readln(datafile,y); writeln(a,b,c,y,z); close(datafile); end. ( 3 - 3 ) create a temporary file on drive 1 } write a two character line} and a two character line} re-position file to the beginning} initialize variables) c

I , since at end-af-line display the values ) read the

'Ali

skip to the next line} read the 'Y' and skip to eof }

•

Executing this program will result in the following output:

AB YZ

A23Y9

Figure 3-3. Examples of Predeclared Procedures read and readln

3-3

3-4

Predeclared Procedures

write(f

,v1 , ... ,vj)

This procedure may be used only with TEXT or INTERACTIVE files. If f is omitted, output is assumed. Note that this construct is equivalent to write(f,v1); ... ; write(f,vj).

See figures 3-2 and 3-3 for examples.

writel n(f,

vi, ... ,

vj)

This construct is equivalent to the sequence: write(f,v1); ... ; write(f,vj) where writeln(f) writes an end of line character of the file f. See figures 3-2 and 3-3 for examples.

page(f)

Causes a form-feed character to be written to the TEXT or INTERACTIVE file f.

n·ip.ulali()I'l.·

.·Ii~l'letiQ~.········

..

<:arr~yj1~kl.~"gtb·:<[,<br~tl~

.. Char:>D: inte9~r

integer

The$.;~nct.iQris;;;used···t~t1.#Q andw~ite atbitr~rylength

buffers from

Ito

anunwpedfilef. The maJiooumnumper of bytes Which will be transferred isgivetl

(I

.sO<:array>;aP

ED

ARRAY

OF

char. should/be at1ea ... is p~es

10

-chat>; ani er expression

0 .. 255 , is

specified.

will

be tratlsfe~~ pto including the: breakpYt¢. The valueS of tn.ese functionsarea~fQJlows, re <length> signifies~'enumber of bytes trill1sferreQr

PASCAL-80

•

• valu

,," ' , .

I'll""

<length>lfbre-a~QnpytEl

ct<:\ef)gth>

if~of orl'ipl:)reak.

'::'::.

lc)c~[lad(fl~array>, loC"r!Je{l,<:tlrrtlY~,

>1):iinteger k>

1) : integer

T~esef

........ s~r~ usedtpread.~nd

... w. lllJtyped file f.a:9tctions

7 byte blocks tbenumberof

h1·

.f~tredi Ibeleng(, ..atr~¥»~CKEI?t\~.RA,Y tipI~ of 512byt

:>~~specified~ ce nQ '3rray bounds

. ...............

........... ar fr~rntto actually tratl\S.w

,sho checkiq~ii~done ll lf

.. start~bl()c:k».~iMbeperf9rmed l4 an be~

<starh

to

that

Qnin the. file; other . the transfer will begin. at the current.f~le positiPU·

_.,. disk. i.

R~ER

·ril~··ris ·PP~~ti?l1~d'3~·~l1a·?~!~le,

.·.r1se

returnsfalS¢~ilf.t··i~a

......q.

",ill

becOmetru is

~.q\l~l

... file hep fisexl}aysted' i.e'iwhenthe.file

G;rFl.

If f is

assoc'

ith:CI:, press~ gCQNTROLtZiuofre edinputdata will true. of(f) to becpro.~

•

Predeclared Procedures

•

PASCAL-SO

eoln(f): boolean

Returns true if the TEXT or INTERACTIVE file f is positioned at an endof -line character, else returns false.

ioresu

I t :

integer

Returns the error cOUeM the last 110 operation. If no error was detected, the value is

O.

•

Dynamic Allocation Procedures new(p)

Allocates a new variable t and assigns th(! address of t to the pointer variable p, where p is defined as:

VAR p: t;

If the type of t is a record type with variants, new(p) allocates a storage area large enough to accommodate the largest variant. See figure 3-4 for an example.

new(p, t1 "." tj)

Allocates a variable of the appropriate size for the variant with tag field values equal to the constants tl, ... ,tj and assigns the address of that variable to the pointer variable p.

mark(p)

Assigns the address of the current top of the HEAP to the pointer variable p. See figure 3-4 for an example.

relea$e(p)

Sets the top of the HEAP to the value of the pointer variable p. See figure

3-4 for anexample.

memavail:integer

Returns the~rithmetiodiffer¢n~e between the current bottom of the executionstack and the top of the heap, in 16-bit words.

•

Arithmetic Functions abs(x): <type of x>

Computes the absolute value of x. The type of x must be either integer or real, and the type of the function is the type of x.

sqr(x): <type of x>

Computes x*x. The type of x must be l~ither integer or real, and the type of the function is the type of x.

3-5

3-6

Predeclared Procedures

{

This program illustrates the use of the predeclared procedures new, mark, and release:

} program three4; type intarray = array[O •• lO] of integer; var i: integer; htop, htopl: -integer; buffer: -intarray; beg in mark (htop); new(buffer) ; mark(htopl); writeln(ord(htopl) - ord(htop)); for i:=O to 10 do buffer-[i] := i*i;

( process the array release(htop); record the top of the HEAP } allocate an array of integers from the top of the HEAP. This

moves

the top of the HEAP upwards by 22 bytes. record the new HEAP top } display the amount of allocated space set the values of the array} set the top of the HEAP back to its original value, which was

saved

in htop. }

The pointer variable 'buffer' now points to locations above the valid area of the HEAP, and must not be used until, using the

'new' procedure again, it points to a valid array.

I end. (3-4)

Executing this program will result in the following output:

22/

Figure 3-4. Examples of Predeclared Procedures new, mark, and release

sin(x): real cos(x):. real

log (x): real

exp(x): real

In(x): real sqrt(x): real arctan(x): real

These functions all require x to be either integer or real, and all return a result of type real.

trunc(x): integer

Returns the whole part of the real argument x. The fractional part is discarded, so that trunc(S.78)=S, and trunc(-2.9)=-2.

round(x): integer

Returns the rounded integer of the real argument x. This function is defined as follows: round(x) = trunc(x

0.5) if x>=O round(x) = trunc(x-O.5) if x<O

PASCAL-SO

•

PASCAL-SO

•

pwroften(x): real

Returns 10 raised to the xth power, where x

IS an integer such that

O<=x<=38.

Predicates odd(x): boolean

Returns true if x is an odd integer, otherwise returns false; x must be of type integer.

Transfer Functions ord(x): integer

Returns the ordinal number of the value of x in the set defined by the type of x. Note that x must be of a scalar type. See figure 3-5 for an example.

chr(x): char

Returns the character whose ordinal number is the value of x, if it exists; x must be of integer type. See figure 3-5 for an example.

Miscellaneous Routines succ(x): <type of x>

Returns the successor value of x, if it exists; x must be of a scalar or suqrange type.

pred(x): <type of x>

Returns the predecessor value of x, if it exists; x must be of a scalar or subrange type.

•

Predeclared Procedures

•

This program illustrates the use of ~he predeclared procedures ord and chr:

} program threeS; type colors = (red,green,yellow,blue); beg in writeln (ord (red): 3,ord (green): 3,ord (yellow): 3,ord (blue): 3); l writeln(chr(ord('A'))); end. ( 3 - 5 )

Executing this program will result in the following output:

A o

1 2 3

Figure 3-5. Examples of Predeclared Procedures ord and chr

3-7

3·8

Predeclared Procedures

Returns the number of bytes thatwould be or are aUocated fotthe argu·

mffiL .

eXit(r<:procedure/funct.IQnidentifier;»

Causes an exit from the named procedure or functioll,. which should part of tbedYl1amic .executioo thread. If the

identifi~tisthe

name. of the pro·

gr~m

~ii!:lld

itself, then execution

JiU.!~rmjnat~.

an?.s0ntrolwill return

toth~c9~;

handler of the

PASq~I>"80 Run<rjmeSystem.Seef.~ure

3·6forl,t,!l'):

eXf,lmpie. .

{

This program illustrates the use of the predeclared procedure exit:

) program three6; var

i: integer;

procedure alpha; forward; procedure beta; forward; procedure gamma; fo rwa rd; procedure alpha; begin beta; writeln('Exit alpha'); end; {alpha} procedure beta; beg in

gamma;

write1n('Exit beta'); end; {beta) procedure gamma; begin write('Please enter a digit: '); read1n(i);

writeln;

write1n('Thank you'); case i of

1: exit(three6);

2: exi t (alpha);

3: exit(beta);

4: exit (gamma) ; end; {case} writeln('Exit gamma'); end; {gamma) begin alpha; writeln('Exit program'); end. {3-6)

Executing this program will result in the following output sequences, depending upon the value of <n>:

Please enter a digit: <n>

Thank you

<n> is entered by the user )

Thank you

Exit program

Thank you

Exit alpha

Thank you

E:x i t beta

Thank you

Exit gamma

Exit program E:xit alpha

Exit beta

Exit program

ExIt alpha

Exi.t program

{ <n>

1) {<n> =

{<n> =

4 ) {<n> >=

<n> <= 0) or

Figure 3·6. Example of Predeclared Procedure exit

PASCAL-80

•

Predeclared Procedures

•

PASCAL-SO

•

gotoxy«column>,<row»

Positions the CRT cursor to the specified <column> and <row>. Both arguments must be integers. Position (0,0) is the top left corner of the screen.

setpointer(p,

Places the address of the variable v into the pointer variable p.

portinput(p,v)

Inputs a value from the

8080/8085

I/O port p and set variable v to that value.

portoutput(p,e)

Outputs the value of the integer expression e to the

8080/8085

I/O port p.

errorset(p)

Causes p to become the current error procedure. The procedure p must be a parameterless procedure declared at the global level of the Pascal program.

The errorset(p) procedure may be executed as often as desired; each invocation causes the previous error procedure to be overridden by the new procedure specified by errorset.

•

String Manipulation Routines length(s): integer

Returns the current value of the dynamic length of the string s. See figure

3-7 for an example.

pos«pattern>,s): integer

Returns the position in the string s of the first occurrence of the string

<pattern>. If <pattern> is not a substring of s, 0 is returned. The position returned is the position of the first character of the match. See figure 3-7 for an example.

concat(s1, ... ,sj): string

Returns a string which is the concatenation of the strings sl to sj. There is no restriction on the number j except that the resultant string be less than

256 characters. See figure 3-7 for an example.

copy(s,<index>,<length»: string

Returns a substring of s, starting at position <index>, of <length> characters. See figure 3-7 for an example.

insert(s1,s2,<index»

Inserts the string sl into the string s2, starting at the <index>th character in s2. See figure 3-7 for an example.

3-9

3-10

Predeclared Procedures

{

This program illustrates the use of the string manipulation routines length, pos, concat, copy, insert, and delete:

J program three7; var sa,sb,sc,sd: strlng[70]; beg In sa

'First STRING to be defined'; sb := 'Second STRING we are defining'; sc

I in this example'; sd

:= " ; ( null string writeln(length(sa) :3,length(sd) :3); writeln(pos('nd ',sb):3, pos('XXX',sc),3); writeln(concat(sb,sc)); writeln(copy(sa,7,3) ); insert( 'Pascal

,sb,S); wr I teln (sb); delete(sa,14,6); writeln(sa); end. ( 3 - 7 )

Executing this program results in the following output:

26 0

5 0

Second STRING we are defining in this example

STR

Second Pascal STRING we are defining

First STRING defined

Figure 3-7. Examples of String Manipulation Routines length, pos, concat, copy, insert, and delete delete(s,<index:>,,c(lenlth»

Deletes·<tength>chafacter~>f:om.··~~·~·stril1;s, stlll'ting~t~osjf~~n <i~dex>;

See figure 3-7 fOLan~xamply.

Character Array Manipulation Routines

These routines operate on PACKED ARRAY OF char structures. No range checking is performed, so they should be used with some care.

scan«length>~<par1ialexpresSiof1>J.a):inteler

Scans the ARRAy a for a chatapter which satisfies the partial expression,

Which must be of the form:

"<>" or "=" follo\lliedby<characterexpres.sloh> where <charaCter expression> is an eXpression which evaluates to a character value. TheARRA¥ a Il1aybe.subsq·jpted toden~t~ a~~J,"ting p~int; otherwise the scan starts at the beginning of <a. The. number of characters scanned is returned. If

<partialex~ pression>,

O~!ireturll¢(i; ifnq chal'a¢terissatisfactorYi<len~th> isre~urn: ed. If <length:> is negative, the array is scanned backwards and the value returned

will

be <::;::0. See figure 3-8 for anexampl~.

PASCAL-SO

•

Predeclared Procedures

•

PASCAL-SO

moveleft «source>,<dest>,<length» moveright«source>, <dest> , <length»

Both of these routines move <length> bytes from ARRAY <source> to

ARRAY <dest>. Either or both <source> and <dest> may be subscripted to denote a starting position other than the first character. The moveleft routine starts

at

the specified left end of both arrays and copies moving right. The moveright routine starts at the right end of both arrays and copies bytes moving left. See figure 3-8 for an example. fillchar(a,<length>,<character»

Fills the ARRAY a with <length> <character>'s. The ARRAY may be subscripted to denote a starting position other than the first character. See figure 3-8 for an example.

•

This program illustrates the use of the character array routines scan, moveleft, moveright, and fillchar:

) program three8;

var

ca,cb: packed array[0 .. 9] of char; sa: string[30]; begin ca

'0123456789'; writeln(scan(10,='4' ,cal :3, scan(l0,='4' ,ca[2]) :4); writeln(scan(lO,='X',ca):3, scan(5, ='X',ca):4)i writeln(scan(-10,='8' ,ca[9]) :3, scan(-10,='X' ,ca[9]

):4);

{ copy ca to cb both ways moveleft (ca ,cb, si zeof (ca) ); writeln(cb); moveright(ca,cb,sizeof(ca)) ; writeln(cb) ; moveleft(ca,ca[l] ,9); { the incorrct way to move characters up by one position writeln(ca) ; moveright(cb,cb[l]

,9); writeln(cb); the correct way } sa := 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'; writeln(sa); fillchar(sa[l1.25,'O'); { a string is a packed array of char) writeln(sa) ;

~nd.

{ 3 - 8 )

Executing this program results in the followirlg output:

-1 -10

0123456789

0000000000

0012345678

ABCDEFGHIJKLMNOPQRSTUVWXYZ

OOOOOOOOOOOOOOOOOOOOOOOOOZ

•

Figure 3-8. Examples of Character Array Routines scan, moveleft, moveright, and fillchar

3-11

•

CHAPTER 4 OPERATING INSTRUCTIONS

The PASCAL-80 System is composed of a Run-Time System (RTS) and a compiler which itself executes on the Run-Time System. The PASCAL-80 compiler converts

PASCAL source code into an intermediate code which is then interpreted by the

Run-Time System.

The ISIS-II text editor is used to create the Pascal source file(s). The PASCAL-80 compiler is then used to compile the source programs so that they may be executed on the RTS. A listing of the PASCAL-80 program is provided by the compiler during compilation. Any error messages are included in this listing.

Getting Started with PASCAL-80

Each user is provided with all the software that makes up the P ASCAL-80 development system. This software is contained on each of two (2) diskettes (single and double density); be sure to use the appropriate diskette on your disk hardware. The directory listing of each of these diskettes can be found in Appendix K.

Release Disks

Each P ASCAL-80 Release Disk contains the software listed below:

Compiler

RTS

Utilities Libraries Example Figures

COMP.COD PASCAL JOIN.COD PBORUN.LlB EX.PAS

PASCAL.RES GENOBJ.COD P801SS.UB

FIG31.PAS

BUFFER.PAS FIG32.PAS

P80RAR.LlB SEEKEX.PAS FIG33.PAS

P80EXT..LlB ERROR. PAS FIG34.PAS

PBOISS.IPLB PEOPLE. OAT FIG35.PAS

FIG36.PAS

FIG37.PAS

Initial Steps

It is highly recommended that you perform the following steps to get started.

Initialize a blank diskette as an ISIS-II system diskette using the !DISK command.

2. Copy all files from your PASCAL-80 Release Disk onto the ISIS-II system diskette to create a PASCAL-80 system diskette that you can load from drive O .

3. If you run out of space on the ISIS-II system diskette, note that in order to run

PASCAL-80 you need only the following files::

ISIS.DIR

ISIS. MAP

ISIS.TO

ISIS.LAB

ISIS. BIN

ISIS.CLI

4-1

4-2

Operating Instructions

4. For most applications, the following files on the ISIS-II system diskette are also useful (but not required to run PASCAL-80):

DIR

COpy

DELETE

RENAME

ATTRIB

SUBMIT

5. It is a good practice and highly recommended that the files containing PASCAL be write-protected. Using the ISIS-II ATTRIBUTE command, change the attributes of the following files to WI:

PASCAL, PASCAL. RES and

COMP.COD

Procedures for performing these functions are given in the

ISIS-II User's Guide,

Order Number 9800306.

Compiler

The P ASCAL-80 Compiler is overlaid and loads its overlays from the drive containing COMP.COD.

Run-Time System

The RTS executes the intermediate code output from the compiler. Its code is contained in the files PASCAL and PASCAL.RES.

libraries

P80RUN.LIB, P80ISS.LIB, and P80RAR.LIIB are ISIS-II object module libraries used in the generation of Load and Go versions of a Pascal program. They are discussed more fully in Chapter 6.

Example Programs

EX.PAS, BUFFER. PAS, ERROR.PAS and SEEKEX.PAS are simple demonstration programs, supplied in source form, which show many of the facilities present in

P ASCAL-80, and which can also be used by the newcomer to familiarize himself with the system. (SEEKEX.PAS is somewhat more complex than the other programs.)

Figure Programs

Each one of the example programs in Chapter 3 is supplied in source form, so that they may be compiled and executed by the user. These files are named FIG3n.PAS, where n is a digit from 1 to 7.

Run-Time System Memory Layout

The PASCAL-80 Run-Time System is composed of an interpreter and a number of predeclared procedures and functions written in Pascal. During interpreter execution, there are two major dynamic data structures: the STACK and the HEAP. The

STACK contains all P-code and data frames; all dynamic variables are allocated from the HEAP. The layout of main memory is illustrated in figure 4-1.

P ASCAL-80

•

Operating Instructions

•

PASCAL-80

TOP OF MEMORY FFFFH

MONITOR

TOP OF PASCAL-80 SPACE F6COH

PRE-DECLARED PROCEDURES

STACK (NIO REALS) EC10H

REAL PROCEDURES

----T----

STACK(FlEALS)EBCOH

STACK

•

HEAP

1

REAL ROUTINES

HEAP (REALS)

HEAP (NO REALS)

INTERPRETER

TOP OF ISIS-II 3880H

ISIS-II

0000

Figure 4-1_ Main Memory Layout for a 64KB System

1015-2

Operating the PASCAL-80 System

Invoking PASCAL·80

To invoke the PASCAL-80 System from ISIS-II, type the following:

-PASCAL [<directive>] [<code-filename> [<options>]]

The directive is an optional field which, when present, causes the PASCAL-80

System to be loaded without the code for real numbers_ The form of this option is:

-R

This option is used to increase the memory available to programs which do not use real numbers. With the -R option specified, approximately 2800 additional bytes are available. For example:

-PASCAL -R

PASCAL-80 VV.r [No reals]

The code-filename is also an optional field which, when present, allows for automatic Pascal program execution. This feature is described in the Automatic

Program Execution section.

4-3

4-4

Operating Instructions

If neither of the optional fields is present, PASCAL-80 responds with:

PASCAL-80 Vv.r

Command Line Syntax for PASCAL·80

When the P ASCAL-80 Run-Time System is invoked, it responds as specified above, and displays its prompt character ">" to indicate that it is waiting for a command which is defined as follows:

<file-command>

<direct-command>

::= <file-command>

<direct-command>

::= <code-filename> [<options»

::=

TRACEON

SIZEON

TRACEOFF

QUIT

SIZEOFF

STATS

The code-filename specifies a compiled Pascal program which will be loaded by the

RTS and executed. The meaning of the <options> field is determined by the program being executed. It allows for the specification of data files, execution options, and directives at the time of invoking the program.

The next two commands, TRACEON and TRACEOFF, are used to control the tracing facility of the PASCAL-80 System.

The QUIT command returns control to the ISIS-II Command Line Interpreter.

The SIZEON and SIZEOFF commands are used to control the run-time monitoring of the ST ACK size and HEAP size.

The ST ATS command causes certain run-time statistics to be displayed.

Examples of valid commands are as follows:

>COMP TEST. PAS

>TEST

>TRACEON

>TRACEOFF

>QUIT

The first command will compile the Pascal source program file TEST.PAS. The second command will execute the Pascal object program TEST. COD, which the previous compilation just generated.

The third command will turn on the TRACE flag, so that the line number of each executed program statement will be displayed when a user program is next executed.

The fourth command turns off the TRACE flag, while the fifth command returns control to ISIS-II.

Code Filename Specification

A code-filename may be expressed in the following ways:

Name Typed

Name Used

<filename>.COD

PASCAL-SO

•

PASCAL-SO

Command Line Options

When the command line specifies a Pascal code file to be executed, that codefilename may be followed by an arbitrary <options> field. This <options> field specifies run-time parameters to the program being invoked, and may be input by that program using the standard "read" and "readln" procedures. When a program starts executing, the function eoln(input) will reflect the presence of an <options> field. It will be false if options are present, and true otherwise.

The following Pascal statements can be used to collect the options from the command line (if any) and place them in the string variable "options": if eoln(input) then options:= " else readln(input,options);

The program may then inspect the value of "optiions" and perform the appropriate actions.

•

Operating Instructions

•

Program Tracing Facility

The PASCAL-80 System incorporates a program tracing facility which allows for selectively monitoring the execution of a Pascal program. When the TRACE flag is set, the line number of each program statement being executed is output to :CO:, enclosed in brackets ("[" and "]"). Using this information, together with the compiler listing which associates line numbers with program statements, a.programmer may more easily determine what the program is doing.

As an example of the tracing output, if the program were to ask for a customer name:

[137][138]Customer name: [139] might be displayed if the TRACE flag were set, while:

Customer name: would only be displayed if the TRACE flag were not set.

The TRACE Flag

The TRACE flag may be manipulated in two ways. The TRACEON command will set the flag, and the TRACEOFF command will reset the flag. Additionally, pressing the INTERRUPT 4 switch on the Intellec system front panel will cause the

TRACE flag to toggle.

particular, every time the INTERRUPT 4 switch is pressed, the TRACE flag will be set if it was reset, or will be reset if it was set. This allows for selectively tracing only those portions of a program which are in question, and executing the remainder of the program normally.

•

Tracing Instructions

In order for the P ASCAL-80 System to trace a program, or portions of a program, tracing instructions must be present in the compiled code. The PASCAL-80 compiler normally inserts these instructions in the object code, but they may be omitted using the embedded compiler directive

UT-}.

When the compiler encounters this directive, it will not issue tracing instructions in any subsequent code which is

4-5

Operating Instructions generated. This situation will persist until a

{$T+} directive is encountered, at which time tracing instructions will begin to be generated again. Therefore, using these directives, an entire Pascal program, or just selected portions, may contain tracing instructions.

Run-Time Monitoring

The P ASCAL-80 Run-Time System has the capability to continuously monitor the dynamic sizes of both the STACK and the HEAP. Since a performance degradation occurs when this monitoring is in effect, the user is able to turn it on and off with the

SIZEON and SIZEOFF commands. When size monitoring is in effect, the system keeps track of three values as they are varied by the running user program:

• The maximum size of the STACK at any time:.

• The maximum size of the HEAP at any time.

• The maximum combined size of the STACK and HEAP at any time.

These values are initialized to zero when a program commences execution, and are saved when it returns to the Pascal Command Line Interpreter. The STACK size value does not include the space consumed by the resident code of the Pascal program, but does include the space occupied by each data frame, including the program's global data frame, and also the length of any SEGMENT procedures.

The ST A TS command will display these savt~d values. They are useful when generating a Load and Go version of a Pascal program, or when constructing an

RMX/80

PASCAL task, since the combined STACK and HEAP value is the maximum free space needed by the program. Note, however, that this free space value is valid only when the program has execution characteristics similar to those during the actual size monitoring, and should not be accepted as the maximum free space the program will ever need. In particular, if the program has declared procedures or functions which are recursive, the number of levels of recursion is one factor contributing to the size of the STACK, and therefore each invocation of the program will require a different amount of free space depending upon the recursion level reached. Also, the particular sequence of procedure calls and returns, as well as the pattern of dynamic variable allocation on the HEAP, determine the free space used during any specific invocation of a program.

Displaying the Statistics

The execution of the ST A TS command will cause the value of certain run-time variables to be displayed. In addition to the size monitoring variables described above, the current size of the free space (between the top of the HEAP and the bottom of the STACK) is also displayed. The format of the ST ATS command is as follows:

<STATS

Interpreter Version: Vx.y

Available Free Space: >size-1>

Maximum HEAP Size: <size-2>

Maximum STACK Size: <size-3>

Maximum Combined Size: <size-4>

Run Time Monitoring: <flag-value-1 >

Run Time Tracing: <flag-value-2> where: x.y

<size-1>

The version and revision of the Pascal Interpreter itself.

The number of bytes available for the code and data of a user program.

P ASCAL-80

4-6

• i .

•

Operating Instructions

•

PASCAL-80

•

<size-2>

<size-3>

<size-4>

The current values of the size monitoring variables.

<flag-value-1 >

<flag-value-2> The state of the associated Run Time parameters. The possible values of these parameters are On or Off.

Automatic Program Execution

If a code-file is specified on the ISIS-II command line when invoking P ASCAL-80, the PASCAL-80 System is loaded and code-filename is executed with no further user input. For example, typing

-PASCAL CaMP EX.PAS would result in the following:

PASCAL-80 VV.r

PASCAL-80 Compiler Vv.r

COMPILING EX.PAS

Symbol table space remaining: 12234 bytes

371ines compiled

PASCAL-80 VV.r

Interrupting Program Execution

INTERRUPT switch 3 on the Intellec system front panel causes the currently executing Pascal program to cease execution, and causes control to be returned to the PASCAL-80 System command handler. An error message is displayed, along with the Segment, Procedure, and Instruction where execution was suspended.

Operating the PASCAL-80 Compiler

Command Line Syntax for the Compiler

The command line syntax for compiling a Pascal program is as follows:

CaMP <filename> [<directives>] where filename is the name of the source code file. If the filename is not given, an error message is printed and control is returned to the PASCAL-80 system.

The source filename may be specified in the following ways:

Name Specified

<filename>.

Name Used

<filename>.PAS

4-7

4-8

Operating Instructions

The <directives> field is an optional sequence of compiler directives (see below).

Each directive must be separated from the preceding directive by one or more spaces. Where directives have brackets, the left hand bracket may occur zero, one, or more spaces after the body of the directive. To terminate the sequence, press return.

If a COMP command is longer than one line on your console, (which must not be greater than 122 characters), you can continue it by entering an ampersand

(&) before the carriage return. The ampersand cannot appear within a directive name or file name.

PASCAL-SO

• to

1111

COMP creates a work file named P80WRK.TMP on the diskette to which the output code file is directed. If you have a file by this name on the output diskette, it will be destroyed.

Compiler Directives

The PASCAL-80 System compiler recognizes various directives which are used to control various phases and details of the compilation process. These directives are partitioned into two classes. The first class is the command line directives, which are specified on the command line after the name of the P ASCAL-80 source file to be compiled. The second class is the embedded directives, which are embedded in the text of the program being compiled. The command line directives are described below; a summary of all directives is in Appendix C.

Compiler Command Line Directives

A description of the available command line directives follows:

NOLIST

No list file is produced.

NOCODE

No intermediate code file is produced.

ERRLlST

The listing is limited to those lines containing syntax errors.

LIST (external-file-name)

Specifies the file to which the listing is to be directed. The default is:

<source-filename> . LST.

CODE (external-file-name)

Specifies the file to which the code

IS to be directed. The default

IS:

<source-filename> .COD.

NOECHO

Error lines are echoed on the console unless this directive is specified.

•

PASCAL-SO Operating Instructions

GLOBAL(external-file-name)

Specifies the global symbol table file when separately compiling a partitioned Pascal program. The default is: <source-filename>.SYM.

WORKFILE«device»

Specifies which diskette device is to be used for the compiler's workfile,

P80WRK. TMP. The default value is the device of the output code file.

DATE«date»

Specifies the date to be included in the page heading of the compiler listing.

The <date> parameter is any sequence of nine or fewer characters not containing parentheses. The default value is all space.

ETAB(external-file-name)

Specifies the external table file when compiling a Pascal program with external references. The default is: <source-filename>.ERT.

NOST ATISTICS

Specifies that the compiler should not accumulate or list the procedure data frame and parameter sizes.

Excluded Combinations

Certain of these directives may not be used in combinations. The following table shows which directives are excluded if the directive in the left-hand column is specified.

Directive Excluded Directives

NOLIST LIST

ERRLlST

NOCODE CODE

Summary of Information on CRT

The general format of the basic command line is:

COMP filename [directives]

The compiler will reply with:

PASCAL-80 Compiler VV.r

Where v is the version number and r is the release number.

Each directive is then acknowledged by the compiler on a separate line, and is either

ACCEPTED or REJECTED. After all the directives have been acknowledged and none were rejected, the compiler opens its files and starts to compile. If any directive was rejected it will display:

•• Compilation Terminated ** and control is returned to the P ASCAL-80 System.

4-9

4-10

Operating Instructions

If all directives were accepted it will display the message:

COMPILING filename

If any file fails to open correctly, the compiler will display: filename failed to open

The compilation will be terminated, returning control to the PASCAL-80 System.

When the compilation is complete, the compiler displays the message:

Symbol table space remaining: nnnnn bytes mmmmm lines compiled where nnnnn is the number of bytes of memory that were not used during compilation of the program. This tells you how much more symbol table space your program can use. The mmmmm is the number of lines in the program.

Compiler Listing Format

The general layout of the list file is as follows:

PASCAL-SO Compiler VV.r

Line Seg Proc Lev Disp filename nnnn nn nnn n nnnn statement 1 date page: nnn

PASCAL-SO

: ?

•

• nnnn nn nnn n nnnn statement n

The first two lines are title information and are repeated for each page. Line is the line number, Seg is the segment number, Proc is the procedure number, Lev is the current level of nesting, and Disp is the displacement of the variable or statement in the current procedure. These numbers are useful in debugging since, when a runtime error occurs, the segment number, procedure number and instruction displacement are displayed. See Appendix E, Run-Time Errors, for more information. Refer to Chapter 5 for examples of program listing.

Initial Compilations

When developing a PASCAL-80 program, it is often desired to perform a quick syntax and semantic check of the program. Compiling a program with

NOSTATISTICS, NOLIST and NOCODE speciflied on the command line will perform these checks in the minimum possible time.

•

CHAPTER 5 EXAMPLE PROGRAMS

The Pascal programs presented in this chapter are designed to illustrate both the basic characteristics and some of the language extensions in PASCAL-SO.

Compiling the Example Programs

Compile all the demonstration programs on the release diskette. These programs have the extension .PAS.

For example:

-PASCAL

PASCAL-80 Vv.r

>COMP EX.PAS

PASCAL-80 Compiler Vv.r

COMPILING EX.PAS

Symbol table space remaining: 12234 bytes

371ines compiled

PASCAL-80 Vv.r

NOTE

All of the examples in this manual assume that a P ASCAL-80 system diskette is created by following the initial steps in Chapter 4, and that this Pascal software diskette is loaded in drive O. If the diskette was loaded in drive 1, the first line in the above example would be:

:F1:PASCAL the third line would be:

:F1:COMP :F1:EX.PAS and the other examples m this manual would be modified accordingly.

To return to ISIS-II, type QUIT.

For example:

PASCAL-80 Vv.r

>QUIT

5-1

5-2

Example Programs

A directory listing of the disk will show that two new files exist-namely, EX.LST, which is the list file, and EX.COD, which contains the intermediate code. Now compile the programs BUFFER.PAS, SEEKEX.PAS,. and ERROR. PAS.

Note that ERROR.PAS has a bug in it which is present to show error formats and is for demonstration purposes only. It does not affect the running of the program.

The message produced by the error is:

ERROR := sum; {cause an error

Line 15, Procedure: ADD Error: 104

The arrow (/\) points to the location in the line where the error occurred.

Running the Demonstration Programs

When these programs have been compiled and run, you have checked out your disk and have mastered the fundamentals of the P ASCAL-80 facilities.

Addition and Subtraction of Numbers

-PASCAL

PASCAL-BO Vv.r

>EX

PASCAL-80

•

NOTE

If you have not returned to ISIS-II (i.e., QUIT) then you type only:

>EX

since you are already in the PASCAL-80 System. Also note that the code file produced by compiling EX.PAS is EX.COD, but to run

EX.COD, only EX need be typed since the PASCAL-80 System automatically appends .COD to any name typed in. Exceptions to this condition are explained in Chapter 4 under Code Filename

Specification.

•

The program is now running:

Input two integers: 2,5

The difference of the two is: -3

The sum of the two is: 7

PASCAL-80 V.vr

•

PASCAL-SO

•

Example Programs

EX.PAS Program Listing

Line Seg Proc Lev Disp

2 0

2 1

2 0

1 program example;

3 var i, j: integer;

0 function sub (valuel, value2: integer): integer; begin sub:= value1 - value2; end { sub} ;

0 procedure diff_and_ sum (var sum, difference: integer); var temp: integer; function add (value1, value2: integer): integer;

18 begin add:= value1 end { add} ;

+ value2;

10 begin { diff_and_ sum} temp:= add(sum, difference); difference:= sub(sum, difference);

0 begin { example}

26 sum:=temp; end { diff_and_ sum} ; writeln; writeln; writeln; write('lnput two intlagers: ');

3 94

3 100

2 108 readln(i, j); if (i <>0) or (j

0) then begin diff_and __ sum (i, j); writeln; end;

108

116 writeln; writeln('The differElnce of the two is: ',j:O);

175

227 writeln('The sum of the two is: ',i:O); writeln;

0 235 end {example}.

•

5-3

5-4

Example Programs

Bufferread and Bufferwrite Example

>BUFFER

Input a line of text:

THIS IS A LINE

TEXT.

Input break char [cntrl Z to stop]: A

The buffer read:

THIS ISA

Length: 9

Input break char lcntrl Z to stop]: W

The buffer read:

THIS IS A LINE OF TEXT.

Length: 23

(Break char not found)

Input break char [cntrl

Z to stop]: <cntrl

PASCAL-SO VV.r

>QUIT

PASCAL-SO

1/1

•

BUFFER.PAS Program Listing

Line Seg Proc Lev Disp

1 program example;

67 break: char; new_len, len: integer; buff_array: packed array[0 .. 80] of char;

108

0 begin

27 rewrite (disk_storage, 'data'); writeln('lnput a line of text: ');

87 readln (buffer);

109

109 len := bufferwrite(clisk_storage, buffer[1], length(buffer)); repeat reset(disk_storage);

2 116

2 132

179

2 197

3 { Example using bufferread and bufferwrite with break characters}

3 var buffer: string;

44 disk_storage: file; writeln; writeln; write('lnput break char [cntrl Z to stop]: '); readln(break); if not eof(input) t'hen

3 208

4 208

4 226

262

4 292

4 331

3 378 begin new_len writeln('

Len~lth:

',abs(new_len):O); if new_len

0 then writeln('(Break char not found)'); end;

:= bufferread(disk_storage, buff_array, len, ord(break)); writeln('The buffer read: '); writeln(copy(buffer, 1, abs(new_len)));

378 until eof(input);

0 388 end.

•

Example Programs

•

PASCAL-SO

ERROR.PAS Program Listing

Line Seg Proc Lev Disp

ERROR 104

100

108

116

175

227

235 program example; var i,j: integer; function sub (value1, value2: integer): integer; begin sub:= value1 - value2; end

I sub

I; procedure diff_and_sum (var sum, difference: integer); var ternp: integer; function add (value1, value2: integer): integer; be~lin

ERROR

:= sum;

I cause an error} add:= value1 end

I add} ;

+ value2; begin

I diff_and_ surn } temp:= add(surn, difference); difference:= sub(surn, difference); surn:= temp; end

I diff_and_sum } ; begin

I example} writeln; writeln; writeln; write('lnput two integers: '); readln(i, j); if (i

0) or (j

0) then be!Jin diff_and_sum (i, j); writeln; end; writeln; writeln(,The difference of the two is: ' ,j:O); writeln('The sum of the two is: ' ,i:O); writeln; end

I example

I .

•

5-5

5-6

Example Programs

Example of Seek and Advanced Record Structure

This program is an information retrieval program named SEEKEX.PAS, which is designed to manage "user information records" in a data file named

PEOPLE.DAT. Each record in this file contains the name of a person, along with additional personal information. SEEKEX will display a requested record and will allow the user to update the data in the record.

Information Retrieval Program: SEEKEX.PAS

-PASCAL SEEKEX

This starts SEEKEX.PAS running, assuming it has been compiled. If it has not been compiled yet, do so by typing:

-PASCAL COMP SEEKEX.PAS and then run it by typing:

>SEEKEX

The system will respond with the following:

Display which record [Enter number] : 10

NO SUCH RECORD

Display which record [Enter number] : 5

Criss Mathews

Female

Social security number: 435

Birth date:

5/30/75

Number of dependents: 0

Debts: 0

Single

Do you wish to change this record? Y

First name:.XXXX

Last name: YYYY

S.S. number: 999

M(ale) or F(emale): M

Input birth date ... Month: 5

Day: 16

Year: 58

Number of dependents: 0

Amount of money owed: 0

Marital Status-[M(arried), S(ingle), D(ivorcedJI, W(idowed)]: S

Display which record [Enter number] : <cntrl Z>

PASCAL-80 Vv.r

>QUIT

The record numbers that exist are numbered 0 through 8.

PASCAL-SO

•

PASCAL-SO

•

SEEKEX.PAS Program Listing

program demo_seek; type status

(married, widowed, divorced, singl,~); date = record month: (jan, feb, mar, apr, may, jun, jul, aug, sep, oct, nov, dec); day: 1. .31; year: integer; end; person record allocated: boolean; name: record first, last: string\20]; end; ssnum: integer; sex: (male, female); birth: date; dependents: integer; debts: integer; case marital status: status of married, widowed: (date marriecl: date); divorced: (date divorced: date;: first divorce: boolean); single: (independent: boolean); end { person); var people: file of person; ch: char; recnumber: integer; procedure initfile (only_one: boolean); var i: integer; ch: char; procedure get date(var date to set date); beg in with date to set do begin repeat readln(i); case i of

7: month month

:= jan; apr; month

:= jul;

10: month

:= oct;

8 :

11: month

.=

feb; month

may; month

aU9; month

:= nov;

3 : month

mar;

6 : month

jun;

9 : month

sep;

12: month

dec; end {case); if (i< 1) or (i> 12) then write('Sad date .. Try again: '); un til i in [1.. 12

1 ; write('

DAY: '); repeat readln(i); if (i< 1) or (i> 31) then write('Bad date .. Try again: '); un t i l i i n [1.. 3 1

J ; day := i; wr i te ( , YEAR: '); readln(year) ; end [wi th}; end {get_date}; begin {init files) if not only one then rewrite(people, 'people.dat') else seek(people, recnumber); repeat with people" do beg in writeln; write('First name: '); readln(input, name. first); i f not eof(input) then beg in write('Last name: '); readln(input, name.last); wr i te ( 'S. S. number: '); readln(input,ssnum); repeat write('M(ale) or F(emale): '); readl n (input, ch); case ch of

1M'

,Iml

sex sex

:= male; female; end;

Example Programs

5-7

Example Programs

SEEKEX.PAS Program Listing (Cont'd.)

until ch in ['M','m','F','f']; writeln; write('Input birth date •.• MONTH: '); get date (birth); writeln; write('Number of dependents: '); readln(input, dependents); write('Amount of money owed: '); readln(input, debts); repeat wri te (' Mari tal Sta tus-[M (an

ied),

5 (ing le), '); write('D(ivorced), 'n'lidowed)]: '); readln (input, ch); case ch of

I , I

beg in

marital status := married; wri te ('-Input da te marr i ed get date(date married); end; -

' 5 ' , ' s ' : begin marital status

:= single; independent := true; end;

'D','d': begin marital status := divorced; first dTvorse

:= true; write('Input date divorced get date(date divorsed); end; -

'W' ,'Wi: begin

marital status := widowed; write( 'Input date married get date(date married); end; -

MONTH:' );

MONTH: ');

MONTH:'); end (case);

until ch in ['M','m','S','s','D','d','W','w ' ];

allocated := true; put(people) ; writeln; end; end (wi th) ; until eof(input) or only one; if not only one then close(people, lock); end (initfileT; function display (a_record: integer) boolean; procedure print date (date_to_print: date,); begin with date to print do beg in writeln(ord (month) +1: 0,'

,day:O,' /' ,year:O); end (with); end (print_date); beg i n (d i s pl a y) seek (people, a record); get(people); with people-, name do beg in i f eof(people) or not allocated then begin display := false; exi t(display); end; display := true; writeln; writeln; writeln(first,' ',last); case sex of male: writeln('Male'); female: writeln('Female'); end (case); writeln('50cial security number write( 'Birth date: '); print date(birth); ssnum:O);

5-8

PASCAL-80

..

•

PASCAL-80

•

SEEKEX.PAS Program Listing (Cont'd.)

writeln('Number of dependents writeln('Debts: ',debts:O); dependents:O); case marital status of married: begin write( 'Married on : '); print date(date married); end; widowed: begin

I) ; divorced: write('Widowed, married on print date(date married); end; beg in write('Divorced on : '); print date(date divorced); end; wr i te 1 n ( , Sing 1 e' ) ; single: end {case); end {with); wri teln; writeln; end {display); beg in r ese t ( pea pl e , ' pea pl e . d at' ) ; repea t writeln; wri te (' Display which record [Enter number] '); readln(recnumber) ; if not eof(input) then if display(recnumber) then beg in write('Do you wish to change this record? '); readln(ch) ; if ch in ['y','Y'] then initfile (true); end else writeln('NO SUCH RECORD'); until eof(input); end.

•

Example Programs

5-9

•

CHAPT~E6

SEPARATE

CC~MPILATION,

PROGRAM

LINKAGE, RELOCATION, AND EXECUTION

The previous chapters describe the procedun~s for compiling and executing a

PASCAL-80 program consisting of a single compilation unit. This chapter describes the techniques available for partitioning a large program into separate compilation units, for linking a PASCAL-80 program with external modules written in

PUM-80, FORTRAN-80, or ASM-80, and for constructing a load-and-go version of your Pascal program which is directly executable from the ISIS-II command line interpreter. All of Chapter 6 exceeds standard Pascal.

Partitioning a Pascal Program

In order to allow for easier development of large PASCAL-80 programs, a program may be partitioned into separate COMPONENTs or compilation units. These

COMPONENTs are then compiled separately and combined by the JOIN utility to produce the final code file.

Since the COMPONENTs are compiled separately, a change in a COMPONENT requires that only that COMPONENT be recompiled, not the entire program. This recompilation is then followed by the JOIN procedure. The entire program must be recompiled only if the global data in the main program is altered.

The Structure of a Partitioned Progr;em

A partitioned program set consists of a main PARTITIONED program and one or more separate COMPONENTs. The main PARTITIONED program contains the global data and the outer block program statements, as well as all resident global procedures. Each COMPONENT contains one or more global segment procedures.

Each one of the COMPONENTs, as well as the main PARTITIONED program, is a compilation unit and is compiled separately.

Each global segment procedure which is contained in a COMPONENT must be declared in the main program as a SEPARATE segment procedure, as follows: segment procedure pi; separate;

Note that the syntax of a SEPARATE segment procedure declaration is similar to that of a forward segment procedure declaration.

The syntax of a PARTITIONED program is as follows:

<partitioned program> ::= <partitioned program heading> <block> .

<partitioned program heading> ::= PARTITIONED PROGRAM <ident>

PARTITIONED PROGRAM <ident>«file id> {,<file id>});

6-1

6-2

Separate Compilation, Program Linkage, Relocation, and Execution

<separate procedure and function heading part> ::=

{<separate procedure or function heading> ;}

<separate procedure or function heading> ::=

::=

SEGMENT <procedure heading> SEPARATE;

<separate function heading> ::= SEGMENT <function heading> SEPARATE;

The syntax of a COMPONENT is as follows:

<component> ::= <component heading> <component block> .

<component heading> ::= COMPONENT <identifier>;

BEGIN END

<segment procedure and function declaration part> ::=

{<segment procedure or function declaration> ;}

<segment procedure or function declaration> ::=

<segment procedure declaration> ::= SEGMENT <procedure declaration>

::=

SEGMENT <function declaration>

For an example of a Pascal program which has been divided into three compilation units, figure 6-1 should be referenced. As is seen in this example, three SEGMENT

PROCEDUREs have been removed from the main program and placed in the COM-

PONENTs. The complete program is composed of a main PARTITIONED PRO-

GRAM, sixl, and two COMPONENTs, sixlc1 and sixlc2. Each of these compilation units resides on a separate diskette file: The PARTITIONED PROGRAM sixl is on SIXl.PAM, the COMPONENT sixlc1 is on SIX1.PA1, and the COMPO-

NENT sixlc2 is on SIXl.PA2.

Note that the structure of both a PARTITIONED PROGRAM and a COMPO-

NENT are similar to that of a (standard) PROGRAM. The differences are noted below.

A PARTITIONED PROGRAM has the following characteristics:

• The reserved word PARTITIONED in the program heading.

• The presence of one or more SEPARATE PROCEDURE or FUNCTION declarations.

A COMPONENT has the following characteristics:

• The reserved word COMPONENT which replaces PROGRAM in the heading.

• No global labels, constants, types or variables may be declared; the complete global environment is declared in the main PARTITIONED PROG RAM.

• There are no program statements in the outer block; just a BEGIN followed by an END.

• Each SEPARATE PROCEDURE and FUNCTION must be declared as a

SEGMENT on the global level.

• Each SEPARATE PROCEDURE and FUNCTION can reference every global constant, type, variable, PROCEDURE and FUNCTION.

PASCAL-80

•

Separate Compilation, Program Linkage, Relocation, and Execution

•

PASCAL-80

•

{ Main Program Compilation Unit - Source on SIX1.PAM ) partitioned program sixl; const header

'This is procedure '; type procname

= string[lO]; var level: integer; segment procedure

aaj

separate; segment procedure bb; separate; segment procedure

CCj

separate; function increment(i: integer): integer; begin writeln(' level: ',i:3); increment := i +

1; end; { increment begin { sixl } level

1; write('This is the main program'); level

:= increment(level); aa: end. { sixl )

Component

Compilation Unit - Source on

SIXl.PAl ) component sixlcl; segment procedure aa; var name: procname; begin name

'aa'; write(header,name); level

:= increment(level); bb; end; { aa ) begin end. { sixlcl

Component 2 Compilation Unit - Source on SIXl.PA2 ) component sixlc2; segment procedure bb; beg in wri te (header,

I bb'); level := increment(level);

CCj

end; { bb } seyment procedure cc; beg in write(header,'cc'): level

:= increment(level); end; { cc ) beg in end. { sixlc2

Figure 6-1. A Partitioned Pascal Program

Code File Construction

The final, executable, code file is constructed from the code files of all of the compilation units. The main PARTITIONED PROGRAM and each of the COM-

PONENTs are compiled separately. The PARTITIONED PROGRAM must be compiled before any of the COMPONENTs can be compiled.

During the compilation of the PARTITIONED PROGRAM, the compiler writes the global symbol table onto a diskette file. This global symbol table file is then read in during the compilation of each of the COMPONENTs. In this way, each of the

SEPARATE PROCEDUREs and FUNCTIONs of a partitioned program set is declared within the global environment declared in the main PARTITIONED PRO-

GRAM. The GLOBAL«file-name» compiler directive allows the name of the global symbol table file to be specified. In the absence of this directive, the compiler uses the file name:

<source-file-name>.SYM

6-3

6-4

Separate Compilation, Program Linkage, Relocation, and Execution

For example, if SIXI.PAM is a PARTITIONED PROGRAM, the command:

COMP SIX1.PAM GLOBAL(MYSYM.XYZ) will cause the global symbol table to be written onto MYSYM.XYZ, while the command:

COMP SIX1.PAM will cause the global symbol table to be placed on the file SIXl.SYM.

After all of the compilation units of a partitioned program set have been successfully compiled, the JOIN utility is used to combine all of the separate code files into a final, executable code file. The format of the JOIN command is:

JOIN <code-file> {,<code-file>} TO <code-file>

For example, the following command will combine SIX1.COM, SIXl.COl and

SIX 1.C02 into SIX I.COD:

JOIN SIX1.COM,SIX1.C01 ,SIX1.C02 TO SIX1.COD

The sequence of commands shown in figure 6-2 will compile each of the compilation units shown in figure 6-1 and then combine the resultant code files into an executable code file. The file SIX I.SYM is used as the global symbol table file, since none of the compilation commands specify a GLOBAL directive. As an aid to understanding this facility, the release diskette contains the three source files:

SIXl.PAM, SIXl.PAI and SIX1.PA2, as well as the file SIXl.CSD, which is a

SUBMIT file containing the commands shown in figure 6-2.

Linking with non-Pascal Modules

For some applications, it may be necessary or desirable to code one or more procedures or functions in a language other than Pascal. These external procedures and functions can be written in PLiM-SO, FORTRAN-SO, or SOSO/SOS5 Assembly

Language and translated by the appropriate language processor. The resultant relocatable object module(s) can be linked, located and then executed as an integral part of the PASCAL-SO program. Refer to other Intel manuals, cited in the preface, for instructions on translating and linking subroutines written in other languages.

In the remainder of this section, a set of external procedures and functions, together with any associated data structures will be referred to as an external module.

PASCAL-BO Extensions

In order to be able to communicate with an external module, a Pascal program must be able to specify what variables, procedures and/ or functions are, in fact, external to the compilation.

PASCAL-80

•

PASCAL

COMP :Fl:SIX1.PAM CODE(:Fl:SIX1.COM}

COMP :Fl:SIXl.PAl CODE(:Fl:SIXl.COl}

COMP :Fl:SIX1.PA2 CODE(:Fl:SIX1.C02}

JOIN :Fl:SIXl.COM, :Fl:SIX1.C01, :Fl:SIX1.C02 TO :Fl:SIXl.COD

QUIT

Figure 6-2. Compiling and Joining a Partitioned Pascal Program

•

PASCAL-80 Separate Compilation, Program Linkage, Relocation, and Execution

These specifications serve two purposes. First, they declare the objects so that the

Pascal program may manipulate them as if they were normal (i.e., non-external) objects. Second, the specifications cause external references to be generated, so that the LINK utility may combine the external modules with the Pascal program.

A PASCAL-SO program declares external variables, procedures and functions in a

Public Declaration Record. The syntax of a public declaration record is as follows:

::=

PUBLIC [<name>];

END;

An example of a public declaration record is: public asum; type range

0 .. 1000; var aresult: integer; function asum(a,b,c: range): integer; end;

All of the items defined in a public declaration record are defined in the global environment of the Pascal program. The only difference between a normal declaration and declaration within a public declaration record is that the former causes storage to be allocated within the Pascal program, while the latter causes the Pascal program to access storage locations allocated externally to the program. In all other ways, a P ASCAL-80 program treats privalle variables and external variables identically.

NOTE

It is the programmer's responsibility to ensure that the structure and size of an external variable is consistent with the declaration of the variable within the public declaration record. If this is not so, unpredictable and usually disastrous results will occur.

The <name> field is an optional field. If it is present, it is accepted by the compiler but otherwise ignored.

Since the <constant declaration part> and <type declaration part> do not cause any storage to be allocated, they are not explicitly associated with any external storage locations. However, they are necessary within a public declaration record so that the variables, procedures, and functions may be defined adequately.

The <variable declaration part> declares variables whose storage is allocated externally to the Pascal program. The compiler allocates an Indirect Reference Pointer in the global environment for each such external variable. An indirect reference pointer is one word in length and is used to address the external variable.

The <procedure and function heading part> declares procedures and functions which are defined and allocated externally to the Pascal program. The compiler allocates an indirect reference pointer in the global environment for each such external procedure or function. These procedures are assumed to exist in memory in

SOSO/SOS5 machine-executable form and the Pascal interpreter CALLs them using the standard PL/M subroutine calling convention. Since the only two data types which can be passed as parameters using this convention are the BYTE type and the

ADDRESS type, a procedure or function heading within a public declaration record

6-5

Separate Compilation, Program Linkage, Relocation, and Execution has a restricted form. In particular, if the size of a parameter is not greater than one word (two bytes) it may be passed by value or by reference (V AR). However, if the size of a parameter is greater than one word, it must be a V AR parameter. Additionally, the size of the result of a function must not be greater than one word.

The general structure of a program which accesses (!xternal objects is as follows:

<public declaration part> ::=

<empty>

I {

<public declaration record> }

An example of such a program is shown in figure 6-3. This Pascal program references two external modules, ASUM and PSUM, each of which declare both an integer variable and an integer function with three parameters of type range. The module ASUM is written in SOSO/SOS5 Assembly Language and the module PSUM is written in PL/M-SO. Each of the external functions merely computes the sum of their three parameters, stores the sum in a PUBLIC variable, and then returns the result as their function value. As is shown in this example, the module coded in

PL/M must not be a main module; i.e., it must not contain executable statements at the module level.

Note that there may be multiple public declaration records, but that they must all appear before any private objects are declared. In particular, this restriction causes all external objects to be in the global environment of the Pascal program.

Therefore, as for all global identifiers, every external variable, procedure, and function name must be different from every other external name, and from every private global variable name. If this condition is not satisfied (e.g., if two external names are the same, or if an external name is the same as a private global name), the compiler will generate Error 101: Identifier declared twice, and will not accept the duplicate name.

However, it is possible that two separate public declaration records may contain declarations for variables of the same type. If this type is not a predeclared data type, these public declaration records will duplicate type declarations. In order to allow for this situation, and not cause a duplicate type or constant declaration error, the compiler will allow types and constants to be redeclared in public declaration records if the new declaration is identical to the original.

Figure 6-3 contains an example of a type, range, which is declared in one public declaration record and then redeclared in another. This situation is necessary since each module must declare the range type independently of any other module.

A public declaration record may be

included in the source file, using the {$l<file-

name>} construct, in the same way as any other Pascal source text, as is demonstrated in figure 6-3 (see Appendix C for details).

P ASCAL-80

6-6

•

Separate Compilation, Program Linkage, Relocation, and Execution

•

PASCAL-80

•

( Program with external linkages Source on SIX3.PAS

program six3; public asumi

type range

~ O .• 1000;

var arslt: integer; function asum(a,b,c: range): integer;

end; ( asum )

public psumi

type range

0 •. 1000; var prslt: integer;

function psum(a,b,c: range): integer; end; var i,j,k: range; result: integer;

beg in i :~

10; j :~

12; k

14;

result ::;::: asum(i,j,k);

writeln(result,arslt); result :~ psum(i,j,k); writeln(result,prslt); end. ( six3 )

External module to compute the SUM of the three arguments: function asum(a,b,c: 0 •• 1000): integer

NAME

PUBLIC

ASUM

ARSLT,ASUM

Declare the result variable

DSEG

ARSLT:

D'tI

CSEG

Compute the sum of the three arguments

ASUM:

XCHG

DAD

POP

DAD

PUSH

SHLD

RET

END

B o

ARSLT

Move DE to HL

Add in the second argument

Skip over the return address get the third argument and add i t in

Restore return address

No starting address, since not a main module

/* External module to compute the SUM of the three arguments: */

/* function psum(a,b,c: O ••

1000): integer

PSUM$MODULE:

DO;

DECLARE PRSLT ADDRESS PUBLIC;

PSUM: PROCEDURE(A,B,C) AryDRESS PUBLIC;

DECLARE(A,B,C) ADDRESS;

PRSLT ~ A

RETURN PRSLTi

END PSUM;

END PSUMSMODULE;

•

Figure 6-3. A Pascal Program With External Linkages

6-7

6-8

Separate Compilation, Program Linkage, Relocation, and Execution

Invoking an External Procedure or Function

As was discussed above, except for the physical location of the object, external objects and private objects are treated identically by the compiler at the source language level. This implies, in particular, that a Pascal program invokes an external procedure or function in exactly the same manner as a private Pascal procedure or function. The necessary linkages to the external routine are handled by the compiler and the interpreter.

From the point of view of the external module, an external procedure or function is called from a Pascal program by the Pascal interpreter using the standard PL/M calling convention. The details of that convention and their relationship to

PASCAL-80, are as follows:

• The value of an actual parameter is passed to an external procedure if the corresponding formal parameter is specified as a value parameter. The address of the actual parameter is passed if the corresponding formal parameter is specified as a V AR, or variable, parameter.

• If the external procedure for function is coded in PLiM or FORTRAN, each

(Pascal) actual parameter is assigned to its corresponding (PLIM or FOR-

TRAN) formal parameter.

• If the external procedure or function is coded in assembly language, it will find its arguments in the standard locations:

A single parameter is passed in the BC register pair.

For a two-parameter procedure or function, the first parameter is passed as above and the second is passed in a similar fashion in the DE register pair.

For a procedure or function with more than two parameters, the last two parameters are passed as described above (next to last in BC, last in DE) and the remainder are found on the stack. They are pushed onto the stack in order from left to right in the parameter list, followed by the return location into Pascal, which is the state of the stack when the called procedure or function begins execution.

• The only restriction to the standard

PL/M calling convention is that an external

PL/M function must be an ADDRESS procedure, even if the value being returned occupies one byte or less. Similarly, if an external function is coded in assembly language, it must always return its value in the HL register pair. If it normally would return a byte in the A register, it should copy the result in A to the L register and clear the H register prior to returning to the Pascal program.

These details of external module linkage are illustrated by the programs in figure

6-3.

The FORTRAN-80 convention for calling a

function

with n arguments is to pass n+ 1 addresses to the function routine. The first address is the location for storing the result and the next addresses are the locations of the n arguments (since, in

FORTRAN-80, all arguments are passed by reference). Therefore, if you want to call an external function of n arguments written in FORTRAN-80 from your Pascal program, you should declare an external procedure of n+ I parameters, each of which is a VAR parameter, and the first one is the variable which receives the result of the FORTRAN-80 function.

PASCAL-SO

•

The External Reference Table

If a PASCAL-80 program references one or more external objects, the compiler automatically generates an External Reference Table on an ISIS-II relocatable

•

Separate Compilation, Program Linkage, Relocation, and Execution

•

PASCAL-SO object file. The ET AB«file-name» compiler directive allows the name of the external reference table file to be specified. In the absence of this directive, the compiler uses the file name:

<source-file-name>. ERT

The External Reference Table contains an external reference for each external object declared in the Pascal program, and defines the relationship between the location of each external object and the location of its Indirect Reference Pointer in the global environment of the Pascal program. The address of the

ExV~rnal

Reference Table itself is defined by the PUBLIC symbol PQETAB.

•

Program Execution with External Objects

In order to execute a P ASCAL-80 program which references external objects, it is necessary to:

1. Compile the Pascal program.

2. Compile and/or assemble the external module(s).

3. Link the external module(s) together with the External Reference Table.

4. Locate the module produced by step 3.

5. Load the module into memory and invoke the PASCAL-80 Run Time System.

Each of these steps is explained in detail below, using the programs in figure 6-3 as an example.

Compile the Pascal Program

If the Pascal program is a single compilation unit, then compile it to produce the code and External Reference Table file.

If the Pascal program is a partitioned program, compile the main module and each of the COMPONENTs. The compiler will generate the External Reference Table file when compiling the main module, then invoke the JOIN utility to combine all the code files into one resultant code file.

For example, the command:

PASCAL COMP SIX3 will compile SIX3 .PAS and generate the following three files:

SIX3.COD: The executable code file

SIX3.LST: The compiler listing file

SIX3.ERT: The external reference table file

•

Compile and/or Assemble the External Module(s)

Translate each of the external modules into 8080/8085 machine-executable code using an appropriate language processor. Ensure that each external reference in the

Pascal program is matched by exactly one PUBLIC declaration in the collectioJl of external modules.

6-9

6-10

Separate Compilation, Program Linkage, Relocation, and Execution

For example, the commands:

PLMBO PSUM.PLM

ASMBO ASUM.ASM will produce the following files:

PSUM .OBJ: The relocatable object file

PSUM.LST: The compiler listing file

ASUM.OBJ: The relocatable object file

ASUM.LST: The assembler listing file

Link the Modules Together

Using the ISIS-II LINK utility, link all of the external object modules together with the External Reference Table and the library file P80EXT.LIB into one relocatable object module.

NOTE

The file containing the External Reference Table must be the first file in the list of input files to LINK, so that the External Reference Table itself is situated at the beginning of the external module.

The format of the LINK command is as follows:

LINK <ert-file>,P80EXT.LlB,<E1>, .. ,<Ek> TO <code-file> where <El>, .. <Ek> are the relocatable object files of the external module(s) and any required support library files.

Using our example programs, the appropriate command is:

LINK SIX3.ERT,PBOEXT.LlB,PSUM.OBJ,ASUM.OBJ,PLMBO,LlB TO EXTMOD.OBJ which will create the complete external object module on EXTMOD.OBJ. Since

SIX3.ERT is the first file mentioned in the above command, the external reference table will be correctly situated at the beginning of the CODE segment.

Locate the External Module

As is discussed in Chapter 4, during normal operation of PASCAL-80, the Run

Time System occupies all of the memory of the Intellec System between the top of

IS1S-1I and the base of the monitor. However, if a Pascal program references an external module, the code for this module must reside in system memory during the execution of the Pascal program. In order to allow for this situation, the

P ASCAL-80 Run Time System has a mechanism whereby it can lower the upper boundary of its work space to make room for an external module. The activation of this mechanism is described in the next section.

Use of this mechanism requires that any such external module be located as high as possible in memory, so as not to unduly restrict PASCAL-80's work space. The Run

Time System can only use the memory up to the bottom of the external module; any memory space between the top of the external module and the Monitor will be unused by PASCAL-80. The following discussion presents the considerations when locating an external module in a 64K Intellec Sys,tem.

PASCAL-80

•

Separate Compilation, Program Linkage, Relocation, and Execution

•

PASCAL-SO

•

A 64K Intellec System has a highest usable memory address of F6COH. Therefore, the base of the external module should be located at:

F6COH - <total length of module>

For example, if the length of the external module is 4096 (lOOOH) bytes, the base of the module must be set to E6COH or lower in the LOCATE step.

As was mentioned above, the external reference table must be situated at the beginning of the external module. If the linking operation described in the previous section was performed correctly, the external reference table will be situated at the beginning of the CODE segment in the relocatable object file of the external module. Therefore, if the CODE segment is the first segment in the executable object file generated by LOCATE, the external reference table will be positioned correctly. The ISIS-II LOCATE utility will position the CODE segment as the first segment if the ORDER control is not used in the LOCATE command or, if it is used, CODE is mentioned ahead of any other segment name. Use of the LOCATE facility is fully described in the

ISIS-II User's Guide.

For example:

LOCATE EXTMOD.OBJ CODE (OE6COH) locates the CODE segment of the module (and therefore the entire module) at

E6COH, and writes the absolute object module onto EXTMOD. Unless a private

ST ACK is required, the ST ACKSIZE(O) control should be specified since the Pascal

Run Time System allocates the STACK from its workspace.

As a check on the relative location of the External Reference Table, the PUBLICS option should be invoked in the LOCATE command. This option will cause the value of the symbol PQET AB (among others) to be listed. This value should be exactly the same as the base address specified in the locate command.

•

Load the External Module into Memory and

Invoke the PASCAL-80 Run Time System

The located external module, EXTMOD, can now be loaded into Intellec Memory at its proper address with the DEBUG command:

-DEBUG EXTMOD

#nnnn

The DEBUG command loads the file into memory and invokes the Monitor. The

Monitor responds with the starting address of the module, which should be ignored.

The monitor then displays a period (.) and waits for a command to be entered. You should respond with G8 followed by a carriage return, to return to ISIS-II.

At this point, so as not to disturb the external module loaded into the top of memory, you must immediately invoke the PASCAL-80 Run Time System with the command:

PASCAL [-R]

The

* control causes P ASCAL-80 to set the upper boundary of its work space to the value of the PUBLIC symbol PQETAB, which is defined to be the base of the external module.

6-11

Separate Compilation, Program Linkage, Relocation, and Execution

The PASCAL-80 Run Time System is now used in the standard way to execute the

Pascal program. All external references in the program will be automatically linked to the associated external object.

For example, if the command:

SIX3 is now given to the PASCAL-80 Command Line Interpreter, the example program in figure 6-3 will be executed and will access the specified external functions and variables.

Load and Go Program Generation

In all the discussions up to now, the only way to execute a P ASCAL-80 program was to first invoke the Pascal Run Time System, and then the desired program. While this two-step process is valuable during program development, it may be a bit cumbersome for a fully-debugged, production program. To allow for this latter situation, it is possible to construct a Load and Go version of a Pascal program.

This Load and Go version is invoked directly from the ISIS-II command line interpreter, does not automatically display any sign-on or start-up message, and thus presents a simpler, more standard, interface to the user.

Generating the Relocatable Object Module

The PASCAL-80 compiler produces a code file which is in a format appropriate for execution by the Pascal Run Time System. However, this format is not compatible with the relocatable object file format, so the: code file must be transformed into a relocatable object file with the GENOB] utility. This utility is invoked by the command:

GENOBJ <code-file> TO <obj-file> [FREE«size»] where the FREE control specifies the initial size of the free space, from which both the HEAP and the Execution STACK are allocated. The HEAP grows upward from the bottom of the free space while the STACK grows downward from the top.

The amount of free space a Pascal program needs is dependent on both the static and dynamic characteristics of the program. For example, the size of the local data frame of a procedure will affect the STACK space used, as will the calling depth of a set of recursive procedures. In order to assist in the determination of the amount of free space a Pascal program requires, the P ASCAL-80 Run Time System has the

SIZEON command. This feature (described in detail in Chapter 4) causes the Run

Time System to continuously monitor the amount of free space used by a program and to keep track of the maximum value. This value can then be displayed with the

ST A TS command. Remember, however, that the value obtained during one execution run might not be valid during another run, if the program has different execution characteristics.

In addition to monitoring the sizes of the STACK and HEAP during one or more execution runs, the following factors should be considered when computing the required free space size:

• The global data frame is allocated on the STACK when the program begins execution.

•

The data frame of a procedure or function is allocated on the STACK only when that procedure or function is active; i.e., only when it is part of the dynamic calling chain.

P ASCAL-80

6-12

•

PASCAL-SO

• If a procedure or function is called recursively, each of its instances has its own data frame allocated on the STACK.

• All parameters to procedures, functions and operators are passed on the

STACK.

• The code of an active SEGMENT PROCEDURE or FUNCTION is allocated on the STACK.

• All dynamic variables are allocated on the HEAP by the new(v) predeclared procedure.

A consideration of these factors leads to the following conclusions:

• The longer a procedure call chain is, the more STACK space is used .

• The deeper the level of recursion (of a procedure or function), the more STACK space is used.

• Two procedures which are never active concurrently will not extend the STACK concurrently.

• The more complex a Pascal expression is, the more STACK space is used during its evaluation.

•

Separate Compilation, Program Linkage, Relocation, and Execution

•

Linking the Object Module

The relocatable object module created from the pascal program code file must now be linked to the Pascal Run Time libraries and associated external modules, if any.

The required LINK command has the form:

LINK <input-list> TO <link-file> [<link controls>]

The <input-list> is a list of ISIS-II files of the form:

<program-module>,

[<external-ref-table>, ... , <external-module>,]

P80RUN.LlB, P80RAR.LlB, P80ISS.LlB where:

• <program-module> is the relocatable object file created from the Pascal program code file by GENOBJ, and should be the first file: on the list.

• <external-ref-table> is the file containing the External Reference Table. This item is present only if the Pascal program references external objects.

• <external-module> represents one or more object files which contain the code for the external module(s). This item is present only if the Pascal program references external objects.

• The last three files are the Pascal libraries required for a Pascal program to run under IS IS-II.

The

ISIS-II User's Guide should be consulted for complete operating instructions

for the LINK utility.

•

Locating the Object Module

The relocatable object module produced by the previous linking operation must now be located to absolute locations. This procedure is performed with the ISIS-II

LOCATE utility, as follows:

LOCATE <link-file> [TO <output-file>] [<controls>]

6-13

- - - - - - - - - - -

Separate Compilation, Program Linkage, Relocation, and Execution

The only restriction on this command is that the CODE segment must be located to an even byte boundary. Other than this, the user is free in the choice of locations for the various segments.

Program Execution

The linked and located Pascal program may now be loaded and executed simply by presenting its name to the ISIS-II command line interpreter. For example:

-MYPROG l<options>] will load and execute this Pascal program, and will not generate any type of automatic sign-on message.

P ASCAL-80

•

CHAPTER 7 PREPARING PROGRAMS TO RUN

UNDER RMXI80™

This chapter describes the use of the special facilities provided to support Pascal programs in the RMX/SO run-time environment-specifically, the PASCAL-SO

Run-Time Package for RMX/SO Systems (iSBC803). Use of RMX/80 itself is described only to the extent necessary to explain how to interface PASCAL-SO programs with it; for complete instructions refer to the

RMXISO

User's Guide. All of

Chapter 7 exceeds standard Pascal.

Also described in this chapter is the use of the RMX/SO Interactive Configuration utility (ICUSO) in configuring a Pascal-based RMX/80 application system. The

ICUSO utility automates the configuration, linking, and locating operations described in the

RMXISO

User's Guide.

It generates the configuration object module, the controller addressable memory (CAM) module, and a submit file containing the link and locate commands required to build the RMX/80 application system. For a complete description of this utility refer to the

RMXISO

Interactive

Configuration Utility User's Guide.

A PASCAL-SO program executing in the RMX/80 environment can avail itself of all of the features of an ISIS-II Pascal program, including the external linking capabilities described in Chapter 6. Additionally, RMX/SO PASCAL contains language extensions which facilitate the incorporation of a Pascal program as a task in the RMX/SO environment. These extensions give an RMX/SO PASCAL program the ability to interface with the complete facilities of RMX/SO. This capability, together with the use of the RMX/SO Interactive Configuration Utility (ICUSO), allows a user to construct an RMX/SO application system entirely in the Pascal programming language, without the need to resort to either

PL/M

or assembly language for certain modules.

Under RMX/SO, PASCAL-SO input and output operations normally use the full or minimal Terminal Handler and the Disk File System, rather than the ISIS-II functions used in the ISIS-II environment. Alternatively, you can omit the Terminal

Handler and/or Disk File System and just use direct port input and output.

Program Structure Under

RMX/SO

Under RMX/SO, programs run as a series of tasks under the control of the RMX/SO

Nucleus. These tasks communicate with each other by sending and receiving messages to and from exchanges. One of the tasks in an RMX/SO application system may be coded in Pascal; this program may make full use of all of the language features of PASCAL-SO. The other user tasks, if any, in addition to any external subroutines called by the Pascal task, may be written in PLlM-80, FORTRAN-SO, or ASM-80, depending on the nature of the functions to be performed .

The RMX/80 task written in Pascal is coded identically to one coded to execute under ISIS-II; no adjustments at the source language level need be made for the difference in environments. This characteristic allows many RMX/SO PASCAL tasks to be thoroughly tested in the ISIS-II environment before being executed under

RMX/SO.

In PASCAL-SO, procedure and function parameters can be passed by value (value parameters) or by reference (variable or var parameters). Also, as described in

Chapter 6, a Pascal program can establish linkages with external procedures, functions, and data structures. These capabilities, together with PASCAL-SO extensions described in later sections, allow a Pascal program complete access to all of the facilities of RMX/SO.

7-1

7-2

Preparing Programs to Run Under RMX/SO

Initialization and Termination

Every PASCAL-SO program exists within a surrounding Run Time Environment.

This surrounding environment contains the predeclared procedures and functions described in Chapter 3 and elsewhere, a number of predeclared data identifiers, and the code required to perform all necessary global initialization and termination sequences. The nature of these sequences depends upon the execution environment of the Pascal program, but in all cases is sufficient to correctly execute the program.

In particular, it is not necessary, within the RMX/SO environment, for tasks separate from the main Pascal task to invoke any special initialization for termination routines; the Run Time Environment within the Pascal task contains all of these routines.

When a Pascal program terminates, executing under ISIS-II, the Run Time Environment causes all open files to be closed and then transfers control to the ISIS-II Command Line Interpreter. The termination logic in the Run Time Environment of a

Pascal task under RMX/SO also closes all open files, but then causes the task to suspend itself forever (by waiting for a message at an empty, private exchange). This means that if you want your Pascal task to be active at all times, it should be coded as a repeat statement or a while statement, such that the exit condition is never satisfied.

If some such statement structure is not utilized, and the program executes its last statement, or an exit«program-name» statement is executed, the Pascal task will be suspended forever; the only way to revive it is to activate the hardware reset feature, which will cause it to be reinitialized.

Input and Output

The RMX/SO PASCAL run-time input/output support library, PSORMX.LIB, allows you to invoke the standard predeclared Pascal procedures and functions

(RESET, REWRITE, CLOSE, PUT, GET, SEEK, READ, WRITE,

BUFFERREAD, BUFFERWRITE, BLOCKREAD, BLOCKWRITE, EOF,

EOLN, and IORESULT) for input and output to the Terminal Handler and Disk

File System (DFS). No sending of request messages to the Terminal Handler or Disk

File System is required; this is all done by the routines in PSORMX.LIB.

File Name Format

In ISIS-II, filenames and extensions are defined by the user, but device names are preestablished by the system. A discussion of this can be found in Chapter 2 of the

ISIS-II User's Guide.

Under RMX/SO, filenames and extensions are files on the

Disk File System are defined by the user, and DFS device names are defined by the configuration module. The device names :CI: and :CO: are predefined to be input from the Terminal Handler and output to the Terminal Handler respectively.

A complete file designator has the same format in Pascal programs running in both the ISIS-II and RMX/SO environments. This common format is as follows:

:<device>:<fiiename>.<extension> where:

• <device> is a two character alphanumeric designation for a device.

If the file is a DFS file, <device> should correspond to a value of the DEVICENAME field in a Device Configuration Table Entry (see ICUSO discussion below). If the file refers to the Terminal Handler, either :CI: or :Co: are valid.

• <filename> is a one to six upper-case, non-blank, alphanumeric characters which specify a portion of the name of a DFS file.

PASCAL-SO

•

PASCAL-80

Preparing Programs to Run Under

RMX/80

•

<extension> is zero to three upper-case, non-blank, alphanumeric characters which are appended to <filename> to completely specify a Disk File System file.

The following are valid

RMX/SO PASCAL file names:

:CI:

:Co:

:F1 :MYFILE.TXT

:HD:DATA36

Input from Terminal Handler

Output to Terminal Handler

DFS disk file on device F1

DFS disk file on device HD

•

The Predeclared Files Input and Output

In PASCAL-SO, input is a predeclared file variable of type INTERACTIVE and output is a predeclared file variable of type TEXT. In a Pascal program executing under ISIS-II, the initialization logic in the surrounding environment automatically connects input to the ISIS-II :CI: file and output to the ISIS-II :CO: file. Under

RMX/SO, these automatic connections are also made, where :CI: corresponds to ter-

minal input and :CO: to terminal output, as discussed above. Therefore, as under

ISIS-II, an

RMX/SO PASCAL program does not have to open the terminal files

input and output.

DFS Service Operations

In addition to supporting the data storage and transfer operations of Pascal, the

Disk File System in

RMX/SO also provides a number of Directory Maintenance Ser-

vices and other service operations. While procedures corresponding to these service operations are not predeclared in the surrounding environment, they may easily be invoked by a Pascal program using the external linkage features of PASCAL-SO.

Run-Time Error Handling

As in the ISIS-II environment, an

RMX/SO PASCAL task can specify a user error

procedure to be invoked upon detection of a run-time error by the PASCAL-SO

Run-Time System. In the absence of such a specification, the default system error procedure will be invoked upon a run-time error. This procedure will attempt to output an error message to the Terminal Handler, will then cause the task to exit and, hence, suspend itself forever.

In order for the Pascal task to retain control over its execution, even in the event of a run-time error, it is necessary for the program to specify its own error procedure(s), as described in Chapter S. The specific actions of an error procedure are dependent upon the nature of the run-time error, the state of the execution environment, and the structure of the Pascal task itself; such procedures must be designed as an integral part of the total

RMX/SO PASCAL application system.

PASCAL-BO Extensions for RMX/BO

RMX/SO PASCAL incorporates a number of language extensions which greatly

facilitate the construction of a Pascal task, including its communication with other tasks and with the

RMX/SO Nucleus. These extensions fall into two categories: a

new predeclared type, the MESSAGE type, and additional predeclared procedures and functions.

7-3

Preparing Programs to Run Under

RMX/80

Need for

RMX/SO Extensions

There exists a major incompatibility between the format of data structures declared in PASCAL-SO and several

RMX/SO

data structures. This may be understood by observing the following conditions of data storage allocation in PASCAL-80:

• Space for data items is allocated in units of words, where a word is a two-byte quantity aligned on an even byte boundary.

• If the size of a data item is less than or equal to one word, the space allocated for the item will never cross a word boundary.

In particular, these conditions imply that a data item which is equal in size to one of type integer (two bytes) will always be allocated on a word boundary.

However, the

RMX/SO

Message Format is incompatible with these conditions in that the HOME EXCHANGE field and the RESPONSE EXCHANGE field, as well as any additional data items in the remainder of the message, are aligned on oddbyte boundaries.

It is therefore not possible to define a data type in PASCAL-80 which has the same structure as an

RMX/SO

message. Consequently, in the absence of any specific language extensions an

RMX/80

message would be a cumbersome type to manipulate.

The above incompatibility is resolved by the definition of a new class of data types and a set of additional predeclared procedures and functions in the supporting environmen t.

PASCAL-80

The MESSAGE Data Type

RMX/80

PASCAL incorporates the MESSAGE type, which is used to define a class of structured data types corresponding to

RMX/SO

messages. Each Pascal

MESSAGE is one byte longer than its associated

RMX/80

message. This additional byte is located at the beginning of the Pascal defined MESSAGE and offsets the fields in the

RMX/80

message format by one byte. The result of the inclusion of this extra byte is that, from the viewpoint of Pascal, the HOME EXCHANGE field, the

RESPONSE EXCHANGE field, and all succeeding fields are located on word boundaries and, therefore, are simple to define and manipulate in a Pascal program.

For example, a DFS Delete Request Message type is declared as follows: type deletemsg

= message homeexch: "exchange; respexch:"exchange; status: integer; fileptr: "fnameblock; end;

The MESSAGE type is similar to the RECORD type, with the following differences.

In a MESSAGE type:

• An unnamed six-byte field preceds the first declared user field.

• Certain parameters to some predeclared procedures must be of type message.

• The PACKED prefix is not allowed.

Note that a MESSAGE type declaration does not declare the LENGTH and TYPE fields of the

RMX/80

message. These fields of a message are manipulated by the predeclared procedures rqsetlt and rqgetlt described below.

7-4

•

Preparing Programs to Run Under

RMX/80

•

PASCAL-80

•

In order to allow for the extra byte in these MESSAGE types, the

RMX/SO

predeclared procedures pass to the external world the address of the second byte in the MESSAGE, not the address of the beginning of the Pascal MESSAGE. Conversely, when an

RMX/SO predeclared procedure receives a message address from a

nucleus operation, it decrements it by one byte before returning it to the Pascal program.

When a Pascal program declares a private variable to be of type MESSAGE, the compiler allocates storage for it, and the item is addressed as described above. In particular, Pascal addresses the first byte of the MESSAGE while

RMX/SO

addresses the second byte. In order to allow for a MESSAGE variable to be declared externally, and still be manipulated correctly, the indirect reference pointer of such a variable points to the byte preceding the first byte in the external message. This address transformation, which is performed automatically, transforms the external message into a Pascal MESSAGE, and therefore allows it to be handled identically to a private MESSAGE.

It is not necessary for the programmer to make any adjustment for the extra byte in a MESSAGE; the Pascal compiler and run-time system effectively mask out its presence. In particular, the PUBLIC symbol which names an external

RMX/SO

message should be bound, as in non-Pascal applications, to the first byte of the

LINK field which, from the viewpoint of

RMX/SO, is the beginning of the message.

Predeclared Procedures and Functions for RMX/80

The following procedures and functions are predeclared in the Run Time Environment, and exist specifically for use by Pascal programs which will execute under

RMX/SO.

MESSAGE Manipulation Procedures

rqsetlt(m,l, t)

Sets the value of the LENGTH field of MESSAGE m to 1 and the value of the TYPE field of m to

Both 1 and t must be integer expressions.

rqgetlt(m,

t)

Sets the value of 1 to the contents of the LENGTH field of MESSAGE m and sets the value of t to the contents of the TYPE field of m. Both I and m must be variables of type integer.

RMX/SO

Nucleus Operations

RMX/SO PASCAL, there is a predeclared procedure (or function) corresponding

to each

RMX/SO Nucleus operation. The names of these Pascal routines are iden-

tical to their

RMX/SO counterparts, as are the order and type of their parameters.

rqsend(e,m)

Sends the MESSAGE m to the exchange e.

rqwait(mp,e, t)

Waits at exchange e for a time limit of t, which must be an integer expression, and returns the address of a message in mp, which must be a pointer to a MESSAGE.

7-5

Preparing Programs to Run Under

RMX/80

rqacpt(mp,e)

Returns the address of a message which has been sent to the exchange e.

If no message is there, NIL is returned. The address (or NIL) is placed in mp, which must be a pointer to a MESSAGE.

rqctck

Decrements the time counters on all tasks on the Delay list.

rqctsk(s)

Creates a task, given the Static Task Descriptor s.

rqcxch(e)

Initializes the exchange e.

rqdlvl(l)

Disables the interrupt level given by I, which must be an integer expression.

rqdtsk(t)

Deletes the task described by the task de:scriptor

rqdxch(e): integer

Deletes the exchange e.

rqelvl(l)

Enables the interrupt level given by I, which must be an integer expression.

rqendi

Ends the interrupt in a user-supplied interrupt routine.

rqisnd(i)

Sends a message to the interrupt exchange i.

rqresm(t)

Resumes a suspended task described by the task descriptor

rqsetp(a, I)

Associates the address, a, of a user-supplied interrupt procedure with an interrupt level. The procedure cannot be a Pascal procedure. Used for iSBC

80/10

applications.

rqsetv(a,l)

Associates the address, a, of a user-supplied interrupt procedure with an interrupt level. The procedure cannot be a Pascal procedure. Used for noniSBC 80/10 applications.

rqsusp(t)

Suspends the task described by the task descriptor t.

PASCAL-80

7-6

•

PASCAL-80 Preparing Programs to Run Under RMX/SO

Constructing an RMX/80 System

The construction of an RMX/SO applications system which contains a Pascal task can be partitioned into four major steps:

• Generating the relocatable object modules of any non-Pascal tasks.

• Generating the relocatable object module of the Pascal task.

• Invoking the RMX/SO Interactive Configuration Utility (ICUSO) to produce the various configuration object modules and the associated Command Sequence

Definition file.

• Applying the SUBMIT command to the Command Sequence Definition file generated in the above step to link and locate the complete RMX/SO application system.

Since a discussion of the first step above is dependent upon the specific application system being constructed, we will assume any such modules have been compiled/assembled and linked. Refer to the Intel manuals cited in the Preface for instructions about utilizing other languages.

•

Generating the Relocatable Object Module

The procedure for generating the relocatable object module of a Pascal task is essentially identical to that for constructing the relocatable object module of a Load and

Go Pascal program. Accordingly, the section in Chapter 6 which discusses Load and

Go program generation should be referenced. The only difference between the two procedures is the format of the GENOBJ command. When generating the relocatable object module of an RMX/SO PASCAL task, this utility is invoked by:

GENOBJ <code-file> TO <obj-file> [FREE(n)] RMX where the inclusion of the RMX option causes GENOBJ to reference RMX/80specific Resident System procedures, instead of the default ISIS-II-specific procedures.

•

The Interactive Configuration Utility

The RMX/SO Interactive Configuration Utility (ICUSO) is a utility used to automate the configuration, linking, and locating operations described in the RMXISO User's

Guide.

ICU80 is used to generate the configuration object module, the controller addressable memory (CAM) module, and a submit file containing the link and locate commands required to build the RMX/SO application system.

ICU80 obtains its input data from two sources: a description file suplied to ICU80 when it is invoked, and data entered from the console by the user in response to prompts from ICU80. One of the features of ICU80 is that an updated description file can be generated which contains all of the additions and modifications the user made during the session with ICUSO. This file may then be used as the initial description file the next time ICU80 is invoked.

When using ICU80 to configure an RMX/SO Application System which includes a

Pascal task, a number of the configuration parameters must have specific values.

These parameters, with their values, are described below. Any configuration parameter which is not mentioned in the following list is not constrained by

RMX/SO PASCAL; it may assume any valid value consistent with the structure of the application system.

7-7

7-8

Preparing Programs to Run Under

RMX/80

The values of the following configuration parameters are constrained as follows:

TERM HNDLR:

If the Pascal program references either of the predeclared files input or output or performs I/O to either :CI: or :CO:, one of the versions of the Terminal Handler must be specified.

TASK NAME:

You may use any name for your Pascal task.

ENTRY POINT:

The ENTRY POINT must be specified as P8INIT.

STK LENGTH:

This parameter should be set to the value 2, since the Pascal task defines its own work space and STACK.

DFLT EXCHG:

The Pascal task does not use a Default Exchange.

EXTRA:

This parameter is set to O.

DFS:

The Disk File System must be included if the Pascal program accesses any disk files.

ATTRIB, DELETE, FORMAT,

LOAD, RENAME, DISKIO:

These DFS services are included only if the Pascal program calls them explicitly.

OPEN, CLOSE,

READ. WRITE, SEEK:

These must be included if the DFS is specified.

LINK:

The following files must be included in the LINK list, in the following order:

<program-module>

<ext-ret-table>

<external-modules>

P80RUN.LlB

P80RAR.LlB

P80RMX.LlB where:

• <program-module> is the relocatable object file created from the Pascal program code file by GENOBJ.

PASCAL-SO

•

PASCAL-80 Preparing Programs to

Run

Under

RMX/80

• <ext-ref-table> is the file containing the External Reference Table. This item is present only if the Pascal program references external objects.

• <external-modules> represents one or more relocatable object files which contain the code for the external module(s). This item is present only if the

Pascal program references external objects.

• The last three files are the PASCAL-SO libraries required for a Pascal program to run in the

RMX/SO

environment.

•

7-9

•

CHAPTERS

RUN-TIME ERROR PROCEDURES

During the execution of a PASCAL-80 program, various run-time errors may occur.

These errors are divided into three general categories:

• Data structure errors

• Value range errors

• Input/output errors.

The interpreter will always detect data structure errors, while detection of errors in the other two categories is not automatic. Errors in these categories are detected only by in-line interpreter p-code operations which mayor may not be generated by the compiler during the compilation of the Pascal program. As is discussed in Appendix

C, the {$R+/-} compiler directive controls the generation of the range-checking code, while the {$I+/-} directive controls the generation of the I/O checking code.

If the code of a compiled Pascal program does not contain this error checking code, the respective run-time errors will never be detected. All of Chapter 8 exceeds standard Pascal.

During program execution, the detection of a run-time error by the P ASCAL-80 interpreter causes a parameterless error procedure to be invoked. In the absence of an error procedure specification by the running program, a default error procedure is invoked. This default procedure writes an appropriate error message to the file output, and then executes exit «program-name», which causes program termination. Appendix E lists the error messages which may be generated by the system default error procedure.

If it is necessary for your program to retain control in the event of a run-time error, a user-declared error procedure may be specified with the predeclared procedure: errorset(p) where p is a parameterless procedure declared at the global level of the Pascal program. When a run-time error is detected, the procedure p is invoked at the point of the error. If, after performing its actions, p terminates normally, the interpreter automatically causes an immediate exit from the procedure which caused the error.

If p executes an exit(q) operation, the interpreter causes an exit from procedure q, as usual. In either case, the procedure which was executing when the run-time error was detected is terminated, and the STACK is unwound appropriately.

In order for a user error procedure to effectively process the run-time error condition, the following predeclared integer variables are present in the Run-Time

Environment:

errnumber errsegment errprocedure errdisplacement errsystem

The number of the last run-time error

The segment number when the error occurred

The procedure number when the error occurred

The instruction displacement when the error occurred

The ISIS-II error number, if errnumber

When a user-declared error procedure is invoked, the active error procedure specification reverts to the standard default error procedure. Therefore, after a runtime error has occured, erroset(p) must be called again if you still want a user error procedure to be active. See figure 8-1 for an example of a user error procedure.

8-1

8-2

Run-Time Error Procedures

This program illustrates the use of the errorset procedure program eightl; type value ~ 0 •• 255;

procedure rterror;

begin

writeln;

writeln('Detection of Error Number: ' ,errnumber:O);

writeln;

end; procedure square(i: value); begin writeln('Input value: ',i:O);

:= i

* ii

writeln('Squared result: ',i:O);

writeln;

end; begin errorset(rterror); square(lO); square(lOO) ; square(200); end. (eightl

Executing this program results in the following output:

Input value: 10

Squared result: 100

Input value: 100

Detection of Error Number: 1

Input value: 200

Value range error

Segment:

Procedure:

Instruction:

. Figure 8-1. Use of the errOifset Procedure

PASCAL-SO

•

Operator

•

arithmetic:

(unary)

- (unary)

• div

mod

relational:

•

• in

•

logical:

not or and

set:

{

.. ·1

(* ... *)

•

Operation

assignment identity sign inversion addition subtraction multiplication integer division real division modulus integer or

real

integer or real integer integer or real integer equality inequality less than greater than less or equal

-orset inclusion greater or equal

-orset inclusion set membership scalar, string, set, or pointer scalar or string scalar or stri ng set scalar or string set first operand is any scalar, the second is its set type negation disjunction conjunction union set difference intersection comment

APPENDIX A

SUMMARY OF OPERATIONS

Type of Operand(s)

any type except file types

Result Type

-boolean any set type T any ASCII characters same as operand integer or real integer real integer boolean boolean

A-I

•

APPENDIX B

PASCAL-SO VOCABULARY

The P ASCAL-80 language vocabulary consists of basic sym bois classified into three categories: letters, digits, and special symbols. The special symbols are operators and delimiters, as follows:

Operators

<> < <= >=

{ t

}

Delimiters { reserved words}

AND

CASE

DIV

ELSE

FILE

GOTO

LABEL

ARRAY BEGIN

COMPONENT CONST

END

FORWARD

MOD

DOWNTO

FOR

FUNCTION

NOT

OF OR PACKED

PARTITIONED PROCEDURE PROGRAM

PUBLIC

SET

RECORD

SEGMENT

REPEAT

SEPARATE

THEN

UNTIL

WITH

VAR

NIL

TYPE

WHILE

In this manual, reserved words are written in upper case letters to emphasize their interpretation as single symbols with a fixed meaning. They may not be used in any context other than that explicit in their definition. In particular, they may not be used as identifiers.

Identifiers

These are names denoting constants, types, variables, procedures, and functions.

An identifier must begin with a letter which may be followed by any combination and number of letters and digits. However, in PASCAL-80, only the first eight characters of any identifier are significant.

Matching upper and lower case letters are equivalent in identifiers and reserved words. In particular, the two identifiers: sample and SAMPLE refer to the same variable. Similarly, packed and PACKED are equivalent names for the same delimiter.

B-1

•

" n

Command Line Directives

APPENDIX C

SUMMARY OF COMPILER

DIRECTIVES

A description of the available command line directives follows:

NOLIST

No list file is produced.

NOCODE

No intermediate code file is produced.

•

ERRLlST

The listing is limited to those lines containing syntax errors.

LIST (external-file-name)

Specifies the file to which the listing is to be directed. The default is:

<source-filename> .LST.

CODE (external-file-name)

Specifies the file to which the code

IS to be directed. The default

IS:

<source- filename> .CO D.

NOECHO

Error lines are echoed on the console unless this directive is specifed.

GLOBAL (external-file-name)

Specifies the global symbol table file when separately compiling a partitioned

Pascal program. The default is: <source-filename> .SYM.

WORKFILE«device»

Specifies which diskette device is to be used for the compiler's work file,

P80WRK.TMP. The default value is the device of the output code file.

•

DATE«date»

Specifies the date to be included in the page heading of the compiler listing.

The <date> parameter is any sequence of nine or fewer characters not containing parentheses. The default value is all spaces .

NOST ATISTICS

Specifies that the compiler should not accumulate or list the procedure data frame and parameter sizes.

ET AB( external-fi le-nam e)

Specifies the external table file when compiling a Pascal program with external references. The default is: <source-filename>.ERT.

C-J

C-2

Summary of Compiler Directives

Excluded Combinations

Certain of these directives may not be used in combinations. The following table shows which directives are excluded if the directive in the left-hand column is specified.

Directive Excluded Directives

NOLIST LIST

ERR LIST

NOCODE CODE

PASCAL-SO

•

Embedded Directives

Embedded compiler directives are inserted in the source code and have the following form:

{$directive[,directive j} or (*$direclive[,directivej*)

Many of the directives have the form directive+ or directive-

If a

+ or - is not present,

+ is assumed.

The use of em bedded directives is discussed below.

This directive causes the text following the C to be placed in the code file. This is useful for putting copyright information and other text into the code file.

This directive must appear at the top of the program; otherwise, a compiletime error will occur.

Example:

When this directive is followed by a follows:

+ or -, the I/O checking is affected as

Causes the compiler to generate code after each statement which performs any I/O, in order to check whether the I/O operation was accomplished successfully. In the case of an unsuccessful I/O operation, a run-time error will occur I

+ is the default value.

Causes the compiler to generate code with no I/O checking. If an I/O error does occur, a run-time error will not occur.

When this directive is not followed by a the INCLUDE FILE directive.

+ or -, the directive is interpreted as

•

PASCAL-SO

Summary of Compiler Directives

Example:

{$I <filename>} will cause the compiler to temporarily suspend its processing of the original source file, and to take subsequent source statements from <filename>. The compiler will continue to process <filename> until it reaches its end-of-file, at which point the compiler will resume processing the original source file. If a drive number is specified, (i.e., :Fl:filename), the file will be opened on the specified drive; otherwise, the file is opened on the same drive from which the original source was taken. Since all the characters between the I and the} or

*) are taken to be the file name, no other directives can follow the include file directive until that directive is closed by a } or

*).

An include file may be specified anywhere in the original source file. The text in the included file merely replaces the INCLUDE directive and becomes part of the source program. The resulting program must, of course, be syntactically and semantically correct, or else a compile-time error will occur. However, in order to allow for convenient structuring of INCLUDEd source code, PASCAL-80 relaxes the rules concerning the ordering of declarations. Under these relaxed rules, if a file is included just after a program's or procedure's last data declaration, (just before the start of the code statements), it may contain, within itself, a complete set of CONST, TYPE, and V AR declarations, as well as PROCEDURE and FUNCTION declarations.

An include file cannot contain an include file directive. If this occurs, a compile-time error is generated.

This directive affects the RANGE CHECKING of the compiler. If the R is followed by a

+,

range checking code is generated by the compiler such that if a value range error occurs while running the program, a run-time error occurs.

When followed by a -, no range checking code is generated; if a value range error does occur while running the program, a run-time error does not occur.

The default value is R

+ . o

This directive determines whether the compiler operates in overlay mode. If the 0

+ directive is given, the compiler operates in overlay mode. If the 0directive is given, the compiler doesn't operate in overlay mode. In the

0-

mode there are about 6300 bytes less memory available for symbol table space, but compile time is decreased since the compiler does not have to read from the disk as often as in the 0

+ mode. 0- is therefore very useful for compiling small and moderate-sized programs. 0

+ is the default value.

This directive determines whether the compiler generates tracing instructions, and may appear anywhere in the source code. If the T

+ directive is given, tracing instructions are inserted in the generated object code. If the Tdirective is given, no tracing instructions are generated. The default value is

T+.

This directive specifies a heading to be printed on the second line of each page of the compiler listing, just below the main title line. All characters in the directive following the H become part of the heading.

For example:

{H File Translation Program} will cause the message "File Tanslation Program" to be a heading on each page of the compiler listing.

C-3

C-4

Summary of Compiler Directives

The next two options deal with list file format:

{$+} :

Causes a top of page on the list file.

U-} : Causes a top of page on the list file if the! current position on the page is within

10 lines from the bottom of the page.

PASCAL-80

•

APPENDIX D

COMPILER ERROR MESSAGES

•

:..

•

10:

11 :

12:

13:

1 :

14:

15:

16:

17:

18:

19:

20:

21 :

Error in simple type

Identifier expected

'PROGRAM' expected

')' expected

':' expected

Illegal symbol (maybe missing ';' on the line above)

Error in parameter list

'OF' expected

'(' expected

Error in type

'[' expected

']' expected

'END' expected

';' expected

Integer expected

'=' expected

'BEGIN' expected

Error in declaration part

Error in <field-list>

' " expected

'.' expected

•

51:

52:

53:

50:

54:

55:

56:

57:

•

101 :

102:

103:

104:

105:

59:

58:

106:

•

119:

120:

121 :

117:

118:

116:

107:

108:

109:

110:

111 :

112:

113:

114:

115:

Error in constant

':=' expected

'THEN' expected

'UNTIL' expected

'DO' expected

'TO' or 'DOWNTO' expected in for statement

'IF' expected

'FILE' expected

Error in <factor> (bad expression)

Error in variable

Identifier declared twice

Low bound exceeds high bound

Identifier is not of the appropriate class

Undeclared identifier

Sign not allowed

Number expected

Incompatible subrange types

File not allowed here

Type must not be real

<tagfield> type must be scalar or subrange

Incompatible with <tagfield> part

Index type must not be real

Index type must be a scalar or a subrange

Base type must not be real

Base type must be a scalar or a subrange

Error in type of standard procedure parameter

Unsatisfied forward reference

Forward reference type identifier in variable declaration

Respecified parameters for a forward declared procedure

Function result type must be scalar, subrange, or pointer

File value parameter not allowed

D-l

Compiler Error Messages

122: A forward declared function's result type can not be respecified

123: Missing result type in function declaration

124: F-format for reals only

125: Error in type of standard procedure parameter

126: Number of parameters does not agree with declaration

127: Illegal parameter substitution

128: Result type does not agree with declaration

129: Type conflict of operands

130: Expression is not of set type

131: Tests on equality allowed only

132: Strict inclusion not allowed

133: File comparison not allowed

134: Illegal type of operand(s)

135: Type of operand must be boolean

136: Set element type must be scalar or subrange

137: Set element types must be compatible

138: Type of variable is not array

139: Index type is not compatible with the declaration

140: Type of variable is not record

141: Type of variable must be file or pointer

142: Illegal parameter solution

143: Illegal type of loop control variable

144: Illegal type of expression

145: Type conflict

146: Assignment of files not allowed

147: Label type incompatible with selecting expression

148: Subrange bounds must be scalar

149: Index type must be integer

150: Assignment to standard function is not allowed

151: Assignment to formal function is not allowed

152: No such field in this record

153: Type error in read

154: Actual parameter must be a variable

155: Control variable cannot be formal or non-local

156: Multidefined case label

157: Too many cases in case statement

158: No such variant in this record

159: Real or string tagfields not allowed

160: Previous declaration was not forward

161: Again forward declared

162: Parameter size must be constant

163: Missing variant in declaration

164: Substitution of standard proc/func not allowed

165: Multidefined label

166: Multideclared label

167: Undeclared label

168: Undefined label

169: Error in base set

170: Value parameter expected

171: Standard file was redeclared

172: Undeclared external file

174: Pascal function or procedure expected

190: PreviOUS declaration was segment declaration

191: Separate declaration valid only on global level

192: Separate procedure must be a segment

193: Comment or heading valid only on global level.

201: Error in real number - digit expected

202: String constant must not exceed source line

203: Integer constant exceeds range

D-2

PASCAL-SO

•

PASCAL-SO

•

250: Too many scopes of nested identifiers

251: Too many nested procedures or functions

252: Too many forward references of procedure entries

253: Procedure too long

259: Expression too complicated

261: Too many segment declarations

300: Division by zero

302: Index expression out of bounds

303: Value to be assigned is out of bounds

304: Element expression out of range

398: Implementation restriction

399: Implementation restriction

400: Illegal character in text

401: Unexpected end of input

402: Error in writing code file, not enough room

403: Error in reading include file

404: Error in writing list file, not enough room

405: Error in reading globals file

406: Error in writing globals file

407: Wrong version of globals file

•

Compiler Error Messages

•

APPENDIX E

RUN-TIME ERROR MESSAGES

In the absence of a user-specified error procedure, a run-time error will cause the system default error procedure to be invoked. This procedure displays an error message and then forces the current program to terminate. Each run-time error causes a specific message to be displayed, along with the Segment number,

Procedure number, and Instruction offset of the offending operation. By referring to the compiler listing of the program in question, the cause of the error may be ascertained.

When a run-time error occurs, the display on the screen will be as follows:

Segment:

Procedure:

Instruction:

<s>

<p>

<i> where <s>, <p>, and <i> are integers, and <error message> is one of the following:

Stack overflow (4)

Value range error (1)

Exit from uncalled procedure (3)

Integer overflow (5)

String overflow (13)

Divide by zero (6)

NIL pointer reference (7)

System 1/0 error (10)

Floating point error (12)

Unimplemented instruction (11)

Program interrupted by user (Interrupt 3) (8)

ISIS-II Error #<e> where <e> denotes an ISIS-II error number where the number following each message is the number of the error.

E-l

•

APPENDIX F

ISIS-II ERROR MESSAGES

This appendix lists the error messages issued by the various ISIS-II commands.

The numbered messages are listed in the first section. The unnumbered messages that are issued by specific commands are listed in subsequent sections.

Numbered ISIS-II Error Messages

By convention, error numbers 1-99 inclusive are reserved for errors that originate in or are detected by the resident routines of ISIS-II; error numbers 100-199 inclusive are reserved for user programs; and numbers 200-255 inclusive are used for errors that may be encountered by nonresident system routines. In the following list an asterisk precedes error numbers that are always fatal. The other errors are generally nonfatal unless they are issued by the kCONSOLE system call. See Table 1 and 2 below. o

No error detected.

1 Limit of 19 buffers exceeded.

2 AFTN does not specify an open file.

3 Attempt to open more than six files simultaneously.

4 Illegal filename specification.

5 Illegal or unrecognized device specification in pathname.

6 Attempt to write to a file open for input.

7 Operation aborted; insufficient disk space.

8 Attempt to read from a file open for output.

9 No more room in disk directory.

10 Pathnames do not specify the same disk.

11 Cannot rename file; name already in use.

12 Attempt to open a file already open.

13 No such file.

14 Attempt to open for writing or to delete or rename a write-protected file.

15 Attempt to load into ISIS-II area or buffer area.

16 Illegal format record.

17 Attempt to rename/delete a non-disk file.

18 Unrecognized system call.

19 Attempt to seek on a non-disk file.

20 Attempt to seek backward past beginning of file.

21 Attempt to rescan a non-lined file.

22 Illegal ACCESS parameter to OPEN or access mode impossible for file specified.

23 No filename specified for a disk file.

24 Disk error (see below).

25 Incorrect specification of echo file to OPEN.

26 Incorrect SWlD parameter in ATTRIB system call.

27 Incorrect MODE parameter in SEEK system call.

28 Null file extension.

29 End of file on console input.

30 Drive not ready.

31 Attempted seek on write-only (output) file.

32 Can't delete an open file.

33 Illegal system call parameter.

34 Bad RETSW argument to LOAD.

35 Attempt to extend a file opened for input by seeking past end-of-file.

F-l

F-2

ISIS-II Error Messages

201 Unrecognized switch.

202 Unrecognized delimiter character.

203 Invalid command syntax.

204 Premature end-of-file.

206 Illegal disk label.

207 No END statement found in input.

208 Checksum error.

209 Illegal records sequence in object module file.

210 Insufficient memory to complete job.

211 Object module record too long.

212 Bad object module record type.

213 Illegal fixup record specified in object module file.

214 Bad parameter in a SUBMIT file.

215 Argument too long in a SUBMIT invocation.

216 Too many parameters in a SUBMIT invocation.

217 Object module record too short.

218 Illegal object module record format.

219 Phase error in LINK.

220 No end-of-file record in object module file.

221 Segment overflow during Link operation.

222 Unrecognized record in object module file.

223 Fixup record pointer is incorrect.

224 Illegal record sequence in object module file in LINK.

225 Illegal module name specified.

226 Module name exceeds 31 characters.

227 Command syntax requires left parenthesis.

228 Command syntax requires right parenthesis.

229 Unrecognized control specified in command.

230 Duplicate symbol found.

231 File already exists.

232 Unrecognized command.

233 Command syntax requires a "TO" clause.

234 File name illegally duplicated in command.

235 File specified in command is not a library file.

236 More than 249 common segments in input files.

237 Specified common segment not found in object file.

238 lllegal stack content record in object file.

239 No module header in input object file.

240 Program exceeds 64K bytes.

When error number 24 occurs, an additional message is output to the console:

STATUS=OOnn

D=x T =yyy S=ZZZ where x represents the drive number, yyy the track address, zzz the sector address, and where nn has the following meanings for floppy disks:

OA

OE

OF

Deleted record.

Data field CRC error.

Invalid address mark.

Seek error.

Address error.

ID field CRC error.

No address mark.

Incorrect data address mark.

Data overrun or data underrun.

Attempt to write on Write Protected drive.

Drive has indicated a Write error.

Operation attempted on drive which is not ready.

PASCAL-SO

•

PASCAL-SO

For hard disks, nn has the following meanings:

OB oe

ID field miscompare.

Data Field eRe error.

Seek error.

Bad sector address.

ID field eRe error.

Protocol violations.

Bad track address.

No ID address mark or sector not found.

Bad data field address mark.

Format error.

Attempt to write on Write protected drive.

Drive has indicated a Write error.

Operation attempted on drive which is not ready.

ISIS-II Error Messages

•

Table F-l. Nonfatal Error Numbers Returned by System Calls

OPEN

READ

WRITE

SEEK

RESCAN

DELETE

RENAME

ATTRIB

CON SOL

WHOCON

ERROR

LOAD

EXIT

SPATH

3,4,5,9,12,13,14,22,23,25,28.

2,8.

2,6.

2,19,20,27,31,35.

2,21.

4,5,13,14,17,23,28,32.

4,5,10,11,13,17,23,28.

4,5,13,23,26,28.

None; all errors are fatal.

None.

3,4,5,12,13,22,23,28,34.

None.

4,5,23,28.

•

Table F-2. Fatal Errors Issued by System Calls

OPEN

READ

WRITE

SEEK

RESCAN

DELETE

RENAME

ATTRIB

CONSOL

WHOCON

ERROR

LOAD

SPATH

1, 7, 24, 30, 33.

24,30,33.

7,24,30,33.

33.

1, 24, 30, 33.

1,24, 30, 33.

1, 24,30, 33.

1,4,5,12,13,14,22,23,24,28,30,33.

33.

1,15,16,24,30,33.

33.

F-3

•

Ii>

•

APPENDIX G

SYNTAX SUMMARY

The syntax of Pascal is described below using Backus-Naur Form (BNF) notation.

This notation uses meta-symbols which belong to the BNF formalism, and are not symbols of the Pascal language. These meta-symbols are:

In addition, syntactic constructs are denoted by English words enclosed in angular brackets, as in <digit>. These words(s) also define the meaning or nature of the construct. The syntactic construct <empty> denotes the null sequence of symbols.

The first symbol, ::=, is used in BNF productions to mean "is defined to be," as in:

<digit>

::=

011 12131415\617\819

The bar symbol

(I ) is used to denote alternation, as in the above production. In other words, <digit> is defined to be either 0, 1, 2, ... , or 9.

The braces,

I and

,denote zero or more repetitions of the symbols enclosed in them. In particular, the production

X::=

I is a short form of the recursive construct

::=

<empty> \ XV

In the following productions, symbols in upper case denote terminal symbols, not syntactic constructs.

The BNF Description of Pascal

<~lock>

•

::=

PROGRAM <identifier>; I

PROGRAM <identifier> ( <file identifier>

{ , <file identifier> ) );

<block>

::=

<type definition part) <variable declaration part)

<procedure and function declaration part) <statement part)

::=

<empty>

LABEL <label> { , <label> ) ;

<label>

::=

::=

<empty>

CONST <constant definition> ( ; <constant definition> );

::=

::=

{ ; <type definition>

::=

0-1

Syntax Summary

The BNF Description of Pascal (Cont'd.)

::= (

<identifier> ( • <identifier> ) )

::=

: :=

<unpacked structured type> I

PACKED <unpacked structured type>

::=

<array type> I <record type> I

<array type> ::

ARRAY [ <index type> ( • <index type>) OF

::=

::=

RECORD <field list> END

::=

::=

::=

<field identifier> ( • <field identifier> ) :

<type>

<empty>

::=

CASE <tag field> <type identifier> OF

<variant> ( • <variant> )

<tag field> ::= <field identifier> :

<empty>

::=

::=

<case label> ( , <case label> )

::=

::=

STRING I STRING [ <unsigned integer>

::=

SET OF <base type>

::=

::=

FILE OF <type>

TEXT

INTERACTIVE

FILE

::=

::=

VAR <variable declaration>

, <identifier)

I :

<type>

::=

( <procedure or function declaration>

::=

<procedure declaration> I

::=

PROCEDURE <identifier> ;

PROCEDURE <identifier>( <formal parameter section>

( ; <formal parameter slection) } ) ;

::=

VAR <parameter group>

::=

<identi fier> { • <identifier> } :

::=

FUNCTION <identifier> : <result type> ;

FUNCTION <identifier> ( <formal parameter section>

( ; <formal parameter section>

I ) :

0-2

PASCAL-SO

•

PASCAL-SO

•

The BNF Description of Pascal (Cont'd.)

<statement_ part> ::= <compound statement)

<label>

<unlabelled statement)

<assignment statement> ::= <variable> := <expression> I

(

• < expression>

) 1

::=

<file buffer> ::= <file variable> -

<referenced variable> ::= <pointer variable> -

<relational operator> ::=

= I <> I < I <= I >= I > I

::=

<term> I <sign> <term> I

<adding operator> ::= + I I OR

<term>

::=

::=

I / I

DIV

MOD

AND

<factor> ::

::=

<function identifier> I

( , <actual parameter> ) )

::=

<set> ::= [ <element list> 1

::=

<element> ::

<expression> I (expression> •• <expression>

::=

<procedure identifier> I

( • <actual parameter> ) )

<procedure identifier> ..

Syntax Summary

0-3

Syntax Summary

The BNF Description of Pascal (Cont'd.)

::=

GOTO <label>

::=

<empty>

::=

::=

<compound statement> 1

<compound statement> ::= BEGIN <statement> ; <statement> } END

::=

::=

IF <expression> THEN <statement>

IF <expression> THEN <statement> ELSE <statement>

( ; <case list element> ) END

::=

<empty>

<case label list> ::= <case label> ( , <case label> )

::=

<while statement> I <repeat statement> I

::=

WHILE <expression> DO <statement>

::=

REPEAT <statement>

UNTIL <expression>

; <statement>

<for list> DO

< sta tern en t>

::=

<initial value> DOWNTO <final value>

::=

::=

::=

::=

WITH <record variable list> DO <statement>

::=

::=

<constant> ::

<unsigned number> ::

< unsigned real>

::=

::=

<d ig it> ) 1

E <scale factor>

::=

<sign>

::=+

::= '

<character> ! <character> ) ,

::=

NIL

AIBICIDIEIFIGIHIIIJIKILIMINIOIPIQIRISITIUIVIWlxlYlzl alblcidielflglhliljlkillminiolplqlrlsitlulvlwixlylz

<d ig it> : : = 0 11 12 13 14 15 16 17 18 19 10

0-4

PASCAL-SO

•

APPENDIX H

SUMMARY OF

EXTENSIONS TO STANDARD PASCAL

PASCAL-80 is an extension of Standard Pascal, as defined in the PASCAL User

Manual, and incorporates structures and operations not found in Standard Pascal.

The following data types are extensions to Standard Pascal and are described in

Chapter 2 and Chapter 7.

The string type

Untyped FILEs

INTERACTIVE files

The MESSAGE type

The following predeclared procedures and functions are extensions to Standard

Pascal, and are described in Chapter 3: blockread(f,a,b [,s]): integer blockwrite(f,a,b los]): integer bufferread(f,a,1 lob]): integer bufferwrite(f,a,1 lob]): integer close(f,PURGE) concat(s, ... ,s): string copy(s,i,I): string delete(s,i,l) errorset(p) exit(p) filichar(a,l,c) gotoxy(x,Y) insert(s, t, i) ioresult: integer length(s): integer log(x): real mark(p) memavail: integer moveleft(s,d,l) moveright(s,d,l) portinput(p, v) portoutput(p, v) pos(p,s): integer pwroften(x): real release(p) reset(f, <string» rewrite(f,<string» scan(l,e,a): integer seek(f, <integer» setpointer(p, v) sizeof(v): integer systemcall(o,a)

The following predeclared procedures and functions are extensions to P ASCAL-80 specifically for

RMX/80

applications: rqacpt(mp,e) rqctck rqctsk(s) rqcxch(e)

H-I

H-2

Summary

of Extensions to

Standard PASCAL

rqdlvl(1 ) rqdtsk(t) rqdxch(e): integer rqelvl(1 ) rqendi rqgetlt(m,1 ,t) rqisnd(i) rqresm(t) rqsend(e,m) rqsetlt(m,1,t) rqsetp(a,1 ) rqsetv(a,1 ) rqsusp(t) rqwait(mp,e, t)

PASCAL-80

•

APPENDIX I

IMPLEMENTATION DETAILS

Data Type Formats

Every variable in P ASCAL-80 is aligned on an even-byte, or word, boundary, although individual elements of a PACKED structure may occupy as little as one bit

(in a PACKED ARRAY OF boolean). All interpreter operations expect their operands to occupy at least one word, even if not all of the information in that word is valid.

boolean

One word, with bit 0 indicating the value (false=O, true=1). The other bits are ignored by the boolean operations.

char

One word, with the low byte containing the character. The high order byte is ignored by operations using a value of type char.

integer

One word. The value is stored in two's complement form, so that a variable of type integer can assume values in the range - 32768 .. 32767.

scalar

One word, with value in the range 0 .. 32767.

real

Two words, in INTEL floating point format.

POINTER

One word, with a value in the range 0 .. 65535.

SET

0 .. 255 words, depending upon the number of elements in the set. Sets are stored as bit vectors, with a lower index of zero, where each bit corresponds to a possible set element. A set variable declared as "SET OF a .. b" is allocated (b+ 15)div16 words, all of which contain valid information. All elements past the last word of a set are assumed to not be elements of the set.

RECORDs and ARRAYs

Any number of words, depending upon the size of the structure. Arrays are stored in row-major order. When a record or an array is an operand to a procedure or internal operation, the structure itself is never loaded onto the stack; just a reference (pointer) to it.

1-1

1-2

Implementation Details

string

1..128 words, depending upon the declared maximum length of the string.

A variable declared as "s: string[n]" is allocated (n div 2)+1 words. The first byte of the string (s[O]) contains the current valid length of the string, while the bytes 1 .. s[O] contain the valid characters.

Implementation Size Limits

• The maximum number of characters in a variable of type string is 255.

• The maximum number of elements in a set is 255*16=4080.

• The maximum number of PROCEDUREs or FUNCTIONs in a segment is 127.

• The maximum number of user SEGMENT PROCEDUREs and SEGMENT

FUNCTIONs is 7.

• The maximum number of bytes of object code in a PROCEDURE or

FUNCTION is 1200.

• The maximum size of a data frame is 16383 words.

Differences Between PASCAL-80 and

Standard Pascal

In P ASCAL-80, the goto statement may only reference local labels; i.e., labels declared in the same block as the goto statement itself. A go to statement may not reference a label declared in an enclosing block, as is possible in Standard Pascal.

However, the predeclared procedure exit overcomes this limitation and provides even more capabilities.

P ASCAL-80 does not support the standard procedures pack and unpack as described in the PASCAL User Manual.

PASCAL-80 limits the (enumerated) elements of a set to positive values only.

PASCAL-80 does not support the construct in which PROCEDUREs and FUNC-

TIONs may be declared as parameters of a PROCEDURE or FUNCTION.

P ASCAL-80 does not support the predeclared procedure dispose. However, the procedures mark and release can be used to approximate the actions of dispose.

PASCAL-SO

•

APPENDIX

PASCAL REFERENCE TEXTS

The primary reference text for Pascal-80, the source which defines Standard

Pascal, is:

PASCAL User Manual and Report

Kathleen Jensen and Niklaus Wirth

Corrected Printing, 1978

In addition, the following texts should be investigated by anyone interested in programming in Pascal:

Algorithms

Data Structures

Programs

Niklaus Wirth

A Practical Introduction to Pascal

I.R. Wilson & A.M. Addyman

PASCAL, An Introduction to Methodical Programming

W. Findlay&D.A. Watt

Computer Science Press,

1978

(Microcomputer) Problem Solving Using PASCAL

Kenneth L. Bowles

Springer-Verlag, New York

1977

Programming in PASCAL

Peter Grogono

Addison-Wesley,

©

1978

An In troduction to Programming and Problem Solving with PASCAL

Schneider, Weingart, Perlman

Structured Programming and Problem-Solving with PASCAL

Richard B. Keiburtz

Prentice-Hall,

1978

•

J-l

•

APPENDIX K

DIRECTORY OF RELEASE DISKETTES

The PASCAL-80 System software is contained on each of two (2) release diskettes

(single and double density). The directory listing of each of these diskettes is as follows:

Single Density Release Diskette

DIRECTORY OF : F ~: 9500065.02

NAME .EXT BLKS LENUTH ATTR

PASCAL

COMP

.COD 293

GENOEJ.COD

PBORUN.LIB 378

10053

3686~

20ij8

47569

PBORAR.LIB 205

EX .PAS

ERROR .PAS

PEOPLE. OAT

FIG32 .PAS

FIG3ij .PAS

FIG36 .PAS

F1G38 .PAS

ASUM .OEJ

25603

810

8~7

700

982

13ij9 lij80

1152

100

ASUM .ASH

PSUM .OEJ

S1X3 .CSD

SIXl .PA2

SIXl .CSD

2 ij

733

130

111

3ij7

193

1817

NAME .EXT ELKS LENGTH ATTR

PASCAL. RES

102 12800

JOIN

.COD

P80EXT.LIB

3072

127

PBOISS.LIB 236 p80ISS.PLB 238

BUFFER. PAS 8

2958B

298~3

878

SEEKEX.PAS

FIG31 .PAS

FIG33 .PAS

F1G35 .PAS

FIG37 .PAS

5IX3 .PAS

ASUM .LST

PSUM .PLM

PSUM .LST

SIXl

.PAM

SIXl • PA 1

EIGHT1.PAS

10 ij

15 ij

6120

869 llij9

366

811

5ijij

171ij

361

2585

576

279

795

187212002

BLOCKS USED

Double Density Release Diskette

DIRECTORY OF :Fl:970058.02

NAME

.EXT

BLKS

LENGTH ATTR

PASCAL 81 10053

COMP .COD 293

GENOBJ.COD 17

36864

2048

P8DRUN.LIB 378

P80RAR.LIB 205

.PAS 8

ERROR .PAS

PEOPLE.DAT

47569

25603

810

847

700

FIG32 .PAS

F1G34 .PAS

982

1349

FIG36 .PAS

FIG38 .PAS

ASUM .OBJ

ASUM .ASM

PSUM .OBJ

SIX3 .CSD

SIXl .PA2

SIXI .CSD

1480

1152

100

733

130

111

347

193

1817

NAME .EXT BLKS LENGTH ATTR

PASCAL.RES 102 12800

JOIN

.COD

P80EXT.LIB

3072

127

P8DISS.LIB 236

P80ISS.PLB 238

BUFFER. PAS

SEEKEX.PAS

FIG31 • PAS

FIG33 .PAS

FIG35 • PAS

FIG37 .PAS

SIX3 .PAS

ASUM .LST

PSUM

.PLM

.LST

SIXI .PAM

SIXl .PAl

29588

29843

1178

6120

869

1149

366

811

544

1714

361

2585

576

279

EIGHT1. PAS 8 795

1926/4004 BLOCKS USED

•

K-l

•

Hej! Jeg er en AI-chatbot, der er specielt trænet til at hjælpe dig med Intel PASCAL-80 software User's Guide. Jeg har grundigt gennemgået dokumentet og kan hjælpe dig med at finde den nøjagtige information, du har brug for, eller forklare indholdet på en klar og simpel måde. Uanset om du leder efter vejledning om specifikke funktioner, fejlfindingstrin eller generel brug, er du velkommen til at stille dine spørgsmål. Jo flere detaljer du giver om dine bekymringer eller behov, jo mere præcist og effektivt kan jeg hjælpe dig!

Assistent skriver

Assistenten er ikke ved tastaturet. Prøv igen senere.

Det ser ud til, at du er nået til et dokument, der er skrevet på flere sprog, herunder et, der ikke er dit modersmål. Du kan bruge følgende links til midlertidigt at skjule sider uden det sprog, du foretrækker.

Annonce