Provided by: tendra_4.1.2-19_i386 bug

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.

FILES

       file.c C source file

       file.i Preprocessed C source file

       file.C C++ source file (only if -Yc++ is specified)

       file.I Preprocessed C++ source file (only if -Yc++ is specified)

       file.j Target independent TDF capsule

       file.t Target dependent TDF capsule

       file.s Assembly source file

       file.o Binary object file

       file.d TenDRA dump file

       file.K C++ spec file (only if -Yc++ is specified)

       file.p Pretty-printed TDF capsule

       file.pl
              PL_TDF source file (only if -Ypl_tdf is specified)

       file.ta
              TDF archive

       file.G Binasm source file (Mips and Alpha only)

       file.T Assembler symbol table (Mips and Alpha only)

       a.out  Default executable name

       a.ta   Default TDF archive name

       a.d    Default dump file name

       a.api  Default API usage analysis file name

       a.j    Default output file for merge-TDF-capsules option

       tcc_startup.h
              Name of preserved tcc start-up file

       /tmp/tcc*
              Temporary directory (this may be changed using the TMPDIR system
              variable, see tempnam(3)).

SEE ALSO

       as(1), cc(1), disp(1), ld(1), prof(1),  tchk(1),  tdfc(1),  tcpplus(1),
       tot_o(1),    tld(1),    trans386(1),    alphatrans(1),    hppatrans(1),
       mipstrans(1), sparctrans(1), tccenv(5).

                                                                        tcc(1)