pub const HELP_BUILTIN: u32 = 1;
pub const CMD_WANT_SUBSHELL: u32 = 1;
pub const CMD_FORCE_SUBSHELL: u32 = 2;
pub const CMD_INVERT_RETURN: u32 = 4;
pub const CMD_IGNORE_RETURN: u32 = 8;
pub const CMD_NO_FUNCTIONS: u32 = 16;
pub const CMD_INHIBIT_EXPANSION: u32 = 32;
pub const CMD_NO_FORK: u32 = 64;
pub const CMD_TIME_PIPELINE: u32 = 128;
pub const CMD_TIME_POSIX: u32 = 256;
pub const CMD_AMPERSAND: u32 = 512;
pub const CMD_STDIN_REDIR: u32 = 1024;
pub const CMD_COMMAND_BUILTIN: u32 = 2048;
pub const CMD_COPROC_SUBSHELL: u32 = 4096;
pub const CMD_LASTPIPE: u32 = 8192;
pub const CMD_STDPATH: u32 = 16384;
pub const CMD_TRY_OPTIMIZING: u32 = 32768;
pub const BUILTIN_ENABLED: u32 = 1;
pub const BUILTIN_DELETED: u32 = 2;
pub const STATIC_BUILTIN: u32 = 4;
pub const SPECIAL_BUILTIN: u32 = 8;
pub const ASSIGNMENT_BUILTIN: u32 = 16;
pub const POSIX_BUILTIN: u32 = 32;
pub const LOCALVAR_BUILTIN: u32 = 64;
pub const ARRAYREF_BUILTIN: u32 = 128;
pub const att_exported: u32 = 1;
pub const att_readonly: u32 = 2;
pub const att_array: u32 = 4;
pub const att_function: u32 = 8;
pub const att_integer: u32 = 16;
pub const att_local: u32 = 32;
pub const att_assoc: u32 = 64;
pub const att_trace: u32 = 128;
pub const att_uppercase: u32 = 256;
pub const att_lowercase: u32 = 512;
pub const att_capcase: u32 = 1024;
pub const att_nameref: u32 = 2048;
pub const att_invisible: u32 = 4096;
pub const att_nounset: u32 = 8192;
pub const att_noassign: u32 = 16384;
pub const att_imported: u32 = 32768;
pub const att_special: u32 = 65536;
pub const att_nofree: u32 = 131072;
pub const att_regenerate: u32 = 262144;
pub const att_tempvar: u32 = 1048576;
pub const att_propagate: u32 = 2097152;
pub const ASS_APPEND: u32 = 1;
pub const ASS_MKLOCAL: u32 = 2;
pub const ASS_MKASSOC: u32 = 4;
pub const ASS_MKGLOBAL: u32 = 8;
pub const ASS_NAMEREF: u32 = 16;
pub const ASS_FORCE: u32 = 32;
pub const ASS_CHKLOCAL: u32 = 64;
pub const ASS_NOEXPAND: u32 = 128;
pub const ASS_NOEVAL: u32 = 256;
pub const ASS_NOLONGJMP: u32 = 512;
pub const ASS_NOINVIS: u32 = 1024;
pub const ASS_ALLOWALLSUB: u32 = 2048;
pub const ASS_ONEWORD: u32 = 4096;
pub const EXECUTION_FAILURE: u32 = 1;
pub const EXECUTION_SUCCESS: u32 = 0;
pub const EX_LONGJMP: u32 = 255;
pub const SEVAL_NONINT: u32 = 1;
pub const SEVAL_INTERACT: u32 = 2;
pub const SEVAL_NOHIST: u32 = 4;
pub const SEVAL_NOFREE: u32 = 8;
pub const SEVAL_RESETLINE: u32 = 16;
pub const SEVAL_PARSEONLY: u32 = 32;
pub const SEVAL_NOLONGJMP: u32 = 64;
pub const SEVAL_FUNCDEF: u32 = 128;
pub const SEVAL_ONECMD: u32 = 256;
pub const SEVAL_NOHISTEXP: u32 = 512;
pub const SEVAL_NOOPTIMIZE: u32 = 1024;
pub type __intmax_t = ::std::os::raw::c_long;
pub type __pid_t = ::std::os::raw::c_int;
pub type pid_t = __pid_t;
pub const r_instruction_r_output_direction: r_instruction = 0;
pub const r_instruction_r_input_direction: r_instruction = 1;
pub const r_instruction_r_inputa_direction: r_instruction = 2;
pub const r_instruction_r_appending_to: r_instruction = 3;
pub const r_instruction_r_reading_until: r_instruction = 4;
pub const r_instruction_r_reading_string: r_instruction = 5;
pub const r_instruction_r_duplicating_input: r_instruction = 6;
pub const r_instruction_r_duplicating_output: r_instruction = 7;
pub const r_instruction_r_deblank_reading_until: r_instruction = 8;
pub const r_instruction_r_close_this: r_instruction = 9;
pub const r_instruction_r_err_and_out: r_instruction = 10;
pub const r_instruction_r_input_output: r_instruction = 11;
pub const r_instruction_r_output_force: r_instruction = 12;
pub const r_instruction_r_duplicating_input_word: r_instruction = 13;
pub const r_instruction_r_duplicating_output_word: r_instruction = 14;
pub const r_instruction_r_move_input: r_instruction = 15;
pub const r_instruction_r_move_output: r_instruction = 16;
pub const r_instruction_r_move_input_word: r_instruction = 17;
pub const r_instruction_r_move_output_word: r_instruction = 18;
pub const r_instruction_r_append_err_and_out: r_instruction = 19;
pub type r_instruction = ::std::os::raw::c_uint;
pub const command_type_cm_for: command_type = 0;
pub const command_type_cm_case: command_type = 1;
pub const command_type_cm_while: command_type = 2;
pub const command_type_cm_if: command_type = 3;
pub const command_type_cm_simple: command_type = 4;
pub const command_type_cm_select: command_type = 5;
pub const command_type_cm_connection: command_type = 6;
pub const command_type_cm_function_def: command_type = 7;
pub const command_type_cm_until: command_type = 8;
pub const command_type_cm_group: command_type = 9;
pub const command_type_cm_arith: command_type = 10;
pub const command_type_cm_cond: command_type = 11;
pub const command_type_cm_arith_for: command_type = 12;
pub const command_type_cm_subshell: command_type = 13;
pub const command_type_cm_coproc: command_type = 14;
pub type command_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WordDesc {
pub word: *mut ::std::os::raw::c_char,
pub flags: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_WordDesc() {
const UNINIT: ::std::mem::MaybeUninit<WordDesc> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<WordDesc>(),
16usize,
concat!("Size of: ", stringify!(WordDesc))
);
assert_eq!(
::std::mem::align_of::<WordDesc>(),
8usize,
concat!("Alignment of ", stringify!(WordDesc))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).word) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(WordDesc),
"::",
stringify!(word)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(WordDesc),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WordList {
pub next: *mut WordList,
pub word: *mut WordDesc,
}
#[test]
fn bindgen_test_layout_WordList() {
const UNINIT: ::std::mem::MaybeUninit<WordList> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<WordList>(),
16usize,
concat!("Size of: ", stringify!(WordList))
);
assert_eq!(
::std::mem::align_of::<WordList>(),
8usize,
concat!("Alignment of ", stringify!(WordList))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(WordList),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).word) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(WordList),
"::",
stringify!(word)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union REDIRECTEE {
pub dest: ::std::os::raw::c_int,
pub filename: *mut WordDesc,
}
#[test]
fn bindgen_test_layout_REDIRECTEE() {
const UNINIT: ::std::mem::MaybeUninit<REDIRECTEE> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<REDIRECTEE>(),
8usize,
concat!("Size of: ", stringify!(REDIRECTEE))
);
assert_eq!(
::std::mem::align_of::<REDIRECTEE>(),
8usize,
concat!("Alignment of ", stringify!(REDIRECTEE))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dest) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(REDIRECTEE),
"::",
stringify!(dest)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).filename) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(REDIRECTEE),
"::",
stringify!(filename)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct redirect {
pub next: *mut redirect,
pub redirector: REDIRECTEE,
pub rflags: ::std::os::raw::c_int,
pub flags: ::std::os::raw::c_int,
pub instruction: r_instruction,
pub redirectee: REDIRECTEE,
pub here_doc_eof: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_redirect() {
const UNINIT: ::std::mem::MaybeUninit<redirect> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<redirect>(),
48usize,
concat!("Size of: ", stringify!(redirect))
);
assert_eq!(
::std::mem::align_of::<redirect>(),
8usize,
concat!("Alignment of ", stringify!(redirect))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(redirect),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).redirector) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(redirect),
"::",
stringify!(redirector)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rflags) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(redirect),
"::",
stringify!(rflags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(redirect),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).instruction) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(redirect),
"::",
stringify!(instruction)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).redirectee) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(redirect),
"::",
stringify!(redirectee)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).here_doc_eof) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(redirect),
"::",
stringify!(here_doc_eof)
)
);
}
pub type REDIRECT = redirect;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct Command {
pub type_: command_type,
pub flags: ::std::os::raw::c_int,
pub line: ::std::os::raw::c_int,
pub redirects: *mut REDIRECT,
pub value: command__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union command__bindgen_ty_1 {
pub For: *mut for_com,
pub Case: *mut case_com,
pub While: *mut while_com,
pub If: *mut if_com,
pub Connection: *mut connection,
pub Simple: *mut simple_com,
pub Function_def: *mut function_def,
pub Group: *mut group_com,
pub Select: *mut select_com,
pub Arith: *mut arith_com,
pub Cond: *mut cond_com,
pub ArithFor: *mut arith_for_com,
pub Subshell: *mut subshell_com,
pub Coproc: *mut coproc_com,
}
#[test]
fn bindgen_test_layout_command__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<command__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<command__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(command__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<command__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(command__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).For) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(command__bindgen_ty_1),
"::",
stringify!(For)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Case) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(command__bindgen_ty_1),
"::",
stringify!(Case)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).While) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(command__bindgen_ty_1),
"::",
stringify!(While)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).If) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(command__bindgen_ty_1),
"::",
stringify!(If)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Connection) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(command__bindgen_ty_1),
"::",
stringify!(Connection)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Simple) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(command__bindgen_ty_1),
"::",
stringify!(Simple)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Function_def) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(command__bindgen_ty_1),
"::",
stringify!(Function_def)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Group) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(command__bindgen_ty_1),
"::",
stringify!(Group)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Select) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(command__bindgen_ty_1),
"::",
stringify!(Select)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Arith) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(command__bindgen_ty_1),
"::",
stringify!(Arith)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Cond) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(command__bindgen_ty_1),
"::",
stringify!(Cond)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ArithFor) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(command__bindgen_ty_1),
"::",
stringify!(ArithFor)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Subshell) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(command__bindgen_ty_1),
"::",
stringify!(Subshell)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Coproc) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(command__bindgen_ty_1),
"::",
stringify!(Coproc)
)
);
}
#[test]
fn bindgen_test_layout_Command() {
const UNINIT: ::std::mem::MaybeUninit<Command> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Command>(),
32usize,
concat!("Size of: ", stringify!(Command))
);
assert_eq!(
::std::mem::align_of::<Command>(),
8usize,
concat!("Alignment of ", stringify!(Command))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Command),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(Command),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(Command),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).redirects) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(Command),
"::",
stringify!(redirects)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(Command),
"::",
stringify!(value)
)
);
}
pub type COMMAND = Command;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct connection {
pub ignore: ::std::os::raw::c_int,
pub first: *mut COMMAND,
pub second: *mut COMMAND,
pub connector: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_connection() {
const UNINIT: ::std::mem::MaybeUninit<connection> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<connection>(),
32usize,
concat!("Size of: ", stringify!(connection))
);
assert_eq!(
::std::mem::align_of::<connection>(),
8usize,
concat!("Alignment of ", stringify!(connection))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(connection),
"::",
stringify!(ignore)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(connection),
"::",
stringify!(first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).second) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(connection),
"::",
stringify!(second)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).connector) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(connection),
"::",
stringify!(connector)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pattern_list {
pub next: *mut pattern_list,
pub patterns: *mut WordList,
pub action: *mut COMMAND,
pub flags: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_pattern_list() {
const UNINIT: ::std::mem::MaybeUninit<pattern_list> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<pattern_list>(),
32usize,
concat!("Size of: ", stringify!(pattern_list))
);
assert_eq!(
::std::mem::align_of::<pattern_list>(),
8usize,
concat!("Alignment of ", stringify!(pattern_list))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pattern_list),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).patterns) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(pattern_list),
"::",
stringify!(patterns)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).action) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(pattern_list),
"::",
stringify!(action)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(pattern_list),
"::",
stringify!(flags)
)
);
}
pub type PATTERN_LIST = pattern_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct case_com {
pub flags: ::std::os::raw::c_int,
pub line: ::std::os::raw::c_int,
pub word: *mut WordDesc,
pub clauses: *mut PATTERN_LIST,
}
#[test]
fn bindgen_test_layout_case_com() {
const UNINIT: ::std::mem::MaybeUninit<case_com> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<case_com>(),
24usize,
concat!("Size of: ", stringify!(case_com))
);
assert_eq!(
::std::mem::align_of::<case_com>(),
8usize,
concat!("Alignment of ", stringify!(case_com))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(case_com),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(case_com),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).word) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(case_com),
"::",
stringify!(word)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).clauses) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(case_com),
"::",
stringify!(clauses)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct for_com {
pub flags: ::std::os::raw::c_int,
pub line: ::std::os::raw::c_int,
pub name: *mut WordDesc,
pub map_list: *mut WordList,
pub action: *mut COMMAND,
}
#[test]
fn bindgen_test_layout_for_com() {
const UNINIT: ::std::mem::MaybeUninit<for_com> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<for_com>(),
32usize,
concat!("Size of: ", stringify!(for_com))
);
assert_eq!(
::std::mem::align_of::<for_com>(),
8usize,
concat!("Alignment of ", stringify!(for_com))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(for_com),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(for_com),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(for_com),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).map_list) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(for_com),
"::",
stringify!(map_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).action) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(for_com),
"::",
stringify!(action)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct arith_for_com {
pub flags: ::std::os::raw::c_int,
pub line: ::std::os::raw::c_int,
pub init: *mut WordList,
pub test: *mut WordList,
pub step: *mut WordList,
pub action: *mut COMMAND,
}
#[test]
fn bindgen_test_layout_arith_for_com() {
const UNINIT: ::std::mem::MaybeUninit<arith_for_com> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<arith_for_com>(),
40usize,
concat!("Size of: ", stringify!(arith_for_com))
);
assert_eq!(
::std::mem::align_of::<arith_for_com>(),
8usize,
concat!("Alignment of ", stringify!(arith_for_com))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(arith_for_com),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(arith_for_com),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).init) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(arith_for_com),
"::",
stringify!(init)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).test) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(arith_for_com),
"::",
stringify!(test)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).step) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(arith_for_com),
"::",
stringify!(step)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).action) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(arith_for_com),
"::",
stringify!(action)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct select_com {
pub flags: ::std::os::raw::c_int,
pub line: ::std::os::raw::c_int,
pub name: *mut WordDesc,
pub map_list: *mut WordList,
pub action: *mut COMMAND,
}
#[test]
fn bindgen_test_layout_select_com() {
const UNINIT: ::std::mem::MaybeUninit<select_com> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<select_com>(),
32usize,
concat!("Size of: ", stringify!(select_com))
);
assert_eq!(
::std::mem::align_of::<select_com>(),
8usize,
concat!("Alignment of ", stringify!(select_com))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(select_com),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(select_com),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(select_com),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).map_list) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(select_com),
"::",
stringify!(map_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).action) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(select_com),
"::",
stringify!(action)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct if_com {
pub flags: ::std::os::raw::c_int,
pub test: *mut COMMAND,
pub true_case: *mut COMMAND,
pub false_case: *mut COMMAND,
}
#[test]
fn bindgen_test_layout_if_com() {
const UNINIT: ::std::mem::MaybeUninit<if_com> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<if_com>(),
32usize,
concat!("Size of: ", stringify!(if_com))
);
assert_eq!(
::std::mem::align_of::<if_com>(),
8usize,
concat!("Alignment of ", stringify!(if_com))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(if_com),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).test) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(if_com),
"::",
stringify!(test)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).true_case) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(if_com),
"::",
stringify!(true_case)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).false_case) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(if_com),
"::",
stringify!(false_case)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct while_com {
pub flags: ::std::os::raw::c_int,
pub test: *mut COMMAND,
pub action: *mut COMMAND,
}
#[test]
fn bindgen_test_layout_while_com() {
const UNINIT: ::std::mem::MaybeUninit<while_com> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<while_com>(),
24usize,
concat!("Size of: ", stringify!(while_com))
);
assert_eq!(
::std::mem::align_of::<while_com>(),
8usize,
concat!("Alignment of ", stringify!(while_com))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(while_com),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).test) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(while_com),
"::",
stringify!(test)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).action) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(while_com),
"::",
stringify!(action)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct arith_com {
pub flags: ::std::os::raw::c_int,
pub line: ::std::os::raw::c_int,
pub exp: *mut WordList,
}
#[test]
fn bindgen_test_layout_arith_com() {
const UNINIT: ::std::mem::MaybeUninit<arith_com> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<arith_com>(),
16usize,
concat!("Size of: ", stringify!(arith_com))
);
assert_eq!(
::std::mem::align_of::<arith_com>(),
8usize,
concat!("Alignment of ", stringify!(arith_com))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(arith_com),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(arith_com),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).exp) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(arith_com),
"::",
stringify!(exp)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cond_com {
pub flags: ::std::os::raw::c_int,
pub line: ::std::os::raw::c_int,
pub type_: ::std::os::raw::c_int,
pub op: *mut WordDesc,
pub left: *mut cond_com,
pub right: *mut cond_com,
}
#[test]
fn bindgen_test_layout_cond_com() {
const UNINIT: ::std::mem::MaybeUninit<cond_com> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<cond_com>(),
40usize,
concat!("Size of: ", stringify!(cond_com))
);
assert_eq!(
::std::mem::align_of::<cond_com>(),
8usize,
concat!("Alignment of ", stringify!(cond_com))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cond_com),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(cond_com),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cond_com),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).op) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(cond_com),
"::",
stringify!(op)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).left) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(cond_com),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).right) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(cond_com),
"::",
stringify!(right)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct simple_com {
pub flags: ::std::os::raw::c_int,
pub line: ::std::os::raw::c_int,
pub words: *mut WordList,
pub redirects: *mut REDIRECT,
}
#[test]
fn bindgen_test_layout_simple_com() {
const UNINIT: ::std::mem::MaybeUninit<simple_com> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<simple_com>(),
24usize,
concat!("Size of: ", stringify!(simple_com))
);
assert_eq!(
::std::mem::align_of::<simple_com>(),
8usize,
concat!("Alignment of ", stringify!(simple_com))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(simple_com),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(simple_com),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).words) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(simple_com),
"::",
stringify!(words)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).redirects) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(simple_com),
"::",
stringify!(redirects)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct function_def {
pub flags: ::std::os::raw::c_int,
pub line: ::std::os::raw::c_int,
pub name: *mut WordDesc,
pub command: *mut COMMAND,
pub source_file: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_function_def() {
const UNINIT: ::std::mem::MaybeUninit<function_def> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<function_def>(),
32usize,
concat!("Size of: ", stringify!(function_def))
);
assert_eq!(
::std::mem::align_of::<function_def>(),
8usize,
concat!("Alignment of ", stringify!(function_def))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(function_def),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(function_def),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(function_def),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).command) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(function_def),
"::",
stringify!(command)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).source_file) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(function_def),
"::",
stringify!(source_file)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct group_com {
pub ignore: ::std::os::raw::c_int,
pub command: *mut COMMAND,
}
#[test]
fn bindgen_test_layout_group_com() {
const UNINIT: ::std::mem::MaybeUninit<group_com> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<group_com>(),
16usize,
concat!("Size of: ", stringify!(group_com))
);
assert_eq!(
::std::mem::align_of::<group_com>(),
8usize,
concat!("Alignment of ", stringify!(group_com))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(group_com),
"::",
stringify!(ignore)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).command) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(group_com),
"::",
stringify!(command)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct subshell_com {
pub flags: ::std::os::raw::c_int,
pub line: ::std::os::raw::c_int,
pub command: *mut COMMAND,
}
#[test]
fn bindgen_test_layout_subshell_com() {
const UNINIT: ::std::mem::MaybeUninit<subshell_com> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<subshell_com>(),
16usize,
concat!("Size of: ", stringify!(subshell_com))
);
assert_eq!(
::std::mem::align_of::<subshell_com>(),
8usize,
concat!("Alignment of ", stringify!(subshell_com))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(subshell_com),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(subshell_com),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).command) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(subshell_com),
"::",
stringify!(command)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct coproc_com {
pub flags: ::std::os::raw::c_int,
pub name: *mut ::std::os::raw::c_char,
pub command: *mut COMMAND,
}
#[test]
fn bindgen_test_layout_coproc_com() {
const UNINIT: ::std::mem::MaybeUninit<coproc_com> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<coproc_com>(),
24usize,
concat!("Size of: ", stringify!(coproc_com))
);
assert_eq!(
::std::mem::align_of::<coproc_com>(),
8usize,
concat!("Alignment of ", stringify!(coproc_com))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(coproc_com),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(coproc_com),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).command) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(coproc_com),
"::",
stringify!(command)
)
);
}
extern "C" {
#[link_name = "\u{1}global_command"]
pub static mut GLOBAL_COMMAND: *mut COMMAND;
}
extern "C" {
pub fn copy_command(arg1: *mut COMMAND) -> *mut COMMAND;
}
pub type intmax_t = __intmax_t;
extern "C" {
pub fn xfree(arg1: *mut ::std::os::raw::c_void);
}
pub type sh_builtin_func_t =
::std::option::Option<unsafe extern "C" fn(arg1: *mut WordList) -> ::std::os::raw::c_int>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bucket_contents {
pub next: *mut bucket_contents,
pub key: *mut ::std::os::raw::c_char,
pub data: *mut ::std::os::raw::c_void,
pub khash: ::std::os::raw::c_uint,
pub times_found: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_bucket_contents() {
const UNINIT: ::std::mem::MaybeUninit<bucket_contents> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<bucket_contents>(),
32usize,
concat!("Size of: ", stringify!(bucket_contents))
);
assert_eq!(
::std::mem::align_of::<bucket_contents>(),
8usize,
concat!("Alignment of ", stringify!(bucket_contents))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(bucket_contents),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(bucket_contents),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(bucket_contents),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).khash) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(bucket_contents),
"::",
stringify!(khash)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).times_found) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(bucket_contents),
"::",
stringify!(times_found)
)
);
}
pub type BUCKET_CONTENTS = bucket_contents;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct hash_table {
pub bucket_array: *mut *mut BUCKET_CONTENTS,
pub nbuckets: ::std::os::raw::c_int,
pub nentries: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_hash_table() {
const UNINIT: ::std::mem::MaybeUninit<hash_table> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<hash_table>(),
16usize,
concat!("Size of: ", stringify!(hash_table))
);
assert_eq!(
::std::mem::align_of::<hash_table>(),
8usize,
concat!("Alignment of ", stringify!(hash_table))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bucket_array) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(hash_table),
"::",
stringify!(bucket_array)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nbuckets) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(hash_table),
"::",
stringify!(nbuckets)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nentries) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(hash_table),
"::",
stringify!(nentries)
)
);
}
pub type HASH_TABLE = hash_table;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Builtin {
pub name: *mut ::std::os::raw::c_char,
pub function: sh_builtin_func_t,
pub flags: ::std::os::raw::c_int,
pub long_doc: *const *mut ::std::os::raw::c_char,
pub short_doc: *const ::std::os::raw::c_char,
pub handle: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_Builtin() {
const UNINIT: ::std::mem::MaybeUninit<Builtin> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<Builtin>(),
48usize,
concat!("Size of: ", stringify!(Builtin))
);
assert_eq!(
::std::mem::align_of::<Builtin>(),
8usize,
concat!("Alignment of ", stringify!(Builtin))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Builtin),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).function) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(Builtin),
"::",
stringify!(function)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(Builtin),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).long_doc) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(Builtin),
"::",
stringify!(long_doc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).short_doc) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(Builtin),
"::",
stringify!(short_doc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(Builtin),
"::",
stringify!(handle)
)
);
}
extern "C" {
#[link_name = "\u{1}num_shell_builtins"]
pub static mut NUM_SHELL_BUILTINS: ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}shell_builtins"]
pub static mut SHELL_BUILTINS: *mut Builtin;
}
extern "C" {
pub static mut SHM_BUF: *mut ::std::os::raw::c_void;
}
pub type arrayind_t = intmax_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct array {
pub max_index: arrayind_t,
pub num_elements: arrayind_t,
pub head: *mut array_element,
pub lastref: *mut array_element,
}
#[test]
fn bindgen_test_layout_array() {
const UNINIT: ::std::mem::MaybeUninit<array> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<array>(),
32usize,
concat!("Size of: ", stringify!(array))
);
assert_eq!(
::std::mem::align_of::<array>(),
8usize,
concat!("Alignment of ", stringify!(array))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_index) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(array),
"::",
stringify!(max_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_elements) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(array),
"::",
stringify!(num_elements)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(array),
"::",
stringify!(head)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lastref) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(array),
"::",
stringify!(lastref)
)
);
}
pub type Array = array;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct array_element {
pub ind: arrayind_t,
pub value: *mut ::std::os::raw::c_char,
pub next: *mut array_element,
pub prev: *mut array_element,
}
#[test]
fn bindgen_test_layout_array_element() {
const UNINIT: ::std::mem::MaybeUninit<array_element> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<array_element>(),
32usize,
concat!("Size of: ", stringify!(array_element))
);
assert_eq!(
::std::mem::align_of::<array_element>(),
8usize,
concat!("Alignment of ", stringify!(array_element))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ind) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(array_element),
"::",
stringify!(ind)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(array_element),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(array_element),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(array_element),
"::",
stringify!(prev)
)
);
}
extern "C" {
pub fn array_to_argv(
arg1: *mut Array,
arg2: *mut ::std::os::raw::c_int,
) -> *mut *mut ::std::os::raw::c_char;
}
pub type sh_var_value_func_t =
::std::option::Option<unsafe extern "C" fn(arg1: *mut variable) -> *mut variable>;
pub type sh_var_assign_func_t = ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut variable,
arg2: *mut ::std::os::raw::c_char,
arg3: arrayind_t,
arg4: *mut ::std::os::raw::c_char,
) -> *mut variable,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct variable {
pub name: *mut ::std::os::raw::c_char,
pub value: *mut ::std::os::raw::c_char,
pub exportstr: *mut ::std::os::raw::c_char,
pub dynamic_value: sh_var_value_func_t,
pub assign_func: sh_var_assign_func_t,
pub attributes: ::std::os::raw::c_int,
pub context: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_variable() {
const UNINIT: ::std::mem::MaybeUninit<variable> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<variable>(),
48usize,
concat!("Size of: ", stringify!(variable))
);
assert_eq!(
::std::mem::align_of::<variable>(),
8usize,
concat!("Alignment of ", stringify!(variable))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(variable),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(variable),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).exportstr) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(variable),
"::",
stringify!(exportstr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dynamic_value) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(variable),
"::",
stringify!(dynamic_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).assign_func) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(variable),
"::",
stringify!(assign_func)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attributes) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(variable),
"::",
stringify!(attributes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(variable),
"::",
stringify!(context)
)
);
}
pub type ShellVar = variable;
extern "C" {
#[link_name = "\u{1}temporary_env"]
pub static mut TEMPORARY_ENV: *mut HASH_TABLE;
}
extern "C" {
pub fn find_function(arg1: *const ::std::os::raw::c_char) -> *mut ShellVar;
}
extern "C" {
pub fn find_variable(arg1: *const ::std::os::raw::c_char) -> *mut ShellVar;
}
extern "C" {
pub fn bind_variable(
arg1: *const ::std::os::raw::c_char,
arg2: *mut ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
) -> *mut ShellVar;
}
extern "C" {
pub fn bind_global_variable(
arg1: *const ::std::os::raw::c_char,
arg2: *mut ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
) -> *mut ShellVar;
}
extern "C" {
pub fn all_shell_variables() -> *mut *mut ShellVar;
}
extern "C" {
pub fn all_shell_functions() -> *mut *mut ShellVar;
}
extern "C" {
pub fn all_visible_variables() -> *mut *mut ShellVar;
}
extern "C" {
pub fn all_visible_functions() -> *mut *mut ShellVar;
}
extern "C" {
pub fn all_exported_variables() -> *mut *mut ShellVar;
}
extern "C" {
pub fn local_exported_variables() -> *mut *mut ShellVar;
}
extern "C" {
pub fn all_local_variables(arg1: ::std::os::raw::c_int) -> *mut *mut ShellVar;
}
extern "C" {
pub fn all_array_variables() -> *mut *mut ShellVar;
}
extern "C" {
pub fn all_variables_matching_prefix(
arg1: *const ::std::os::raw::c_char,
) -> *mut *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn get_variable_value(arg1: *mut ShellVar) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn get_string_value(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn unbind_variable(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn check_unbind_variable(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn push_context(
arg1: *mut ::std::os::raw::c_char,
arg2: ::std::os::raw::c_int,
arg3: *mut HASH_TABLE,
);
}
extern "C" {
pub fn pop_context();
}
extern "C" {
pub fn dispose_command(arg1: *mut COMMAND);
}
extern "C" {
pub fn dispose_words(arg1: *mut WordList);
}
extern "C" {
pub fn list_string(
arg1: *mut ::std::os::raw::c_char,
arg2: *mut ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
) -> *mut WordList;
}
extern "C" {
pub fn expand_string_to_string(
arg1: *mut ::std::os::raw::c_char,
arg2: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}ifs_value"]
pub static mut IFS: *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn parse_command() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strvec_dispose(arg1: *mut *mut ::std::os::raw::c_char);
}
extern "C" {
pub fn strvec_to_word_list(
arg1: *mut *mut ::std::os::raw::c_char,
arg2: ::std::os::raw::c_int,
arg3: ::std::os::raw::c_int,
) -> *mut WordList;
}
extern "C" {
pub static mut shell_name: *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}patch_level"]
pub static mut PATCH_LEVEL: ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}dist_version"]
pub static mut DIST_VERSION: *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn bash_main(
argc: ::std::os::raw::c_int,
argv: *mut *mut ::std::os::raw::c_char,
env: *mut *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
pub type scallop_cb =
::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_char)>;
extern "C" {
pub fn lib_init(
arg1: *mut ::std::os::raw::c_char,
arg2: *mut ::std::os::raw::c_void,
arg3: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn lib_error_handlers(error_cb: scallop_cb, warning_cb: scallop_cb);
}
extern "C" {
pub fn lib_reset();
}
extern "C" {
pub fn scallop_toggle_restricted(arg1: ::std::os::raw::c_int);
}
extern "C" {
pub fn register_builtins(arg1: *mut *mut Builtin, arg2: usize) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn scallop_source_file(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn scallop_evalstring(
arg1: *const ::std::os::raw::c_char,
arg2: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn builtin_address_internal(
arg1: *mut ::std::os::raw::c_char,
arg2: ::std::os::raw::c_int,
) -> *mut Builtin;
}
extern "C" {
#[link_name = "\u{1}get_minus_o_opts"]
pub fn get_set_options() -> *mut *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn get_shopt_options() -> *mut *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}executing_builtin"]
pub static mut BUILTIN_LEVEL: ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}subshell_level"]
pub static mut SUBSHELL_LEVEL: ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}this_command_name"]
pub static mut CURRENT_COMMAND: *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn executing_line_number() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn scallop_execute_command(arg1: *mut COMMAND) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn scallop_execute_shell_function(
arg1: *mut ShellVar,
arg2: *mut WordList,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}shell_pgrp"]
pub static mut SHELL_PID: pid_t;
}
extern "C" {
pub fn set_sigchld_handler();
}
extern "C" {
pub fn with_input_from_string(
arg1: *mut ::std::os::raw::c_char,
arg2: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn push_stream(arg1: ::std::os::raw::c_int);
}
extern "C" {
pub fn pop_stream();
}
extern "C" {
#[link_name = "\u{1}restricted"]
pub static mut RESTRICTED: ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}restricted_shell"]
pub static mut RESTRICTED_SHELL: ::std::os::raw::c_int;
}