CoCalc -- FunctionWrappers.h

CoCalc provides the best real-time collaborative environment for Jupyter Notebooks, LaTeX documents, and SageMath, scalable from individual users to large groups and classes!

GitHub Repository: hrydgard/ppsspp
Path: blob/master/Core/HLE/FunctionWrappers.h
Views: ¹⁴⁰¹
1
// Copyright (c) 2012- PPSSPP Project.
2

3
// This program is free software: you can redistribute it and/or modify
4
// it under the terms of the GNU General Public License as published by
5
// the Free Software Foundation, version 2.0 or later versions.
6

7
// This program is distributed in the hope that it will be useful,
8
// but WITHOUT ANY WARRANTY; without even the implied warranty of
9
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
// GNU General Public License 2.0 for more details.
11

12
// A copy of the GPL 2.0 should have been included with the program.
13
// If not, see http://www.gnu.org/licenses/
14

15
// Official git repository and contact information can be found at
16
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
17

18
#pragma once
19

20
#include "Common/CommonTypes.h"
21
#include "Core/HLE/HLE.h"
22
#include "Core/MemMap.h"
23

24
// For easy parameter parsing and return value processing.
25

26
// 64bit wrappers
27
// 64bit values are always "aligned" in regs (never start on an odd reg.)
28

29
template<u64 func()> void WrapU64_V() {
30
	u64 retval = func();
31
	RETURN64(retval);
32
}
33

34
template<u64 func(u32)> void WrapU64_U() {
35
	u64 retval = func(PARAM(0));
36
	RETURN64(retval);
37
}
38

39
template<u64 func(int)> void WrapU64_I() {
40
	u64 retval = func(PARAM(0));
41
	RETURN64(retval);
42
}
43

44
template<u64 func(u32, u64)> void WrapU64_UU64() {
45
	u64 retval = func(PARAM(0), PARAM64(2));
46
	RETURN64(retval);
47
}
48

49
template<u64 func(int, u64)> void WrapU64_IU64() {
50
	u64 retval = func(PARAM(0), PARAM64(2));
51
	RETURN64(retval);
52
}
53

54
template<int func(int, u64)> void WrapI_IU64() {
55
	int retval = func(PARAM(0), PARAM64(2));
56
	RETURN(retval);
57
}
58

59
template<int func(u32, u64)> void WrapI_UU64() {
60
	int retval = func(PARAM(0), PARAM64(2));
61
	RETURN(retval);
62
}
63

64
template<u32 func(u32, u64)> void WrapU_UU64() {
65
	u32 retval = func(PARAM(0), PARAM64(2));
66
	RETURN(retval);
67
}
68

69
template<int func(u32, u32, u64)> void WrapI_UUU64() {
70
	int retval = func(PARAM(0), PARAM(1), PARAM64(2));
71
	RETURN(retval);
72
}
73

74
template<u32 func(int, s64, int)> void WrapU_II64I() {
75
	u32 retval = func(PARAM(0), PARAM64(2), PARAM(4));
76
	RETURN(retval);
77
}
78

79
template<u32 func(u32, u64, u32, u32)> void WrapU_UU64UU() {
80
	u32 retval = func(PARAM(0), PARAM64(2), PARAM(4), PARAM(5));
81
	RETURN(retval);
82
}
83

84
template<u32 func(int, u64, u32, u32)> void WrapU_IU64UU() {
85
	u32 retval = func(PARAM(0), PARAM64(2), PARAM(4), PARAM(5));
86
	RETURN(retval);
87
}
88

89
template<int func(int, int, const char*, u64)> void WrapI_IICU64() {
90
	int retval = func(PARAM(0), PARAM(1), Memory::GetCharPointer(PARAM(2)), PARAM64(4));
91
	RETURN(retval);
92
}
93

94
template<s64 func(int, s64, int)> void WrapI64_II64I() {
95
	s64 retval = func(PARAM(0), PARAM64(2), PARAM(4));
96
	RETURN64(retval);
97
}
98

