Left Recursion Research Articles

Tunnel Parsing with counted repetitions

The article describes a new and efficient algorithm for parsing, called Tunnel Parsing, that parses from left to right on the basis of a context-free grammar without left recursion and rules that recognize empty words. The algorithm is applicable mostly for domain-specific languages. In the article, particular attention is paid to the parsing of grammar element repetitions. As a result of the parsing, a statically typed concrete syntax tree is built from top to bottom, that accurately reflects the grammar. The parsing is not done through a recursion, but through an iteration. The Tunnel Parsing algorithm uses the grammars directly without a prior refactoring and is with a linear time complexity for deterministic context-free grammars.

POSSIBILITY OF USING ELEMENTS OF MATHEMATICAL LIBRARY FOR A PARALLEL LANGUAGE IN CONSTRUCTION MATRIX PROGRAMS

Today, due to problems in improving computing performance, parallel programming continues to evolve. There are many different languages in which you can write parallel programs. One of them is the functional-threading parallel programming language Pifagor, which in turn is very specific and allows you to write a program with maximum parallelism, as well as it is designed to solve the portability problem of parallel programs. Tools and a library of functions continue to be developed for this language. This study is devoted to the development of elements of the mathematical library and the search for the most effective mathematical parallel algorithms. The following methods are considered and used in the work: sequential, recursive (left and right recursion), factorization, and pairwise comparisons. As a result of the study, a number of mathematical functions were developed, and a study was made of the possibility of using these functions in the development of programs for multiplying large-dimensional matrices. The work demonstrates the effectiveness of using the developed simple functions implemented by different methods in matrix multiplication programs. The prospects of further work in this direction are noted, having in mind the analysis of the possibility of using artificial intelligence methods to increase efficiency and facilitate the development of parallel programs with large-sized matrices.

Packrat Parsing: A Literature Review

Packrat parsing is recently introduced technique based upon expression grammar. This parsing approach uses memoization and ensures a guarantee of linear parse time by avoiding redundant function calls by using memoization. This paper studies the progress made in packrat parsing till date and discusses the approaches to tackle this parsing process efficiently. In addition to this, other issues such as left recursion, error reporting also seems to be associated with this type of parsing approach and discussed here the efforts attempted by researchers to address this issue. This paper, therefore, presents a state of the art review of packrat parsing so that researchers can use this for further development of technology in an efficient manner.

Regularization of context free grammars on the base of equivalent transformations of syntax graph-schemes

CFR-grammarCFR-grammarIn the article we validate the urgency of the problem rapid tuning a syntactic definition of language that implemented by applying the method of regularization of a translational context-free grammar using the equivalent transformations of their syntactic graph-scheme to optimize the built parser. In the paper we handle the method of regularization of a translational context-free grammar using the equivalent transformations of their syntactic graph-scheme to optimize the built parser. The notion “regularization of a CF grammar” is introduced. We consider a CF grammar in a regular form (CFR-grammar) supplied with extended set of operations in regular expressions in the right hand side of rules. The algorithm of extracting left (right) recursion nonterminals has been shown for CFR-grammar case. It is implemented in the system SynGT (Syntax Graph Transformations).

Left recursion in Parsing Expression Grammars

Parsing Expression Grammars (PEGs) are a formalism that can describe all deterministic context-free languages through a set of rules that specify a top-down parser for some language. PEGs are easy to use, and there are efficient implementations of PEG libraries in several programming languages.A frequently missed feature of PEGs is left recursion, which is commonly used in Context-Free Grammars (CFGs) to encode left-associative operations. We present a simple conservative extension to the semantics of PEGs that gives useful meaning to direct and indirect left-recursive rules, and show that our extensions make it easy to express left-recursive idioms from CFGs in PEGs, with similar results. We prove the conservativeness of these extensions, and also prove that they work with any left-recursive PEG.PEGs can also be compiled to programs in a low-level parsing machine. We present an extension to the semantics of the operations of this parsing machine that let it interpret left-recursive PEGs, and prove that this extension is correct with regard to our semantics for left-recursive PEGs.

