tendracc - Online in the Cloud

PROGRAM:

NAME

tcc - User interface to the TDF system

SYNOPSIS

tcc [ options ] files

DESCRIPTION

tcc is the user interface to the TDF system. It is more fully
documented in the tcc User's Guide.

tcc accepts several types of arguments as files:

- Arguments whose names end in .c are understood to be C source
files.

- Arguments whose names end in .i are understood to be
preprocessed C source files.

- Arguments whose names end in .C are understood to be C++ source
files (only if -Yc++ is specified).

- Arguments whose names end in .I are understood to be
preprocessed C++ source files (only if -Yc++ is specified).

- Arguments whose names end in .j are understood to be target
independent TDF capsules.

- Arguments whose names end in .ta are understood to be archives
of target independent TDF capsules.

- Arguments whose names end in .t are understood to be target
dependent TDF capsules.

- Arguments whose names end in .s are understood to be assembly
source files.

- Arguments whose names end in .d are understood to be TenDRA dump
files.

- Arguments whose names end in .K are understood to be C++ spec
files (only if -Yc++ is specified).

- Arguments whose names end in .p are understood to be TDF
notation source files (only if -Ytnc is specified).

- Arguments whose names end in .pl are understood to be PL_TDF
source files (only if -Ypl_tdf is specified).

- All other arguments (but particularly those whose names end in
.o and .a) are understood to be binary object files.

The compilation process is as follows. Depending on the options given,
it may halt at any stage:

1. TDF archives are split into their constituent target independent
capsules.

2. C source files (including preprocessed C) are compiled into
target independent TDF capsules using tdfc(1). (tcpplus(1) does
the same for C++ source files when -Yc++ is specified.)

3. Target independent TDF capsules are linked, using tld(1), with
the TDF libraries to produce target dependent TDF capsules.

4. Target dependent TDF capsules are translated into assembly
source files using one of mipstrans(1) (q.v. - things are not
quite so simple in this case), trans386(1) etc.

5. Assembly source files are compiled into binary object files
using as(1).

6. Binary object files are linked with the precompiled libraries,
using ld(1), to produce a final executable.

With the exception of binary object files, intermediate files are not
preserved unless explicitly instructed.

The standard file suffixes c, i, C, I, j, t, s, o, d, k, and K,
together with p (pretty-printed TDF capsule) and pl (PL_TDF source
file), are used to indicate file types in some options. Also the
various compilation phases are identified by letters in some options.
These are:

c C to TDF producer

p C preprocessor

x C++ to TDF producer (only if -Yc++ is specified)

g C++ preprocessor (only if -Yc++ is specified)

L TDF linker (or builder)

t TDF translator

a System assembler

l System linker

S C++ spec linker

e Compact-output error reporter (only if -Ycompact is specified)

u TenDRA dump file linker

d TDF pretty-printer

OPTIONS

The following options are supported by tcc. All options are scanned
before input files are dealt with. The system variable TCCOPTS may be
used to specify a list of options which are processed before the first
command-line option.

-Astring
Asserts the predicate string.

-Bstring
Passed to the system linker. The valid values of string are
target dependent.

-C Not implemented and provided for cc(1) compatibility only. It
is meant to preserve comments when preprocessing.

-Dstring
Where string is of the form macro or macro=defn, is equivalent
to inserting the preprocessor directives "#define macro 1" or
"#define macro defn" at the start of each C source file. This
is implemented by tcc writing this directive into a start-up
file.

-E Invokes the C preprocessor only, putting the result into a file
with a .i suffix if other options indicate that preprocessed C
files are to be preserved, or onto the standard output
otherwise. Similarly, C++ source files are preprocessed and put
into files with .I suffixes.

-Eletter:file
Causes file to be invoked as the executable for the compilation
stage given by letter.

-Fletter
Tells tcc to stop after producing the files indicated by letter,
and to preserve these files. letter is a single character
corresponding to the suffix of the files to be preserved.

-G Provided for cc compatibility.

-H Causes the names of files included by a '#include' directive to
be printed.

-Istring
Tells the producers and preprocessors to search the directory
string for included files. The directories are searched in the
order given, followed by the system default directories.

