Forward-declared procedures parameter-lists and scope

This paper examines some issues which relate to the definition of scope in Pascal, and pressures which have been brought to bear on the draft international standard for Pascal for duplicate procedure headings for forward-declared procedures. The causes for these pressures, and the conceptual integrity of Pascal are discussed. The interfacing nature of parameter lists is examined, and the concept of ‘detergent construct’ introduced, leading to ‘detergent scope rules’.     

Strings and the sequence abstraction in Pascal

This paper examines the sequence abstraction known in Pascal as the ‘file’, and shows how sequences of characters (‘strings’ in the SNOBOL sense) may be cleanly fitted into Pascal-like languages. The specific problems of providing the suggested facilities as an experimental extension to Pascal are examined.     

A multi-user operating system for transaction processing,written in Concurrent Pascal

This paper presents a medium-sized operating system written in Concurrent Pascal, thereby describing further experience with this language and giving further indications of its scope. The operating system was developed to support an application in the area that is usually termed ‘commercial’ or ‘administrative’. Both the functional capabilities and the structure of the operating system are described, with emphasis on its facilities for data file management, and its size and performance are given. A secondary theme of the paper is the relationship of the operating system's qualities to the properties and facilities of the programming language Concurrent Pascal used for its development.     

A portable trace for the Pascal heap

Debugging aids for high-level languages supporting structured data types should provide diagnostic information in a form terminologically as close as possible to that of the original source code. In addition, it is desirable that such software be portable. The package HEAPTRACE satisfies both the above criteria. It is a precompiler for Pascal programs which enables the user to trace the heap, selectively dumping dynamically-created records in a high-level format. It is portable as it is written entirely in Pascal; furthermore, since it is implemented as additions and modifications to a well-known compiler, its principles may easily be built into any Pascal compiler or diagnostics system. However, there is a small price to pay for achieving portability in that three possibly desirable features cannot be satisfactorily implemented in a machine-independent manner.     

Copying of dynamic structures in a pascal environment

Two problems involving the use of dynamic lists in Pascal are (1) the limited size of the heap and (2) the difficulty in creating copies of complex multi-linked structures. Both these problems can be solved by writing the appropriate segment of memory to a file on disk. The heap segment may then be released. To recover the structure during a later phase of processing, the contents of the file can be transferred back onto the heap. This paper presents an algorithm to implement this solution.     

Extending the power of Pascal's external procedure mechanism

The CDC Pascal 6000–3.4 compiler allows external procedures to be designed and compiled separately. Such a mechanism strongly enhances the extensibility of the language. However, the external procedures are restricted to having ‘fixed’ parameter list only and is therefore unsuitable for designing I/O routines. This paper describes a cheap way to release the restriction thereby extending the power of the external procedure mechanism significantly. The method is to include a new compiler option, called the Z option, to the existing Pascal compiler. The Z option allows a user to breach the strong binding between format and actual parameters while not diminishing program reliability. The main advantage is that the I/O system can now be isolated from the compiler. I/O features can be added and removed easily as with other library routines.     

The costs and benefits of lazy interactive input in pascal

The programming language Pascal was designed and implemented in a non-interactive programming environment. This paper surveys proposals for incorporating interaction into Pascal, and focuses on a scheme known as ‘lazy evaluation’. It presents and compares performance measurements of two Pascal run-time systems for the same compiler; a buffered, non-interactive version, and a modification of that system to support lazy evaluation.     

UCSD Pascal on the VAX,portability and performance

Between 1976 and 1980 the Pascal Project at UCSD produced a ‘nearly portable’ operating system based on Pascal. Under the auspices of a graduate student project at UCSD, the UCSD Pascal system was ported to run in the 32-bit address environment of the VAX 11/780 under VMS and UNIX

1 UNIX is a trademark of Bell Laboratories. VAX and VMS are trademarks of Digital Equipment Corporation. UCSD Pascal is a trademark of the Regents of the University of California.

. This paper describes the implementation decisions and the portability and efficiency considerations that motivated the decisions. Improvements to portability and efficiency are discussed.     

The ‘Completeness’ of the pascal test suite

The British Standards Institution aided by the National Physical Laboratory (NPL) are setting up the framework for a national service which will validate Pascal compilers against the requirements of the ISO Standard for Pascal.¹ The basis of this service is the Pascal Compiler Validation Suite,² a large collection of test programs (produced jointly by NPL and the University of Tasmania) which were derived directly from the Standard, Naturally, the Suite must be as searching as possible, and Ideally all features of the language should be exercised by the Suite. This paper describes an investigation into the ‘completeness’ of the Suite; note that ‘completeness’ is not used in any formal sense throughout the paper. The investigation is carried out by passing the entire Suite through a model implementation of Pascal, the Standard Pascal Static Checker,³ to determine whether any parts of this implementation do not get exercised by the Suite. Further tests are then written to exercise these parts. A by-product of this work is a tool which produces an execution profile for a Pascal program; this paper describes the function of the tool.     

