Symbol Table Research Articles

Test template framework

A framework for specification-based testing is demonstrated on a symbol table case study, specified using the Z notation. Test derivation and structuring is discussed, as well as applications of the framework in deriving test oracles and aiding regressing testing during maintenance. Areas for further research and discussion are comparison of heuristics with regard to generated test suites and usability, formalising testing heuristics, and the discrepancy between functional testing and robustness testing.

Data security in a fixed-model arithmetic coding compression algorithm

The data security provided by a fixed-model arithmetic coding compression algorithm is investigated. The “key” to this proposed encryption system comprises the source symbol table and associated frequencies (the model). A chosen plaintext attack is described which allows determination of the key. The major weakness of the algorithm is the generation of non-random output. Repeating binary strings are produced upon input of long strings of one source symbol. This feature can be used to determine the ordering of the symbols in the source symbol table and their associated frequencies. The key is thus discovered, allowing an attacker to decipher intercepted messages. Security may be improved by choosing random symbol ordering and random frequencies. This adversely affects the performance and compression characteristics, however. The algorithm is not recommended for encryption purposes.

A concurrent compiler for Modula-2+

In this paper we describe a collection of techniques for the design and implementation of concurrent compilers. We begin by describing a technique for dividing a source program into many streams so that each stream can be compiled concurrently. We discuss several compiler design issues unique to concurrent compilers including source program partitioning, symbol table management, compiler task scheduling and information flow constraints. The application of our techniques is illustrated by a complete design for a concurrent Modula-2+ compiler. After describing the structure of this compiler's performance that demonstrates that significant improvements in compilation time can be achieved through the use of concurrency.

The Maximum Size of Dynamic Data Structures

This paper develops two probabilistic methods that allow the analysis of the maximum data structure size encountered during a sequence of insertions and deletions in data structures such as priority queues, dictionaries, linear lists, and symbol tables, and in sweepline structures for geometry and Very-Large-Scale-Integration (VLSI) applications. The notion of the “maximum” is basic to issues of resource preallocation. The methods here are applied to combinatorial models of file histories and probabilistic models, as well as to a non-Markovian process (algorithm) for processing sweepline information in an efficient way, called “hashing with lazy deletion” (HwLD). Expressions are derived for the expected maximum data structure size that are asymptotically exact, that is, correct up to lower-order terms; in several cases of interest the expected value of the maximum size is asymptotically equal to the maximum expected size. This solves several open problems, including longstanding questions in queueing theory. Both of these approaches are robust and rely upon novel applications of techniques from the analysis of algorithms. At a high level, the first method isolates the primary contribution to the maximum and bounds the lesser effects. In the second technique the continuous-time probabilistic model is related to its discrete analog—the maximum slot occupancy in hashing.

High-level tools for language implementation

TOOLS is a language implementation system based on the integration of context-free grammars and class-based programming. The main goal of TOOLS has been to explore unified mechanisms for different aspects of language implementations. To this end, the TOOLS specification language has been geared toward object-oriented languages so that various natural entities in the source text can be viewed as instances of object classes. Consequently, data structures like symbol tables, activation records, and intermediate code can be conveniently represented as collections of objects, and activities like passes and program execution can be represented as collective activations of objects. Experiments have shown that relatively efficient implementations can be produced in a short time using TOOLS.

Partial compilation of REXX

A comprehensive set of compilation techniques for coping with various dynamic features of the REXX programming language are described. Among them are a novel symbol table structure, a multiple representation method for type-free objects, and a number of run-time acceleration techniques. Most of the work can be unified under the general principle of delayed execution, which is applicable in other situations as well. Significant performance gains were observed in an experimental setting, and these results led to the decision to develop IBMs recently announced REXX compiler product.

Computational improvements in Prolog applications by predicate variable pointers

