Fossil

        </dia:attribute>
        <dia:attribute name="obj_bb">
          <dia:rectangle val="6,14.4575;9.245,16.1975"/>
        </dia:attribute>
        <dia:attribute name="text">
          <dia:composite type="text">
            <dia:attribute name="string">
              <dia:string># 
 belongs to#</dia:string>
            </dia:attribute>
            <dia:attribute name="font">
              <dia:font family="sans" style="0" name="Helvetica"/>
            </dia:attribute>
            <dia:attribute name="height">
              <dia:real val="0.80000000000000004"/>

        </dia:attribute>
        <dia:attribute name="obj_bb">
          <dia:rectangle val="6,2.4575;7.385,4.1975"/>
        </dia:attribute>
        <dia:attribute name="text">
          <dia:composite type="text">
            <dia:attribute name="string">
              <dia:string># 
child#</dia:string>
            </dia:attribute>
            <dia:attribute name="font">
              <dia:font family="sans" style="0" name="Helvetica"/>
            </dia:attribute>
            <dia:attribute name="height">
              <dia:real val="0.80000000000000004"/>

        </dia:attribute>
        <dia:attribute name="obj_bb">
          <dia:rectangle val="4,9.4575;5.385,11.1975"/>
        </dia:attribute>
        <dia:attribute name="text">
          <dia:composite type="text">
            <dia:attribute name="string">
              <dia:string># 
child#</dia:string>
            </dia:attribute>
            <dia:attribute name="font">
              <dia:font family="sans" style="0" name="Helvetica"/>
            </dia:attribute>
            <dia:attribute name="height">
              <dia:real val="0.80000000000000004"/>

        </dia:attribute>
        <dia:attribute name="obj_bb">
          <dia:rectangle val="8,6.4575;10.2797,8.1975"/>
        </dia:attribute>
        <dia:attribute name="text">
          <dia:composite type="text">
            <dia:attribute name="string">
              <dia:string>#   
  parent#</dia:string>
            </dia:attribute>
            <dia:attribute name="font">
              <dia:font family="sans" style="0" name="Helvetica"/>
            </dia:attribute>
            <dia:attribute name="height">
              <dia:real val="0.80000000000000004"/>

typedef __int64 cson_int_t;
#define CSON_INT_T_SFMT "I64d"
#define CSON_INT_T_PFMT "I64d"
#elif (__STDC_VERSION__ >= 199901L) || (HAVE_LONG_LONG == 1)
typedef long long cson_int_t;
#define CSON_INT_T_SFMT "lld"
#define CSON_INT_T_PFMT "lld"
#else 
typedef long cson_int_t;
#define CSON_INT_T_SFMT "ld"
#define CSON_INT_T_PFMT "ld"
#endif

/** @typedef double_or_long_double cson_double_t

/**
   Convenience typedef.
*/
typedef struct cson_value cson_value;

/** @struct cson_value
   
   The core value type of this API. It is opaque to clients, and
   only the cson public API should be used for setting or
   inspecting their values.

   This class is opaque because stack-based usage can easily cause
   leaks if one does not intimately understand the underlying
   internal memory management (which sometimes changes).

   It is (as of 20110323) legal to insert a given value instance into
   multiple containers (they will share ownership using reference
   counting) as long as those insertions do not cause cycles. However,
   be very aware that such value re-use uses a reference to the
   original copy, meaning that if its value is changed once, it is
   changed everywhere. Also beware that multi-threaded write
   operations on such references leads to undefined behaviour.
   
   PLEASE read the ACHTUNGEN below...

   ACHTUNG #1:

   cson_values MUST NOT form cycles (e.g. via object or array
   entries).

   Not abiding th Holy Law Of No Cycles will lead to double-frees and
   the like (i.e. undefined behaviour, likely crashes due to infinite
   recursion or stepping on invalid (freed) pointers).

   ACHTUNG #2:
   
   ALL cson_values returned as non-const cson_value pointers from any
   public functions in the cson API are to be treated as if they are
   heap-allocated, and MUST be freed by client by doing ONE of:
   
   - Passing it to cson_value_free().
   
   - Adding it to an Object or Array, in which case the object/array
   takes over ownership. As of 20110323, a value may be inserted into
   a single container multiple times, or into multiple containers,
   in which case they all share ownership (via reference counting)
   of the original value (meaning any changes to it are visible in
   all references to it).
   
   Each call to cson_value_new_xxx() MUST eventually be followed up
   by one of those options.
   
   Some cson_value_new_XXX() implementations do not actually allocate
   memory, but this is an internal implementation detail. Client code
   MUST NOT rely on this behaviour and MUST treat each object
   returned by such a function as if it was a freshly-allocated copy
   (even if their pointer addresses are the same).
   
   ACHTUNG #3:

   Note that ACHTUNG #2 tells us that we must always free (or transfer
   ownership of) all pointers returned bycson_value_new_xxx(), but
   that two calls to (e.g.) cson_value_new_bool(1) will (or might)
   return the same address. The client must not rely on the
   "non-allocation" policy of such special cases, and must pass each

   @code
   int rc = cson_some_func(...);
   if( 0 == rc ) {...success...}
   else if( cson_rc.ArgError == rc ) { ... some argument was wrong ... }
   else if( cson_rc.AllocError == rc ) { ... allocation error ... }
   ...
   @endcode
   
   The entries named Parse_XXX are generally only returned by
   cson_parse() and friends.
*/

/** @struct cson_rc_
   See \ref cson_rc for details.
*/

     */
    unsigned int col;

    /**
       Length, in bytes.
    */
    unsigned int length;
    
    /**
       Error code of the parse run (0 for no error).
    */
    int errorCode;

    /**
       The total number of object keys successfully processed by the

struct cson_output_opt
{
    /**
       Specifies how to indent (or not) output. The values
       are:

       (0) == no extra indentation.
       
       (1) == 1 TAB character for each level.

       (>1) == that number of SPACES for each level.
    */
    unsigned char indentation;

    /**
       Maximum object/array depth to traverse. Traversing deeply can
       be indicative of cycles in the object/array tree, and this
       value is used to figure out when to abort the traversal.
    */
    unsigned short maxDepth;
    
    /**
       If true, a newline will be added to generated output,
       else not.
    */
    char addNewline;

    /**

   returns, so the implementation must copy or ignore the data, but not
   hold a copy of the src pointer.

   Must return 0 on success, non-0 on error (preferably a value from
   cson_rc).

   These functions are called relatively often during the JSON-output
   process, and should try to be fast.   
*/
typedef int (*cson_data_dest_f)( void * state, void const * src, unsigned int n );

