bluuebunny/crossref_metadata_2025_split huggingface dataset:
Compact coding of syntactically correct source programs
Authors: Contla Jose Felipe 
Published: November 2006

AbstractThe technique for compacting source programs is based on recording the path followed by the parser while traversing the syntax tables of the programming language in which the program was written. However, to record every syntactical form visited by the parser would contain redundant information. For example: every syntactically correct Pascal program contains the terminal symbol PROGRAM. Consequently while recording the path followed by the parser, the fact that this terminal symbol has been traversed could be ignored. Therefore, these are techniques for recording only the information which is essential for the decoder to reconstruct the original program by traversing the syntax graph.
The robust implementation of sequence‐controlled iteration
Authors: Newey M. C. , Waite W. M. 
Published: November 2006

AbstractMany Pascal compilers generate incorrect code for statements. The trap that catches many implementors, whereby overflow is generated incorrectly, is explained and means for avoiding it are discussed (with attention to cost). Most common languages have a similar construct in which iteration is ‘controlled’ by a sequence of values in that a variable takes on successive values of the sequence for the several executions of the ‘body’. Often, the size step is not restricted to plus‐or‐minus one (as in Pascal) and the correctness situation cannot be characterized in such black and white terms. Typically, there is a range of behaviours that are valid and the compiler writer is able to choose a compromise between time‐space overheads and avoidance of unnecessary overflow indications; we describe the latter behaviour as robust. We present techniques for implementation appropriate to several languages and direct comments at language designers warning against both ignoring and overestimating the cost of robustly implementing iteration statements with arbitrary step size. Lastly, we criticize the design of instructions available in some machines, ostensibly to support the implementation of such sequence controlled iteration statements.
A method of program transformation between variable sharing and message passing
Authors: Hikita Teruo , Ishihata Kiyoshi 
Published: November 2006

AbstractThere have been proposed and used many programming concepts for realizing interprocess communication and synchronization, and two fundamental categories among them are variable sharing (e.g. semaphores) and message passing (signals, input/output in CSP and redezvous in Ada). The aim of this paper is to investigate the relationship between these two mechanisms, and in particular, program transformation between them. We here propose a transformation method between parallel programs written in each of these two, which uses transformation schemes named monitor transformations. We exhibit the method by showing through a chain of program transformations the equivalence of two versions of a parallel algorithm called dynamic sorting array.
Combining mascot with modula‐2 to aid the engineering of real‐time systems
Authors: Budgen D. 
Published: November 2006

AbstractThis paper examines how the ‘MASCOT machine’ and the Modula‐2 language may be used together as a basis for engineering a range of real‐time systems. It is shown that Modula‐2 provides the features required for a satisfactory MASCOT implementation language without the normal need to add extra features or use preprocessing. The paper also describes how the MASCOT design tools can be interpreted more widely than has previously been considered in order to provide support for a large range of problems.
An evaluation of tagging
Authors: Van Vliet J. C. , Gladney H. M. 
Published: November 2006

AbstractTagging is the augmentation of run‐time data with some form of self‐description for type checking or storage management purposes. We have studied the contribution of automatic tagging by converting two programs written in object‐oriented languages to PL/1. We had thought that much of the apparent superiority of the object‐oriented version came from dynamic binding of operator invocations. However, of several factors contributing to program quality, automatic storage management and the availability of generic abstract data types seem equally important in the examples studied. Tags turned out to be needed for only a few data objects and are used in only a few places. When the obligatory tags are modelled in PL/1, the code becomes particular to the problem at hand and is less elegant. On the other hand, current implementations of object‐oriented languages have considerable overhead in both time and space for tags. This led us to consider combining tagged and non‐tagged objects in a single language.
A large scale network storage facility
Authors: Dakin R. J. , Lederer B. R. , Parker K. R. 
Published: November 2006

AbstractThis paper is concerned with the overall design of the Terabit File Store — a network storage facility based on a Braegen Automated Tape Library. The characteristics of the tape library — in particular its large capacity and slow access — provide both challenges and opportunities for the system designer. The use of disc cache and the optimization of file placement have been used to provide reasonable performance in the face of substantial tape handling times. Catalogue facilities have been tailored to cater for the support of large file holdings and user file back‐up applications. It has been possible to automate the back‐up of essential file‐store information which together with automatic integrity checks, helps to minimize the damage that can be caused by faults. Considerable attention has been given to facilities that automate much of the management of the system in a network environment. Other aspects of the design discussed in the paper include protection, housekeeping and host interfacing.
Video‐slide: A presentation aid for the bbc microcomputer
Authors: Rees Michael J. , Robson David J. 
Published: November 2006

