Provided by: fp-compiler_2.4.0-2_i386 bug

NAME

       fpc - Free Pascal Compiler (FPC) binary

SYNOPSIS

       fpc [options] [sourcefile]

DESCRIPTION

       This  binary is the main binary of the Free Pascal Compiler (FPC) which
       is a Turbo Pascal and  Delphi  (7.0)  compatible  standalone  (non  GCC
       frontend) multitarget Pascal compiler.

       The  compiler  uses  LD(1)  and can use AS(1) (see parameter -Aas), but
       also has its own binary object writer.

       The current main targets are  Go32V2  (Dos  DJGPP  extender),  Freebsd,
       Linux,  MacOS,  MacOSX,  MorphOS,  Netware,  OS/2 and Win32.  The other
       targets (M68K compilers for Atari and Amiga) are either based on  older
       versions of the compiler or are still in development.

       This  manpage is meant for quick-reference only. FPC comes with a great
       (2000+ pages) manual, which is updated constantly, while this man  page
       can be out of date.

Version number

       Starting   with   release   1.0,  a  new  versioning  system  has  been
       implemented.  If the last number is even (1.0, 1.0.2),  it  is  stable,
       and  if  the  last  number  is  odd  it is a daily changing development
       version.(1.0.5, 1.1) just like the linux kernel.

       Version 0.99.5 however is a stable release.  It  was  made  before  the
       even/odd version naming system was introduced.

Usage

       The  compilation  process  is  started  by  typing  fpc  followed  by a
       sourcefile  name  (normally  with  .pas  or  .pp   extension).   Before
       processing  the  actual  processing  of the source file, fpc.cfg(5) the
       configuration file of the compiler is read which contains the  location
       of  the  RTL,  other packages (FCL, FreeVision), and optionally default
       values for some switches. See the separate manpage  of  fpc.cfg(5)  for
       more information.