/**
    Reads JSON-formatted string data (in ASCII, UTF8, or UTF16), using the
    src function to fetch all input. This function fetches each input character
    from the source function, which is calls like src(srcState, buffer, bufferSize),

    which contains any settings the caller wants. If it is NULL then
    default settings (the values defined in cson_parse_opt_empty) are
    used.

    The info argument may be NULL. If it is not NULL then the parser
    populates it with information which is useful in error
    reporting. Namely, it contains the line/column of parse errors.
    
    The srcState argument is ignored by this function but is passed on to src,
    so any output-destination-specific state can be stored there and accessed
    via the src callback.
    
    Non-parse error conditions include:

    - (!tgt) or !src: cson_rc.ArgError
    - cson_rc.AllocError can happen at any time during the input phase

    Here's a complete example of using a custom input source:

    cson_parse_FILE() or cson_parse_string().

    TODOs:

    - Buffer the input in larger chunks. We currently read
    byte-by-byte, but i'm too tired to write/test the looping code for
    the buffering.
    
    @see cson_parse_FILE()
    @see cson_parse_string()
*/
int cson_parse( cson_value ** tgt, cson_data_source_f src, void * srcState,
                cson_parse_opt const * opt, cson_parse_info * info );
/**
   A cson_data_source_f() implementation which requires the state argument

   cson_rc.RangeError is returned.

   The destState parameter is ignored by this function and is passed
   on to the dest function.

   Returns 0 on success. On error, any amount of output might have been
   generated before the error was triggered.
   
   Example:

   @code
   int rc = cson_output( myValue, cson_data_dest_FILE, stdout, NULL );
   // basically equivalent to: cson_output_FILE( myValue, stdout, NULL );
   // but note that cson_output_FILE() actually uses different defaults
   // for the output options.

typedef struct cson_string cson_string;

/**
   Converts the given value to a boolean, using JavaScript semantics depending
   on the concrete type of val:

   undef or null: false
   
   boolean: same
   
   integer, double: 0 or 0.0 == false, else true
   
   object, array: true

   string: length-0 string is false, else true.

   Returns 0 on success and assigns *v (if v is not NULL) to either 0 or 1.
   On error (val is NULL) then v is not modified.
*/
int cson_value_fetch_bool( cson_value const * val, char * v );

/**
   Similar to cson_value_fetch_bool(), but fetches an integer value.

   The conversion, if any, depends on the concrete type of val:

   NULL, null, undefined: *v is set to 0 and 0 is returned.
   
   string, object, array: *v is set to 0 and
   cson_rc.TypeError is returned. The error may normally be safely
   ignored, but it is provided for those wanted to know whether a direct
   conversion was possible.

   integer: *v is set to the int value and 0 is returned.
   
   double: *v is set to the value truncated to int and 0 is returned.
*/
int cson_value_fetch_integer( cson_value const * val, cson_int_t * v );

/**
   The same conversions and return values as
   cson_value_fetch_integer(), except that the roles of int/double are

   they are equivalent, or a positive number if lhs is greater-than
   rhs. It has the following rules for equivalence:

   - The maximum number of bytes compared is the lesser of rhsLen and
   the length of lhs. If the strings do not match, but compare equal
   up to the just-described comparison length, the shorter string is
   considered to be less-than the longer one.
   
   - If lhs and rhs are both NULL, or both have a length of 0 then they will
   compare equal.

   - If lhs is null/length-0 but rhs is not then lhs is considered to be less-than
   rhs.

   - If rhs is null/length-0 but lhs is not then rhs is considered to be less-than

/**
   Returns the length, in bytes, of str, or 0 if str is NULL. This is
   an O(1) operation.

   TODO: add cson_string_length_chars() (is O(N) unless we add another
   member to store the char length).
   
   @see cson_string_cstr()
*/
unsigned int cson_string_length_bytes( cson_string const * str );

/**
    Returns the number of UTF8 characters in str. This value will
    be at most as long as cson_string_length_bytes() for the

   freed before inserting the new item.

   ar is expanded, if needed, to be able to hold at least (ndx+1)
   items, and any new entries created by that expansion are empty
   (NULL values).

   On success, 0 is returned and ownership of v is transfered to ar.
  
   On error ownership of v is NOT modified, and the caller may still
   need to clean it up. For example, the following code will introduce
   a leak if this function fails:

   @code
   cson_array_append( myArray, cson_value_new_integer(42) );
   @endcode

   v to ar. On error, ownership of v is not modified. Ownership of ar
   is never changed by this function.

   This is functionally equivalent to
   cson_array_set(ar,cson_array_length_get(ar),v), but this
   implementation has slightly different array-preallocation policy
   (it grows more eagerly).
   
   Returns 0 on success, non-zero on error. Error cases include:

   - ar or v are NULL: cson_rc.ArgError

   - Array cannot be expanded to hold enough elements: cson_rc.AllocError.

   - Appending would cause a numeric overlow in the array's size:

   Alias for cson_value_new_bool(v).
*/
cson_value * cson_new_bool(char v);

/**
   Returns the special JSON "null" value. When outputing JSON,
   its string representation is "null" (without the quotes).
   
   See cson_value_new_bool() for notes regarding the returned
   value's memory.
*/
cson_value * cson_value_null();

/**
   Equivalent to cson_value_new_bool(1).

*/
cson_value * cson_new_double(cson_double_t v);

/**
   Semantically the same as cson_value_new_bool(), but for strings.
   This creates a JSON value which copies the first n bytes of str.
   The string will automatically be NUL-terminated.
   
   Note that if str is NULL or n is 0, this function still
   returns non-NULL value representing that empty string.
   
   Returns NULL on allocation error.
   
   See cson_value_new_bool() for important information about the
   returned memory.
*/
cson_value * cson_value_new_string( char const * str, unsigned int n );