On the semantics of parsing actions

Parsers, whether constructed by hand or automatically via a parser generator tool, typically need to compute some useful semantic information in addition to the purely syntactic analysis of their input. Semantic actions may be added to parsing code by hand, or the parser generator may have its own syntax for annotating grammar rules with semantic actions. In this paper, we take a functional programming view of such actions. We use concepts from the semantics of mostly functional programming languages and adapt them to give meaning to the actions of the parser. Specifically, the semantics is inspired by the categorical semantics of lambda calculi and the use of premonoidal categories for the semantics of effects in programming languages. This framework is then applied to our leading example, the transformation of grammars to eliminate left recursion. The syntactic transformation of left-recursion elimination leads to a corresponding semantic transformation of the actions for the grammar. We prove the semantic transformation correct and relate it to continuation passing style, a widely studied transformation in lambda calculi and functional programming. As an idealization of the input language of parser generators, we define a call-by-value calculus with first-order functions and a type-and-effect system where the effects are given by sequences of grammar symbols. The account of left-recursion elimination is then extended to this calculus.

GLL parse-tree generation

Backtracking techniques which are often used to extend recursive descent (RD) parsers can have explosive run-times and cannot deal with grammars with left recursion. GLL parsers are fully general, worst-case cubic parsers which have the recursive descent-like property that they are easy to write and to use for grammar debugging. They have the direct relationship with the grammar that an RD parser has. In this paper we give an algorithm for generating GLL parsers which build an SPPF representation of the derivations of the input, complementing our existing GLL recognition algorithm, and we show that such parsers and recognisers are worst-case cubic.

Recognizing Bangla Grammar Using Predictive Parser

We describe a Context Free Grammar (CFG) for Bangla language and hence we propose a Bangla parser based on the grammar. Our approach is very much general to apply in Bangla Sentences and the method is well accepted for parsing a language of a grammar. The proposed parser is a predictive parser and we construct the parse table for recognizing Bangla grammar. Using the parse table we recognize syntactical mistakes of Bangla sentences when there is no entry for a terminal in the parse table. If a natural language can be successfully parsed then grammar checking from this language becomes possible. The proposed scheme is based on Top down parsing method and we have avoided the left recursion of the CFG using the idea of left factoring.

Recognizing Plans with Loops Represented in a Lexicalized Grammar

This paper extends existing plan recognition research to handle plans containing loops. We supply an encoding of plans with loops for recognition, based on techniques used to parse lexicalized grammars, and demonstrate its effectiveness empirically. To do this, the paper first shows how encoding plan libraries as context free grammars permits the application of standard rewriting techniques to remove left recursion and ε-productions, thereby enabling polynomial time parsing. However, these techniques alone fail to provide efficient algorithms for plan recognition. We show how the loop-handling methods from formal grammars can be extended to the more general plan recognition problem and provide a method for encoding loops in an existing plan recognition system that scales linearly in the number of loop iterations.

Total parser combinators

A monadic parser combinator library which guarantees termination of parsing, while still allowing many forms of left recursion, is described. The library's interface is similar to those of many other parser combinator libraries, with two important differences: one is that the interface clearly specifies which parts of the constructed parsers may be infinite, and which parts have to be finite, using dependent types and a combination of induction and coinduction; and the other is that the parser type is unusually informative. The library comes with a formal semantics, using which it is proved that the parser combinators are as expressive as possible. The implementation is supported by a machine-checked correctness proof.

GLL Parsing

