cfar.txt

OXCC is a multipass, interpreting C compiler with several language extensions. It generates an Archi

CFAR.TXT Version 2

A .cff archive is maintained with `cfar' which works in a similar manner
to ar. The notable difference about .cff archives is their ability to hold
multiple libraries and multiply defined symbols. The user can store up to
4096 libraries for each of 16 library types. A library contains .o files
in a.out or coff format. Symbols may not be multiply defined within one library.
Since .cff filesystems have database characteristics, the entries are
automatically cross indexed in various ways and provide very fast access
to a particular module or symbol. Nothing precludes the user from combining
archival and other data within the same .cff file. .o files are stored
as data chunks within libraries, they have a sibling .x chunk which is a packet
of globally defined symbols in the .o chunk and a sibling .t chunk which
contains the external filetime and origin path. Chunks have very low overhead,
they are allocated in 32 byte increments.

Ordinary files may be entered into the archive by using the -F switch. These
files can be stored as normal files or as chunks. Chunks are fixed size and
thus cannot be written past the stored EOF. The archiver records the source
path for each ordinary file so that the -M switch can print commands which
would recreate the archive. Files entered with the -F switch are known as
FILEMODE files.

The executable code for `cfar.o' is normally stored in oxlib.cff.

Read CFF.TXT to learn more about .cff filesystems.

Standard (reserved) symbols in the root directory of a .cff archive.

    ArVeR       version number of archive
    SN0         a serial number supplier
    SN1         ditto
    SN2         ditto

Standard (reserved) subdirectories within .cff archives:

    `/msyms'     cross indexed symbols
    `/ipaths'    cross indexed paths to .o files in libraries
    `/qipaths'   quick access path info
    `/origins'   paths to outside origns of the archived .o files
    `/qorigins'  quick access origin info
    `/fipaths'   internal paths to FILEMODE files    
    `/ltype0'    library types 0
        `/ltype0/lib0'      library 0 type 0
        `/ltype0/lib1'      library 1 type 0
        ...
        `/ltype0/lib4095'   library 4095 type 0
    ...
    `/ltype15'   library types 15
        `/ltype15/lib0'      library 0 type 15
         ...
        `/ltype15/lib4095'   library 4095 type 15
  
Currently, the following library types are in use:
 Type
  0    random collections of modules such as libc.a libm.a etc.
  1    class libraries	(a single class occupies a single .o file)
  2    subsystem libraries (a single subsystem occupies a single .o file)
  3    symbols found in dlls
  4-7  to be defined
  8    source code for the random modules
  9    source code for classes
  10   source code for subsystems
  11   source code for dll substitute functions
  12-15 to be defined


Usage: cfar [-acdflmrstvxCDFMNS] cfpath [file...]
    Switch -- Meaning
    a         Add file, do not overwrite
    c         Check input files against library for clashes
    d         Delete file
    f         Freshen the archive (replace outdated files)
    l#        Place file in libnum #, min:0 max:4095
    m         Print archive map to stdout
    r         Replace/Add file
    s         `file' is a symbol name not a file name (for extract/delete)
    t#        Set libtype # 0=module, 1=class, 2=subsystem, max:15
    v         Verbose
    x         Extract file
    M         Print to stdout, commands which would recreate the archive
    S         Shrink archive (eliminate unused space)
    D         DLLMODE, symbols and dlls from a dlldef.xxx file
    F         FILEMODE, symbols not saved or checked
    C         If FILEMODE, put file in a chunk
    N         If FILEMODE, give input file a new name (last part of cfpath)

Examples:

    cfar -rt1l6 oxlib.cff *.o      // enter a bunch of .o files into
                                   // library 6 type 1 (classes)

    cfar -dl2S oxlib.cff func.o    // delete func.o from library 2
                                   // type 0 and shrink the archive
	
    cfar -mv oxlib.cff > oxlib.map // print a verbose map of the contents
                                   // oxlib.cff and store it in oxlib.map

    cfar -xt2l5s oxlib.cff _main   // extract the module in library 5
                                   // type 2 which defines the symbol
                                   // _main

    cfar -al4 oxlib.cff libc.a     // add libc.a to library 4 type 0

    cfar -cl4 oxlib.cff libc.a     // check libc.a against the contents
                                   // of library 4 type 0 and print any 
                                   // symbol clashes

    cfar -rv oxlib.cff libm.a      // add/replace the contents of libm.a
                                   // to library 0 type 0, verbosely

    cfar -Dr oxlib.cff dlldef.w32  // add/replace the symbols for win32 dlls
                                   // into msyms, use libtype=3

    cfar -FCa oxlib.cff/lang c.grm // add the ordinary file c.grm to the
                                   // subdirectory /lang and store it as a
                                   // chunk (the subdir will be created if
                                   // it does not exist)

    cfar -FNa oxlib.cff/new.c xx.c // add the ordinary file xx.c to the root
                                   // directory and give it a new name, new.c

    cfar -Fd oxlib.cff/lang/c.grm  // delete the ordinary file /lang/c.grm

    cfar -Fx oxlib.cff/new.c       // extract the ordinary file /new.c

    cfar -f oxlib.cff              // freshen all the entries
	
    cfar -M oxlib.cff > oxlib.bat  // print a .bat file which would 
	                               // recreate the archive