/**
   Allocates a new "object" value and transfers ownership of it to the

/**
   This works like cson_value_new_object() but returns an Object
   handle directly.

   The value handle for the returned object can be fetched with
   cson_object_value(theObject).
   
   Ownership is transfered to the caller, who must eventually free it
   by passing the Value handle (NOT the Object handle) to
   cson_value_free() or passing ownership to a parent container.

   Returns NULL on error (out of memory).
*/
cson_object * cson_new_object();

   value if its reference count drops to 0. Reference counts are
   increased by either inserting the value into a container or via
   cson_value_add_reference(). Even if this function does not
   immediately destroy the value, the value must be considered, from
   the perspective of that client code, to have been
   destroyed/invalidated by this call.

   
   @see cson_value_new_object()
   @see cson_value_new_array()
   @see cson_value_add_reference()
*/
void cson_value_free(cson_value * v);

/**

   cson_object_unset(obj,key). Note that (v==NULL) is treated
   differently from v having the special null value. In the latter
   case, the key is set to the special null value.

   The key may be encoded as ASCII or UTF8. Results are undefined
   with other encodings, and the errors won't show up here, but may
   show up later, e.g. during output.
   
   Returns 0 on success, non-0 on error. It has the following error
   cases:

   - cson_rc.ArgError: obj or key are NULL or strlen(key) is 0.

   - cson_rc.AllocError: an out-of-memory error

   increased refcounts unless they are replacing themselves (which is
   a harmless no-op).
*/
int cson_object_set_s( cson_object * obj, cson_string * key, cson_value * v );

/**
   Removes a property from an object.
   
   If obj contains the given key, it is removed and 0 is returned. If
   it is not found, cson_rc.NotFoundError is returned (which can
   normally be ignored by client code).

   cson_rc.ArgError is returned if obj or key are NULL or key has
   a length of 0.

    and traversing its properties as the path specifies. If a given part of the
    path is not found, then this function fails with cson_rc.NotFoundError.

    If it finds the given path, it returns the value by assiging *tgt
    to it.  If tgt is NULL then this function has no side-effects but
    will return 0 if the given path is found within the object, so it can be used
    to test for existence without fetching it.
    
    Returns 0 if it finds an entry, cson_rc.NotFoundError if it finds
    no item, and any other non-zero error code on a "real" error. Errors include:

   - obj or path are NULL: cson_rc.ArgError
    
    - separator is 0, or path is an empty string or contains only
    separator characters: cson_rc.RangeError

    - There is an upper limit on how long a single path component may
    be (some "reasonable" internal size), and cson_rc.RangeError is
    returned if that length is violated.

    
    Limitations:

    - It has no way to fetch data from arrays this way. i could
    imagine, e.g., a path of "subobj.subArray.0" for
    subobj.subArray[0], or "0.3.1" for [0][3][1]. But i'm too
    lazy/tired to add this.

    Example usage:
    

    Assume we have a JSON structure which abstractly looks like:

    @code
    {"subobj":{"subsubobj":{"myValue":[1,2,3]}}}
    @endcode

    Note that because keys in JSON may legally contain a '.', the
    separator must be specified by the caller. e.g. the path
    "subobj/subsubobj/myValue" with separator='/' is equivalent the
    path "subobj.subsubobj.myValue" with separator='.'. The value of 0
    is not legal as a separator character because we cannot
    distinguish that use from the real end-of-string without requiring
    the caller to also pass in the length of the string.
   
    Multiple successive separators in the list are collapsed into a
    single separator for parsing purposes. e.g. the path "a...b...c"
    (separator='.') is equivalent to "a.b.c".

    @see cson_object_get_sub()
    @see cson_object_get_sub2()
*/

   code.

   @see cson_object_iter_init()
   @see cson_object_iter_next()
*/
struct cson_object_iterator
{
    
    /** @internal
        The underlying object.
    */
    cson_object const * obj;
    /** @internal
        Current position in the property list.
     */

       key = cson_kvp_key(kvp);
       val = cson_kvp_value(kvp);
       ...
   }
   @endcode

   There is no need to clean up an iterator, as it holds no dynamic resources.
   
   @see cson_kvp_key()
   @see cson_kvp_value()
*/
cson_kvp * cson_object_iter_next( cson_object_iterator * iter );


