Search results for keyword `components'

[69]

Don Batory and Bart J. Geraci. Validating component compositions in software system generators. In International Conference on Software Reuse, Florida, 1996. (PostScript)

Generators synthesize software systems by composing components from reuse libraries. In general, not all syntactically correct compositions are semantically correct. In this paper, we present domain-independent algorithms for the GenVoca model of software generators to validate component compositions. Our work relies on attribute grammars and offers powerful debugging capabilities with explanation-based error reporting. We illustrate our approach by showing how compositions are debugged by a GenVoca generator for container data structures.

[121]

John Tang Boyland. Descriptional Composition of Compiler Components. PhD thesis, University of California, Berkeley, September 1996. Available as technical report UCB//CSD-96-916.

[214]

Gerald D. P. Dueck and Gordon V. Cormack. Modular attribute grammars. The Computer Journal, 33:164-172, 1990. See also: research report CS-88-19, University of Waterloo (May 1988).

Attribute grammars provide a formal declarative notation for describing the semantics and translation of programming languages. Describing any real programming language is a significant software engineering challenge. From a software engineering viewpoint, current notations for attribute grammars have two flaws: tedious repetition of essentially the same attribute computations is inevitable, and the various components of the description cannt be decomposed into modules -- they must be merged (and hence closely coupled) with the syntax specification. This paper describes a tool that generated attribute grammars from pattern oriented specifications. These specifications can be grouped according to the separation of concerns arising from individual aspects of the compilation process. Implementation and use of the attribute grammar generator MAGGIE is described.

[363]

Tapio Grönfors. Peak identification of auditory brainstem responses with multifilters and attributed automaton. Technical Report R-92-4, University of Turku, 1992.

An attributed automaton, a special case of attribute grammar, is a flexible tool in pattern recognition. It allows the utilization of contextual information from previously analyzed patterns in the analysis of the current pattern, and offers the possibility of describing those structural characteristics of patterns which cannot be described by classic methods of syntactic pattern recognition. Auditory brainstem responses are routinely used in audiology and otoneurology. Many studies on using the spectral analysis of averaged auditory brainstem responses have described at least two frequency bands, corresponding to the slow fast components. Selective nonrecursive digital filters for each frequency band in the spectrum of the auditory brainstem response have revealed enhancement or attenuation of components, depending on the band. In this study, multifilters and an attributed automaton were combined for the identification peaks.

[494]

Gail E. Kaiser and Simon M. Kaplan. Parallel and distributed incremental attribute evaluation algorithms for multi-user software development environments. In ACM Transactions on Software Engineering and Methodology, volume 2 of 1, pages 47-92. ACM press, January 1993.

The problem of change propagation in multiuser software development environments distributed across a local-area network is addressed. The program is modeled as an attributed parse tree segmented among multiple user processes and changes are modeled as subtree replacements requested asynchronously by inidividual users. Change propagation is then implemented using decentralised incremental evaluation of an attribute grammar that defines the static semantic properties of the programming language. Building up to our primary result, we first present algorithms that support parallel evaluation on a centralised tree in response to single edits using a single diting cursor and multiple dits with multiple editing cursors. Then we present our algorithm for parallel evaluation on a decentralized tree. We also present a protocol to guarantee reliability of the evaluation algorithm as components of the decentralized tree become unavailable due to failures and return to availability.

[520]

Uwe Kastens. Attribute grammars in a compiler construction environment. In Henk Alblas and Borivoj Melichar, editors, Attribute Grammars, Applications and Systems, volume 545 of Lecture Notes in Computer Science, pages 380-400. Springer-Verlag, New York-Heidelberg-Berlin, June 1991. Prague.

Attribute Grammar (AG) specifications are implemented by attribute evaluators which perform computations on tree structures as specified. An AT system should concentrate on generating that implementation. In compiler construction the attribute evaluator has to be combined with other modules, like scanner, parser, tree construction, data bases, and translation modules. Those are generated by other compiler tools, taken from library, or implemented for the specific application. These components have to fit together properly on the specification level as well as on the level of module interfaces. In this paper those relationships are demonstrated using the LIGA system within the compiler construction environment Eli as an example.

[723]

T . Murer, A. Würtz, D. Scherer, and D. Schweizer. GIPSY: Generating integrated process support systems - project overview. Ik-report no. 22, Swiss Federal Institute of Technology Zurick, December 1996.

Cooperative software engineering requires integration of a distributed and heterogeneous world of actors and resources. Component technology will augment integration problems due to distributed development of large numbers of interoperating components. Extensible Attribute Grammars (EAG) are used for the specification and generation of highly integrated tool components that support the software process. Tool components are plugged into a process support framework which allows for the distributed definition and enactment of a software process. A common understanding of the process is provided by a 3D process model which supports tool integration on a high level so that developers perceive the tools as a homogeneous environment

[726]

F. Vicu na. Semantic Formalization in Mathematical Modeling Languages. PhD thesis, Computer Science Department, UCLA, 1990.

Most existing languages for mathematical programming have semantics that are only incompletely formalized. This situation -- studied in detail for AMPL, GAMS, and LINGO -- inhibits efforts to achieve a high level of automation for diagnosing errors and generating major components of a computer-based modeling environment (e.g., language-based editors, type inference tools, and immediate expression evaluators). The focus of this dissertation is to demonstrate that attribute grammars furnish a suitable declarative formalism with which to overcome this serious deficiency. SML is the main target language, although a similar development should be possible for most other mathematical modeling languages. The feasibility of the proposed approach is demonstrated by expressing the full syntax and semantics of SML in attribute grammar equations, and by using them in conjunction with the Cornell Synthesizer Generator to generate a language-directed editor for SML on a UNIX workstation. Both the automatic detection of missing language constructs and the immediate evaluation of numerical and logical expressions are addressed.

[747]

Robert L. Nord and Frank Pfenning. The ergo attribute system. In Peter Henderson, editor, ACM SIGSOFT/SIGPLAN Symp. on Practical Software Development Environments, pages 110-120. ACM press, Boston, MA, November 1988. Joint issue with ACM SIGPLAN Notices 24, 2 (February 1989)Published as SIGSOFT Software Eng. Notes, volume 13, number 5.

The Ergo Attribute System was designed to satisfy the requirements for attributes in a language-generic program derivation environment. It consists of three components: an abstract data type of attributes that guarantees attribute consistency; a Common Lisp implementation which combines demand-driven and incremental attribute evaluation in a novel way while allowing for attribute persistence over many generations of a program; and an attribute-grammar compiler producing code based on this abstract data type from a high-level specification. Experience with three major applications (one being the attribute-grammar compiler itself) confirms that the overhead in storing and accessing attributes incurred by the implementation scheme is more than offset by the gains from the demand-driven, incremental, and persistent nature of attribution.

[1034]

Janet A. Walz. Extending Attribute Grammar and Type Inference Algorithms. Ph.D. thesis, Cornell University, February 1989.

Gated attribute grammars and error-tolerant unification expand upon the usual views of attribute grammars and unification. Normally, attribute grammars are constrained to be noncircular; gated attribute grammars allow fairly general circularities. Most unification algorithms do not behave well when given inconsistent input; the new unification paradigm proposed here not only tolerates inconsistencies but extracts information from them. The expanded views prove to be useful in interactive language-based programming environments. Generalized unification allows the environment to help the user find the sources of type errors in a program, while gated attribute grammars allow the environment to provide an interpreter for incremental reevaluation of programs after small changes to the code. The defining feature of gated attribute grammars is the appearance of a gate attribute (indicating where cycle evaluation should begin and end) within every cycle. Attributes are ordered by collapsing strongly connected components in the dependency graph and topologically sorting the result. The smaller dependency graph for each component (ignoring edges leading to the gate) can be recursively collapsed to provide further ordering. use of the evaluation order defined in this manner allows gated attribute grammars to do without the restrictions on functions within a component needed by the other varieties of circular attribute grammars. Initial and incremental evaluation algorithms are given, as well as a sample grammar allowing an editor for a small language to become an incremental interpreter. Counting unification defines unique solutions to sets of input equations that contain conflicting type information. These solutions are derived from the potential variable constraints implied by the input equations. For each type variable, each branch (a portion of a constraint) is assigned a weight indicating the number of times the input set implied such a constraint. When the input equations are derived from the static analysis of a program, the relative branch weights for a conflicting variable give the overall pattern of uses of that variable and can direct attention to parts of the program that disagree with the majority of uses. A number of error-tolerant unification algorithms are presented.