Coverage for wasmtime/bindgen/generated/__init__.py: 49%

1from .imports import RootImports 

2from .intrinsics import _clamp, _decode_utf8, _encode_utf8, _list_canon_lift, _list_canon_lower, _load, _store 

3from .types import Err, Ok, Result 

4import ctypes 

5import importlib_resources 

6import pathlib 

7from typing import List, Tuple, cast 

8import wasmtime 

9 

10class Root: 

11 

12 def __init__(self, store: wasmtime.Store, import_object: RootImports) -> None: 

13 file = importlib_resources.files() / ('root.core2.wasm') 

14 if isinstance(file, pathlib.Path): 

15 module = wasmtime.Module.from_file(store.engine, file) 

16 else: 

17 module = wasmtime.Module(store.engine, file.read_bytes()) 

18 instance0 = wasmtime.Instance(store, module, []).exports(store) 

19 file = importlib_resources.files() / ('root.core0.wasm') 

20 if isinstance(file, pathlib.Path): 

21 module = wasmtime.Module.from_file(store.engine, file) 

22 else: 

23 module = wasmtime.Module(store.engine, file.read_bytes()) 

24 instance1 = wasmtime.Instance(store, module, [ 

25 instance0["11"], 

26 instance0["12"], 

27 instance0["13"], 

28 instance0["14"], 

29 instance0["15"], 

30 ]).exports(store) 

31 def lowering0_callee(caller: wasmtime.Caller, arg0: int) -> None: 

32 import_object.types.drop_descriptor(arg0 & 0xffffffff) 

33 lowering0_ty = wasmtime.FuncType([wasmtime.ValType.i32(), ], []) 

34 trampoline0 = wasmtime.Func(store, lowering0_ty, lowering0_callee, access_caller = True) 

35 def lowering1_callee(caller: wasmtime.Caller) -> int: 

36 ret = import_object.stdin.get_stdin() 

37 return _clamp(ret, 0, 4294967295) 

38 lowering1_ty = wasmtime.FuncType([], [wasmtime.ValType.i32(), ]) 

39 trampoline1 = wasmtime.Func(store, lowering1_ty, lowering1_callee, access_caller = True) 

40 def lowering2_callee(caller: wasmtime.Caller) -> int: 

41 ret = import_object.stdout.get_stdout() 

42 return _clamp(ret, 0, 4294967295) 

43 lowering2_ty = wasmtime.FuncType([], [wasmtime.ValType.i32(), ]) 

44 trampoline2 = wasmtime.Func(store, lowering2_ty, lowering2_callee, access_caller = True) 

45 def lowering3_callee(caller: wasmtime.Caller) -> int: 

46 ret = import_object.stderr.get_stderr() 

47 return _clamp(ret, 0, 4294967295) 

48 lowering3_ty = wasmtime.FuncType([], [wasmtime.ValType.i32(), ]) 

49 trampoline3 = wasmtime.Func(store, lowering3_ty, lowering3_callee, access_caller = True) 

50 def lowering4_callee(caller: wasmtime.Caller, arg0: int) -> None: 

51 import_object.terminal_output.drop_terminal_output(arg0 & 0xffffffff) 

52 lowering4_ty = wasmtime.FuncType([wasmtime.ValType.i32(), ], []) 

53 trampoline4 = wasmtime.Func(store, lowering4_ty, lowering4_callee, access_caller = True) 

54 def lowering5_callee(caller: wasmtime.Caller, arg0: int) -> None: 

55 import_object.streams.drop_input_stream(arg0 & 0xffffffff) 

56 lowering5_ty = wasmtime.FuncType([wasmtime.ValType.i32(), ], []) 

57 trampoline5 = wasmtime.Func(store, lowering5_ty, lowering5_callee, access_caller = True) 

58 def lowering6_callee(caller: wasmtime.Caller, arg0: int) -> None: 

59 import_object.streams.drop_output_stream(arg0 & 0xffffffff) 

60 lowering6_ty = wasmtime.FuncType([wasmtime.ValType.i32(), ], []) 

61 trampoline6 = wasmtime.Func(store, lowering6_ty, lowering6_callee, access_caller = True) 

62 def lowering7_callee(caller: wasmtime.Caller, arg0: int) -> None: 

63 import_object.terminal_input.drop_terminal_input(arg0 & 0xffffffff) 

64 lowering7_ty = wasmtime.FuncType([wasmtime.ValType.i32(), ], []) 

65 trampoline7 = wasmtime.Func(store, lowering7_ty, lowering7_callee, access_caller = True) 

