lua51 0.1.6

Lua 5.1.5 bindings for Rust.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

use libc::*;

use crate::ffi::lua::*;

#[repr(C)]
#[derive(Copy, Clone)]
pub union UserAlignment {
	pub u: c_double,
	pub s: *mut c_void,
	pub l: c_long,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GCObject {}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GCHeader {
	pub next: *mut GCObject,
	pub tt: u8,
	pub marked: u8,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union Value {
	pub gc: *mut GCObject,
	pub p: *mut c_void,
	pub n: lua_Number,
	pub b: i32,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct TValue {
	pub value: Value,
	pub tt: i32,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct __TString {
	pub common_header: GCHeader,
	pub reserved: u8,
	pub hash: u32,
	publen: usize,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union TString {
	pub dummy: UserAlignment,
	pub tsv: __TString,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct Node {
	pub i_val: TValue,
	pub i_key: TKey,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct __TKey {
	pub value: Value,
	pub tt: i32,
	pub next: *mut Node,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union TKey {
	pub nk: __TKey,
	pub tvk: TValue,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct Table {
	pub common_header: GCHeader,
	pub flags: u8,
	pub lsizenode: u8,
	pub metatable: *mut Table,
	pub array: *mut TValue,
	pub node: *mut Node,
	pub lastfree: *mut Node,
	pub gclist: *mut GCObject,
	pub sizearray: i32,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct __UpValDoubleLinkedList {
	pub prev: *mut UpVal,
	pub next: *mut UpVal,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union __UpVal {
	pub value: TValue,
	pub l: __UpValDoubleLinkedList,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct UpVal {
	pub common_header: GCHeader,
	pub v: *mut TValue,
	pub u: __UpVal,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct LocVar {
	pub varname: *mut TString,
	pub startpc: i32,
	pub endpc: i32,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct Proto {
	pub common_header: GCHeader,
	pub k: *mut TValue,
	pub code: *mut u32,
	pub p: *mut *mut Proto,
	pub lineinfo: *mut i32,
	pub locvars: *mut LocVar,
	pub upvalues: *mut *mut TString,
	pub source: *mut TString,
	pub sizeupvalues: i32,
	pub sizek: i32,
	pub sizecode: i32,
	pub sizelineinfo: i32,
	pub sizep: i32,
	pub sizelocvars: i32,
	pub linedefined: i32,
	pub lastlinedefined: i32,
	pub gclist: *mut GCObject,
	pub nups: u8,
	pub numparams: u8,
	pub is_vararg: u8,
	pub maxstacksize: u8,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct ClosureHeader {
	pub common_header: GCHeader,
	pub isC: u8,
	pub nupvalues: u8,
	pub gclist: *mut GCObject,
	pub env: *mut Table,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct LClosure {
	pub closure_header: ClosureHeader,
	pub p: *mut Proto,
	pub upvals: *mut [UpVal; 1],
}