fsh—A functional unix command interpreter

Command interpreters under the UNIX operating system typically employ the syntax and semantics of imperative programming languages. Many of the advantages that functional programming languages hold over imperative languages can be incorporated in a functional command interpreter. Unfortunately, functional command interpreters to date have used the syntax of Backus's FP. The advantages of command expressiveness and composition have not been appreciated. A powerful functional command interpreter, fsh, that overcomes many of the deterrents of previous functional command interpreters is presented. Much of the unnecessary complexity of existing UNIX command interpreters is avoided by following the functional paradigm. fsh has been implemented under the UNIX 4.2BSD and System V operating systems.     

An operating system for interactive terminals

Conventional operating systems have for many-years used the ideas of standard stream interfaces to peripherals. Multi-tasking has been used in order to give an efficient response while maintaining simplicity and flexibility for the user. This paper describes an extension to an operating system which makes similar facilities available for the control of interactive workstations, and also provides a command dispatcher which enables the straightforward implementation of arbitrary user-defined command languages. The current system has been written in BCPL to run on a PDP 11/45 handling a Vector General display, but the design is suitable for use with a variety of terminals, computers and languages.     

Support for graphs of processes in a command interpreter

Since the inception of pipes in the UNIX operating system, the standard UNIX command interpreters, or shells, have supported processes connected only in linear arrangements. This paper explains why linear pipe structures are too restrictive and how the standard UNIX shells have dictated the interface strategy of new commands. A new command interpreter is presented that supports general directed process graphs. Processes and files are considered simply as nodes and pipes as arcs in a process graph.     

The evolution of job control languages

Job control languages are a feature of any large scale operating system. This paper traces the historical development of these languages, and compares two representative examples, OS/360 JCL and GEORGE 3 command language. The paper draws an analogy between job control languages and programming languages, showing that JCL is equivalent to an assembly language, whilst GEORGE 3 command language is like a simple autocode.     

Duplication and partial evaluation

This paper presents a general implementation framework for reflective languages. It allows us to systematically build reflective languages which have the following favorable properties: (1) user programs are allowed to access and change (parts of) metalevel interpreters, (2) reflective facilities are available at every level, (hence there exists conceptually an infinite tower of interpreters), and (3) the interpreter runs as efficiently as the conventional (directly implemented) metacircular interpreter when reflection is not used. Our scheme is divided into three stages. First, we define interpreters which give the operational semantics of each level, and conceptually construct the infinite tower of these interpreters. They are thenduplicated to obtain directly executed interpreters, while introducing double interpretation to maintain redefinability of interpreters. Finally, partial evaluation is employed to collapse the double interpretation into single interpretation. We illustrate our scheme by implementing a particular reflective language calledBlack in Scheme, but it is general enough to be applied to other reflective languages. The paper gives the complete Scheme implementation of Black and demonstrates some examples. We also show how a system with the delta abstraction introduced by Blond can be constructed in our framework.     

Executing continuation semantics: A comparison

Several authors have suggested translating denotational semantics into prototype interpreters written in high-level programming languages to provide evaluation tools for language designers. These implementations have generally been understandable when restricted to direct denotational semantics. This paper considers using two declarative programming languages, Prolog and Standard ML, to implement an interpreter that follows the continuation semantics of a small imperative programming language, called Gull. Each of the two declarative languages presents certain difficulties related to evaluation strategies and expressiveness. The implementations are compared in terms of their ease of use for prototyping, their resemblance to the denotational definitions, and their efficiency.     

A dialogue system for creating and manipulating graphical symbols and structures

Conventional higher level programming languages have not been designed for effective application to the kind of problems which arise in interactive computer graphics. In order to correct this, efforts have been made to use conversational languages or to design command languages which allow the user to interact with the system via light buttons or teletype.This paper describes a conversational system — called DIGS — using a keyboard-oriented language. The language enables the user to construct models step-by-step with a minimum of typing effort. Intermediate results (graphic or non-graphic) may be controlled at each point of the construction process.The purpose is to provide a tool for easily creating and editing fairly complex symbols as well as hierarchic pictures. Data can be associated with the picture parts and relationships defined between them.     