99
//32bit wrappers
100
template<void func()> void WrapV_V() {
101
	func();
102
}
103

104
template<u32 func()> void WrapU_V() {
105
	RETURN(func());
106
}
107

108
template<u32 func(int, void *, int)> void WrapU_IVI() {
109
	u32 retval = func(PARAM(0), Memory::GetPointerWrite(PARAM(1)), PARAM(2));
110
	RETURN(retval);
111
}
112

113
template<int func(const char *, int, int, u32)> void WrapI_CIIU() {
114
	u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3));
115
	RETURN(retval);
116
}
117

118
template<int func(int, const char *, u32, void *, void *, u32, int)> void WrapI_ICUVVUI() {
119
	u32 retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), Memory::GetPointerWrite(PARAM(3)),Memory::GetPointerWrite(PARAM(4)), PARAM(5), PARAM(6) );
120
	RETURN(retval);
121
}
122

123
// Hm, do so many params get passed in registers?
124
template<int func(const char *, int, const char *, int, int, int, int, int)> void WrapI_CICIIIII() {
125
	u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), Memory::GetCharPointer(PARAM(2)),
126
		PARAM(3), PARAM(4), PARAM(5), PARAM(6), PARAM(7));
127
	RETURN(retval);
128
}
129

130
// Hm, do so many params get passed in registers?
131
template<int func(const char *, int, int, int, int, int, int)> void WrapI_CIIIIII() {
132
	u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
133
		PARAM(3), PARAM(4), PARAM(5), PARAM(6));
134
	RETURN(retval);
135
}
136

137
template<int func(int, int, int, const char *)> void WrapI_IIIC() {
138
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), Memory::GetCharPointer(PARAM(3)));
139
	RETURN(retval);
140
}
141

142
// Hm, do so many params get passed in registers?
143
template<int func(int, int, int, int, int, int, u32)> void WrapI_IIIIIIU() {
144
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
145
	RETURN(retval);
146
}
147

148
// Hm, do so many params get passed in registers?
149
template<int func(int, int, int, int, int, int, int, int, u32)> void WrapI_IIIIIIIIU() {
150
	u32 param8 = *(const u32_le *)Memory::GetPointerWrite(currentMIPS->r[29]); //Fixed 9th parameter, thanks to Kingcom
151
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6), PARAM(7), param8);
152
	RETURN(retval);
153
}
154

155
template<u32 func(int, void *)> void WrapU_IV() {
156
	u32 retval = func(PARAM(0), Memory::GetPointerWrite(PARAM(1)));
157
	RETURN(retval);
158
}
159

160
template<float func()> void WrapF_V() {
161
	RETURNF(func());
162
}
163

164
// TODO: Not sure about the floating point parameter passing
165
template<float func(int, float, u32)> void WrapF_IFU() {
166
	RETURNF(func(PARAM(0), PARAMF(0), PARAM(1)));
167
}
168

169
template<u32 func(u32)> void WrapU_U() {
170
	u32 retval = func(PARAM(0));
171
	RETURN(retval);
172
}
173

174
template<u32 func(u32, int)> void WrapU_UI() {
175
	u32 retval = func(PARAM(0), PARAM(1));
176
	RETURN(retval);
177
}
178

179
template<int func(u32)> void WrapI_U() {
180
	int retval = func(PARAM(0));
181
	RETURN(retval);
182
}
183

184
template<int func(u32, int)> void WrapI_UI() {
185
	int retval = func(PARAM(0), PARAM(1));
186
	RETURN(retval);
187
}
188

189
template<int func(u32, int, int, u32)> void WrapI_UIIU() {
190
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
191
	RETURN(retval);
192
}
193

194
template<u32 func(int, u32, int)> void WrapU_IUI() {
195
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
196
	RETURN(retval);
197
}
198

199
template<int func(u32, u32)> void WrapI_UU() {
200
	int retval = func(PARAM(0), PARAM(1));
201
	RETURN(retval);
202
}
203

