<MACRO>
<NAME>GSF_INPUT_BONOBO_TYPE</NAME>
#define GSF_INPUT_BONOBO_TYPE        (gsf_input_bonobo_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_INPUT_BONOBO</NAME>
#define GSF_INPUT_BONOBO(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_INPUT_BONOBO_TYPE, GsfInputBonobo))
</MACRO>
<MACRO>
<NAME>GSF_IS_INPUT_BONOBO</NAME>
#define GSF_IS_INPUT_BONOBO(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_INPUT_BONOBO_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfInputBonobo</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_input_bonobo_get_type</NAME>
<RETURNS>GType     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_bonobo_new</NAME>
<RETURNS>GsfInput *</RETURNS>
Bonobo_Stream const stream, GError **err
</FUNCTION>
<MACRO>
<NAME>GSF_INPUT_GNOMEVFS_TYPE</NAME>
#define GSF_INPUT_GNOMEVFS_TYPE        (gsf_input_gnomevfs_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_INPUT_GNOMEVFS</NAME>
#define GSF_INPUT_GNOMEVFS(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_INPUT_GNOMEVFS_TYPE, GsfInputGnomeVFS))
</MACRO>
<MACRO>
<NAME>GSF_IS_INPUT_GNOMEVFS</NAME>
#define GSF_IS_INPUT_GNOMEVFS(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_INPUT_GNOMEVFS_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfInputGnomeVFS</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_input_gnomevfs_get_type</NAME>
<RETURNS>GType	  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_gnomevfs_new</NAME>
<RETURNS>GsfInput *</RETURNS>
char const *uri, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_gnomevfs_new_uri</NAME>
<RETURNS>GsfInput *</RETURNS>
GnomeVFSURI *uri, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_gnomevfs_needs_local_copy</NAME>
<RETURNS>gboolean  </RETURNS>
GsfInputGnomeVFS *vfs_input
</FUNCTION>
<MACRO>
<NAME>GSF_OUTPUT_BONOBO_TYPE</NAME>
#define GSF_OUTPUT_BONOBO_TYPE        (gsf_output_bonobo_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTPUT_BONOBO</NAME>
#define GSF_OUTPUT_BONOBO(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTPUT_BONOBO_TYPE, GsfOutputBonobo))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTPUT_BONOBO</NAME>
#define GSF_IS_OUTPUT_BONOBO(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTPUT_BONOBO_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfOutputBonobo</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_output_bonobo_get_type</NAME>
<RETURNS>GType      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_bonobo_new</NAME>
<RETURNS>GsfOutput *</RETURNS>
Bonobo_Stream const stream, GError **err
</FUNCTION>
<MACRO>
<NAME>GSF_OUTPUT_GNOMEVFS_TYPE</NAME>
#define GSF_OUTPUT_GNOMEVFS_TYPE        (gsf_output_gnomevfs_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTPUT_GNOMEVFS</NAME>
#define GSF_OUTPUT_GNOMEVFS(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTPUT_GNOMEVFS_TYPE, GsfOutputGnomeVFS))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTPUT_GNOMEVFS</NAME>
#define GSF_IS_OUTPUT_GNOMEVFS(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTPUT_GNOMEVFS_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfOutputGnomeVFS</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_output_gnomevfs_get_type</NAME>
<RETURNS>GType	   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_gnomevfs_new</NAME>
<RETURNS>GsfOutput *</RETURNS>
char const *filename, GError **err
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_gnomevfs_new_uri</NAME>
<RETURNS>GsfOutput *</RETURNS>
GnomeVFSURI * uri, GError **err
</FUNCTION>
<MACRO>
<NAME>GSF_SHARED_BONOBO_STREAM_TYPE</NAME>
#define GSF_SHARED_BONOBO_STREAM_TYPE	(gsf_shared_bonobo_stream_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_SHARED_BONOBO_STREAM</NAME>
#define GSF_SHARED_BONOBO_STREAM(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_SHARED_BONOBO_STREAM_TYPE, GsfSharedBonoboStream))
</MACRO>
<MACRO>
<NAME>GSF_IS_SHARED_BONOBO_STREAM</NAME>
#define GSF_IS_SHARED_BONOBO_STREAM(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_SHARED_BONOBO_STREAM_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfSharedBonoboStream</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfSharedBonoboStream</NAME>
struct _GsfSharedBonoboStream {
	GObject g_object;
	Bonobo_Stream stream;
	CORBA_long pos;
};
</STRUCT>
<FUNCTION>
<NAME>gsf_shared_bonobo_stream_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_shared_bonobo_stream_new</NAME>
<RETURNS>GsfSharedBonoboStream *</RETURNS>
Bonobo_Stream stream
</FUNCTION>
<MACRO>
<NAME>GSF_DOCPROP_VECTOR_TYPE</NAME>
#define GSF_DOCPROP_VECTOR_TYPE	 (gsf_docprop_vector_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_DOCPROP_VECTOR</NAME>
#define GSF_DOCPROP_VECTOR(o)	 (G_TYPE_CHECK_INSTANCE_CAST((o), GSF_DOCPROP_VECTOR, GsfDocPropVector))
</MACRO>
<MACRO>
<NAME>IS_GSF_DOCPROP_VECTOR</NAME>
#define IS_GSF_DOCPROP_VECTOR(o) (G_TYPE_CHECK_INSTANCE_TYPE((o), GSF_DOCPROP_VECTOR_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfDocPropVector</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_docprop_vector_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_docprop_vector_new</NAME>
<RETURNS>GsfDocPropVector *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_docprop_vector_append</NAME>
<RETURNS>void		  </RETURNS>
GsfDocPropVector *vector, GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gsf_docprop_vector_as_string</NAME>
<RETURNS>gchar		 *</RETURNS>
GsfDocPropVector const *vector
</FUNCTION>
<MACRO>
<NAME>VAL_IS_GSF_DOCPROP_VECTOR</NAME>
#define VAL_IS_GSF_DOCPROP_VECTOR(v) (G_TYPE_CHECK_VALUE_TYPE((v), GSF_DOCPROP_VECTOR_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_value_get_docprop_vector</NAME>
<RETURNS>GsfDocPropVector *</RETURNS>
GValue const *value
</FUNCTION>
<FUNCTION>
<NAME>gsf_value_get_docprop_varray</NAME>
<RETURNS>GValueArray	 *</RETURNS>
GValue const *value
</FUNCTION>
<MACRO>
<NAME>GSF_OUTPUT_MEMORY_TYPE</NAME>
#define GSF_OUTPUT_MEMORY_TYPE	(gsf_output_memory_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTPUT_MEMORY</NAME>
#define GSF_OUTPUT_MEMORY(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTPUT_MEMORY_TYPE, GsfOutputMemory))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTPUT_MEMORY</NAME>
#define GSF_IS_OUTPUT_MEMORY(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTPUT_MEMORY_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfOutputMemory</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_output_memory_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_memory_new</NAME>
<RETURNS>GsfOutput *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_memory_get_bytes</NAME>
<RETURNS>const guint8*</RETURNS>
GsfOutputMemory * mem
</FUNCTION>
<MACRO>
<NAME>GSF_INPUT_STDIO_TYPE</NAME>
#define GSF_INPUT_STDIO_TYPE        (gsf_input_stdio_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_INPUT_STDIO</NAME>
#define GSF_INPUT_STDIO(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_INPUT_STDIO_TYPE, GsfInputStdio))
</MACRO>
<MACRO>
<NAME>GSF_IS_INPUT_STDIO</NAME>
#define GSF_IS_INPUT_STDIO(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_INPUT_STDIO_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfInputStdio</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_input_stdio_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_stdio_new</NAME>
<RETURNS>GsfInput *</RETURNS>
char const *filename, GError **err
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_stdio_new_FILE</NAME>
<RETURNS>GsfInput *</RETURNS>
char const *filename, FILE *file,gboolean keep_open
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_memory_new_from_iochannel</NAME>
<RETURNS>GsfInput *</RETURNS>
GIOChannel *channel,GError    **error
</FUNCTION>
<MACRO>
<NAME>GSF_INPUT_GZIP_TYPE</NAME>
#define GSF_INPUT_GZIP_TYPE        (gsf_input_gzip_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_INPUT_GZIP</NAME>
#define GSF_INPUT_GZIP(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_INPUT_GZIP_TYPE, GsfInputGZip))
</MACRO>
<MACRO>
<NAME>GSF_IS_INPUT_GZIP</NAME>
#define GSF_IS_INPUT_GZIP(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_INPUT_GZIP_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfInputGZip</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_input_gzip_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_gzip_new</NAME>
<RETURNS>GsfInput *</RETURNS>
GsfInput *source, GError **err
</FUNCTION>
<MACRO>
<NAME>GSF_STRUCTURED_BLOB_TYPE</NAME>
#define GSF_STRUCTURED_BLOB_TYPE        (gsf_structured_blob_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_STRUCTURED_BLOB</NAME>
#define GSF_STRUCTURED_BLOB(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_STRUCTURED_BLOB_TYPE, GsfStructuredBlob))
</MACRO>
<MACRO>
<NAME>GSF_IS_STRUCTURED_BLOB</NAME>
#define GSF_IS_STRUCTURED_BLOB(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_STRUCTURED_BLOB_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfStructuredBlob</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_structured_blob_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_structured_blob_read</NAME>
<RETURNS>GsfStructuredBlob *</RETURNS>
GsfInput *input
</FUNCTION>
<FUNCTION>
<NAME>gsf_structured_blob_write</NAME>
<RETURNS>gboolean	   </RETURNS>
GsfStructuredBlob *blob,GsfOutfile *container
</FUNCTION>
<MACRO>
<NAME>ZIP_HEADER_SIZE</NAME>
#define ZIP_HEADER_SIZE 		30
</MACRO>
<MACRO>
<NAME>ZIP_HEADER_VERSION</NAME>
#define ZIP_HEADER_VERSION 		 4
</MACRO>
<MACRO>
<NAME>ZIP_HEADER_OS</NAME>
#define ZIP_HEADER_OS	 		 5
</MACRO>
<MACRO>
<NAME>ZIP_HEADER_FLAGS</NAME>
#define ZIP_HEADER_FLAGS 	         6
</MACRO>
<MACRO>
<NAME>ZIP_HEADER_COMP_METHOD</NAME>
#define ZIP_HEADER_COMP_METHOD           8
</MACRO>
<MACRO>
<NAME>ZIP_HEADER_TIME</NAME>
#define ZIP_HEADER_TIME                 10
</MACRO>
<MACRO>
<NAME>ZIP_HEADER_CRC</NAME>
#define ZIP_HEADER_CRC 			14
</MACRO>
<MACRO>
<NAME>ZIP_HEADER_COMP_SIZE</NAME>
#define ZIP_HEADER_COMP_SIZE		18
</MACRO>
<MACRO>
<NAME>ZIP_HEADER_UNCOMP_SIZE</NAME>
#define ZIP_HEADER_UNCOMP_SIZE          22
</MACRO>
<MACRO>
<NAME>ZIP_HEADER_NAME_LEN</NAME>
#define ZIP_HEADER_NAME_LEN		26
</MACRO>
<MACRO>
<NAME>ZIP_HEADER_EXTRA_LEN</NAME>
#define ZIP_HEADER_EXTRA_LEN		28
</MACRO>
<MACRO>
<NAME>ZIP_TRAILER_SIZE</NAME>
#define ZIP_TRAILER_SIZE 		22
</MACRO>
<MACRO>
<NAME>ZIP_TRAILER_DISK</NAME>
#define ZIP_TRAILER_DISK 		4
</MACRO>
<MACRO>
<NAME>ZIP_TRAILER_DIR_DISK</NAME>
#define ZIP_TRAILER_DIR_DISK 		6
</MACRO>
<MACRO>
<NAME>ZIP_TRAILER_ENTRIES</NAME>
#define ZIP_TRAILER_ENTRIES 		8
</MACRO>
<MACRO>
<NAME>ZIP_TRAILER_TOTAL_ENTRIES</NAME>
#define ZIP_TRAILER_TOTAL_ENTRIES 	10
</MACRO>
<MACRO>
<NAME>ZIP_TRAILER_DIR_SIZE</NAME>
#define ZIP_TRAILER_DIR_SIZE 		12
</MACRO>
<MACRO>
<NAME>ZIP_TRAILER_DIR_POS</NAME>
#define ZIP_TRAILER_DIR_POS 		16
</MACRO>
<MACRO>
<NAME>ZIP_TRAILER_COMMENT_SIZE</NAME>
#define ZIP_TRAILER_COMMENT_SIZE	20
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_SIZE</NAME>
#define ZIP_DIRENT_SIZE                 46
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_ENCODER</NAME>
#define ZIP_DIRENT_ENCODER              4
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_EXTRACT</NAME>
#define ZIP_DIRENT_EXTRACT              6
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_FLAGS</NAME>
#define ZIP_DIRENT_FLAGS                8
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_COMPR_METHOD</NAME>
#define ZIP_DIRENT_COMPR_METHOD         10
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_DOSTIME</NAME>
#define ZIP_DIRENT_DOSTIME              12
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_CRC32</NAME>
#define ZIP_DIRENT_CRC32                16
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_CSIZE</NAME>
#define ZIP_DIRENT_CSIZE                20
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_USIZE</NAME>
#define ZIP_DIRENT_USIZE                24
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_NAME_SIZE</NAME>
#define ZIP_DIRENT_NAME_SIZE            28
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_EXTRAS_SIZE</NAME>
#define ZIP_DIRENT_EXTRAS_SIZE          30
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_COMMENT_SIZE</NAME>
#define ZIP_DIRENT_COMMENT_SIZE         32
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_DISKSTART</NAME>
#define ZIP_DIRENT_DISKSTART            34
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_FILE_TYPE</NAME>
#define ZIP_DIRENT_FILE_TYPE            36
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_FILE_MODE</NAME>
#define ZIP_DIRENT_FILE_MODE            38
</MACRO>
<MACRO>
<NAME>ZIP_DIRENT_OFFSET</NAME>
#define ZIP_DIRENT_OFFSET               42
</MACRO>
<MACRO>
<NAME>ZIP_FILE_HEADER_SIZE</NAME>
#define ZIP_FILE_HEADER_SIZE            30
</MACRO>
<MACRO>
<NAME>ZIP_FILE_HEADER_EXTRACT</NAME>
#define ZIP_FILE_HEADER_EXTRACT          4
</MACRO>
<MACRO>
<NAME>ZIP_FILE_HEADER_FLAGS</NAME>
#define ZIP_FILE_HEADER_FLAGS            6
</MACRO>
<MACRO>
<NAME>ZIP_FILE_HEADER_COMPR_METHOD</NAME>
#define ZIP_FILE_HEADER_COMPR_METHOD     8
</MACRO>
<MACRO>
<NAME>ZIP_FILE_HEADER_DOSTIME</NAME>
#define ZIP_FILE_HEADER_DOSTIME         10
</MACRO>
<MACRO>
<NAME>ZIP_FILE_HEADER_CRC32</NAME>
#define ZIP_FILE_HEADER_CRC32           14
</MACRO>
<MACRO>
<NAME>ZIP_FILE_HEADER_CSIZE</NAME>
#define ZIP_FILE_HEADER_CSIZE           18
</MACRO>
<MACRO>
<NAME>ZIP_FILE_HEADER_USIZE</NAME>
#define ZIP_FILE_HEADER_USIZE           22
</MACRO>
<MACRO>
<NAME>ZIP_FILE_HEADER_NAME_SIZE</NAME>
#define ZIP_FILE_HEADER_NAME_SIZE       26
</MACRO>
<MACRO>
<NAME>ZIP_FILE_HEADER_EXTRAS_SIZE</NAME>
#define ZIP_FILE_HEADER_EXTRAS_SIZE     28
</MACRO>
<MACRO>
<NAME>ZIP_NAME_SEPARATOR</NAME>
#define ZIP_NAME_SEPARATOR    '/'
</MACRO>
<MACRO>
<NAME>ZIP_BLOCK_SIZE</NAME>
#define ZIP_BLOCK_SIZE 32768
</MACRO>
<MACRO>
<NAME>ZIP_BUF_SIZE</NAME>
#define ZIP_BUF_SIZE 512
</MACRO>
<MACRO>
<NAME>ZZIP_IS_ENCRYPTED</NAME>
#define ZZIP_IS_ENCRYPTED(p)    ((*(unsigned char*)p)&1)
</MACRO>
<MACRO>
<NAME>ZZIP_IS_COMPRLEVEL</NAME>
#define ZZIP_IS_COMPRLEVEL(p)  (((*(unsigned char*)p)>>1)&3)
</MACRO>
<MACRO>
<NAME>ZZIP_IS_STREAMED</NAME>
#define ZZIP_IS_STREAMED(p)    (((*(unsigned char*)p)>>3)&1)
</MACRO>
<STRUCT>
<NAME>GsfZipDirent</NAME>
typedef struct {	
	char                    *name;
	GsfZipCompressionMethod  compr_method;
	guint32                  crc32;
	size_t                   csize;
	size_t                   usize;
	gsf_off_t                offset;
	gsf_off_t                data_offset;
	guint32                  dostime;
} GsfZipDirent;
</STRUCT>
<STRUCT>
<NAME>GsfZipVDir</NAME>
typedef struct {
	char *name;
	gboolean is_directory;
	GsfZipDirent *dirent;
	GSList *children, *last_child;
} GsfZipVDir;
</STRUCT>
<FUNCTION>
<NAME>gsf_zip_dirent_new</NAME>
<RETURNS>GsfZipDirent *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_zip_dirent_free</NAME>
<RETURNS>void          </RETURNS>
GsfZipDirent *dirent
</FUNCTION>
<FUNCTION>
<NAME>gsf_vdir_new</NAME>
<RETURNS>GsfZipVDir *</RETURNS>
char const *name, gboolean is_directory,GsfZipDirent *dirent
</FUNCTION>
<FUNCTION>
<NAME>gsf_vdir_free</NAME>
<RETURNS>void	    </RETURNS>
GsfZipVDir *vdir, gboolean free_dirent
</FUNCTION>
<FUNCTION>
<NAME>gsf_vdir_add_child</NAME>
<RETURNS>void	    </RETURNS>
GsfZipVDir *vdir, GsfZipVDir *child
</FUNCTION>
<MACRO>
<NAME>GSF_OUTPUT_IOCHANNEL_TYPE</NAME>
#define GSF_OUTPUT_IOCHANNEL_TYPE	(gsf_output_iochannel_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTPUT_IOCHANNEL</NAME>
#define GSF_OUTPUT_IOCHANNEL(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTPUT_IOCHANNEL_TYPE, GsfOutputIOChannel))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTPUT_IOCHANNEL</NAME>
#define GSF_IS_OUTPUT_IOCHANNEL(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTPUT_IOCHANNEL_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfOutputIOChannel</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_output_iochannel_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_iochannel_new</NAME>
<RETURNS>GsfOutput *</RETURNS>
GIOChannel * channel
</FUNCTION>
<MACRO>
<NAME>GSF_OUTPUT_BZIP_TYPE</NAME>
#define GSF_OUTPUT_BZIP_TYPE        (gsf_output_bzip_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTPUT_BZIP</NAME>
#define GSF_OUTPUT_BZIP(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTPUT_BZIP_TYPE, GsfOutputBzip))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTPUT_BZIP</NAME>
#define GSF_IS_OUTPUT_BZIP(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTPUT_BZIP_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfOutputBzip</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_output_bzip_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_bzip_new</NAME>
<RETURNS>GsfOutput *</RETURNS>
GsfOutput *sink, GError **err
</FUNCTION>
<STRUCT>
<NAME>GsfInfileZip</NAME>
</STRUCT>
<MACRO>
<NAME>GSF_INFILE_ZIP_TYPE</NAME>
#define GSF_INFILE_ZIP_TYPE        (gsf_infile_zip_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_INFILE_ZIP</NAME>
#define GSF_INFILE_ZIP(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_INFILE_ZIP_TYPE, GsfInfileZip))
</MACRO>
<MACRO>
<NAME>GSF_IS_INFILE_ZIP</NAME>
#define GSF_IS_INFILE_ZIP(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_INFILE_ZIP_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_infile_zip_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_infile_zip_new</NAME>
<RETURNS>GsfInfile *</RETURNS>
GsfInput *source, GError **err
</FUNCTION>
<MACRO>
<NAME>GSF_META_NAME_CREATOR</NAME>
#define GSF_META_NAME_CREATOR				"dc:creator"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_DATE_MODIFIED</NAME>
#define GSF_META_NAME_DATE_MODIFIED			"dc:date"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_DESCRIPTION</NAME>
#define GSF_META_NAME_DESCRIPTION			"dc:description"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_KEYWORDS</NAME>
#define GSF_META_NAME_KEYWORDS				"dc:keywords"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_LANGUAGE</NAME>
#define GSF_META_NAME_LANGUAGE				"dc:language"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_CODEPAGE</NAME>
#define	GSF_META_NAME_CODEPAGE				"msole:codepage"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_SUBJECT</NAME>
#define GSF_META_NAME_SUBJECT				"dc:subject"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_TITLE</NAME>
#define GSF_META_NAME_TITLE				"dc:title"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_BYTE_COUNT</NAME>
#define GSF_META_NAME_BYTE_COUNT			"gsf:byte-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_CASE_SENSITIVE</NAME>
#define GSF_META_NAME_CASE_SENSITIVE			"gsf:case-sensitivity"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_CATEGORY</NAME>
#define GSF_META_NAME_CATEGORY				"gsf:category"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_CELL_COUNT</NAME>
#define GSF_META_NAME_CELL_COUNT			"gsf:cell-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_CHARACTER_COUNT</NAME>
#define GSF_META_NAME_CHARACTER_COUNT			"gsf:character-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_DICTIONARY</NAME>
#define GSF_META_NAME_DICTIONARY			"gsf:dictionary"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_DOCUMENT_PARTS</NAME>
#define GSF_META_NAME_DOCUMENT_PARTS			"gsf:document-parts"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_HEADING_PAIRS</NAME>
#define GSF_META_NAME_HEADING_PAIRS			"gsf:heading-pairs"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_HIDDEN_SLIDE_COUNT</NAME>
#define GSF_META_NAME_HIDDEN_SLIDE_COUNT		"gsf:hidden-slide-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_IMAGE_COUNT</NAME>
#define GSF_META_NAME_IMAGE_COUNT           		"gsf:image-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_LAST_SAVED_BY</NAME>
#define GSF_META_NAME_LAST_SAVED_BY         		"gsf:last-saved-by"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_LINKS_DIRTY</NAME>
#define GSF_META_NAME_LINKS_DIRTY			"gsf:links-dirty"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_LOCALE_SYSTEM_DEFAULT</NAME>
#define GSF_META_NAME_LOCALE_SYSTEM_DEFAULT		"gsf:default-locale"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_MANAGER</NAME>
#define GSF_META_NAME_MANAGER				"gsf:manager"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_PRESENTATION_FORMAT</NAME>
#define GSF_META_NAME_PRESENTATION_FORMAT		"gsf:presentation-format"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_SCALE</NAME>
#define GSF_META_NAME_SCALE				"gsf:scale"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_SECURITY</NAME>
#define GSF_META_NAME_SECURITY				"gsf:security"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_THUMBNAIL</NAME>
#define GSF_META_NAME_THUMBNAIL				"gsf:thumbnail"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_LINE_COUNT</NAME>
#define GSF_META_NAME_LINE_COUNT			"gsf:line-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_MM_CLIP_COUNT</NAME>
#define GSF_META_NAME_MM_CLIP_COUNT			"gsf:MM-clip-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_NOTE_COUNT</NAME>
#define GSF_META_NAME_NOTE_COUNT			"gsf:note-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_OBJECT_COUNT</NAME>
#define GSF_META_NAME_OBJECT_COUNT			"gsf:object-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_PAGE_COUNT</NAME>
#define GSF_META_NAME_PAGE_COUNT			"gsf:page-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_PARAGRAPH_COUNT</NAME>
#define GSF_META_NAME_PARAGRAPH_COUNT			"gsf:paragraph-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_SLIDE_COUNT</NAME>
#define GSF_META_NAME_SLIDE_COUNT			"gsf:slide-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_SPREADSHEET_COUNT</NAME>
#define GSF_META_NAME_SPREADSHEET_COUNT			"gsf:spreadsheet-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_TABLE_COUNT</NAME>
#define GSF_META_NAME_TABLE_COUNT			"gsf:table-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_WORD_COUNT</NAME>
#define GSF_META_NAME_WORD_COUNT			"gsf:word-count"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_MSOLE_UNKNOWN_17</NAME>
#define GSF_META_NAME_MSOLE_UNKNOWN_17			"msole:unknown-doc-17"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_MSOLE_UNKNOWN_18</NAME>
#define GSF_META_NAME_MSOLE_UNKNOWN_18			"msole:unknown-doc-18"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_MSOLE_UNKNOWN_19</NAME>
#define GSF_META_NAME_MSOLE_UNKNOWN_19			"msole:unknown-doc-19"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_MSOLE_UNKNOWN_20</NAME>
#define GSF_META_NAME_MSOLE_UNKNOWN_20			"msole:unknown-doc-20"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_MSOLE_UNKNOWN_21</NAME>
#define GSF_META_NAME_MSOLE_UNKNOWN_21			"msole:unknown-doc-21"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_MSOLE_UNKNOWN_22</NAME>
#define GSF_META_NAME_MSOLE_UNKNOWN_22			"msole:unknown-doc-22"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_MSOLE_UNKNOWN_23</NAME>
#define GSF_META_NAME_MSOLE_UNKNOWN_23			"msole:unknown-doc-23"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_DATE_CREATED</NAME>
#define GSF_META_NAME_DATE_CREATED			"meta:creation-date"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_EDITING_DURATION</NAME>
#define GSF_META_NAME_EDITING_DURATION			"meta:editing-duration"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_GENERATOR</NAME>
#define GSF_META_NAME_GENERATOR				"meta:generator"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_KEYWORD</NAME>
#define GSF_META_NAME_KEYWORD				"meta:keyword"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_INITIAL_CREATOR</NAME>
#define GSF_META_NAME_INITIAL_CREATOR			"meta:initial-creator"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_COMPANY</NAME>
#define GSF_META_NAME_COMPANY				"dc:publisher"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_PRINT_DATE</NAME>
#define GSF_META_NAME_PRINT_DATE			"meta:print-date"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_LAST_PRINTED</NAME>
#define GSF_META_NAME_LAST_PRINTED			"gsf:last-printed"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_PRINTED_BY</NAME>
#define GSF_META_NAME_PRINTED_BY			"meta:printed-by"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_REVISION_COUNT</NAME>
#define GSF_META_NAME_REVISION_COUNT			"meta:editing-cycles"
</MACRO>
<MACRO>
<NAME>GSF_META_NAME_TEMPLATE</NAME>
#define GSF_META_NAME_TEMPLATE				"meta:template"
</MACRO>
<STRUCT>
<NAME>GsfInput</NAME>
struct _GsfInput {
	GObject   g_object;