The design of an object-oriented command interpreter

Object-oriented programming languages are noted for their ability to allow users quickly to construct large software systems. They achieve this ability by allowing the programmer to concentrate on what it is they want to do, ignoring details of how that functionality is achieved. Such characteristics should make the object-oriented style of programming attractive to casual or novice computer users, indeed one of the best known object-oriented programming languages, Smalltalk, was initially designed with just such novice users in mind. The Unix operating system is widely regarded as a good environment for doing software development. Nevertheless, its large number of often terse and cryptic commands make it difficult for novice or casual users to use. In this paper we argue that one solution is to create an object-oriented command interpreter, or shell, between the user and the underlying system. This paper reports on the construction of one such prototype shell, and the lessons we have learned from the use of this system.     

Static and Dynamic Program Compilation by Interpreter Specialization

Interpretation and run-time compilation techniques are increasingly important because they can support heterogeneous architectures, evolving programming languages, and dynamically-loaded code. Interpretation is simple to implement, but yields poor performance. Run-time compilation yields better performance, but is costly to implement. One way to preserve simplicity but obtain good performance is to apply program specialization to an interpreter in order to generate an efficient implementation of the program automatically. Such specialization can be carried out at both compile time and run time.Recent advances in program-specialization technology have significantly improved the performance of specialized interpreters. This paper presents and assesses experiments applying program specialization to both bytecode and structured-language interpreters. The results show that for some general-purpose bytecode languages, specialization of an interpreter can yield speedups of up to a factor of four, while specializing certain structured-language interpreters can yield performance comparable to that of an implementation in a general-purpose language, compiled using an optimizing compiler.     

Building Interpreters with Rewriting Strategies

Programming language semantics based on pure rewrite rules suffers from the gap between the rewriting strategy implemented in rewriting engines and the intended evaluation strategy. This paper shows how programmable rewriting strategies can be used to implement interpreters for programming languages based on rewrite rules. The advantage of this approach is that reduction rules are first class entities that can be reused in different strategies, even in other kinds of program transformations such as optimizers. The approach is illustrated with several interpreters for the lambda calculus based on implicit and explicit (parallel) substitution, different strategies including normalization, eager evaluation, lazy evaluation, and lazy evaluation with updates. An extension with pattern matching and choice shows that such interpreters can easily be extended.     

基于Python的SCPI命令解释器的设计

目前可编程仪器标准命令（SCPI）依然被广泛使用,因此设计一个高效通用的SCPI命令解释器很重要。常用的SCPI命令解释器多以C语言开发,采用链式二叉树等存储结构,多有如解析效率低、通用性差、不识别等效命令等缺点。因此提出一种基于Python语言的设计。相比于常用的链式二叉树或顺序存储等结构,本设计提出一种基于Python字典结构的新型存储结构,减少了解析时的查询次数,提高了解析效率。而针对常用SCPI命令解释器通用性差的缺点,本设计提出以XML文档描述SCPI命令树,在启动时动态加载进内存的方式提高了解释器的通用性。同时,由于Python跨平台的特性,所设计的SCPI命令解释器也拥有良好的跨平台特性,适于在各平台下工作。     

Multilingual rule-based approach to number expansion: Framework, extensions and application

The language development of a multilingual text-to-speech system requires contribution from linguists and native speakers of a given language. Text normalization including number expansion is one of the language-specific processing steps. The most available solutions do not support inflections and are not simple enough to be practical for non-technical developers. This paper presents a novel solution for expressing the number expansion rules. The rule framework is fast and easy to use without technical background and truly multilingual supporting gender-specific inflections of numerals. The rules require only a small amount of memory and are conveniently stored as software independent language data. The same rule framework can be extended to carry out other text-normalization tasks including processing of context-dependent abbreviations and interpretation of formatted text such as date and time expressions. The framework has been successfully used in creating number, unit and time conversion rules for 42 languages. The created rules supported cardinal numbers from 0 to 999999 and 13 units such as m, km, h and min. Professional translators without technical background generated the rules for most of the languages. The average number of rule lines for number, unit and time rules were 87, 49 and 13, respectively. The average development time for a full rule set was seven hours per language. The most complex rule sets were in Slavonic languages whereas the simplest ones were in Sino-Tibetan languages.     