204
template<int func(u32, float, float)> void WrapI_UFF() {
205
	// Not sure about the float arguments.
206
	int retval = func(PARAM(0), PARAMF(0), PARAMF(1));
207
	RETURN(retval);
208
}
209

210
template<int func(u32, u32, u32)> void WrapI_UUU() {
211
	int retval = func(PARAM(0), PARAM(1), PARAM(2));
212
	RETURN(retval);
213
}
214

215
template<int func(u32, u32, u32, int)> void WrapI_UUUI() {
216
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
217
	RETURN(retval);
218
}
219

220
template<int func(u32, u32, u32, int, int, int,int )> void WrapI_UUUIIII() {
221
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
222
	RETURN(retval);
223
}
224

225
template<int func(u32, u32, u32, u32)> void WrapI_UUUU() {
226
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
227
	RETURN(retval);
228
}
229

230
template<int func(u32, u32, u32, u32, u32)> void WrapI_UUUUU() {
231
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
232
	RETURN(retval);
233
}
234

235
template<int func()> void WrapI_V() {
236
	int retval = func();
237
	RETURN(retval);
238
}
239

240
template<u32 func(int)> void WrapU_I() {
241
	u32 retval = func(PARAM(0));
242
	RETURN(retval);
243
}
244

245
template<u32 func(int, int, u32)> void WrapU_IIU() {
246
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
247
	RETURN(retval);
248
}
249

250
template<int func(int)> void WrapI_I() {
251
	int retval = func(PARAM(0));
252
	RETURN(retval);
253
}
254

255
template<void func(u32)> void WrapV_U() {
256
	func(PARAM(0));
257
}
258

259
template<void func(int)> void WrapV_I() {
260
	func(PARAM(0));
261
}
262

263
template<void func(u32, u32)> void WrapV_UU() {
264
	func(PARAM(0), PARAM(1));
265
}
266

267
template<void func(int, int)> void WrapV_II() {
268
	func(PARAM(0), PARAM(1));
269
}
270

271
template<void func(u32, const char *)> void WrapV_UC() {
272
	func(PARAM(0), Memory::GetCharPointer(PARAM(1)));
273
}
274

275
template<int func(u32, const char *)> void WrapI_UC() {
276
	int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)));
277
	RETURN(retval);
278
}
279

280
template<int func(u32, const char *, int)> void WrapI_UCI() {
281
	int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2));
282
	RETURN(retval);
283
}
284

285
template<u32 func(u32, int , int , int, int, int)> void WrapU_UIIIII() {
286
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
287
	RETURN(retval);
288
}
289

290
template<u32 func(u32, int , int , int, u32)> void WrapU_UIIIU() {
291
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
292
	RETURN(retval);
293
}
294

295
template<u32 func(u32, int , int , int, int, int, int)> void WrapU_UIIIIII() {
296
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
297
	RETURN(retval);
298
}
299

300
template<u32 func(u32, u32)> void WrapU_UU() {
301
	u32 retval = func(PARAM(0), PARAM(1));
302
	RETURN(retval);
303
}
304

305
template<u32 func(u32, u32, int)> void WrapU_UUI() {
306
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
307
	RETURN(retval);
308
}
309

310
template<u32 func(u32, u32, int, int)> void WrapU_UUII() {
311
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
312
	RETURN(retval);
313
}
314

315
template<u32 func(const char *, u32, u32, u32)> void WrapU_CUUU() {
316
	u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3));
317
	RETURN(retval);
318
}
319

320
template<void func(u32, int, u32, int, int)> void WrapV_UIUII() {
321
	func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
322
}
323

324
template<u32 func(u32, int, u32, int, int)> void WrapU_UIUII() {
325
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
326
	RETURN(retval);
327
}
328

329
template<int func(u32, int, u32, int, int)> void WrapI_UIUII() {
330
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
331
	RETURN(retval);
332
}
333