	gsf_off_t    size, cur_offset;
	char      *name;
	GsfInfile *container;
};
</STRUCT>
<STRUCT>
<NAME>GsfInputClass</NAME>
typedef struct {
	GObjectClass g_object_class;

	GsfInput     *(*Dup)  (GsfInput *input, GError **err);
	const guint8 *(*Read) (GsfInput *input, size_t num_bytes,
			       guint8 *optional_buffer);
	gboolean      (*Seek) (GsfInput *input, gsf_off_t offset,
			       GSeekType whence);
	GsfInput     *(*OpenSibling)  (GsfInput const *input,
				       char const *path, GError **err);

	/* Padding for future expansion */
	void (*_gsf_reserved0) (void);
	void (*_gsf_reserved1) (void);
	void (*_gsf_reserved2) (void);
	void (*_gsf_reserved3) (void);
} GsfInputClass;
</STRUCT>
<MACRO>
<NAME>GSF_INPUT_CLASS</NAME>
#define GSF_INPUT_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST ((k), GSF_INPUT_TYPE, GsfInputClass))
</MACRO>
<MACRO>
<NAME>GSF_IS_INPUT_CLASS</NAME>
#define GSF_IS_INPUT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GSF_INPUT_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_input_set_name</NAME>
<RETURNS>gboolean </RETURNS>
GsfInput *input, char const *name
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_set_name_from_filename</NAME>
<RETURNS>gboolean </RETURNS>
GsfInput *input, char const *filename
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_set_container</NAME>
<RETURNS>gboolean </RETURNS>
GsfInput *input, GsfInfile *container
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_set_size</NAME>
<RETURNS>gboolean </RETURNS>
GsfInput *input, gsf_off_t size
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_seek_emulate</NAME>
<RETURNS>gboolean </RETURNS>
GsfInput *input, gsf_off_t pos
</FUNCTION>
<MACRO>
<NAME>GSF_INPUT_PROXY_TYPE</NAME>
#define GSF_INPUT_PROXY_TYPE        (gsf_input_proxy_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_INPUT_PROXY</NAME>
#define GSF_INPUT_PROXY(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_INPUT_PROXY_TYPE, GsfInputProxy))
</MACRO>
<MACRO>
<NAME>GSF_IS_INPUT_PROXY</NAME>
#define GSF_IS_INPUT_PROXY(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_INPUT_PROXY_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfInputProxy</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_input_proxy_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_proxy_new</NAME>
<RETURNS>GsfInput *</RETURNS>
GsfInput *source
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_proxy_new_section</NAME>
<RETURNS>GsfInput *</RETURNS>
GsfInput *source,gsf_off_t offset,gsf_off_t size
</FUNCTION>
<FUNCTION>
<NAME>gsf_opendoc_metadata_read</NAME>
<RETURNS>GError	*</RETURNS>
GsfInput *input,  GsfDocMetaData *md
</FUNCTION>
<FUNCTION>
<NAME>gsf_opendoc_metadata_subtree</NAME>
<RETURNS>void	 </RETURNS>
GsfXMLIn *doc,    GsfDocMetaData *md
</FUNCTION>
<FUNCTION>
<NAME>gsf_opendoc_metadata_write</NAME>
<RETURNS>gboolean </RETURNS>
GsfXMLOut *output, GsfDocMetaData const *md
</FUNCTION>
<MACRO>
<NAME>GSF_INPUT_MEMORY_TYPE</NAME>
#define GSF_INPUT_MEMORY_TYPE	(gsf_input_memory_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_INPUT_MEMORY</NAME>
#define GSF_INPUT_MEMORY(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_INPUT_MEMORY_TYPE, GsfInputMemory))
</MACRO>
<MACRO>
<NAME>GSF_IS_INPUT_MEMORY</NAME>
#define GSF_IS_INPUT_MEMORY(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_INPUT_MEMORY_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfInputMemory</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_input_memory_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_memory_new</NAME>
<RETURNS>GsfInput *</RETURNS>
guint8 const *buf, gsf_off_t length,gboolean needs_free
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_memory_new_clone</NAME>
<RETURNS>GsfInput *</RETURNS>
guint8 const *buf, gsf_off_t length
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_mmap_new</NAME>
<RETURNS>GsfInput *</RETURNS>
char const *filename, GError **err
</FUNCTION>
<STRUCT>
<NAME>GsfOutfile</NAME>
struct _GsfOutfile {
	GsfOutput parent;
};
</STRUCT>
<STRUCT>
<NAME>GsfOutfileClass</NAME>
typedef struct {
	GsfOutputClass output_class;
	GsfOutput   *(*new_child) (GsfOutfile *outfile,
				   char const *name, gboolean is_dir,
				   char const *first_property_name,
				   va_list args);
} GsfOutfileClass;
</STRUCT>
<MACRO>
<NAME>GSF_OUTFILE_CLASS</NAME>
#define GSF_OUTFILE_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST ((k), GSF_OUTFILE_TYPE, GsfOutfileClass))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTFILE_CLASS</NAME>
#define GSF_IS_OUTFILE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GSF_OUTFILE_TYPE))
</MACRO>
<MACRO>
<NAME>GSF_LE_GET_GUINT8</NAME>
#define GSF_LE_GET_GUINT8(p) (*(guint8 const *)(p))
</MACRO>
<MACRO>
<NAME>GSF_LE_GET_GUINT16</NAME>
#define GSF_LE_GET_GUINT16(p)				\
	(guint16)((((guint8 const *)(p))[0] << 0)  |	\
		  (((guint8 const *)(p))[1] << 8))
