Bitbucket is a code hosting site with unlimited public and private repositories. We're also free for small teams!

Close
TENDRA 5.0.0 RELEASE INFORMATION
================================

REVISION INFORMATION
--------------------
$Id$

COPYRIGHT INFORMATION
---------------------

Please read the file COPYRIGHT for the copyright notice.


ORGANISATION OF RELEASE
-----------------------

The src subdirectory, which contains the source code, is organised into
the following top-level directories:

    build		which contains various information used during
			installation;

    installers		which contains the compiler back-ends, which
			translate the compiler intermediate form, TDF,
			to the appropriate machine instructions;

    lib			which contains everything not included in the
			other directories;

    producers		which contains the compiler front-ends, which
			translate C and C++ to the compiler intermediate
			form, TDF;

    tools		which contains various tools for manipulating,
			viewing and generating TDF;

    utilities		which contains various compiler generator
			utilities used in the development of the TenDRA
			software.

The installers directory is split into a common section, containing code
which is used by all the back ends, plus a directory for each of the
target CPUs:

    680x0		Motorola 68020, 68030 and 68040,
    80x86		Intel i386, i486 and Pentium,
    alpha		DEC Alpha,
    amd64		AMD64,
    hppa		HP Precision Architecture,
    mips		SGI/DEC MIPS,
    power		POWER,
    ppc601		POWER PC,
    sparc		SPARC.

Each CPU directory is also divided into a common section, plus a directory
for each of the target operating systems:

    680x0/sunos		680x0 on SunOS 4,
    80x86/cygwin32	Intel on Cygwin32,
    80x86/dragonfly	Intel on DragonFly,
    80x86/freebsd	Intel on FreeBSD,
    80x86/linux		Intel on Linux,
    80x86/minix		Intel on Minix,
    80x86/netbsd	Intel on NetBSD,
    80x86/openbsd	Intel on OpenBSD,
    80x86/sco		Intel on SCO,
    80x86/solaris	Intel on Solaris 2,
    80x86/svr4.2	Intel on Unixware,
    alpha/osf1		Alpha on OSF/1,
    amd64/dragonfly	AMD64 on DragonFly,
    amd64/freebsd	AMD64 on FreeBSD,
    amd64/linux		AMD64 on Linux,
    amd64/netbsd	AMD64 on NetBSD,
    amd64/openbsd	AMD64 on OpenBSD,
    hppa/hpux		HP-PA on HP-UX,
    mips/irix		MIPS on Irix,
    mips/ultrix		MIPS on Ultrix,
    power/aix		POWER on AIX,
    ppc601/aix		POWER PC on AIX,
    sparc/solaris	SPARC on Solaris 2,
    sparc/sunos		SPARC on SunOS 4.

The common installer directory is also subdivided, for convenience, into
a number of different subdirectories:

    construct		which contains the main routines for transforming
			and optimising the internal representation;

    diag		which contains routines for reading and processing
			diagnostic information contained within the TDF;

    dwarf		which contains routines for writing out diagnostic
			information as DWARF directives;

    dwarf2		which contains routines for writing out diagnostic
			information as DWARF 2 directives;

    linkinfo		which contains routines for reading linkage
			information contained within the TDF;

    reader		which contains the main routine for reading the
			input TDF and building up the internal representation;

    templ		which contains template files used to generate
			the TDF reading routines.

The producers subdirectory is divided into a common directory, containing
code shared by both the C and C++ producers, plus directories c and cpp,
containing the language specific components.  The differences between
the languages are driven from the parser, which is found in the syntax
subdirectory of c and cpp.  C merely uses a subset of the routines
available for the C++ producer, with a number of run-time or compile-time
flags to control the differences between the languages.

The common producer directory is divided, for convenience into a number
of subdirectories:

    construct		which contains the main routines for building up
			and checking the internal representation;

    obj_c		which contains macros describing the internal
			representation;

    obj_templ		which contains various template files used in
			automatic code generation;

    obj_tok		which contains TenDRA tokens describing the
			internal representation;

    output		which contains the routines of writing the
			internal representation to disk as TDF;

    parse		which contains routines for lexical analysis
			and preprocessing;

    utility		which contains routines for error reporting,
			memory allocation etc.

The tools directory contains the source for a number of different tools:

    disp		translates TDF into a human readable form;

    tcc			is the front-end to the TenDRA compiler;

    tld			links a number of TDF capsules into one;

    tnc			is an unstructured TDF assember and disassembler;

    tpl			is a structured TDF assembler;

    tspec		is a specification tool used in the TenDRA API
			descriptions.

The utilities directory contains the source for a number of different
compiler generator tools:

    calculus		is used to manage the complex type system used
			in the producers;

    lexi		is a simple lexical analyser generator (lex is
			not used);

    make_err		is used to manage the producer error catalogue;

    make_tdf		is used to generate TDF encoding and decoding
			routines from the TDF specification;

    shared		contains code common to a number of tools;

    sid			is a parser generator (yacc is not used);

The lib directory is divided into a number of subdirectories:

    apis		containing the TenDRA API descriptions used in
			its API checking facilities;

    cpp			containing the C++ support library (note that this
			is only a minimal language support subset of the
			complete C++ standard library);

    env			containing the compiler front-end configuration
			files;

    libtdf		containing a support library certain aspects of
			TDF (such as 64 bits integers);

    machines		containing machine specific tools, libraries and
			configuration files;

    startup		containing the C and C++ producer configuration
			files;

    tdf			containing a description of the TDF specification
			used by make_tdf to generate TDF encoders and
			decoders.


ORGANISATION OF INSTALLED RELEASE
---------------------------------

The installation script creates three shell scripts in the public
binaries directory (/usr/local/bin in the default set-up).  These are
the compiler, tcc, the stand-alone static checker, tchk, and the
API specification tool, tspec.  The manual pages for these tools and
those which they invoke are installed in the manual page directory
(/usr/local/man in the default set-up).  The remaining files are
installed into the TenDRA configuration directory (/usr/local/lib/TenDRA
in the default set-up).  The remainder of this section describes the
files installed into this directory.

For each target machine, a directory:

		    machines/<os>/<os_vers>/<cpu>

is created to hold the machine dependent files, where <os> denotes the
operating system name, <os_vers> denotes the operating system version
and <cpu> denotes the CPU type (as above).  This machine directory
has five subdirectories:

    bin			containing the compiled executables for this
			machine; advanced users may wish to put this
			directory on their PATH, but the executables
			in the public binaries directory should suffice
			for most users;

    env			containing the tcc configuration files for this
			machine (see above);

    include		containing the modified system headers for this
			machine; these are copied directly from the
			src/lib/machines directory in the release;

    lib			containing the API token libraries describing the
			implementation of the various standard APIs on
			this machine; the generation of these libraries
			from the API descriptions and the system headers
			is the most complex part of the installation;

    startup		containing the compiler configuration files
			describing how to navigate through the system
			headers on this machine; these are copied directly
			from the src/lib/machines directory in the
			release.

The remainder of the directories created by the installation are common
to all machines.  These are:

    building		containing files automatically generated by tspec
			from the API descriptions which are used to build
			the API token libraries; these files are only used
			during installation and may be deleted if space is
			short;

    include		containing the include files automatically generated
			by tspec from the API descriptions;

    startup		containing the C and C++ producer configuration
			files copied directly from the src/lib/startup
			directory in the release.

Recent activity

Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.