AbstractVideo‐Slide is a powerful visual aid for the BBC Microcomputer. It can be used to support a wide variety of talks, ranging from lessons to business presentations. Video‐Slide manipulates screens of coloured information which are referred to as slides. These are compatible with the broadcast teletext standard. Slides are prepared in advance with graphics editor and librarian utilities. During the presentation itself, a display program gives simple, direct control over the sequencing of slides with several important features. Video‐Slide programs are menu‐driven with a simple visual interface, and are designed to be used by non‐computer users. This paper describes the design concepts and implementation of the Video‐Slide system.
Efficient algorithms to create and maintain balanced and threaded binary search trees
Authors: Iyengar S. Sitharama , Chang Hsi 
Published: November 2006

AbstractThe algorithm proposed by Chang and lyengar to perfectly balance binary search trees has been modified to not only balance but also thread binary search trees. Threads are constructed in the same sequence as normal pointers during the balancing process. No extra workspace is necessary, and the running time is also linear for the modified algorithm. Such produced tree structure has minimal average path length for fast information retrieval, and threads to facilitate more flexible and efficient traversing schemes. Maintenance and manipulation of the data structure are discussed and relevant algorithms given.
Design and implementation of the wisconsin storage system
Authors: Chou H‐T. , Dewitt David J. , Katz Randy H. , Klug Anthony C. 
Published: November 2006

AbstractWe describe the implementation of a flexible data storage system for the UNIX environment that has been designed as an experimental vehicle for building database management systems. The storage component forms a foundation upon which a variety of database systems can be constructed including support for unconventional types of data. We describe the system architecture, the design decisions incorporated within its implementation, our experiences in developing this large piece of software, and the applications that have been built on top of it.
Prtds — a pascal run‐time diagnostics system
Authors: White N. H. , Bennett K. H. 
Published: November 2006

AbstractA run‐time diagnostics system has been described that allows the user to interrogate a program fully in source language terms. In particular, dynamically created data structures are catered for. The diagnostics system allows all objects including those created dynamically to be interrogated and can display a graphical representation of linked data structures. This paper describes the implementation of such a system with the language Pascal on a GEC 4080.
A debugger for message‐based processes
Authors: Smith Edward T. 
Published: November 2006

AbstractThis paper describes a debugger of message‐based, communicating processes. This debugger is designed to reduce the apparent complexity of large systems of communicating programs by regarding only the interprocess activities of such programs. The debugger provides users with information about how sets of processes behave rather than what each program associated with each process does. It also provides various primitives for manipulating the interprocess activities of processes. In order to concentrate on just those operations pertinent to multi‐process debugging, the debugger provides no ability to access the source code of any program. Our system includes a user‐interface program, a mechanism to fire and execute interprocess debugging demons and a mechanism to obtain transcripts of interprocess activities. The user interface executes commands for the user at a terminal for creating and manipulating individual interprocess events. Demons are an event‐driven mechanism used to automatically monitor and modify interprocess events. Transcripts provide a record of interprocess events executed for a process that can be replayed later. We make use of these tools to provide individual process control, communication monitoring and process testing.
An intelligent pascal editor for a graphical oriented workstation
Authors: Jesshope C. R. , Crawley M. J. , Lovegrove G. L. 
Published: November 2006

AbstractA Pascal syntax directed screen editor, designed to run under PNX on an ICL Perq workstation is presented. The editor (Eliot) offers a structured approach to text editing and provides complete Pascal syntax checking. The exceptional graphic capabilities of the Perq are used to good effect in providing an efficient user interface by way of a hierarchy of pop‐up menus. Using this interface, skeletal programs may be entered down to the assignment statement, or procedure call level without recourse to the keyboard, selections being made from menus using a graphics tablet and puck. Eliot encourages block structured programs with nested blocks by the use of a tree structured menu, representing the program structure. This allows for efficient movement around the program, again using the tablet and puck. Syntax checking is performed continually with errors reported and highlighted immediately for correction at will. For further error checking a variable scan option can be invoked which lists details of variable names which are not declared, or declared more than once, or declared and not used at all.
A high level language based system for cross‐assembler definition
Authors: Ancona M. , Clematis A. , Dodero G. , Pino A. 
Published: November 2006