66 def lowering8_callee(caller: wasmtime.Caller, arg0: int) -> None: 

67 expected: Result[None, None] 

68 if arg0 == 0: 

69 expected = Ok(None) 

70 elif arg0 == 1: 

71 expected = Err(None) 

72 else: 

73 raise TypeError("invalid variant discriminant for expected") 

74 import_object.exit.exit(expected) 

75 lowering8_ty = wasmtime.FuncType([wasmtime.ValType.i32(), ], []) 

76 trampoline8 = wasmtime.Func(store, lowering8_ty, lowering8_callee, access_caller = True) 

77 file = importlib_resources.files() / ('root.core1.wasm') 

78 if isinstance(file, pathlib.Path): 

79 module = wasmtime.Module.from_file(store.engine, file) 

80 else: 

81 module = wasmtime.Module(store.engine, file.read_bytes()) 

82 instance2 = wasmtime.Instance(store, module, [ 

83 instance1["memory"], 

84 instance0["0"], 

85 instance0["3"], 

86 instance0["4"], 

87 instance1["cabi_realloc"], 

88 instance0["5"], 

89 instance0["1"], 

90 instance0["2"], 

91 trampoline0, 

92 instance0["6"], 

93 instance0["7"], 

94 instance0["8"], 

95 trampoline1, 

96 trampoline2, 

97 trampoline3, 

98 trampoline4, 

99 trampoline5, 

100 trampoline6, 

101 trampoline7, 

102 instance0["9"], 

103 instance0["10"], 

104 trampoline8, 

105 ]).exports(store) 

106 def lowering9_callee(caller: wasmtime.Caller, arg0: int) -> None: 

107 ret = import_object.preopens.get_directories() 

108 vec = ret 

109 len3 = len(vec) 

110 result = self._realloc0(caller, 0, 0, 4, len3 * 12) 

111 assert(isinstance(result, int)) 

112 for i4 in range(0, len3): 

113 e = vec[i4] 

114 base0 = result + i4 * 12 

115 (tuplei,tuplei1,) = e 

116 _store(ctypes.c_uint32, self._core_memory0, caller, base0, 0, _clamp(tuplei, 0, 4294967295)) 

117 ptr, len2 = _encode_utf8(tuplei1, self._realloc0, self._core_memory0, caller) 

118 _store(ctypes.c_uint32, self._core_memory0, caller, base0, 8, len2) 

119 _store(ctypes.c_uint32, self._core_memory0, caller, base0, 4, ptr) 

120 _store(ctypes.c_uint32, self._core_memory0, caller, arg0, 4, len3) 

121 _store(ctypes.c_uint32, self._core_memory0, caller, arg0, 0, result) 

122 lowering9_ty = wasmtime.FuncType([wasmtime.ValType.i32(), ], []) 

123 trampoline9 = wasmtime.Func(store, lowering9_ty, lowering9_callee, access_caller = True) 

124 core_memory0 = instance1["memory"] 

125 assert(isinstance(core_memory0, wasmtime.Memory)) 

126 self._core_memory0 = core_memory0 

127 realloc0 = instance2["cabi_import_realloc"] 

128 assert(isinstance(realloc0, wasmtime.Func)) 

129 self._realloc0 = realloc0 

130 def lowering10_callee(caller: wasmtime.Caller, arg0: int, arg1: int, arg2: int) -> None: 

131 ret = import_object.types.write_via_stream(arg0 & 0xffffffff, arg1 & 0xffffffffffffffff) 

132 if isinstance(ret, Ok): 

133 payload = ret.value 

134 _store(ctypes.c_uint8, self._core_memory0, caller, arg2, 0, 0) 

135 _store(ctypes.c_uint32, self._core_memory0, caller, arg2, 4, _clamp(payload, 0, 4294967295)) 

136 elif isinstance(ret, Err): 

137 payload0 = ret.value 

138 _store(ctypes.c_uint8, self._core_memory0, caller, arg2, 0, 1) 

139 _store(ctypes.c_uint8, self._core_memory0, caller, arg2, 4, (payload0).value) 

140 else: 

141 raise TypeError("invalid variant specified for expected") 

142 lowering10_ty = wasmtime.FuncType([wasmtime.ValType.i32(), wasmtime.ValType.i64(), wasmtime.ValType.i32(), ], []) 

143 trampoline10 = wasmtime.Func(store, lowering10_ty, lowering10_callee, access_caller = True) 