Recursive Descent (RD) parsers are popular because their control flow follows the structure of the grammar and hence they are easy to write and to debug. However, the class of grammars which admit RD parsers is very limited. Backtracking techniques may be used to extend this class, but can have explosive runtimes and cannot deal with grammars with left recursion. Tomita-style RNGLR parsers are fully general but are based on LR techniques and do not have the direct relationship with the grammar that an RD parser has. We develop the fully general GLL parsing technique which is recursive descent-like, and has the property that the parse follows closely the structure of the grammar rules, but uses RNGLR-like machinery to handle non-determinism. The resulting recognisers run in worst-case cubic time and can be built even for left recursive grammars.

Typed Transformations of Typed Grammars: The Left Corner Transform

One of the questions which comes up when using embedded domain specific languages is to what extent we can analyze and transform embedded programs, as normally done in more conventional compilers. Special problems arise when the host language is strongly typed, and this host type system is used to type the embedded language. In this paper we describe how we can use a library, which was designed for constructing transformations of typed abstract syntax, in the removal of left recursion from a typed grammar description. The algorithm we describe is the Left-Corner Transform, which is small enough to be fully explained, involved enough to be interesting, and complete enough to serve as a tutorial on how to proceed in similar cases. The described transformation has been successfully used in constructing a compositional and efficient alternative to the standard Haskell read function.

A new top-down parsing algorithm to accommodate ambiguity and left recursion in polynomial time

Top-down backtracking language processors are highly modular, can handle ambiguity, and are easy to implement with clear and maintainable code. However, a widely-held, and incorrect, view is that top-down processors are inherently exponential for ambiguous grammars and cannot accommodate left-recursive productions. It has been known for many years that exponential complexity can be avoided by memoization, and that left-recursive productions can be accommodated through a variety of techniques. However, until now, memoization and techniques for handling left recursion have either been presented independently, or else attempts at their integration have compromised modularity and clarity of the code.

Generalized Bottom Up Parsers With Reduced Stack Activity

We describe a generalized bottom up parser in which non-embedded recursive rules are handled directly by the underlying automaton, thus limiting stack activity to the activation of rules displaying embedded recursion. Our strategy is motivated by Aycock and Horspool's approach, but uses a different automaton construction and leads to parsers that are correct for all context-free grammars, including those with hidden left recursion. The automaton features edges which directly connnect states containing reduction actions with their associated goto state: hence we call the approach reduction incorporated generalized LR parsing. Our parser constructs shared packed parse forests in a style similar to that of Tomita parsers. We give formal proofs of the correctness of our algorithm, and compare it with Tomita's algorithm in terms of the space and time requirements of the running parsers and the size of the parsers' tables. Experimental results are given for standard grammars for ANSI-C, ISO-Pascal; for a non-deterministic grammar for IBM VS-COBOL, and for a small grammar that triggers asymptotic worst case behaviour in our parser.

Semantics-preserving Migration of Semantic Rules During Left Recursion Removal in Attribute Grammars

Several tools for source-to-source transformation are based on top down parsers. This restricts the user to use grammars without left recursion. Removing left recursion of a given grammar often makes it unreadable, preventing a user from concentrating on the original grammar. Additionally, the question arises, whether the tool implements the semantics of the original language, if it is implemented based on a different grammar than in the original language definition. Moreover, existing implementations of semantics for the original grammar cannot be reused directly. The paper contributes to the field of automatic migration of software (here semantic rules) induced by a grammar change. It revises removal of left recursion in the context of grammar adaptations and demonstrates, that while removing left recursion at the same time the semantic rules can be migrated automatically. Thus, a programmer can continue to use semantic rules on a left recursive grammar. The problem is explained and justified.

Reducing non-determinism in right nulled GLR parsers

Tomita's general parsing algorithm is linear on LR(1) grammars but fails to terminate on grammars with hidden left recursion and is not efficient in the presence of $\epsilon$ -rules. When Right Nulled (RN) parse tables are used Tomita style GLR algorithms operate correctly and more efficiently on all context free grammars. However, an RN table may contain more conflicts than the corresponding LR table, making the construction of parts of the internal structure redundant. We show that in certain cases conflicts can be removed from an RN table without compromising the correctness of the associated parser. In particular, all conflicts can be removed if the grammar is LR(1). This improves the performance of the parser and allows resolved RN tables for LR(1) grammars to be used with standard (deterministic) LR stack-based parsing algorithms, adding the `short-circuiting' of right nullable reductions to the armoury of efficient implementation techniques for such algorithms.