Options

       General options

       -h     if  you  specify this option, the compiler outputs a list of all
              options, and exits after that.

       -?     idem as -h, but waiting after every  screenfull  for  the  enter
              key.

       -i     This   option   tells   the  compiler  to  print  the  copyright
              information.

              You can give it an option, as -ixxx where "xxx" can  be  one  of
              the following:

              D      Returns the compiler date.

              V      Returns the compiler version.

              SO     Returns the compiler OS.

              SP     Returns the compiler processor.

              TO     Returns the target OS.

              TP     Returns the target Processor.

       -l     This option tells the compiler to print the FPC logo on standard
              output. It also gives you the FPC version number.

       -n     Tells the compiler not to read the configuration file fpc.cfg(5)

       Options for getting feedback

       -vxxx  Be verbose. "xxx" is a combination of the following:

              e      Tells the compiler to show only errors. This option is on
                     by default.

              i      Tells the compiler to show some general information.

              w      Tells the compiler to issue warnings.

              n      Tells the compiler to issue notes.

              h      Tells the compiler to issue hints.

              l      Tells the  compiler  to  show  the  line  numbers  as  it
                     processes a file. Numbers are shown per 100.

              u      Tells  the  compiler  to  print the names of the files it
                     opens.

              t      Tells the compiler to print the names  of  the  files  it
                     tries to open.

              p      Tells  the  compiler to print the names of procedures and
                     functions as it is processing them.

              c      Tells the compiler  to  warn  you  when  it  processes  a
                     conditional.

              m      Tells the compiler to write which macros are defined.

              d      Tells the compiler to write other debugging info.

              a      Tells  the  compiler to write all possible info. (this is
                     the same as specifying all options)

              0      Tells the compiler to write no messages. This  is  useful
                     when  you  want  to  override  the default setting in the
                     configuration file.

              b      Tells the compiler to show all procedure declarations  if
                     an overloaded function error occurs.

              x      Tells  the  compiler  to output some executable info (for
                     Win32 platform only).

              r      Rhide/GCC   compatibility   mode:   formats   the   error
                     differently, so they are understood by RHIDE.

       Options concerning files and directories

       -exxx  tells  the  compiler that xxx is the directory where it can find
              the executables as (the assembler) and ld (the linker).

       -FD    same as -e.

       -Fexxx This option tells the compiler to write errors, etc. to the file
              xxx

       -FExxx set the executable/unit output path to xxx

       -Fixxx adds xxx to the path where the compiler searches for its include
              files.

       -Flxxx Adds xxx to the library searching path,  and  is  passe  to  the
              linker.

       -FLxxx (  Linux  only)  Tells  the  compiler  to use xxx as the dynamic
              linker.  Default  this   is   /lib/ld-linux.so.2,   or   lib/ld-
              linux.so.1, depending on which one is found.

       -Foxxx Adds xxx to the object file path. This path is used when looking
              for files that need to be linked in.

       -Frxxx tells the compiler that  xxx  contains  the  compiler  messages.
              Default  the  compiler  has  built-in  messages. Specifying this
              option will override the default messages.  (useful if you  want
              to use a language other than the default language).

       -Fuxxx Adds  xxx  to  the  unit  path.   By  default, the compiler only
              searches for units in the current directory  and  the  directory
              where  the  compiler  itself  resides.  This  option  tells  the
              compiler also to look in the directory xxx

       -FUxxx Tells the compiler to write units in directory  xxx  instead  of
              the current directory.

       -Ixxx  Add xxx to the include file search path.  This path is used when
              looking for include files.

       for more information on these options, see also the programmers manual.

       -a     Tells  the compiler not to delete the assembler file.  This also
              counts for the (possibly) generated batch script.

       -al    Tells the compiler  to  include  the  sourcecode  lines  in  the
              assembler file as comments.

       -an    Tells  the compiler to include node information in the generated
              assembler  file.   This  is  mainly  for  use  by  the  compiler
              developers.

       -ap    Tells  the  compiler  to  use  pipes  to  communicate  with  the
              assembler.

       -ar    Tells the compiler to include  register  allocation/deallocation
              information.

       -at    Tells    the    compiler    to    include   temparary   register
              allocation/deallocation information.

       -Axxx  specifies what kind of assembler should be generated . Here  xxx
              is one of the following :

              AS     A unix .o (object) file, using GNU AS

              coff   coff object file (go32) using internal writer.

              default
                     Use the default writer for the current platform.

              elf    elf  object  file  (linux,  32-bit  only)  using internal
                     writer.

              nasmcoff
                     a coff file using the nasm assembler.

              nasmelf
                     a ELF32 file (LINUX only) using the nasm assembler.

              nasmobj
                     a obj file using the nasm assembler.

              masm   An obj file using the Microsoft masm assembler.

              pecoff pecoff object file (win32) using internal writer.

              tasm   An obj file using the Borland tasm assembler.

              wasm   An obj file using the Watcom assembler.

       -Ccxxx set the default calling convention to XXX.

       -CD    Create dynamic library.

       -Ce    Compile using emulated floating point instructions.

       -Cfxxx Set the used floating point instruction set to xxx.

       -Cg    Generate PIC code.

       -Chxxx Reserves xxx bytes heap.  xxx should be between 1024  and
              67107840.

       -Ci    Generate Input/Output checking code.

       -Cn    Omit the linking stage.

       -Co    Generate Integer overflow checking code.

       -CR    Verify  object call validity (method calls mustbe valid).

       -Cr    Generate Range checking code.

       -Csxxx Set stack size to xxx bytes.

       -Ct    generate stack checking code.

       -CX    Create a smartlinked library.

       -dxxx  Define  the  symbol  name  xxx  This  can  be   used   to
              conditionally compile parts of your code.

       -E     Same as -Cn.

       -g     Generate debugging information for debugging with GDB

       -gg    idem as -g.

       -gd    generate debugging info for dbx.

       -gh    use  the  heaptrc  unit  (see  the  units part of the FPC
              manual).

       -gl    use the lineinfo unit for line information (see the units
              part of the FPC manual).

       -gv    Generate information for debugging with valgrind.

       -gw    Generate DWARF debugging information.

       -Oxxx  optimize  the  compiler’s output; xxx can have one of the
              following values :

              g      optimize for size, try to generate smaller code.

              G      optimize for time, try  to  generate  faster  code
                     (default).

              r      keep certain variables in registers (experimental,
                     use with caution).

              u      uncertain optimizations

              1      Level 1 optimizations (quick optimizations).

              2      Level  2  optimizations  (-O1  plus  some   slower
                     optimizations).

              3      Level 3 optimizations (-O2 plus -Ou).

              pn     Specify processor : n can be one of

                      1      optimize for 386/486

                      2      optimize for Pentium/PentiumMMX (tm)

                      3      optimizations  for  PentiumPro  /  P-II  /
                             Cyrix 6x86 / K6 (tm)

              The exact effect of these effects can  be  found  in  the
              programmers part of the manual.

       -oxxx  Tells  the  compiler to use xxx as the name of the output
              file (executable). Only with programs.

       -pg    Generate profiler code for gprof.

       -s     Tells the compiler not to call the assembler and  linker.
              Instead,  the  compiler  writes  a script, PPAS.BAT under
              DOS, or ppas.sh under Linux, which can then  be  executed
              to produce an executable.

       -sh    Tells  the compiler to generate a script that can be used
              to assemble and link on  the  host  system,  not  on  the
              target system. Use this when cross-compiling.

       -sr    Skip register allocation stage in compiler (use with -ar)

       -st    Tells the compiler to generate a script that can be  used
              to  assemble  and  link  on the target system, not on the
              host system. Use this when cross-compiling.

       -Txxx  Specifies the target operating system.  xxx can be one of
              the following:

              EMX    OS/2 and DOS via the EMX extender.

              FREEBSD
                     FreeBSD

              GO32V2 DOS and version 2 of the DJ DELORIE extender.

              LINUX  Linux.

              NETBSD Netbsd.

              NETWARE
                     Novell Netware module (clib)

              NETLIBC
                     Novell Netware module (libc)

              OPENBSD
                     OpenBSD

              OS2    OS/2 (native mode)

              SunOS  Solaris SunOS

              WATCOM WatCOM dos extender

              WDOSX  WDosX Dos extender

              WIN32  Windows 32 bit.

       -uxxx  undefine  the  symbol  xxx  if it is defined. This is the
              opposite of the -d option.

       -Xx    Executable options. These tell the compiler what kind  of
              executable  should  be  generated. the parameter x can be
              one of the following:

              c      (Linux only, obsolete) Link with  the  C  library.
                     You  should  only  use this when you start to port
                     Free Pascal to another operating system.

              D      Link   with   dynamic   libraries   (defines   the
                     FPC_LINK_DYNAMIC symbol)

              d      Don’t use the standard library path. Use this when
                     cross-compiling, to avoid linking with the host OS
                     libraries.

              Pxxx   Prepend  the  names of binutils (as, ld) with xxx.
                     For use when cross-compiling.

              rxxx   Set the library search path to xxx.

              s      Strip the symbols from the executable.

              S      Link   with   static   libraries   (defines    the
                     FPC_LINK_STATIC symbol)

              t      Link statically (passes -static to the linker)

              X      Link   smart.   Using   this   option   sets   the
                     FPC_LINK_SMART symbol.

       Options concerning  the  sources  (language  options)  for  more
       information on these options, see also in the Programmers Manual

       -Mmode Specify the language  mode.   mode  can  be  one  of  the
              following:

              delphi Delphi-compatibility  mode.  This loads the objpas
                     unit, and switches on ansistring mode ( -Sh ).

              fpc    Default mode.

              gpc    GNU pascal mode (does nothing at the moment)

              macpas Mac pascal mode. This loads the  macpas  unit  and
                     switches on some Mac extensions (mainly macros)

              objfpc Object Pascal mode. This loads the objpas unit.

              tp     Turbo Pascal mode.

       -Rxxx  Specifies  what assembler you use in your "asm" assembler
              code blocks. Here xxx is one of the following:

              att    Asm blocks contain AT&T assembler.

              intel  Asm blocks contain Intel assembler.

              direct Asm blocks should be copied as-is in the assembler
                     file.

       -S2    Switch on Delphi 2 extensions.

       -Sa    Generate code for assertions.

       -Sc    Support C-style operators, i.e. *=, +=, /= and -=.

       -Sd    Tries to be Delphi compatible

       -Se    The  compiler  stops after the first error. Normally, the
              compiler tries to  continue  compiling  after  an  error,
              until 50 errors are reached, or a fatal error is reached,
              and then it stops. With this switch,  the  compiler  will
              stop after the first error.

       -Sg    Support the label and goto commands.

       -Sh    use ansistrings by default.

       -SIxxx Specify  the  kind  of interfaces.  xxx can be one of the
              following:

              COM    use COM interfaces. (all interfaces  descend  from
                     IUnknown)

              CORBA  use CORBA interfaces. (no inheritance is supposed)

       -Si    Support C++ style INLINE.

       -Sm    Support C-style macros.

       -So    Try  to  be  Borland  TP  7.0  compatible  (no   function
              overloading etc.).

       -Sp    Try to be GPC (GNU Pascal Compiler) compatible.

       -Ss    The  name of constructors must be "init", and the name of
              destructors should be "done".

       -St    Allow the "static" keyword in objects.

       -Un    Do not check the unit name. Normally, the  unit  name  is
              the  same  as the filename. This option allows both to be
              different.

       -Ur    Create a release unit. This sets a special  flag  in  the
              unit, causing the compiler not to look for sources.

       -Us    Compile a system unit. This option causes the compiler to
              define only some very basic types.

SEE ALSO

       fpc.cfg(5) ppdep(1) ppudump(1) ppumove(1) ptop(1) h2pas(1) ld(1)
       as(1)