tendra /

Filename Size Date modified Message
doc
mk
src
55 B
update tags
4.5 KB
Make sure we have the right license specified for the TenDRA project.
329 B
Add -r to the bmake call.
3.0 KB
Have INSTALL contain all installation instructions and let README have all
1.8 KB
Create a bootstrap path and normal path.
246 B
Let BOOTSTRAP switch between tendra.bootstrap.mk and tendra.build.mk.
8.6 KB
Have INSTALL contain all installation instructions and let README have all
7.1 KB
Add FreeBSd 7.
3.0 KB
Duplicate the logic for cc*, seems you cannot do all too strange regular
2.0 KB
Add sid as a project line, adding its obj directory for inclusion of
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.