David R. Hanson

Generators in Icon

Icon is a new programming language that includes a goal-directed expression evaluation mechanism. This mechanism is based on generators--expressions that are capable of producing more than one value. If the value produced by a generator does not lead to a successful result, the generator is automatically activated for an alternate value. Generators form an integral part of Icon and can be used anywhere. In addition, they form the basis for the string scanning facility and subsume some of the control expressions found in other languages. Several examples are given.

An Alternative to the Use of Patterns in String Processing

SNOBOL4 is best known for its string processing facilities, which are based on patterns as data objects. Despite the demonstrated success of patterns, there are many shortcomings associated with their use. The concept of patterns in SNOBOL4 is examined and problem areas are discussed. An alternative method for high-level string processing is described. This method, implemented in the programming language Icon, employs generators, which are capable of producing alternative values. Generators, coupled with a goal-driven method of expression evaluation, provide the string processing facilities of SNOBOL4 without the disadvantages associated with patterns. Comparisons between SNOBOL4 and Icon are included and the broader implications of the new approach are discussed.

Storage management for an implementation of SNOBOL4

The implementation of the SNOBOL4 programming language requires some scheme for dynamic allocation and reclamation of storage. This paper describes the method used in a machine‐dependent implementation of SNOBOL4 called SITBOL. Available storage is divided into two regions: one for the allocation of storage for permanent or immovable objects and one for objects that are subject to reclamation. Reclamation is accomplished by a four‐phase algorithm, which includes marking, address adjustment and compaction. The reclamation process is supplemented by several heuristics that reduce the cost of reclamation and increase the amount of storage reclaimed. The storage overhead of the technique is analysed and compared with an alternate method. Some empirical measurements of actual SNOBOL4 programs are given that substantiate the results of the analysis.

A portable storage management system for the icon programming language

Icon is a new programming language designed primarily for non‐numerical applications. Its roots are in SNOBOL4 and SL5; as in those languages, execution‐time flexibility is an important attribute of Icon, although some aspects of programs are bound at compile time to improve efficiency. Icon, which is implemented in Ratfor, is also intended to be portable and suitable for 16‐bit computers. The storage management system in Icon is designed to meet the goals of portability, flexibility and efficiency. This is accomplished by subdividing the storage management system into a set of type‐specific storage management subsystems. This paper describes the implementation of these subsystems, their interaction, and their performance.

Is block structure necessary

Block structure is traditionally considered an a priori requirement for algorithmic programming languages. Most new languages since Algol‐60 have block structure. Reasons exist, however, to omit the general form of block structure‐nested procedure definitions in which references to identifiers defined in outer procedures are permitted‐from programming languages, especially those intended for systems programming applications. This paper reviews the concept of block structure and considers its advantages and disadvantages. It concludes that, in many cases, a module facility is superior to block structure and should be considered in lieu of block structure in future languages.

The icon programming language: an overview

1. Introduction 1 .1 Philosophy and Design Goal s Icon is a programming language designed for nonnumerical applications with an emphasis on string processing. Icon inherit s the philosophical bases of SNOBOL4 [1] and SL5 [2] : high-level , sometimes novel features ; ease and convenience of use ; and run-time flexibility. Unlike SNOBOL4 and SL5, Icon is intended to b e practical for production applications. The inherent conflic t between the philosophical goals and the size and speed necessar y for economic practicality is handled by including optional declarations . Consistent with the philosophy of the language, th e defaults provided in the absence of declarations provide th e flexibility needed for experimental and research applications. Declarations can be added to gain greater efficiency for production applications. Icon emphasizes expressive power in control structures. I t resembles SL5 rather than SNOBOL4 in this respect, although ne w mechanisms allow a smaller repertoire of basic constructs tha n that of SL5. Like SL5, Icon expressions return a result consisting of a value and a signal. Values are used in the norma l computational manner, while signals drive control structures. An important component of Icon is goal-directed evaluation o f expressions, called generators. Generators are capable of producing alternative values as demanded by circumstances. Th e goal-directed control structures and generators facilitate programming of search algorithms and they eliminate the need fo r patterns and scanning environments used for string analysis i n SNOBOL4 and SL5. In Icon, string scanning operations can b e freely mixed with other operations, integrating string processin g as a natural part of the language, as opposed to a separate facility as in SNOBOL4 and SL5 [3] .

A high-level programming and command language

Unifying programming and command languages is a promising idea that has yet to be thoroughly exploited. Most attempts at such unification have used Lisp or traditional languages, such as Pascal. This paper describes the command and programming language EZ , which attempts to unify command and programming languages by using high-level string-processing concepts, such as those in SNOBOL4 and Icon. EZ has particularly simple data abstractions that attempt to bridge the gap between the data abstractions of command languages and those of programming languages. This is accomplished by type fusion , which pushes the differences between some classes of types, such as strings and text files, out of the language and into the implementation. The language, its use, and its implementation are described.

Variable associations in SNOBOL4

This paper describes a new facility in the SNOBOL4 programming language that provides the capability to associate the execution of a programmer‐defined function with the act of assigning a variable a value or retrieving the value of a variable. The facility, called programmer‐defined variable association, subsumes the existing built‐in associations used for input, output and value tracing and provides, at the source‐language level, the protection and datatype coercion mechanisms used in keywords. Several applications are described that illustrate the usefulness of this addition to the language. The facility is especially useful for program monitoring and debugging. The implementation of this facility and the effect of implementation techniques on programming language design are also discussed.

A portable file directory system

A portable file directory system that provides a machine‐independent method for specifying files is described. The portable directory system, or PDS, facilitates uniform usage of portable software by supplying a standard for file specification. The PDS supports a hierarchical directory structure, similar to that in UNIX and Multics, and a set of primitives for manipulating the structure and preparing files for input/output. While the PDS participates in file specification, it does not participate in the actual i/o; it has no impact on i/o efficiency. The implementation, which is easily extended to include additional capabilities, is described. Experience in using the PDS as a part of command interpreters and preprocessors is also discussed.

Simple code optimizations

Program optimization has received a great deal of attention for many years, which has resulted in numerous advances in compiler technology. The effectiveness of various simple optimizations has received comparably little attention during the same time period. The simplicity of most programs suggests that straightforward optimizations pay the greatest dividends. This paper describes three such optimizations suitable for one‐pass compilers. The optimizations involve expression rearrangement, instruction selection, and the use of a cache for the allocation of resources. The cost of these optimizations is low; none require major changes to the size or structure of the compiler or reduce compilation speed by more than 10%. The benefits are high; each optimization results in at least a 10% average reduction in object code size and a corresponding reduction in execution time. Examples and implementation details are also described.