</MACRO>
<MACRO>
<NAME>GSF_LE_GET_GUINT32</NAME>
#define GSF_LE_GET_GUINT32(p)				\
	(guint32)((((guint8 const *)(p))[0] << 0)  |	\
		  (((guint8 const *)(p))[1] << 8)  |	\
		  (((guint8 const *)(p))[2] << 16) |	\
		  (((guint8 const *)(p))[3] << 24))
</MACRO>
<MACRO>
<NAME>GSF_LE_GET_GUINT64</NAME>
#define GSF_LE_GET_GUINT64(p) (gsf_le_get_guint64 (p))
</MACRO>
<MACRO>
<NAME>GSF_LE_GET_GINT8</NAME>
#define GSF_LE_GET_GINT8(p) ((gint8)GSF_LE_GET_GUINT8(p))
</MACRO>
<MACRO>
<NAME>GSF_LE_GET_GINT16</NAME>
#define GSF_LE_GET_GINT16(p) ((gint16)GSF_LE_GET_GUINT16(p))
</MACRO>
<MACRO>
<NAME>GSF_LE_GET_GINT32</NAME>
#define GSF_LE_GET_GINT32(p) ((gint32)GSF_LE_GET_GUINT32(p))
</MACRO>
<MACRO>
<NAME>GSF_LE_GET_GINT64</NAME>
#define GSF_LE_GET_GINT64(p) ((gint64)GSF_LE_GET_GUINT64(p))
</MACRO>
<MACRO>
<NAME>GSF_LE_GET_FLOAT</NAME>
#define GSF_LE_GET_FLOAT(p) (gsf_le_get_float (p))
</MACRO>
<MACRO>
<NAME>GSF_LE_GET_DOUBLE</NAME>
#define GSF_LE_GET_DOUBLE(p) (gsf_le_get_double (p))
</MACRO>
<FUNCTION>
<NAME>gsf_le_get_guint64</NAME>
<RETURNS>guint64 </RETURNS>
void const *p
</FUNCTION>
<FUNCTION>
<NAME>gsf_le_get_float</NAME>
<RETURNS>float   </RETURNS>
void const *p
</FUNCTION>
<FUNCTION>
<NAME>gsf_le_get_double</NAME>
<RETURNS>double  </RETURNS>
void const *p
</FUNCTION>
<MACRO>
<NAME>GSF_LE_SET_GUINT8</NAME>
#define GSF_LE_SET_GUINT8(p, dat)			\
	(*((guint8 *)(p))      = ((dat)        & 0xff))
</MACRO>
<MACRO>
<NAME>GSF_LE_SET_GUINT16</NAME>
#define GSF_LE_SET_GUINT16(p, dat)			\
	((*((guint8 *)(p) + 0) = ((dat)        & 0xff)),\
	 (*((guint8 *)(p) + 1) = ((dat) >>  8) & 0xff))
</MACRO>
<MACRO>
<NAME>GSF_LE_SET_GUINT32</NAME>
#define GSF_LE_SET_GUINT32(p, dat)				\
	((*((guint8 *)(p) + 0) = (guchar) ((dat))       & 0xff),	\
	 (*((guint8 *)(p) + 1) = (guchar) ((dat) >>  8) & 0xff),	\
	 (*((guint8 *)(p) + 2) = (guchar) ((dat) >> 16) & 0xff),	\
	 (*((guint8 *)(p) + 3) = (guchar) ((dat) >> 24) & 0xff))
</MACRO>
<MACRO>
<NAME>GSF_LE_SET_GUINT64</NAME>
#define GSF_LE_SET_GUINT64(p, dat)			\
	((*((guint8 *)(p) + 0) = (guchar) ((dat))       & 0xff),	\
	 (*((guint8 *)(p) + 1) = (guchar) ((dat) >>  8) & 0xff),	\
	 (*((guint8 *)(p) + 2) = (guchar) ((dat) >> 16) & 0xff),	\
	 (*((guint8 *)(p) + 3) = (guchar) ((dat) >> 24) & 0xff),	\
	 (*((guint8 *)(p) + 4) = (guchar) ((dat) >> 32) & 0xff),	\
	 (*((guint8 *)(p) + 5) = (guchar) ((dat) >> 40) & 0xff),	\
	 (*((guint8 *)(p) + 6) = (guchar) ((dat) >> 48) & 0xff),	\
	 (*((guint8 *)(p) + 7) = (guchar) ((dat) >> 56) & 0xff))
