File: xd_edsio.h

package info (click to toggle)
xdelta 1.1.3-9.1
  • links: PTS, VCS
  • area: main
  • in suites: jessie, jessie-kfreebsd, stretch
  • size: 2,256 kB
  • ctags: 1,552
  • sloc: sh: 11,470; ansic: 10,490; lisp: 1,525; makefile: 123
file content (401 lines) | stat: -rw-r--r-- 20,347 bytes parent folder | download | duplicates (9)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
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.16 Tue, 06 Apr 1999 23:40:10 -0700 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_ */