The programming tradeoffs between structure-oriented and clause-oriented operations on data structures in Prolog are limited in current implementations because the assertion of clauses that include uninstantiated variables destroys any binding between these variables and those with which they are unified in the execution of the program. Built-in predicates for Prolog that allow one to assert predicate variables pointers, which are constants, rather than uninstantiated variables, are presented. The author shows: the possible performance benefits of clause-oriented implementations of data structures over equivalent structure-oriented versions, the logical implications of the proposed built-in predicates, and their practical significance by integrating them in C-Prolog and evaluating the two different implementations of the symbol table dictionary in D.H.D. Warren's pseudo-Pascal compiler example.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

An object addressing mechanism for statically typed languages with multiple inheritance

In this paper we are concerned with addressing techniques for statically typed languages with multiple inheritance. The addressing techniques are responsible for the efficient implementation of record field selection. In object-oriented languages, this record selection is equivalent to the access of methods. Thus, the efficiency of these techniques greatly affects the overall performance of an object-oriented language. We will demonstrate that addresses, in such systems, cannot always be calculated statically and show how symbol tables have been used as address maps at run time. The essence of the paper is a new addressing technique that can statically calculate either the address of a field or the address of the address of the field. This technique is powerful enough to support an efficient implementation of multiple inheritance with implicit subtyping as described by Cardelli.

APLO: a simple modern APL

APL0 is a simple modern APL written entirely in APL2. It is smaller than APL2 (or even VSAPL) but is more powerful. APL0 is implemented as a shell that translates APL0 statements into standard APL2. Details such as symbol table and workspace management are all handled by native APL2. The result is a powerful and malleable APL system.

Analysis of brain gene expression in schizophrenia by molecular cloning techniques

The paper describes an investigation of some possible “dimensional” systems for the designation of physical concepts. The usual system, based on the primary concepts of length, mass, and time, results in a large number of ambiguities (Table II) and is therefore unsatisfactory. The introduction of an additional primary concept for heat and another for electromagnetism is an improvement, but many ambiguities still remain (Table III). The trouble is caused by our failure to distinguish between distances in different directions.By introducing two fundamental lengths lr and lt (radial and tangential) in place of the usual l, we eliminate the former difficulty and obtain distinct designation symbols for the concepts of energy and torque, for normal stress and shear stress, for pharosage (radiant energy per unit area) and hellos (brightness).There are six types of practical application for idon theory (“dimensions”), all of which are handled as well (or better) by the lr,lt-system as by the old method. Examples are given of the use of the new method in checking equations and in deriving new equations by idonic analysis. Tables of designation symbols are given for the principal concepts of physics (Table VI to X). Finally, an alternative system is outlined which employes the fundamental lengths lr, lt, and l, and which discriminates between vectors and scalars in physical space (Table XI). This vector system is useful in certain problems, though in most cases the simpler lr/lt-system is adequate.

A hypergraph-based hierarchial data structure and its applications

A new data structure, which combines a hierarchical organization with a hypergraph-based representation, is presented. This structure, called a structured hypergraph, is a hierarchy of hypergraphs and combines the two concepts of modular decomposition and of description of an entity at different levels of abstraction. Two basic transformations, called refinement and abstraction, are described. These latter are the basic tools for defining and modifying a structured hypergraph. Applications of this structure as a hardware system model, as a description of the symbol table of modular language, as a hierarchical representation of solid objects, and as a model of computer networks are discussed.

Detecting stack-based environments in denotational definitions

We present a statically checkable, sufficient, syntactic criterion for implementing the environment argument in a denotational definition as a global stack variable. We also show how such an environment can be implemented as a compile-time symbol table. If the denotational definition also supports a global store variable, the store can be implemented as run-time primary storage, and a conventional compile/evaluate implementation results. In addition to its value for implementation, the criterion is useful for understanding the relationship between functional and imperative programming language styles. We present two examples.

Source encoding using syntactic information source models