</MACRO>
<MACRO>
<NAME>GSF_LE_SET_GINT8</NAME>
#define GSF_LE_SET_GINT8(p,dat) GSF_LE_SET_GUINT8((p),(dat))
</MACRO>
<MACRO>
<NAME>GSF_LE_SET_GINT16</NAME>
#define GSF_LE_SET_GINT16(p,dat) GSF_LE_SET_GUINT16((p),(dat))
</MACRO>
<MACRO>
<NAME>GSF_LE_SET_GINT32</NAME>
#define GSF_LE_SET_GINT32(p,dat) GSF_LE_SET_GUINT32((p),(dat))
</MACRO>
<MACRO>
<NAME>GSF_LE_SET_GINT64</NAME>
#define GSF_LE_SET_GINT64(p,dat) GSF_LE_SET_GUINT64((p),(dat))
</MACRO>
<MACRO>
<NAME>GSF_LE_SET_FLOAT</NAME>
#define GSF_LE_SET_FLOAT(p,dat) gsf_le_set_float((p),(dat))
</MACRO>
<MACRO>
<NAME>GSF_LE_SET_DOUBLE</NAME>
#define GSF_LE_SET_DOUBLE(p,dat) gsf_le_set_double((p),(dat))
</MACRO>
<FUNCTION>
<NAME>gsf_le_set_float</NAME>
<RETURNS>void </RETURNS>
void *p, float f
</FUNCTION>
<FUNCTION>
<NAME>gsf_le_set_double</NAME>
<RETURNS>void </RETURNS>
void *p, double d
</FUNCTION>
<FUNCTION>
<NAME>gsf_init</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_shutdown</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_init_dynamic</NAME>
<RETURNS>void </RETURNS>
GTypeModule *module
</FUNCTION>
<FUNCTION>
<NAME>gsf_shutdown_dynamic</NAME>
<RETURNS>void </RETURNS>
GTypeModule *module
</FUNCTION>
<FUNCTION>
<NAME>gsf_mem_dump</NAME>
<RETURNS>void </RETURNS>
guint8 const *ptr, size_t len
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_dump</NAME>
<RETURNS>void </RETURNS>
GsfInput *input, gboolean dump_as_hex
</FUNCTION>
<FUNCTION>
<NAME>gsf_base64_encode_simple</NAME>
<RETURNS>guint8 *</RETURNS>
guint8 const *data, size_t len
</FUNCTION>
<FUNCTION>
<NAME>gsf_base64_encode_close</NAME>
<RETURNS>size_t  </RETURNS>
guint8 const *in, size_t inlen,gboolean break_lines, guint8 *out,int *state, guint *save
</FUNCTION>
<FUNCTION>
<NAME>gsf_base64_encode_step</NAME>
<RETURNS>size_t  </RETURNS>
guint8 const *in, size_t len,gboolean break_lines, guint8 *out,int *state, guint *save
</FUNCTION>
<FUNCTION>
<NAME>gsf_base64_decode_simple</NAME>
<RETURNS>size_t  </RETURNS>
guint8 *data, size_t len
</FUNCTION>
<FUNCTION>
<NAME>gsf_base64_decode_step</NAME>
<RETURNS>size_t  </RETURNS>
guint8 const *in, size_t len,guint8 *out, int *state, guint *save
</FUNCTION>
<FUNCTION>
<NAME>gsf_filename_to_utf8</NAME>
<RETURNS>char *</RETURNS>
char const *filename, gboolean quoted
</FUNCTION>
<VARIABLE>
<NAME>libgsf_major_version</NAME>
extern int libgsf_major_version;
</VARIABLE>
<VARIABLE>
<NAME>libgsf_minor_version</NAME>
extern int libgsf_minor_version;
</VARIABLE>
<VARIABLE>
<NAME>libgsf_micro_version</NAME>
extern int libgsf_micro_version;
</VARIABLE>
<FUNCTION>
<NAME>gsf_extension_pointer</NAME>
<RETURNS>char const *</RETURNS>
char const * path
</FUNCTION>
<FUNCTION>
<NAME>gsf_iconv_close</NAME>
<RETURNS>void	    </RETURNS>
GIConv handle
</FUNCTION>
<FUNCTION>
<NAME>gsf_property_settings_collect_valist</NAME>
<RETURNS>void        </RETURNS>
GType object_type,GParameter **p_params,size_t *p_n_params,const gchar *first_property_name,va_list var_args
</FUNCTION>
<FUNCTION>
<NAME>gsf_property_settings_collect</NAME>
<RETURNS>void        </RETURNS>
GType object_type,GParameter **p_params,size_t *p_n_params,const gchar *first_property_name,...
</FUNCTION>
<FUNCTION>
<NAME>gsf_property_settings_free</NAME>
<RETURNS>void        </RETURNS>
GParameter *params,size_t n_params
</FUNCTION>
<MACRO>
<NAME>GSF_ERROR</NAME>
#define GSF_ERROR (gsf_error_quark ())
</MACRO>
<ENUM>
<NAME>GsfError</NAME>
typedef enum {
	GSF_ERROR_OUT_OF_MEMORY,
	GSF_ERROR_INVALID_DATA
} GsfError;
</ENUM>
<FUNCTION>
<NAME>gsf_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_set_name</NAME>
<RETURNS>gboolean </RETURNS>
GsfOutput *output, char const *name
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_set_name_from_filename</NAME>
<RETURNS>gboolean </RETURNS>
GsfOutput *output, char const *filename
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_set_container</NAME>
<RETURNS>gboolean </RETURNS>
GsfOutput *output, GsfOutfile *container
</FUNCTION>
<MACRO>
<NAME>GSF_BLOB_TYPE</NAME>
#define GSF_BLOB_TYPE			(gsf_blob_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_BLOB</NAME>
#define GSF_BLOB(obj)		  	(G_TYPE_CHECK_INSTANCE_CAST ((obj), GSF_BLOB_TYPE, GsfBlob))
</MACRO>
<MACRO>
<NAME>GSF_BLOB_CLASS</NAME>
#define GSF_BLOB_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), GSF_BLOB_TYPE, GsfBlobClass))
</MACRO>
<MACRO>
<NAME>GSF_IS_BLOB</NAME>
#define GSF_IS_BLOB(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSF_BLOB_TYPE))
</MACRO>
<MACRO>
<NAME>GSF_IS_BLOB_CLASS</NAME>
#define GSF_IS_BLOB_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GSF_BLOB_TYPE))
</MACRO>
<MACRO>
<NAME>GSF_BLOB_GET_CLASS</NAME>
#define GSF_BLOB_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), GSF_BLOB_TYPE, GsfBlobClass))
</MACRO>
<MACRO>
<NAME>GSF_TYPE_BLOB</NAME>
#define GSF_TYPE_BLOB			(gsf_blob_get_type ())
</MACRO>
<STRUCT>
<NAME>GsfBlob</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfBlobClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfBlobPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfBlob</NAME>
struct _GsfBlob {
	GObject object;
	GsfBlobPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GsfBlobClass</NAME>
struct _GsfBlobClass {
	GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gsf_blob_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_blob_new</NAME>
<RETURNS>GsfBlob *</RETURNS>
gsize size,gconstpointer data_to_copy,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gsf_blob_get_size</NAME>
<RETURNS>gsize </RETURNS>
GsfBlob const *blob
</FUNCTION>
<FUNCTION>
<NAME>gsf_blob_peek_data</NAME>
<RETURNS>gconstpointer </RETURNS>
GsfBlob const *blob
</FUNCTION>
<ENUM>
<NAME>GsfZipCompressionMethod</NAME>
typedef enum {
	GSF_ZIP_STORED =          0,		/* supported for export */
	GSF_ZIP_SHRUNK =          1,
	GSF_ZIP_REDUCEDx1 =       2,
	GSF_ZIP_REDUCEDx2 =       3,
	GSF_ZIP_REDUCEDx3 =       4,
	GSF_ZIP_REDUCEDx4 =       5,
	GSF_ZIP_IMPLODED  =       6,
	GSF_ZIP_TOKENIZED =       7,
	GSF_ZIP_DEFLATED =        8,		/* supported for export */
	GSF_ZIP_DEFLATED_BETTER = 9,
	GSF_ZIP_IMPLODED_BETTER = 10
} GsfZipCompressionMethod;
</ENUM>
<STRUCT>
<NAME>GsfOutfileZip</NAME>
</STRUCT>
<MACRO>
<NAME>GSF_OUTFILE_ZIP_TYPE</NAME>
#define GSF_OUTFILE_ZIP_TYPE	(gsf_outfile_zip_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTFILE_ZIP</NAME>
#define GSF_OUTFILE_ZIP(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTFILE_ZIP_TYPE, GsfOutfileZip))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTFILE_ZIP</NAME>
#define GSF_IS_OUTFILE_ZIP(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTFILE_ZIP_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_outfile_zip_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_zip_new</NAME>
<RETURNS>GsfOutfile *</RETURNS>
GsfOutput *sink, GError **err
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_zip_set_compression_method</NAME>
<RETURNS>gboolean    </RETURNS>
GsfOutfileZip *zip,GsfZipCompressionMethod method
</FUNCTION>
<ENUM>
<NAME>GsfOutputCsvQuotingMode</NAME>
typedef enum {
	GSF_OUTPUT_CSV_QUOTING_MODE_NEVER,
	GSF_OUTPUT_CSV_QUOTING_MODE_AUTO,
	GSF_OUTPUT_CSV_QUOTING_MODE_ALWAYS
} GsfOutputCsvQuotingMode;
</ENUM>
<FUNCTION>
<NAME>gsf_output_csv_quoting_mode_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GSF_OUTPUT_CSV_QUOTING_MODE_TYPE</NAME>
#define GSF_OUTPUT_CSV_QUOTING_MODE_TYPE (gsf_output_csv_quoting_mode_get_type ())
</MACRO>
<STRUCT>
<NAME>GsfOutputCsv</NAME>
typedef struct {
	GsfOutput output;

	GsfOutput *sink;

	char *quote;
	size_t quote_len;
	GsfOutputCsvQuotingMode quoting_mode;
	char *quoting_triggers;

	char *eol;
	size_t eol_len;
	char *separator;
	size_t separator_len;
	gboolean fields_on_line;

	GString *buf;
} GsfOutputCsv;
</STRUCT>
<MACRO>
<NAME>GSF_OUTPUT_CSV_TYPE</NAME>
#define GSF_OUTPUT_CSV_TYPE        (gsf_output_csv_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTPUT_CSV</NAME>
#define GSF_OUTPUT_CSV(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTPUT_CSV_TYPE, GsfOutputCsv))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTPUT_CSV</NAME>
#define GSF_IS_OUTPUT_CSV(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTPUT_CSV_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_output_csv_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_csv_write_field</NAME>
<RETURNS>gboolean </RETURNS>
GsfOutputCsv *csv,char const *field,size_t len
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_csv_write_eol</NAME>
<RETURNS>gboolean </RETURNS>
GsfOutputCsv *csv
</FUNCTION>
<STRUCT>
<NAME>GsfOutputCsvClass</NAME>
typedef struct {
	GsfOutputClass output_class;
} GsfOutputCsvClass;
</STRUCT>
<STRUCT>
<NAME>GsfOutputIconvClass</NAME>
typedef struct {
	GsfOutputClass output_class;
} GsfOutputIconvClass;
</STRUCT>
<MACRO>
<NAME>GSF_OUTPUT_ICONV_TYPE</NAME>
#define GSF_OUTPUT_ICONV_TYPE        (gsf_output_iconv_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTPUT_ICONV</NAME>
#define GSF_OUTPUT_ICONV(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTPUT_ICONV_TYPE, GsfOutputIconv))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTPUT_ICONV</NAME>
#define GSF_IS_OUTPUT_ICONV(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTPUT_ICONV_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfOutputIconv</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_output_iconv_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_iconv_new</NAME>
<RETURNS>GsfOutput *</RETURNS>
GsfOutput *sink, char const *dst, char const *src
</FUNCTION>
<MACRO>
<NAME>GSF_INPUT_TEXTLINE_TYPE</NAME>
#define GSF_INPUT_TEXTLINE_TYPE        (gsf_input_textline_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_INPUT_TEXTLINE</NAME>
#define GSF_INPUT_TEXTLINE(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_INPUT_TEXTLINE_TYPE, GsfInputTextline))
</MACRO>
<MACRO>
<NAME>GSF_IS_INPUT_TEXTLINE</NAME>
#define GSF_IS_INPUT_TEXTLINE(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_INPUT_TEXTLINE_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfInputTextline</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_input_textline_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_textline_new</NAME>
<RETURNS>GsfInput      *</RETURNS>
GsfInput *source
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_textline_ascii_gets</NAME>
<RETURNS>unsigned char *</RETURNS>
GsfInputTextline *textline
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_textline_utf8_gets</NAME>
<RETURNS>guint8	      *</RETURNS>
GsfInputTextline *textline
</FUNCTION>
<MACRO>
<NAME>GSF_SHARED_MEMORY_TYPE</NAME>
#define GSF_SHARED_MEMORY_TYPE	(gsf_shared_memory_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_SHARED_MEMORY</NAME>
#define GSF_SHARED_MEMORY(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_SHARED_MEMORY_TYPE, GsfSharedMemory))
</MACRO>
<MACRO>
<NAME>GSF_IS_SHARED_MEMORY</NAME>
#define GSF_IS_SHARED_MEMORY(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_SHARED_MEMORY_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfSharedMemory</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfSharedMemory</NAME>
struct _GsfSharedMemory {
	GObject g_object;
	void *buf;
	gsf_off_t size;