TRIPOS—a portable operating system for mini-computers

There are several successful operating systems for mini-computers written in high level languages and the time is now ripe for the development of portable systems for such machines. The system described in this paper is primarily designed to provide a friendly interactive multiprocessing environment for a single user. From his point of view, substantial parts of the system are completely machine independent. These include, for instance, the filing system, the command language, text editors, overlaying facilities and interprocess communication primitives. The system is suitable for many different application areas ranging over process control, data acquisition, data communication, text handling, data base systems and teaching.     

CHEF: A versatile portable text editor

CHEF is an interactive text editor for use with both printing and display terminals. Its prime field of application is computer source program editing but it has some word processing capabilities that make it useful for documentation and general text editing work. There is a comprehensive set of whole-line operations, including block moves and the insertion of text from external files, together with substring replacement and line segmentation based on a flexible pattern-matching algorithm. There is a set of one-line buffers for temporary storage of lines or command strings and complex command sequences can be built up by macro substitution. Considerable effort has been made to design a command syntax that is flexible and consistent and, at the same time, minimizes effort during the editing process. CHEF copies the user's file into an internal work-space so that the original is not disturbed until the user is satisfied with the results of the editing session. A virtual memory technique is used to provide a work-space that can be almost any desired size, with random access to any part and efficient editing operations. CHEF is written in BCPL and has already been implemented on four different machines.     

From Syntactic Theories to Interpreters: Automating the Proof of Unique Decomposition

Developing syntactic theories for reasoning about programming languages usually involves proving a unique-decomposition lemma. The proof of such a lemma is tedious, error-prone, and is usually attempted many times during the design of a theory. We therefore investigate the automation of such proofs.We map the unique-decomposition lemma to the problems of checking equivalence and ambiguity of syntactic definitions. Because checking these properties of context-free grammars is undecidable, we work with regular tree grammars and use algorithms on finite tree automata to perform the checking. To make up for the insufficient expressiveness of regular tree grammars, we extend the basic framework with built-in types and constants, contexts, and polymorphic types.Our implementation extends an earlier system by Xiao et al. [16] that translates semantic specifications expressed as syntactic theories to interpreters. We have successfully used the combined system to generate interpreters and verify the unique-decomposition lemma for a number of examples.     

UBMBPT—unrestricted Hartree—Fock many-body perturbation theory program in C

The open-shell single-reference many-body perturbation theory (MBPT) method for electron correlation calculation has been implemented up to the third order. The inclusion of bubble as well as non-bubble diagrams allows the unrestricted Hartree—Fock (UHF) reference with the UHF as well as the restricted Hartree—Fock (RHF) optimized orbitals. The program has been implemented in C language for its efficiency and flexibility. Given the input requirements and physical resource limitations, dynamic memory allocation capability of C allows optimal use of physical memory automatically. Input data are taken from the standard input stream in text/ASCII form for generality; allowing interoperation with programs in other languages and piping for minimizing disk space requirements. If the correct input is provided by the appropriate SCF program and prefilter, user involvement in the calculation is minimal. Various command line options are provided to monitor the program progress through timings, memory allocation and deallocation as well as file and disk size tracing. The appropriate environment variables under UNIX operating system allow flexible reassignment of temporary files to different directories and/or disks without program recompilation.     

Creating natural language interfaces to VR systems

Two research projects are described that explore the use of spoken natural language interfaces to virtual reality (VR) systems. Both projects combine off-the-shelf speech recognition and synthesis technology with in-house command interpreters that interface to the VR applications. Details about the interpreters and other technical aspects of the projects are provided, together with a discussion of some of the design decisions involved in the creation of speech interfaces. Questions and issues raised by the projects are presented as inspiration for future work. These issues include: requirements for object and information representation in VR models to support natural language interfaces; use of the visual context to establish the interaction context; difficulties with referencing events in the virtual world; and problems related to the usability of speech and natural language interfaces in general.