144 def lowering11_callee(caller: wasmtime.Caller, arg0: int, arg1: int) -> None: 

145 ret = import_object.types.append_via_stream(arg0 & 0xffffffff) 

146 if isinstance(ret, Ok): 

147 payload = ret.value 

148 _store(ctypes.c_uint8, self._core_memory0, caller, arg1, 0, 0) 

149 _store(ctypes.c_uint32, self._core_memory0, caller, arg1, 4, _clamp(payload, 0, 4294967295)) 

150 elif isinstance(ret, Err): 

151 payload0 = ret.value 

152 _store(ctypes.c_uint8, self._core_memory0, caller, arg1, 0, 1) 

153 _store(ctypes.c_uint8, self._core_memory0, caller, arg1, 4, (payload0).value) 

154 else: 

155 raise TypeError("invalid variant specified for expected") 

156 lowering11_ty = wasmtime.FuncType([wasmtime.ValType.i32(), wasmtime.ValType.i32(), ], []) 

157 trampoline11 = wasmtime.Func(store, lowering11_ty, lowering11_callee, access_caller = True) 

158 def lowering12_callee(caller: wasmtime.Caller, arg0: int, arg1: int) -> None: 

159 ret = import_object.types.get_type(arg0 & 0xffffffff) 

160 if isinstance(ret, Ok): 

161 payload = ret.value 

162 _store(ctypes.c_uint8, self._core_memory0, caller, arg1, 0, 0) 

163 _store(ctypes.c_uint8, self._core_memory0, caller, arg1, 1, (payload).value) 

164 elif isinstance(ret, Err): 

165 payload0 = ret.value 

166 _store(ctypes.c_uint8, self._core_memory0, caller, arg1, 0, 1) 

167 _store(ctypes.c_uint8, self._core_memory0, caller, arg1, 1, (payload0).value) 

168 else: 

169 raise TypeError("invalid variant specified for expected") 

170 lowering12_ty = wasmtime.FuncType([wasmtime.ValType.i32(), wasmtime.ValType.i32(), ], []) 

171 trampoline12 = wasmtime.Func(store, lowering12_ty, lowering12_callee, access_caller = True) 

172 def lowering13_callee(caller: wasmtime.Caller, arg0: int, arg1: int) -> None: 

173 ret = import_object.random.get_random_bytes(arg0 & 0xffffffffffffffff) 

174 ptr, len0 = _list_canon_lower(ret, ctypes.c_uint8, 1, 1, self._realloc0, self._core_memory0, caller) 

175 _store(ctypes.c_uint32, self._core_memory0, caller, arg1, 4, len0) 

176 _store(ctypes.c_uint32, self._core_memory0, caller, arg1, 0, ptr) 

177 lowering13_ty = wasmtime.FuncType([wasmtime.ValType.i64(), wasmtime.ValType.i32(), ], []) 

178 trampoline13 = wasmtime.Func(store, lowering13_ty, lowering13_callee, access_caller = True) 

179 def lowering14_callee(caller: wasmtime.Caller, arg0: int) -> None: 

180 ret = import_object.environment.get_environment() 

181 vec = ret 

182 len5 = len(vec) 

183 result = self._realloc0(caller, 0, 0, 4, len5 * 16) 

184 assert(isinstance(result, int)) 

185 for i6 in range(0, len5): 

186 e = vec[i6] 

187 base0 = result + i6 * 16 

188 (tuplei,tuplei1,) = e 

189 ptr, len2 = _encode_utf8(tuplei, self._realloc0, self._core_memory0, caller) 

190 _store(ctypes.c_uint32, self._core_memory0, caller, base0, 4, len2) 

191 _store(ctypes.c_uint32, self._core_memory0, caller, base0, 0, ptr) 

192 ptr3, len4 = _encode_utf8(tuplei1, self._realloc0, self._core_memory0, caller) 

193 _store(ctypes.c_uint32, self._core_memory0, caller, base0, 12, len4) 

194 _store(ctypes.c_uint32, self._core_memory0, caller, base0, 8, ptr3) 

195 _store(ctypes.c_uint32, self._core_memory0, caller, arg0, 4, len5) 

196 _store(ctypes.c_uint32, self._core_memory0, caller, arg0, 0, result) 

197 lowering14_ty = wasmtime.FuncType([wasmtime.ValType.i32(), ], []) 

198 trampoline14 = wasmtime.Func(store, lowering14_ty, lowering14_callee, access_caller = True) 

199 def lowering15_callee(caller: wasmtime.Caller, arg0: int) -> None: 