-Jstring
Tells the TDF linker to search the directory string for TDF
libraries. The linker searches the directories in the order
given, followed by the system default directories.

-Kstring,...
Provided for cc compatibility. Specifies various installer
options.

-Lstring
Tells the system linker to search the directory string for
libraries. It searches the directories in the order given,
followed by the system default directories.

-M Specifies that the TDF linker should link all the given target
independent TDF capsules into one. This is done between stages
2 and 3 above. The default name for the produced capsule is
a.j.

-MA Specifies that the TDF linker should link all the given target
independent TDF capsules into one and also hide all the defined
tag and token names from the resultant TDF (except the tag
"main"). This should only be used to compile complete programs.
The default name for the resulting capsule is a.j.

-Nidentifier:string
As -Istring except that the identifier identifier is associated
with the directory string in the producer.

-Ostring
This flag has no effect other than to cancel any previous
diagnostics flag and is included only for compatibility with
other compilers. All TDF optimisations are on by default. All
optimisations are believed to be correct, any bug which occurs
in the fully-optimised state is a genuine bug.

-P Invokes the C preprocessor only, putting the result into a file
with a .i suffix. The C++ preprocessor is similarly invoked for
C++ source files, putting the result into a file with a .I
suffix.

-Pletter...
Tells tcc to preserve those files indicated by letter. Each
letter is a single character corresponding to the suffix of the
files to be preserved. The tcc startup-file can be preserved as
tcc_startup.h using -Ph. All intermediate files can be
preserved using -Pa.

-S Tells tcc to stop after producing an assembly source file. This
is equivalent to -Fs.

-Sletter,string,...
The specifies that the list of input files string all have type
letter, where letter is a single character giving the normal
suffix of the file type. This gives an alternative method of
passing input files to tcc, one which does not depend on it
having to recognise suffixes to find the type of a file.

-Sletter:string
Similar to the option above, but specifies a single input file,
string (which may contain a comma).

-Ustring
Is equivalent to inserting the preprocessor directive "#undef
string" at the start of each C source file. This is implemented
by tcc writing this directive into a start-up file. The only
macros built into the C to TDF producer are __LINE__ , __FILE__
, __DATE__ , __TIME__ , __STDC__ , __ANDF__ and __TenDRA__ .

-V Causes all tools invoked by tcc to print their version numbers.

-Wletter,string,...
This passes the list of options string to the compilation phase
indicated by letter.

-Wletter:string
Similar to the option above, but specifies a single option
string (which may contain a comma).

-Xstring
Specifies a compilation mode. string can be a for "lenient
ANSI", c for "strict ANSI" (this is default), p for "strict ANSI
with some extra checks", s for "strict ANSI with many extra
checks" or t for "traditional".

-X:string
Specifies an individual compilation option. See the tcc User's
Guide for details.

-Yfile Specifies the environment to use. An environment is a file
telling tcc to modify its defaults. If the full pathname of env
is not given, the file is searched for along the tcc
environments path which is a list of directories separated by
colons. This search path can be printed using -show_env. There
are certain standard environments, for example, ansi,
representing the ANSI API (this is the default API environment),
posix represents the POSIX API, xpg3 the XPG3 API, and so on.
The system environment allows tcc to behave like cc(1), using
the system header files etc. See the tcc User's Guide and
tccenv(5) manual page for more details about environments.

-Zstring
Provided for cc(1) compatibility. Specifies various installer
options.

-api_check
Causes tchk to create an API usage analysis file, with default
name a.api.

-api_check_out string
If an API usage analysis file is produced, call it string.

-b Stops the library libc.a being used by the linker by default.

-c Tells tcc to stop after producing the binary object files. This
is equivalent to -Fo.

-cc Causes tcc to invoke cc(1) for its code production, using the C
to TDF producer as a checking front-end to cc. This allows the
checking capabilities of the front-end of the TDF compiler to be
exploited on machines where no TDF back-end is available.

-cc_only
Causes tcc to invoke cc(1) only.

-ch Causes tcc to emulate the stand-alone static checker, tchk(1).
Intermodular checks are enabled in this mode.