334
template<u32 func(u32, int, u32, int)> void WrapU_UIUI() {
335
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
336
	RETURN(retval);
337
}
338

339
template<int func(u32, int, u32, int)> void WrapI_UIUI() {
340
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
341
	RETURN(retval);
342
}
343

344
template<u32 func(u32, int, u32)> void WrapU_UIU() {
345
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
346
	RETURN(retval);
347
}
348

349
template<u32 func(u32, int, u32, u32)> void WrapU_UIUU() {
350
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
351
	RETURN(retval);
352
}
353

354
template<u32 func(u32, int, int)> void WrapU_UII() {
355
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
356
	RETURN(retval);
357
}
358

359
template<u32 func(u32, int, int, u32)> void WrapU_UIIU() {
360
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
361
	RETURN(retval);
362
}
363

364
template<int func(u32, int, int, u32, u32)> void WrapI_UIIUU() {
365
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
366
	RETURN(retval);
367
}
368

369
template<int func(u32, u32, int, int)> void WrapI_UUII() {
370
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
371
	RETURN(retval);
372
}
373

374
template<int func(u32, u32, int, int, int)> void WrapI_UUIII() {
375
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
376
	RETURN(retval);
377
}
378

379
template<void func(u32, int, int, int)> void WrapV_UIII() {
380
	func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
381
}
382

383
template<void func(u32, int, int, int, int, int)> void WrapV_UIIIII() {
384
	func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
385
}
386

387
template<void func(u32, int, int)> void WrapV_UII() {
388
	func(PARAM(0), PARAM(1), PARAM(2));
389
}
390

391
template<u32 func(int, u32)> void WrapU_IU() {
392
	int retval = func(PARAM(0), PARAM(1));
393
	RETURN(retval);
394
}
395

396
template<int func(int, u32)> void WrapI_IU() {
397
	int retval = func(PARAM(0), PARAM(1));
398
	RETURN(retval);
399
}
400

401
template<int func(u32, u32, int)> void WrapI_UUI() {
402
	int retval = func(PARAM(0), PARAM(1), PARAM(2));
403
	RETURN(retval);
404
}
405

406
template<int func(u32, u32, int, u32)> void WrapI_UUIU() {
407
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
408
	RETURN(retval);
409
}
410

411
template<int func(int, int)> void WrapI_II() {
412
	int retval = func(PARAM(0), PARAM(1));
413
	RETURN(retval);
414
}
415

416
template<int func(int, int, int)> void WrapI_III() {
417
	int retval = func(PARAM(0), PARAM(1), PARAM(2));
418
	RETURN(retval);
419
}
420

421
template<int func(int, u32, int)> void WrapI_IUI() {
422
	int retval = func(PARAM(0), PARAM(1), PARAM(2));
423
	RETURN(retval);
424
}
425

426
template<int func(int, int, int, int)> void WrapI_IIII() {
427
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
428
	RETURN(retval);
429
}
430

431
template<int func(u32, int, int, int)> void WrapI_UIII() {
432
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
433
	RETURN(retval);
434
}
435

436
template<int func(int, int, int, u32, int)> void WrapI_IIIUI() {
437
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
438
	RETURN(retval);
439
}
440

441
template<int func(int, u32, u32, int, int)> void WrapI_IUUII() {
442
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
443
	RETURN(retval);
444
}
445

446
template<int func(int, const char *, int, u32, u32)> void WrapI_ICIUU() {
447
	int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3), PARAM(4));
448
	RETURN(retval);
449
}
450

451
template<int func(int, int, u32)> void WrapI_IIU() {
452
	int retval = func(PARAM(0), PARAM(1), PARAM(2));
453
	RETURN(retval);
454
}
455

456
template<void func(int, u32)> void WrapV_IU() {
457
	func(PARAM(0), PARAM(1));
458
}
459

460
template<void func(u32, int)> void WrapV_UI() {
461
	func(PARAM(0), PARAM(1));
462
}
463