200 ret = import_object.terminal_stderr.get_terminal_stderr() 

201 if ret is None: 

202 _store(ctypes.c_uint8, self._core_memory0, caller, arg0, 0, 0) 

203 else: 

204 payload0 = ret 

205 _store(ctypes.c_uint8, self._core_memory0, caller, arg0, 0, 1) 

206 _store(ctypes.c_uint32, self._core_memory0, caller, arg0, 4, _clamp(payload0, 0, 4294967295)) 

207 lowering15_ty = wasmtime.FuncType([wasmtime.ValType.i32(), ], []) 

208 trampoline15 = wasmtime.Func(store, lowering15_ty, lowering15_callee, access_caller = True) 

209 def lowering16_callee(caller: wasmtime.Caller, arg0: int) -> None: 

210 ret = import_object.terminal_stdin.get_terminal_stdin() 

211 if ret is None: 

212 _store(ctypes.c_uint8, self._core_memory0, caller, arg0, 0, 0) 

213 else: 

214 payload0 = ret 

215 _store(ctypes.c_uint8, self._core_memory0, caller, arg0, 0, 1) 

216 _store(ctypes.c_uint32, self._core_memory0, caller, arg0, 4, _clamp(payload0, 0, 4294967295)) 

217 lowering16_ty = wasmtime.FuncType([wasmtime.ValType.i32(), ], []) 

218 trampoline16 = wasmtime.Func(store, lowering16_ty, lowering16_callee, access_caller = True) 

219 def lowering17_callee(caller: wasmtime.Caller, arg0: int) -> None: 

220 ret = import_object.terminal_stdout.get_terminal_stdout() 

221 if ret is None: 

222 _store(ctypes.c_uint8, self._core_memory0, caller, arg0, 0, 0) 

223 else: 

224 payload0 = ret 

225 _store(ctypes.c_uint8, self._core_memory0, caller, arg0, 0, 1) 

226 _store(ctypes.c_uint32, self._core_memory0, caller, arg0, 4, _clamp(payload0, 0, 4294967295)) 

227 lowering17_ty = wasmtime.FuncType([wasmtime.ValType.i32(), ], []) 

228 trampoline17 = wasmtime.Func(store, lowering17_ty, lowering17_callee, access_caller = True) 

229 def lowering18_callee(caller: wasmtime.Caller, arg0: int, arg1: int, arg2: int, arg3: int) -> None: 

230 ptr = arg1 

231 len0 = arg2 

232 list = cast(bytes, _list_canon_lift(ptr, len0, 1, ctypes.c_uint8, self._core_memory0, caller)) 

233 ret = import_object.streams.write(arg0 & 0xffffffff, list) 

234 if isinstance(ret, Ok): 

235 payload = ret.value 

236 _store(ctypes.c_uint8, self._core_memory0, caller, arg3, 0, 0) 

237 (tuplei,tuplei1,) = payload 

238 _store(ctypes.c_uint64, self._core_memory0, caller, arg3, 8, _clamp(tuplei, 0, 18446744073709551615)) 

239 _store(ctypes.c_uint8, self._core_memory0, caller, arg3, 16, (tuplei1).value) 

240 elif isinstance(ret, Err): 

241 payload2 = ret.value 

242 _store(ctypes.c_uint8, self._core_memory0, caller, arg3, 0, 1) 

243 else: 

244 raise TypeError("invalid variant specified for expected") 

245 lowering18_ty = wasmtime.FuncType([wasmtime.ValType.i32(), wasmtime.ValType.i32(), wasmtime.ValType.i32(), wasmtime.ValType.i32(), ], []) 

246 trampoline18 = wasmtime.Func(store, lowering18_ty, lowering18_callee, access_caller = True) 

247 def lowering19_callee(caller: wasmtime.Caller, arg0: int, arg1: int, arg2: int, arg3: int) -> None: 

248 ptr = arg1 

249 len0 = arg2 

250 list = cast(bytes, _list_canon_lift(ptr, len0, 1, ctypes.c_uint8, self._core_memory0, caller)) 

251 ret = import_object.streams.blocking_write(arg0 & 0xffffffff, list) 

252 if isinstance(ret, Ok): 

253 payload = ret.value 

254 _store(ctypes.c_uint8, self._core_memory0, caller, arg3, 0, 0) 

255 (tuplei,tuplei1,) = payload 

256 _store(ctypes.c_uint64, self._core_memory0, caller, arg3, 8, _clamp(tuplei, 0, 18446744073709551615)) 

