The Experts below are selected from a list of 258 Experts worldwide ranked by ideXlab platform
Hanspeter Mossenbock - One of the best experts on this subject based on the ideXlab platform.
-
ll 1 conflict resolution in a Recursive Descent compiler generator
Lecture Notes in Computer Science, 2003Co-Authors: Albrecht Wos, Markus Loberbauer, Hanspeter MossenbockAbstract:Recursive Descent parsing is restricted to languages whose grammars are LL(1), i.e., which can be parsed top-down with a single lookahead symbol. Unfortunately, many languages such as Java, C++, or C# are not LL(1). Therefore Recursive Descent parsing cannot be used or the parser has to make its decisions based on semantic information or a multi-symbol lookahead.
-
JMLC - LL(1) Conflict Resolution in a Recursive Descent Compiler Generator
Lecture Notes in Computer Science, 2003Co-Authors: Albrecht Wöß, Markus Loberbauer, Hanspeter MossenbockAbstract:Recursive Descent parsing is restricted to languages whose grammars are LL(1), i.e., which can be parsed top-down with a single lookahead symbol. Unfortunately, many languages such as Java, C++, or C# are not LL(1). Therefore Recursive Descent parsing cannot be used or the parser has to make its decisions based on semantic information or a multi-symbol lookahead.
-
CC - A Generator for Production Quality Compilers
Lecture Notes in Computer Science, 1991Co-Authors: Hanspeter MossenbockAbstract:This paper presents a compiler description language and its implementation Coco/R (Compiler Compiler for Recursive Descent). Coco/R reads an attributed EBNF grammar of a language and translates it into a Recursive Descent parser and a scanner for that language. The programmer has to supply a main program that calls the parser and semantic modules that are called from within the parser. Coco/R evolved from two predecessors: the scanner generator Alex [Moss86] and the parser generator Coco [ReMo89]. Their input languages were merged and simplified due to our experiences with these tools over several years (a similar tool with a slightly different motivation also emerged from Alex and Coco [DoPi90]). Using Coco/R, compilers can be generated that are as efficient as hand-coded and carefully optimized production quality compilers. Almost as important as efficiency is the simplicity and adequacy of the system. Programmers are not willing to use a tool if it does not come in handy to their work, if it uses an arcane notation or a bulk of options and special cases. Coco/R puts simplicity and efficiency over power. Proceedings of the 3rd International Workshop on Compiler Compilers; Lecture Notes in Computer Science 477, Springer Verlag 1990, pp 42-55
Elizabeth Scott - One of the best experts on this subject based on the ideXlab platform.
-
GLL parse-tree generation
Science of Computer Programming, 2013Co-Authors: Elizabeth Scott, Adrian JohnstoneAbstract: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.
-
GLL Parsing
Electronic Notes in Theoretical Computer Science, 2010Co-Authors: Elizabeth Scott, Adrian JohnstoneAbstract: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.
-
rdp—an iterator-based Recursive Descent parser generator with tree promotion operators
Sigplan Notices, 1998Co-Authors: Adrian Johnstone, Elizabeth ScottAbstract:rdp is a parser generator which accepts Iterator Backus Naur Form productions decorated with attributes and ANSI-C actions and produces Recursive Descent parsers. It has special support for the generation of tree-based intermediate forms, built-in symbol table handling for the implementation of context-sensitive components of the language syntax and a support library that includes a generalised graph handling module that can output graphs in a form suitable for use with well known visualisation tools.
-
rdp an iterator based Recursive Descent parser generator with tree promotion operators
Sigplan Notices, 1998Co-Authors: Adrian Johnstone, Elizabeth ScottAbstract:rdp is a parser generator which accepts Iterator Backus Naur Form productions decorated with attributes and ANSI-C actions and produces Recursive Descent parsers. It has special support for the generation of tree-based intermediate forms, built-in symbol table handling for the implementation of context-sensitive components of the language syntax and a support library that includes a generalised graph handling module that can output graphs in a form suitable for use with well known visualisation tools.
-
CC - Generalised Recursive Descent parsing and Fellow-Determinism
Lecture Notes in Computer Science, 1998Co-Authors: Adrian Johnstone, Elizabeth ScottAbstract:This paper presents a construct for mapping arbitrary non-left Recursive context-free grammars into Recursive Descent parsers that: handle ambiguous grammars correctly; perform with LL(1) efficiency on LL(1) grammars; allow straightforward implementation of both inherited and synthesized attributes; and allow semantic actions to be added at any point in the grammar. We describe both the basic algorithm and a tool, GRDP, which generates parsers which use this technique. Modifications of the basic algorithm to improve efficiency lead to a discussion of follow-determinism, a fundamental property that gives insights into the behaviour of both LL and LR parsers.
Dave Clarke - One of the best experts on this subject based on the ideXlab platform.
-
from type checking by Recursive Descent to type checking with an abstract machine
Language Descriptions Tools and Applications, 2011Co-Authors: Ilya Sergey, Dave ClarkeAbstract:Modern type systems for programming languages usually incorporate additional information useful for program analysis, e.g., effects, control flow, non-interference, strictness etc. When designing a typing predicate for such systems, a form of logical derivation rules is normally taken. Despite the expressivity of this approach, the straightforward implementation of an appropriate type checker is usually inefficient in terms of stack consumption and further optimisations. This leads to a significant gap between an analysis and program implementing the analysis. In this paper we demonstrate an application of techniques investigated by Danvy et al. to derive an abstract machine for typing from the traditional Recursive Descent approach. All used techniques are off-the-shelf and no appropriate correspondence theorems between an initial type system and the derived abstract machine needs to be proven: they are instead corollaries of the correctness of inter-derivation and of the initial specification. Whereas a Recursive Descent is something straightforward to implement based on declarative typing rules, the derived abstract machine exposes behaviour similar to Landin's SECD machine and gives a solid basis for further optimizations using abstract interpretation.
-
LDTA - From type checking by Recursive Descent to type checking with an abstract machine
Proceedings of the Eleventh Workshop on Language Descriptions Tools and Applications - LDTA '11, 2011Co-Authors: Ilya Sergey, Dave ClarkeAbstract:Modern type systems for programming languages usually incorporate additional information useful for program analysis, e.g., effects, control flow, non-interference, strictness etc. When designing a typing predicate for such systems, a form of logical derivation rules is normally taken. Despite the expressivity of this approach, the straightforward implementation of an appropriate type checker is usually inefficient in terms of stack consumption and further optimisations. This leads to a significant gap between an analysis and program implementing the analysis. In this paper we demonstrate an application of techniques investigated by Danvy et al. to derive an abstract machine for typing from the traditional Recursive Descent approach. All used techniques are off-the-shelf and no appropriate correspondence theorems between an initial type system and the derived abstract machine needs to be proven: they are instead corollaries of the correctness of inter-derivation and of the initial specification. Whereas a Recursive Descent is something straightforward to implement based on declarative typing rules, the derived abstract machine exposes behaviour similar to Landin's SECD machine and gives a solid basis for further optimizations using abstract interpretation.
Adrian Johnstone - One of the best experts on this subject based on the ideXlab platform.
-
GLL parse-tree generation
Science of Computer Programming, 2013Co-Authors: Elizabeth Scott, Adrian JohnstoneAbstract: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.
-
GLL Parsing
Electronic Notes in Theoretical Computer Science, 2010Co-Authors: Elizabeth Scott, Adrian JohnstoneAbstract: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.
-
rdp—an iterator-based Recursive Descent parser generator with tree promotion operators
Sigplan Notices, 1998Co-Authors: Adrian Johnstone, Elizabeth ScottAbstract:rdp is a parser generator which accepts Iterator Backus Naur Form productions decorated with attributes and ANSI-C actions and produces Recursive Descent parsers. It has special support for the generation of tree-based intermediate forms, built-in symbol table handling for the implementation of context-sensitive components of the language syntax and a support library that includes a generalised graph handling module that can output graphs in a form suitable for use with well known visualisation tools.
-
rdp an iterator based Recursive Descent parser generator with tree promotion operators
Sigplan Notices, 1998Co-Authors: Adrian Johnstone, Elizabeth ScottAbstract:rdp is a parser generator which accepts Iterator Backus Naur Form productions decorated with attributes and ANSI-C actions and produces Recursive Descent parsers. It has special support for the generation of tree-based intermediate forms, built-in symbol table handling for the implementation of context-sensitive components of the language syntax and a support library that includes a generalised graph handling module that can output graphs in a form suitable for use with well known visualisation tools.
-
CC - Generalised Recursive Descent parsing and Fellow-Determinism
Lecture Notes in Computer Science, 1998Co-Authors: Adrian Johnstone, Elizabeth ScottAbstract:This paper presents a construct for mapping arbitrary non-left Recursive context-free grammars into Recursive Descent parsers that: handle ambiguous grammars correctly; perform with LL(1) efficiency on LL(1) grammars; allow straightforward implementation of both inherited and synthesized attributes; and allow semantic actions to be added at any point in the grammar. We describe both the basic algorithm and a tool, GRDP, which generates parsers which use this technique. Modifications of the basic algorithm to improve efficiency lead to a discussion of follow-determinism, a fundamental property that gives insights into the behaviour of both LL and LR parsers.
Ilya Sergey - One of the best experts on this subject based on the ideXlab platform.
-
from type checking by Recursive Descent to type checking with an abstract machine
Language Descriptions Tools and Applications, 2011Co-Authors: Ilya Sergey, Dave ClarkeAbstract:Modern type systems for programming languages usually incorporate additional information useful for program analysis, e.g., effects, control flow, non-interference, strictness etc. When designing a typing predicate for such systems, a form of logical derivation rules is normally taken. Despite the expressivity of this approach, the straightforward implementation of an appropriate type checker is usually inefficient in terms of stack consumption and further optimisations. This leads to a significant gap between an analysis and program implementing the analysis. In this paper we demonstrate an application of techniques investigated by Danvy et al. to derive an abstract machine for typing from the traditional Recursive Descent approach. All used techniques are off-the-shelf and no appropriate correspondence theorems between an initial type system and the derived abstract machine needs to be proven: they are instead corollaries of the correctness of inter-derivation and of the initial specification. Whereas a Recursive Descent is something straightforward to implement based on declarative typing rules, the derived abstract machine exposes behaviour similar to Landin's SECD machine and gives a solid basis for further optimizations using abstract interpretation.
-
LDTA - From type checking by Recursive Descent to type checking with an abstract machine
Proceedings of the Eleventh Workshop on Language Descriptions Tools and Applications - LDTA '11, 2011Co-Authors: Ilya Sergey, Dave ClarkeAbstract:Modern type systems for programming languages usually incorporate additional information useful for program analysis, e.g., effects, control flow, non-interference, strictness etc. When designing a typing predicate for such systems, a form of logical derivation rules is normally taken. Despite the expressivity of this approach, the straightforward implementation of an appropriate type checker is usually inefficient in terms of stack consumption and further optimisations. This leads to a significant gap between an analysis and program implementing the analysis. In this paper we demonstrate an application of techniques investigated by Danvy et al. to derive an abstract machine for typing from the traditional Recursive Descent approach. All used techniques are off-the-shelf and no appropriate correspondence theorems between an initial type system and the derived abstract machine needs to be proven: they are instead corollaries of the correctness of inter-derivation and of the initial specification. Whereas a Recursive Descent is something straightforward to implement based on declarative typing rules, the derived abstract machine exposes behaviour similar to Landin's SECD machine and gives a solid basis for further optimizations using abstract interpretation.