Computer Languages最新文献

Previous work on temporal and historical databases has been mainly based on the assumption that the time intervals of temporal attributes and the start/finish points of modeled events are precisely known. In many real life situations, however, the time boundary of events and the duration of entity relationships may not be exactly known. Modeling these situations and providing a way to write queries dealing with time impreciseness represents a useful extension currently lacking in existing/proposed temporal database systems. In this paper, we discuss the problem of handling time impreciseness in temporal databases and present three models for the representation of imprecise time intervals. We illustrate the basic idea and motivation of each model, its underlying logic, tradeoffs, and important properties. We also propose query language extensions that can enrich the user interface with capabilities to formulate queries dealing with time impreciseness. Extensions to existing query constructs at both the transaction level and the operator level are presented. New operators related to time impreciseness are also presented. The models and extensions discussed in this paper enrich the flexibility of temporal databases and can be used to help users obtain more meaningful replies for their temporal queries.

We investigate a view of compiler generation which does not involve the direct specification of the source→target relationship. Here, the concentration is on the role of self-interpreters in this context, and their derivation. The method is based on a category theoretic model of language using finite limit sketches and requires the automatic derivation of a target partial evaluator and a source interpreter, expressed as a target program. We describe a technique to derive a self-interpreter as this represents a significant step towards the derivation of both partial evaluators and interpreters.

Invocation handling mechanism in many concurrent languages have significant limitations that make it difficult or costly to solve common programming situations encountered in program visualization, debugging, and scheduling scenarios. This paper discusses these limitations, introduces new language mechanisms aimed at remedying these limitations, and presents an implementation of the new mechanisms. The examples are given in SR; the new mechanisms and implementation are an extension of SR and its implementation. However, these new mechanisms are applicable to other concurrent languages. They can augment or replace current invocation handling mechanisms.

BaLinda K implements objects in a functional framework. Active objects, which permit concurrent execution and tuple exchanges between externally invoked methods and the object body within the confines of an object boundary, are shown to be a useful tool for establishing concurrency relations between parallel tasks.

Complex languages are often modularized into sublanguages and the compiler is accordingly organized as a set of separate modules. Modularization (called federalization) is beneficial for beating complexity, for maintenance, and for reuse. Focusing on syntax analysis, we consider the decomposition of a grammar into deterministic subgrammars. We study three conditions for determinism in grammar partitioning: first using homogeneous modules of the LR(1) or LL(1) kind; then using heterogeneous modules (LR(1) or LL(1)). Federalization slightly decreases the generality of LR(1) parsers, but not of LL(1) ones, and it allows to handle some grammars which are not LALR(1). Experimental results show that LR(1) federal automata have fewer (up to 60%) states than monolithic LR(1) automata. Criteria for modularization, practical experiences and hints to semantic decomposition issues conclude the paper.

In this paper we present a new language, called ParCeL-1, intended to make easier the implementation of computation-intensive and artificial intelligence applications on highly parallel MIMD architectures. The computational model of ParCeL-1 is object-oriented and synchronous, based on virtual processors called cells that compute and communicate alternately. The current prototype is implemented on several multi-processor systems (Cray T3D, Intel Paragon, Telmat T-Node, workstation networks using PVM, and SGI Power Challenge Array). Several applications written in ParCeL-1 are described, together with their performances obtained on a 256-processor Cray T3D.

Preference logic grammars (PLGs) are introduced in this paper as a concise, declarative, modular, and efficient means of resolving ambiguity in logic grammars. Preference logic grammars can be thought as extensions of definite clause grammars (DCGs) and definite-clause translation grammars (DCTGs). Just as DCGs and DCTGs can be directly translated into logic programs, PLGs can be translated into preference logic programs (PLPs), which we introduced in our earlier work. We discuss two applications of PLGs: optimal parsing, and ambiguity resolution in programming-language and natural-language grammars. Optimal parsing is an extension of parsing wherein costs are associated with the different (ambiguous) parses of a string and the preferred parse is the one with least cost. Many problems can be viewed as optimal parsing problems, e.g., code generation, document layout, etc. In the area of natural language parsing, we illustrate the use of preference clauses for resolution of prepositional phrase attachment ambiguities, and point out the growing consensus in the literature on the need to explicitly specify preference criteria for ambiguity resolution.