AbstractA method to develop cross‐assemblers is explained by describing the XMETA system, where the advantages given by the semantic power of meta‐assemblies have been combined with the clarity of modern high level languages, such as Pascal, in defining assembly semantics. XMETA accepts a superset of the IEEE‐P694 microprocessor assembly language standard syntax: system structure is detailed and examples are provided to illustrate its use. Actual experiences are briefly summarized in the conclusions.
Implementation of an interpreter for abstract equations
Authors: Hoffmann Christoph M. , O'donnell Michael J. , Strandh Robert I. 
Published: November 2006

AbstractThis paper summarizes a project whose goal is the implementation of a useful interpreter for abstract equations that is absolutely faithful to the logical semantics of equations. The interpreter was first distributed to Berkeley UNIX VAX sites in May 1983. The main novelties of the interpreter are strict adherence to semantics based on logical consequences, ‘lazy’ (outermost) evaluation applied uniformly, an implementation based on table‐driven pattern matching, with no run‐time penalty for large sets of equations, and strict separation of syntactic and semantic processing, so that different syntaxes may be used for different problems.
Compact recursive‐descent parsing of expressions
Authors: Hanson David R. 
Published: November 2006

AbstractCompiler writing tools, such as parser generators, are‐commonly used to build new operators. Nevertheless, constructing compilers by hand remains common. Such compilers are often built using recursive‐descent parsing for most of the language and operator‐precedence parsing for expressions. This paper describes a simple technique for parsing expressions using recursive descent that avoids the usual proliferation of procedures that occurs when recursive descent is used to parse expressions. By taking advantage of the similarity of the productions describing expressions in most languages, the n + 1 procedures usually required to parse expressions with n precedence levels can be replaced with a table and two procedures.
Executable semantic descriptions
Authors: Watt David A. 
Published: November 2006

AbstractWe describe how the denotational semantics of a programming language can be executed directly, if it is expressed in a suitable functional programming language such as ML. We also apply Mosses' idea of ‘semantic algebras’ to construct semantic descriptions that are significantly more modular and understandable than usual. The possibility of executing a language's semantic description directly supports a methodology of language design that we advocate: express the design as a formal language description, and use this to test and refine the design, before becoming committed to constructing a compiler.
Printing Arabic text using dot matrix printers
Authors: Khayat M. G. 
Published: November 2006

AbstractThe increased use of Arabic in computer systems makes it necessary to consider the effects of using Arabic script for input and output. Printing Arabic text using dot matrix printers requires special software or firmware. First, character shapes must be developed and loaded into the printer's memory. Secondly, since an Arabic letter can have up to four different shapes depending on its position in the word, a program must be developed to determine which shape of a character is to be printed. This process is called contextual analysis. Dot matrix printers have a character set of 128 codes including control codes, which implies that not all possible shapes of the Arabic alphabet can be loaded into the printer's memory. There are at least two solutions to this problem. One is to delete some of the shapes of certain characters. The other solution involves decomposing some of the shapes into common parts that can be combined to form the desired shape. In our approach, we use a combination of the two solutions. The result of this study is the development of two programs. One program is used to print Arabic text containing English text. The second program prints English text containing Arabic text. The programs change the fount of the printer according to the type of text. Both programs also perform contextual analysis of Arabic text.
Insecurities in FORTRAN DO‐loops
Authors: Cooke D. J. , Abdollahzadeh F. 
Published: November 2006

AbstractDespite a long‐established body of relevant computer science, lack of precise specification of certain aspects of FORTRAN and deviation from the published standards permit the construction of non‐standard programs which run under different systems to give contradictory results. This paper highlights certain deviant features of DO‐loops.
A probe effect in concurrent programs
Authors: Gait Jason 
Published: November 2006

AbstractThis paper reports on an experimental study of the probe effect, defined as an alteration in the frequency of run‐time computational errors observed when delays are introduced into concurrent programs. If the concurrent program being studied has no synchronization errors, then there is no probe effect. In the presence of synchronization errors, the frequency of observable output errors for a sample experimental program starts at a high value for small delays, oscillates rapidly as the delay is increased, and apparently settles at zero errors for larger values of delay. Thus, for sufficiently large delays, the probe effect can almost completely mask synchronization errors in concurrent programs. For sufficiently large concurrent process sets, even small values of embedded delay may mask synchronization errors, provided side effects in shared memory are not included in the observation.
File updating revisited
Authors: Lunbeck R. J. 
Published: November 2006

