Attribute evaluation methods

Alblas, Henk

doi:10.1007/3-540-54572-7_3

Cited by 18 publications

(6 citation statements)

References 30 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Canonical attribute grammars were implemented by statically computing a schedule (or plan) consisting of multiple passes over the AST, ordered such that the input values of the attribute computations in one pass are computed in a previous pass (see Alblas [1991] for a survey). Expressivity of canonical attribute grammars is limited by this stratified evaluation.…”

Section: On-demand Evaluation Of Canonical Attribute Grammarsmentioning

confidence: 99%

Knowing when to ask: sound scheduling of name resolution in type checkers derived from declarative specifications

Rouvoet

Antwerpen

Poulsen

et al. 2020

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

There is a large gap between the specification of type systems and the implementation of their type checkers, which impedes reasoning about the soundness of the type checker with respect to the specification. A vision to close this gap is to automatically obtain type checkers from declarative programming language specifications. This moves the burden of proving correctness from a case-by-case basis for concrete languages to a single correctness proof for the specification language. This vision is obstructed by an aspect common to all programming languages: name resolution. Naming and scoping are pervasive and complex aspects of the static semantics of programming languages. Implementations of type checkers for languages with name binding features such as modules, imports, classes, and inheritance interleave collection of binding information (i.e., declarations, scoping structure, and imports) and querying that information. This requires scheduling those two aspects in such a way that query answers are stableÐi.e., they are computed only after all relevant binding structure has been collected. Type checkers for concrete languages accomplish stability using language-specific knowledge about the type system.In this paper we give a language-independent characterization of necessary and sufficient conditions to guarantee stability of name and type queries during type checking in terms of critical edges in an incomplete scope graph. We use critical edges to give a formal small-step operational semantics to a declarative specification language for type systems, that achieves soundness by delaying queries that may depend on missing information. This yields type checkers for the specified languages that are sound by constructionÐi.e., they schedule queries so that the answers are stable, and only accept programs that are name-and type-correct according to the declarative language specification. We implement this approach, and evaluate it against specifications of a small module and record language, as well as subsets of Java and Scala.CCS Concepts: • Theory of computation → Constraint and logic programming; Operational semantics.

show abstract

Section: On-demand Evaluation Of Canonical Attribute Grammarsmentioning

confidence: 99%

Knowing when to ask: sound scheduling of name resolution in type checkers derived from declarative specifications

Rouvoet

Antwerpen

Poulsen

et al. 2020

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…Some of these classes can be evaluated in a single pass over the parse tree, with a single visit of each node [10,11,15]. More general classes of attribute grammars require multiple passes, and algorithms have been proposed for finding evaluation orders that minimize the number of passes [1,22]. These techniques have been extended to evaluation of attributes of multiple tree nodes in parallel [9].…”

Section: Sound Fusion In Tree Traversal Languagesmentioning

confidence: 99%

Miniphases: compilation using modular and efficient tree transformations

Petrashko

Lhoták

Odersky

2017

Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

Production compilers commonly perform dozens of transformations on an intermediate representation. Running those transformations in separate passes harms performance. One approach to recover performance is to combine transformations by hand in order to reduce number of passes. Such an approach harms modularity, and thus makes it hard to maintain and evolve a compiler over the long term, and makes reasoning about performance harder. This paper describes a methodology that allows a compiler writer to define multiple transformations separately, but fuse them into a single traversal of the intermediate representation when the compiler runs. This approach has been implemented in the Dotty compiler for the Scala language. Our performance evaluation indicates that this approach reduces the running time of tree transformations by 35% and shows that this is due to improved cache friendliness. At the same time, the approach improves total memory consumption by reducing the object tenuring rate by 50%. This approach enables compiler writers to write transformations that are both modular and fast at the same time.

show abstract

“…LOAGs have been a popular subject in AG literature, although defined slightly differently in several instances [1,7,13,15]. The subclass OAG, for which Kastens' algorithm can generate evaluators in polynomial runtime, has been more popular in practical implementations due to the complexity of generating evaluators for LOAGs.…”

Section: Linearly Ordered Attribute Grammarsmentioning

confidence: 99%

Linearly Ordered Attribute Grammars

Binsbergen

Bransen

Dijkstra

2015

Proceedings of the 2015 Workshop on Partial Evaluation and Program Manipulation

View full text Add to dashboard Cite

Attribute Grammars (AGs) extend Context-Free Grammars with attributes: information gathered on the syntax tree that adds semantics to the syntax. AGs are very well suited for describing static analyses, code-generation and other phases incorporated in a compiler. AGs are divided into classes based on the nature of the dependencies between the attributes. In this paper we examine the class of Linearly Ordered Attribute Grammars (LOAGs), for which strict, bounded size evaluators can be generated. Deciding whether an Attribute Grammar is linearly ordered is an NP-hard problem. The Ordered Attribute Grammars form a subclass of LOAG for which membership is tested in polynomial time by Kastens' algorithm (1980). On top of this algorithm we apply an augmenting dependency selection algorithm, allowing it to determine membership for the class LOAG. Although the worst-case complexity of our algorithm is exponential, the algorithm turns out to be efficient for practical full-sized AGs. As a result, we can compile the main AG of the Utrecht Haskell Compiler without the manual addition of augmenting dependencies. The reader is provided with insight in the difficulty of deciding whether an AG is linearly ordered, what optimistic choice is made by Kastens' algorithm and how augmenting dependencies can resolve these difficulties.

show abstract

Attribute evaluation methods

Cited by 18 publications

References 30 publications

Knowing when to ask: sound scheduling of name resolution in type checkers derived from declarative specifications

Knowing when to ask: sound scheduling of name resolution in type checkers derived from declarative specifications

Miniphases: compilation using modular and efficient tree transformations

Linearly Ordered Attribute Grammars

Contact Info

Product

Resources

About