C++ Producer Guide

March 1998

next section previous section current document TenDRA home page document index

1 - Introduction
1.1 - Updated introduction
2 - Interface descriptions
2.1 - Invocation
2.2 - Compiler configuration
2.3 - Token syntax
2.4 - Symbol table dump
2.5 - Intermodule analysis
2.6 - Implementation details
2.7 - Standard library
3 - Program overview
3.1 - Source code organisation
3.2 - Type system
3.3 - Error database
3.4 - Parsing C++
3.5 - TDF generation
A - #pragma directive syntax
B - Symbol table dump syntax
C - Error catalogue syntax

1. Introduction

This document is designed as a technical overview of the TenDRA C++ to TDF/ANDF producer. It is divided into two broad areas; descriptions of the public interfaces of the producer, and an overview of the producer source code.

Whereas the interface description contains most of the information which would be required in a users' guide, it is not necessarily in a readily digestible form. The C++ producer is designed to complement the existing TenDRA C to TDF producer; although they are completely distinct programs, the same design philosophy underlies both and they share a number of common interfaces. There are no radical differences between the two producers, besides the fact that the C++ producer covers a vastly larger and more complex language. This means that much of the existing documentation on the C producer can be taken as also applying to the C++ producer. This document tries to make clear where the C++ producer extends the C producer's interfaces, and those portions of these interfaces which are not directly applicable to C++.

A familiarity with both C++ and TDF is assumed. The version of C++ implemented is that given by the draft ISO C++ standard. All references to "ISO C++" within the document should strictly be qualified using the word "draft", but for convenience this has been left implicit. The C++ producer has a number of switches which allow it to be configured for older dialects of C++. In particular, the version of C++ described in the ARM (Annotated Reference Manual) is fully supported.

The TDF specification (version 4.0) may be consulted for a description of the compiler intermediate language used. The paper TDF and Portability provides a useful (if slightly old) introduction to some of the ideas relating to static program analysis and interface checking which underlie the whole TenDRA compilation system.

The warning sign:

is used within the document to indicate areas where the implementation is currently incomplete or incorrect.

1.1. Updated introduction

Since this document was originally written, the old C producer, tdfc, has been replaced by a new C producer, tdfc2, which is just a modified version of the C++ producer, tcpplus. All C producer documentation continues to apply to the new C producer, but the new C producer also has many of the features described in this document as only applying to the C++ producer.

2. Interface descriptions

The most important public interfaces of the C++ producer are the ISO C++ standard and the TDF 4.0 specification; however there are other interfaces, mostly common to both the C and C++ producers, which are described in this section.

An important design criterion of the C++ producer was that it should be strictly ISO conformant by default, but have a method whereby dialect features and extra static program analysis can be enabled. This compiler configuration is controlled by the #pragma TenDRA directives described in the first section.

The requirement that the C and C++ producers should be able to translate portable C or C++ programs into target independent TDF requires a mechanism whereby the target dependent implementations of APIs can be represented. This mechanism, the #pragma token syntax, is described in the following section. Note that at present this mechanism only contains support for C APIs; it is considered that the C++ language itself contains sufficient interface mechanisms for C++ APIs to be described.

The C and C++ producers provide two mechanisms whereby type and declaration information derived from a translation unit can be stored to a file for post-processing by other tools. The first is the symbol table dump, which is a public interface designed for use by third party tools. The second is the C/C++ spec file, which is designed for ease of reading and writing by the producers themselves, and is used for intermodule analysis.

The mapping from C++ to TDF implemented by the C++ producer is largely straightforward. There are however target dependencies arising within the language itself which require special handling. These are represented by certain standard tokens which the producer requires to be defined on the target machine. These tokens are also used to describe the interface between the producer and the run-time system. Note that the C++ producer is primarily concerned with the C++ language, not with the standard C++ library. An example implementation of those library components which are required as an integral part of the language (memory allocation, exception handling, run-time type information etc.) is provided. Otherwise, libraries should be obtained from third parties. A number of hints on integrating such libraries with the C++ producer are given.

3. Program overview

The C++ producer is a large program (over 200000 lines, including automatically generated code) written in C. A description of the coding conventions used, the API observed and the basic organisation of the source code are described in the first section.

One of the design methods used in the C++ producer is the extensive use of automatic code generation tools. The type system is based around the calculus tool, which allows complex type systems to be described in a simple format. The interface generated by calculus allows for rigorous static type checking, generic type constructors for lists, stacks etc., encapsulation of the operations on the types within the system, and optional run-time checking for null pointers and discriminated union tags. An overview is given of the type system used as the basis of the C++ producer design. Also see the calculus users' guide.

The other general purpose code generation tool used in the C++ producer is the parser generator, sid. A brief description of the problems in writing a C++ parser is given. Also see the sid users' guide.

The other code generation tools used were written specifically for the C++ producer. The error reporting routines within the producer are based on an error catalogue, from which code for constructing and printing errors is generated. The TDF output routines are based on primitives automatically generated from a standard database describing the TDF specification.

The program itself is well commented, so no lower level program documentation has been provided. When performing development work the producer should be compiled with the DEBUG macro defined. This enables the calculus run-time checks, along with other assertions, and makes available the debugging routines, DEBUG_type, which can be used to print an object from the internal type system.


  1. Working paper for Draft Proposed Internation Standard for Information Systems - Programming Language C++, X3J16/96-0225, December 1996: http://www.cygnus.com/misc/wp/dec96pub/ or http://www.maths.warwick.ac.uk/c++/pub/wp/html/cd2/.

  2. The Annotated C++ Reference Manual, Margaret Ellis and Bjarne Stroustrup, ISBN 0-201-51459-1, Addison-Wesley, 1990: http://heg-school.aw.com/cseng/authors/ellis/annocpp/annocpp.html

  3. TDF Specification, Issue 4.0: attached.

  4. C Checker Reference Manual: attached.

  5. TDF and Portability: attached.

  6. C Coding Standards, DRA/CIS(SE2)/WI/94/57/2.0 (OSSG internal document).

Part of the TenDRA Web.
Crown Copyright © 1998.