home *** CD-ROM | disk | FTP | other *** search
/ Computer Club Elmshorn Atari PD / CCE_PD.iso / mac / 1000 / CCE_1024.ZIP / CCE_1024 / SOZBIN07.LZH / SOZDISTR / DOC / SOZOBON.DOC < prev    next >
Text File  |  1994-10-23  |  25KB  |  667 lines
  1.  
  2.             The Sozobon C Compiler
  3.  
  4.                eXtended Version
  5.  
  6.              a freeware offering
  7.               maintained by Jerry G. Geiger
  8.  
  9.              based on the SOZOBON 2.00 release
  10.                   by
  11.                Sozobon, Limited
  12.  
  13.  
  14.  
  15.                 Users Reference
  16.  
  17.  
  18.  
  19.       1. Introduction
  20.  
  21.       The Sozobon C Compiler is a complete implementation of the C
  22.       language as defined by Kernighan & Ritchie and prevailing
  23.       practice.  It is on the way to being compatible with ANSI/POSIX
  24.       standards.  The package includes a compiler, optimizer, assembler,
  25.       linker, and several other associated utilities.  For runtime
  26.       library support, xdlibs, a library based on the public domain
  27.       dLibs routines and some other different libraries are used.
  28.  
  29.       This extended SOZOBON version is based on Sozobon 2.00 (c) by
  30.      Sozobon Ltd: Tony Andrews, Johann Ruegg, and Joe Treat.
  31.       It's Runtime library is based on dLibs library by Dale Schumacher.
  32.       The GEM libary is based on GEMFast library by Ian Lepore.
  33.  
  34.  
  35.       1.1 Copyright and Disclaimer
  36.  
  37.       Like the original library packages and original Sozobon versions,
  38.       the eXtended Version of the Sozobon compiler including all
  39.       executables and other components may be freely distributed.
  40.  
  41.       The extended version of the Sozobon C compiler can be freely
  42.       distributed, as long as you don't modify the copyright and mark
  43.       changed parts clearly.
  44.       You may not charge any money for copying the three Sozobon
  45.       archives, or their contents or parts of them.  You may not include
  46.       them in any public domain/Shareware disk libraries for the
  47.       purposes of sale (even for a minimal charge).
  48.  
  49.       IN NO EVENT WILL I AND/OR ANY OTHER PARTY BE LIABLE TO YOU FOR DAMAGES,
  50.       INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER SPECIAL, INCIDENTAL
  51.       OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
  52.       (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
  53.       INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A FAILURE OF THE
  54.       PROGRAMS TO OPERATE WITH OTHER PROGRAMS) THE PROGRAMS, EVEN IF YOU HAVE
  55.       BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR ANY CLAIM BY
  56.       ANY OTHER PARTY.
  57.       This goes for the libraries too, of course.
  58.  
  59.       Berlin, Nov 1993 and again now: Mar 2 1994, May/June/October 1994
  60.         Jerry G. Geiger
  61.  
  62.  
  63.  
  64.       2. Development Environment
  65.  
  66.       This  section  describes    in  more  detail  the  operation of the
  67.       compiler    and  the relationship between parts of the compiler and
  68.       the corresponding pieces of the Alcyon compiler.
  69.  
  70.       The compiler works best when used with a shell like 'bash', 'tcsh',
  71.       'mupfel' or similiar.
  72.  
  73.       There is a special GEM based shell called C-Desk, by Holger Weets,
  74.       for those who dislike make-files and command line environments.
  75.  
  76.       The  compiler should be usable on machines with 512K and a single
  77.       disk.  This  document  does not  describe  the  optimal layout for
  78.       various  ST  configurations, but you can probably figure out what
  79.       makes  the  most    sense  for  your  machine.   This will probably
  80.       involve  a  RAM disk,  and  some    arrangement  of  programs  and
  81.       libraries on one or more floppies.
  82.  
  83.       2.1 Environment Variables
  84.  
  85.       Several environment variables may be used to alter the operation
  86.       of the compiler.    The variables are used to specify the location
  87.       of executables, header files, libraries, and temporary files.
  88.  
  89.       Some variables may reference a list of directories to be searched,
  90.       with elements of the list separated by commas or semicolons.  The
  91.       variables are:
  92.  
  93.        PATH      (executables, list of paths)
  94.              (\usr\bin)
  95.              (where make and cc find the components)
  96.        INCLUDEDIR     (std header file path: one path)
  97.                 hcc replaces the builtin paths with this path 
  98.              (\usr\include)
  99.        INCLUDE     list of directories with header files
  100.                      used instead of builtins or $INCLDUEDIR
  101.        LIBDIR     (libraries, startup modules: one path)
  102.              (\usr\lib)
  103.        LIB         list of directories with libraries
  104.                      used instead of builtins or $LIBDIR
  105.        TMPDIR     (temporary files: one path)
  106.              (\usr\tmp)
  107.       If you have not specified a LIBDIR or INCLUDEDIR variable, the builtin
  108.       pathes are searched for if $INCLUDE or $LIB isn't set.
  109.  
  110.       cc or hcc and ld will built their own $LIB / $INCLUDE if these
  111.       variables are not set from the $LIBDIR and $INCLUDEDIR pathes and
  112.       some builtin names. While hcc and ld only handle the 'xdlibs'
  113.       directory in this pathes, cc can switch to different libraries with
  114.       the --mint --c68 and --dlibs options.
  115.       
  116.       So cc assumes to find in the path $INCLUDEDIR the directories
  117.       'xdlibs', 'mntinc' and 'dlibs' with the special library header files 
  118.       in them. A INCLDUE variable built by cc from 
  119.                 INCLUDEDIR=u:\usr\include
  120.       would be:
  121.                 INCLDUE=u:\usr\include\xdlibs,u:\usr\include
  122.  
  123.       A $LIB variable built by cc would be in the same case (default) with a
  124.                 LIBDIR=u:\usr\lib
  125.       specified:
  126.                 LIB=u:\usr\lib\sozobonx\xdlibs,u:\usr\lib\sozobonx
  127.       and with the --mint option:
  128.                 LIB=u:\usr\lib\sozobonx\mntlib,u:\usr\lib\sozobonx
  129.  
  130.  
  131.       2.2 Recommanded Directory Structure
  132.  
  133.       Unpacking the distribution will create this structure in a 
  134.       directory 'sozdistr' but not in '\usr'.
  135.  
  136.     \usr\bin\
  137.         cc.ttp, hcc.ttp, ... (all the executables)
  138.     \usr\include\
  139.             xdlibs\...
  140.             mntinc\...
  141.             dlibs\...
  142.             ... (general header files)
  143.     \usr\lib\
  144.         sozobonx\
  145.             xdlibs\...
  146.             mntlib\...
  147.             dlibs\...
  148.             ... (general SozobonX libraries)
  149.         c68\
  150.            xdlibs\...
  151.            mntlib\...
  152.            ... (general c68 libraries)
  153.  
  154.  
  155.       3. Types and Other Compiler Dependencies
  156.  
  157.       3. 1. The supported data types and their sizes (in bytes) are:
  158.  
  159.        void        0
  160.        char        1
  161.        short       2
  162.        int           2 (switchable to 4)
  163.        long        4
  164.        unsigned char   1
  165.        unsigned short  2
  166.        unsigned int    2 (switchable to 4)
  167.        unsigned long   4
  168.        float       4
  169.        double       4 (soon 8 - IEEE)
  170.        POINTER       4
  171.  
  172.  
  173.       Floating point math is supported using the "Fast Floating Point"
  174.       representation documented by Motorola and implemented by the
  175.       Alcyon compiler.    Both 'float' and 'double' types are supported,
  176.       but are actually identical.  We would like to support the IEEE format
  177.       eventually, but this will have to do for now.
  178.  
  179.       Any of the basic data types may be declared as register variables.
  180.       Pointers occupy the A registers, all other types are placed in D
  181.       registers.  Six data registers and five address registers are
  182.       available for use by register variables.
  183.  
  184.       3.2 Compiler Limits
  185.  
  186.       Some limits imposed by the Sozobon compiler are:
  187.  
  188.      * Local  variables  are  limited to a total of 32K in size per
  189.        function.
  190.  
  191.      * The size of a single structure may not exceed 32K.
  192.  
  193.      * Include files may not be nested more than 8 deep.
  194.  
  195.      * Identifiers may be of any length, and are case significant.
  196.  
  197.      * Arrays may not exceed 0x80000000 bytes, so the largest index of
  198.        a char array is 0x7fffffff. Arrays larger than 64K
  199.        may cause some trouble, but they should work.
  200.  
  201.      * The switch expressions may be of any integer type (char, short,
  202.        or long).
  203.  
  204.       3.3 Constants and implicit types
  205.  
  206.      * The resulting type of sizeof() is unsigned int by default.
  207.        There is a warning generated if sizeof() exceeds 64K, in which
  208.        case you you should assign the sizeof() expression to a long
  209.        variable. If the result exceeds 0x7fffffff Bytes an error
  210.        message is printed.
  211.  
  212.      * Integer constants are of the smallest type they fit in (char,
  213.        short, or long) unless they are noted as octal or hexadecimal
  214.        constants, which are unsigned by default.  You can force a
  215.        constant to be a long value using hexadecimal notation with
  216.        leading '0' characters; '0x0000ff00' will be long like
  217.        '0xff00L'
  218.  
  219.       * Arrays' index expressions are normally casted to long integer.
  220.  
  221.  
  222.       3.4 extensions to K&R compatibility
  223.  
  224.      * bit fields - now standard fields: first in decl is MSB
  225.  
  226.          * long bit fields implemented ( unsigned long foo : 25; )
  227.  
  228.      * enumerations
  229.  
  230.      * structure assignment
  231.  
  232.      * structure parameters
  233.  
  234.      * structure return values
  235.  
  236.      * assembly escapes
  237.  
  238.      * multibyte constants
  239.  
  240.      * ANSI function declarations (with identifiers only!)
  241.  
  242.      * void type, pointer to void
  243.  
  244.      * string concats
  245.  
  246.      * variable Parameters ('...') in function declarations
  247.  
  248.      * all ANSI keywords
  249.  
  250.       Most of the features listed above are self-explanatory.  Assembly
  251.       code can be embedded within C using the following syntax:
  252.  
  253.        asm("assembly code");
  254.  
  255.       The string within quotes is passed directly to the output file.
  256.       It is preceded by a tab, and followed by a newline, so these do
  257.       not need to be given in the string.  Extreme caution should be
  258.       used when running the optimizer on C code that contains assembly
  259.       escapes.    For access to variables put the name of the variable in
  260.       angle-brackets like:
  261.  
  262.           asm(" move.l #1, <i>");
  263.  
  264.       3.5 Missing ANSI C compatibility
  265.  
  266.       Not implemented is:
  267.  
  268.       * type checking of arguments to parameters in function calls
  269.  
  270.       * the keywords const and volatile are not working at all
  271.  
  272.       * '#elif' is not known to the builtin preprocessor
  273.  
  274.       * function declarations without identifiers
  275.  
  276.  
  277.  
  278.       4.0  The components of Sozobon eXtended version
  279.  
  280.  
  281.       The binaries are maintained by different people now! So please
  282.       read in the man files where to send your bugreports. Please mention
  283.       the version and patchlevel you can find with '-V' option or the
  284.       'ident' tool you may have in your enviroment! 
  285.       
  286.       This is not a complete description of all the binaries of Sozobon.
  287.       If you have installed Sozobon completely you will have access to
  288.       the detailed description in the man files (typing 'man <name>' or
  289.       using the ST-Guide HyperText system). Maybe you have printed them.
  290.  
  291.       The excutables will (soon) know all some common options.    The
  292.       directly called ones (make, cc, ar, nm, ipc and mkptypes) will
  293.       accept the following multiletter options:
  294.  
  295.       --version
  296.     Print a detailed version description and exit.
  297.  
  298.       --help
  299.     Print a help-page (short description of all options) and exit.
  300.  
  301.       All will know the following options:
  302.  
  303.       -V (same as --version)
  304.  
  305.       -v verbose output
  306.  
  307.       -h (same as --help) or a usage message (hcc, top, jas, ld)
  308.  
  309.  
  310.       4.1 cc - run the compiler components
  311.  
  312.       The features and options are discribed in file cc.man, which is a
  313.       copy of man\cat1\cc.1 you have copied in your $MANPATH\cat1 directory.
  314.  
  315.       This is the most important program if you use SOZOBONX with
  316.       makefiles or in a cli shell (e.g.  Gemini's console window). It
  317.       will run all the passes to generate an excutable or object
  318.       modules.
  319.  
  320.       The compiler converts your source code to assembly language so
  321.       that the optimizer can optimize it, the assembler can convert it
  322.       to an object file, and the linker can generate an executable from
  323.       it and some library stuff.
  324.  
  325.       cc now supports another compiler, Thorsten Roskowetz's c68 port, too.
  326.       It should be available in an archive 'sozc68<nn>.lzh', including a
  327.       MiNT library for this compiler. Therefore Scotts Bigham's 'cpp' is
  328.       now included in the SozobonX distribution.
  329.  
  330.  
  331.       4.2 hcc - The Compiler
  332.  
  333.       The compiler generates error messages if there are problems with
  334.       your source code.  It includes a preprocessor wich can handle
  335.       statements like:
  336.  
  337.     #assert <expression>
  338.  
  339.       If expression is false the compile session aborts.
  340.  
  341.     #error "string"
  342.  
  343.       The compile session will stop, and error <string> will be
  344.       displayed.
  345.  
  346.     #pragma <option> <arguments>
  347.  
  348.       For information on #pragma commands, see the manual file (hcc.man).
  349.  
  350.  
  351.       The following MACROS are implemented:
  352.       These are'defined', and you can manipulate them:
  353.  
  354.     MC68000, mc68000, SOZOBON (value is 0x200)
  355.     ATARI_ST, TOS,    __TOS__, __SOZOBONX__ (value is current version),
  356.     __MSHORT__ (if ints are of type short)
  357.  
  358.       These conatain strings with usefull information, you can not change
  359.       them, except the first two, with a special preprocessor statement.
  360.       (see man file for more details)
  361.     __LINE__, __FILE__, __BASE_FILE__, __VERSION__
  362.     __TIME__, __DATE__, __SDATE__, __STIME__, __GDATE__
  363.  
  364.  
  365.       The  compiler  uses  the    "normal"  68000  C calling conventions.
  366.       Register    A6  is    used  as  a  frame pointer, and function return
  367.       values  are  placed in D0.
  368.  
  369.       gemdos(), bios() and xbios() calls are replaced by quasi-inline
  370.       functions - the trap instruction is generated.
  371.  
  372.  
  373.       bit fields
  374.       
  375.       Are now standard fields: first bit in decl, or more precise MSB in
  376.       first expession of the bit field declaration is MSB in the whole 
  377.       field.
  378.       There are long bit fields implemented now, exceeding 16 bits for
  379.       single expression: (e.g. unsigned long foo : 25; )
  380.  
  381.  
  382.       4.2.1 Profiling
  383.  
  384.       To use profiling, invoke cc with the -p option.  The compiler will
  385.       generate additional code: At begin of every function a function
  386.          'void _prolog(char funcname[])'    and at end a function
  387.      'void _epilog(char funcname[])'    is called. They count the
  388.       number of calls to each function, and time each call. To get this
  389.       profiling information you have to call the function
  390.          'void _safeprof()'.
  391.  
  392.       All these functions exist in the library (file extended.lib). The
  393.       funktion '_safeprof()' writes all of the profiling stuff to a file
  394.       called '.\prof.out'. If you use the 'prof_s.o' startup module,
  395.       this function is automatically called when your program exits.  cc
  396.       will make use of this startup module if called with option '-p'.
  397.       You can of course repleace these functions by your own ones.
  398.  
  399.       4.2.2 Source Level Debugging
  400.  
  401.       To use source level debugging, invoke cc/hcc with the Option
  402.       '-X<n>[function]'. The compiler generates additional code
  403.       according to level <n> in the option.  You can specify a function
  404.       which is called by this code at the begin and end of every
  405.       function reached at runtime.  In loops this function is usually
  406.       called, too.  If you don't specify a function, only the line
  407.       number and the file name the module was compiled from is saved. 
  408.       You can use the function '_debug' from the library file
  409.       'extended.lib' or write an own function.  If you specify level 2
  410.       with the <n> option this function is called one time for every
  411.       line in the source code.  If you don't specify a function at all,
  412.       the level option is ignored.  The special startup code needed for
  413.       this feature (debug_s.o) will be used by the linker, if you call
  414.       cc with the '-X'option. 
  415.  
  416.       The above mentioned function '_debug()' from libraray archive
  417.       'extended.lib' is the interface to Holger Weets' and Christian
  418.       Wempes's source level debugger. If you specify this function with the
  419.       '-X' option, it is linked into your program.
  420.       This debugger uses BIOS console for output, and assumes 24 lines
  421.       in the output window. It will prompt for an command after
  422.       invocation by the _debug() function:
  423.       --------------
  424.       Sozobon Online Debugger V1.0 -- Written by C. Wempe & H. Weets, 1992
  425.       current position: line <number> of file <source file>
  426.       >
  427.       --------------
  428.       Where line <number> is the number of the line in the <source file>
  429.       from which the current code is compiled.
  430.  
  431.       The following commands are implemented:
  432.  
  433.       ?                       - display this help
  434.       b [file [start [end]]]  - show/set breakpoint and position
  435.       c [start [count]]       - display lines of source file
  436.       f                       - free loaded file
  437.       g [cnt]                 - continue with program
  438.       l [filename]            - Load file (default: actual file)
  439.       m [start [end]]         - memory dump
  440.       n                       - display actual line
  441.       q                       - quit program (call exit)
  442.       r                       - display registers
  443.       t                       - toggle meaning of return key
  444.       x                       - exit debugging (never return)
  445.       reg=value               - set value of register (reg = d0-d7,a0-a7)
  446.       reg&value               - mask register
  447.       [$|%]number             - displays <number> in DEC, BIN and HEX 
  448.  
  449.       4.2.3
  450.  
  451.       For more information and the commandline options see the hcc man
  452.       file (hcc.man)
  453.  
  454.  
  455.       4.3 top - The Optimizer
  456.  
  457.       The optimizer can vastly improve your program;  executed between
  458.       the compiler and the assembler, the optimzer removes segments of
  459.       code that are not efficient and replaces them with code that is.
  460.       When variables can be registered (for faster access) this is also
  461.       done.  For more information about the optimizer, please consult
  462.       the manual file (top.man).
  463.  
  464.  
  465.       4.4  jas - The Assembler
  466.  
  467.       The assembler converts the output of the compiler into an object
  468.       file so that the linker can deal with it.  It can read usual
  469.       Motorola 68000 assembler code, written by hand, too.  For more
  470.       information about the assembler, please consult the manual file
  471.       (jas.man).
  472.  
  473.  
  474.       4.5  ld - The Linker
  475.  
  476.       The linker is the last step performed in a compilation;  it takes
  477.       all of the source code modules of a program and gathers them into
  478.       a single object file, then prepends the startup code to the object
  479.       and takes some used functions from the libraries, to form an
  480.       executable program.  For more information on the linker, please
  481.       consult the ld manual file (ld.man).
  482.  
  483.  
  484.       4.6  The Libraries
  485.  
  486.       SOZOBON eXtended version comes along with XdLibs, based on the the
  487.       dLibs library routines, written by Dale Schumacher.  A GEM library
  488.       is included, too.  It is based on Ian Lepore's GEMfast library.
  489.       A ST-Guide hypertext documentation of the libraries is to find
  490.       in this distribution, made by Michel Forget from XdLibs.doc
  491.       and the other library doc files.
  492.  
  493.       You can tell 'cc' what runtime library you want to be linked; it will
  494.       get the right file and the right starupcode:
  495.  
  496.       default is : (taking libs from 'sozobonx' directory)
  497.       -mshort
  498.      xdlibs/crt0.o (startup) and xdlibs/libc.a (library) for some 
  499.         functions you need ty specify '-lextra' to get 
  500.                 xdlibs/libextra.a as additional library
  501.  
  502.       other options:
  503.       --dlibs
  504.      dstart.o and dlibs.a get used
  505.  
  506.       --mint    (the libraries will soon exist)
  507.      mntlib/ctr0.o and mntlib/libc.a are used
  508.  
  509.       -mlong    (not yet implemented, for the libraries don't exist)
  510.      xdlibs/crt032.o and xdlibs/libc32.a will get used.
  511.  
  512.       --c68    (libraries are taken form c68 directory, not the
  513.               sozobonx one)
  514.  
  515.       4.6.1 Startup Code
  516.  
  517.       The startup code is the entry point of a program, doing some basic
  518.       things, and not at least calling your 'main()' function.
  519.       So the startup modules are used to link programs.  Different moduls
  520.       are in this distribution, the default startup module is 'crt0.o'.
  521.       In the file 'xdlibs.doc' you will find a chapter about startup
  522.       modules.
  523.  
  524.  
  525.       4.6.2  XdLibs  The C Runtime Library
  526.  
  527.       See the file 'xdlibs.doc' for a complete documentation of the runtime
  528.       library. It is available as hyper text file, too.
  529.       The standard library modules are to find in the files 'libc.a'
  530.       and 'libextra.a'. The last one contains rarely used functions and
  531.       extensions to the C standard library.
  532.       With this release 'libc.a' contains all floating point code, too.
  533.  
  534.       One traditional problem with C compilers and floating point is that
  535.       as soon as you call printf(), you wind up linking in a bunch of
  536.       floating point code whether you need it or not.  To avoid this
  537.       problem there is now a different solution:
  538.  
  539.       There is an additional library 'libci.a' which is used by cc unless
  540.       you specify '-f' or '-lm', it's the integer only library with no
  541.       floating point support at all.
  542.       There may be libraries like 'libi.a' e.g. in MiNT directory containing
  543.       printf and scanf routines for integer only programs. You will have to
  544.       write a '-li' in cc's commandline to make use of them.
  545.  
  546.  
  547.       4.6.3  libm.a  The Mathematics Floating Point Library
  548.  
  549.       Just add '-lm' to your commandline and cc will force ld to
  550.       link from the math library 'libm.a'. You don't need an extra '-f'
  551.       cc won't use the integer only library with this argument.
  552.  
  553.       We make no claims regarding the accuracy or speed of the floating
  554.       point code.  This code was thrown together to get something into
  555.       this release, but still needs some work.    Only the basic
  556.       operations are supported.
  557.  
  558.       This time new floating point handling is build in to hcc and a new
  559.       library is in test state. So in next release full IEEE floating point
  560.       is supported by SozobonX.
  561.  
  562.  
  563.       4.6.4 GEM libraries
  564.  
  565.       You will find two GEM libraries in this distribution, xvdifast.a
  566.       and xaesfast.a.  They are bug-fixed and/or extended versions of
  567.       the well known gemfast library.
  568.  
  569.  
  570.       4.6.5 utility libraries
  571.  
  572.       Some utility libraries are added to this distribution (util.a and
  573.       gemlib.a).
  574.  
  575.  
  576.       4.7 make
  577.  
  578.       Now there is a make.man in this distribution, and you will find
  579.       a file make.doc - discussing make in general.
  580.  
  581.       make is a tool to make something, not only programs from source
  582.       code. You can describe what is to do and the relationships among
  583.       the files in a 'makefile'; and each time you change some files the
  584.       simple shell command 'make' suffices to perform all necessary
  585.       actions (recompilations). make knows how to make an executable from
  586.       source files and can learn new rules, too.
  587.  
  588.  
  589.       4.8 ipc  The Include Pre Compiler
  590.  
  591.       This program by Holger Weets will precompile your header files, to
  592.       get them read faster by hcc.  Since header ('*.h') files rarely
  593.       change, this utility was created to allow you to compile them in
  594.       advance so that they do not have to be compiled every time your
  595.       source code is compiled.  This can greatly speed up the
  596.       compilation process.  For more information on the include file
  597.       precompiler, please read the manual file (ipc.man).
  598.  
  599.  
  600.       4.9 mkptypes   Make Function Prototypes
  601.  
  602.       The mkptypes program will generate header files from C source files,
  603.       to be included as global access function declarations in any
  604.       header files, or as static function declarations in your sourcefiles.
  605.       Please read the manual file (mkptypes.man).
  606.  
  607.       4.10 library utilities
  608.  
  609.       4.10.1 nm
  610.  
  611.       The 'nm' program dumps the symbol table of object files,
  612.       libraries, and executables.  The output is not in standard form,
  613.       yet.  See manual (nm.man).
  614.  
  615.       4.10.2 ar
  616.  
  617.       The 'ar' program manages libraries, especially of object modules.
  618.       See manual (ar.man).
  619.  
  620.       4.10.3 har   Holger's Archiver.
  621.  
  622.       This is a 'ar' utility with a GEM/AES interface for interactive
  623.       dealing with library archives.
  624.  
  625.  
  626.       4.11 pflags
  627.  
  628.       The pflags program sets and shows execution flags in the program
  629.       header. See manual for details (pflags.man).
  630.        
  631.  
  632.       4.12 tagfile    Make Tag Files
  633.  
  634.       This utility generates 'tagfiles' from source files, for usage by
  635.       C-Desk and QED/ACE or e.g. your editor - if you can tell it what a
  636.       tagfile is for. The tagfiles are used by the debugger 'debug' to
  637.       get some information about the bug's location, too.
  638.  
  639.  
  640.       4.13 clint
  641.  
  642.       This program is not standard 'lint' utility, but was written by
  643.       Holger Weets for testing and checking source code as well. There is
  644.       no english documentation available this time, maybe soon.
  645.  
  646.  
  647.       4.15 debug    Debugger
  648.  
  649.       A small debugger by Holger Weets just to get some information
  650.       where a exception causing bug is located in your source files.
  651.       (It makes use of existing tagfiles)
  652.  
  653.       4.16 szadb    Debugger
  654.  
  655.       Not in this distribution, I am going to ask Michal Jaegermann
  656.       for support.
  657.  
  658.       4.17 Some unchanged programs from original Sozobon 2.00 distribution:
  659.  
  660.      * The    'size'    utility  prints the size of text, data, and bss
  661.        for objects, libraries, and executables.
  662.  
  663.      * The    'globs'  program  isn't very useful unless you have the
  664.        Alcyon  compiler.  It  removes  local  symbols  from  object
  665.  
  666. -eof-
  667.