1pub const LZMA_H_INTERNAL: u32 = 1;
4pub const LZMA_VERSION_MAJOR: u32 = 5;
5pub const LZMA_VERSION_MINOR: u32 = 8;
6pub const LZMA_VERSION_PATCH: u32 = 1;
7pub const LZMA_VERSION_COMMIT: &[u8; 1] = b"\0";
8pub const LZMA_VERSION_STABILITY_ALPHA: u32 = 0;
9pub const LZMA_VERSION_STABILITY_BETA: u32 = 1;
10pub const LZMA_VERSION_STABILITY_STABLE: u32 = 2;
11pub const LZMA_VERSION_STABILITY_STRING: &[u8; 1] = b"\0";
12pub const LZMA_VLI_MAX: lzma_vli = u64::MAX / 2;
13pub const LZMA_VLI_UNKNOWN: lzma_vli = u64::MAX;
14pub const LZMA_VLI_BYTES_MAX: usize = 9;
15pub const LZMA_CHECK_ID_MAX: u32 = 15;
16pub const LZMA_CHECK_SIZE_MAX: u32 = 64;
17pub const LZMA_FILTERS_MAX: u32 = 4;
18pub const LZMA_DELTA_DIST_MIN: u32 = 1;
19pub const LZMA_DELTA_DIST_MAX: u32 = 256;
20pub const LZMA_LCLP_MIN: u32 = 0;
21pub const LZMA_LCLP_MAX: u32 = 4;
22pub const LZMA_LC_DEFAULT: u32 = 3;
23pub const LZMA_LP_DEFAULT: u32 = 0;
24pub const LZMA_PB_MIN: u32 = 0;
25pub const LZMA_PB_MAX: u32 = 4;
26pub const LZMA_PB_DEFAULT: u32 = 2;
27pub const LZMA_STREAM_HEADER_SIZE: u32 = 12;
28pub const LZMA_BLOCK_HEADER_SIZE_MIN: u32 = 8;
29pub const LZMA_BLOCK_HEADER_SIZE_MAX: u32 = 1024;
30
31#[cfg(target_env = "msvc")]
32#[doc(hidden)]
33pub type __enum_ty = ::std::os::raw::c_int;
34#[cfg(not(target_env = "msvc"))]
35#[doc(hidden)]
36pub type __enum_ty = ::std::os::raw::c_uint;
37
38extern "C" {
39 pub fn lzma_version_number() -> u32;
40}
41extern "C" {
42 pub fn lzma_version_string() -> *const ::std::os::raw::c_char;
43}
44pub type lzma_bool = ::std::os::raw::c_uchar;
45pub const lzma_reserved_enum_LZMA_RESERVED_ENUM: lzma_reserved_enum = 0;
46pub type lzma_reserved_enum = __enum_ty;
47pub const lzma_ret_LZMA_OK: lzma_ret = 0;
48pub const lzma_ret_LZMA_STREAM_END: lzma_ret = 1;
49pub const lzma_ret_LZMA_NO_CHECK: lzma_ret = 2;
50pub const lzma_ret_LZMA_UNSUPPORTED_CHECK: lzma_ret = 3;
51pub const lzma_ret_LZMA_GET_CHECK: lzma_ret = 4;
52pub const lzma_ret_LZMA_MEM_ERROR: lzma_ret = 5;
53pub const lzma_ret_LZMA_MEMLIMIT_ERROR: lzma_ret = 6;
54pub const lzma_ret_LZMA_FORMAT_ERROR: lzma_ret = 7;
55pub const lzma_ret_LZMA_OPTIONS_ERROR: lzma_ret = 8;
56pub const lzma_ret_LZMA_DATA_ERROR: lzma_ret = 9;
57pub const lzma_ret_LZMA_BUF_ERROR: lzma_ret = 10;
58pub const lzma_ret_LZMA_PROG_ERROR: lzma_ret = 11;
59pub const lzma_ret_LZMA_SEEK_NEEDED: lzma_ret = 12;
60pub const lzma_ret_LZMA_RET_INTERNAL1: lzma_ret = 101;
61pub const lzma_ret_LZMA_RET_INTERNAL2: lzma_ret = 102;
62pub const lzma_ret_LZMA_RET_INTERNAL3: lzma_ret = 103;
63pub const lzma_ret_LZMA_RET_INTERNAL4: lzma_ret = 104;
64pub const lzma_ret_LZMA_RET_INTERNAL5: lzma_ret = 105;
65pub const lzma_ret_LZMA_RET_INTERNAL6: lzma_ret = 106;
66pub const lzma_ret_LZMA_RET_INTERNAL7: lzma_ret = 107;
67pub const lzma_ret_LZMA_RET_INTERNAL8: lzma_ret = 108;
68pub type lzma_ret = __enum_ty;
69pub const lzma_action_LZMA_RUN: lzma_action = 0;
70pub const lzma_action_LZMA_SYNC_FLUSH: lzma_action = 1;
71pub const lzma_action_LZMA_FULL_FLUSH: lzma_action = 2;
72pub const lzma_action_LZMA_FULL_BARRIER: lzma_action = 4;
73pub const lzma_action_LZMA_FINISH: lzma_action = 3;
74pub type lzma_action = __enum_ty;
75#[repr(C)]
76#[derive(Debug, Copy, Clone)]
77pub struct lzma_allocator {
78 pub alloc: ::std::option::Option<
79 unsafe extern "C" fn(
80 opaque: *mut ::std::os::raw::c_void,
81 nmemb: usize,
82 size: usize,
83 ) -> *mut ::std::os::raw::c_void,
84 >,
85 pub free: ::std::option::Option<
86 unsafe extern "C" fn(opaque: *mut ::std::os::raw::c_void, ptr: *mut ::std::os::raw::c_void),
87 >,
88 pub opaque: *mut ::std::os::raw::c_void,
89}
90#[test]
91fn bindgen_test_layout_lzma_allocator() {
92 const UNINIT: ::std::mem::MaybeUninit<lzma_allocator> = ::std::mem::MaybeUninit::uninit();
93 let ptr = UNINIT.as_ptr();
94 assert_eq!(
95 ::std::mem::size_of::<lzma_allocator>(),
96 24usize,
97 "Size of lzma_allocator"
98 );
99 assert_eq!(
100 ::std::mem::align_of::<lzma_allocator>(),
101 8usize,
102 "Alignment of lzma_allocator"
103 );
104 assert_eq!(
105 unsafe { ::std::ptr::addr_of!((*ptr).alloc) as usize - ptr as usize },
106 0usize,
107 "Offset of field: lzma_allocator::alloc"
108 );
109 assert_eq!(
110 unsafe { ::std::ptr::addr_of!((*ptr).free) as usize - ptr as usize },
111 8usize,
112 "Offset of field: lzma_allocator::free"
113 );
114 assert_eq!(
115 unsafe { ::std::ptr::addr_of!((*ptr).opaque) as usize - ptr as usize },
116 16usize,
117 "Offset of field: lzma_allocator::opaque"
118 );
119}
120#[repr(C)]
121#[derive(Debug, Copy, Clone)]
122pub struct lzma_internal_s {
123 _unused: [u8; 0],
124}
125pub type lzma_internal = lzma_internal_s;
126#[repr(C)]
127#[derive(Debug, Copy, Clone)]
128pub struct lzma_stream {
129 pub next_in: *const u8,
130 pub avail_in: usize,
131 pub total_in: u64,
132 pub next_out: *mut u8,
133 pub avail_out: usize,
134 pub total_out: u64,
135 pub allocator: *const lzma_allocator,
136 pub internal: *mut lzma_internal,
137 pub reserved_ptr1: *mut ::std::os::raw::c_void,
138 pub reserved_ptr2: *mut ::std::os::raw::c_void,
139 pub reserved_ptr3: *mut ::std::os::raw::c_void,
140 pub reserved_ptr4: *mut ::std::os::raw::c_void,
141 pub seek_pos: u64,
142 pub reserved_int2: u64,
143 pub reserved_int3: usize,
144 pub reserved_int4: usize,
145 pub reserved_enum1: lzma_reserved_enum,
146 pub reserved_enum2: lzma_reserved_enum,
147}
148#[test]
149fn bindgen_test_layout_lzma_stream() {
150 const UNINIT: ::std::mem::MaybeUninit<lzma_stream> = ::std::mem::MaybeUninit::uninit();
151 let ptr = UNINIT.as_ptr();
152 assert_eq!(
153 ::std::mem::size_of::<lzma_stream>(),
154 136usize,
155 "Size of lzma_stream"
156 );
157 assert_eq!(
158 ::std::mem::align_of::<lzma_stream>(),
159 8usize,
160 "Alignment of lzma_stream"
161 );
162 assert_eq!(
163 unsafe { ::std::ptr::addr_of!((*ptr).next_in) as usize - ptr as usize },
164 0usize,
165 "Offset of field: lzma_stream::next_in"
166 );
167 assert_eq!(
168 unsafe { ::std::ptr::addr_of!((*ptr).avail_in) as usize - ptr as usize },
169 8usize,
170 "Offset of field: lzma_stream::avail_in"
171 );
172 assert_eq!(
173 unsafe { ::std::ptr::addr_of!((*ptr).total_in) as usize - ptr as usize },
174 16usize,
175 "Offset of field: lzma_stream::total_in"
176 );
177 assert_eq!(
178 unsafe { ::std::ptr::addr_of!((*ptr).next_out) as usize - ptr as usize },
179 24usize,
180 "Offset of field: lzma_stream::next_out"
181 );
182 assert_eq!(
183 unsafe { ::std::ptr::addr_of!((*ptr).avail_out) as usize - ptr as usize },
184 32usize,
185 "Offset of field: lzma_stream::avail_out"
186 );
187 assert_eq!(
188 unsafe { ::std::ptr::addr_of!((*ptr).total_out) as usize - ptr as usize },
189 40usize,
190 "Offset of field: lzma_stream::total_out"
191 );
192 assert_eq!(
193 unsafe { ::std::ptr::addr_of!((*ptr).allocator) as usize - ptr as usize },
194 48usize,
195 "Offset of field: lzma_stream::allocator"
196 );
197 assert_eq!(
198 unsafe { ::std::ptr::addr_of!((*ptr).internal) as usize - ptr as usize },
199 56usize,
200 "Offset of field: lzma_stream::internal"
201 );
202 assert_eq!(
203 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr1) as usize - ptr as usize },
204 64usize,
205 "Offset of field: lzma_stream::reserved_ptr1"
206 );
207 assert_eq!(
208 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr2) as usize - ptr as usize },
209 72usize,
210 "Offset of field: lzma_stream::reserved_ptr2"
211 );
212 assert_eq!(
213 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr3) as usize - ptr as usize },
214 80usize,
215 "Offset of field: lzma_stream::reserved_ptr3"
216 );
217 assert_eq!(
218 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr4) as usize - ptr as usize },
219 88usize,
220 "Offset of field: lzma_stream::reserved_ptr4"
221 );
222 assert_eq!(
223 unsafe { ::std::ptr::addr_of!((*ptr).seek_pos) as usize - ptr as usize },
224 96usize,
225 "Offset of field: lzma_stream::seek_pos"
226 );
227 assert_eq!(
228 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int2) as usize - ptr as usize },
229 104usize,
230 "Offset of field: lzma_stream::reserved_int2"
231 );
232 assert_eq!(
233 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int3) as usize - ptr as usize },
234 112usize,
235 "Offset of field: lzma_stream::reserved_int3"
236 );
237 assert_eq!(
238 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int4) as usize - ptr as usize },
239 120usize,
240 "Offset of field: lzma_stream::reserved_int4"
241 );
242 assert_eq!(
243 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum1) as usize - ptr as usize },
244 128usize,
245 "Offset of field: lzma_stream::reserved_enum1"
246 );
247 assert_eq!(
248 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum2) as usize - ptr as usize },
249 132usize,
250 "Offset of field: lzma_stream::reserved_enum2"
251 );
252}
253extern "C" {
254 pub fn lzma_code(strm: *mut lzma_stream, action: lzma_action) -> lzma_ret;
255}
256extern "C" {
257 pub fn lzma_end(strm: *mut lzma_stream);
258}
259extern "C" {
260 pub fn lzma_get_progress(strm: *mut lzma_stream, progress_in: *mut u64, progress_out: *mut u64);
261}
262extern "C" {
263 pub fn lzma_memusage(strm: *const lzma_stream) -> u64;
264}
265extern "C" {
266 pub fn lzma_memlimit_get(strm: *const lzma_stream) -> u64;
267}
268extern "C" {
269 pub fn lzma_memlimit_set(strm: *mut lzma_stream, memlimit: u64) -> lzma_ret;
270}
271pub type lzma_vli = u64;
272extern "C" {
273 pub fn lzma_vli_encode(
274 vli: lzma_vli,
275 vli_pos: *mut usize,
276 out: *mut u8,
277 out_pos: *mut usize,
278 out_size: usize,
279 ) -> lzma_ret;
280}
281extern "C" {
282 pub fn lzma_vli_decode(
283 vli: *mut lzma_vli,
284 vli_pos: *mut usize,
285 in_: *const u8,
286 in_pos: *mut usize,
287 in_size: usize,
288 ) -> lzma_ret;
289}
290extern "C" {
291 pub fn lzma_vli_size(vli: lzma_vli) -> u32;
292}
293pub const lzma_check_LZMA_CHECK_NONE: lzma_check = 0;
294pub const lzma_check_LZMA_CHECK_CRC32: lzma_check = 1;
295pub const lzma_check_LZMA_CHECK_CRC64: lzma_check = 4;
296pub const lzma_check_LZMA_CHECK_SHA256: lzma_check = 10;
297pub type lzma_check = __enum_ty;
298extern "C" {
299 pub fn lzma_check_is_supported(check: lzma_check) -> lzma_bool;
300}
301extern "C" {
302 pub fn lzma_check_size(check: lzma_check) -> u32;
303}
304extern "C" {
305 pub fn lzma_crc32(buf: *const u8, size: usize, crc: u32) -> u32;
306}
307extern "C" {
308 pub fn lzma_crc64(buf: *const u8, size: usize, crc: u64) -> u64;
309}
310extern "C" {
311 pub fn lzma_get_check(strm: *const lzma_stream) -> lzma_check;
312}
313#[repr(C)]
314#[derive(Debug, Copy, Clone)]
315pub struct lzma_filter {
316 pub id: lzma_vli,
317 pub options: *mut ::std::os::raw::c_void,
318}
319#[test]
320fn bindgen_test_layout_lzma_filter() {
321 const UNINIT: ::std::mem::MaybeUninit<lzma_filter> = ::std::mem::MaybeUninit::uninit();
322 let ptr = UNINIT.as_ptr();
323 assert_eq!(
324 ::std::mem::size_of::<lzma_filter>(),
325 16usize,
326 "Size of lzma_filter"
327 );
328 assert_eq!(
329 ::std::mem::align_of::<lzma_filter>(),
330 8usize,
331 "Alignment of lzma_filter"
332 );
333 assert_eq!(
334 unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
335 0usize,
336 "Offset of field: lzma_filter::id"
337 );
338 assert_eq!(
339 unsafe { ::std::ptr::addr_of!((*ptr).options) as usize - ptr as usize },
340 8usize,
341 "Offset of field: lzma_filter::options"
342 );
343}
344extern "C" {
345 pub fn lzma_filter_encoder_is_supported(id: lzma_vli) -> lzma_bool;
346}
347extern "C" {
348 pub fn lzma_filter_decoder_is_supported(id: lzma_vli) -> lzma_bool;
349}
350extern "C" {
351 pub fn lzma_filters_copy(
352 src: *const lzma_filter,
353 dest: *mut lzma_filter,
354 allocator: *const lzma_allocator,
355 ) -> lzma_ret;
356}
357extern "C" {
358 pub fn lzma_filters_free(filters: *mut lzma_filter, allocator: *const lzma_allocator);
359}
360extern "C" {
361 pub fn lzma_raw_encoder_memusage(filters: *const lzma_filter) -> u64;
362}
363extern "C" {
364 pub fn lzma_raw_decoder_memusage(filters: *const lzma_filter) -> u64;
365}
366extern "C" {
367 pub fn lzma_raw_encoder(strm: *mut lzma_stream, filters: *const lzma_filter) -> lzma_ret;
368}
369extern "C" {
370 pub fn lzma_raw_decoder(strm: *mut lzma_stream, filters: *const lzma_filter) -> lzma_ret;
371}
372extern "C" {
373 pub fn lzma_filters_update(strm: *mut lzma_stream, filters: *const lzma_filter) -> lzma_ret;
374}
375extern "C" {
376 pub fn lzma_raw_buffer_encode(
377 filters: *const lzma_filter,
378 allocator: *const lzma_allocator,
379 in_: *const u8,
380 in_size: usize,
381 out: *mut u8,
382 out_pos: *mut usize,
383 out_size: usize,
384 ) -> lzma_ret;
385}
386extern "C" {
387 pub fn lzma_raw_buffer_decode(
388 filters: *const lzma_filter,
389 allocator: *const lzma_allocator,
390 in_: *const u8,
391 in_pos: *mut usize,
392 in_size: usize,
393 out: *mut u8,
394 out_pos: *mut usize,
395 out_size: usize,
396 ) -> lzma_ret;
397}
398extern "C" {
399 pub fn lzma_properties_size(size: *mut u32, filter: *const lzma_filter) -> lzma_ret;
400}
401extern "C" {
402 pub fn lzma_properties_encode(filter: *const lzma_filter, props: *mut u8) -> lzma_ret;
403}
404extern "C" {
405 pub fn lzma_properties_decode(
406 filter: *mut lzma_filter,
407 allocator: *const lzma_allocator,
408 props: *const u8,
409 props_size: usize,
410 ) -> lzma_ret;
411}
412extern "C" {
413 pub fn lzma_filter_flags_size(size: *mut u32, filter: *const lzma_filter) -> lzma_ret;
414}
415extern "C" {
416 pub fn lzma_filter_flags_encode(
417 filter: *const lzma_filter,
418 out: *mut u8,
419 out_pos: *mut usize,
420 out_size: usize,
421 ) -> lzma_ret;
422}
423extern "C" {
424 pub fn lzma_filter_flags_decode(
425 filter: *mut lzma_filter,
426 allocator: *const lzma_allocator,
427 in_: *const u8,
428 in_pos: *mut usize,
429 in_size: usize,
430 ) -> lzma_ret;
431}
432extern "C" {
433 pub fn lzma_str_to_filters(
434 str_: *const ::std::os::raw::c_char,
435 error_pos: *mut ::std::os::raw::c_int,
436 filters: *mut lzma_filter,
437 flags: u32,
438 allocator: *const lzma_allocator,
439 ) -> *const ::std::os::raw::c_char;
440}
441extern "C" {
442 pub fn lzma_str_from_filters(
443 str_: *mut *mut ::std::os::raw::c_char,
444 filters: *const lzma_filter,
445 flags: u32,
446 allocator: *const lzma_allocator,
447 ) -> lzma_ret;
448}
449extern "C" {
450 pub fn lzma_str_list_filters(
451 str_: *mut *mut ::std::os::raw::c_char,
452 filter_id: lzma_vli,
453 flags: u32,
454 allocator: *const lzma_allocator,
455 ) -> lzma_ret;
456}
457#[repr(C)]
458#[derive(Debug, Copy, Clone)]
459pub struct lzma_options_bcj {
460 pub start_offset: u32,
461}
462#[test]
463fn bindgen_test_layout_lzma_options_bcj() {
464 const UNINIT: ::std::mem::MaybeUninit<lzma_options_bcj> = ::std::mem::MaybeUninit::uninit();
465 let ptr = UNINIT.as_ptr();
466 assert_eq!(
467 ::std::mem::size_of::<lzma_options_bcj>(),
468 4usize,
469 "Size of lzma_options_bcj"
470 );
471 assert_eq!(
472 ::std::mem::align_of::<lzma_options_bcj>(),
473 4usize,
474 "Alignment of lzma_options_bcj"
475 );
476 assert_eq!(
477 unsafe { ::std::ptr::addr_of!((*ptr).start_offset) as usize - ptr as usize },
478 0usize,
479 "Offset of field: lzma_options_bcj::start_offset"
480 );
481}
482extern "C" {
483 pub fn lzma_bcj_arm64_encode(start_offset: u32, buf: *mut u8, size: usize) -> usize;
484}
485extern "C" {
486 pub fn lzma_bcj_arm64_decode(start_offset: u32, buf: *mut u8, size: usize) -> usize;
487}
488extern "C" {
489 pub fn lzma_bcj_riscv_encode(start_offset: u32, buf: *mut u8, size: usize) -> usize;
490}
491extern "C" {
492 pub fn lzma_bcj_riscv_decode(start_offset: u32, buf: *mut u8, size: usize) -> usize;
493}
494extern "C" {
495 pub fn lzma_bcj_x86_encode(start_offset: u32, buf: *mut u8, size: usize) -> usize;
496}
497extern "C" {
498 pub fn lzma_bcj_x86_decode(start_offset: u32, buf: *mut u8, size: usize) -> usize;
499}
500pub const lzma_delta_type_LZMA_DELTA_TYPE_BYTE: lzma_delta_type = 0;
501pub type lzma_delta_type = ::std::os::raw::c_uint;
502#[repr(C)]
503#[derive(Debug, Copy, Clone)]
504pub struct lzma_options_delta {
505 pub type_: lzma_delta_type,
506 pub dist: u32,
507 pub reserved_int1: u32,
508 pub reserved_int2: u32,
509 pub reserved_int3: u32,
510 pub reserved_int4: u32,
511 pub reserved_ptr1: *mut ::std::os::raw::c_void,
512 pub reserved_ptr2: *mut ::std::os::raw::c_void,
513}
514#[test]
515fn bindgen_test_layout_lzma_options_delta() {
516 const UNINIT: ::std::mem::MaybeUninit<lzma_options_delta> = ::std::mem::MaybeUninit::uninit();
517 let ptr = UNINIT.as_ptr();
518 assert_eq!(
519 ::std::mem::size_of::<lzma_options_delta>(),
520 40usize,
521 "Size of lzma_options_delta"
522 );
523 assert_eq!(
524 ::std::mem::align_of::<lzma_options_delta>(),
525 8usize,
526 "Alignment of lzma_options_delta"
527 );
528 assert_eq!(
529 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
530 0usize,
531 "Offset of field: lzma_options_delta::type_"
532 );
533 assert_eq!(
534 unsafe { ::std::ptr::addr_of!((*ptr).dist) as usize - ptr as usize },
535 4usize,
536 "Offset of field: lzma_options_delta::dist"
537 );
538 assert_eq!(
539 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int1) as usize - ptr as usize },
540 8usize,
541 "Offset of field: lzma_options_delta::reserved_int1"
542 );
543 assert_eq!(
544 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int2) as usize - ptr as usize },
545 12usize,
546 "Offset of field: lzma_options_delta::reserved_int2"
547 );
548 assert_eq!(
549 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int3) as usize - ptr as usize },
550 16usize,
551 "Offset of field: lzma_options_delta::reserved_int3"
552 );
553 assert_eq!(
554 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int4) as usize - ptr as usize },
555 20usize,
556 "Offset of field: lzma_options_delta::reserved_int4"
557 );
558 assert_eq!(
559 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr1) as usize - ptr as usize },
560 24usize,
561 "Offset of field: lzma_options_delta::reserved_ptr1"
562 );
563 assert_eq!(
564 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr2) as usize - ptr as usize },
565 32usize,
566 "Offset of field: lzma_options_delta::reserved_ptr2"
567 );
568}
569pub const lzma_match_finder_LZMA_MF_HC3: lzma_match_finder = 3;
570pub const lzma_match_finder_LZMA_MF_HC4: lzma_match_finder = 4;
571pub const lzma_match_finder_LZMA_MF_BT2: lzma_match_finder = 18;
572pub const lzma_match_finder_LZMA_MF_BT3: lzma_match_finder = 19;
573pub const lzma_match_finder_LZMA_MF_BT4: lzma_match_finder = 20;
574pub type lzma_match_finder = __enum_ty;
575extern "C" {
576 pub fn lzma_mf_is_supported(match_finder: lzma_match_finder) -> lzma_bool;
577}
578pub const lzma_mode_LZMA_MODE_FAST: lzma_mode = 1;
579pub const lzma_mode_LZMA_MODE_NORMAL: lzma_mode = 2;
580pub type lzma_mode = __enum_ty;
581extern "C" {
582 pub fn lzma_mode_is_supported(mode: lzma_mode) -> lzma_bool;
583}
584#[repr(C)]
585#[derive(Debug, Copy, Clone)]
586pub struct lzma_options_lzma {
587 pub dict_size: u32,
588 pub preset_dict: *const u8,
589 pub preset_dict_size: u32,
590 pub lc: u32,
591 pub lp: u32,
592 pub pb: u32,
593 pub mode: lzma_mode,
594 pub nice_len: u32,
595 pub mf: lzma_match_finder,
596 pub depth: u32,
597 pub ext_flags: u32,
598 pub ext_size_low: u32,
599 pub ext_size_high: u32,
600 pub reserved_int4: u32,
601 pub reserved_int5: u32,
602 pub reserved_int6: u32,
603 pub reserved_int7: u32,
604 pub reserved_int8: u32,
605 pub reserved_enum1: lzma_reserved_enum,
606 pub reserved_enum2: lzma_reserved_enum,
607 pub reserved_enum3: lzma_reserved_enum,
608 pub reserved_enum4: lzma_reserved_enum,
609 pub reserved_ptr1: *mut ::std::os::raw::c_void,
610 pub reserved_ptr2: *mut ::std::os::raw::c_void,
611}
612#[test]
613fn bindgen_test_layout_lzma_options_lzma() {
614 const UNINIT: ::std::mem::MaybeUninit<lzma_options_lzma> = ::std::mem::MaybeUninit::uninit();
615 let ptr = UNINIT.as_ptr();
616 assert_eq!(
617 ::std::mem::size_of::<lzma_options_lzma>(),
618 112usize,
619 "Size of lzma_options_lzma"
620 );
621 assert_eq!(
622 ::std::mem::align_of::<lzma_options_lzma>(),
623 8usize,
624 "Alignment of lzma_options_lzma"
625 );
626 assert_eq!(
627 unsafe { ::std::ptr::addr_of!((*ptr).dict_size) as usize - ptr as usize },
628 0usize,
629 "Offset of field: lzma_options_lzma::dict_size"
630 );
631 assert_eq!(
632 unsafe { ::std::ptr::addr_of!((*ptr).preset_dict) as usize - ptr as usize },
633 8usize,
634 "Offset of field: lzma_options_lzma::preset_dict"
635 );
636 assert_eq!(
637 unsafe { ::std::ptr::addr_of!((*ptr).preset_dict_size) as usize - ptr as usize },
638 16usize,
639 "Offset of field: lzma_options_lzma::preset_dict_size"
640 );
641 assert_eq!(
642 unsafe { ::std::ptr::addr_of!((*ptr).lc) as usize - ptr as usize },
643 20usize,
644 "Offset of field: lzma_options_lzma::lc"
645 );
646 assert_eq!(
647 unsafe { ::std::ptr::addr_of!((*ptr).lp) as usize - ptr as usize },
648 24usize,
649 "Offset of field: lzma_options_lzma::lp"
650 );
651 assert_eq!(
652 unsafe { ::std::ptr::addr_of!((*ptr).pb) as usize - ptr as usize },
653 28usize,
654 "Offset of field: lzma_options_lzma::pb"
655 );
656 assert_eq!(
657 unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
658 32usize,
659 "Offset of field: lzma_options_lzma::mode"
660 );
661 assert_eq!(
662 unsafe { ::std::ptr::addr_of!((*ptr).nice_len) as usize - ptr as usize },
663 36usize,
664 "Offset of field: lzma_options_lzma::nice_len"
665 );
666 assert_eq!(
667 unsafe { ::std::ptr::addr_of!((*ptr).mf) as usize - ptr as usize },
668 40usize,
669 "Offset of field: lzma_options_lzma::mf"
670 );
671 assert_eq!(
672 unsafe { ::std::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
673 44usize,
674 "Offset of field: lzma_options_lzma::depth"
675 );
676 assert_eq!(
677 unsafe { ::std::ptr::addr_of!((*ptr).ext_flags) as usize - ptr as usize },
678 48usize,
679 "Offset of field: lzma_options_lzma::ext_flags"
680 );
681 assert_eq!(
682 unsafe { ::std::ptr::addr_of!((*ptr).ext_size_low) as usize - ptr as usize },
683 52usize,
684 "Offset of field: lzma_options_lzma::ext_size_low"
685 );
686 assert_eq!(
687 unsafe { ::std::ptr::addr_of!((*ptr).ext_size_high) as usize - ptr as usize },
688 56usize,
689 "Offset of field: lzma_options_lzma::ext_size_high"
690 );
691 assert_eq!(
692 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int4) as usize - ptr as usize },
693 60usize,
694 "Offset of field: lzma_options_lzma::reserved_int4"
695 );
696 assert_eq!(
697 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int5) as usize - ptr as usize },
698 64usize,
699 "Offset of field: lzma_options_lzma::reserved_int5"
700 );
701 assert_eq!(
702 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int6) as usize - ptr as usize },
703 68usize,
704 "Offset of field: lzma_options_lzma::reserved_int6"
705 );
706 assert_eq!(
707 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int7) as usize - ptr as usize },
708 72usize,
709 "Offset of field: lzma_options_lzma::reserved_int7"
710 );
711 assert_eq!(
712 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int8) as usize - ptr as usize },
713 76usize,
714 "Offset of field: lzma_options_lzma::reserved_int8"
715 );
716 assert_eq!(
717 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum1) as usize - ptr as usize },
718 80usize,
719 "Offset of field: lzma_options_lzma::reserved_enum1"
720 );
721 assert_eq!(
722 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum2) as usize - ptr as usize },
723 84usize,
724 "Offset of field: lzma_options_lzma::reserved_enum2"
725 );
726 assert_eq!(
727 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum3) as usize - ptr as usize },
728 88usize,
729 "Offset of field: lzma_options_lzma::reserved_enum3"
730 );
731 assert_eq!(
732 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum4) as usize - ptr as usize },
733 92usize,
734 "Offset of field: lzma_options_lzma::reserved_enum4"
735 );
736 assert_eq!(
737 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr1) as usize - ptr as usize },
738 96usize,
739 "Offset of field: lzma_options_lzma::reserved_ptr1"
740 );
741 assert_eq!(
742 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr2) as usize - ptr as usize },
743 104usize,
744 "Offset of field: lzma_options_lzma::reserved_ptr2"
745 );
746}
747extern "C" {
748 pub fn lzma_lzma_preset(options: *mut lzma_options_lzma, preset: u32) -> lzma_bool;
749}
750#[repr(C)]
751#[derive(Debug, Copy, Clone)]
752pub struct lzma_mt {
753 pub flags: u32,
754 pub threads: u32,
755 pub block_size: u64,
756 pub timeout: u32,
757 pub preset: u32,
758 pub filters: *const lzma_filter,
759 pub check: lzma_check,
760 pub reserved_enum1: lzma_reserved_enum,
761 pub reserved_enum2: lzma_reserved_enum,
762 pub reserved_enum3: lzma_reserved_enum,
763 pub reserved_int1: u32,
764 pub reserved_int2: u32,
765 pub reserved_int3: u32,
766 pub reserved_int4: u32,
767 pub memlimit_threading: u64,
768 pub memlimit_stop: u64,
769 pub reserved_int7: u64,
770 pub reserved_int8: u64,
771 pub reserved_ptr1: *mut ::std::os::raw::c_void,
772 pub reserved_ptr2: *mut ::std::os::raw::c_void,
773 pub reserved_ptr3: *mut ::std::os::raw::c_void,
774 pub reserved_ptr4: *mut ::std::os::raw::c_void,
775}
776#[test]
777fn bindgen_test_layout_lzma_mt() {
778 const UNINIT: ::std::mem::MaybeUninit<lzma_mt> = ::std::mem::MaybeUninit::uninit();
779 let ptr = UNINIT.as_ptr();
780 assert_eq!(
781 ::std::mem::size_of::<lzma_mt>(),
782 128usize,
783 "Size of lzma_mt"
784 );
785 assert_eq!(
786 ::std::mem::align_of::<lzma_mt>(),
787 8usize,
788 "Alignment of lzma_mt"
789 );
790 assert_eq!(
791 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
792 0usize,
793 "Offset of field: lzma_mt::flags"
794 );
795 assert_eq!(
796 unsafe { ::std::ptr::addr_of!((*ptr).threads) as usize - ptr as usize },
797 4usize,
798 "Offset of field: lzma_mt::threads"
799 );
800 assert_eq!(
801 unsafe { ::std::ptr::addr_of!((*ptr).block_size) as usize - ptr as usize },
802 8usize,
803 "Offset of field: lzma_mt::block_size"
804 );
805 assert_eq!(
806 unsafe { ::std::ptr::addr_of!((*ptr).timeout) as usize - ptr as usize },
807 16usize,
808 "Offset of field: lzma_mt::timeout"
809 );
810 assert_eq!(
811 unsafe { ::std::ptr::addr_of!((*ptr).preset) as usize - ptr as usize },
812 20usize,
813 "Offset of field: lzma_mt::preset"
814 );
815 assert_eq!(
816 unsafe { ::std::ptr::addr_of!((*ptr).filters) as usize - ptr as usize },
817 24usize,
818 "Offset of field: lzma_mt::filters"
819 );
820 assert_eq!(
821 unsafe { ::std::ptr::addr_of!((*ptr).check) as usize - ptr as usize },
822 32usize,
823 "Offset of field: lzma_mt::check"
824 );
825 assert_eq!(
826 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum1) as usize - ptr as usize },
827 36usize,
828 "Offset of field: lzma_mt::reserved_enum1"
829 );
830 assert_eq!(
831 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum2) as usize - ptr as usize },
832 40usize,
833 "Offset of field: lzma_mt::reserved_enum2"
834 );
835 assert_eq!(
836 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum3) as usize - ptr as usize },
837 44usize,
838 "Offset of field: lzma_mt::reserved_enum3"
839 );
840 assert_eq!(
841 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int1) as usize - ptr as usize },
842 48usize,
843 "Offset of field: lzma_mt::reserved_int1"
844 );
845 assert_eq!(
846 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int2) as usize - ptr as usize },
847 52usize,
848 "Offset of field: lzma_mt::reserved_int2"
849 );
850 assert_eq!(
851 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int3) as usize - ptr as usize },
852 56usize,
853 "Offset of field: lzma_mt::reserved_int3"
854 );
855 assert_eq!(
856 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int4) as usize - ptr as usize },
857 60usize,
858 "Offset of field: lzma_mt::reserved_int4"
859 );
860 assert_eq!(
861 unsafe { ::std::ptr::addr_of!((*ptr).memlimit_threading) as usize - ptr as usize },
862 64usize,
863 "Offset of field: lzma_mt::memlimit_threading"
864 );
865 assert_eq!(
866 unsafe { ::std::ptr::addr_of!((*ptr).memlimit_stop) as usize - ptr as usize },
867 72usize,
868 "Offset of field: lzma_mt::memlimit_stop"
869 );
870 assert_eq!(
871 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int7) as usize - ptr as usize },
872 80usize,
873 "Offset of field: lzma_mt::reserved_int7"
874 );
875 assert_eq!(
876 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int8) as usize - ptr as usize },
877 88usize,
878 "Offset of field: lzma_mt::reserved_int8"
879 );
880 assert_eq!(
881 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr1) as usize - ptr as usize },
882 96usize,
883 "Offset of field: lzma_mt::reserved_ptr1"
884 );
885 assert_eq!(
886 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr2) as usize - ptr as usize },
887 104usize,
888 "Offset of field: lzma_mt::reserved_ptr2"
889 );
890 assert_eq!(
891 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr3) as usize - ptr as usize },
892 112usize,
893 "Offset of field: lzma_mt::reserved_ptr3"
894 );
895 assert_eq!(
896 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr4) as usize - ptr as usize },
897 120usize,
898 "Offset of field: lzma_mt::reserved_ptr4"
899 );
900}
901extern "C" {
902 pub fn lzma_easy_encoder_memusage(preset: u32) -> u64;
903}
904extern "C" {
905 pub fn lzma_easy_decoder_memusage(preset: u32) -> u64;
906}
907extern "C" {
908 pub fn lzma_easy_encoder(strm: *mut lzma_stream, preset: u32, check: lzma_check) -> lzma_ret;
909}
910extern "C" {
911 pub fn lzma_easy_buffer_encode(
912 preset: u32,
913 check: lzma_check,
914 allocator: *const lzma_allocator,
915 in_: *const u8,
916 in_size: usize,
917 out: *mut u8,
918 out_pos: *mut usize,
919 out_size: usize,
920 ) -> lzma_ret;
921}
922extern "C" {
923 pub fn lzma_stream_encoder(
924 strm: *mut lzma_stream,
925 filters: *const lzma_filter,
926 check: lzma_check,
927 ) -> lzma_ret;
928}
929extern "C" {
930 pub fn lzma_stream_encoder_mt_memusage(options: *const lzma_mt) -> u64;
931}
932extern "C" {
933 pub fn lzma_stream_encoder_mt(strm: *mut lzma_stream, options: *const lzma_mt) -> lzma_ret;
934}
935extern "C" {
936 pub fn lzma_mt_block_size(filters: *const lzma_filter) -> u64;
937}
938extern "C" {
939 pub fn lzma_alone_encoder(
940 strm: *mut lzma_stream,
941 options: *const lzma_options_lzma,
942 ) -> lzma_ret;
943}
944extern "C" {
945 pub fn lzma_stream_buffer_bound(uncompressed_size: usize) -> usize;
946}
947extern "C" {
948 pub fn lzma_stream_buffer_encode(
949 filters: *mut lzma_filter,
950 check: lzma_check,
951 allocator: *const lzma_allocator,
952 in_: *const u8,
953 in_size: usize,
954 out: *mut u8,
955 out_pos: *mut usize,
956 out_size: usize,
957 ) -> lzma_ret;
958}
959extern "C" {
960 pub fn lzma_microlzma_encoder(
961 strm: *mut lzma_stream,
962 options: *const lzma_options_lzma,
963 ) -> lzma_ret;
964}
965extern "C" {
966 pub fn lzma_stream_decoder(strm: *mut lzma_stream, memlimit: u64, flags: u32) -> lzma_ret;
967}
968extern "C" {
969 pub fn lzma_stream_decoder_mt(strm: *mut lzma_stream, options: *const lzma_mt) -> lzma_ret;
970}
971extern "C" {
972 pub fn lzma_auto_decoder(strm: *mut lzma_stream, memlimit: u64, flags: u32) -> lzma_ret;
973}
974extern "C" {
975 pub fn lzma_alone_decoder(strm: *mut lzma_stream, memlimit: u64) -> lzma_ret;
976}
977extern "C" {
978 pub fn lzma_lzip_decoder(strm: *mut lzma_stream, memlimit: u64, flags: u32) -> lzma_ret;
979}
980extern "C" {
981 pub fn lzma_stream_buffer_decode(
982 memlimit: *mut u64,
983 flags: u32,
984 allocator: *const lzma_allocator,
985 in_: *const u8,
986 in_pos: *mut usize,
987 in_size: usize,
988 out: *mut u8,
989 out_pos: *mut usize,
990 out_size: usize,
991 ) -> lzma_ret;
992}
993extern "C" {
994 pub fn lzma_microlzma_decoder(
995 strm: *mut lzma_stream,
996 comp_size: u64,
997 uncomp_size: u64,
998 uncomp_size_is_exact: lzma_bool,
999 dict_size: u32,
1000 ) -> lzma_ret;
1001}
1002#[repr(C)]
1003#[derive(Debug, Copy, Clone)]
1004pub struct lzma_stream_flags {
1005 pub version: u32,
1006 pub backward_size: lzma_vli,
1007 pub check: lzma_check,
1008 pub reserved_enum1: lzma_reserved_enum,
1009 pub reserved_enum2: lzma_reserved_enum,
1010 pub reserved_enum3: lzma_reserved_enum,
1011 pub reserved_enum4: lzma_reserved_enum,
1012 pub reserved_bool1: lzma_bool,
1013 pub reserved_bool2: lzma_bool,
1014 pub reserved_bool3: lzma_bool,
1015 pub reserved_bool4: lzma_bool,
1016 pub reserved_bool5: lzma_bool,
1017 pub reserved_bool6: lzma_bool,
1018 pub reserved_bool7: lzma_bool,
1019 pub reserved_bool8: lzma_bool,
1020 pub reserved_int1: u32,
1021 pub reserved_int2: u32,
1022}
1023#[test]
1024fn bindgen_test_layout_lzma_stream_flags() {
1025 const UNINIT: ::std::mem::MaybeUninit<lzma_stream_flags> = ::std::mem::MaybeUninit::uninit();
1026 let ptr = UNINIT.as_ptr();
1027 assert_eq!(
1028 ::std::mem::size_of::<lzma_stream_flags>(),
1029 56usize,
1030 "Size of lzma_stream_flags"
1031 );
1032 assert_eq!(
1033 ::std::mem::align_of::<lzma_stream_flags>(),
1034 8usize,
1035 "Alignment of lzma_stream_flags"
1036 );
1037 assert_eq!(
1038 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
1039 0usize,
1040 "Offset of field: lzma_stream_flags::version"
1041 );
1042 assert_eq!(
1043 unsafe { ::std::ptr::addr_of!((*ptr).backward_size) as usize - ptr as usize },
1044 8usize,
1045 "Offset of field: lzma_stream_flags::backward_size"
1046 );
1047 assert_eq!(
1048 unsafe { ::std::ptr::addr_of!((*ptr).check) as usize - ptr as usize },
1049 16usize,
1050 "Offset of field: lzma_stream_flags::check"
1051 );
1052 assert_eq!(
1053 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum1) as usize - ptr as usize },
1054 20usize,
1055 "Offset of field: lzma_stream_flags::reserved_enum1"
1056 );
1057 assert_eq!(
1058 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum2) as usize - ptr as usize },
1059 24usize,
1060 "Offset of field: lzma_stream_flags::reserved_enum2"
1061 );
1062 assert_eq!(
1063 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum3) as usize - ptr as usize },
1064 28usize,
1065 "Offset of field: lzma_stream_flags::reserved_enum3"
1066 );
1067 assert_eq!(
1068 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum4) as usize - ptr as usize },
1069 32usize,
1070 "Offset of field: lzma_stream_flags::reserved_enum4"
1071 );
1072 assert_eq!(
1073 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool1) as usize - ptr as usize },
1074 36usize,
1075 "Offset of field: lzma_stream_flags::reserved_bool1"
1076 );
1077 assert_eq!(
1078 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool2) as usize - ptr as usize },
1079 37usize,
1080 "Offset of field: lzma_stream_flags::reserved_bool2"
1081 );
1082 assert_eq!(
1083 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool3) as usize - ptr as usize },
1084 38usize,
1085 "Offset of field: lzma_stream_flags::reserved_bool3"
1086 );
1087 assert_eq!(
1088 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool4) as usize - ptr as usize },
1089 39usize,
1090 "Offset of field: lzma_stream_flags::reserved_bool4"
1091 );
1092 assert_eq!(
1093 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool5) as usize - ptr as usize },
1094 40usize,
1095 "Offset of field: lzma_stream_flags::reserved_bool5"
1096 );
1097 assert_eq!(
1098 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool6) as usize - ptr as usize },
1099 41usize,
1100 "Offset of field: lzma_stream_flags::reserved_bool6"
1101 );
1102 assert_eq!(
1103 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool7) as usize - ptr as usize },
1104 42usize,
1105 "Offset of field: lzma_stream_flags::reserved_bool7"
1106 );
1107 assert_eq!(
1108 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool8) as usize - ptr as usize },
1109 43usize,
1110 "Offset of field: lzma_stream_flags::reserved_bool8"
1111 );
1112 assert_eq!(
1113 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int1) as usize - ptr as usize },
1114 44usize,
1115 "Offset of field: lzma_stream_flags::reserved_int1"
1116 );
1117 assert_eq!(
1118 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int2) as usize - ptr as usize },
1119 48usize,
1120 "Offset of field: lzma_stream_flags::reserved_int2"
1121 );
1122}
1123extern "C" {
1124 pub fn lzma_stream_header_encode(options: *const lzma_stream_flags, out: *mut u8) -> lzma_ret;
1125}
1126extern "C" {
1127 pub fn lzma_stream_footer_encode(options: *const lzma_stream_flags, out: *mut u8) -> lzma_ret;
1128}
1129extern "C" {
1130 pub fn lzma_stream_header_decode(options: *mut lzma_stream_flags, in_: *const u8) -> lzma_ret;
1131}
1132extern "C" {
1133 pub fn lzma_stream_footer_decode(options: *mut lzma_stream_flags, in_: *const u8) -> lzma_ret;
1134}
1135extern "C" {
1136 pub fn lzma_stream_flags_compare(
1137 a: *const lzma_stream_flags,
1138 b: *const lzma_stream_flags,
1139 ) -> lzma_ret;
1140}
1141#[repr(C)]
1142#[derive(Debug, Copy, Clone)]
1143pub struct lzma_block {
1144 pub version: u32,
1145 pub header_size: u32,
1146 pub check: lzma_check,
1147 pub compressed_size: lzma_vli,
1148 pub uncompressed_size: lzma_vli,
1149 pub filters: *mut lzma_filter,
1150 pub raw_check: [u8; 64usize],
1151 pub reserved_ptr1: *mut ::std::os::raw::c_void,
1152 pub reserved_ptr2: *mut ::std::os::raw::c_void,
1153 pub reserved_ptr3: *mut ::std::os::raw::c_void,
1154 pub reserved_int1: u32,
1155 pub reserved_int2: u32,
1156 pub reserved_int3: lzma_vli,
1157 pub reserved_int4: lzma_vli,
1158 pub reserved_int5: lzma_vli,
1159 pub reserved_int6: lzma_vli,
1160 pub reserved_int7: lzma_vli,
1161 pub reserved_int8: lzma_vli,
1162 pub reserved_enum1: lzma_reserved_enum,
1163 pub reserved_enum2: lzma_reserved_enum,
1164 pub reserved_enum3: lzma_reserved_enum,
1165 pub reserved_enum4: lzma_reserved_enum,
1166 pub ignore_check: lzma_bool,
1167 pub reserved_bool2: lzma_bool,
1168 pub reserved_bool3: lzma_bool,
1169 pub reserved_bool4: lzma_bool,
1170 pub reserved_bool5: lzma_bool,
1171 pub reserved_bool6: lzma_bool,
1172 pub reserved_bool7: lzma_bool,
1173 pub reserved_bool8: lzma_bool,
1174}
1175#[test]
1176fn bindgen_test_layout_lzma_block() {
1177 const UNINIT: ::std::mem::MaybeUninit<lzma_block> = ::std::mem::MaybeUninit::uninit();
1178 let ptr = UNINIT.as_ptr();
1179 assert_eq!(
1180 ::std::mem::size_of::<lzma_block>(),
1181 208usize,
1182 "Size of lzma_block"
1183 );
1184 assert_eq!(
1185 ::std::mem::align_of::<lzma_block>(),
1186 8usize,
1187 "Alignment of lzma_block"
1188 );
1189 assert_eq!(
1190 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
1191 0usize,
1192 "Offset of field: lzma_block::version"
1193 );
1194 assert_eq!(
1195 unsafe { ::std::ptr::addr_of!((*ptr).header_size) as usize - ptr as usize },
1196 4usize,
1197 "Offset of field: lzma_block::header_size"
1198 );
1199 assert_eq!(
1200 unsafe { ::std::ptr::addr_of!((*ptr).check) as usize - ptr as usize },
1201 8usize,
1202 "Offset of field: lzma_block::check"
1203 );
1204 assert_eq!(
1205 unsafe { ::std::ptr::addr_of!((*ptr).compressed_size) as usize - ptr as usize },
1206 16usize,
1207 "Offset of field: lzma_block::compressed_size"
1208 );
1209 assert_eq!(
1210 unsafe { ::std::ptr::addr_of!((*ptr).uncompressed_size) as usize - ptr as usize },
1211 24usize,
1212 "Offset of field: lzma_block::uncompressed_size"
1213 );
1214 assert_eq!(
1215 unsafe { ::std::ptr::addr_of!((*ptr).filters) as usize - ptr as usize },
1216 32usize,
1217 "Offset of field: lzma_block::filters"
1218 );
1219 assert_eq!(
1220 unsafe { ::std::ptr::addr_of!((*ptr).raw_check) as usize - ptr as usize },
1221 40usize,
1222 "Offset of field: lzma_block::raw_check"
1223 );
1224 assert_eq!(
1225 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr1) as usize - ptr as usize },
1226 104usize,
1227 "Offset of field: lzma_block::reserved_ptr1"
1228 );
1229 assert_eq!(
1230 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr2) as usize - ptr as usize },
1231 112usize,
1232 "Offset of field: lzma_block::reserved_ptr2"
1233 );
1234 assert_eq!(
1235 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr3) as usize - ptr as usize },
1236 120usize,
1237 "Offset of field: lzma_block::reserved_ptr3"
1238 );
1239 assert_eq!(
1240 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int1) as usize - ptr as usize },
1241 128usize,
1242 "Offset of field: lzma_block::reserved_int1"
1243 );
1244 assert_eq!(
1245 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int2) as usize - ptr as usize },
1246 132usize,
1247 "Offset of field: lzma_block::reserved_int2"
1248 );
1249 assert_eq!(
1250 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int3) as usize - ptr as usize },
1251 136usize,
1252 "Offset of field: lzma_block::reserved_int3"
1253 );
1254 assert_eq!(
1255 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int4) as usize - ptr as usize },
1256 144usize,
1257 "Offset of field: lzma_block::reserved_int4"
1258 );
1259 assert_eq!(
1260 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int5) as usize - ptr as usize },
1261 152usize,
1262 "Offset of field: lzma_block::reserved_int5"
1263 );
1264 assert_eq!(
1265 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int6) as usize - ptr as usize },
1266 160usize,
1267 "Offset of field: lzma_block::reserved_int6"
1268 );
1269 assert_eq!(
1270 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int7) as usize - ptr as usize },
1271 168usize,
1272 "Offset of field: lzma_block::reserved_int7"
1273 );
1274 assert_eq!(
1275 unsafe { ::std::ptr::addr_of!((*ptr).reserved_int8) as usize - ptr as usize },
1276 176usize,
1277 "Offset of field: lzma_block::reserved_int8"
1278 );
1279 assert_eq!(
1280 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum1) as usize - ptr as usize },
1281 184usize,
1282 "Offset of field: lzma_block::reserved_enum1"
1283 );
1284 assert_eq!(
1285 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum2) as usize - ptr as usize },
1286 188usize,
1287 "Offset of field: lzma_block::reserved_enum2"
1288 );
1289 assert_eq!(
1290 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum3) as usize - ptr as usize },
1291 192usize,
1292 "Offset of field: lzma_block::reserved_enum3"
1293 );
1294 assert_eq!(
1295 unsafe { ::std::ptr::addr_of!((*ptr).reserved_enum4) as usize - ptr as usize },
1296 196usize,
1297 "Offset of field: lzma_block::reserved_enum4"
1298 );
1299 assert_eq!(
1300 unsafe { ::std::ptr::addr_of!((*ptr).ignore_check) as usize - ptr as usize },
1301 200usize,
1302 "Offset of field: lzma_block::ignore_check"
1303 );
1304 assert_eq!(
1305 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool2) as usize - ptr as usize },
1306 201usize,
1307 "Offset of field: lzma_block::reserved_bool2"
1308 );
1309 assert_eq!(
1310 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool3) as usize - ptr as usize },
1311 202usize,
1312 "Offset of field: lzma_block::reserved_bool3"
1313 );
1314 assert_eq!(
1315 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool4) as usize - ptr as usize },
1316 203usize,
1317 "Offset of field: lzma_block::reserved_bool4"
1318 );
1319 assert_eq!(
1320 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool5) as usize - ptr as usize },
1321 204usize,
1322 "Offset of field: lzma_block::reserved_bool5"
1323 );
1324 assert_eq!(
1325 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool6) as usize - ptr as usize },
1326 205usize,
1327 "Offset of field: lzma_block::reserved_bool6"
1328 );
1329 assert_eq!(
1330 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool7) as usize - ptr as usize },
1331 206usize,
1332 "Offset of field: lzma_block::reserved_bool7"
1333 );
1334 assert_eq!(
1335 unsafe { ::std::ptr::addr_of!((*ptr).reserved_bool8) as usize - ptr as usize },
1336 207usize,
1337 "Offset of field: lzma_block::reserved_bool8"
1338 );
1339}
1340extern "C" {
1341 pub fn lzma_block_header_size(block: *mut lzma_block) -> lzma_ret;
1342}
1343extern "C" {
1344 pub fn lzma_block_header_encode(block: *const lzma_block, out: *mut u8) -> lzma_ret;
1345}
1346extern "C" {
1347 pub fn lzma_block_header_decode(
1348 block: *mut lzma_block,
1349 allocator: *const lzma_allocator,
1350 in_: *const u8,
1351 ) -> lzma_ret;
1352}
1353extern "C" {
1354 pub fn lzma_block_compressed_size(block: *mut lzma_block, unpadded_size: lzma_vli) -> lzma_ret;
1355}
1356extern "C" {
1357 pub fn lzma_block_unpadded_size(block: *const lzma_block) -> lzma_vli;
1358}
1359extern "C" {
1360 pub fn lzma_block_total_size(block: *const lzma_block) -> lzma_vli;
1361}
1362extern "C" {
1363 pub fn lzma_block_encoder(strm: *mut lzma_stream, block: *mut lzma_block) -> lzma_ret;
1364}
1365extern "C" {
1366 pub fn lzma_block_decoder(strm: *mut lzma_stream, block: *mut lzma_block) -> lzma_ret;
1367}
1368extern "C" {
1369 pub fn lzma_block_buffer_bound(uncompressed_size: usize) -> usize;
1370}
1371extern "C" {
1372 pub fn lzma_block_buffer_encode(
1373 block: *mut lzma_block,
1374 allocator: *const lzma_allocator,
1375 in_: *const u8,
1376 in_size: usize,
1377 out: *mut u8,
1378 out_pos: *mut usize,
1379 out_size: usize,
1380 ) -> lzma_ret;
1381}
1382extern "C" {
1383 pub fn lzma_block_uncomp_encode(
1384 block: *mut lzma_block,
1385 in_: *const u8,
1386 in_size: usize,
1387 out: *mut u8,
1388 out_pos: *mut usize,
1389 out_size: usize,
1390 ) -> lzma_ret;
1391}
1392extern "C" {
1393 pub fn lzma_block_buffer_decode(
1394 block: *mut lzma_block,
1395 allocator: *const lzma_allocator,
1396 in_: *const u8,
1397 in_pos: *mut usize,
1398 in_size: usize,
1399 out: *mut u8,
1400 out_pos: *mut usize,
1401 out_size: usize,
1402 ) -> lzma_ret;
1403}
1404#[repr(C)]
1405#[derive(Debug, Copy, Clone)]
1406pub struct lzma_index_s {
1407 _unused: [u8; 0],
1408}
1409pub type lzma_index = lzma_index_s;
1410#[repr(C)]
1411#[derive(Copy, Clone)]
1412pub struct lzma_index_iter {
1413 pub stream: lzma_index_iter__bindgen_ty_1,
1414 pub block: lzma_index_iter__bindgen_ty_2,
1415 pub internal: [lzma_index_iter__bindgen_ty_3; 6usize],
1416}
1417#[repr(C)]
1418#[derive(Debug, Copy, Clone)]
1419pub struct lzma_index_iter__bindgen_ty_1 {
1420 pub flags: *const lzma_stream_flags,
1421 pub reserved_ptr1: *const ::std::os::raw::c_void,
1422 pub reserved_ptr2: *const ::std::os::raw::c_void,
1423 pub reserved_ptr3: *const ::std::os::raw::c_void,
1424 pub number: lzma_vli,
1425 pub block_count: lzma_vli,
1426 pub compressed_offset: lzma_vli,
1427 pub uncompressed_offset: lzma_vli,
1428 pub compressed_size: lzma_vli,
1429 pub uncompressed_size: lzma_vli,
1430 pub padding: lzma_vli,
1431 pub reserved_vli1: lzma_vli,
1432 pub reserved_vli2: lzma_vli,
1433 pub reserved_vli3: lzma_vli,
1434 pub reserved_vli4: lzma_vli,
1435}
1436#[test]
1437fn bindgen_test_layout_lzma_index_iter__bindgen_ty_1() {
1438 const UNINIT: ::std::mem::MaybeUninit<lzma_index_iter__bindgen_ty_1> =
1439 ::std::mem::MaybeUninit::uninit();
1440 let ptr = UNINIT.as_ptr();
1441 assert_eq!(
1442 ::std::mem::size_of::<lzma_index_iter__bindgen_ty_1>(),
1443 120usize,
1444 "Size of lzma_index_iter__bindgen_ty_1"
1445 );
1446 assert_eq!(
1447 ::std::mem::align_of::<lzma_index_iter__bindgen_ty_1>(),
1448 8usize,
1449 "Alignment of lzma_index_iter__bindgen_ty_1"
1450 );
1451 assert_eq!(
1452 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1453 0usize,
1454 "Offset of field: lzma_index_iter__bindgen_ty_1::flags"
1455 );
1456 assert_eq!(
1457 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr1) as usize - ptr as usize },
1458 8usize,
1459 "Offset of field: lzma_index_iter__bindgen_ty_1::reserved_ptr1"
1460 );
1461 assert_eq!(
1462 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr2) as usize - ptr as usize },
1463 16usize,
1464 "Offset of field: lzma_index_iter__bindgen_ty_1::reserved_ptr2"
1465 );
1466 assert_eq!(
1467 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr3) as usize - ptr as usize },
1468 24usize,
1469 "Offset of field: lzma_index_iter__bindgen_ty_1::reserved_ptr3"
1470 );
1471 assert_eq!(
1472 unsafe { ::std::ptr::addr_of!((*ptr).number) as usize - ptr as usize },
1473 32usize,
1474 "Offset of field: lzma_index_iter__bindgen_ty_1::number"
1475 );
1476 assert_eq!(
1477 unsafe { ::std::ptr::addr_of!((*ptr).block_count) as usize - ptr as usize },
1478 40usize,
1479 "Offset of field: lzma_index_iter__bindgen_ty_1::block_count"
1480 );
1481 assert_eq!(
1482 unsafe { ::std::ptr::addr_of!((*ptr).compressed_offset) as usize - ptr as usize },
1483 48usize,
1484 "Offset of field: lzma_index_iter__bindgen_ty_1::compressed_offset"
1485 );
1486 assert_eq!(
1487 unsafe { ::std::ptr::addr_of!((*ptr).uncompressed_offset) as usize - ptr as usize },
1488 56usize,
1489 "Offset of field: lzma_index_iter__bindgen_ty_1::uncompressed_offset"
1490 );
1491 assert_eq!(
1492 unsafe { ::std::ptr::addr_of!((*ptr).compressed_size) as usize - ptr as usize },
1493 64usize,
1494 "Offset of field: lzma_index_iter__bindgen_ty_1::compressed_size"
1495 );
1496 assert_eq!(
1497 unsafe { ::std::ptr::addr_of!((*ptr).uncompressed_size) as usize - ptr as usize },
1498 72usize,
1499 "Offset of field: lzma_index_iter__bindgen_ty_1::uncompressed_size"
1500 );
1501 assert_eq!(
1502 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
1503 80usize,
1504 "Offset of field: lzma_index_iter__bindgen_ty_1::padding"
1505 );
1506 assert_eq!(
1507 unsafe { ::std::ptr::addr_of!((*ptr).reserved_vli1) as usize - ptr as usize },
1508 88usize,
1509 "Offset of field: lzma_index_iter__bindgen_ty_1::reserved_vli1"
1510 );
1511 assert_eq!(
1512 unsafe { ::std::ptr::addr_of!((*ptr).reserved_vli2) as usize - ptr as usize },
1513 96usize,
1514 "Offset of field: lzma_index_iter__bindgen_ty_1::reserved_vli2"
1515 );
1516 assert_eq!(
1517 unsafe { ::std::ptr::addr_of!((*ptr).reserved_vli3) as usize - ptr as usize },
1518 104usize,
1519 "Offset of field: lzma_index_iter__bindgen_ty_1::reserved_vli3"
1520 );
1521 assert_eq!(
1522 unsafe { ::std::ptr::addr_of!((*ptr).reserved_vli4) as usize - ptr as usize },
1523 112usize,
1524 "Offset of field: lzma_index_iter__bindgen_ty_1::reserved_vli4"
1525 );
1526}
1527#[repr(C)]
1528#[derive(Debug, Copy, Clone)]
1529pub struct lzma_index_iter__bindgen_ty_2 {
1530 pub number_in_file: lzma_vli,
1531 pub compressed_file_offset: lzma_vli,
1532 pub uncompressed_file_offset: lzma_vli,
1533 pub number_in_stream: lzma_vli,
1534 pub compressed_stream_offset: lzma_vli,
1535 pub uncompressed_stream_offset: lzma_vli,
1536 pub uncompressed_size: lzma_vli,
1537 pub unpadded_size: lzma_vli,
1538 pub total_size: lzma_vli,
1539 pub reserved_vli1: lzma_vli,
1540 pub reserved_vli2: lzma_vli,
1541 pub reserved_vli3: lzma_vli,
1542 pub reserved_vli4: lzma_vli,
1543 pub reserved_ptr1: *const ::std::os::raw::c_void,
1544 pub reserved_ptr2: *const ::std::os::raw::c_void,
1545 pub reserved_ptr3: *const ::std::os::raw::c_void,
1546 pub reserved_ptr4: *const ::std::os::raw::c_void,
1547}
1548#[test]
1549fn bindgen_test_layout_lzma_index_iter__bindgen_ty_2() {
1550 const UNINIT: ::std::mem::MaybeUninit<lzma_index_iter__bindgen_ty_2> =
1551 ::std::mem::MaybeUninit::uninit();
1552 let ptr = UNINIT.as_ptr();
1553 assert_eq!(
1554 ::std::mem::size_of::<lzma_index_iter__bindgen_ty_2>(),
1555 136usize,
1556 "Size of lzma_index_iter__bindgen_ty_2"
1557 );
1558 assert_eq!(
1559 ::std::mem::align_of::<lzma_index_iter__bindgen_ty_2>(),
1560 8usize,
1561 "Alignment of lzma_index_iter__bindgen_ty_2"
1562 );
1563 assert_eq!(
1564 unsafe { ::std::ptr::addr_of!((*ptr).number_in_file) as usize - ptr as usize },
1565 0usize,
1566 "Offset of field: lzma_index_iter__bindgen_ty_2::number_in_file"
1567 );
1568 assert_eq!(
1569 unsafe { ::std::ptr::addr_of!((*ptr).compressed_file_offset) as usize - ptr as usize },
1570 8usize,
1571 "Offset of field: lzma_index_iter__bindgen_ty_2::compressed_file_offset"
1572 );
1573 assert_eq!(
1574 unsafe { ::std::ptr::addr_of!((*ptr).uncompressed_file_offset) as usize - ptr as usize },
1575 16usize,
1576 "Offset of field: lzma_index_iter__bindgen_ty_2::uncompressed_file_offset"
1577 );
1578 assert_eq!(
1579 unsafe { ::std::ptr::addr_of!((*ptr).number_in_stream) as usize - ptr as usize },
1580 24usize,
1581 "Offset of field: lzma_index_iter__bindgen_ty_2::number_in_stream"
1582 );
1583 assert_eq!(
1584 unsafe { ::std::ptr::addr_of!((*ptr).compressed_stream_offset) as usize - ptr as usize },
1585 32usize,
1586 "Offset of field: lzma_index_iter__bindgen_ty_2::compressed_stream_offset"
1587 );
1588 assert_eq!(
1589 unsafe { ::std::ptr::addr_of!((*ptr).uncompressed_stream_offset) as usize - ptr as usize },
1590 40usize,
1591 "Offset of field: lzma_index_iter__bindgen_ty_2::uncompressed_stream_offset"
1592 );
1593 assert_eq!(
1594 unsafe { ::std::ptr::addr_of!((*ptr).uncompressed_size) as usize - ptr as usize },
1595 48usize,
1596 "Offset of field: lzma_index_iter__bindgen_ty_2::uncompressed_size"
1597 );
1598 assert_eq!(
1599 unsafe { ::std::ptr::addr_of!((*ptr).unpadded_size) as usize - ptr as usize },
1600 56usize,
1601 "Offset of field: lzma_index_iter__bindgen_ty_2::unpadded_size"
1602 );
1603 assert_eq!(
1604 unsafe { ::std::ptr::addr_of!((*ptr).total_size) as usize - ptr as usize },
1605 64usize,
1606 "Offset of field: lzma_index_iter__bindgen_ty_2::total_size"
1607 );
1608 assert_eq!(
1609 unsafe { ::std::ptr::addr_of!((*ptr).reserved_vli1) as usize - ptr as usize },
1610 72usize,
1611 "Offset of field: lzma_index_iter__bindgen_ty_2::reserved_vli1"
1612 );
1613 assert_eq!(
1614 unsafe { ::std::ptr::addr_of!((*ptr).reserved_vli2) as usize - ptr as usize },
1615 80usize,
1616 "Offset of field: lzma_index_iter__bindgen_ty_2::reserved_vli2"
1617 );
1618 assert_eq!(
1619 unsafe { ::std::ptr::addr_of!((*ptr).reserved_vli3) as usize - ptr as usize },
1620 88usize,
1621 "Offset of field: lzma_index_iter__bindgen_ty_2::reserved_vli3"
1622 );
1623 assert_eq!(
1624 unsafe { ::std::ptr::addr_of!((*ptr).reserved_vli4) as usize - ptr as usize },
1625 96usize,
1626 "Offset of field: lzma_index_iter__bindgen_ty_2::reserved_vli4"
1627 );
1628 assert_eq!(
1629 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr1) as usize - ptr as usize },
1630 104usize,
1631 "Offset of field: lzma_index_iter__bindgen_ty_2::reserved_ptr1"
1632 );
1633 assert_eq!(
1634 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr2) as usize - ptr as usize },
1635 112usize,
1636 "Offset of field: lzma_index_iter__bindgen_ty_2::reserved_ptr2"
1637 );
1638 assert_eq!(
1639 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr3) as usize - ptr as usize },
1640 120usize,
1641 "Offset of field: lzma_index_iter__bindgen_ty_2::reserved_ptr3"
1642 );
1643 assert_eq!(
1644 unsafe { ::std::ptr::addr_of!((*ptr).reserved_ptr4) as usize - ptr as usize },
1645 128usize,
1646 "Offset of field: lzma_index_iter__bindgen_ty_2::reserved_ptr4"
1647 );
1648}
1649#[repr(C)]
1650#[derive(Copy, Clone)]
1651pub union lzma_index_iter__bindgen_ty_3 {
1652 pub p: *const ::std::os::raw::c_void,
1653 pub s: usize,
1654 pub v: lzma_vli,
1655}
1656#[test]
1657fn bindgen_test_layout_lzma_index_iter__bindgen_ty_3() {
1658 const UNINIT: ::std::mem::MaybeUninit<lzma_index_iter__bindgen_ty_3> =
1659 ::std::mem::MaybeUninit::uninit();
1660 let ptr = UNINIT.as_ptr();
1661 assert_eq!(
1662 ::std::mem::size_of::<lzma_index_iter__bindgen_ty_3>(),
1663 8usize,
1664 "Size of lzma_index_iter__bindgen_ty_3"
1665 );
1666 assert_eq!(
1667 ::std::mem::align_of::<lzma_index_iter__bindgen_ty_3>(),
1668 8usize,
1669 "Alignment of lzma_index_iter__bindgen_ty_3"
1670 );
1671 assert_eq!(
1672 unsafe { ::std::ptr::addr_of!((*ptr).p) as usize - ptr as usize },
1673 0usize,
1674 "Offset of field: lzma_index_iter__bindgen_ty_3::p"
1675 );
1676 assert_eq!(
1677 unsafe { ::std::ptr::addr_of!((*ptr).s) as usize - ptr as usize },
1678 0usize,
1679 "Offset of field: lzma_index_iter__bindgen_ty_3::s"
1680 );
1681 assert_eq!(
1682 unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
1683 0usize,
1684 "Offset of field: lzma_index_iter__bindgen_ty_3::v"
1685 );
1686}
1687#[test]
1688fn bindgen_test_layout_lzma_index_iter() {
1689 const UNINIT: ::std::mem::MaybeUninit<lzma_index_iter> = ::std::mem::MaybeUninit::uninit();
1690 let ptr = UNINIT.as_ptr();
1691 assert_eq!(
1692 ::std::mem::size_of::<lzma_index_iter>(),
1693 304usize,
1694 "Size of lzma_index_iter"
1695 );
1696 assert_eq!(
1697 ::std::mem::align_of::<lzma_index_iter>(),
1698 8usize,
1699 "Alignment of lzma_index_iter"
1700 );
1701 assert_eq!(
1702 unsafe { ::std::ptr::addr_of!((*ptr).stream) as usize - ptr as usize },
1703 0usize,
1704 "Offset of field: lzma_index_iter::stream"
1705 );
1706 assert_eq!(
1707 unsafe { ::std::ptr::addr_of!((*ptr).block) as usize - ptr as usize },
1708 120usize,
1709 "Offset of field: lzma_index_iter::block"
1710 );
1711 assert_eq!(
1712 unsafe { ::std::ptr::addr_of!((*ptr).internal) as usize - ptr as usize },
1713 256usize,
1714 "Offset of field: lzma_index_iter::internal"
1715 );
1716}
1717pub const lzma_index_iter_mode_LZMA_INDEX_ITER_ANY: lzma_index_iter_mode = 0;
1718pub const lzma_index_iter_mode_LZMA_INDEX_ITER_STREAM: lzma_index_iter_mode = 1;
1719pub const lzma_index_iter_mode_LZMA_INDEX_ITER_BLOCK: lzma_index_iter_mode = 2;
1720pub const lzma_index_iter_mode_LZMA_INDEX_ITER_NONEMPTY_BLOCK: lzma_index_iter_mode = 3;
1721pub type lzma_index_iter_mode = ::std::os::raw::c_uint;
1722extern "C" {
1723 pub fn lzma_index_memusage(streams: lzma_vli, blocks: lzma_vli) -> u64;
1724}
1725extern "C" {
1726 pub fn lzma_index_memused(i: *const lzma_index) -> u64;
1727}
1728extern "C" {
1729 pub fn lzma_index_init(allocator: *const lzma_allocator) -> *mut lzma_index;
1730}
1731extern "C" {
1732 pub fn lzma_index_end(i: *mut lzma_index, allocator: *const lzma_allocator);
1733}
1734extern "C" {
1735 pub fn lzma_index_append(
1736 i: *mut lzma_index,
1737 allocator: *const lzma_allocator,
1738 unpadded_size: lzma_vli,
1739 uncompressed_size: lzma_vli,
1740 ) -> lzma_ret;
1741}
1742extern "C" {
1743 pub fn lzma_index_stream_flags(
1744 i: *mut lzma_index,
1745 stream_flags: *const lzma_stream_flags,
1746 ) -> lzma_ret;
1747}
1748extern "C" {
1749 pub fn lzma_index_checks(i: *const lzma_index) -> u32;
1750}
1751extern "C" {
1752 pub fn lzma_index_stream_padding(i: *mut lzma_index, stream_padding: lzma_vli) -> lzma_ret;
1753}
1754extern "C" {
1755 pub fn lzma_index_stream_count(i: *const lzma_index) -> lzma_vli;
1756}
1757extern "C" {
1758 pub fn lzma_index_block_count(i: *const lzma_index) -> lzma_vli;
1759}
1760extern "C" {
1761 pub fn lzma_index_size(i: *const lzma_index) -> lzma_vli;
1762}
1763extern "C" {
1764 pub fn lzma_index_stream_size(i: *const lzma_index) -> lzma_vli;
1765}
1766extern "C" {
1767 pub fn lzma_index_total_size(i: *const lzma_index) -> lzma_vli;
1768}
1769extern "C" {
1770 pub fn lzma_index_file_size(i: *const lzma_index) -> lzma_vli;
1771}
1772extern "C" {
1773 pub fn lzma_index_uncompressed_size(i: *const lzma_index) -> lzma_vli;
1774}
1775extern "C" {
1776 pub fn lzma_index_iter_init(iter: *mut lzma_index_iter, i: *const lzma_index);
1777}
1778extern "C" {
1779 pub fn lzma_index_iter_rewind(iter: *mut lzma_index_iter);
1780}
1781extern "C" {
1782 pub fn lzma_index_iter_next(
1783 iter: *mut lzma_index_iter,
1784 mode: lzma_index_iter_mode,
1785 ) -> lzma_bool;
1786}
1787extern "C" {
1788 pub fn lzma_index_iter_locate(iter: *mut lzma_index_iter, target: lzma_vli) -> lzma_bool;
1789}
1790extern "C" {
1791 pub fn lzma_index_cat(
1792 dest: *mut lzma_index,
1793 src: *mut lzma_index,
1794 allocator: *const lzma_allocator,
1795 ) -> lzma_ret;
1796}
1797extern "C" {
1798 pub fn lzma_index_dup(
1799 i: *const lzma_index,
1800 allocator: *const lzma_allocator,
1801 ) -> *mut lzma_index;
1802}
1803extern "C" {
1804 pub fn lzma_index_encoder(strm: *mut lzma_stream, i: *const lzma_index) -> lzma_ret;
1805}
1806extern "C" {
1807 pub fn lzma_index_decoder(
1808 strm: *mut lzma_stream,
1809 i: *mut *mut lzma_index,
1810 memlimit: u64,
1811 ) -> lzma_ret;
1812}
1813extern "C" {
1814 pub fn lzma_index_buffer_encode(
1815 i: *const lzma_index,
1816 out: *mut u8,
1817 out_pos: *mut usize,
1818 out_size: usize,
1819 ) -> lzma_ret;
1820}
1821extern "C" {
1822 pub fn lzma_index_buffer_decode(
1823 i: *mut *mut lzma_index,
1824 memlimit: *mut u64,
1825 allocator: *const lzma_allocator,
1826 in_: *const u8,
1827 in_pos: *mut usize,
1828 in_size: usize,
1829 ) -> lzma_ret;
1830}
1831extern "C" {
1832 pub fn lzma_file_info_decoder(
1833 strm: *mut lzma_stream,
1834 dest_index: *mut *mut lzma_index,
1835 memlimit: u64,
1836 file_size: u64,
1837 ) -> lzma_ret;
1838}
1839#[repr(C)]
1840#[derive(Debug, Copy, Clone)]
1841pub struct lzma_index_hash_s {
1842 _unused: [u8; 0],
1843}
1844pub type lzma_index_hash = lzma_index_hash_s;
1845extern "C" {
1846 pub fn lzma_index_hash_init(
1847 index_hash: *mut lzma_index_hash,
1848 allocator: *const lzma_allocator,
1849 ) -> *mut lzma_index_hash;
1850}
1851extern "C" {
1852 pub fn lzma_index_hash_end(index_hash: *mut lzma_index_hash, allocator: *const lzma_allocator);
1853}
1854extern "C" {
1855 pub fn lzma_index_hash_append(
1856 index_hash: *mut lzma_index_hash,
1857 unpadded_size: lzma_vli,
1858 uncompressed_size: lzma_vli,
1859 ) -> lzma_ret;
1860}
1861extern "C" {
1862 pub fn lzma_index_hash_decode(
1863 index_hash: *mut lzma_index_hash,
1864 in_: *const u8,
1865 in_pos: *mut usize,
1866 in_size: usize,
1867 ) -> lzma_ret;
1868}
1869extern "C" {
1870 pub fn lzma_index_hash_size(index_hash: *const lzma_index_hash) -> lzma_vli;
1871}
1872extern "C" {
1873 pub fn lzma_physmem() -> u64;
1874}
1875extern "C" {
1876 pub fn lzma_cputhreads() -> u32;
1877}