Masataka Sassa

Generation of efficient LALR parsers for regular right part grammars

SummaryA method for building small fast LALR parsers for regular right part grammars is given. No grammar transformation is required. No extra state of the LALR parser for the recognition of strings generated by a right part is required. At some reduce states the parser may refer to lookback states (states in which the parser may be restarted after the reduction). An optimizing algorithm to reduce these references is also given.

Programming with streams in a Pascal-like language

A description is given of features which were added to a conventional programming language that will manipulate streams of values. A stream is a sequence of values of a certain fixed type. The number of elements of a stream may be determined at execution time, and evaluation of each element can be postponed until its value is actually needed. Many programs can be expressed naturally and clearly as networks of processes communicating by means of streams. The network is called a composite function and consists of several component functions. Since component functions are connected solely by streams, they greatly increase the flexibility of combinations and the reusability of programs. Loop statements can be considered as iterative statements over streams. One general problem in these networks is the mechanism of terminating each process of the network. A practical solution for this problem is presented. Comparisons to other programming styles, such as coroutines, Lisp, functional programming, and dataflow languages, are described. Three modes of execution are considered for the implementation of composite functions: parallel mode, coroutine mode, and inline mode. In the inline mode, a composite function is expanded and transformed into a single function, realizing maximum run-time efficiency. Algorithms for this expansion are given. >

Simultaneous Finite Automata: An Efficient Data-Parallel Model for Regular Expression Matching

Automata play important roles in wide area of computing and the growth of multicores calls for their efficient parallel implementation. Though it is known in theory that we can perform the computation of a finite automaton in parallel by simulating transitions, its implementation has a large overhead due to the simulation. In this paper we propose a new automaton called simultaneous finite automaton (SFA) for efficient parallel computation of an automaton. The key idea is to extend an automaton so that it involves the simulation of transitions. Since an SFA itself has a good property of parallelism, we can develop easily a parallel implementation without overheads. We have implemented a regular expression matcher based on SFA, and it has achieved over 10-times speedups on an environment with dual hexa-core CPUs in a typical case.

Rie, a compiler generator based on a one-pass-type attribute grammar

We herein describe a compiler generator, Rie, which is based on a one‐pass‐type attribute grammar. LR‐attributed grammars are one class of attribute grammars in which attribute evaluation can be performed in one pass during LR parsing without creating a parse tree. Rie was developed based on a variant of an LR‐attributed grammar called ECLR‐attributed grammar (equivalence class LR‐attributed grammar), in which equivalence relations are introduced into the LR‐attributed grammar. Rie generates a one‐pass compiler from a compiler description given in attribute grammar form. Many language processors have been developed using Rie. The generated compiler is only about 1.8 times slower than a handwritten compiler, which is fairly efficient for a compiler generated from formal descriptions.

Rie and Jun: towards the generation of all compiler phases

Two compiler generators, both based on attribute grammars, have been used together in an attempt to generate almost all compiler phases.

Yet another generation of LALR parsers for regular right part grammars

Abstract. In this paper we introduce two methods for building LALR parsers for regular right part grammars (RRPGs). Both methods build a parser directly from a grammar, require no extra state or data structure, and can deal with all LALR RRPGs.The first method is quite simple. For almost all LALR RRPGs, including the majority of grammars with stacking conflicts, parsing actions are similar to those of LALR parsers for usual context free grammars. No extra action is required to recognize a handle in this case. For other LALR RRPGs, the right hand side of a production is checked to recognize a handle.The second method does not require checking of the right hand side of a production to recognize a handle. Instead, it records the number of conflicts in LR items and in the stack. Unlike previous methods, our method needs no extra data structure.

Circular attribute grammars with remote attribute references and their evaluators

Attribute grammars (AGs) are a suitable formalism for the development of language processing systems. However, for languages including unrestricted labeled jumps, such as “goto” in C, the optimizers in compilers are difficult to write in AGs. This is due to two problems that few previous researchers could deal with simultaneously, i.e., references of attribute values on distant nodes and circularity in attribute dependency. This paper proposescircular remote attribute grammars (CRAGs), an extension of AGs that allows (1) direct relations between two distant attribute instances through pointers referring to other nodes in the derivation tree, and (2) circular dependencies, under certain conditions including those that arise from remote references. This extension gives AG programmers a natural means of describing language processors and programming environments for languages that include any type of jump structure. We also show a method of constructing an efficient evaluator for CRAGs called amostly static evaluator. The performance of the proposed evaluator has been measured and compared with dynamic and static evaluators.

Regular Expressions with Semantic Rules and Their Application to Data Structure Directed Programs

Summary Most input data have structures that can be defined by regular expressions, and it is often necessary to develop programs that process these input data not only syntactically but also semantically. One formal method of developing such programs is to use attribute grammars, that is, context-free grammars augmented with semantic rules. Context-free grammars, however, are often inferior to regular expressions as tools for representing data structures intuitively, and systems based on attribute grammars are rather complex. This paper proposes regular expressions with semantic rules , which can be used as tools for expressing the syntax and semantics of input data, and a method of generating programs for processing these input data. First, regular expressions with semantic rules will be defined as regular expressions intermixed with semantic statements. Then, an algorithm will be given for translating a regular expression with semantic rules to a nondeterministic finite automaton with semantic actions (NFAS), and another algorithm for translating an NFAS to a deterministic finite automaton with semantic actions (DFAS). Finally, our semantic rules and translation algorithms will be expanded so that the proposed method can be applied to programs that process data defined in terms of regular expressions with semantic rules, that is, to data-structure-directed programs.

Time-optimal short-circuit evaluation of Boolean expressions

Boolean expressions are an important constituent of programming languages and query languages for data base systems. Evaluation of boolean expressions by short-circuiting is a familiar method which skips over the evaluation of boolean primitives no longer relevant to the value of the expression as a whole. It often results in an attractive optimization of the execution time, both in programming languages [1,4,5] and in data base query languages [2,3]. However, commutativity and associativity of “and” and “or” operations, which can allow further optimization, is not taken into account in previous works. In this paper we focus on short-circuit evaluation of boolean expressions and present a method of realizing time-optimal short-circuit evaluation by reordering the evaluation sequence. In general, the time of short-circuit evaluation varies between the cases when it yields “true” and “false”. We first derive formulae to estimate the expected time and true/false probability of short-circuit evaluation in each case, given a boolean expression and an evaluation time and true/false probability for each boolean primitive of the expression. Using these formulae, we present a theorem to minimize the expected time of short-circuit evaluation by reordering the evaluation sequence of boolean subexpressions, based on laws of commutativity and associativity of “and” and “or” operations. The theorem utilizes the concept of dynamic programming. An early idea of this paper appeared in [7]; detailed discussions can be found in [6].