AbstractExpositions of sequential master file updating are usually concerned only with insertions of new records, alterations or deletions of existing records and with the joint processing of these transactions. In actual practice other types of file transactions may also be needed, such as printing of (parts of) records, preventing possible alterations of certain records, etc. A general framework for dealing as well with such transactions in one processing run is presented. Simplifications of this framework are possible for random‐access files.
Syntax‐directed compression of program files
Authors: Katajainen Jyrki , Penttonen Martti , Teuhola Jukka 
Published: November 2006

AbstractParsing can be applied to compress source programs. A suitably encoded parse tree, together with the symbol table, constitutes a very compact representation of the program. The paper reports a Prolog implementation of the method, including automatic, syntax‐directed, encoder and decoder generators. The test results show compression gains of 50–60 per cent.
Copying of dynamic structures in a pascal environment
Authors: Forsythe Kenneth , Matwin Stanislaw 
Published: November 2006

AbstractTwo 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.
Inter‐process communication in MVS/XA and applications for scientific and engineering information processing
Authors: Marinescu Dan C. 
Published: November 2006

AbstractThis paper surveys inter‐process communication in MVS/XA (multiple virtual system/extended architecture) and explores the use of cross‐memory services for this purpose. The lack of high‐level interfaces to system services is a major handicap in MVS/XA. Tools to provide high‐level services, in particular, tools for inter‐process communication, can be implemented in a simple, elegant and efficient way. The implementation and use of a communication subsystem, the extended communication facility (ECF), are also described. The ideas and mechanisms presented are useful for many scientific and engineering applications running under MVS/XA. Examples include distributed systems, applications using concurrent programming, a quasi‐batch environment, communication subsystems, and mail subsystems.
Iterative development of information systems: A case study
Authors: Blum Bruce I. 
Published: November 2006

AbstractThis paper makes some observations about the applicability of iterative development for system implementation. After a general discussion of the software process, the types of projects suitable for this approach are identified. A system designed to support the iterative development method is then briefly examined, and a case study of its use is presented. Conclusions about the process are drawn, and some research issues regarding productivity are defined.
Integrating distributed array processing into EMAS 2900
Authors: Brown Michael W. 
Published: November 2006

AbstractThis paper describes the integration of initially one, and later a second, ICL Distributed Array Processor (DAP) into a dual ICL 2972 installation running the Edinburgh Multi‐Access System (EMAS). The alterations made to each level of the operating system are briefly described, along with the methods for mounting some of the relevant ICL DAP compiler software. Software enhancements to enable multi‐programming of the DAP and a locally designed method for DAP data area expansion are also described. A brief résumé of the user facilities available is included, along with operational policies and some utilization figures.
Providing multi‐user access to distributed array processors
Authors: Stephens P. D. , Yarwood J. K. 
Published: November 2006

AbstractThis paper describes the integration of two ICL Distributed Array Processors (DAPs) into a dual ICL 2976 configuration running the Edinburgh Multi‐Access System (EMAS). The principles underlying the general multi‐access service are not compromised; special scheduling arrangements provide effective control and use of the DAP resource while allowing multi‐user access to the DAPs for DAP program development.
Algorithms for pattern matching
Authors: Davies G. , Bowsher S. 
Published: November 2006

AbstractThis paper describes four algorithms of varying complexity used for pattern matching, and investigates their behaviour. The algorithms are tested using patterns of varying length from several alphabets. It is concluded that although there is no overall ‘best’ algorithm, the more complex algorithms are worth considering as they are generally more efficient in terms of number of comparisons made and execution time.
Formatted syntaxes and modula‐2
Authors: Woodman Mark 
Published: November 2006

AbstractThe formatted syntax notation has been developed for the specification of formatted programming languages. This paper describes how a formatted syntax may be constructed for the purpose of prettyprinting an existing free‐format language. Those aspects of the system of particular relevance to free‐format languages are emphasized and their use explained. Also, a number of deficiencies in the defining metasyntax and formatting symbol repertoire are discussed. Practical enhancements and further areas of research are suggested. The programming language Modula‐2 is used for illustration, and a formatted syntax for it is given.
Dbxtool: A window‐based symbolic debugger for sun workstations
Authors: Adams Evan , Muchnick Steven S. 
Published: November 2006

AbstractDbxtool is a window‐ and mouse‐based debugger for C, Pascal and FORTRAN programs running on Sun workstations. Its use of the mouse as the primary input mechanism eliminates the need to type variables, line numbers, breakpoints and most commands. Its multiple windows provide several qualitatively different perspectives on the debugging problem. Compared to the Unix 4.2 BSD dbx from which it is derived, it has been extended with the abilities to debug multiple‐process programs, already‐running processes, and the Sun Operating System kernel.