The theory of cut-free sequent proofs has been used to motivate and justify the design of a number of logic programming languages. Two such languages, λProlog and its linear logic refinement, Lolli [15], provide for various forms of abstraction (modules, abstract data types, and higher-order programming) but lack primitives for concurrency. The logic programming language, LO (Linear Objects) [2] provides some primitives for concurrency but lacks abstraction mechanisms. In this paper we present Forum, a logic programming presentation of all of linear logic that modularly extends λProlog, Lolli, and LO. Forum, therefore, allows specifications to incorporate both abstractions and concurrency. To illustrate the new expressive strengths of Forum, we specify in it a sequent calculus proof system and the operational semantics of a programming language that incorporates references and concurrency. We also show that the meta theory of linear logic can be used to prove properties of the objectlanguages specified in Forum.

The theory of cut-free sequent proofs has been used to motivate and justify the design of a number of logic programming languages. Two such languages, λProlog and its linear logic refinement, Lolli [12], provide data types, higher-order programming) but lack primitives for concurrency. The logic programming language, LO (Linear Objects) [2] provides for concurrency but lacks abstraction mechanisms. In this paper we present Forum, a logic programming presentation of all of linear logic that modularly extends the languages λProlog, Lolli, and LO. Forum, therefore, allows specifications to incorporate both abstractions and concurrency. As a meta-language, Forum greatly extends the expressiveness of these other logic programming languages. To illustrate its expressive strength, we specify in Forum a sequent calculus proof system and the operational semantics of a functional programming language that incorporates such nonfunctional features as counters and references. 1

. The WAM allows within its framework many variations e.g. regarding the term representation, the instruction set and the memory organization. Consequently several Prolog systems have implemented successful variants of the WAM. While these variants are eective within their own context, it is dicult to assess the merit of their particular variation. In this work, four term representations that were used by at least one successful system are compared empirically within dProlog, one basic implementation which keeps all other things equal. We also report on dierent implementation choices in the dProlog emulator itself. dProlog is reasonably ecient, so it makes sense to use it for these experiments. 1

We describe a new language translation framework (partial translation) and the implementation of one of its instances: the C-$cation of Binary Prolog. Partial C-ification is a translation framework which com-piles sequences of emulator instructions down to native code (on top of a C compiler). In the case of logic programming languages, their complex control structure, some large in-structions, and the management of the symbol table are left to the emulator while the native code chunks will deal with relatively long sequences of simple instructions. The technique can be seen as an automatic specialization with respect to a given program of the traditional instruction folding techniques used to speed-up emulators. When the target language of the host compiler is the same as the implementation language of the emulator (say C), the emulator, the representation of the byte code as a C data structure, some other C-ified library routines and hand-written C-code can all be compiled and linked together to a form a stand-alone application. We give full details and performance analysis of the C-ification of a continuation passing Binary ProIog engine for which large write-mode sequences and the absence of a call-return mechanism make the framework particularly well suited. The framework is shown as practical and easy to implement and it compares favorably with instruction folding tech-niques used traditionally to speedup emulators.

We describe a new language translation framework (partial translation) and the application of one of its instances: the C-ification of Binary Prolog. Our partial translation framework compiles selected sequences of emulator instructions down to native code. The technique can be seen as an automatic specialization with respect to a given program of the traditional instruction folding techniques used to speed-up emulators. In our implementation, the complex control structure, some large instructions and the management of the symbol table are left to the emulator while the translated code deals with relatively long sequences of simple instructions. After compilation, the generated code is linked with a target language representation of the emulator's byte-code and the emulator itself to form a stand-alone application. The composite runtime system's behavior can be seen as a form of `coroutining' between emulated and native code. The framework supports modular compilation, allows programm...

4.1.1). Please send comments and bug reports to binprolog@info.umoncton.ca. 3 Introduction to BinProlog BinProlog has been developped by Paul Tarau mostly at the University of Moncton, Canada, and is based on his BinWAM abstract machine, a specialization of the WAM for the efficient execution of binary logic programs. BinProlog is a fast and small Prolog compiler, based on the transformation of Prolog to binary clauses. The compilation technique is similar to the Continuation Passing Style transformation used in some ML implementations. Although it (used to) incorporate some last minute research experiments, which might look adventurous at the first sight, BinProlog is a fairly robust and complete Prolog implementation featuring both C-emulated execution and generation of standalone applications by compilation to C. Some of its features are: ffl source-level transformation based stateless module system ffl dynamic code, f

Abstract not found

. Continuation passing binarization and specialization of the WAM to binary logic programs have been proven practical implementation techniques in the BinProlog system. In this paper we investigate the additional benefits of having first order continuations at source level. We devise a convenient way to manipulate them by introducing multipleheaded clauses which give direct access to continuations at source-level. We discuss the connections with various logic grammars, give examples of typical problem solving tasks and show how looking at the future of computation can improve expressiveness and describe complex control mechanisms without leaving the framework of binary definite programs. Keywords: continuation passing binary logic programs, logic grammars, program transformation based compilation, continuations as first order objects, logic programming with continuations. 1 Introduction From its very inception, logic programming has cross-fertilized with computational linguistics in ...

Abstract not found

The WAM keeps environments on a stack. As an alternative, we explore allocating them on the heap, in the context of hProlog. The changes needed to make this work are described, as well as the modified optimizations. Benchmarking shows that this is not a totally wacky idea. We do the same for WAM choice points.