464
template<u32 func(const char *)> void WrapU_C() {
465
	u32 retval = func(Memory::GetCharPointer(PARAM(0)));
466
	RETURN(retval);
467
}
468

469
template<u32 func(const char *, const char *, const char *, u32)> void WrapU_CCCU() {
470
	u32 retval = func(Memory::GetCharPointer(PARAM(0)),
471
			Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)),
472
			PARAM(3));
473
	RETURN(retval);
474
}
475

476
template<int func(const char *)> void WrapI_C() {
477
	int retval = func(Memory::GetCharPointer(PARAM(0)));
478
	RETURN(retval);
479
}
480

481
template<int func(const char *, u32)> void WrapI_CU() {
482
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1));
483
	RETURN(retval);
484
}
485

486
template<int func(const char *, u32, int)> void WrapI_CUI() {
487
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
488
	RETURN(retval);
489
}
490

491
template<int func(int, const char *, int, u32)> void WrapI_ICIU() {
492
	int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3));
493
	RETURN(retval);
494
}
495

496
template<int func(const char *, int, u32)> void WrapI_CIU() {
497
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
498
	RETURN(retval);
499
}
500

501
template<int func(const char *, u32, u32)> void WrapI_CUU() {
502
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
503
	RETURN(retval);
504
}
505

506
template<int func(const char *, u32, u32, u32)> void WrapI_CUUU() {
507
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
508
			PARAM(3));
509
	RETURN(retval);
510
}
511

512
template<int func(const char *, const char*, int, int)> void WrapI_CCII() {
513
	int retval = func(Memory::GetCharPointer(PARAM(0)), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3));
514
	RETURN(retval);
515
}
516

517
template<int func(const char *, u32, u32, int, u32, u32)> void WrapI_CUUIUU() {
518
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
519
			PARAM(3), PARAM(4), PARAM(5));
520
	RETURN(retval);
521
}
522

523
template<int func(const char *, int, int, u32, int, int)> void WrapI_CIIUII() {
524
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
525
		PARAM(3), PARAM(4), PARAM(5));
526
	RETURN(retval);
527
}
528

529
template<int func(const char *, int, int, int, u32, u32, int)> void WrapI_CIIIUUI() {
530
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
531
		PARAM(3), PARAM(4), PARAM(5), PARAM(6));
532
	RETURN(retval);
533
}
534

535
template<int func(const char *, int, u32, u32, u32)> void WrapI_CIUUU() {
536
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
537
			PARAM(3), PARAM(4));
538
	RETURN(retval);
539
}
540

541
template<int func(const char *, u32, u32, u32, u32, u32)> void WrapI_CUUUUU() {
542
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
543
			PARAM(3), PARAM(4), PARAM(5));
544
	RETURN(retval);
545
}
546

547
template<u32 func(const char *, u32)> void WrapU_CU() {
548
	u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1));
549
	RETURN((u32) retval);
550
}
551

552
template<u32 func(u32, const char *)> void WrapU_UC() {
553
	u32 retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)));
554
	RETURN(retval);
555
}
556

557
template<u32 func(const char *, u32, u32)> void WrapU_CUU() {
558
	u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
559
	RETURN((u32) retval);
560
}
561

562
template<u32 func(int, int, int)> void WrapU_III() {
563
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
564
	RETURN(retval);
565
}
566

567
template<u32 func(int, int)> void WrapU_II() {
568
	u32 retval = func(PARAM(0), PARAM(1));
569
	RETURN(retval);
570
}
571

572
template<u32 func(int, int, int, int)> void WrapU_IIII() {
573
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
574
	RETURN(retval);
575
}
576

577
template<u32 func(int, u32, u32)> void WrapU_IUU() {
578
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
579
	RETURN(retval);
580
}
581

582
template<u32 func(int, u32, u32, u32)> void WrapU_IUUU() {
583
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
584
	RETURN(retval);
585
}
586

587
template<u32 func(int, u32, u32, u32, u32)> void WrapU_IUUUU() {
588
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
589
	RETURN(retval);
590
}
591