257 _store(ctypes.c_uint8, self._core_memory0, caller, arg3, 16, (tuplei1).value) 

258 elif isinstance(ret, Err): 

259 payload2 = ret.value 

260 _store(ctypes.c_uint8, self._core_memory0, caller, arg3, 0, 1) 

261 else: 

262 raise TypeError("invalid variant specified for expected") 

263 lowering19_ty = wasmtime.FuncType([wasmtime.ValType.i32(), wasmtime.ValType.i32(), wasmtime.ValType.i32(), wasmtime.ValType.i32(), ], []) 

264 trampoline19 = wasmtime.Func(store, lowering19_ty, lowering19_callee, access_caller = True) 

265 file = importlib_resources.files() / ('root.core3.wasm') 

266 if isinstance(file, pathlib.Path): 

267 module = wasmtime.Module.from_file(store.engine, file) 

268 else: 

269 module = wasmtime.Module(store.engine, file.read_bytes()) 

270 instance3 = wasmtime.Instance(store, module, [ 

271 trampoline9, 

272 trampoline10, 

273 trampoline11, 

274 trampoline12, 

275 trampoline13, 

276 trampoline14, 

277 trampoline15, 

278 trampoline16, 

279 trampoline17, 

280 trampoline18, 

281 trampoline19, 

282 instance2["fd_write"], 

283 instance2["random_get"], 

284 instance2["environ_get"], 

285 instance2["environ_sizes_get"], 

286 instance2["proc_exit"], 

287 instance0["$imports"], 

288 ]).exports(store) 

289 realloc1 = instance1["cabi_realloc"] 

290 assert(isinstance(realloc1, wasmtime.Func)) 

291 self._realloc1 = realloc1 

292 post_return0 = instance1["cabi_post_generate"] 

293 assert(isinstance(post_return0, wasmtime.Func)) 

294 self._post_return0 = post_return0 

295 lift_callee0 = instance1["generate"] 

296 assert(isinstance(lift_callee0, wasmtime.Func)) 

297 self.lift_callee0 = lift_callee0 

298 def generate(self, caller: wasmtime.Store, name: str, wit: bytes) -> Result[List[Tuple[str, bytes]], str]: 

299 ptr, len0 = _encode_utf8(name, self._realloc1, self._core_memory0, caller) 

300 ptr1, len2 = _list_canon_lower(wit, ctypes.c_uint8, 1, 1, self._realloc1, self._core_memory0, caller) 

301 ret = self.lift_callee0(caller, ptr, len0, ptr1, len2) 

302 assert(isinstance(ret, int)) 

303 load = _load(ctypes.c_uint8, self._core_memory0, caller, ret, 0) 

304 expected: Result[List[Tuple[str, bytes]], str] 

305 if load == 0: 

306 load3 = _load(ctypes.c_int32, self._core_memory0, caller, ret, 4) 

307 load4 = _load(ctypes.c_int32, self._core_memory0, caller, ret, 8) 

308 ptr15 = load3 

309 len16 = load4 

310 result: List[Tuple[str, bytes]] = [] 

311 for i17 in range(0, len16): 

312 base5 = ptr15 + i17 * 16 

313 load6 = _load(ctypes.c_int32, self._core_memory0, caller, base5, 0) 

314 load7 = _load(ctypes.c_int32, self._core_memory0, caller, base5, 4) 

315 ptr8 = load6 

316 len9 = load7 

317 list = _decode_utf8(self._core_memory0, caller, ptr8, len9) 

318 load10 = _load(ctypes.c_int32, self._core_memory0, caller, base5, 8) 

319 load11 = _load(ctypes.c_int32, self._core_memory0, caller, base5, 12) 

320 ptr12 = load10 

321 len13 = load11 

322 list14 = cast(bytes, _list_canon_lift(ptr12, len13, 1, ctypes.c_uint8, self._core_memory0, caller)) 

323 result.append((list, list14,)) 

324 expected = Ok(result) 

325 elif load == 1: 

326 load18 = _load(ctypes.c_int32, self._core_memory0, caller, ret, 4) 

327 load19 = _load(ctypes.c_int32, self._core_memory0, caller, ret, 8) 

328 ptr20 = load18 

329 len21 = load19 

330 list22 = _decode_utf8(self._core_memory0, caller, ptr20, len21) 

331 expected = Err(list22) 

332 else: 

333 raise TypeError("invalid variant discriminant for expected") 

334 tmp = expected 

335 self._post_return0(caller, ret) 

336 return tmp