	gboolean needs_free;
	gboolean needs_unmap;
};
</STRUCT>
<FUNCTION>
<NAME>gsf_shared_memory_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_shared_memory_new</NAME>
<RETURNS>GsfSharedMemory *</RETURNS>
void *buf, gsf_off_t size, gboolean needs_free
</FUNCTION>
<FUNCTION>
<NAME>gsf_shared_memory_mmapped_new</NAME>
<RETURNS>GsfSharedMemory *</RETURNS>
void *buf, gsf_off_t size
</FUNCTION>
<MACRO>
<NAME>GSF_INPUT_TYPE</NAME>
#define GSF_INPUT_TYPE        (gsf_input_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_INPUT</NAME>
#define GSF_INPUT(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_INPUT_TYPE, GsfInput))
</MACRO>
<MACRO>
<NAME>GSF_IS_INPUT</NAME>
#define GSF_IS_INPUT(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_INPUT_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_input_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_name</NAME>
<RETURNS>char const   *</RETURNS>
GsfInput *input
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_container</NAME>
<RETURNS>GsfInfile    *</RETURNS>
GsfInput *input
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_dup</NAME>
<RETURNS>GsfInput     *</RETURNS>
GsfInput *input, GError **err
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_sibling</NAME>
<RETURNS>GsfInput     *</RETURNS>
GsfInput const *input, char const *name, GError **err
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_size</NAME>
<RETURNS>gsf_off_t     </RETURNS>
GsfInput *input
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_eof</NAME>
<RETURNS>gboolean      </RETURNS>
GsfInput *input
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_read</NAME>
<RETURNS>guint8 const *</RETURNS>
GsfInput *input, size_t num_bytes,guint8 *optional_buffer
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_remaining</NAME>
<RETURNS>gsf_off_t     </RETURNS>
GsfInput *input
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_tell</NAME>
<RETURNS>gsf_off_t     </RETURNS>
GsfInput *input
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_seek</NAME>
<RETURNS>gboolean      </RETURNS>
GsfInput *input,gsf_off_t offset, GSeekType whence
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_copy</NAME>
<RETURNS>gboolean  </RETURNS>
GsfInput *input, GsfOutput *output
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_uncompress</NAME>
<RETURNS>GsfInput *</RETURNS>
GsfInput *src
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_error_id</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_error</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GsfOutfileMSOle</NAME>
</STRUCT>
<MACRO>
<NAME>GSF_OUTFILE_MSOLE_TYPE</NAME>
#define GSF_OUTFILE_MSOLE_TYPE	(gsf_outfile_msole_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTFILE_MSOLE</NAME>
#define GSF_OUTFILE_MSOLE(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTFILE_MSOLE_TYPE, GsfOutfileMSOle))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTFILE_MSOLE</NAME>
#define GSF_IS_OUTFILE_MSOLE(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTFILE_MSOLE_TYPE))
</MACRO>
<MACRO>
<NAME>OLE_DEFAULT_SB_SHIFT</NAME>
#define OLE_DEFAULT_SB_SHIFT	 6
</MACRO>
<MACRO>
<NAME>OLE_DEFAULT_BB_SHIFT</NAME>
#define OLE_DEFAULT_BB_SHIFT	 9
</MACRO>
<FUNCTION>
<NAME>gsf_outfile_msole_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_msole_new</NAME>
<RETURNS>GsfOutfile *</RETURNS>
GsfOutput *sink
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_msole_new_full</NAME>
<RETURNS>GsfOutfile *</RETURNS>
GsfOutput *sink,guint bb_size, guint sb_size
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_msole_set_class_id</NAME>
<RETURNS>gboolean    </RETURNS>
GsfOutfileMSOle *ole,guint8 const *clsid
</FUNCTION>
<MACRO>
<NAME>OLE_HEADER_SIZE</NAME>
#define OLE_HEADER_SIZE		 0x200	/* independent of big block size size */
</MACRO>
<MACRO>
<NAME>OLE_HEADER_SIGNATURE</NAME>
#define OLE_HEADER_SIGNATURE	 0x00
</MACRO>
<MACRO>
<NAME>OLE_HEADER_CLSID</NAME>
#define OLE_HEADER_CLSID	 0x08	/* See ReadClassStg */
</MACRO>
<MACRO>
<NAME>OLE_HEADER_MINOR_VER</NAME>
#define OLE_HEADER_MINOR_VER	 0x18	/* 0x33 and 0x3e have been seen */
</MACRO>
<MACRO>
<NAME>OLE_HEADER_MAJOR_VER</NAME>
#define OLE_HEADER_MAJOR_VER	 0x1a	/* 0x3 been seen in wild */
</MACRO>
<MACRO>
<NAME>OLE_HEADER_BYTE_ORDER</NAME>
#define OLE_HEADER_BYTE_ORDER	 0x1c	/* 0xfe 0xff == Intel Little Endian */
</MACRO>
<MACRO>
<NAME>OLE_HEADER_BB_SHIFT</NAME>
#define OLE_HEADER_BB_SHIFT      0x1e
</MACRO>
<MACRO>
<NAME>OLE_HEADER_SB_SHIFT</NAME>
#define OLE_HEADER_SB_SHIFT      0x20
</MACRO>
<MACRO>
<NAME>OLE_HEADER_CSECTDIR</NAME>
#define OLE_HEADER_CSECTDIR	 0x28
</MACRO>
<MACRO>
<NAME>OLE_HEADER_NUM_BAT</NAME>
#define OLE_HEADER_NUM_BAT	 0x2c
</MACRO>
<MACRO>
<NAME>OLE_HEADER_DIRENT_START</NAME>
#define OLE_HEADER_DIRENT_START  0x30
</MACRO>
<MACRO>
<NAME>OLE_HEADER_THRESHOLD</NAME>
#define OLE_HEADER_THRESHOLD	 0x38
</MACRO>
<MACRO>
<NAME>OLE_HEADER_SBAT_START</NAME>
#define OLE_HEADER_SBAT_START    0x3c
</MACRO>
<MACRO>
<NAME>OLE_HEADER_NUM_SBAT</NAME>
#define OLE_HEADER_NUM_SBAT      0x40
</MACRO>
<MACRO>
<NAME>OLE_HEADER_METABAT_BLOCK</NAME>
#define OLE_HEADER_METABAT_BLOCK 0x44
</MACRO>
<MACRO>
<NAME>OLE_HEADER_NUM_METABAT</NAME>
#define OLE_HEADER_NUM_METABAT   0x48
</MACRO>
<MACRO>
<NAME>OLE_HEADER_START_BAT</NAME>
#define OLE_HEADER_START_BAT	 0x4c
</MACRO>
<MACRO>
<NAME>BAT_INDEX_SIZE</NAME>
#define BAT_INDEX_SIZE		 4
</MACRO>
<MACRO>
<NAME>OLE_HEADER_METABAT_SIZE</NAME>
#define OLE_HEADER_METABAT_SIZE	 ((OLE_HEADER_SIZE - OLE_HEADER_START_BAT) / BAT_INDEX_SIZE)
</MACRO>
<MACRO>
<NAME>DIRENT_MAX_NAME_SIZE</NAME>
#define DIRENT_MAX_NAME_SIZE	0x40
</MACRO>
<MACRO>
<NAME>DIRENT_DETAILS_SIZE</NAME>
#define DIRENT_DETAILS_SIZE	0x40
</MACRO>
<MACRO>
<NAME>DIRENT_SIZE</NAME>
#define DIRENT_SIZE		(DIRENT_MAX_NAME_SIZE + DIRENT_DETAILS_SIZE)
</MACRO>
<MACRO>
<NAME>DIRENT_NAME_LEN</NAME>
#define DIRENT_NAME_LEN		0x40	/* length in bytes incl 0 terminator */
</MACRO>
<MACRO>
<NAME>DIRENT_TYPE</NAME>
#define DIRENT_TYPE		0x42
</MACRO>
<MACRO>
<NAME>DIRENT_COLOUR</NAME>
#define DIRENT_COLOUR		0x43
</MACRO>
<MACRO>
<NAME>DIRENT_PREV</NAME>
#define DIRENT_PREV		0x44
</MACRO>
<MACRO>
<NAME>DIRENT_NEXT</NAME>
#define DIRENT_NEXT		0x48
</MACRO>
<MACRO>
<NAME>DIRENT_CHILD</NAME>
#define DIRENT_CHILD		0x4c
</MACRO>
<MACRO>
<NAME>DIRENT_CLSID</NAME>
#define DIRENT_CLSID		0x50	/* only for dirs */
</MACRO>
<MACRO>
<NAME>DIRENT_USERFLAGS</NAME>
#define DIRENT_USERFLAGS	0x60	/* only for dirs */
</MACRO>
<MACRO>
<NAME>DIRENT_CREATE_TIME</NAME>
#define DIRENT_CREATE_TIME	0x64	/* for files */
</MACRO>
<MACRO>
<NAME>DIRENT_MODIFY_TIME</NAME>
#define DIRENT_MODIFY_TIME	0x6c	/* for files */
</MACRO>
<MACRO>
<NAME>DIRENT_FIRSTBLOCK</NAME>
#define DIRENT_FIRSTBLOCK	0x74
</MACRO>
<MACRO>
<NAME>DIRENT_FILE_SIZE</NAME>
#define DIRENT_FILE_SIZE	0x78
</MACRO>
<MACRO>
<NAME>DIRENT_TYPE_INVALID</NAME>
#define DIRENT_TYPE_INVALID	0
</MACRO>
<MACRO>
<NAME>DIRENT_TYPE_DIR</NAME>
#define DIRENT_TYPE_DIR		1
</MACRO>
<MACRO>
<NAME>DIRENT_TYPE_FILE</NAME>
#define DIRENT_TYPE_FILE	2
</MACRO>
<MACRO>
<NAME>DIRENT_TYPE_LOCKBYTES</NAME>
#define DIRENT_TYPE_LOCKBYTES	3	/* ? */
</MACRO>
<MACRO>
<NAME>DIRENT_TYPE_PROPERTY</NAME>
#define DIRENT_TYPE_PROPERTY	4	/* ? */
</MACRO>
<MACRO>
<NAME>DIRENT_TYPE_ROOTDIR</NAME>
#define DIRENT_TYPE_ROOTDIR	5
</MACRO>
<MACRO>
<NAME>DIRENT_MAGIC_END</NAME>
#define DIRENT_MAGIC_END	0xffffffff
</MACRO>
<MACRO>
<NAME>BAT_MAGIC_UNUSED</NAME>
#define BAT_MAGIC_UNUSED	0xffffffff	/*		   -1 */
</MACRO>
<MACRO>
<NAME>BAT_MAGIC_END_OF_CHAIN</NAME>
#define BAT_MAGIC_END_OF_CHAIN	0xfffffffe	/*		   -2 */
</MACRO>
<MACRO>
<NAME>BAT_MAGIC_BAT</NAME>
#define BAT_MAGIC_BAT		0xfffffffd	/* a bat block,    -3 */
</MACRO>
<MACRO>
<NAME>BAT_MAGIC_METABAT</NAME>
#define BAT_MAGIC_METABAT	0xfffffffc	/* a metabat block -4 */
</MACRO>
<STRUCT>
<NAME>GsfInfileMSOle</NAME>
</STRUCT>
<MACRO>
<NAME>GSF_INFILE_MSOLE_TYPE</NAME>
#define GSF_INFILE_MSOLE_TYPE        (gsf_infile_msole_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_INFILE_MSOLE</NAME>
#define GSF_INFILE_MSOLE(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_INFILE_MSOLE_TYPE, GsfInfileMSOle))
</MACRO>
<MACRO>
<NAME>GSF_IS_INFILE_MSOLE</NAME>
#define GSF_IS_INFILE_MSOLE(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_INFILE_MSOLE_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_infile_msole_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_infile_msole_new</NAME>
<RETURNS>GsfInfile *</RETURNS>
GsfInput *source, GError **err
</FUNCTION>
<FUNCTION>
<NAME>gsf_infile_msole_get_class_id</NAME>
<RETURNS>gboolean   </RETURNS>
GsfInfileMSOle const *ole,guint8 *res
</FUNCTION>
<STRUCT>
<NAME>GsfOutfileStdio</NAME>
</STRUCT>
<MACRO>
<NAME>GSF_OUTFILE_STDIO_TYPE</NAME>
#define GSF_OUTFILE_STDIO_TYPE	(gsf_outfile_stdio_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTFILE_STDIO</NAME>
#define GSF_OUTFILE_STDIO(o)	(G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTFILE_STDIO_TYPE, GsfOutfileStdio))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTFILE_STDIO</NAME>
#define GSF_IS_OUTFILE_STDIO(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTFILE_STDIO_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_outfile_stdio_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_stdio_new</NAME>
<RETURNS>GsfOutfile *</RETURNS>
char const *root, GError **err
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_stdio_new_full</NAME>
<RETURNS>GsfOutfile *</RETURNS>
char const *root, GError **err,char const *first_property_name,...
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_stdio_new_valist</NAME>
<RETURNS>GsfOutfile *</RETURNS>
char const *root, GError **err,char const *first_property_name,va_list     var_args
</FUNCTION>
<STRUCT>
<NAME>GsfOpenPkgRel</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfOpenPkgRels</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_open_pkg_rel_is_extern</NAME>
<RETURNS>gboolean      </RETURNS>
GsfOpenPkgRel const *rel
</FUNCTION>
<FUNCTION>
<NAME>gsf_open_pkg_rel_get_target</NAME>
<RETURNS>char const   *</RETURNS>
GsfOpenPkgRel const *rel
</FUNCTION>
<FUNCTION>
<NAME>gsf_open_pkg_rel_get_type</NAME>
<RETURNS>char const   *</RETURNS>
GsfOpenPkgRel const *rel
</FUNCTION>
<FUNCTION>
<NAME>gsf_open_pkg_lookup_rel_by_type</NAME>
<RETURNS>GsfOpenPkgRel *</RETURNS>
GsfInput *in, char const *type
</FUNCTION>
<FUNCTION>
<NAME>gsf_open_pkg_lookup_rel_by_id</NAME>
<RETURNS>GsfOpenPkgRel *</RETURNS>
GsfInput *in, char const *id
</FUNCTION>
<FUNCTION>
<NAME>gsf_open_pkg_open_rel_by_type</NAME>
<RETURNS>GsfInput      *</RETURNS>
GsfInput *in, char const *type,GError **err
</FUNCTION>
<FUNCTION>
<NAME>gsf_open_pkg_open_rel_by_id</NAME>
<RETURNS>GsfInput      *</RETURNS>
GsfInput *in, char const *id,GError **err
</FUNCTION>
<FUNCTION>
<NAME>gsf_open_pkg_parse_rel_by_id</NAME>
<RETURNS>GError	      *</RETURNS>
GsfXMLIn *xin, char const *id,GsfXMLInNode const *dtd,GsfXMLInNS const *ns
</FUNCTION>
<FUNCTION>
<NAME>gsf_open_pkg_get_rel_by_type</NAME>
<RETURNS>GsfInput      *</RETURNS>
GsfInput *in, char const *type
</FUNCTION>
<FUNCTION>
<NAME>gsf_open_pkg_get_rel_by_id</NAME>
<RETURNS>GsfInput      *</RETURNS>
GsfInput *in, char const *id
</FUNCTION>
<STRUCT>
<NAME>GsfOutfileOpenPkg</NAME>
</STRUCT>
<MACRO>
<NAME>GSF_OUTFILE_OPEN_PKG_TYPE</NAME>
#define GSF_OUTFILE_OPEN_PKG_TYPE	(gsf_outfile_open_pkg_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTFILE_OPEN_PKG</NAME>
#define GSF_OUTFILE_OPEN_PKG(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTFILE_OPEN_PKG_TYPE, GsfOutfileOpenPkg))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTFILE_OPEN_PKG</NAME>
#define GSF_IS_OUTFILE_OPEN_PKG(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTFILE_OPEN_PKG_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_outfile_open_pkg_get_type</NAME>
<RETURNS>GType	    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_open_pkg_new</NAME>
<RETURNS>GsfOutfile *</RETURNS>
GsfOutfile *sink
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_open_pkg_set_sink</NAME>
<RETURNS>void	    </RETURNS>
GsfOutfileOpenPkg *open_pkg,GsfOutput *sink
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_open_pkg_set_content_type</NAME>
<RETURNS>void	    </RETURNS>
GsfOutfileOpenPkg *open_pkg,char const *content_type
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_open_pkg_relate</NAME>
<RETURNS>char const *</RETURNS>
GsfOutfileOpenPkg *child,GsfOutfileOpenPkg *parent,char const *type
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_open_pkg_add_rel</NAME>
<RETURNS>GsfOutput  *</RETURNS>
GsfOutfile *dir,char const *name,char const *content_type,GsfOutfile *parent,char const *type
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_open_pkg_add_extern_rel</NAME>
<RETURNS>char const *</RETURNS>
GsfOutfileOpenPkg *parent,char const *target,char const *content_type
</FUNCTION>
<FUNCTION>
<NAME>gsf_open_pkg_error_id</NAME>
<RETURNS>gint </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GsfInfileStdio</NAME>
</STRUCT>
<MACRO>
<NAME>GSF_INFILE_STDIO_TYPE</NAME>
#define GSF_INFILE_STDIO_TYPE        (gsf_infile_stdio_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_INFILE_STDIO</NAME>
#define GSF_INFILE_STDIO(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_INFILE_STDIO_TYPE, GsfInfileStdio))
</MACRO>
<MACRO>
<NAME>GSF_IS_INFILE_STDIO</NAME>
#define GSF_IS_INFILE_STDIO(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_INFILE_STDIO_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_infile_stdio_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_infile_stdio_new</NAME>
<RETURNS>GsfInfile *</RETURNS>
char const *root, GError **err
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_parser_context</NAME>
<RETURNS>xmlParserCtxt *</RETURNS>
GsfInput   *input
</FUNCTION>
<FUNCTION>
<NAME>gsf_xmlDocFormatDump</NAME>
<RETURNS>int	       </RETURNS>
GsfOutput  *output,xmlDoc	  *cur,char const *encoding,gboolean    format
</FUNCTION>
<STRUCT>
<NAME>GsfXMLIn</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfXMLInDoc</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfXMLInNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfXMLInNS</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfXMLBlob</NAME>
</STRUCT>
<ENUM>
<NAME>GsfXMLContent</NAME>
typedef enum {
	GSF_XML_NO_CONTENT = FALSE,
	GSF_XML_CONTENT,
	GSF_XML_SHARED_CONTENT
} GsfXMLContent;
</ENUM>
<USER_FUNCTION>
<NAME>GsfXMLInUnknownFunc</NAME>
<RETURNS>gboolean </RETURNS>
GsfXMLIn *xin,
					 xmlChar const *elem, xmlChar const **attrs
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GsfXMLInExtDtor</NAME>
<RETURNS>void </RETURNS>
GsfXMLIn *xin, gpointer old_state
</USER_FUNCTION>
<STRUCT>
<NAME>GsfXMLIn</NAME>
struct _GsfXMLIn {
	/* public state : read only */
	gpointer	    user_state;
	GString		   *content;
	GsfXMLInDoc  const *doc;
	GsfXMLInNode const *node;	/* current node (not on the stack) */
	GSList	 	   *node_stack;	/* stack of GsfXMLInNode */
};
</STRUCT>
<STRUCT>
<NAME>GsfXMLInNode</NAME>
struct _GsfXMLInNode {
	char const *id;		/* unique in the entire tree */
	int	    ns_id;
	char const *name;
	char const *parent_id;
	void (*start) (GsfXMLIn *xin, xmlChar const **attrs);
	void (*end)   (GsfXMLIn *xin, GsfXMLBlob *unknown);