/**

       @code
       void * myptr = buf.mem;
       buf = cson_buffer_empty;
       @endcode

       (You might also need to store buf.used and buf.capacity,
       depending on what you want to do with the memory.)
       
       When doing so, the memory must eventually be passed to free()
       to deallocate it.
    */
    unsigned char * mem;
};
/** Convenience typedef. */
typedef struct cson_buffer cson_buffer;

   contents, and it should not be used except to free its contents.

   On error non-zero is returned. Errors include:

   - Invalid arguments: cson_rc.ArgError

   - Buffer cannot be expanded (runs out of memory): cson_rc.AllocError
   
   Example usage:

   @code
   cson_buffer buf = cson_buffer_empty;
   // optional: cson_buffer_reserve(&buf, 1024 * 10);
   int rc = cson_output_buffer( myValue, &buf, NULL );
   if( 0 != rc ) {

   {
       char * mem = (char *)buf.mem;
       buf = cson_buffer_empty;
       ...
       free(mem);
   }
   @endcode
   
   @see cson_output()
   
*/
int cson_output_buffer( cson_value const * v, cson_buffer * buf,
                        cson_output_opt const * opt );

/**
   This works identically to cson_parse_string(), but takes a
   cson_buffer object as its input.  buf->used bytes of buf->mem are

   Whether or not this function succeeds, dest still owns any memory
   pointed to by dest->mem, and the client must eventually free it by
   calling cson_buffer_reserve(dest,0).

   dest->mem might (and possibly will) be (re)allocated by this
   function, so any pointers to it held from before this call might be
   invalidated by this call.
   
   On error non-0 is returned and dest has almost certainly been
   modified but its state must be considered incomplete.

   Errors include:

   - dest or src are NULL (cson_rc.ArgError)

    @code
    void * mem = buf.mem;
    buf = cson_buffer_empty;
    @endcode

    In which case the memory must eventually be passed to free() to
    free it.    
*/
int cson_buffer_fill_from( cson_buffer * dest, cson_data_source_f src, void * state );


/**
   Increments the reference count for the given value. This is a
   low-level operation and should not normally be used by client code

   point adds a reference and simply passed the value to
   cson_value_free() when they're done. The object will be kept alive
   for other sharing points which added a reference.

   Normally any such value handles would be invalidated when the
   parent container(s) is/are cleaned up, but this function can be
   used to effectively delay the cleanup.
   
   This function, at its lowest level, increments the value's
   reference count by 1.

   To decrement the reference count, pass the value to
   cson_value_free(), after which the value must be considered, from
   the perspective of that client code, to be destroyed (though it
   will not be if there are still other live references to
   it). cson_value_free() will not _actually_ destroy the value until
   its reference count drops to 0.

   Returns 0 on success. The only error conditions are if v is NULL
   (cson_rc.ArgError) or if the reference increment would overflow
   (cson_rc.RangeError). In theory a client would get allocation
   errors long before the reference count could overflow (assuming
   those reference counts come from container insertions, as opposed
   to via this function).

   Insider notes which clients really need to know:
   
   For shared/constant value instances, such as those returned by
   cson_value_true() and cson_value_null(), this function has no side
   effects - it does not actually modify the reference count because
   (A) those instances are shared across all client code and (B) those
   objects are static and never get cleaned up. However, that is an
   implementation detail which client code should not rely on. In
   other words, if you call cson_value_add_reference() 3 times using

   eventually free the value using cson_value_free() or add it to a
   container object/array to transfer ownership to the container. The
   returned object will be of the same logical type as orig.

   ACHTUNG: if orig contains any cyclic references at any depth level
   this function will endlessly recurse. (Having _any_ cyclic
   references violates this library's requirements.)
   
   Returns NULL if orig is NULL or if cloning fails. Assuming that
   orig is in a valid state, the only "likely" error case is that an
   allocation fails while constructing the clone. In other words, if
   cloning fails due to something other than an allocation error then
   either orig is in an invalid state or there is a bug.

   When this function clones Objects or Arrays it shares any immutable

   --key : Treats key as a boolean with a true value.

   --key=VAL : Treats VAL as either a double, integer, or string.

   --key= : Treats key as a JSON null (not literal NULL) value.

   Arguments not starting with a dash are skipped.
   
   Each key/value pair is inserted into an object.  If a given key
   appears more than once then only the final entry is actually
   stored.

   argc and argv are expected to be values from main() (or similar,
   possibly adjusted to remove argv[0]).

   type depending on the field type reported by sqlite3_column_type(st,col):

   Integer, double, null, or string (TEXT and BLOB data, though not
   all blob data is legal for a JSON string).

   st must be a sqlite3_step()'d row and col must be a 0-based column
   index within that result row.
 */       
cson_value * cson_sqlite3_column_to_value( sqlite3_stmt * st, int col );

/**
   Creates a JSON Array object containing the names of all columns
   of the given prepared statement handle. 
    
   Returns a new array value on success, which the caller owns. Its elements
   are in the same order as in the underlying query.

   On error NULL is returned.
    
   st is not traversed or freed by this function - only the column
   count and names are read.
*/
cson_value * cson_sqlite3_column_names( sqlite3_stmt * st );

/**
   Creates a JSON Object containing key/value pairs corresponding

   value which contains the JSON-form values of the given result
   set row.
*/
cson_value * cson_sqlite3_row_to_array( sqlite3_stmt * st );
/**
    Converts the results of an sqlite3 SELECT statement to JSON,
    in the form of a cson_value object tree.
    
    st must be a prepared, but not yet traversed, SELECT query.
    tgt must be a pointer to NULL (see the example below). If
    either of those arguments are NULL, cson_rc.ArgError is returned.
    
    This walks the query results and returns a JSON object which
    has a different structure depending on the value of the 'fat'
    argument.
    
    
    If 'fat' is 0 then the structure is:
    
    @code
    {
        "columns":["colName1",..."colNameN"],
        "rows":[
            [colVal0, ... colValN],
            [colVal0, ... colValN],
            ...
        ]
    }
    @endcode
    
    In the "non-fat" format the order of the columns and row values is
    guaranteed to be the same as that of the underlying query.
    
    If 'fat' is not 0 then the structure is:
    
    @code
    {
        "columns":["colName1",..."colNameN"],
        "rows":[
            {"colName1":value1,..."colNameN":valueN},
            {"colName1":value1,..."colNameN":valueN},
            ...

    change when passed through different JSON implementations,
    depending on how they implement object key/value pairs.

    On success it returns 0 and assigns *tgt to a newly-allocated
    JSON object tree (using the above structure), which the caller owns.
    If the query returns no rows, the "rows" value will be an empty
    array, as opposed to null.
    
    On error non-0 is returned and *tgt is not modified.
    
    The error code cson_rc.IOError is used to indicate a db-level
    error, and cson_rc.TypeError is returned if sqlite3_column_count(st)
    returns 0 or less (indicating an invalid or non-SELECT statement).
    
    The JSON data types are determined by the column type as reported
    by sqlite3_column_type():
    
    SQLITE_INTEGER: integer
    
    SQLITE_FLOAT: double
    
    SQLITE_TEXT or SQLITE_BLOB: string, and this will only work if
    the data is UTF8 compatible.
    
    If the db returns a literal or SQL NULL for a value it is converted
    to a JSON null. If it somehow finds a column type it cannot handle,
    the value is also converted to a NULL in the output.

    Example
    
    @code
    cson_value * json = NULL;
    int rc = cson_sqlite3_stmt_to_json( myStatement, &json, 1 );
    if( 0 != rc ) { ... error ... }
    else {
        cson_output_FILE( json, stdout, NULL );
        cson_value_free( json );

   position (starting and ndx, though the array uses 0-based offsets).

   TODO: add Object support for named parameters.

   Returns 0 on success, non-0 on error.
 */
int cson_sqlite3_bind_value( sqlite3_stmt * st, int ndx, cson_value const * v );
    
#if defined(__cplusplus)
} /*extern "C"*/
#endif
    
