. This paper addresses efficient parsing in the context of logical inference for the purpose of using logic programming languages in compiler writing. A bottom-up, deterministic parsing mechanism is formulated for "bounded right context" grammars, a subclass of LR(k) grammars with characteristics amenable to declarative parser specification. A working parser generator for a logic programming language is described. 1 Introduction The overall aim of this paper is to use logic programming as a practical instrument for compiler writing and other activities concerning programming languages and systems. Many declarative methods in logic programming (e.g., higher order abstract syntax) have been developed for the representation and analysis of programming language constructs. However, logic programming is still not as widely used as conventional languages in compiler writing. One reason for this has been the lack of general and efficient parsing schemes. Parsing in Prolog has traditio...

ure logic spatial properties can be expressed by the use of abstract example pictures. Thus referring to picture logic as a visual logic addresses both aspects at once: the logic is used to reason about visual structures and in turn is a visual language itself. Most picture specification languages developed so far are derived from standard grammar formalisms that stem from the realm of classical compiler construction techniques [CC90, Pf92]. Usually these are of limited expressiveness and cannot be used to analyse certain types of picture properties. The poster will give examples for such problems like non-tree like picture structures, etc. and how they can be specified with picture logic. There are some other approaches to logic specification tools for pictures [HM90] as well as to relational languages for picture specification [FPT+91] that are structurally very close to logic languages. Their common approach is to express spatial relations of objects by formulae like or in a relat

We describe a modular compiler architecture that has been developed for a functional data model DBMS. The architecture allows compilers for new sub-languages to be constructed rapidly, by reusing the components of the existing compiler, and allows new semantics and code generation strategies to be defined for existing language constructs. This point is demonstrated by the construction of a new compiler for an integrity constraint language, which required only two new modules to be added to the system. The most significant advantage of our architecture, however, is that it allows the DBMS itself to use the individual compiler modules, opening up a host of possibilities for run-time manipulation of application code.

Parsing has been a traditional workbench for showing the virtues of declarative programming. Both logic and functional programming claim the ability of writing parsers in a natural and concise way. We address here the task from a functional-logic perspective. By modelling parsers as non-deterministic functions we achieve a very natural manner of building parsers, which combines the nicest properties of the functional and logic approaches. In particular, we are able to easily define within our framework parsers in a style very close to the `monadic parsers' of functional programming, but without any syntactic overhead. In a different direction we show that, if the functional-logic setting permits higher-order patterns while defining functions, parsers can be freely manipulated as data. This allows programming useful metalevel analysis or transformations, like discovering if the grammar corresponding to a given parser is LL(1). Finally, we sketch the potential application to parsing of f...

An abstract representation for grammar rules that permits an easy implementation of several attributed grammar transformations is presented. It clearly separates the actions that contribute to evaluating attribute values from the circulation of these values, and it makes it easy to combine the representations of several rules in order to build the representation of new rules. This abstract form applies well to such transforms as elimination of left-recursion, elimination of empty derivation, unfolding and factorization. Finally, the technique is applied to DCGs and a Prolog implementation of the abstract form and of the transforms is described. 1 Introduction Text-books (e.g., the Dragon book [1], and others [2, 3]) are rich and precise when dealing with the manipulations (analysis, transformation) of pure Context-Free Grammars (CFGs). They also present parsing techniques for Attributed CFGs (ACFGs), and specialized analysis for ACFGs like the detection of circular dependencies. How...

We show that logic programming offers useful methods and techniques to software engineers. Several research and industrial projects have either successfully applied logic programming languages during the software development lifecycle, or have developed useful software engineering tools exploiting some feature of logic programming. We overview the main software specification and design techniques based on Prolog or on more advanced logic languages. We also survey a number of software development tools based on logic programming. These tools range from constraint-based structure editors, symbolic debuggers, and (de)compilers, to configuration tools, project databases, and planners for knowledge-based programming-in-the-large, to rule-based notations and processcentered environments for coordinating and enacting the software development process. Index Terms: Software Engineering, Formal Methods, Specification, Design, Testing, Logic Programming, Software Prototyping, Maintenanc...

We describe in this paper an original solution for structured document analysis. The idea is to use a grammar to guide the segmentation of the graphical objects and their recognition. The grammar is essentially a description of the relations (relative position and size, adjacency, etc) between the graphical objects.

This paper discusses a sequence of deductive parsers, called PAD1 - PADS, that utilize an axiomatization of the principles and parameters of GB theory, including a restricted transformational component (Move-). PAD2 uses an inference control strategy based on the 'freeze' predicate of Prolog-H, while PAD3 - 5 utilize the Unfold-Fold transformation to transform the original axiomatization into a form that functions as a recursive descent Prolog parser for the fragment.

Program query languages are an essential component of program analysis and manipulation systems. In each such system, a query identifies the source-code parts of interest by reasoning over a program representation that is dedicated to the intent of the system (e.g. call-graphs to detect behavioral flaws, abstract syntax trees for refactorings, concrete source code to verify programming conventions, etc.). In order to detect a wide variety of such “patterns of interest”, or more importantly, to detect patterns that require a combination of such program representations, developers must understand all the different applicable representations and techniques. We therefore present a logicbased language that allows the program’s implementation to be queried using concrete source code templates that are matched against a combination of structural and behavioral program representations. These representations include call-graphs, points-to analysis results and abstract syntax trees that are uniformly composed through a customizable unification procedure. The result of our approach is that developers can detect patterns in the queried program using source code excerpts (embedded in logic queries) which act as prototypical samples of the structure and behavior they intend to match.

Abstract not found