	union {
		int	    v_int;
		gboolean    v_bool;
		gpointer    v_blob;
		char const *v_str;
	} user_data;
	GsfXMLContent has_content;

	unsigned int check_children_for_ns : 1;
	unsigned int share_children_with_parent : 1;
};
</STRUCT>
<STRUCT>
<NAME>GsfXMLInNS</NAME>
struct _GsfXMLInNS {
	char const *uri;
	unsigned    ns_id;
};
</STRUCT>
<MACRO>
<NAME>GSF_XML_IN_NS</NAME>
#define GSF_XML_IN_NS(id, uri) \
{ uri, id }
</MACRO>
<MACRO>
<NAME>GSF_XML_IN_NS_END</NAME>
#define GSF_XML_IN_NS_END \
{ NULL, 0 }
</MACRO>
<MACRO>
<NAME>GSF_XML_IN_NODE_FULL</NAME>
#define GSF_XML_IN_NODE_FULL(parent_id, id, ns, name, has_content, 	\
			     share_children_with_parent, check_ns, start, end, user)	\
{									\
	#id, ns, name, #parent_id, start, end, { user }, has_content,	\
	check_ns, share_children_with_parent,				\
}
</MACRO>
<MACRO>
<NAME>GSF_XML_IN_NODE</NAME>
#define GSF_XML_IN_NODE(parent_id, id, ns, name, has_content, start, end) \
	GSF_XML_IN_NODE_FULL(parent_id, id, ns, name, has_content,	  \
			     FALSE, FALSE, start, end, 0)
</MACRO>
<MACRO>
<NAME>GSF_XML_IN_NODE_END</NAME>
#define GSF_XML_IN_NODE_END	\
	{ NULL, 0, NULL, NULL, NULL, NULL, { 0 }, GSF_XML_NO_CONTENT, FALSE, FALSE }
</MACRO>
<FUNCTION>
<NAME>gsf_xml_in_doc_new</NAME>
<RETURNS>GsfXMLInDoc *</RETURNS>
GsfXMLInNode const *nodes, GsfXMLInNS const *ns
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_in_doc_free</NAME>
<RETURNS>void	     </RETURNS>
GsfXMLInDoc *doc
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_in_doc_parse</NAME>
<RETURNS>gboolean     </RETURNS>
GsfXMLInDoc *doc, GsfInput *input,gpointer user_state
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_in_doc_set_unknown_handler</NAME>
<RETURNS>void	     </RETURNS>
GsfXMLInDoc *doc,GsfXMLInUnknownFunc handler
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_in_push_state</NAME>
<RETURNS>void	     </RETURNS>
GsfXMLIn *xin, GsfXMLInDoc const *doc,gpointer new_state, GsfXMLInExtDtor dtor,xmlChar const **attrs
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_in_get_input</NAME>
<RETURNS>GsfInput    *</RETURNS>
GsfXMLIn const *xin
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_in_check_ns</NAME>
<RETURNS>char const  *</RETURNS>
GsfXMLIn const *xin, char const *str,unsigned int ns_id
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_in_namecmp</NAME>
<RETURNS>gboolean     </RETURNS>
GsfXMLIn const *xin, char const *str,unsigned int ns_id, char const *name
</FUNCTION>
<STRUCT>
<NAME>GsfXMLOut</NAME>
</STRUCT>
<MACRO>
<NAME>GSF_XML_OUT_TYPE</NAME>
#define GSF_XML_OUT_TYPE	(gsf_xml_out_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_XML_OUT</NAME>
#define GSF_XML_OUT(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_XML_OUT_TYPE, GsfXMLOut))
</MACRO>
<MACRO>
<NAME>GSF_IS_XML_OUT</NAME>
#define GSF_IS_XML_OUT(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_XML_OUT_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_xml_out_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_new</NAME>
<RETURNS>GsfXMLOut *</RETURNS>
GsfOutput *output
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_set_doc_type</NAME>
<RETURNS>void	    </RETURNS>
GsfXMLOut *xout, char const *type
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_start_element</NAME>
<RETURNS>void	    </RETURNS>
GsfXMLOut *xout, char const *id
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_end_element</NAME>
<RETURNS>char const *</RETURNS>
GsfXMLOut *xout
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_simple_element</NAME>
<RETURNS>void </RETURNS>
GsfXMLOut *xout, char const *id,char const *content
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_simple_int_element</NAME>
<RETURNS>void </RETURNS>
GsfXMLOut *xout, char const *id,int val
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_simple_float_element</NAME>
<RETURNS>void </RETURNS>
GsfXMLOut *xout, char const *id,double val, int precision
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_add_cstr_unchecked</NAME>
<RETURNS>void </RETURNS>
GsfXMLOut *xout, char const *id,char const *val_utf8
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_add_cstr</NAME>
<RETURNS>void </RETURNS>
GsfXMLOut *xout, char const *id,char const *val_utf8
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_add_bool</NAME>
<RETURNS>void </RETURNS>
GsfXMLOut *xout, char const *id,gboolean val
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_add_int</NAME>
<RETURNS>void </RETURNS>
GsfXMLOut *xout, char const *id,int val
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_add_uint</NAME>
<RETURNS>void </RETURNS>
GsfXMLOut *xout, char const *id,unsigned int val
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_add_float</NAME>
<RETURNS>void </RETURNS>
GsfXMLOut *xout, char const *id,double val, int precision
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_add_color</NAME>
<RETURNS>void </RETURNS>
GsfXMLOut *xout, char const *id,unsigned int r, unsigned int g, unsigned int b
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_add_base64</NAME>
<RETURNS>void </RETURNS>
GsfXMLOut *xout, char const *id,guint8 const *data, unsigned int len
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_add_enum</NAME>
<RETURNS>void </RETURNS>
GsfXMLOut *xout, char const *id,GType etype, gint val
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_add_gvalue</NAME>
<RETURNS>void </RETURNS>
GsfXMLOut *xout, char const *id,GValue const *val
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_gvalue_from_str</NAME>
<RETURNS>gboolean </RETURNS>
GValue *res, GType t, char const *str
</FUNCTION>
<FUNCTION>
<NAME>gsf_xml_out_get_output</NAME>
<RETURNS>GsfOutput *</RETURNS>
GsfXMLOut const *xout
</FUNCTION>
<MACRO>
<NAME>GSF_OUTFILE_TYPE</NAME>
#define GSF_OUTFILE_TYPE        (gsf_outfile_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTFILE</NAME>
#define GSF_OUTFILE(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTFILE_TYPE, GsfOutfile))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTFILE</NAME>
#define GSF_IS_OUTFILE(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTFILE_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_outfile_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_new_child</NAME>
<RETURNS>GsfOutput *</RETURNS>
GsfOutfile *outfile,char const *name, gboolean is_dir
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_new_child_full</NAME>
<RETURNS>GsfOutput *</RETURNS>
GsfOutfile *outfile,char const *name, gboolean is_dir,char const *first_property_name,...
</FUNCTION>
<FUNCTION>
<NAME>gsf_outfile_new_child_varg</NAME>
<RETURNS>GsfOutput *</RETURNS>
GsfOutfile *outfile,char const *name, gboolean is_dir,char const *first_property_name,va_list args
</FUNCTION>
<MACRO>
<NAME>GSF_PARAM_STATIC</NAME>
#define GSF_PARAM_STATIC (G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)
</MACRO>
<MACRO>
<NAME>GSF_PARAM_STATIC</NAME>
#define GSF_PARAM_STATIC 0
</MACRO>
<MACRO>
<NAME>GSF_CLASS_FULL</NAME>
#define	GSF_CLASS_FULL(name, prefix, base_init, base_finalize, \
		       class_init, class_finalize, instance_init, parent_type, \
		       abstract, interface_decl) \