Compiling Vector Pascal to the XeonPhi

Intel's XeonPhi is a highly parallel x86 architecture chip made by Intel. It has a number of novel features which make it a particularly challenging target for the compiler writer. This paper describes the techniques used to port the Glasgow Vector Pascal Compiler to this architecture and assess its performance by comparisons of the XeonPhi with 3 other machines running the same algorithms. Copyright © 2015 John Wiley & Sons, Ltd.     

Has the program been altered?

It is often essential to know if a computer program has been altered. If the text has been provided on magnetic tape and subsequently loaded onto another computer with possible changes in the character set, the problem becomes more difficult. This paper proposes the use of a ‘parity check’ as used in digital data transmission. An implementation of this algorithm in Pascal is given together with details of how a Pascal source text can be checked for alterations using the algorithm.     

A microprogrammed P-CODE interpreter for the data general eclipse S/130 minicomputer

This paper describes the implementation of a P-CODE interpreter by microprogramming. An existing system based upon the Pascal P compiler was modified by rewriting the interpreter in microcode. Consequent improvements in the system performance are illustrated by times for compiling the compiler and various small Pascal programs. The execution rate for the new system is also compared with several other languages available on the Eclipse. Problems relating to Eclipse microcode when used for tasks of this type are also discussed.     

The supermac macro processor in pascal

SUPERMAC-Pascal is an implementation of the general-purpose macro processor SUPERMAC. It allows the user to write macros using Pascal procedures and to compile these procedures using his normal Pascal compiler. This paper describes how the macro processor was adapted to fit Pascal, and how the apparently intractable problems of performing string processing in Pascal were tackled.     

Run-time detection of undefined variables considered essential

Access to an undefined variable—one which has never been assigned a value—can be detected by automatic means. However, today's compilers do not detect undefined variables comprehensively, and the environment dependence of these errors often allows them to evade normal testing procedures. Language standards for Pascal, Modula-2 and Ada specify the circumstances in which the undefined variable access should cause an error trap. The logic of undefined in these standards is compared, revealing problems in security, implementation effort and consistency with accepted programming practice. An alternative logic, ‘undefined if totally-undefined’ is proposed.     

GRASP—A 3D graphics system for Pascal users

This paper describes a 3D graphics package ‘GRASP’ implemented in Pascal language and interfaced with the Pascal compiler developed for the DEC PDP-10 machine, by Urs Amman et al. GRASP supports storage tube and raster scan graphics terminals and pen plotters. The package is incorporated as a set of standard procedures into the enhanced Pascal compiler. The various features of the package are presented here and a comparison is made vis-a-vis the other existing 3D graphics packages. GRASP is simple to use and provides a valuable tool for the development of application programs written in Pascal and requiring a graphics capability.     

An analysis of Pascal programs in compiler writing

A method and results of static and dynamic analysis of Pascal programs are described. In order to investigate characteristics of large systems programs developed by the stepwise refinement programming approach and written in Pascal, several Pascal compilers written in Pascal were analysed from both static and dynamic points of view. As a main conclusion, procedures play an important role in the stepwise refinement approach and implementors of a compiler and designers of high level language machines for Pascal-like languages should pay careful attention to this point. The set data structure is one of the characteristics of the Pascal language and statistics of set operations are also described.     

Extension of Pascal by coroutines and its application to quasi-parallel programming and simulation

This paper describes an extension of Pascal by coroutines as a basic tool to make quasi-parallel programming possible. This extension is acheived by predefined procedures, i.e. by semantical means without modification of the syntax of the language. Process and simulation concepts are developed entirely in the extended Pascal. These concepts are suited for quasi-parallel programming and for process-oriented simulation of discrete-event systems. The presented simulation system is easy to implement, it is flexible and modifiable. It retains the powerful facilities and the portability and availability of Pascal.     

A contextual analysis of Pascal programs

More than 120,000 lines of Pascal programs, written by graduate students and faculty members, have been statically analysed to provide a better understanding of how the language is ‘really’ used. The analysis was done within twelve distinct contexts to discover differences in usage patterns among the various contexts. For example, it was found that 47 per cent of the operands in arguments lists were constants. The results are displayed as tables of frequency counts which show how often each construct is used within a context. Also, we have compared our findings to the results from studies of other languages, such as FORTRAN, SAL and XPL.     

A note on extension of Pascal by coroutines

In this communication, a simplification is suggested for the coroutine extension of Pascal described by Kriz and Sandmayr. In addition to being simpler to implement, it is also more user-friendly and secure because most of the strict sequence constraints on procedure invocations are lifted. The scheme uses the Pascal-P compiler, without modification except for the addition of a few built-in procedures, together with a macroassembler for Pcode preprocessing.