1 /* -*-Mode: C;-*-
2  * Copyright (C) 1997, 1998, 1999  Josh MacDonald
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  *
18  * Author: Josh MacDonald <jmacd@CS.Berkeley.EDU>
19  *
20  * This file was AUTOMATICALLY GENERATED using:
21  *
22  * $Id: edsio.el 1.2 Sun, 28 Jan 2007 12:21:11 -0800 jmacd $
23  */
24 
25 #include "edsio.h"
26 
27 #include "xdelta.h"
28 
29 #ifndef _XD_EDSIO_H_
30 #define _XD_EDSIO_H_
31 
32 #ifdef __cplusplus
33 extern "C" {
34 #endif
35 
36 #include "edsio_edsio.h"
37 
38 /* Initialize this library. */
39 
40 gboolean xd_edsio_init (void);
41 
42 /* Types defined here. */
43 
44 /* XdStringEventCode.
45  */
46 
47 typedef struct _XdStringEventCode XdStringEventCode;
48 struct _XdStringEventCode { gint code; };
49 
50 typedef struct _XdStringEvent XdStringEvent;
51 struct _XdStringEvent { gint code; const char* srcfile; guint srcline; const char* version; };
52 
53 /* XdHandleIntIntEventCode.
54  */
55 
56 typedef struct _XdHandleIntIntEventCode XdHandleIntIntEventCode;
57 struct _XdHandleIntIntEventCode { gint code; };
58 
59 typedef struct _XdHandleIntIntEvent XdHandleIntIntEvent;
60 struct _XdHandleIntIntEvent { gint code; const char* srcfile; guint srcline; FileHandle* stream; int expected; int received; };
61 
62 /* XdHandleStringStringEventCode.
63  */
64 
65 typedef struct _XdHandleStringStringEventCode XdHandleStringStringEventCode;
66 struct _XdHandleStringStringEventCode { gint code; };
67 
68 typedef struct _XdHandleStringStringEvent XdHandleStringStringEvent;
69 struct _XdHandleStringStringEvent { gint code; const char* srcfile; guint srcline; FileHandle* stream; const char* expected; const char* received; };
70 
71 /* XdIntEventCode.
72  */
73 
74 typedef struct _XdIntEventCode XdIntEventCode;
75 struct _XdIntEventCode { gint code; };
76 
77 typedef struct _XdIntEvent XdIntEvent;
78 struct _XdIntEvent { gint code; const char* srcfile; guint srcline; int index; };
79 
80 /* XdVoidEventCode.
81  */
82 
83 typedef struct _XdVoidEventCode XdVoidEventCode;
84 struct _XdVoidEventCode { gint code; };
85 
86 typedef struct _XdVoidEvent XdVoidEvent;
87 struct _XdVoidEvent { gint code; const char* srcfile; guint srcline; };
88 
89 typedef struct _SerialVersion0Instruction SerialVersion0Instruction;
90 typedef struct _SerialVersion0Control SerialVersion0Control;
91 typedef struct _SerialVersion0SourceInfo SerialVersion0SourceInfo;
92 typedef struct _SerialRsyncIndex SerialRsyncIndex;
93 typedef struct _SerialRsyncIndexElt SerialRsyncIndexElt;
94 typedef struct _SerialXdeltaInstruction SerialXdeltaInstruction;
95 typedef struct _SerialXdeltaControl SerialXdeltaControl;
96 typedef struct _SerialXdeltaSourceInfo SerialXdeltaSourceInfo;
97 typedef struct _SerialXdeltaIndex SerialXdeltaIndex;
98 typedef struct _SerialXdeltaChecksum SerialXdeltaChecksum;
99 /* Functions declared here. */
100 
101 /* Serial Types */
102 
103 enum _SerialXdType {
104 
105   ST_XdeltaChecksum = (1<<(1+EDSIO_LIBRARY_OFFSET_BITS))+3,
106   ST_XdeltaIndex = (1<<(2+EDSIO_LIBRARY_OFFSET_BITS))+3,
107   ST_XdeltaSourceInfo = (1<<(3+EDSIO_LIBRARY_OFFSET_BITS))+3,
108   ST_XdeltaControl = (1<<(7+EDSIO_LIBRARY_OFFSET_BITS))+3,
109   ST_XdeltaInstruction = (1<<(8+EDSIO_LIBRARY_OFFSET_BITS))+3,
110   ST_RsyncIndexElt = (1<<(9+EDSIO_LIBRARY_OFFSET_BITS))+3,
111   ST_RsyncIndex = (1<<(10+EDSIO_LIBRARY_OFFSET_BITS))+3,
112   ST_Version0SourceInfo = (1<<(4+EDSIO_LIBRARY_OFFSET_BITS))+3,
113   ST_Version0Control = (1<<(5+EDSIO_LIBRARY_OFFSET_BITS))+3,
114   ST_Version0Instruction = (1<<(6+EDSIO_LIBRARY_OFFSET_BITS))+3
115 };
116 
117 
118 
119 /* XdeltaChecksum Structure
120  */
121 
122 struct _SerialXdeltaChecksum {
123   guint16 high;
124   guint16 low;
125 };
126 
127 void     serializeio_print_xdeltachecksum_obj        (SerialXdeltaChecksum* obj, guint indent_spaces);
128 
129 gboolean unserialize_xdeltachecksum                  (SerialSource *source, SerialXdeltaChecksum**);
130 gboolean unserialize_xdeltachecksum_internal         (SerialSource *source, SerialXdeltaChecksum** );
131 gboolean unserialize_xdeltachecksum_internal_noalloc (SerialSource *source, SerialXdeltaChecksum* );
132 gboolean serialize_xdeltachecksum                    (SerialSink *sink, guint16 high, guint16 low);
133 gboolean serialize_xdeltachecksum_obj                (SerialSink *sink, const SerialXdeltaChecksum* obj);
134 gboolean serialize_xdeltachecksum_internal           (SerialSink *sink, guint16 high, guint16 low);
135 gboolean serialize_xdeltachecksum_obj_internal (SerialSink *sink, SerialXdeltaChecksum* obj);
136 guint    serializeio_count_xdeltachecksum            (guint16 high, guint16 low);
137 guint    serializeio_count_xdeltachecksum_obj        (SerialXdeltaChecksum const* obj);
138 
139 /* XdeltaIndex Structure
140  */
141 
142 struct _SerialXdeltaIndex {
143   guint32 file_len;
144   guint8 file_md5[16];
145   guint32 index_len;
146   SerialXdeltaChecksum* index;
147 };
148 
149 void     serializeio_print_xdeltaindex_obj        (SerialXdeltaIndex* obj, guint indent_spaces);
150 
151 gboolean unserialize_xdeltaindex                  (SerialSource *source, SerialXdeltaIndex**);
152 gboolean unserialize_xdeltaindex_internal         (SerialSource *source, SerialXdeltaIndex** );
153 gboolean unserialize_xdeltaindex_internal_noalloc (SerialSource *source, SerialXdeltaIndex* );
154 gboolean serialize_xdeltaindex                    (SerialSink *sink, guint32 file_len, const guint8 file_md5[16], guint32 index_len, SerialXdeltaChecksum const* index);
155 gboolean serialize_xdeltaindex_obj                (SerialSink *sink, const SerialXdeltaIndex* obj);
156 gboolean serialize_xdeltaindex_internal           (SerialSink *sink, guint32 file_len, const guint8 file_md5[16], guint32 index_len, SerialXdeltaChecksum const* index);
157 gboolean serialize_xdeltaindex_obj_internal (SerialSink *sink, SerialXdeltaIndex* obj);
158 guint    serializeio_count_xdeltaindex            (guint32 file_len, const guint8 file_md5[16], guint32 index_len, SerialXdeltaChecksum const* index);
159 guint    serializeio_count_xdeltaindex_obj        (SerialXdeltaIndex const* obj);
160 
161 /* XdeltaSourceInfo Structure
162  */
163 
164 struct _SerialXdeltaSourceInfo {
165   const gchar* name;
166   guint8 md5[16];
167   guint32 len;
168   gboolean isdata;
169   gboolean sequential;
170   guint32       position;
171   guint32       copies;
172   guint32       copy_length;
173   FileHandle   *in;
174 };
175 
176 void     serializeio_print_xdeltasourceinfo_obj        (SerialXdeltaSourceInfo* obj, guint indent_spaces);
177 
178 gboolean unserialize_xdeltasourceinfo                  (SerialSource *source, SerialXdeltaSourceInfo**);
179 gboolean unserialize_xdeltasourceinfo_internal         (SerialSource *source, SerialXdeltaSourceInfo** );
180 gboolean unserialize_xdeltasourceinfo_internal_noalloc (SerialSource *source, SerialXdeltaSourceInfo* );
181 gboolean serialize_xdeltasourceinfo                    (SerialSink *sink, const gchar* name, const guint8 md5[16], guint32 len, gboolean isdata, gboolean sequential);
182 gboolean serialize_xdeltasourceinfo_obj                (SerialSink *sink, const SerialXdeltaSourceInfo* obj);
183 gboolean serialize_xdeltasourceinfo_internal           (SerialSink *sink, const gchar* name, const guint8 md5[16], guint32 len, gboolean isdata, gboolean sequential);
184 gboolean serialize_xdeltasourceinfo_obj_internal (SerialSink *sink, SerialXdeltaSourceInfo* obj);
185 guint    serializeio_count_xdeltasourceinfo            (const gchar* name, const guint8 md5[16], guint32 len, gboolean isdata, gboolean sequential);
186 guint    serializeio_count_xdeltasourceinfo_obj        (SerialXdeltaSourceInfo const* obj);
187 
188 /* XdeltaControl Structure
189  */
190 
191 struct _SerialXdeltaControl {
192   guint8 to_md5[16];
193   guint32 to_len;
194   gboolean has_data;
195   guint32 source_info_len;
196   SerialXdeltaSourceInfo** source_info;
197   guint32 inst_len;
198   SerialXdeltaInstruction* inst;
199   GArray    *inst_array;
200   GPtrArray *source_info_array;
201 };
202 
203 void     serializeio_print_xdeltacontrol_obj        (SerialXdeltaControl* obj, guint indent_spaces);
204 
205 gboolean unserialize_xdeltacontrol                  (SerialSource *source, SerialXdeltaControl**);
206 gboolean unserialize_xdeltacontrol_internal         (SerialSource *source, SerialXdeltaControl** );
207 gboolean unserialize_xdeltacontrol_internal_noalloc (SerialSource *source, SerialXdeltaControl* );
208 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);
209 gboolean serialize_xdeltacontrol_obj                (SerialSink *sink, const SerialXdeltaControl* obj);
210 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);
211 gboolean serialize_xdeltacontrol_obj_internal (SerialSink *sink, SerialXdeltaControl* obj);
212 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);
213 guint    serializeio_count_xdeltacontrol_obj        (SerialXdeltaControl const* obj);
214 
215 /* XdeltaInstruction Structure
216  */
217 
218 struct _SerialXdeltaInstruction {
219   guint32 index;
220   guint32 offset;
221   guint32 length;
222   guint32 output_start;
223 };
224 
225 void     serializeio_print_xdeltainstruction_obj        (SerialXdeltaInstruction* obj, guint indent_spaces);
226 
227 gboolean unserialize_xdeltainstruction                  (SerialSource *source, SerialXdeltaInstruction**);
228 gboolean unserialize_xdeltainstruction_internal         (SerialSource *source, SerialXdeltaInstruction** );
229 gboolean unserialize_xdeltainstruction_internal_noalloc (SerialSource *source, SerialXdeltaInstruction* );
230 gboolean serialize_xdeltainstruction                    (SerialSink *sink, guint32 index, guint32 offset, guint32 length);
231 gboolean serialize_xdeltainstruction_obj                (SerialSink *sink, const SerialXdeltaInstruction* obj);
232 gboolean serialize_xdeltainstruction_internal           (SerialSink *sink, guint32 index, guint32 offset, guint32 length);
233 gboolean serialize_xdeltainstruction_obj_internal (SerialSink *sink, SerialXdeltaInstruction* obj);
234 guint    serializeio_count_xdeltainstruction            (guint32 index, guint32 offset, guint32 length);
235 guint    serializeio_count_xdeltainstruction_obj        (SerialXdeltaInstruction const* obj);
236 
237 /* RsyncIndexElt Structure
238  */
239 
240 struct _SerialRsyncIndexElt {
241   guint8 md5[16];
242   SerialXdeltaChecksum cksum;
243   SerialRsyncIndexElt* next;
244   gint match_offset;
245 };
246 
247 void     serializeio_print_rsyncindexelt_obj        (SerialRsyncIndexElt* obj, guint indent_spaces);
248 
249 gboolean unserialize_rsyncindexelt                  (SerialSource *source, SerialRsyncIndexElt**);
250 gboolean unserialize_rsyncindexelt_internal         (SerialSource *source, SerialRsyncIndexElt** );
251 gboolean unserialize_rsyncindexelt_internal_noalloc (SerialSource *source, SerialRsyncIndexElt* );
252 gboolean serialize_rsyncindexelt                    (SerialSink *sink, const guint8 md5[16], SerialXdeltaChecksum const* cksum);
253 gboolean serialize_rsyncindexelt_obj                (SerialSink *sink, const SerialRsyncIndexElt* obj);
254 gboolean serialize_rsyncindexelt_internal           (SerialSink *sink, const guint8 md5[16], SerialXdeltaChecksum const* cksum);
255 gboolean serialize_rsyncindexelt_obj_internal (SerialSink *sink, SerialRsyncIndexElt* obj);
256 guint    serializeio_count_rsyncindexelt            (const guint8 md5[16], SerialXdeltaChecksum const* cksum);
257 guint    serializeio_count_rsyncindexelt_obj        (SerialRsyncIndexElt const* obj);
258 
259 /* RsyncIndex Structure
260  */
261 
262 struct _SerialRsyncIndex {
263   guint32 seg_len;
264   guint32 file_len;
265   guint8 file_md5[16];
266   guint32 index_len;
267   SerialRsyncIndexElt* index;
268   SerialRsyncIndexElt** table;
269   guint table_size;
270 };
271 
272 void     serializeio_print_rsyncindex_obj        (SerialRsyncIndex* obj, guint indent_spaces);
273 
274 gboolean unserialize_rsyncindex                  (SerialSource *source, SerialRsyncIndex**);
275 gboolean unserialize_rsyncindex_internal         (SerialSource *source, SerialRsyncIndex** );
276 gboolean unserialize_rsyncindex_internal_noalloc (SerialSource *source, SerialRsyncIndex* );
277 gboolean serialize_rsyncindex                    (SerialSink *sink, guint32 seg_len, guint32 file_len, const guint8 file_md5[16], guint32 index_len, SerialRsyncIndexElt const* index);
278 gboolean serialize_rsyncindex_obj                (SerialSink *sink, const SerialRsyncIndex* obj);
279 gboolean serialize_rsyncindex_internal           (SerialSink *sink, guint32 seg_len, guint32 file_len, const guint8 file_md5[16], guint32 index_len, SerialRsyncIndexElt const* index);
280 gboolean serialize_rsyncindex_obj_internal (SerialSink *sink, SerialRsyncIndex* obj);
281 guint    serializeio_count_rsyncindex            (guint32 seg_len, guint32 file_len, const guint8 file_md5[16], guint32 index_len, SerialRsyncIndexElt const* index);
282 guint    serializeio_count_rsyncindex_obj        (SerialRsyncIndex const* obj);
283 
284 /* Version0SourceInfo Structure
285  */
286 
287 struct _SerialVersion0SourceInfo {
288   guint8 md5[16];
289   guint8 real_md5[16];
290   guint32 length;
291 };
292 
293 void     serializeio_print_version0sourceinfo_obj        (SerialVersion0SourceInfo* obj, guint indent_spaces);
294 
295 gboolean unserialize_version0sourceinfo                  (SerialSource *source, SerialVersion0SourceInfo**);
296 gboolean unserialize_version0sourceinfo_internal         (SerialSource *source, SerialVersion0SourceInfo** );
297 gboolean unserialize_version0sourceinfo_internal_noalloc (SerialSource *source, SerialVersion0SourceInfo* );
298 gboolean serialize_version0sourceinfo                    (SerialSink *sink, const guint8 md5[16], const guint8 real_md5[16], guint32 length);
299 gboolean serialize_version0sourceinfo_obj                (SerialSink *sink, const SerialVersion0SourceInfo* obj);
300 gboolean serialize_version0sourceinfo_internal           (SerialSink *sink, const guint8 md5[16], const guint8 real_md5[16], guint32 length);
301 gboolean serialize_version0sourceinfo_obj_internal (SerialSink *sink, SerialVersion0SourceInfo* obj);
302 guint    serializeio_count_version0sourceinfo            (const guint8 md5[16], const guint8 real_md5[16], guint32 length);
303 guint    serializeio_count_version0sourceinfo_obj        (SerialVersion0SourceInfo const* obj);
304 
305 /* Version0Control Structure
306  */
307 
308 struct _SerialVersion0Control {
309   gboolean normalized;
310   guint32 data_len;
311   SerialVersion0SourceInfo to_info;
312   guint32 source_info_len;
313   SerialVersion0SourceInfo** source_info;
314   guint32 inst_len;
315   SerialVersion0Instruction* inst;
316   GArray    *inst_array;
317   GPtrArray *source_info_array;
318 };
319 
320 void     serializeio_print_version0control_obj        (SerialVersion0Control* obj, guint indent_spaces);
321 
322 gboolean unserialize_version0control                  (SerialSource *source, SerialVersion0Control**);
323 gboolean unserialize_version0control_internal         (SerialSource *source, SerialVersion0Control** );
324 gboolean unserialize_version0control_internal_noalloc (SerialSource *source, SerialVersion0Control* );
325 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);
326 gboolean serialize_version0control_obj                (SerialSink *sink, const SerialVersion0Control* obj);
327 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);
328 gboolean serialize_version0control_obj_internal (SerialSink *sink, SerialVersion0Control* obj);
329 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);
330 guint    serializeio_count_version0control_obj        (SerialVersion0Control const* obj);
331 
332 /* Version0Instruction Structure
333  */
334 
335 struct _SerialVersion0Instruction {
336   guint32 offset;
337   guint32 length;
338   guint8 type;
339   guint8 index;
340 };
341 
342 void     serializeio_print_version0instruction_obj        (SerialVersion0Instruction* obj, guint indent_spaces);
343 
344 gboolean unserialize_version0instruction                  (SerialSource *source, SerialVersion0Instruction**);
345 gboolean unserialize_version0instruction_internal         (SerialSource *source, SerialVersion0Instruction** );
346 gboolean unserialize_version0instruction_internal_noalloc (SerialSource *source, SerialVersion0Instruction* );
347 gboolean serialize_version0instruction                    (SerialSink *sink, guint32 offset, guint32 length);
348 gboolean serialize_version0instruction_obj                (SerialSink *sink, const SerialVersion0Instruction* obj);
349 gboolean serialize_version0instruction_internal           (SerialSink *sink, guint32 offset, guint32 length);
350 gboolean serialize_version0instruction_obj_internal (SerialSink *sink, SerialVersion0Instruction* obj);
351 guint    serializeio_count_version0instruction            (guint32 offset, guint32 length);
352 guint    serializeio_count_version0instruction_obj        (SerialVersion0Instruction const* obj);
353 
354 void xd_generate_void_event_internal (XdVoidEventCode code, const char* srcfile, gint srcline);
355 #define xd_generate_void_event(ecode) xd_generate_void_event_internal((ecode),__FILE__,__LINE__)
356 
357 extern const XdVoidEventCode EC_XdTooFewSources;
358 #define EC_XdTooFewSourcesValue ((0<<EDSIO_LIBRARY_OFFSET_BITS)+3)
359 
360 extern const XdVoidEventCode EC_XdTooManySources;
361 #define EC_XdTooManySourcesValue ((1<<EDSIO_LIBRARY_OFFSET_BITS)+3)
362 
363 void xd_generate_int_event_internal (XdIntEventCode code, const char* srcfile, gint srcline, int index);
364 #define xd_generate_int_event(ecode, index) xd_generate_int_event_internal((ecode),__FILE__,__LINE__, (index))
365 
366 extern const XdIntEventCode EC_XdOutOfRangeSourceIndex;
367 #define EC_XdOutOfRangeSourceIndexValue ((2<<EDSIO_LIBRARY_OFFSET_BITS)+3)
368 
369 extern const XdVoidEventCode EC_XdInvalidControl;
370 #define EC_XdInvalidControlValue ((3<<EDSIO_LIBRARY_OFFSET_BITS)+3)
371 
372 extern const XdVoidEventCode EC_XdInvalidRsyncCache;
373 #define EC_XdInvalidRsyncCacheValue ((4<<EDSIO_LIBRARY_OFFSET_BITS)+3)
374 
375 extern const XdVoidEventCode EC_XdIncompatibleDelta;
376 #define EC_XdIncompatibleDeltaValue ((5<<EDSIO_LIBRARY_OFFSET_BITS)+3)
377 
378 void xd_generate_handlestringstring_event_internal (XdHandleStringStringEventCode code, const char* srcfile, gint srcline, FileHandle* stream, const char* expected, const char* received);
379 #define xd_generate_handlestringstring_event(ecode, stream, expected, received) xd_generate_handlestringstring_event_internal((ecode),__FILE__,__LINE__, (stream), (expected), (received))
380 
381 extern const XdHandleStringStringEventCode EC_XdStreamChecksumFailed;
382 #define EC_XdStreamChecksumFailedValue ((6<<EDSIO_LIBRARY_OFFSET_BITS)+3)
383 
384 void xd_generate_handleintint_event_internal (XdHandleIntIntEventCode code, const char* srcfile, gint srcline, FileHandle* stream, int expected, int received);
385 #define xd_generate_handleintint_event(ecode, stream, expected, received) xd_generate_handleintint_event_internal((ecode),__FILE__,__LINE__, (stream), (expected), (received))
386 
387 extern const XdHandleIntIntEventCode EC_XdStreamLengthFailed;
388 #define EC_XdStreamLengthFailedValue ((7<<EDSIO_LIBRARY_OFFSET_BITS)+3)
389 
390 void xd_generate_string_event_internal (XdStringEventCode code, const char* srcfile, gint srcline, const char* version);
391 #define xd_generate_string_event(ecode, version) xd_generate_string_event_internal((ecode),__FILE__,__LINE__, (version))
392 
393 extern const XdStringEventCode EC_XdBackwardCompatibilityMode;
394 #define EC_XdBackwardCompatibilityModeValue ((8<<EDSIO_LIBRARY_OFFSET_BITS)+3)
395 
396 #ifdef __cplusplus
397 }
398 #endif
399 
400 #endif /* _XD_EDSIO_H_ */
401 
402