GType									\
prefix ## _get_type (void)						\
{									\
	static GType type = 0;						\
	if (G_UNLIKELY  (type == 0)) {					\
		static GTypeInfo const object_info = {			\
			sizeof (name ## Class),				\
			(GBaseInitFunc) base_init,			\
			(GBaseFinalizeFunc) base_finalize,		\
			(GClassInitFunc) class_init,			\
			(GClassFinalizeFunc) class_finalize,		\
			NULL,	/* class_data */			\
			sizeof (name),					\
			0,	/* n_preallocs */			\
			(GInstanceInitFunc) instance_init,		\
			NULL						\
		};							\
		type = g_type_register_static (parent_type, #name,	\
			&object_info, (GTypeFlags) abstract);		\
		interface_decl						\
	}								\
	return type;							\
}
</MACRO>
<MACRO>
<NAME>GSF_CLASS</NAME>
#define	GSF_CLASS(name, prefix, class_init, instance_init, parent) \
	GSF_CLASS_FULL(name, prefix, NULL, NULL, class_init, NULL, \
				instance_init, parent, 0, {})
</MACRO>
<MACRO>
<NAME>GSF_CLASS_ABSTRACT</NAME>
#define	GSF_CLASS_ABSTRACT(name, prefix, class_init, instance_init, parent) \
	GSF_CLASS_FULL(name, prefix, NULL, NULL, class_init, NULL, \
		       instance_init, parent, G_TYPE_FLAG_ABSTRACT, {})
</MACRO>
<MACRO>
<NAME>GSF_INTERFACE_FULL</NAME>
#define GSF_INTERFACE_FULL(type, init_func, iface_type) {	\
	static GInterfaceInfo const iface = {			\
		(GInterfaceInitFunc) init_func, NULL, NULL };	\
	g_type_add_interface_static (type, iface_type, &iface);	\
}
</MACRO>
<MACRO>
<NAME>GSF_INTERFACE</NAME>
#define GSF_INTERFACE(init_func, iface_type)			\
	GSF_INTERFACE_FULL(type, init_func, iface_type)
</MACRO>
<MACRO>
<NAME>GSF_DYNAMIC_CLASS_FULL</NAME>
#define	GSF_DYNAMIC_CLASS_FULL(name, prefix, base_init, base_finalize, \
				   class_init,  class_finalize, instance_init, parent_type, \
			       abstract, interface_decl) 		\
static GType prefix ## _type; 						\
									\
GType prefix ## _get_type (void);					\
void  prefix ## _register_type (GTypeModule *module);			\
									\