#endif /* CSON_ENABLE_SQLITE3 */
#endif /* WANDERINGHORSE_NET_CSON_SQLITE3_H_INCLUDED */
/* end file include/wh/cson/cson_sqlite3.h */
#endif /* FOSSIL_ENABLE_JSON */

  }

  /* Output strings for all the help text */
  for(i=0; i<nFixed; i++){
    char *z = aEntry[i].zHelp;
    if( z==0 ) continue;
    if( aEntry[i].zIf ) printf("%s", aEntry[i].zIf);
    printf("static const char zHelp%03d[] = \n", aEntry[i].iHelp);
    printf("  \"");
    while( *z ){
      if( *z=='\n' ){
        printf("\\n\"\n  \"");
      }else if( *z=='"' ){
        printf("\\\"");
      }else{
        putchar(*z);

%!PS-Adobe-3.0 EPSF-3.0 
%%BoundingBox: 0 0 249 284
%%Pages: 0
%%Creator: Sun Microsystems, Inc.
%%Title: none
%%CreationDate: none
%%LanguageLevel: 2
%%EndComments

%%EndProlog
%%BeginSetup
%%EndSetup
%%Page: 1 1
%%BeginPageSetup
%%EndPageSetup
pum
0.02835 0.02837 s 
0 -10008 t
/tm matrix currentmatrix def
tm setmatrix
-4875 -2599 t 
1 1 s 
0.500 c 7207 8311 m  7036 8281 6990 7727 7105 7073 ct 7221 6420 7453 5915 7625 5945 ct 
7796 5975 7842 6529 7727 7183 ct 7612 7836 7379 8342 7207 8311 ct p ef
7607 10301 m  7445 10335 7221 9926 7107 9387 ct 6992 8847 7030 8382 7192 8348 ct 
7354 8313 7578 8723 7693 9262 ct 7807 9802 7769 10267 7607 10301 ct p ef
8749 11736 m  8626 11826 8289 11574 7995 11173 ct 7701 10773 7563 10375 7686 10285 ct 
7809 10195 8146 10446 8440 10847 ct 8734 11248 8872 11645 8749 11736 ct p ef
10691 12070 m  10668 12234 10205 12303 9658 12223 ct 9111 12143 8686 11946 8710 11782 ct 
8734 11618 9197 11550 9744 11629 ct 10291 11709 10715 11906 10691 12070 ct p ef
10761 12053 m  10721 11951 11064 11722 11526 11541 ct 11989 11360 12396 11296 12436 11398 ct 
12476 11500 12134 11729 11671 11910 ct 11208 12091 10801 12155 10761 12053 ct 
p ef
12410 11353 m  12365 11314 12499 11087 12709 10847 ct 12920 10607 13126 10444 13171 10483 ct 
13216 10522 13082 10749 12872 10989 ct 12662 11230 12455 11392 12410 11353 ct 
p ef
7901 12525 m  7790 12525 7700 12212 7700 11826 ct 7700 11440 7790 11127 7901 11127 ct 
8012 11127 8102 11440 8102 11826 ct 8102 12212 8012 12525 7901 12525 ct p ef
7826 12575 m  7765 12668 7415 12547 7044 12306 ct 6672 12064 6420 11793 6480 11700 ct 
6541 11607 6891 11728 7262 11970 ct 7634 12211 7886 12482 7826 12575 ct p ef
6460 11694 m  6435 11723 6333 11673 6234 11584 ct 6134 11494 6073 11399 6099 11371 ct 
6124 11343 6225 11392 6325 11482 ct 6425 11571 6485 11666 6460 11694 ct p ef
13183 10437 m  13129 10414 13185 10157 13309 9863 ct 13433 9569 13579 9350 13633 9373 ct 
13688 9396 13632 9653 13508 9947 ct 13384 10241 13238 10460 13183 10437 ct p ef
9900 11524 m  9790 11524 9701 11211 9701 10825 ct 9701 10439 9790 10126 9900 10126 ct 
10009 10126 10098 10439 10098 10825 ct 10098 11211 10009 11524 9900 11524 ct 
p ef
9828 11574 m  9767 11667 9417 11546 9046 11305 ct 8674 11063 8422 10792 8482 10699 ct 
8543 10606 8893 10727 9264 10969 ct 9636 11210 9888 11481 9828 11574 ct p ef
6085 9230 m  5976 9131 6097 8819 6357 8533 ct 6616 8247 6915 8095 7024 8194 ct 
7133 8293 7012 8605 6752 8892 ct 6493 9178 6194 9329 6085 9230 ct p ef
5910 9182 m  5805 9210 5629 8884 5516 8456 ct 5403 8027 5396 7657 5501 7629 ct 
5605 7601 5782 7927 5895 8356 ct 6008 8784 6014 9154 5910 9182 ct p ef
8630 9345 m  8548 9270 8691 8978 8951 8692 ct 9210 8406 9487 8234 9569 8309 ct 
9651 8383 9507 8675 9248 8961 ct 8989 9247 8712 9419 8630 9345 ct p ef
8566 9556 m  8478 9624 8188 9394 7918 9043 ct 7647 8692 7499 8352 7587 8285 ct 
7675 8217 7965 8447 8235 8798 ct 8506 9149 8654 9489 8566 9556 ct p ef
6579 11626 m  6549 11638 6480 11543 6425 11413 ct 6371 11283 6352 11167 6382 11154 ct 
6412 11141 6481 11237 6535 11367 ct 6590 11497 6609 11613 6579 11626 ct p ef
5952 11674 m  5959 11642 6081 11642 6223 11674 ct 6366 11707 6475 11759 6468 11791 ct 
6461 11823 6339 11823 6197 11790 ct 6054 11758 5945 11706 5952 11674 ct p ef
5384 7615 m  5359 7644 5257 7594 5158 7505 ct 5058 7415 4997 7320 5023 7292 ct 
5048 7264 5149 7313 5249 7403 ct 5349 7492 5409 7587 5384 7615 ct p ef
5503 7547 m  5473 7559 5404 7464 5349 7334 ct 5295 7204 5276 7088 5306 7075 ct 
5336 7062 5405 7158 5459 7288 ct 5514 7418 5533 7534 5503 7547 ct p ef
4875 7595 m  4882 7562 5004 7563 5147 7595 ct 5289 7628 5399 7680 5392 7712 ct 
5385 7744 5263 7744 5120 7711 ct 4977 7679 4868 7627 4875 7595 ct p ef
9764 8248 m  9739 8220 9798 8125 9898 8036 ct 9997 7946 10097 7897 10123 7925 ct 
10148 7952 10088 8047 9989 8137 ct 9890 8226 9789 8276 9764 8248 ct p ef
9641 8179 m  9611 8167 9631 8051 9685 7920 ct 9740 7790 9809 7694 9839 7707 ct 
9869 7720 9850 7836 9795 7966 ct 9741 8097 9672 8192 9641 8179 ct p ef
10269 8227 m  10276 8259 10167 8311 10024 8343 ct 9882 8375 9760 8375 9753 8343 ct 
9746 8311 9856 8259 9998 8227 ct 10141 8195 10262 8195 10269 8227 ct p ef
9749 10085 m  9724 10113 9623 10064 9523 9974 ct 9424 9885 9363 9790 9389 9762 ct 
9414 9734 9515 9783 9615 9872 ct 9714 9961 9775 10057 9749 10085 ct p ef
9868 10017 m  9838 10029 9770 9934 9715 9804 ct 9661 9674 9641 9558 9671 9545 ct 
9702 9533 9770 9628 9824 9758 ct 9879 9888 9898 10004 9868 10017 ct p ef
9242 10064 m  9249 10032 9371 10032 9513 10064 ct 9656 10097 9765 10149 9758 10181 ct 
9751 10213 9629 10213 9487 10180 ct 9344 10148 9235 10096 9242 10064 ct p ef
6841 4401 m  6726 4212 7272 3670 8061 3191 ct 8849 2711 9581 2475 9696 2664 ct 
9811 2853 9265 3395 8477 3875 ct 7688 4355 6956 4590 6841 4401 ct p ef
9097 6042 m  8862 6353 8161 6221 7532 5745 ct 6902 5270 6583 4632 6818 4321 ct 
7053 4009 7754 4142 8384 4617 ct 9013 5092 9333 5730 9097 6042 ct p ef
7880 5222 m  7747 5124 7957 4611 8349 4075 ct 8742 3540 9168 3185 9302 3283 ct 
9435 3381 9225 3894 8833 4430 ct 8440 4965 8014 5320 7880 5222 ct p ef
9003 6100 m  8784 6059 8750 5255 8927 4303 ct 9103 3351 9423 2612 9642 2652 ct 
9861 2693 9895 3498 9719 4450 ct 9543 5401 9222 6140 9003 6100 ct p ef
0 10008 t 
pom
count op_count sub {pop} repeat countdictstack dict_count sub {end} repeat b4_inc_state restore
%%PageTrailer
%%Trailer
%%EOF

%!PS-Adobe-3.0 EPSF-3.0 
%%BoundingBox: 0 0 555 735
%%Pages: 0
%%Creator: Sun Microsystems, Inc.
%%Title: none
%%CreationDate: none
%%LanguageLevel: 2
%%EndComments

%%EndProlog
%%BeginSetup
%%EndSetup
%%Page: 1 1
%%BeginPageSetup
%%EndPageSetup
pum
0.02833 0.02833 s 
0 -25940 t
/tm matrix currentmatrix def
gs
tm setmatrix
-1000 -1000 t 
1 1 s 
1000 1000 m 20589 1000 l 20589 26939 l 1000 26939 l 1000 1000 l eoclip newpath
gs
1000 1000 m 20589 1000 l 20589 26939 l 1000 26939 l 1000 1000 l eoclip newpath
1000 1000 m 20590 1000 l 20590 26940 l 1000 26940 l 1000 1000 l eoclip newpath
0.500 c 7207 8311 m  7036 8281 6989 7726 7104 7073 ct 7220 6420 7453 5913 7624 5944 ct 
7796 5974 7842 6529 7727 7182 ct 7612 7835 7378 8341 7207 8311 ct p ef
7607 10301 m  7446 10335 7220 9925 7106 9386 ct 6991 8847 7030 8381 7191 8347 ct 
7353 8312 7578 8723 7693 9262 ct 7807 9800 7768 10267 7607 10301 ct p ef
8749 11736 m  8627 11825 8288 11574 7995 11173 ct 7701 10772 7562 10374 7685 10284 ct 
7808 10194 8146 10446 8440 10847 ct 8734 11247 8872 11646 8749 11736 ct p ef
10683 12127 m  10664 12260 10204 12303 9657 12224 ct 9111 12145 8683 11972 8702 11840 ct 
8721 11707 9181 11664 9727 11743 ct 10274 11822 10702 11995 10683 12127 ct p ef
10761 12053 m  10721 11951 11064 11721 11526 11540 ct 11989 11359 12397 11296 12437 11397 ct 
12477 11499 12134 11729 11671 11910 ct 11209 12091 10801 12154 10761 12053 ct 
p ef
12410 11353 m  12366 11314 12500 11087 12710 10847 ct 12920 10607 13127 10444 13171 10483 ct 
13216 10522 13082 10749 12872 10989 ct 12662 11229 12455 11392 12410 11353 ct 
p ef
7901 12525 m  7790 12525 7700 12212 7700 11826 ct 7700 11440 7790 11127 7901 11127 ct 
8012 11127 8102 11440 8102 11826 ct 8102 12212 8012 12525 7901 12525 ct p ef
7825 12576 m  7765 12669 7414 12548 7043 12306 ct 6671 12065 6419 11793 6479 11700 ct 
6540 11607 6891 11728 7262 11969 ct 7633 12211 7886 12483 7825 12576 ct p ef
6460 11695 m  6434 11723 6333 11674 6233 11584 ct 6133 11495 6072 11399 6098 11371 ct 
6123 11342 6225 11392 6325 11481 ct 6425 11571 6485 11666 6460 11695 ct p ef
13184 10437 m  13129 10414 13185 10156 13309 9862 ct 13434 9569 13580 9349 13634 9372 ct 
13688 9395 13632 9653 13508 9947 ct 13384 10240 13238 10460 13184 10437 ct p ef
9899 11524 m  9790 11524 9700 11211 9700 10825 ct 9700 10439 9790 10126 9899 10126 ct 
10008 10126 10098 10439 10098 10825 ct 10098 11211 10008 11524 9899 11524 ct 
p ef
9827 11575 m  9767 11668 9416 11547 9045 11305 ct 8673 11064 8421 10792 8481 10699 ct 
8542 10606 8893 10727 9264 10968 ct 9635 11210 9888 11482 9827 11575 ct p ef
6085 9230 m  5976 9132 6098 8819 6357 8533 ct 6616 8247 6915 8096 7024 8194 ct 
7133 8293 7012 8605 6753 8892 ct 6493 9178 6194 9329 6085 9230 ct p ef
5910 9183 m  5806 9210 5629 8885 5516 8456 ct 5403 8028 5396 7658 5501 7630 ct 
5605 7602 5782 7928 5895 8357 ct 6008 8785 6014 9155 5910 9183 ct p ef
8630 9344 m  8547 9270 8691 8977 8950 8691 ct 9209 8405 9486 8234 9568 8308 ct 
9650 8383 9507 8675 9248 8961 ct 8989 9247 8712 9419 8630 9344 ct p ef
8566 9557 m  8478 9625 8187 9395 7917 9044 ct 7646 8693 7498 8353 7586 8285 ct 
7674 8217 7965 8448 8235 8799 ct 8505 9150 8654 9490 8566 9557 ct p ef
6578 11626 m  6548 11638 6479 11543 6424 11413 ct 6370 11283 6351 11166 6381 11153 ct 
6412 11141 6481 11236 6535 11366 ct 6589 11496 6609 11613 6578 11626 ct p ef
5952 11673 m  5959 11641 6081 11641 6224 11674 ct 6366 11706 6476 11759 6469 11791 ct 
6462 11823 6340 11823 6197 11791 ct 6055 11758 5945 11706 5952 11673 ct p ef
5384 7616 m  5358 7644 5257 7595 5157 7505 ct 5057 7416 4996 7320 5022 7292 ct 
5047 7263 5149 7313 5249 7402 ct 5349 7492 5409 7587 5384 7616 ct p ef
5502 7547 m  5472 7559 5403 7464 5348 7334 ct 5294 7204 5275 7087 5305 7074 ct 
5336 7062 5405 7157 5459 7287 ct 5513 7417 5533 7534 5502 7547 ct p ef
4875 7594 m  4882 7562 5004 7562 5147 7594 ct 5289 7627 5399 7679 5392 7712 ct 
5385 7744 5263 7744 5120 7711 ct 4978 7679 4868 7626 4875 7594 ct p ef
9763 8248 m  9738 8220 9798 8124 9897 8035 ct 9996 7946 10097 7896 10122 7924 ct 
10147 7951 10087 8047 9988 8136 ct 9889 8225 9787 8275 9763 8248 ct p ef
9639 8179 m  9608 8166 9628 8050 9682 7920 ct 9737 7790 9806 7694 9836 7707 ct 
9867 7719 9847 7836 9793 7966 ct 9739 8096 9669 8192 9639 8179 ct p ef
10269 8228 m  10277 8260 10166 8312 10024 8344 ct 9881 8376 9759 8376 9752 8344 ct 
9745 8311 9855 8259 9998 8227 ct 10140 8195 10262 8196 10269 8228 ct p ef
9749 10085 m  9724 10113 9622 10064 9523 9975 ct 9424 9886 9363 9791 9388 9762 ct 
9414 9734 9516 9784 9615 9872 ct 9714 9961 9774 10057 9749 10085 ct p ef
9868 10017 m  9839 10029 9770 9933 9715 9803 ct 9661 9673 9642 9557 9671 9544 ct 
9701 9532 9770 9628 9824 9758 ct 9879 9888 9898 10004 9868 10017 ct p ef
9242 10063 m  9249 10031 9371 10031 9514 10064 ct 9656 10096 9766 10149 9759 10181 ct 
9752 10213 9630 10213 9487 10181 ct 9345 10148 9235 10096 9242 10063 ct p ef
6841 4401 m  6726 4212 7272 3669 8060 3190 ct 8848 2710 9581 2475 9696 2664 ct 
9811 2853 9265 3396 8477 3875 ct 7689 4354 6956 4590 6841 4401 ct p ef
9098 6041 m  8863 6352 8161 6220 7532 5745 ct 6903 5271 6583 4632 6818 4321 ct 
7053 4009 7755 4142 8384 4617 ct 9013 5091 9333 5730 9098 6041 ct p ef
7879 5222 m  7746 5124 7956 4610 8348 4075 ct 8740 3540 9167 3185 9300 3283 ct 
9433 3380 9224 3895 8832 4430 ct 8440 4964 8012 5319 7879 5222 ct p ef
9004 6100 m  8786 6059 8751 5255 8927 4303 ct 9103 3351 9424 2612 9642 2652 ct 
9861 2693 9896 3498 9719 4449 ct 9543 5401 9222 6140 9004 6100 ct p ef
106 lw 1 lj 9435 13668 m  9429 13652 l  9421 13637 l  9412 13622 l  9401 13607 l 
9390 13593 l  9377 13579 l  9363 13565 l  9347 13552 l  9331 13539 l  9313 13526 l 
9295 13515 l  9275 13503 l  9254 13493 l  9233 13482 l  9211 13473 l  9188 13464 l 
9164 13456 l  9139 13448 l  9114 13441 l  9088 13435 l  9062 13430 l  9035 13425 l 
9008 13422 l  8981 13419 l  8953 13416 l  8925 13415 l  8898 13414 l  8870 13414 l 
8842 13415 l  8814 13417 l  8787 13419 l  8759 13422 l  8732 13426 l  8706 13431 l 
8680 13437 l  8654 13443 l  8629 13450 l  8605 13458 l  8581 13466 l  8558 13475 l 
8536 13485 l  8514 13495 l  8494 13506 l  8475 13517 l  8456 13529 l  8439 13542 l 
8423 13555 l  8408 13568 l  8394 13582 l  8381 13596 l  8370 13611 l  8360 13626 l 
8351 13641 l  8344 13656 l  8338 13672 l  8333 13687 l  8330 13703 l  8328 13719 l 
8327 13735 l  8328 13751 l  8330 13767 l  8334 13783 l  8338 13798 l  8345 13814 l 
8352 13829 l  8361 13844 l  8372 13859 l  8383 13874 l  8396 13888 l  8410 13902 l 
8425 13915 l  8441 13928 l  8459 13940 l  8477 13952 l  8497 13964 l  8517 13974 l 
8539 13985 l  8561 13994 l  8584 14003 l  8608 14011 l  8632 14019 l  8657 14026 l 
8683 14032 l  8709 14037 l  8736 14042 l  8763 14046 l  8790 14049 l  8818 14052 l 
8846 14053 l  8873 14054 l  8901 14054 l  8929 14053 l  8957 14051 l  ps
8347 14443 m  8354 14459 l  8362 14474 l  8371 14489 l  8382 14504 l  8394 14518 l 
8407 14533 l  8421 14546 l  8436 14560 l  8453 14573 l  8471 14585 l  8490 14597 l 
8510 14608 l  8530 14619 l  8552 14629 l  8575 14639 l  8598 14647 l  8622 14656 l 
8647 14663 l  8673 14670 l  8699 14676 l  8725 14681 l  8752 14685 l  8779 14689 l 
8807 14692 l  8835 14694 l  8863 14695 l  8891 14696 l  8919 14696 l  8947 14695 l 
8975 14693 l  9002 14690 l  9030 14687 l  9057 14682 l  9083 14677 l  9109 14672 l 
9135 14665 l  9160 14658 l  9184 14650 l  9208 14641 l  9231 14632 l  9253 14622 l 
9274 14612 l  9294 14600 l  9313 14589 l  9332 14576 l  9349 14564 l  9364 14550 l 
9379 14537 l  9393 14523 l  9405 14508 l  9416 14494 l  9425 14479 l  9434 14463 l 
9441 14448 l  9446 14432 l  9451 14416 l  9453 14400 l  9455 14384 l  9455 14368 l 
9453 14352 l  9451 14336 l  9446 14320 l  9441 14305 l  9434 14289 l  9426 14274 l 
9416 14259 l  9405 14244 l  9393 14230 l  9380 14216 l  9365 14202 l  9349 14189 l 
9332 14176 l  9314 14164 l  9295 14152 l  9275 14141 l  9254 14130 l  9232 14120 l 
9209 14111 l  9185 14102 l  9161 14094 l  9136 14087 l  9110 14081 l  9084 14075 l 
9057 14070 l  9030 14066 l  9003 14062 l  8975 14059 l  8948 14057 l  ps
10974 13668 m  10968 13652 l  10960 13637 l  10951 13622 l  10940 13607 l 
10929 13593 l  10916 13579 l  10902 13565 l  10886 13552 l  10870 13539 l 
10853 13526 l  10834 13515 l  10814 13503 l  10794 13493 l  10772 13482 l 
10750 13473 l  10727 13464 l  10703 13456 l  10679 13448 l  10653 13441 l 
10628 13435 l  10602 13430 l  10575 13425 l  10548 13422 l  10521 13419 l 
10493 13416 l  10465 13415 l  10438 13414 l  10410 13414 l  10382 13415 l 
10354 13417 l  10327 13419 l  10300 13422 l  10273 13426 l  10246 13431 l 
10220 13437 l  10194 13443 l  10169 13450 l  10145 13458 l  10121 13466 l 
10098 13475 l  10076 13485 l  10055 13495 l  10035 13506 l  10015 13517 l 
9997 13529 l  9980 13542 l  9964 13555 l  9949 13568 l  9935 13582 l  9922 13596 l 
9911 13611 l  9901 13626 l  9892 13641 l  9885 13656 l  9879 13672 l  9874 13687 l 
9871 13703 l  9869 13719 l  9868 13735 l  9869 13751 l  9871 13767 l  9875 13783 l 
9879 13798 l  9886 13814 l  9893 13829 l  9902 13844 l  9912 13859 l  9924 13874 l 
9937 13888 l  9951 13902 l  9966 13915 l  9982 13928 l  10000 13940 l 
10018 13952 l  10037 13964 l  10058 13974 l  10079 13985 l  10101 13994 l 
10124 14003 l  10148 14011 l  10173 14019 l  10198 14026 l  10223 14032 l 
10250 14037 l  10276 14042 l  10303 14046 l  10330 14049 l  10358 14052 l 
10386 14053 l  10413 14054 l  10441 14054 l  10469 14053 l  10497 14051 l 
ps
9888 14443 m  9895 14459 l  9903 14474 l  9912 14489 l  9923 14504 l  9934 14518 l 
9948 14533 l  9962 14546 l  9977 14560 l  9994 14573 l  10012 14585 l 
10031 14597 l  10050 14608 l  10071 14619 l  10093 14629 l  10115 14639 l 
10139 14647 l  10163 14656 l  10188 14663 l  10213 14670 l  10239 14676 l 
10265 14681 l  10292 14685 l  10320 14689 l  10347 14692 l  10375 14694 l 
10403 14695 l  10431 14696 l  10459 14696 l  10487 14695 l  10514 14693 l 
10542 14690 l  10569 14687 l  10596 14682 l  10623 14677 l  10649 14672 l 
10675 14665 l  10700 14658 l  10724 14650 l  10748 14641 l  10770 14632 l 
10792 14622 l  10813 14612 l  10834 14600 l  10853 14589 l  10871 14576 l 
10888 14564 l  10904 14550 l  10918 14537 l  10932 14523 l  10944 14508 l 
10955 14494 l  10965 14479 l  10973 14463 l  10980 14448 l  10985 14432 l 
10990 14416 l  10992 14400 l  10994 14384 l  10994 14368 l  10992 14352 l 
10990 14336 l  10986 14320 l  10980 14305 l  10973 14289 l  10965 14274 l 
10955 14259 l  10944 14244 l  10932 14230 l  10919 14216 l  10904 14202 l 
10888 14189 l  10871 14176 l  10853 14164 l  10834 14152 l  10814 14141 l 
10793 14130 l  10771 14120 l  10748 14111 l  10725 14102 l  10700 14094 l 
10675 14087 l  10650 14081 l  10624 14075 l  10597 14070 l  10570 14066 l 
10543 14062 l  10515 14059 l  10488 14057 l  ps
7205 14684 m  6849 14684 6559 14412 6559 14078 ct 6559 13744 6849 13472 7205 13472 ct 
7561 13472 7851 13744 7851 14078 ct 7851 14412 7561 14684 7205 14684 ct pc
5427 13589 m  5427 14657 l  ps
5374 13560 m  6242 13560 l  ps
5374 13914 m  6090 13914 l  ps
11776 13397 m  11776 14697 l  ps
12625 13414 m  12625 14680 l  ps
12577 14640 m  13493 14640 l  ps
gr
gs
1000 1000 m 20589 1000 l 20589 26939 l 1000 26939 l 1000 1000 l eoclip newpath
gr
gr
0 25940 t 
pom
count op_count sub {pop} repeat countdictstack dict_count sub {end} repeat b4_inc_state restore
%%PageTrailer
%%Trailer
%%EOF

other artifact.</p>

<blockquote>
<b>file</b> <i>artifact-id size</i> <b>\n</b> <i>content</i><br>
<b>file</b> <i>artifact-id delta-artifact-id size</i> <b>\n</b> <i>content</i>
</blockquote>

<p>File cards are followed by in-line "payload" data.  
The content of the artifact
or the artifact delta is the first <i>size</i> bytes of the
x-fossil content that immediately follow the newline that
terminates the file card.
</p>

<p>The first argument of a file card is the ID of the artifact that