592
template<u32 func(u32, u32, u32)> void WrapU_UUU() {
593
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
594
	RETURN(retval);
595
}
596

597
template<void func(int, u32, u32)> void WrapV_IUU() {
598
	func(PARAM(0), PARAM(1), PARAM(2));
599
}
600

601
template<void func(int, int, u32)> void WrapV_IIU() {
602
	func(PARAM(0), PARAM(1), PARAM(2));
603
}
604

605
template<void func(u32, int, u32)> void WrapV_UIU() {
606
	func(PARAM(0), PARAM(1), PARAM(2));
607
}
608

609
template<int func(u32, int, u32)> void WrapI_UIU() {
610
	int retval = func(PARAM(0), PARAM(1), PARAM(2));
611
	RETURN(retval);
612
}
613

614
template<void func(int, u32, u32, u32, u32)> void WrapV_IUUUU() {
615
	func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
616
}
617

618
template<void func(u32, u32, u32)> void WrapV_UUU() {
619
	func(PARAM(0), PARAM(1), PARAM(2));
620
}
621

622
template<void func(u32, u32, u32, u32)> void WrapV_UUUU() {
623
	func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
624
}
625

626
template<void func(const char *, u32, int, u32)> void WrapV_CUIU() {
627
	func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3));
628
}
629

630
template<int func(const char *, u32, int, u32)> void WrapI_CUIU() {
631
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3));
632
	RETURN(retval);
633
}
634

635
template<void func(u32, const char *, u32, int, u32)> void WrapV_UCUIU() {
636
	func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3),
637
			PARAM(4));
638
}
639

640
template<int func(u32, const char *, u32, int, u32)> void WrapI_UCUIU() {
641
	int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2),
642
			PARAM(3), PARAM(4));
643
	RETURN(retval);
644
}
645

646
template<void func(const char *, u32, int, int, u32)> void WrapV_CUIIU() {
647
	func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3),
648
			PARAM(4));
649
}
650

651
template<int func(const char *, u32, int, int, u32)> void WrapI_CUIIU() {
652
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
653
			PARAM(3), PARAM(4));
654
	RETURN(retval);
655
}
656

657
template<u32 func(u32, u32, u32, u32)> void WrapU_UUUU() {
658
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
659
	RETURN(retval);
660
}
661

662
template<u32 func(u32, const char *, u32, u32)> void WrapU_UCUU() {
663
	u32 retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3));
664
	RETURN(retval);
665
}
666

667
template<u32 func(u32, u32, u32, int)> void WrapU_UUUI() {
668
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
669
	RETURN(retval);
670
}
671

672
template<u32 func(u32, u32, u32, int, u32)> void WrapU_UUUIU() {
673
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
674
	RETURN(retval);
675
}
676

677
template<u32 func(u32, u32, u32, int, u32, int)> void WrapU_UUUIUI() {
678
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
679
	RETURN(retval);
680
}
681

682
template<u32 func(u32, u32, int, u32)> void WrapU_UUIU() {
683
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
684
	RETURN(retval);
685
}
686

687
template<u32 func(u32, int, int, int)> void WrapU_UIII() {
688
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
689
	RETURN(retval);
690
}
691

692
template<int func(int, u32, u32, u32, u32)> void WrapI_IUUUU() {
693
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
694
	RETURN(retval);
695
}
696

697
template<int func(int, u32, u32, u32, u32, u32)> void WrapI_IUUUUU() {
698
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
699
	RETURN(retval);
700
}
701

702
template<int func(int, u32, int, int)> void WrapI_IUII() {
703
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
704
	RETURN(retval);
705
}
706
template<u32 func(u32, u32, u32, u32, u32)> void WrapU_UUUUU() {
707
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
708
	RETURN(retval);
709
}
710

711
template<void func(u32, u32, u32, u32, u32)> void WrapV_UUUUU() {
712
	func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
713
}
714

