Computer Languages最新文献

We consider the NP-complete problem of generating contiguous evaluations for expression DAGs with a minimal number of registers. We present two algorithms that generate optimal contiguous evaluation for a given DAG. The first is a modification of a complete search algorithm that omits the generation of redundant evaluations. The second algorithm generates only the most promising evaluations by splitting the DAG into trees with import and export nodes and evaluating the trees with a modified labeling scheme. Experiments with randomly generated DAGs and large DAGs from real application programs confirm that the new algorithms generate optimal contiguous evaluations quite fast.

We present a system for producing retargetable code generators containing coloring-based register allocators. The compiler writer specifies the overall register characteristics of the target machine, as well as the specific register requirements of individual assembly instructions. A Code Generator Prepass processes the specific instruction requirements so that they can be considered during register allocation. We also present our notion of “generic” coloring algorithms which simplify the retargeting of register allocators to different architectures. The system is suitable for RISC and CISC architectures

This paper presents a multiparadigm language I⁺ which is an integration of the three major programming paradigms: object-oriented, logic and functional. I⁺ has an object-oriented framework in which the notions of classes, objects, methods, inheritance and message passing are supported. Methods may be specified as clauses or functions, thus the two declarative paradigms are incorporated at the method level of the object-oriented paradigm. In addition, two levels of parallelism may be exploited in I⁺ programming. Therefore I⁺ is a multiparadigm language for object-oriented declarative programming as well as parallel programming.

The Seeheim Model of human-computer interaction partitions an interactive application into a user-interface, a dialogue controller and the application itself. One of the formal techniques of implementing the dialogue controller is based on context-free grammars and automata. In this work, we modify an off-the-shelf compiler generator (YACC) to generate the dialogue controller. The dialogue controller is then integrated into the popular X-window system, to create an interactive-application generator. The actions of the user drive the automaton, which in turn controls the application.

In this paper, we look at the problem of scheduling expression trees with reusable registers on delayed load architectures. Reusable registers come into the picture when the compiler has a data-flow analyzer which is able to estimate the extent of use of the registers. Earlier work considered the same problem without allowing for register variables. Subsequently, Venugopal considered non-reusable registers in the tree. We further extend these efforts to consider a much more general form of the tree. We describe an approximate algorithm for the problem. We formally prove that the code schedule produced by this algorithm will, in the worst case, generate one interlock and use just one more register than that used by the optimal schedule. Spilling is minimized. The approximate algorithm is simple and has linear complexity.

The development of a large-scale software application naturally lends itself to a top-down development process where the problem is divided into smaller problems that are dispersed among multiple people or teams. Once these sub-problems have been solved, the software components or modules implementing these solutions are integrated into the whole for a final solution. In a component-based environment, large applications are constructed by combining software components in a variety of ways. In such an environment, the components may be implemented in different languages and be distributed across different machines. Alternately, these modules may be different parts of a program running in a single address space. These options (and the many options in between) require different techniques for integration. Software packaging is an important method for assisting in the process of assembling large programs from separate pieces, especially over a heterogeneous environment (an environment consisting of different machines, architecture, languages or operating systems). A software packager is a tool that takes a description of the modules of a program, the available connection methods, and the final desired connection geometry, and creates the integration methods to create the application.

The design of debugging tools is often ad hoc, with tools tailor-made for specific target languages and operating systems. Consequently, no unified theory of debugger design has emerged. Especially neglected is the design of languages to control debugging activities—and fundamental issues that arise in the implementation and use of such languages. We introduce GDL, a powerful low-level debugging language whose primitives capture the intuitive, informal semantics used in imperative debugging. GDL can be extended to incorporate higher-level constructs, hence we use it as our vehicle to examine central semantic issues that confront designers and implementors of debugging languages.

We gauge the efficiency of various GDL constructs on typical architectures and highlight semantic issues arising from the integration of those mechanisms. Our exploration of semantic issues is intended to provide guidance for designers of debugging languages, to ensure all high-level language features can be mapped cleanly and efficiently onto underlying architectural hooks, without endangering the semantic integrity of those high-level constructs.

A language space provides a unified framework to deal with the properties of language constructs by associating them with their specification rules. The concrete syntax is represented by segments of the language space. The semantics is given by derived operations of the algebras where these constructs are interpreted by the processing tools operating on the language space. We examine in this paper only processing tools that collect syntactic information over the language space. Tools involved in semantics processing such as translators and interpreters are also integrated in the language space but are not discussed here.

In this paper we present an O(log n) time parallel algorithm for arithmetic expression evaluation, on an n × n processor array with reconfigurable bus system, where n is the sum of the number of operators and constants in the expression. The basic technique involved here is leaves-cutting (rake operation), as in the case of PRAM model algorithms available in the literature for this problem. The input to our algorithm is assumed to be the binary tree associated with a given expression (also known as expression tree with n number of nodes). Our algorithm is faster compared to the previous best time for expression evaluation on mesh connected computers which is O(√n).

We present a method for recovering from syntax errors encountered during parsing. The method provides a form of minimum distance repair, has linear time complexity, and is completely automatic. A formal method is presented for evaluating the performance of error recovery methods, based on global minimum-distance error correction. The minimum-distance error recovery method achieves a theoretically best performance on 80% of Pascal programs in the weighted Ripley-Druseikis collection. Comparisons of performance with other error recovery methods are given.