Abstract not found

The thesis describes novel techniques and algorithms for the practical parsing of realistic Natural Language (NL) texts with a wide-coverage unification-based grammar of English. The thesis tackles two of the major problems in this area: firstly, the fact that parsing realistic inputs with such grammars can be computationally very expensive, and secondly, the observation that many analyses are often assigned to an input, only one of which usually forms the basis of the correct interpretation. The thesis starts by presenting a new unification algorithm, justifies why it is well-suited to practical NL parsing, and describes a bottom-up active chart parser which employs this unification algorithm together with several other novel processing and optimisation techniques. Empirical results demonstrate that an implementation of this parser has significantly better practical

Partial evaluation can turn a generalparser into a parser generator. The generated parsers surpass those produced by traditional parser generators in speed and compactness. We use an inherently functional approach to implement general LR(k) parsers and specialize them using the partial evaluator Similix. The functional implementation of LR parsing allows for concise implementation of the algorithmsthemselves and requires only straightforwardchanges to achieve good specialization results. In contrast, a traditional, stack-based implementation of a general LR parser requires significant structural changes to make it amenable to satisfactory specialization. 1 Introduction We present two inherently functional implementations of general LR(k) parsers: a direct-style first-order textbook version and one using continuation-passing style (CPS) for statetransitions. Neither requires the handling of an explicit parsing stack. These parsers, when specialized with respect to a grammar and lookah...

As mobile and embedded devices become widespread, the management and configuration of the software in the devices is increasingly turning into a critical issue. OSGi is a business standard for the life cycle management of Java software components. It is based on a service oriented architecture where functional units are decoupled and components can be managed independently of each other. However, the focus continuously shifts from the originally intended area of small and embedded devices towards large-scaled enterprise systems. As a result, implementations of the OSGi framework are increasingly becoming more heavyweight and less suitable for smaller computing devices. In this paper, we describe the experience gathered during the design of Concierge, an implementation of the OSGi specification tailored to resource-constrained devices. Comprehensive benchmarks show that Concierge performs better than existing implementations and consumes less resources.

Current methodology for compiler construction evolved from the need to release programmers form the burden of writing machine-language programs. This methodology does not assume a formal concept of a programming language and is not based on mathematical algorithms that model the behavior of a compiler. The side effect is that compiler implementation is a difficult task and the correctness of a compiler usually is not proven mathematically. Moreover, a compiler may be based on assumptions about its source and target languages that are not necessarily acceptable for another compiler that has the same source and target languages. The consequence is that programs are not portable between platforms of machines and between generations of languages. In addition, while a conventional compiler freezes the notation that programmers can use to develop their programs the problem domain evolves and requires extensions that are not supported by the compiler. These problems are addressed by two direc...

The paper has three aims. Its primary focus is a derivation method which is --- in contrast to many of the classical presentations in the literature --- easy to comprehend and thus easy to adapt to different needs. Secondly, it presents an improved LR parser which has the power of LR parsing, but (almost) the efficiency of LALR parsing. Finally, it elucidates the strong conceptual relationships that actually exist between LL and LR parsing. It is also briefly shown that the flexibility and easy adaptability of our techniques open up the possibility for new applications. As an example, we outline how type-based overload resolution (and thus type analysis) for arbitrary mixfix operators can be implemented in the framework of a polymorphic functional language. Contents 1 Introduction 3 2 Basic Concepts: Grammars and Transformations 6 2.1 Grammars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.2 Parse Trees and Postfix Notation . . . . . . . . . . ....

this paper appeared in Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation, 1995 under the title "The Essence of LR Parsing." Authors' addresses: Michael Sperber, Wilhelm-Schickard-Institut fur Informatik, Universitat Tubingen, Sand 13, D72076 Tubingen, Germany, sperber@informatik.uni-tuebingen.de.

Implementation of a new compiler usually requires making frequent adjustments to grammar de#nitions. An incremental technique for updating the parser tables after a minor change to the grammar could potentially savemuch computational e#ort. More importantly, debugging a grammar is made easier if the grammar is re-checked for correctness after each small change to the grammar. The basic design philosophy of an incremental parser generator, and incremental algorithms for LR#0#, SLR#1# and LALR#1# parser generation are discussed in this paper. Some of these algorithms have been incorporated into an implementation of an incremental LALR#1# parser generator.

Abstract not found

This paper addresses the longstanding problem of the recognition limitations of classical LALR(1) parser generators by proposing the usage of noncanonical parsers. To this end, we present a definition of noncanonical LALR(1) parsers, NLALR(1). The class of grammars accepted by NLALR(1) parsers is a proper superclass of the NSLR(1) and LALR(1) grammar classes. Among the recognized languages are some nondeterministic languages. The proposed parsers retain many of the qualities of canonical LALR(1) parsers: they are deterministic, easy to construct, and run in linear time. We argue that they could provide the basis for a range of powerful noncanonical parsers.