Imported Upstream version 1.1.4upstream/1.1.4upstream

1 files changed, 401 insertions, 0 deletions

diff --git a/xd_edsio.h b/xd_edsio.h
new file mode 100755
index 0000000..fef9051
--- /dev/null
+++ b/xd_edsio.h
@@ -0,0 +1,401 @@
+/* -*-Mode: C;-*-
+ * Copyright (C) 1997, 1998, 1999  Josh MacDonald
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Author: Josh MacDonald <jmacd@CS.Berkeley.EDU>
+ *
+ * This file was AUTOMATICALLY GENERATED using:
+ *
+ * $Id: edsio.el 1.2 Sun, 28 Jan 2007 12:21:11 -0800 jmacd $
+ */
+
+#include "edsio.h"
+
+#include "xdelta.h"
+
+#ifndef _XD_EDSIO_H_
+#define _XD_EDSIO_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "edsio_edsio.h"
+
+/* Initialize this library. */
+
+gboolean xd_edsio_init (void);
+
+/* Types defined here. */
+
+/* XdStringEventCode.
+ */
+
+typedef struct _XdStringEventCode XdStringEventCode;
+struct _XdStringEventCode { gint code; };
+
+typedef struct _XdStringEvent XdStringEvent;
+struct _XdStringEvent { gint code; const char* srcfile; guint srcline; const char* version; };
+
+/* XdHandleIntIntEventCode.
+ */
+
+typedef struct _XdHandleIntIntEventCode XdHandleIntIntEventCode;
+struct _XdHandleIntIntEventCode { gint code; };
+
+typedef struct _XdHandleIntIntEvent XdHandleIntIntEvent;
+struct _XdHandleIntIntEvent { gint code; const char* srcfile; guint srcline; FileHandle* stream; int expected; int received; };
+
+/* XdHandleStringStringEventCode.
+ */
+
+typedef struct _XdHandleStringStringEventCode XdHandleStringStringEventCode;
+struct _XdHandleStringStringEventCode { gint code; };
+
+typedef struct _XdHandleStringStringEvent XdHandleStringStringEvent;
+struct _XdHandleStringStringEvent { gint code; const char* srcfile; guint srcline; FileHandle* stream; const char* expected; const char* received; };
+
+/* XdIntEventCode.
+ */
+
+typedef struct _XdIntEventCode XdIntEventCode;
+struct _XdIntEventCode { gint code; };
+
+typedef struct _XdIntEvent XdIntEvent;
+struct _XdIntEvent { gint code; const char* srcfile; guint srcline; int index; };
+
+/* XdVoidEventCode.
+ */
+
+typedef struct _XdVoidEventCode XdVoidEventCode;
+struct _XdVoidEventCode { gint code; };
+
+typedef struct _XdVoidEvent XdVoidEvent;
+struct _XdVoidEvent { gint code; const char* srcfile; guint srcline; };
+
+typedef struct _SerialVersion0Instruction SerialVersion0Instruction;
+typedef struct _SerialVersion0Control SerialVersion0Control;
+typedef struct _SerialVersion0SourceInfo SerialVersion0SourceInfo;
+typedef struct _SerialRsyncIndex SerialRsyncIndex;
+typedef struct _SerialRsyncIndexElt SerialRsyncIndexElt;
+typedef struct _SerialXdeltaInstruction SerialXdeltaInstruction;
+typedef struct _SerialXdeltaControl SerialXdeltaControl;
+typedef struct _SerialXdeltaSourceInfo SerialXdeltaSourceInfo;
+typedef struct _SerialXdeltaIndex SerialXdeltaIndex;
+typedef struct _SerialXdeltaChecksum SerialXdeltaChecksum;
+/* Functions declared here. */
+
+/* Serial Types */
+
+enum _SerialXdType {
+
+  ST_XdeltaChecksum = (1<<(1+EDSIO_LIBRARY_OFFSET_BITS))+3, 
+  ST_XdeltaIndex = (1<<(2+EDSIO_LIBRARY_OFFSET_BITS))+3, 
+  ST_XdeltaSourceInfo = (1<<(3+EDSIO_LIBRARY_OFFSET_BITS))+3, 
+  ST_XdeltaControl = (1<<(7+EDSIO_LIBRARY_OFFSET_BITS))+3, 
+  ST_XdeltaInstruction = (1<<(8+EDSIO_LIBRARY_OFFSET_BITS))+3, 
+  ST_RsyncIndexElt = (1<<(9+EDSIO_LIBRARY_OFFSET_BITS))+3, 
+  ST_RsyncIndex = (1<<(10+EDSIO_LIBRARY_OFFSET_BITS))+3, 
+  ST_Version0SourceInfo = (1<<(4+EDSIO_LIBRARY_OFFSET_BITS))+3, 
+  ST_Version0Control = (1<<(5+EDSIO_LIBRARY_OFFSET_BITS))+3, 
+  ST_Version0Instruction = (1<<(6+EDSIO_LIBRARY_OFFSET_BITS))+3
+};
+
+
+
+/* XdeltaChecksum Structure
+ */
+
+struct _SerialXdeltaChecksum {
+  guint16 high;
+  guint16 low;
+};
+
+void     serializeio_print_xdeltachecksum_obj        (SerialXdeltaChecksum* obj, guint indent_spaces);
+
+gboolean unserialize_xdeltachecksum                  (SerialSource *source, SerialXdeltaChecksum**);
+gboolean unserialize_xdeltachecksum_internal         (SerialSource *source, SerialXdeltaChecksum** );
+gboolean unserialize_xdeltachecksum_internal_noalloc (SerialSource *source, SerialXdeltaChecksum* );
+gboolean serialize_xdeltachecksum                    (SerialSink *sink, guint16 high, guint16 low);
+gboolean serialize_xdeltachecksum_obj                (SerialSink *sink, const SerialXdeltaChecksum* obj);
+gboolean serialize_xdeltachecksum_internal           (SerialSink *sink, guint16 high, guint16 low);
+gboolean serialize_xdeltachecksum_obj_internal (SerialSink *sink, SerialXdeltaChecksum* obj);
+guint    serializeio_count_xdeltachecksum            (guint16 high, guint16 low);
+guint    serializeio_count_xdeltachecksum_obj        (SerialXdeltaChecksum const* obj);
+
+/* XdeltaIndex Structure
+ */
+
+struct _SerialXdeltaIndex {
+  guint32 file_len;
+  guint8 file_md5[16];
+  guint32 index_len;
+  SerialXdeltaChecksum* index;
+};
+
+void     serializeio_print_xdeltaindex_obj        (SerialXdeltaIndex* obj, guint indent_spaces);
+
+gboolean unserialize_xdeltaindex                  (SerialSource *source, SerialXdeltaIndex**);
+gboolean unserialize_xdeltaindex_internal         (SerialSource *source, SerialXdeltaIndex** );
+gboolean unserialize_xdeltaindex_internal_noalloc (SerialSource *source, SerialXdeltaIndex* );
+gboolean serialize_xdeltaindex                    (SerialSink *sink, guint32 file_len, const guint8 file_md5[16], guint32 index_len, SerialXdeltaChecksum const* index);
+gboolean serialize_xdeltaindex_obj                (SerialSink *sink, const SerialXdeltaIndex* obj);
+gboolean serialize_xdeltaindex_internal           (SerialSink *sink, guint32 file_len, const guint8 file_md5[16], guint32 index_len, SerialXdeltaChecksum const* index);
+gboolean serialize_xdeltaindex_obj_internal (SerialSink *sink, SerialXdeltaIndex* obj);
+guint    serializeio_count_xdeltaindex            (guint32 file_len, const guint8 file_md5[16], guint32 index_len, SerialXdeltaChecksum const* index);
+guint    serializeio_count_xdeltaindex_obj        (SerialXdeltaIndex const* obj);
+
+/* XdeltaSourceInfo Structure
+ */
+
+struct _SerialXdeltaSourceInfo {
+  const gchar* name;
+  guint8 md5[16];
+  guint32 len;
+  gboolean isdata;
+  gboolean sequential;
+  guint32       position;
+  guint32       copies;
+  guint32       copy_length;
+  FileHandle   *in;
+};
+
+void     serializeio_print_xdeltasourceinfo_obj        (SerialXdeltaSourceInfo* obj, guint indent_spaces);
+
+gboolean unserialize_xdeltasourceinfo                  (SerialSource *source, SerialXdeltaSourceInfo**);
+gboolean unserialize_xdeltasourceinfo_internal         (SerialSource *source, SerialXdeltaSourceInfo** );
+gboolean unserialize_xdeltasourceinfo_internal_noalloc (SerialSource *source, SerialXdeltaSourceInfo* );
+gboolean serialize_xdeltasourceinfo                    (SerialSink *sink, const gchar* name, const guint8 md5[16], guint32 len, gboolean isdata, gboolean sequential);
+gboolean serialize_xdeltasourceinfo_obj                (SerialSink *sink, const SerialXdeltaSourceInfo* obj);
+gboolean serialize_xdeltasourceinfo_internal           (SerialSink *sink, const gchar* name, const guint8 md5[16], guint32 len, gboolean isdata, gboolean sequential);
+gboolean serialize_xdeltasourceinfo_obj_internal (SerialSink *sink, SerialXdeltaSourceInfo* obj);
+guint    serializeio_count_xdeltasourceinfo            (const gchar* name, const guint8 md5[16], guint32 len, gboolean isdata, gboolean sequential);
+guint    serializeio_count_xdeltasourceinfo_obj        (SerialXdeltaSourceInfo const* obj);
+
+/* XdeltaControl Structure
+ */
+
+struct _SerialXdeltaControl {
+  guint8 to_md5[16];
+  guint32 to_len;
+  gboolean has_data;
+  guint32 source_info_len;
+  SerialXdeltaSourceInfo** source_info;
+  guint32 inst_len;
+  SerialXdeltaInstruction* inst;
+  GArray    *inst_array;
+  GPtrArray *source_info_array;
+};
+
+void     serializeio_print_xdeltacontrol_obj        (SerialXdeltaControl* obj, guint indent_spaces);
+
+gboolean unserialize_xdeltacontrol                  (SerialSource *source, SerialXdeltaControl**);
+gboolean unserialize_xdeltacontrol_internal         (SerialSource *source, SerialXdeltaControl** );
+gboolean unserialize_xdeltacontrol_internal_noalloc (SerialSource *source, SerialXdeltaControl* );
+gboolean serialize_xdeltacontrol                    (SerialSink *sink, const guint8 to_md5[16], guint32 to_len, gboolean has_data, guint32 source_info_len, SerialXdeltaSourceInfo* const* source_info, guint32 inst_len, SerialXdeltaInstruction const* inst);
+gboolean serialize_xdeltacontrol_obj                (SerialSink *sink, const SerialXdeltaControl* obj);
+gboolean serialize_xdeltacontrol_internal           (SerialSink *sink, const guint8 to_md5[16], guint32 to_len, gboolean has_data, guint32 source_info_len, SerialXdeltaSourceInfo* const* source_info, guint32 inst_len, SerialXdeltaInstruction const* inst);
+gboolean serialize_xdeltacontrol_obj_internal (SerialSink *sink, SerialXdeltaControl* obj);
+guint    serializeio_count_xdeltacontrol            (const guint8 to_md5[16], guint32 to_len, gboolean has_data, guint32 source_info_len, SerialXdeltaSourceInfo* const* source_info, guint32 inst_len, SerialXdeltaInstruction const* inst);
+guint    serializeio_count_xdeltacontrol_obj        (SerialXdeltaControl const* obj);
+
+/* XdeltaInstruction Structure
+ */
+
+struct _SerialXdeltaInstruction {
+  guint32 index;
+  guint32 offset;
+  guint32 length;
+  guint32 output_start;
+};
+
+void     serializeio_print_xdeltainstruction_obj        (SerialXdeltaInstruction* obj, guint indent_spaces);
+
+gboolean unserialize_xdeltainstruction                  (SerialSource *source, SerialXdeltaInstruction**);
+gboolean unserialize_xdeltainstruction_internal         (SerialSource *source, SerialXdeltaInstruction** );
+gboolean unserialize_xdeltainstruction_internal_noalloc (SerialSource *source, SerialXdeltaInstruction* );
+gboolean serialize_xdeltainstruction                    (SerialSink *sink, guint32 index, guint32 offset, guint32 length);
+gboolean serialize_xdeltainstruction_obj                (SerialSink *sink, const SerialXdeltaInstruction* obj);
+gboolean serialize_xdeltainstruction_internal           (SerialSink *sink, guint32 index, guint32 offset, guint32 length);
+gboolean serialize_xdeltainstruction_obj_internal (SerialSink *sink, SerialXdeltaInstruction* obj);
+guint    serializeio_count_xdeltainstruction            (guint32 index, guint32 offset, guint32 length);
+guint    serializeio_count_xdeltainstruction_obj        (SerialXdeltaInstruction const* obj);
+
+/* RsyncIndexElt Structure
+ */
+
+struct _SerialRsyncIndexElt {
+  guint8 md5[16];
+  SerialXdeltaChecksum cksum;
+  SerialRsyncIndexElt* next;
+  gint match_offset;
+};
+
+void     serializeio_print_rsyncindexelt_obj        (SerialRsyncIndexElt* obj, guint indent_spaces);
+
+gboolean unserialize_rsyncindexelt                  (SerialSource *source, SerialRsyncIndexElt**);
+gboolean unserialize_rsyncindexelt_internal         (SerialSource *source, SerialRsyncIndexElt** );
+gboolean unserialize_rsyncindexelt_internal_noalloc (SerialSource *source, SerialRsyncIndexElt* );
+gboolean serialize_rsyncindexelt                    (SerialSink *sink, const guint8 md5[16], SerialXdeltaChecksum const* cksum);
+gboolean serialize_rsyncindexelt_obj                (SerialSink *sink, const SerialRsyncIndexElt* obj);
+gboolean serialize_rsyncindexelt_internal           (SerialSink *sink, const guint8 md5[16], SerialXdeltaChecksum const* cksum);
+gboolean serialize_rsyncindexelt_obj_internal (SerialSink *sink, SerialRsyncIndexElt* obj);
+guint    serializeio_count_rsyncindexelt            (const guint8 md5[16], SerialXdeltaChecksum const* cksum);
+guint    serializeio_count_rsyncindexelt_obj        (SerialRsyncIndexElt const* obj);
+
+/* RsyncIndex Structure
+ */
+
+struct _SerialRsyncIndex {
+  guint32 seg_len;
+  guint32 file_len;
+  guint8 file_md5[16];
+  guint32 index_len;
+  SerialRsyncIndexElt* index;
+  SerialRsyncIndexElt** table;
+  guint table_size;
+};
+
+void     serializeio_print_rsyncindex_obj        (SerialRsyncIndex* obj, guint indent_spaces);
+
+gboolean unserialize_rsyncindex                  (SerialSource *source, SerialRsyncIndex**);
+gboolean unserialize_rsyncindex_internal         (SerialSource *source, SerialRsyncIndex** );
+gboolean unserialize_rsyncindex_internal_noalloc (SerialSource *source, SerialRsyncIndex* );
+gboolean serialize_rsyncindex                    (SerialSink *sink, guint32 seg_len, guint32 file_len, const guint8 file_md5[16], guint32 index_len, SerialRsyncIndexElt const* index);
+gboolean serialize_rsyncindex_obj                (SerialSink *sink, const SerialRsyncIndex* obj);
+gboolean serialize_rsyncindex_internal           (SerialSink *sink, guint32 seg_len, guint32 file_len, const guint8 file_md5[16], guint32 index_len, SerialRsyncIndexElt const* index);
+gboolean serialize_rsyncindex_obj_internal (SerialSink *sink, SerialRsyncIndex* obj);
+guint    serializeio_count_rsyncindex            (guint32 seg_len, guint32 file_len, const guint8 file_md5[16], guint32 index_len, SerialRsyncIndexElt const* index);
+guint    serializeio_count_rsyncindex_obj        (SerialRsyncIndex const* obj);
+
+/* Version0SourceInfo Structure
+ */
+
+struct _SerialVersion0SourceInfo {
+  guint8 md5[16];
+  guint8 real_md5[16];
+  guint32 length;
+};
+
+void     serializeio_print_version0sourceinfo_obj        (SerialVersion0SourceInfo* obj, guint indent_spaces);
+
+gboolean unserialize_version0sourceinfo                  (SerialSource *source, SerialVersion0SourceInfo**);
+gboolean unserialize_version0sourceinfo_internal         (SerialSource *source, SerialVersion0SourceInfo** );
+gboolean unserialize_version0sourceinfo_internal_noalloc (SerialSource *source, SerialVersion0SourceInfo* );
+gboolean serialize_version0sourceinfo                    (SerialSink *sink, const guint8 md5[16], const guint8 real_md5[16], guint32 length);
+gboolean serialize_version0sourceinfo_obj                (SerialSink *sink, const SerialVersion0SourceInfo* obj);
+gboolean serialize_version0sourceinfo_internal           (SerialSink *sink, const guint8 md5[16], const guint8 real_md5[16], guint32 length);
+gboolean serialize_version0sourceinfo_obj_internal (SerialSink *sink, SerialVersion0SourceInfo* obj);
+guint    serializeio_count_version0sourceinfo            (const guint8 md5[16], const guint8 real_md5[16], guint32 length);
+guint    serializeio_count_version0sourceinfo_obj        (SerialVersion0SourceInfo const* obj);
+
+/* Version0Control Structure
+ */
+
+struct _SerialVersion0Control {
+  gboolean normalized;
+  guint32 data_len;
+  SerialVersion0SourceInfo to_info;
+  guint32 source_info_len;
+  SerialVersion0SourceInfo** source_info;
+  guint32 inst_len;
+  SerialVersion0Instruction* inst;
+  GArray    *inst_array;
+  GPtrArray *source_info_array;
+};
+
+void     serializeio_print_version0control_obj        (SerialVersion0Control* obj, guint indent_spaces);
+
+gboolean unserialize_version0control                  (SerialSource *source, SerialVersion0Control**);
+gboolean unserialize_version0control_internal         (SerialSource *source, SerialVersion0Control** );
+gboolean unserialize_version0control_internal_noalloc (SerialSource *source, SerialVersion0Control* );
+gboolean serialize_version0control                    (SerialSink *sink, gboolean normalized, guint32 data_len, SerialVersion0SourceInfo const* to_info, guint32 source_info_len, SerialVersion0SourceInfo* const* source_info, guint32 inst_len, SerialVersion0Instruction const* inst);
+gboolean serialize_version0control_obj                (SerialSink *sink, const SerialVersion0Control* obj);
+gboolean serialize_version0control_internal           (SerialSink *sink, gboolean normalized, guint32 data_len, SerialVersion0SourceInfo const* to_info, guint32 source_info_len, SerialVersion0SourceInfo* const* source_info, guint32 inst_len, SerialVersion0Instruction const* inst);
+gboolean serialize_version0control_obj_internal (SerialSink *sink, SerialVersion0Control* obj);
+guint    serializeio_count_version0control            (gboolean normalized, guint32 data_len, SerialVersion0SourceInfo const* to_info, guint32 source_info_len, SerialVersion0SourceInfo* const* source_info, guint32 inst_len, SerialVersion0Instruction const* inst);
+guint    serializeio_count_version0control_obj        (SerialVersion0Control const* obj);
+
+/* Version0Instruction Structure
+ */
+
+struct _SerialVersion0Instruction {
+  guint32 offset;
+  guint32 length;
+  guint8 type;
+  guint8 index;
+};
+
+void     serializeio_print_version0instruction_obj        (SerialVersion0Instruction* obj, guint indent_spaces);
+
+gboolean unserialize_version0instruction                  (SerialSource *source, SerialVersion0Instruction**);
+gboolean unserialize_version0instruction_internal         (SerialSource *source, SerialVersion0Instruction** );
+gboolean unserialize_version0instruction_internal_noalloc (SerialSource *source, SerialVersion0Instruction* );
+gboolean serialize_version0instruction                    (SerialSink *sink, guint32 offset, guint32 length);
+gboolean serialize_version0instruction_obj                (SerialSink *sink, const SerialVersion0Instruction* obj);
+gboolean serialize_version0instruction_internal           (SerialSink *sink, guint32 offset, guint32 length);
+gboolean serialize_version0instruction_obj_internal (SerialSink *sink, SerialVersion0Instruction* obj);
+guint    serializeio_count_version0instruction            (guint32 offset, guint32 length);
+guint    serializeio_count_version0instruction_obj        (SerialVersion0Instruction const* obj);
+
+void xd_generate_void_event_internal (XdVoidEventCode code, const char* srcfile, gint srcline);
+#define xd_generate_void_event(ecode) xd_generate_void_event_internal((ecode),__FILE__,__LINE__)
+
+extern const XdVoidEventCode EC_XdTooFewSources;
+#define EC_XdTooFewSourcesValue ((0<<EDSIO_LIBRARY_OFFSET_BITS)+3)
+
+extern const XdVoidEventCode EC_XdTooManySources;
+#define EC_XdTooManySourcesValue ((1<<EDSIO_LIBRARY_OFFSET_BITS)+3)
+
+void xd_generate_int_event_internal (XdIntEventCode code, const char* srcfile, gint srcline, int index);
+#define xd_generate_int_event(ecode, index) xd_generate_int_event_internal((ecode),__FILE__,__LINE__, (index))
+
+extern const XdIntEventCode EC_XdOutOfRangeSourceIndex;
+#define EC_XdOutOfRangeSourceIndexValue ((2<<EDSIO_LIBRARY_OFFSET_BITS)+3)
+
+extern const XdVoidEventCode EC_XdInvalidControl;
+#define EC_XdInvalidControlValue ((3<<EDSIO_LIBRARY_OFFSET_BITS)+3)
+
+extern const XdVoidEventCode EC_XdInvalidRsyncCache;
+#define EC_XdInvalidRsyncCacheValue ((4<<EDSIO_LIBRARY_OFFSET_BITS)+3)
+
+extern const XdVoidEventCode EC_XdIncompatibleDelta;
+#define EC_XdIncompatibleDeltaValue ((5<<EDSIO_LIBRARY_OFFSET_BITS)+3)
+
+void xd_generate_handlestringstring_event_internal (XdHandleStringStringEventCode code, const char* srcfile, gint srcline, FileHandle* stream, const char* expected, const char* received);
+#define xd_generate_handlestringstring_event(ecode, stream, expected, received) xd_generate_handlestringstring_event_internal((ecode),__FILE__,__LINE__, (stream), (expected), (received))
+
+extern const XdHandleStringStringEventCode EC_XdStreamChecksumFailed;
+#define EC_XdStreamChecksumFailedValue ((6<<EDSIO_LIBRARY_OFFSET_BITS)+3)
+
+void xd_generate_handleintint_event_internal (XdHandleIntIntEventCode code, const char* srcfile, gint srcline, FileHandle* stream, int expected, int received);
+#define xd_generate_handleintint_event(ecode, stream, expected, received) xd_generate_handleintint_event_internal((ecode),__FILE__,__LINE__, (stream), (expected), (received))
+
+extern const XdHandleIntIntEventCode EC_XdStreamLengthFailed;
+#define EC_XdStreamLengthFailedValue ((7<<EDSIO_LIBRARY_OFFSET_BITS)+3)
+
+void xd_generate_string_event_internal (XdStringEventCode code, const char* srcfile, gint srcline, const char* version);
+#define xd_generate_string_event(ecode, version) xd_generate_string_event_internal((ecode),__FILE__,__LINE__, (version))
+
+extern const XdStringEventCode EC_XdBackwardCompatibilityMode;
+#define EC_XdBackwardCompatibilityModeValue ((8<<EDSIO_LIBRARY_OFFSET_BITS)+3)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _XD_EDSIO_H_ */
+