715
template<u32 func(const char *, const char *)> void WrapU_CC() {
716
	int retval = func(Memory::GetCharPointer(PARAM(0)),
717
			Memory::GetCharPointer(PARAM(1)));
718
	RETURN(retval);
719
}
720

721
template<void func(const char *, int)> void WrapV_CI() {
722
	func(Memory::GetCharPointer(PARAM(0)), PARAM(1));
723
}
724

725
template<u32 func(const char *, int)> void WrapU_CI() {
726
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1));
727
	RETURN(retval);
728
}
729

730
template<u32 func(const char *, int, int)> void WrapU_CII() {
731
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
732
	RETURN(retval);
733
}
734

735
template<int func(const char *, int, u32, int, u32)> void WrapU_CIUIU() {
736
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
737
			PARAM(3), PARAM(4));
738
	RETURN(retval);
739
}
740

741
template<u32 func(const char *, int, u32, int, u32, int)> void WrapU_CIUIUI() {
742
	u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
743
			PARAM(3), PARAM(4), PARAM(5));
744
	RETURN(retval);
745
}
746

747
template<u32 func(u32, u32, u32, u32, u32, u32)> void WrapU_UUUUUU() {
748
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4),
749
			PARAM(5));
750
	RETURN(retval);
751
}
752

753
template<int func(int, u32, u32, u32)> void WrapI_IUUU() {
754
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
755
	RETURN(retval);
756
}
757

758
template<int func(int, u32, u32)> void WrapI_IUU() {
759
	int retval = func(PARAM(0), PARAM(1), PARAM(2));
760
	RETURN(retval);
761
}
762

763
template<u32 func(u32, u32, u32, u32, u32, u32, u32)> void WrapU_UUUUUUU() {
764
  u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
765
  RETURN(retval);
766
}
767

768
template<int func(int, u32, u32, u32, u32, u32, u32)> void WrapI_IUUUUUU() {
769
	int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
770
	RETURN(retval);
771
}
772

773
template<int func(u32, int, u32, u32)> void WrapI_UIUU() {
774
	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
775
	RETURN(retval);
776
}
777

778
template<int func(int, const char *)> void WrapI_IC() {
779
	int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)));
780
	RETURN(retval);
781
}
782

783
template <int func(int, const char *, const char *, u32, int)> void WrapI_ICCUI() {
784
	int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)), PARAM(3), PARAM(4));
785
	RETURN(retval);
786
}
787

788
template <int func(int, const char *, const char *, int)> void WrapI_ICCI() {
789
	int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)), PARAM(3));
790
	RETURN(retval);
791
}
792

793
template <int func(const char *, int, int)> void WrapI_CII() {
794
	int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
795
	RETURN(retval);
796
}
797

798
template <int func(int, const char *, int)> void WrapI_ICI() {
799
	int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2));
800
	RETURN(retval);
801
}
802

803
template<int func(int, void *, void *, void *, void *, u32, int)> void WrapI_IVVVVUI(){
804
  u32 retval = func(PARAM(0), Memory::GetPointerWrite(PARAM(1)), Memory::GetPointerWrite(PARAM(2)), Memory::GetPointerWrite(PARAM(3)), Memory::GetPointerWrite(PARAM(4)), PARAM(5), PARAM(6) );
805
  RETURN(retval);
806
}
807

808
template<int func(int, const char *, u32, void *, int, int, int)> void WrapI_ICUVIII(){
809
  u32 retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), Memory::GetPointerWrite(PARAM(3)), PARAM(4), PARAM(5), PARAM(6));
810
  RETURN(retval);
811
}
812

813
template<int func(void *, u32, int)> void WrapI_VUI(){
814
	u32 retval = func(Memory::GetPointerWrite(PARAM(0)), PARAM(1), PARAM(2));
815
	RETURN(retval);
816
}
817

818
CoCalc provides the best real-time collaborative environment for Jupyter Notebooks, LaTeX documents, and SageMath, scalable from individual users to large groups and classes!

Product

Resources

Company
