Symbol Table Construction and Name Lookup in ISO C++
James F. Power and Brian A. Malloy,37th International Conference on Technology of Object-Oriented Languages and Systems,
Sydney, Australia, November 20-23, 2000.
ISBN: 0-7695-0918-5.
In this paper, we present an object-oriented model of symbol table construction and name lookup for ISO C++ using the Unified Modeling Language (UML). Our use of UML class, activity and sequence diagrams serves to explicate our model and our use of patterns such as decorator and facade increase the understandability of the model. Clause three of the ISO C++ standard describes the procedures and rules for performing name lookup; our activity and sequence diagrams serve to simulate these procedures in graphical fashion. An advantage of our approach is that our model can increase C++ understandability for those practitioners with a working UML knowledge.
An Object Oriented Approach to Parser Generation in C++
Lisa Cosgrave, James Power and John Waldron,Conference of the South African Institute of Computer Scientists and Information Technologists,
Cape Town, South Africa, November 1-3, 2000.
In this paper we describe the design and implementation of a system for representing context-free grammars in C++. The system allows for grammar representation at the object level, providing enhanced modularity and flexibility when compared to traditional generator-based approaches. We also describe the transformation of grammar flow analysis problems into an object-oriented framework using the Visitor pattern, as well as the implementation of a top-down LL(1) parser. As such, this work represents the synthesis of three presently disparate fields in parser design and implementation: combinator parsing, fixpoint-based grammar flow analysis, and object-oriented design.
Also appears in the South African Computer Journal, No. 26, pp 207-211, November 2000
Comparison of Bytecode and Stack Frame Usage by Eiffel and Java Programs in the Java Virtual Machine
John Waldron and James Power,2nd International Workshop on Computer Science and Information Technologies,
Ufa, Russia, September 18-23, 2000.
ISBN: 5-86911-312-1.
Dynamic quantatative measurements Bytecode and Stack Frame Usage by Eiffel and Java Programs in the Java Virtual Machine are made. Two Eiffel programs are dynamically analysed while executing on the JVM, and the results compared with those from the Java Programs. The aim is to examine whether properties like instruction usage and stack frame size are properties of the Java programming language itself or are exhibited by Eiffel programs as well. Remarkably local_load, push_const and local_store always account for very close to 40% of instructions executed, a property of the Java Virtual Machine irrespective of the programming language compiler or compiler optimizations used.
Metric-Based Analysis of Context-Free Grammars
James Power and Brian Malloy,8th IEEE International Workshop on Program Comprehension,
Limerick, Ireland, 10-11 June, 2000.
ISBN: 0-7695-0656-9.
Recent advances in software engineering have produced a variety of well established approaches, formalisms and techniques to facilitate the construction of large-scale applications. Developers interested in the construction of robust, extensible software that is easy to maintain should expect to deploy a range of these techniques, as appropriate to the task. In this paper, we provide a foundation for the application of established software metrics to the measurement of context-free grammars. The usual application of software metrics is to program code; we provide a mapping that allows these metrics to be applied to grammars. This allows us to interpret six software engineering metrics in a grammatical context, including McCabe's complexity metric and Fenton's impurity metric. We have designed and implemented a tool to automatically compute the six metrics; as a case study, we use these six metrics to measure some of the properties of grammars for the Oberon, ISO C, ISO C++ and Java programming languages. We believe that the techniques that we have developed can be applied to estimating the difficulty of designing, implementing, testing and maintaining parsers for large grammars.
Specifying and Verifying IP with Linear Logic
David Sinclair, James Power, Paul Gibson, David Gray, and Geoff Hamilton,International Workshop on Distributed Systems Validation and Verification,
Taipei, Taiwan, ROC, April 10, 2000.
This paper presents a specification of the IP layer in linear logic and shows how linear logic can be used to prove some properties of this layer. Both the specification and the correctness proofs have been validated using the Coq proof assistant, via the authors' embedding of linear logic into this constructive framework.
An Approach for Modeling the Name Lookup Problem in the C++ Programming Language
James F. Power and Brian A. Malloy,15th ACM Symposium on Applied Computing,
Villa Olmo, Como, Italy, March 19-21, 2000.
ISBN: 1-58113-239-5.
Formal grammars are well established for specifying the syntax of programming languages. However, the formal specification of programming language semantics has proven more elusive. A recent standard, the Unified Modeling Language (UML), has quickly become established as a common framework for the specification of large scale software applications. In this paper, we describe an approach for using the UML to specify aspects of the static semantics of programming languages. In particular, we describe a technique for solving the name lookup problem for the recently standardized C++ programming language. We apply our approach to C++ because a solution to the name lookup problem is required for parser construction and our solution can be applied to Java and other programming languages.