GType									\
prefix ## _get_type ()							\
{									\
	g_return_val_if_fail (prefix ## _type != 0, 0); 		\
	return prefix ## _type;						\
}									\
void									\
prefix ## _register_type (GTypeModule *module)				\
{									\
	GTypeInfo const type_info = {					\
		sizeof (name ## Class),					\
		(GBaseInitFunc) base_init,				\
		(GBaseFinalizeFunc) base_finalize,			\
		(GClassInitFunc) class_init,				\
		(GClassFinalizeFunc) class_finalize,			\
		NULL,	/* class_data */				\
		sizeof (name),						\
		0,	/* n_preallocs */				\
		(GInstanceInitFunc) instance_init,			\
		NULL							\
	};								\
	GType type;							\
									\
	g_return_if_fail (prefix ## _type == 0); 			\
									\
	type = prefix ## _type = g_type_module_register_type (module,	\
		parent_type, #name, &type_info, (GTypeFlags) abstract);	\
	interface_decl							\
}
</MACRO>
<MACRO>
<NAME>GSF_DYNAMIC_CLASS</NAME>
#define	GSF_DYNAMIC_CLASS(name, prefix, class_init, instance_init, parent)	\
	GSF_DYNAMIC_CLASS_FULL(name, prefix, NULL, NULL, class_init, NULL, 	\
				   instance_init, parent, 0, {})
</MACRO>
<MACRO>
<NAME>GSF_DYNAMIC_CLASS_ABSTRACT</NAME>
#define	GSF_DYNAMIC_CLASS_ABSTRACT(name, prefix, class_init, instance_init, parent) \
	GSF_DYNAMIC_CLASS_FULL(name, prefix, NULL, NULL, class_init, NULL, 	\
		       instance_init, parent, G_TYPE_FLAG_ABSTRACT, {})
</MACRO>
<MACRO>
<NAME>GSF_DYNAMIC_INTERFACE_FULL</NAME>
#define GSF_DYNAMIC_INTERFACE_FULL(type, init_func, iface_type, module) {	\
	GInterfaceInfo const iface = {						\
		(GInterfaceInitFunc) init_func, NULL, NULL };			\
	g_type_module_add_interface (module, type, iface_type, &iface);		\
}
</MACRO>
<MACRO>
<NAME>GSF_DYNAMIC_INTERFACE</NAME>
#define GSF_DYNAMIC_INTERFACE(init_func, iface_type, module)			\
	GSF_DYNAMIC_INTERFACE_FULL(type, init_func, iface_type, module)
</MACRO>
<MACRO>
<NAME>GSF_DOC_META_DATA_TYPE</NAME>
#define GSF_DOC_META_DATA_TYPE  (gsf_doc_meta_data_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_DOC_META_DATA</NAME>
#define GSF_DOC_META_DATA(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_DOC_META_DATA_TYPE, GsfDocMetaData))
</MACRO>
<MACRO>
<NAME>IS_GSF_DOC_META_DATA</NAME>
#define IS_GSF_DOC_META_DATA(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_DOC_META_DATA_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_doc_meta_data_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_meta_data_new</NAME>
<RETURNS>GsfDocMetaData *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_meta_data_lookup</NAME>
<RETURNS>GsfDocProp     *</RETURNS>
GsfDocMetaData const *meta,char const *name
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_meta_data_insert</NAME>
<RETURNS>void		</RETURNS>
GsfDocMetaData *meta,char *name, GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_meta_data_remove</NAME>
<RETURNS>void		</RETURNS>
GsfDocMetaData *meta,char const *name
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_meta_data_steal</NAME>
<RETURNS>GsfDocProp     *</RETURNS>
GsfDocMetaData *meta,char const *name
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_meta_data_store</NAME>
<RETURNS>void		</RETURNS>
GsfDocMetaData *meta,GsfDocProp     *prop
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_meta_data_foreach</NAME>
<RETURNS>void		</RETURNS>
GsfDocMetaData const *meta,GHFunc func, gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_meta_data_size</NAME>
<RETURNS>gsize		</RETURNS>
GsfDocMetaData const *meta
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_meta_dump</NAME>
<RETURNS>void		</RETURNS>
GsfDocMetaData const *meta
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_prop_new</NAME>
<RETURNS>GsfDocProp   *</RETURNS>
char *name
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_prop_free</NAME>
<RETURNS>void	      </RETURNS>
GsfDocProp *prop
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_prop_get_name</NAME>
<RETURNS>char const   *</RETURNS>
GsfDocProp const *prop
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_prop_get_val</NAME>
<RETURNS>GValue const *</RETURNS>
GsfDocProp const *prop
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_prop_set_val</NAME>
<RETURNS>void	      </RETURNS>
GsfDocProp *prop, GValue *val
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_prop_swap_val</NAME>
<RETURNS>GValue 	     *</RETURNS>
GsfDocProp *prop, GValue *val
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_prop_get_link</NAME>
<RETURNS>char const   *</RETURNS>
GsfDocProp const *prop
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_prop_set_link</NAME>
<RETURNS>void	      </RETURNS>
GsfDocProp *prop, char *link
</FUNCTION>
<FUNCTION>
<NAME>gsf_doc_prop_dump</NAME>
<RETURNS>void	      </RETURNS>
GsfDocProp const *prop
</FUNCTION>
<ENUM>
<NAME>GsfClipFormat</NAME>
typedef enum {
	GSF_CLIP_FORMAT_WINDOWS_CLIPBOARD = -1,
	GSF_CLIP_FORMAT_MACINTOSH_CLIPBOARD = -2,
	GSF_CLIP_FORMAT_GUID = -3,
	GSF_CLIP_FORMAT_NO_DATA = 0,
	GSF_CLIP_FORMAT_CLIPBOARD_FORMAT_NAME = 1, /* in the file it's actually any positive integer */
	GSF_CLIP_FORMAT_UNKNOWN /* this is our own value for unknown types or invalid data */
} GsfClipFormat;
</ENUM>
<ENUM>
<NAME>GsfClipFormatWindows</NAME>
typedef enum {
	GSF_CLIP_FORMAT_WINDOWS_ERROR = -1,		/* our own value */
	GSF_CLIP_FORMAT_WINDOWS_UNKNOWN = -2,		/* our own value */
	GSF_CLIP_FORMAT_WINDOWS_METAFILE = 3,		/* CF_METAFILEPICT */
	GSF_CLIP_FORMAT_WINDOWS_DIB = 8,		/* CF_DIB */
	GSF_CLIP_FORMAT_WINDOWS_ENHANCED_METAFILE = 14	/* CF_ENHMETAFILE */
} GsfClipFormatWindows;
</ENUM>
<MACRO>
<NAME>GSF_TYPE_CLIP_DATA</NAME>
#define GSF_TYPE_CLIP_DATA		(gsf_clip_data_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_CLIP_DATA</NAME>
#define GSF_CLIP_DATA(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GSF_TYPE_CLIP_DATA, GsfClipData))
</MACRO>
<MACRO>
<NAME>GSF_CLIP_DATA_CLASS</NAME>
#define GSF_CLIP_DATA_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GSF_TYPE_CLIP_DATA, GsfClipDataClass))
</MACRO>
<MACRO>
<NAME>GSF_IS_CLIP_DATA</NAME>
#define GSF_IS_CLIP_DATA(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSF_TYPE_CLIP_DATA))
</MACRO>
<MACRO>
<NAME>GSF_IS_CLIP_DATA_CLASS</NAME>
#define GSF_IS_CLIP_DATA_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GSF_TYPE_CLIP_DATA))
</MACRO>
<MACRO>
<NAME>GSF_CLIP_DATA_GET_CLASS</NAME>
#define GSF_CLIP_DATA_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GSF_TYPE_CLIP_DATA, GsfClipDataClass))
</MACRO>
<STRUCT>
<NAME>GsfClipData</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfClipDataClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfClipDataPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfClipData</NAME>
struct _GsfClipData {
	GObject object;

	GsfClipDataPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GsfClipDataClass</NAME>
struct _GsfClipDataClass {
	GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gsf_clip_data_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_clip_data_new</NAME>
<RETURNS>GsfClipData *</RETURNS>
GsfClipFormat format,GsfBlob *data_blob
</FUNCTION>
<FUNCTION>
<NAME>gsf_clip_data_get_format</NAME>
<RETURNS>GsfClipFormat </RETURNS>
GsfClipData *clip_data
</FUNCTION>
<FUNCTION>
<NAME>gsf_clip_data_get_data_blob</NAME>
<RETURNS>GsfBlob *</RETURNS>
GsfClipData *clip_data
</FUNCTION>
<FUNCTION>
<NAME>gsf_clip_data_get_windows_clipboard_format</NAME>
<RETURNS>GsfClipFormatWindows </RETURNS>
GsfClipData *clip_data,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gsf_clip_data_peek_real_data</NAME>
<RETURNS>gconstpointer </RETURNS>
GsfClipData *clip_data,gsize *ret_size,GError **error
</FUNCTION>
<FUNCTION>
<NAME>gsf_msole_metadata_read</NAME>
<RETURNS>GError	   *</RETURNS>
GsfInput *in,GsfDocMetaData *accum
</FUNCTION>
<FUNCTION>
<NAME>gsf_msole_metadata_write</NAME>
<RETURNS>gboolean    </RETURNS>
GsfOutput *out,GsfDocMetaData const *meta_data,gboolean doc_not_component
</FUNCTION>
<FUNCTION>
<NAME>gsf_msole_lid_for_language</NAME>
<RETURNS>guint	    </RETURNS>
char const *lang
</FUNCTION>
<FUNCTION>
<NAME>gsf_msole_codepage_to_lid</NAME>
<RETURNS>guint	    </RETURNS>
int codepage
</FUNCTION>
<FUNCTION>
<NAME>gsf_msole_lid_to_codepage</NAME>
<RETURNS>int	    </RETURNS>
guint lid
</FUNCTION>
<FUNCTION>
<NAME>gsf_msole_lid_to_codepage_str</NAME>
<RETURNS>gchar	   *</RETURNS>
guint lid
</FUNCTION>
<FUNCTION>
<NAME>gsf_msole_language_for_lid</NAME>
<RETURNS>char const *</RETURNS>
guint lid
</FUNCTION>
<FUNCTION>
<NAME>gsf_msole_iconv_win_codepage</NAME>
<RETURNS>int	    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_msole_iconv_open_for_import</NAME>
<RETURNS>GIConv	    </RETURNS>
int codepage
</FUNCTION>
<FUNCTION>
<NAME>gsf_msole_iconv_open_for_export</NAME>
<RETURNS>GIConv	    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_msole_iconv_open_codepage_for_import</NAME>
<RETURNS>GIConv	    </RETURNS>
char const *to, int codepage
</FUNCTION>
<FUNCTION>
<NAME>gsf_msole_iconv_open_codepages_for_export</NAME>
<RETURNS>GIConv	    </RETURNS>
int codepage_to, char const *from
</FUNCTION>
<FUNCTION>
<NAME>gsf_msole_iconv_open_codepage_for_export</NAME>
<RETURNS>GIConv	    </RETURNS>
int codepage_to
</FUNCTION>
<FUNCTION>
<NAME>gsf_msole_inflate</NAME>
<RETURNS>GByteArray *</RETURNS>
GsfInput *input, gsf_off_t offset
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_memory_new_from_bzip</NAME>
<RETURNS>GsfInput *</RETURNS>
GsfInput *source, GError **err
</FUNCTION>
<MACRO>
<NAME>GSF_INPUT_HTTP_TYPE</NAME>
#define GSF_INPUT_HTTP_TYPE	(gsf_input_http_get_type())
</MACRO>
<MACRO>
<NAME>GSF_INPUT_HTTP</NAME>
#define GSF_INPUT_HTTP(obj)	(G_TYPE_CHECK_INSTANCE_CAST((obj), GSF_INPUT_HTTP_TYPE, GsfInputHTTP))
</MACRO>
<MACRO>
<NAME>GSF_IS_INPUT_HTTP</NAME>
#define GSF_IS_INPUT_HTTP(obj)	(G_TYPE_CHECK_INSTANCE_TYPE((obj), GSF_INPUT_HTTP_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfInputHTTP</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_input_http_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_http_new</NAME>
<RETURNS>GsfInput *</RETURNS>
gchar const *url, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_http_get_url</NAME>
<RETURNS>gchar	 *</RETURNS>
GsfInputHTTP *input
</FUNCTION>
<FUNCTION>
<NAME>gsf_input_http_get_content_type</NAME>
<RETURNS>gchar	 *</RETURNS>
GsfInputHTTP *input
</FUNCTION>
<MACRO>
<NAME>GSF_OUTPUT_STDIO_TYPE</NAME>
#define GSF_OUTPUT_STDIO_TYPE        (gsf_output_stdio_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTPUT_STDIO</NAME>
#define GSF_OUTPUT_STDIO(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTPUT_STDIO_TYPE, GsfOutputStdio))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTPUT_STDIO</NAME>
#define GSF_IS_OUTPUT_STDIO(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTPUT_STDIO_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfOutputStdio</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_output_stdio_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_stdio_new</NAME>
<RETURNS>GsfOutput *</RETURNS>
char const *filename, GError **err
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_stdio_new_full</NAME>
<RETURNS>GsfOutput *</RETURNS>
char const *filename, GError **err,char const *first_property_name,...
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_stdio_new_valist</NAME>
<RETURNS>GsfOutput *</RETURNS>
char const *filename, GError **err,char const *first_property_name,va_list     var_args
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_stdio_new_FILE</NAME>
<RETURNS>GsfOutput *</RETURNS>
char const *filename, FILE *file,gboolean keep_open
</FUNCTION>
<MACRO>
<NAME>GSF_INFILE_TYPE</NAME>
#define GSF_INFILE_TYPE        (gsf_infile_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_INFILE</NAME>
#define GSF_INFILE(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_INFILE_TYPE, GsfInfile))
</MACRO>
<MACRO>
<NAME>GSF_IS_INFILE</NAME>
#define GSF_IS_INFILE(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_INFILE_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_infile_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_infile_num_children</NAME>
<RETURNS>int	    </RETURNS>
GsfInfile *infile
</FUNCTION>
<FUNCTION>
<NAME>gsf_infile_name_by_index</NAME>
<RETURNS>char const *</RETURNS>
GsfInfile *infile, int i
</FUNCTION>
<FUNCTION>
<NAME>gsf_infile_child_by_index</NAME>
<RETURNS>GsfInput   *</RETURNS>
GsfInfile *infile, int i
</FUNCTION>
<FUNCTION>
<NAME>gsf_infile_child_by_name</NAME>
<RETURNS>GsfInput   *</RETURNS>
GsfInfile *infile, char const *name
</FUNCTION>
<FUNCTION>
<NAME>gsf_infile_child_by_vname</NAME>
<RETURNS>GsfInput   *</RETURNS>
GsfInfile *infile, char const *name, ...
</FUNCTION>
<STRUCT>
<NAME>GsfOutputClass</NAME>
typedef struct {
	GObjectClass g_object_class;

	gboolean (*Close)   (GsfOutput *output);
	gboolean (*Seek)    (GsfOutput *output,
			     gsf_off_t offset, GSeekType whence);
	gboolean (*Write)   (GsfOutput *output,
			     size_t num_bytes, guint8 const *data);
	gsf_off_t (*Vprintf) (GsfOutput *output,
			     char const *format, va_list args)
			     G_GNUC_PRINTF (2, 0);
} GsfOutputClass;
</STRUCT>
<MACRO>
<NAME>GSF_OUTPUT_CLASS</NAME>
#define GSF_OUTPUT_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST ((k), GSF_OUTPUT_TYPE, GsfOutputClass))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTPUT_CLASS</NAME>
#define GSF_IS_OUTPUT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GSF_OUTPUT_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfOutput</NAME>
struct _GsfOutput {
	GObject g_object;

	/*< protected >*/
	gsf_off_t   cur_size, cur_offset;
	char       *name;
	GObject    *wrapped_by;
	GsfOutfile *container;
	GError	   *err;
	gboolean    is_closed;

	char	   *printf_buf;
	int	    printf_buf_size;
};
</STRUCT>
<MACRO>
<NAME>GSF_OUTPUT_TYPE</NAME>
#define GSF_OUTPUT_TYPE        (gsf_output_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTPUT</NAME>
#define GSF_OUTPUT(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTPUT_TYPE, GsfOutput))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTPUT</NAME>
#define GSF_IS_OUTPUT(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTPUT_TYPE))
</MACRO>
<FUNCTION>
<NAME>gsf_output_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_name</NAME>
<RETURNS>char const   *</RETURNS>
GsfOutput const *output
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_container</NAME>
<RETURNS>GsfOutfile   *</RETURNS>
GsfOutput const *output
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_error</NAME>
<RETURNS>GError const *</RETURNS>
GsfOutput const *output
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_set_error</NAME>
<RETURNS>gboolean </RETURNS>
GsfOutput *output,gint        code,char const *format,...
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_size</NAME>
<RETURNS>gsf_off_t     </RETURNS>
GsfOutput *output
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_close</NAME>
<RETURNS>gboolean      </RETURNS>
GsfOutput *output
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_is_closed</NAME>
<RETURNS>gboolean      </RETURNS>
GsfOutput const *output
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_tell</NAME>
<RETURNS>gsf_off_t     </RETURNS>
GsfOutput *output
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_seek</NAME>
<RETURNS>gboolean      </RETURNS>
GsfOutput *output,gsf_off_t offset, GSeekType whence
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_write</NAME>
<RETURNS>gboolean      </RETURNS>
GsfOutput *output,size_t num_bytes, guint8 const *data
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_wrap</NAME>
<RETURNS>gboolean </RETURNS>
GObject *wrapper, GsfOutput *wrapee
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_unwrap</NAME>
<RETURNS>gboolean </RETURNS>
GObject *wrapper, GsfOutput *wrapee
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_error_id</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_printf</NAME>
<RETURNS>gboolean </RETURNS>
GsfOutput *output, char const *format,...
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_vprintf</NAME>
<RETURNS>gsf_off_t </RETURNS>
GsfOutput *output, char const *format,va_list args
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_puts</NAME>
<RETURNS>gboolean </RETURNS>
GsfOutput *output, char const *line
</FUNCTION>
<MACRO>
<NAME>GSF_TIMESTAMP_TYPE</NAME>
#define GSF_TIMESTAMP_TYPE      (gsf_timestamp_get_type ())
</MACRO>
<MACRO>
<NAME>VAL_IS_GSF_TIMESTAMP</NAME>
#define VAL_IS_GSF_TIMESTAMP(v) (G_TYPE_CHECK_VALUE_TYPE((v), GSF_TIMESTAMP_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfTimestamp</NAME>
struct _GsfTimestamp {
	GDate	  date;			/* In local timezone */
	glong     seconds;		/* time of day */
	GString	  time_zone;		/* possibly blank */

	guint32	  timet;
};
</STRUCT>
<FUNCTION>
<NAME>gsf_timestamp_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_timestamp_copy</NAME>
<RETURNS>GsfTimestamp *</RETURNS>
GsfTimestamp const *stamp
</FUNCTION>
<FUNCTION>
<NAME>gsf_timestamp_free</NAME>
<RETURNS>void          </RETURNS>
GsfTimestamp       *stamp
</FUNCTION>
<FUNCTION>
<NAME>gsf_timestamp_parse</NAME>
<RETURNS>int           </RETURNS>
char const *spec, GsfTimestamp *stamp
</FUNCTION>
<FUNCTION>
<NAME>gsf_timestamp_as_string</NAME>
<RETURNS>char 	     *</RETURNS>
GsfTimestamp const *stamp
</FUNCTION>
<FUNCTION>
<NAME>gsf_timestamp_hash</NAME>
<RETURNS>guint         </RETURNS>
GsfTimestamp const *stamp
</FUNCTION>
<FUNCTION>
<NAME>gsf_timestamp_equal</NAME>
<RETURNS>gboolean      </RETURNS>
GsfTimestamp const *a,GsfTimestamp const *b
</FUNCTION>
<FUNCTION>
<NAME>gsf_value_set_timestamp</NAME>
<RETURNS>void </RETURNS>
GValue *value, GsfTimestamp const *stamp
</FUNCTION>
<MACRO>
<NAME>GSF_OUTPUT_GZIP_TYPE</NAME>
#define GSF_OUTPUT_GZIP_TYPE        (gsf_output_gzip_get_type ())
</MACRO>
<MACRO>
<NAME>GSF_OUTPUT_GZIP</NAME>
#define GSF_OUTPUT_GZIP(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), GSF_OUTPUT_GZIP_TYPE, GsfOutputGZip))
</MACRO>
<MACRO>
<NAME>GSF_IS_OUTPUT_GZIP</NAME>
#define GSF_IS_OUTPUT_GZIP(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSF_OUTPUT_GZIP_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfOutputGZip</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsf_output_gzip_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsf_output_gzip_new</NAME>
<RETURNS>GsfOutput *</RETURNS>
GsfOutput *sink, GError **err
</FUNCTION>
<STRUCT>
<NAME>GsfInfile</NAME>
struct _GsfInfile {
	GsfInput parent;
};
</STRUCT>
<STRUCT>
<NAME>GsfInfileClass</NAME>
typedef struct {
	GsfInputClass input_class;
	int	    (*num_children)   (GsfInfile *infile);
	char const *(*name_by_index)  (GsfInfile *infile, int i);
	GsfInput   *(*child_by_index) (GsfInfile *infile,
				       int i, GError **err);
	GsfInput   *(*child_by_name)  (GsfInfile *infile,
				       char const *name, GError **err);
} GsfInfileClass;
</STRUCT>
<MACRO>
<NAME>GSF_INFILE_CLASS</NAME>
#define GSF_INFILE_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST ((k), GSF_INFILE_TYPE, GsfInfileClass))
</MACRO>
<MACRO>
<NAME>GSF_IS_INFILE_CLASS</NAME>
#define GSF_IS_INFILE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GSF_INFILE_TYPE))
</MACRO>
<STRUCT>
<NAME>GsfInput</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfInfile</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfOutput</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfOutfile</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfDocProp</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfDocMetaData</NAME>
</STRUCT>
<STRUCT>
<NAME>GsfTimestamp</NAME>
</STRUCT>
<TYPEDEF>
<NAME>gsf_off_t</NAME>
typedef gint64 gsf_off_t;
</TYPEDEF>
<MACRO>
<NAME>GSF_OFF_T_FORMAT</NAME>
#define GSF_OFF_T_FORMAT	G_GINT64_FORMAT
</MACRO>