-d Halts the compilation after the creation of the dump files.
This is equivalent to -Fd.

-disp Runs the TDF pretty-printer on all files at stage 2 or 3 and
then terminates. The results are put into files with .p
suffixes.

-disp_t
Runs the pretty-printer on all files at stage 3 and then
terminates. This differs from the previous option in that it
displays the TDF after linking with the target-dependent TDF
libraries rather than before. The output is put into a file
with a .p suffix.

-dn or -dy
Passed to the system linker.

-doletter string
Sets the name of the default output file of type letter to
string. For example, -doh can be used to set the name of the
preserved start-up file.

-dry Makes tcc print information on what system commands it would
execute with the given files and options (as in verbose mode)
but not actually perform them.

-dump Causes tcc to dump its current status. This option is only used
during the actual compilation of tcc.

-estring
Is equivalent to inserting the preprocessor directive "#include
"string"" at the end of each C source file.

-fstring
Is equivalent to inserting the preprocessor directive "#include
"string"" at the start of each C source file.

-g Tells tcc to produce diagnostic information compatible with the
system debugger.

-hstring
Passed to the system linker.

-i Tells tcc to stop after producing the target independent TDF
capsules. This is equivalent to -Fj.

-im Enables intermodular checks.

-im0 Disables intermodular checks.

-info Causes tcc to print information on the current API.

-jstring
Tells the TDF linker to use the TDF library string.tl.

-k In intermodular checking mode, halts the compilation after the
creation of the C++ spec files. This is equivalent to -FK.

-keep_errors
By default, if an error occurs during the production of a file,
tcc will remove it. This option will preserve such files.

-lstring
Tells the system linker to use the library libstring.a.

-make_up_names
Causes tcc to make up names for all intermediate files rather
than forming them from the basenames of the input files.

-message string
Causes tcc to print the message string.

-nepc Tells the C to TDF producer to allow certain non-portable
constructs through.

-not_ansi
Tells the C to TDF producer to allow certain non-ANSI features
through.

-no_startup_options
Ensures that no start-up or end-up options are passed to the C
to TDF producer (unlikely to be useful).

-o string
If a final executable is produced, call it string (the default
is a.out). Otherwise, if only one file is preserved, call it
string.

-p Produces profiling data for use with prof(1) on those machines
for which this command is available.

-prod Specifies that tcc should stop after producing the target
independent TDF capsules and combine them into a TDF archive.
The default archive name is a.ta.

-q or -quiet
Specifies that tcc should work silently. This is the default.

-query Causes tcc to print a list of all the options it recognises,
together with a brief description of each. Since this list is
automatically generated it is likely to be more accurate than
this manual page.

-s Passed to the system linker.

-sletter:suffix
Specifies that files with suffix suffix are interpreted as
having type indicated by letter.

-show_env
Prints the tcc environments path. This is a list of directories
separated by colons. The first element of the list is always
the system default environments directory and the last element
is always the current working directory. The other elements may
be specified by the user by means of the TCCENV system variable.

-show_errors
Makes tcc report on the command it was executing when an error
occurred.

-special string
Allows various internal options to be specified.

-startup string
Causes string to be printed to the tcc built-in start-up file.

-sym Enables dump-linking.

-sym: string
Enables dump-linking (with mode specified by options in string).

-target string
No effect (allowed for compatibility with cc(1) on some
systems).

-temp dir
Specifies that tcc should use dir as its temporary directory.

-tidy Causes tcc to remove its intermediate files when they are no
longer required rather than waiting to the end of the
compilation.

-time Makes tcc print information on what system commands it is
executing (as with verbose mode) followed by the time taken for
each.

-ustring
Passed to the system linker.

-v or -verbose
Specifies that tcc should work in verbose mode, sending
information on what system commands it is executing to the
standard output.

-vb Causes the name of each input file to be printed as it is
processed.

-version
Makes tcc report its version number.

-w Suppresses all tcc warning messages.

-work string
Specifies that all preserved intermediate files are placed in
the directory string rather than where they are placed by
default, in the current working directory.

-wsl Tells the TDF translator to make all string literals writable.

-zstring
Passed to the system linker.

Use tendracc online using onworks.net services