Search results for keyword `Object-oriented'

[88]

E. Bjarnason and Görel Hedin. Tool support for framework-specific language extensions. In Bosch and Mitchell, editors, Object-Oriented Technology. ECOOP'97 Workshop Reader, volume 1357 of LNCS, pages 137-140. Springer Verlag, 1997.

[148]

M.-L. Christ-Neumann and H.-W. Schmidt. ASDL---an object-oriented specification language for syntax-directed environments. In European Software Eng. Conf. (ESEC '87), pages 77-85. Strasbourg, September 1987.

[272]

L. Fegaras, D. Maier, and T. Sheard. Specifying rule-based query optimizers in a reflective framework. In Third International Conference on Deductive and Object-Oriented Databases, pages 146-168, Phoenix, Arizona, December 1993.

Numerous structures for database query optimizers have been proposed. Many of those proposals aimed at automating the construction of query optimizers from some kind of specification of optimizer behavior. These specification frameworks do a good job of partitioning and modularizing the kinds of information needed to generate a query optimizer. Most of them represent at least part of this information in a rule-like form. Nevertheless, large portions of these specifications still take a procedural form. The contributions of this work are threefold. We present a language for specifying optimizers that captures a larger portion of the necessary information in a declarative manner. This language is in turn based on a model of query rewriting where query expressions carry annotations that are propagated during query transformation and planning. This framework is reminiscent of inherited and synthesized attributes for attribute grammars, and we believe it is expressive of a wide range of information: logical and physical properties, both desired and delivered, cost estimates, optimization contexts, and control strategies. Finally, we present a mechanism for processing optimizer specifications that is based on compile-time reflection. This mechanism proves to be succinct and flexible, allowing modifications of the specification syntax, incorporation of new capabilities into generated optimizers, and retargeting the translation to a variety of optimization frameworks. We report on an implementation of our ideas using the CRML reflective functional language and on optimizer specifications we have written for several query algebras

[353]

Katsuhiko Gondow and Takuya Katayama. On formalization of object oriented attribute grammars OOAG and higher order attribute grammars using record calculus. Technical Report 95TR-0020, Tokyo Institute of Technology, 1995.

The purpose of this paper is twofold. First we present a denotational semantics of attribute grammars(AGs) by using Cardelli's record calculus. The denotational semantics is simple and natural. In our semantics, an attributed tree is represented by nested records to preserve the structural information of the attributed tree, while in traditional denotational semantics AGs are formalized by either valuation mapping from attributes (often in the root) to their values or mapping from inherited attributes to synthesized attributes in the root. It is a positive characteristic of our semantics to deal with attributed tree as AG's semantics rather than attribute valuation. For the purpose of describing structure-oriented software development environments, many computational models based on AGs have already been proposed. These computational models are usually extended so as to deal with tree transformation. We believe that our semantics can be a good formal basis to define these computational models. To show this, we formalize OOAG(Object-Oriented AGs) and higher order AGs(HAGs) by extending our denotational semantics of AGs. This is the second purpose of this paper. Both of them are computational models to deal with tree transformation depending upon attribute values. As the result of these formalizations, we can formally discuss the differences between OOAG and HAGs. For example, we show that tree transformation in OOAG is modeled as a function to determine the next state, while that in HAGs is just a static tree construction. This paper is the revised English version of "Attribute Grammars as Record Calculus" (Technical Report No.93TR-0047), which is written in Japanese.

[366]

Josef Grosch. Multiple inheritance in object-oriented attribute grammars. Technical Report 28, GMD, Karlsruhe University, 1992.

[381]

G. Hedin. An object-oriented notation for attribute grammars. In the 3rd European Conference on Object-Oriented Programming (ECOOP'89), BCS Workshop Series, pages 329-345, Nottingham, U.K., July 1989. Cambridge University Press. Also published in LU-CS-TR:89-42.

This paper presents an attribute grammar notation which is based on the object-oriented concepts of classification hierarchies, inheritance, and late binding. The notation allows compact and flexible language specification through the use of inheritance and equation overriding. Furthermore, demand attributes can be implemented efficiently by using a technique similar to the one used for virtual procedures in Simula. Such attributes are important especially in incremental langauge-based environments as they do not consume storage. The notation also makes it possible to define general attributes which can be accessed without knowledge of the particular langauge modelled by the grammar. This can be utilized for integration of grammar independent tools. The notation is based on a single-inheritance classification, and a discussion is given on the problems which would arise if the notation was augmented to multiple-inheritance.

[382]

Görel Hedin. Incremental static-semantics analysis for object-oriented languages using door attribute grammars. In Henk Alblas and Borivoj Melichar, editors, Attribute Grammars, Applications and Systems, volume 545 of Lecture Notes in Computer Science, pages 374-379. Springer-Verlag, New York-Heidelberg-Berlin, June 1991. Prague.

[492]

G. E. Kaiser and D. Garlan. MELD: A declarative language for writing methods. Technical report, Carnegie-Mellon University, SEI, Pittsburgh, PA, June 1986.

Object-oriented programs are written as collections of messages. When an object receives a message, the system attempts to find a method with the same name as given in the message. The system queries the class that defines the object. If the class provides a corresponding method, the method is performed. The method may return a value to the sender of the message. It may have side-effects on the local memory of the object. The method may send messages to additional objects as part of it computation. This notion of encapsulating operations, in the form of methods, within the definition of an object is common to essentially all object-oriented programming languages. Messages and methods are currently written in what is fundamentally a procedural style. A messagge is a procedure call with several parameters, where one parameter is distinguished as the object to which the message is sent. A method is a procedure: it may return a value, have side-effects, and invoke other procedures by sending messages. We believe that the object-oriented framework lends itself quite easily to the description of programs in a declarative language. In this paper, we propose a declarative language for writing messages and methods. Our notation retains all the important features of object-oriented programming, but adds a higher level of abstraction to the description of object behavior. Our language, called MELD, is an extension of attribute grammars. Its implementation takes advantage of algorithms developed for incremental attribute grammar evaluation in the context of language-based programming environments.

[558]

Kai Koskimies and Jukka Paakki. TOOLS: a unifying approach to object-oriented language interpretation. In ACM SIGPLAN '87 Symp. on Interpreters and Interpretetive Techniques, pages 153-164. ACM press, St. Paul, MN, June 1987. Published as ACM SIGPLAN Notices, volume 22, number 7.

[569]

Kai Koskimies. Object-oriented language processing with HLP84. report C-1986-3, Department of Comp. Sc., University of Helsinki, 1986.

Language processor generators are systems that produce various language processors (including compilers) on the basis of a high-level specification. The design of language processor generators is discussed on the basis of experiments with a traditional compiler writing system (HLP78) employing pure LALR parsing and general attribute grammars. It is argued that these methods are too primitive from the practical point of view: the concepts of the specification language should be on a higher abstraction level. The design of a new language processor generator, HLP84, is based on this view. This system is an attempt to provide high-level tools for a restricted class of applications (one-pass analysis). The syntactic facilities include regular expressions on the right-hand sides of productions, a disambiguating mechanism that is integrated with regular expressions, and a mechanism for using semantic information to aid parsing; the semantic facilities include e.g. a built-in database for storing the descriptors of program entities and a simple mechanism for semantic error handling. Early experiences with the new system show that in spite of the general overhead caused by the higher automation level, the system allows the generation of reasonably efficient processors.

[616]

Theodore W. Leung. Compiling object-oriented queries. Technical Report CS-94-05, Department of Computer Science, Brown University, February 1994.

The effectiveness of database query optimization is dependent on the optimizer's ability to make efficient use of physical resources in a computer system. The optimizer decides how to use those resources in the plan generation step. We describe an approach to plan generation where physical level rewriting produces performance increases which cannot be obtained via source level transformations. Example optimizations serve as a demonstration of a new rule language based on list and tree pattern matching. A formalism similar to attribute grammars computes information needed by the plan generator. Many of the techniques presented are reminiscent of compiler optimizations. We conclude by describing the work that will be completed in the thesis.

[628]

Tan. Lichao, Y. Shinoda, and T. Katayama. Coping with Changes in an Object Management System based on Attribute Grammars. In Proceedings of the Fourth ACM SIGSOFT '90 Symposium on Software Development Environments, pages 56-65, December 1990. Published as SIGSOFT Software Engineering Notes, volume 15, number 6.

Methods of dealing with change in an object management system OS/0 are discussed. OS/0 is a prototype of an attribute grammar based object management model, called object-oriented attribute grammars (OOAG) by Y. Shinoda et al. (1990). OOAG is a hybrid model that combines features of functional and object-oriented paradigms. Various aspects of software object databases can be described using its capabilities. Software objects in OOAG are managed as autonomous, hierarchical trees containing attributes. The OOAG is also capable of describing software processes as hierarchies of software objects, with data driven process enaction mechanism. Many aspects of changes to such a tree, including the evolution of the tree type definition, or the dynamic transformation of its internal structure can be dealt with easily by the benefits of a combined attribute grammars based and object oriented paradigm. The authors also introduce a mechanism that helps to provide an efficient way for manipulating changed objects. The mechanism is characterized by meta-objects that are used to control the evaluation of the changes. Meta-objects prove to be a suitable mechanism for handling change management tasks in evolving object environments.

[690]

Nikolaj Korbar Marjan Mernik and Vijem Zumer. Object-oriented evaluation paradigm in attribute grammar-based. Computing and Information, 2(1), June 1996.

[744]

Tetsuya Nitta. Construction of compiler generator based on the attribute grammar and object-oriented language. Master's thesis, Watanabe Laboratory, 1995.

Present compiler generators have several problems. First, there are many restrictions in describing the specifications of compilers. Secondly, compilers generated by present compiler generators are hard to read. In this paper, we propose a compiler generator based on the attribute grammar and an object-oriented language. Compilers generated by the proposed method have the following properties: (1) a syntactic tree is constructed before evaluating attributes, (2) a top-down parsing without backtracking and left-recursion is used. By these properties, the class of attribute grammars acceptable by the compiler generator is larger than that of L-attribute grammars, and the readability of the generated compilers is better than that of compilers generated by other generators.

[935]

Yoichi Shinoda and Takuya Katayama. Object-oriented extension of attribute grammars and its implementation using distributed attribute evaluation algorithm. In Pierre Deransart and Martin Jourdan, editors, Attribute Grammars and their Applications (WAGA), volume 461 of Lecture Notes in Computer Science, pages 177-191. Springer-Verlag, New York-Heidelberg-Berlin, September 1990. Paris.

[978]

L Thomas and S. Cruz-lara. A concurrent object-oriented paradigm for attribute grammars. Technical report, Centre de recherche en Informatique de Mancy, 1990.

[979]

L. Thomas and S. Cruz-Lara. A concurrent object-oriented paradigm for attribute grammars. In Plenum Publishing Corporation 1992 COMPUTER SCIENCE : Research and Applications, 1992.