Definite-clause set grammars: a formalism for problem solving

First, we present definite-clause set grammars (DCSG), a DCG-like formalism for free-word-order languages. The DCSG formalism is well suited for problem solving. By dealing with DCSG as a generalized parsing problem, we avoid a certain type of looping problem in backward chaining. Next, we extend DCSG by viewing grammar rules as definitions for set conversions. In order to realize inverse conversions, we introduce an inverse operator into DCSG syntax. This operator enables partial bottom-up analyses in the DCSG top-down parsing process. Next, we discuss a looping problem called “left recursion” in top-down parsing. The looping problem is avoided by the bottom-up mechanism of the extended DCSG. The bottom-up mechanism can be viewed as the top-down controlled firing of production rules. Unlike most production systems, production systems written in extended DCSG can backtrack and produce alternative solutions. DCSG is a simple but powerful tool for generalized parsing problems which involve finding structures in a given data set.

LexAGen: An interactive incremental scanner generator

AbstractThis paper describes LexAGen, an interactive scanner generator which is the first component of an interactive compiler generation environment. LexAGen can generate fast scanners for languages whose tokens can be specified by regular grammars. However, LexAGen also supports several context‐sensitive programming language constructs such as nested comments and the interaction between floating‐point numbers and the range operator in Modula‐2. In addition, LexAGen includes a fast new algorithm for keyword identification. However, the most important and novel aspects of LexAGen are that it constructs scanners incrementally and that specifications can be executed anytime for validation testing.LexAGen specifications are expressed and entered interactively in a restricted BNF format (no left recursion). All syntactic errors and token conflicts are detected and reported immediately as LexAGen incrementally constructs a deterministic finite automaton to represent the scanner. At any time, the user can test the scanner fragment which has been entered by supplying text to be scanned. Alternatively, the user can generate a C‐code scanner from the automaton. The generated automaton uses a direct execution approach and is quite fast.LexAGen is implemented in Smalltalk‐80. Its extensive use of interactive graphics makes it very easy to use. In addition, the object‐oriented paradigm of Smalltalk‐80 is the basis for the incremental analysis, the error detection scheme and an intermediate representation which can be easily modified to generate scanners in other target languages such as Pascal, Modula‐2 and Ada.

Parser generation and grammar manipulation using prolog's infinite trees

The construction of parsers recognizing strings in a context-free language L(G) is usually done by generating a set of PROLOG clauses capable of parsing strings of L. Although this is a convenient way of generating parsers, it does not readily allow one to study the properties of G or to perform grammar transformations. This paper proposes a general PROLOG parser capable of analyzing the strings of L(G) when G is presented as an infinite tree. In particular, if the syntax of the grammar rules themselves is specified by a grammar, the parser can be used to recognize context-free grammar rules. Subsequently, actions can be attached to the parser so that it is possible to generate infinite trees for any grammar G′. Strings of L(G′) can then be analyzed uing the same general parser. The proposed approach allows the verification of conditions such as left recursion, satisfiability of LL(1) requirements, as well as grammar transformations such as ε elimination. The same analyzer is also capable of generating efficient parsers for specific machines.

On the covering problem for left-recursive grammars

Two new proofs of the fact that proper left-recursive grammars can be covered by non-left-recursive grammars are presented. The first proof is based on a simple trick inspired by the over ten-year-old idea that semantic information hanged on the productions can be carried along in the transformations. The second proof involves a new method for eliminating left recursion from a proper context-free grammar in such a way that the covering grammar is obtained directly.