ScummVM API documentation
script_api.h
1/* ScummVM - Graphic Adventure Engine
2 *
3 * ScummVM is the legal property of its developers, whose names
4 * are too numerous to list here. Please refer to the COPYRIGHT
5 * file distributed with this source distribution.
6 *
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 *
20 */
21
22//=============================================================================
23//
24// Script API function type and helper macros for forwarding runtime script
25// values to real engine functions.
26//
27//=============================================================================
28
29#ifndef AGS_ENGINE_SCRIPT_SCRIPT_API_H
30#define AGS_ENGINE_SCRIPT_SCRIPT_API_H
31
32#include "ags/shared/core/types.h"
33#include "ags/engine/ac/runtime_defines.h"
34#include "ags/shared/debugging/out.h"
35
36namespace AGS3 {
37
38struct RuntimeScriptValue;
39
40// TODO: replace void* with base object class when possible; also put array class for parameters
41typedef RuntimeScriptValue ScriptAPIFunction(const RuntimeScriptValue *params, int32_t param_count);
42typedef RuntimeScriptValue ScriptAPIObjectFunction(void *self, const RuntimeScriptValue *params, int32_t param_count);
43
44// Sprintf that takes either script values or common argument list from plugin.
45// Uses EITHER sc_args/sc_argc or varg_ptr as parameter list, whichever is not
46// NULL, with varg_ptr having HIGHER priority.
47const char *ScriptSprintf(char *buffer, size_t buf_length, const char *format,
48 const RuntimeScriptValue *sc_args, int32_t sc_argc, va_list *varg_ptr);
49// Sprintf that takes script values as arguments
50inline const char *ScriptSprintf(char *buffer, size_t buf_length, const char *format, const RuntimeScriptValue *args, int32_t argc) {
51 return ScriptSprintf(buffer, buf_length, format, args, argc, nullptr);
52}
53// Variadic sprintf (needed, because all arguments are pushed as pointer-sized values). Currently used only when plugin calls
54// exported engine function. Should be removed when this plugin issue is resolved.
55inline const char *ScriptVSprintf(char *buffer, size_t buf_length, const char *format, va_list &arg_ptr) {
56 return ScriptSprintf(buffer, buf_length, format, nullptr, 0, &arg_ptr);
57}
58
59// Helper macro for registering an API function for both script and plugin,
60// for the common case where they have similar names: the script's "translator"
61// function's name is derived from the real one by adding a "Sc_" prefix.
62#define API_FN_PAIR(FN_NAME) Sc_##FN_NAME, (void *)FN_NAME
63
64// Helper macros for script functions;
65// asserting for internal mistakes; suppressing "unused param" warnings
66#define ASSERT_SELF(METHOD) \
67 (void)params; (void)param_count; \
68 assert((self != NULL) && "Object pointer is null in call to API function")
69#define ASSERT_PARAM_COUNT(FUNCTION, X) \
70 (void)params; (void)param_count; \
71 assert((params != NULL && param_count >= X) && "Not enough parameters in call to API function")
72#define ASSERT_VARIABLE_VALUE(VARIABLE) \
73 (void)params; (void)param_count; \
74 assert((params != NULL && param_count >= 1) && "Not enough parameters to set API property")
75#define ASSERT_OBJ_PARAM_COUNT(METHOD, X) \
76 ASSERT_SELF(METHOD); \
77 ASSERT_PARAM_COUNT(METHOD, X)
78
79//-----------------------------------------------------------------------------
80// Calls to ScriptSprintf with automatic translation
81
82#define API_SCALL_SCRIPT_SPRINTF(FUNCTION, PARAM_COUNT) \
83 ASSERT_PARAM_COUNT(FUNCTION, PARAM_COUNT); \
84 char ScSfBuffer[STD_BUFFER_SIZE]; \
85 const char *scsf_buffer = ScriptSprintf(ScSfBuffer, STD_BUFFER_SIZE, get_translation(params[PARAM_COUNT - 1].CStr), params + PARAM_COUNT, param_count - PARAM_COUNT)
86
87#define API_OBJCALL_SCRIPT_SPRINTF(METHOD, PARAM_COUNT) \
88 ASSERT_OBJ_PARAM_COUNT(METHOD, PARAM_COUNT); \
89 char ScSfBuffer[STD_BUFFER_SIZE]; \
90 const char *scsf_buffer = ScriptSprintf(ScSfBuffer, STD_BUFFER_SIZE, get_translation(params[PARAM_COUNT - 1].CStr), params + PARAM_COUNT, param_count - PARAM_COUNT)
91
92//-----------------------------------------------------------------------------
93// Calls to ScriptSprintf without translation
94
95#define API_SCALL_SCRIPT_SPRINTF_PURE(FUNCTION, PARAM_COUNT) \
96 ASSERT_PARAM_COUNT(FUNCTION, PARAM_COUNT); \
97 char ScSfBuffer[STD_BUFFER_SIZE]; \
98 const char *scsf_buffer = ScriptSprintf(ScSfBuffer, STD_BUFFER_SIZE, params[PARAM_COUNT - 1].CStr, params + PARAM_COUNT, param_count - PARAM_COUNT)
99
100
101//-----------------------------------------------------------------------------
102// Calls to ScriptSprintfV (unsafe plugin variant)
103
104#define API_PLUGIN_SCRIPT_SPRINTF(FORMAT_STR) \
105 va_list args; \
106 va_start(args, FORMAT_STR); \
107 char ScSfBuffer[STD_BUFFER_SIZE]; \
108 const char *scsf_buffer = ScriptVSprintf(ScSfBuffer, STD_BUFFER_SIZE, get_translation(FORMAT_STR), args); \
109 va_end(args)
110
111#define API_PLUGIN_SCRIPT_SPRINTF_PURE(FORMAT_STR) \
112 va_list args; \
113 va_start(args, FORMAT_STR); \
114 char ScSfBuffer[STD_BUFFER_SIZE]; \
115 const char *scsf_buffer = ScriptVSprintf(ScSfBuffer, STD_BUFFER_SIZE, FORMAT_STR, args); \
116 va_end(args)
117
118//-----------------------------------------------------------------------------
119// Calls to static functions
120//
121// IMPORTANT: please note following: historically AGS compiler did not have
122// proper "void" type and allowed to store the return value of "void" API
123// functions as an integer (although that value did not have any practical
124// meaning). For backwards compatibility we actually return integer value
125// of '0' in all the VOID script API functions!
126//
127
128#define API_SCALL_VOID(FUNCTION) \
129 (void)params; (void)param_count; \
130 FUNCTION(); \
131 return RuntimeScriptValue((int32_t)0)
132
133#define API_SCALL_VOID_PBOOL(FUNCTION) \
134 ASSERT_PARAM_COUNT(FUNCTION, 1); \
135 FUNCTION(params[0].GetAsBool()); \
136 return RuntimeScriptValue((int32_t)0)
137
138#define API_SCALL_VOID_PINT(FUNCTION) \
139 ASSERT_PARAM_COUNT(FUNCTION, 1); \
140 FUNCTION(params[0].IValue); \
141 return RuntimeScriptValue((int32_t)0)
142
143#define API_SCALL_VOID_PINT2(FUNCTION) \
144 ASSERT_PARAM_COUNT(FUNCTION, 2); \
145 FUNCTION(params[0].IValue, params[1].IValue); \
146 return RuntimeScriptValue((int32_t)0)
147
148#define API_SCALL_VOID_PINT3(FUNCTION) \
149 ASSERT_PARAM_COUNT(FUNCTION, 3); \
150 FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue); \
151 return RuntimeScriptValue((int32_t)0)
152
153#define API_SCALL_VOID_PINT4(FUNCTION) \
154 ASSERT_PARAM_COUNT(FUNCTION, 4); \
155 FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue); \
156 return RuntimeScriptValue((int32_t)0)
157
158#define API_SCALL_VOID_PINT5(FUNCTION) \
159 ASSERT_PARAM_COUNT(FUNCTION, 5); \
160 FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue, params[4].IValue); \
161 return RuntimeScriptValue((int32_t)0)
162
163#define API_SCALL_VOID_PINT6(FUNCTION) \
164 ASSERT_PARAM_COUNT(FUNCTION, 6); \
165 FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue, params[4].IValue, params[5].IValue); \
166 return RuntimeScriptValue((int32_t)0)
167
168#define API_SCALL_VOID_PINT_POBJ(FUNCTION, P1CLASS) \
169 ASSERT_PARAM_COUNT(FUNCTION, 2); \
170 FUNCTION(params[0].IValue, (P1CLASS*)params[1].Ptr); \
171 return RuntimeScriptValue((int32_t)0)
172
173#define API_SCALL_VOID_PINT_POBJ2(FUNCTION, P1CLASS, P2CLASS) \
174 ASSERT_PARAM_COUNT(FUNCTION, 3); \
175 FUNCTION(params[0].IValue, (P1CLASS*)params[1].Ptr, (P2CLASS*)params[2].Ptr); \
176 return RuntimeScriptValue((int32_t)0)
177
178#define API_SCALL_VOID_PINT2_POBJ(FUNCTION, P1CLASS) \
179 ASSERT_PARAM_COUNT(FUNCTION, 3); \
180 FUNCTION(params[0].IValue, params[1].IValue, (P1CLASS*)params[2].Ptr); \
181 return RuntimeScriptValue((int32_t)0)
182
183#define API_SCALL_VOID_PINT3_POBJ_PINT(FUNCTION, P1CLASS) \
184 ASSERT_PARAM_COUNT(FUNCTION, 5); \
185 FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue, (P1CLASS*)params[3].Ptr, params[4].IValue); \
186 return RuntimeScriptValue((int32_t)0)
187
188#define API_SCALL_VOID_PINT4_POBJ(FUNCTION, P1CLASS) \
189 ASSERT_PARAM_COUNT(FUNCTION, 5); \
190 FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue, (P1CLASS*)params[4].Ptr); \
191 return RuntimeScriptValue((int32_t)0)
192
193#define API_SCALL_VOID_PFLOAT2(FUNCTION) \
194 ASSERT_PARAM_COUNT(FUNCTION, 2); \
195 FUNCTION(params[0].FValue, params[1].FValue); \
196 return RuntimeScriptValue((int32_t)0)
197
198#define API_SCALL_VOID_POBJ(FUNCTION, P1CLASS) \
199 ASSERT_PARAM_COUNT(FUNCTION, 1); \
200 FUNCTION((P1CLASS*)params[0].Ptr); \
201 return RuntimeScriptValue((int32_t)0)
202
203#define API_SCALL_VOID_POBJ_PINT(FUNCTION, P1CLASS) \
204 ASSERT_PARAM_COUNT(FUNCTION, 2); \
205 FUNCTION((P1CLASS*)params[0].Ptr, params[1].IValue); \
206 return RuntimeScriptValue((int32_t)0)
207
208#define API_SCALL_VOID_POBJ_PINT2(FUNCTION, P1CLASS) \
209 ASSERT_PARAM_COUNT(FUNCTION, 3); \
210 FUNCTION((P1CLASS*)params[0].Ptr, params[1].IValue, params[2].IValue); \
211 return RuntimeScriptValue((int32_t)0)
212
213#define API_SCALL_VOID_POBJ2(FUNCTION, P1CLASS, P2CLASS) \
214 ASSERT_PARAM_COUNT(FUNCTION, 2); \
215 FUNCTION((P1CLASS*)params[0].Ptr, (P2CLASS*)params[1].Ptr); \
216 return RuntimeScriptValue((int32_t)0)
217
218#define API_SCALL_INT(FUNCTION) \
219 (void)params; (void)param_count; \
220 return RuntimeScriptValue().SetInt32(FUNCTION())
221
222#define API_SCALL_INT_PINT(FUNCTION) \
223 ASSERT_PARAM_COUNT(FUNCTION, 1); \
224 return RuntimeScriptValue().SetInt32(FUNCTION(params[0].IValue))
225
226#define API_SCALL_INT_PINT2(FUNCTION) \
227 ASSERT_PARAM_COUNT(FUNCTION, 2); \
228 return RuntimeScriptValue().SetInt32(FUNCTION(params[0].IValue, params[1].IValue))
229
230#define API_SCALL_INT_PINT3(FUNCTION) \
231 ASSERT_PARAM_COUNT(FUNCTION, 3); \
232 return RuntimeScriptValue().SetInt32(FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue))
233
234#define API_SCALL_INT_PINT4(FUNCTION) \
235 ASSERT_PARAM_COUNT(FUNCTION, 4); \
236 return RuntimeScriptValue().SetInt32(FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue))
237
238#define API_SCALL_INT_PINT4_PFLOAT(FUNCTION) \
239 ASSERT_PARAM_COUNT(FUNCTION, 5) \
240 return RuntimeScriptValue().SetInt32(FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue, params[3].FValue))
241
242#define API_SCALL_INT_PINT5(FUNCTION) \
243 ASSERT_PARAM_COUNT(FUNCTION, 5); \
244 return RuntimeScriptValue().SetInt32(FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue, params[4].IValue))
245
246#define API_SCALL_INT_PFLOAT_PINT(FUNCTION) \
247 ASSERT_PARAM_COUNT(FUNCTION, 2); \
248 return RuntimeScriptValue().SetInt32(FUNCTION(params[0].FValue, params[1].IValue))
249
250#define API_SCALL_INT_POBJ(FUNCTION, P1CLASS) \
251 ASSERT_PARAM_COUNT(FUNCTION, 1); \
252 return RuntimeScriptValue().SetInt32(FUNCTION((P1CLASS*)params[0].Ptr))
253
254#define API_SCALL_INT_POBJ_PINT(FUNCTION, P1CLASS) \
255 ASSERT_PARAM_COUNT(FUNCTION, 2); \
256 return RuntimeScriptValue().SetInt32(FUNCTION((P1CLASS*)params[0].Ptr, params[1].IValue))
257
258#define API_SCALL_INT_POBJ_PINT2(FUNCTION, P1CLASS) \
259 ASSERT_PARAM_COUNT(FUNCTION, 3); \
260 return RuntimeScriptValue().SetInt32(FUNCTION((P1CLASS*)params[0].Ptr, params[1].IValue, params[2].IValue))
261
262#define API_SCALL_INT_POBJ2(FUNCTION, P1CLASS, P2CLASS) \
263 ASSERT_PARAM_COUNT(FUNCTION, 2); \
264 return RuntimeScriptValue().SetInt32(FUNCTION((P1CLASS*)params[0].Ptr, (P2CLASS*)params[1].Ptr))
265
266#define API_SCALL_INT_PINT_POBJ(FUNCTION, P1CLASS) \
267 ASSERT_PARAM_COUNT(FUNCTION, 2); \
268 return RuntimeScriptValue().SetInt32(FUNCTION(params[0].IValue, (P1CLASS*)params[1].Ptr))
269
270#define API_SCALL_FLOAT(FUNCTION) \
271 (void)params; (void)param_count; \
272 return RuntimeScriptValue().SetFloat(FUNCTION())
273
274#define API_SCALL_FLOAT_PINT(FUNCTION) \
275 ASSERT_PARAM_COUNT(FUNCTION, 1); \
276 return RuntimeScriptValue().SetFloat(FUNCTION(params[0].IValue))
277
278#define API_SCALL_FLOAT_PFLOAT(FUNCTION) \
279 ASSERT_PARAM_COUNT(FUNCTION, 1); \
280 return RuntimeScriptValue().SetFloat(FUNCTION(params[0].FValue))
281
282#define API_SCALL_FLOAT_PFLOAT2(FUNCTION) \
283 ASSERT_PARAM_COUNT(FUNCTION, 2); \
284 return RuntimeScriptValue().SetFloat(FUNCTION(params[0].FValue, params[1].FValue))
285
286#define API_SCALL_BOOL(FUNCTION) \
287 (void)params; (void)param_count; \
288 return RuntimeScriptValue().SetInt32AsBool(FUNCTION())
289
290#define API_SCALL_BOOL_POBJ(FUNCTION, P1CLASS) \
291 ASSERT_PARAM_COUNT(FUNCTION, 1); \
292 return RuntimeScriptValue().SetInt32AsBool(FUNCTION((P1CLASS*)params[0].Ptr))
293
294#define API_SCALL_BOOL_PINT(FUNCTION) \
295 ASSERT_PARAM_COUNT(FUNCTION, 1); \
296 return RuntimeScriptValue().SetInt32AsBool(FUNCTION(params[0].IValue))
297
298#define API_SCALL_BOOL_POBJ_PINT(FUNCTION, P1CLASS) \
299 ASSERT_PARAM_COUNT(FUNCTION, 2); \
300 return RuntimeScriptValue().SetInt32AsBool(FUNCTION((P1CLASS*)params[0].Ptr, params[1].IValue))
301
302#define API_SCALL_BOOL_POBJ2(FUNCTION, P1CLASS, P2CLASS) \
303 ASSERT_PARAM_COUNT(FUNCTION, 2); \
304 return RuntimeScriptValue().SetInt32AsBool(FUNCTION((P1CLASS*)params[0].Ptr, (P2CLASS*)params[1].Ptr))
305
306#define API_SCALL_OBJ(RET_CLASS, RET_MGR, FUNCTION) \
307 (void)params; (void)param_count; \
308 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)FUNCTION()), &RET_MGR)
309/*
310 #define API_CONST_SCALL_OBJ(RET_CLASS, RET_MGR, FUNCTION) \
311 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)FUNCTION()), &RET_MGR)
312*/
313#define API_SCALL_OBJ_PINT(RET_CLASS, RET_MGR, FUNCTION) \
314 ASSERT_PARAM_COUNT(FUNCTION, 1); \
315 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)FUNCTION(params[0].IValue)), &RET_MGR)
316/*
317#define API_CONST_SCALL_OBJ_PINT(RET_CLASS, RET_MGR, FUNCTION) \
318 ASSERT_PARAM_COUNT(FUNCTION, 1); \
319 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)FUNCTION(params[0].IValue)), &RET_MGR)
320*/
321#define API_SCALL_OBJ_POBJ_PINT_PBOOL(RET_CLASS, RET_MGR, FUNCTION, P1CLASS) \
322 ASSERT_PARAM_COUNT(FUNCTION, 3); \
323 return RuntimeScriptValue().SetScriptObject((void*)(RET_CLASS*)FUNCTION((P1CLASS*)params[0].Ptr, params[1].IValue, params[2].GetAsBool()), &RET_MGR)
324
325#define API_SCALL_OBJ_PINT2(RET_CLASS, RET_MGR, FUNCTION) \
326 ASSERT_PARAM_COUNT(FUNCTION, 2); \
327 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)FUNCTION(params[0].IValue, params[1].IValue)), &RET_MGR)
328/*
329#define API_CONST_SCALL_OBJ_PINT2(RET_CLASS, RET_MGR, FUNCTION) \
330 ASSERT_PARAM_COUNT(FUNCTION, 2); \
331 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)FUNCTION(params[0].IValue, params[1].IValue)), &RET_MGR)
332*/
333#define API_SCALL_OBJ_PINT3_POBJ(RET_CLASS, RET_MGR, FUNCTION, P1CLASS) \
334 ASSERT_PARAM_COUNT(FUNCTION, 4); \
335 return RuntimeScriptValue().SetScriptObject((void*)(RET_CLASS*)FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue, (P1CLASS*)params[3].Ptr), &RET_MGR)
336
337#define API_SCALL_OBJ_POBJ(RET_CLASS, RET_MGR, FUNCTION, P1CLASS) \
338 ASSERT_PARAM_COUNT(FUNCTION, 1); \
339 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)FUNCTION((P1CLASS*)params[0].Ptr)), &RET_MGR)
340/*
341#define API_CONST_SCALL_OBJ_POBJ(RET_CLASS, RET_MGR, FUNCTION, P1CLASS) \
342 ASSERT_PARAM_COUNT(FUNCTION, 1); \
343 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)FUNCTION((P1CLASS*)params[0].Ptr)), &RET_MGR)
344*/
345#define API_SCALL_OBJAUTO(RET_CLASS, FUNCTION) \
346 (void)params; (void)param_count; \
347 RET_CLASS* ret_obj = FUNCTION(); \
348 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
349
350#define API_SCALL_OBJAUTO_PINT(RET_CLASS, FUNCTION) \
351 ASSERT_PARAM_COUNT(FUNCTION, 1); \
352 RET_CLASS* ret_obj = FUNCTION(params[0].IValue); \
353 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
354
355#define API_SCALL_OBJAUTO_PINT2(RET_CLASS, FUNCTION) \
356 ASSERT_PARAM_COUNT(FUNCTION, 2); \
357 RET_CLASS* ret_obj = FUNCTION(params[0].IValue, params[1].IValue); \
358 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
359
360#define API_SCALL_OBJAUTO_PINT3(RET_CLASS, FUNCTION) \
361 ASSERT_PARAM_COUNT(FUNCTION, 3); \
362 RET_CLASS* ret_obj = FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue); \
363 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
364
365#define API_SCALL_OBJAUTO_PINT4(RET_CLASS, FUNCTION) \
366 ASSERT_PARAM_COUNT(FUNCTION, 4); \
367 RET_CLASS* ret_obj = FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue); \
368 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
369
370#define API_SCALL_OBJAUTO_PINT5(RET_CLASS, FUNCTION) \
371 ASSERT_PARAM_COUNT(FUNCTION, 5); \
372 RET_CLASS* ret_obj = FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue, params[4].IValue); \
373 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
374
375#define API_SCALL_OBJAUTO_PINT2_PBOOL(RET_CLASS, FUNCTION) \
376 ASSERT_PARAM_COUNT(FUNCTION, 3); \
377 RET_CLASS *ret_obj = FUNCTION(params[0].IValue, params[1].IValue, params[2].GetAsBool()); \
378 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
379
380#define API_SCALL_OBJAUTO_PINT3_PBOOL(RET_CLASS, FUNCTION) \
381 ASSERT_PARAM_COUNT(FUNCTION, 4); \
382 RET_CLASS *ret_obj = FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue, params[3].GetAsBool()); \
383 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
384
385#define API_SCALL_OBJAUTO_PINT3_PBOOL2(RET_CLASS, FUNCTION) \
386 ASSERT_PARAM_COUNT(FUNCTION, 5); \
387 RET_CLASS *ret_obj = FUNCTION(params[0].IValue, params[1].IValue, params[2].IValue, params[3].GetAsBool(), params[4].GetAsBool()); \
388 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
389
390#define API_SCALL_OBJAUTO_PBOOL2(RET_CLASS, FUNCTION) \
391 ASSERT_PARAM_COUNT(FUNCTION, 2); \
392 RET_CLASS* ret_obj = FUNCTION(params[0].GetAsBool(), params[1].GetAsBool()); \
393 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
394
395#define API_SCALL_OBJAUTO_POBJ(RET_CLASS, FUNCTION, P1CLASS) \
396 ASSERT_PARAM_COUNT(FUNCTION, 1); \
397 RET_CLASS* ret_obj = FUNCTION((P1CLASS*)params[0].Ptr); \
398 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
399
400#define API_SCALL_OBJAUTO_POBJ_PINT(RET_CLASS, FUNCTION, P1CLASS) \
401 ASSERT_PARAM_COUNT(FUNCTION, 2); \
402 RET_CLASS* ret_obj = (RET_CLASS*)FUNCTION((P1CLASS*)params[0].Ptr, params[1].IValue); \
403 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
404
405#define API_SCALL_OBJAUTO_POBJ_PINT4(RET_CLASS, FUNCTION, P1CLASS) \
406 ASSERT_PARAM_COUNT(FUNCTION, 5); \
407 RET_CLASS* ret_obj = FUNCTION((P1CLASS*)params[0].Ptr, params[1].IValue, params[2].IValue, params[3].IValue, params[4].IValue); \
408 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
409
410
411#define API_SCALL_STOBJ_POBJ2(RET_CLASS, FUNCTION, P1CLASS, P2CLASS) \
412 ASSERT_PARAM_COUNT(FUNCTION, 2); \
413 RET_CLASS* ret_obj = FUNCTION((P1CLASS*)params[0].Ptr, (P2CLASS*)params[1].Ptr); \
414 return RuntimeScriptValue().SetStaticObject(ret_obj, &_GP(GlobalStaticManager))
415
416//-----------------------------------------------------------------------------
417// Calls to object functions
418
419#define API_OBJCALL_VOID(CLASS, METHOD) \
420 ASSERT_SELF(METHOD); \
421 METHOD((CLASS*)self); \
422 return RuntimeScriptValue((int32_t)0)
423
424#define API_OBJCALL_VOID_PINT(CLASS, METHOD) \
425 ASSERT_OBJ_PARAM_COUNT(METHOD, 1); \
426 METHOD((CLASS*)self, params[0].IValue); \
427 return RuntimeScriptValue((int32_t)0)
428
429#define API_OBJCALL_VOID_PINT2(CLASS, METHOD) \
430 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
431 METHOD((CLASS*)self, params[0].IValue, params[1].IValue); \
432 return RuntimeScriptValue((int32_t)0)
433
434#define API_OBJCALL_VOID_PINT3(CLASS, METHOD) \
435 ASSERT_OBJ_PARAM_COUNT(METHOD, 3); \
436 METHOD((CLASS*)self, params[0].IValue, params[1].IValue, params[2].IValue); \
437 return RuntimeScriptValue((int32_t)0)
438
439#define API_OBJCALL_VOID_PINT4(CLASS, METHOD) \
440 ASSERT_OBJ_PARAM_COUNT(METHOD, 4); \
441 METHOD((CLASS*)self, params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue); \
442 return RuntimeScriptValue((int32_t)0)
443
444#define API_OBJCALL_VOID_PINT5(CLASS, METHOD) \
445 ASSERT_OBJ_PARAM_COUNT(METHOD, 5); \
446 METHOD((CLASS*)self, params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue, params[4].IValue); \
447 return RuntimeScriptValue((int32_t)0)
448
449#define API_OBJCALL_VOID_PINT6(CLASS, METHOD) \
450 ASSERT_OBJ_PARAM_COUNT(METHOD, 6); \
451 METHOD((CLASS*)self, params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue, params[4].IValue, params[5].IValue); \
452 return RuntimeScriptValue((int32_t)0)
453
454#define API_OBJCALL_VOID_PINT7(CLASS, METHOD) \
455 ASSERT_OBJ_PARAM_COUNT(METHOD, 7); \
456 METHOD((CLASS*)self, params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue, params[4].IValue, params[5].IValue, params[6].IValue); \
457 return RuntimeScriptValue((int32_t)0)
458
459#define API_OBJCALL_VOID_PINT8(CLASS, METHOD) \
460 ASSERT_OBJ_PARAM_COUNT(METHOD, 8); \
461 METHOD((CLASS*)self, params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue, params[4].IValue, params[5].IValue, params[6].IValue, params[7].IValue); \
462 return RuntimeScriptValue((int32_t)0)
463
464#define API_OBJCALL_VOID_PFLOAT(CLASS, METHOD) \
465 ASSERT_OBJ_PARAM_COUNT(METHOD, 1); \
466 METHOD((CLASS*)self, params[0].FValue); \
467 return RuntimeScriptValue()
468
469#define API_OBJCALL_VOID_PFLOAT2(CLASS, METHOD) \
470 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
471 METHOD((CLASS*)self, params[0].FValue, params[1].FValue); \
472 return RuntimeScriptValue()
473
474#define API_OBJCALL_VOID_PBOOL(CLASS, METHOD) \
475 ASSERT_OBJ_PARAM_COUNT(METHOD, 1); \
476 METHOD((CLASS*)self, params[0].GetAsBool()); \
477 return RuntimeScriptValue((int32_t)0)
478
479#define API_OBJCALL_VOID_PINT_PBOOL(CLASS, METHOD) \
480 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
481 METHOD((CLASS*)self, params[0].IValue, params[1].GetAsBool()); \
482 return RuntimeScriptValue((int32_t)0)
483
484#define API_OBJCALL_VOID_PINT_POBJ(CLASS, METHOD, P1CLASS) \
485 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
486 METHOD((CLASS*)self, params[0].IValue, (P1CLASS*)params[1].Ptr); \
487 return RuntimeScriptValue((int32_t)0)
488
489#define API_OBJCALL_VOID_PINT3_POBJ(CLASS, METHOD, P1CLASS) \
490 ASSERT_OBJ_PARAM_COUNT(METHOD, 4); \
491 METHOD((CLASS*)self, params[0].IValue, params[1].IValue, params[2].IValue, (P1CLASS*)params[3].Ptr); \
492 return RuntimeScriptValue((int32_t)0)
493
494#define API_OBJCALL_VOID_PINT5_POBJ(CLASS, METHOD, P1CLASS) \
495 ASSERT_OBJ_PARAM_COUNT(METHOD, 6); \
496 METHOD((CLASS*)self, params[0].IValue, params[1].IValue, params[2].IValue, params[3].IValue, params[4].IValue, (P1CLASS*)params[5].Ptr); \
497 return RuntimeScriptValue((int32_t)0)
498
499#define API_OBJCALL_VOID_POBJ(CLASS, METHOD, P1CLASS) \
500 ASSERT_OBJ_PARAM_COUNT(METHOD, 1); \
501 METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr); \
502 return RuntimeScriptValue((int32_t)0)
503
504#define API_OBJCALL_VOID_POBJ_PINT(CLASS, METHOD, P1CLASS) \
505 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
506 METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr, params[1].IValue); \
507 return RuntimeScriptValue((int32_t)0)
508
509#define API_OBJCALL_VOID_POBJ_PINT2(CLASS, METHOD, P1CLASS) \
510 ASSERT_OBJ_PARAM_COUNT(METHOD, 3); \
511 METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr, params[1].IValue, params[2].IValue); \
512 return RuntimeScriptValue((int32_t)0)
513
514#define API_OBJCALL_VOID_POBJ2(CLASS, METHOD, P1CLASS, P2CLASS) \
515 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
516 METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr, (P2CLASS*)params[1].Ptr); \
517 return RuntimeScriptValue((int32_t)0)
518
519#define API_OBJCALL_INT(CLASS, METHOD) \
520 ASSERT_SELF(METHOD); \
521 return RuntimeScriptValue().SetInt32(METHOD((CLASS*)self))
522
523#define API_OBJCALL_INT_PINT(CLASS, METHOD) \
524 ASSERT_OBJ_PARAM_COUNT(METHOD, 1); \
525 return RuntimeScriptValue().SetInt32(METHOD((CLASS*)self, params[0].IValue))
526
527#define API_OBJCALL_INT_PINT_POBJ(CLASS, METHOD, P1CLASS) \
528 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
529 return RuntimeScriptValue().SetInt32(METHOD((CLASS*)self, params[0].IValue, params[1].CStr))
530
531#define API_OBJCALL_INT_PINT2(CLASS, METHOD) \
532 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
533 return RuntimeScriptValue().SetInt32(METHOD((CLASS*)self, params[0].IValue, params[1].IValue))
534
535#define API_OBJCALL_INT_POBJ(CLASS, METHOD, P1CLASS) \
536 ASSERT_OBJ_PARAM_COUNT(METHOD, 1); \
537 return RuntimeScriptValue().SetInt32(METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr))
538
539#define API_OBJCALL_INT_POBJ_PINT(CLASS, METHOD, P1CLASS) \
540 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
541 return RuntimeScriptValue().SetInt32(METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr, params[1].IValue))
542
543#define API_OBJCALL_INT_POBJ_PBOOL(CLASS, METHOD, P1CLASS) \
544 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
545 return RuntimeScriptValue().SetInt32(METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr, params[1].GetAsBool()))
546
547#define API_OBJCALL_FLOAT(CLASS, METHOD) \
548 ASSERT_SELF(METHOD); \
549 return RuntimeScriptValue().SetFloat(METHOD((CLASS*)self))
550
551#define API_OBJCALL_BOOL(CLASS, METHOD) \
552 ASSERT_SELF(METHOD); \
553 return RuntimeScriptValue().SetInt32AsBool(METHOD((CLASS*)self))
554
555#define API_OBJCALL_BOOL_PINT(CLASS, METHOD) \
556 ASSERT_OBJ_PARAM_COUNT(METHOD, 1); \
557 return RuntimeScriptValue().SetInt32AsBool(METHOD((CLASS*)self, params[0].IValue))
558
559#define API_OBJCALL_BOOL_POBJ(CLASS, METHOD, P1CLASS) \
560 ASSERT_OBJ_PARAM_COUNT(METHOD, 1); \
561 return RuntimeScriptValue().SetInt32AsBool(METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr))
562
563#define API_OBJCALL_BOOL_POBJ_PINT(CLASS, METHOD, P1CLASS) \
564 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
565 return RuntimeScriptValue().SetInt32AsBool(METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr, params[1].IValue))
566
567#define API_OBJCALL_BOOL_POBJ2(CLASS, METHOD, P1CLASS, P2CLASS) \
568 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
569 return RuntimeScriptValue().SetInt32AsBool(METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr, (P2CLASS*)params[1].Ptr))
570
571#define API_OBJCALL_BOOL(CLASS, METHOD) \
572 ASSERT_SELF(METHOD); \
573 return RuntimeScriptValue().SetInt32AsBool(METHOD((CLASS*)self))
574
575#define API_OBJCALL_OBJ_PINT_POBJ(CLASS, RET_CLASS, RET_MGR, METHOD, P1CLASS) \
576 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
577 return RuntimeScriptValue().SetScriptObject((void*)METHOD((CLASS*)self, params[0].IValue, (P1CLASS*)params[1].Ptr), &RET_MGR)
578
579#define API_OBJCALL_OBJ_POBJ2_PINT(CLASS, RET_CLASS, RET_MGR, METHOD, P1CLASS, P2CLASS) \
580 ASSERT_OBJ_PARAM_COUNT(METHOD, 3); \
581 return RuntimeScriptValue().SetScriptObject((void*)METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr, (P2CLASS*)params[1].Ptr, params[2].IValue), &RET_MGR)
582
583#define API_OBJCALL_OBJ_POBJ2_PBOOL(CLASS, RET_CLASS, RET_MGR, METHOD, P1CLASS, P2CLASS) \
584 ASSERT_OBJ_PARAM_COUNT(METHOD, 3); \
585 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr, (P2CLASS*)params[1].Ptr, params[2].GetAsBool())), &RET_MGR)
586/*
587#define API_CONST_OBJCALL_OBJ_POBJ2_PBOOL(CLASS, RET_CLASS, RET_MGR, METHOD, P1CLASS, P2CLASS) \
588 ASSERT_OBJ_PARAM_COUNT(METHOD, 3); \
589 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr, (P2CLASS*)params[1].Ptr, params[2].GetAsBool())), &RET_MGR)
590*/
591#define API_OBJCALL_OBJ(CLASS, RET_CLASS, RET_MGR, METHOD) \
592 ASSERT_SELF(METHOD); \
593 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)METHOD((CLASS*)self)), &RET_MGR)
594/*
595#define API_CONST_OBJCALL_OBJ(CLASS, RET_CLASS, RET_MGR, METHOD) \
596 ASSERT_SELF(METHOD); \
597 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)METHOD((CLASS*)self)), &RET_MGR)
598*/
599#define API_OBJCALL_OBJ_PINT(CLASS, RET_CLASS, RET_MGR, METHOD) \
600 ASSERT_OBJ_PARAM_COUNT(METHOD, 1); \
601 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)METHOD((CLASS*)self, params[0].IValue)), &RET_MGR)
602/*
603#define API_CONST_OBJCALL_OBJ_PINT(CLASS, RET_CLASS, RET_MGR, METHOD) \
604 ASSERT_OBJ_PARAM_COUNT(METHOD, 1); \
605 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)METHOD((CLASS*)self, params[0].IValue)), &RET_MGR)
606*/
607#define API_OBJCALL_OBJ_PINT2(CLASS, RET_CLASS, RET_MGR, METHOD) \
608 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
609 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)METHOD((CLASS*)self, params[0].IValue, params[1].IValue)), &RET_MGR)
610/*
611#define API_CONST_OBJCALL_OBJ_PINT2(CLASS, RET_CLASS, RET_MGR, METHOD) \
612 ASSERT_OBJ_PARAM_COUNT(METHOD, 2); \
613 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)METHOD((CLASS*)self, params[0].IValue, params[1].IValue)), &RET_MGR)
614*/
615#define API_OBJCALL_OBJ_PINT3(CLASS, RET_CLASS, RET_MGR, METHOD) \
616 ASSERT_OBJ_PARAM_COUNT(METHOD, 3); \
617 return RuntimeScriptValue().SetScriptObject((void*)(RET_CLASS*)METHOD((CLASS*)self, params[0].IValue, params[1].IValue, params[2].IValue), &RET_MGR)
618
619#define API_OBJCALL_OBJ_POBJ(CLASS, RET_CLASS, RET_MGR, METHOD, P1CLASS) \
620 ASSERT_OBJ_PARAM_COUNT(METHOD, 1); \
621 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr)), &RET_MGR)
622/*
623#define API_CONST_OBJCALL_OBJ_POBJ(CLASS, RET_CLASS, RET_MGR, METHOD, P1CLASS) \
624 ASSERT_OBJ_PARAM_COUNT(METHOD, 1); \
625 return RuntimeScriptValue().SetScriptObject(const_cast<void *>((const void *)(RET_CLASS*)METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr)), &RET_MGR)
626*/
627#define API_OBJCALL_OBJAUTO(CLASS, RET_CLASS, METHOD) \
628 ASSERT_SELF(METHOD); \
629 RET_CLASS* ret_obj = METHOD((CLASS*)self); \
630 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
631
632#define API_OBJCALL_OBJAUTO_PINT2_PBOOL(CLASS, RET_CLASS, METHOD) \
633 ASSERT_OBJ_PARAM_COUNT(METHOD, 3); \
634 RET_CLASS* ret_obj = METHOD((CLASS*)self, params[0].IValue, params[1].IValue, params[2].GetAsBool()); \
635 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
636
637#define API_OBJCALL_OBJAUTO_POBJ(CLASS, RET_CLASS, METHOD, P1CLASS) \
638 ASSERT_OBJ_PARAM_COUNT(METHOD, 1); \
639 RET_CLASS* ret_obj = METHOD((CLASS*)self, (P1CLASS*)params[0].Ptr); \
640 return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj)
641
642} // namespace AGS3
643
644#endif