The use of syntactic information source models for the source encoding (data compression) of messages is described. Syntactic models formulated using context-free grammars augmented with derivation step probabilities are considered. Using an arithmetic coder as the low-level encoding unit, it is shown how practical encoding systems can be constructed from such models. Application of the techniques to the encoding of syntactically correct Pascal computer programs is described, and additional techniques including the use of symbol tables are introduced. The resultant syntactic encoders achieve compression of Pascal programs approaching 90%. >

Facilitating process prototyping by controlling the impact of change

Facilitating process prototyping by controlling the impact of change

The design of a language processor generator

AbstractLanguage processor generators are systems that produce various language processors (including compilers) on the basis of a high‐level specification. The design of language processor generators is discussed on the basis of experiments with a traditional compiler writing system (HLP78) employing pore LALR parsing and general attribute grammars. It is argued that these methods are too primitive from the practical point of view. The design of a new language processor generator, HLP84, is based on this view. This system is an attempt to provide high‐level tools for a restricted class of applications (one‐pass analysis). The syntactic facilities include regular expressions on the right‐hand sides of productions, a disambiguating mechanism that is integrated with regular expressions, and a mechanism for using semantic information to aid parsing. The semantic facilities include automatic support for semantic error handling and for symbol tables. Early experiences with the new system show that in spite of the general overhead caused by the higher automation level, the system allows the generation of reasonably efficient processors.

大縮尺地図の類似系記号による分析とそのサブルーチン化

This paper describes a symbols used in large scale method of subroutinization mapping by personal computer. First, the legend of these maps were analyzed and a table of the various symbols applied in different large scale maps was made out according to the line or area of symbols, such as, circle, triangle and etcetera. Then the classification of symbol elements was tested by analyzing “similar type symbols”. Regarding to the symbol subroutinization process, the standards for fixed-form symbols used in legends of large scale maps were set and the subroutine for most symbols were produced. The result shows that this method can process the map symbols more efficiently.

Flexible symbol table structures for compiling C++

AbstractAlthough the C++ programming language is derived from C, it has a fundamentally different formulation of scope. This paper describes the scope structure of C++ and outlines approaches to two of C++'s special translation problems: representing scope in the symbol table and determining destructor activation sequences on scope exit. The solutions presented are based on the operational view of scope in C++ as a collection of interrelated scope objects.

Dynamic compilation in the unix environment

AbstractA system for dynamic compilation under the Unix operating system is described. The basis of the system is an incremental assembler that can be used statically or during program execution to insert or replace a module in an executable image. All cross‐module references are via offets into a run‐time symbol table. All generated code is independent of its location or the location of the symbol table. The symbol table and all modules reside in memory segments compatible with the memory allocator malloc(). The symbol table origin is maintained in a processor register. Library procedures allow the assembler (or C compiler) to be called to alter the currently executing program, or to place a stub function which acts as a trap, so that when the stub is invoked it caues a file to be dynamically compiled into the executing program to replace the stub with a bona fide procedure. This facilitates the construction of advanced interactive environments using native code. Some example applications, to Prolog and to incremental compilation, are considered.

TOOLS: a unifying approach to object-oriented language interpretation

The object-oriented paradigm is applied to the interpreting of programming languages. An intermediate representation of a program is created as a collection of objects representing various entities in the conceptual world of the source language. These objects cover both the static and the dynamic aspects of a program. As a major advantage of this approach, issues that are traditionally handled by very different techniques (like symbol table management and the generation and execution of intermediate code) can be treated in a unified manner. The specification language of an interpreter generator based on these principles is described.

Efficient incremental evaluation of aggregate values in attribute grammars

Aggregate valued attributes, which store collections of keyed elements, are required in attribute grammars to communicate information from multiple definition sites to multiple use locations. For syntax directed editors and incremental compilers, symbol tables are represented as aggregate values. We present efficient algorithms for incrementally maintaining these aggregate values and give an incremental evaluation algorithm that restricts attribute propagation to attributes dependent only upon information within the aggregate value that has changed.