src/squirrel_helper.hpp
branchnoai
changeset 9813 9646f7e37c31
parent 9723 eee46cb39750
child 10722 6ea1daff57aa
equal deleted inserted replaced
9812:4bc3062476c8 9813:9646f7e37c31
   149 		static int SQCall(void *instance, Tretval (*func)(Targ1), HSQUIRRELVM vm)
   149 		static int SQCall(void *instance, Tretval (*func)(Targ1), HSQUIRRELVM vm)
   150 		{
   150 		{
   151 			Tretval ret = (*func)(
   151 			Tretval ret = (*func)(
   152 				GetParam(ForceType<Targ1>(), vm, 2)
   152 				GetParam(ForceType<Targ1>(), vm, 2)
   153 			);
   153 			);
   154 			sq_remove(vm, 2);
   154 			sq_pop(vm, 1);
   155 			return Return(vm, ret);
   155 			return Return(vm, ret);
   156 		}
   156 		}
   157 	};
   157 	};
   158 
   158 
   159 	/**
   159 	/**
   164 		static int SQCall(void *instance, Tretval (*func)(Targ1), HSQUIRRELVM vm)
   164 		static int SQCall(void *instance, Tretval (*func)(Targ1), HSQUIRRELVM vm)
   165 		{
   165 		{
   166 			(*func)(
   166 			(*func)(
   167 				GetParam(ForceType<Targ1>(), vm, 2)
   167 				GetParam(ForceType<Targ1>(), vm, 2)
   168 			);
   168 			);
   169 			sq_remove(vm, 2);
   169 			sq_pop(vm, 1);
   170 			return 0;
   170 			return 0;
   171 		}
   171 		}
   172 	};
   172 	};
   173 
   173 
   174 	/**
   174 	/**
   179 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
   179 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
   180 		{
   180 		{
   181 			Tretval ret = (instance->*func)(
   181 			Tretval ret = (instance->*func)(
   182 				GetParam(ForceType<Targ1>(), vm, 2)
   182 				GetParam(ForceType<Targ1>(), vm, 2)
   183 			);
   183 			);
   184 			sq_remove(vm, 2);
   184 			sq_pop(vm, 1);
   185 			return Return(vm, ret);
   185 			return Return(vm, ret);
   186 		}
   186 		}
   187 	};
   187 	};
   188 
   188 
   189 	/**
   189 	/**
   194 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
   194 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
   195 		{
   195 		{
   196 			(instance->*func)(
   196 			(instance->*func)(
   197 				GetParam(ForceType<Targ1>(), vm, 2)
   197 				GetParam(ForceType<Targ1>(), vm, 2)
   198 			);
   198 			);
   199 			sq_remove(vm, 2);
   199 			sq_pop(vm, 1);
   200 			return 0;
   200 			return 0;
   201 		}
   201 		}
   202 
   202 
   203 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
   203 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
   204 		{
   204 		{
   219 		{
   219 		{
   220 			Tretval ret = (*func)(
   220 			Tretval ret = (*func)(
   221 				GetParam(ForceType<Targ1>(), vm, 2),
   221 				GetParam(ForceType<Targ1>(), vm, 2),
   222 				GetParam(ForceType<Targ2>(), vm, 3)
   222 				GetParam(ForceType<Targ2>(), vm, 3)
   223 			);
   223 			);
   224 			sq_remove(vm, 2);
   224 			sq_pop(vm, 2);
   225 			sq_remove(vm, 3);
       
   226 			return Return(vm, ret);
   225 			return Return(vm, ret);
   227 		}
   226 		}
   228 	};
   227 	};
   229 
   228 
   230 	/**
   229 	/**
   236 		{
   235 		{
   237 			(*func)(
   236 			(*func)(
   238 				GetParam(ForceType<Targ1>(), vm, 2),
   237 				GetParam(ForceType<Targ1>(), vm, 2),
   239 				GetParam(ForceType<Targ2>(), vm, 3)
   238 				GetParam(ForceType<Targ2>(), vm, 3)
   240 			);
   239 			);
   241 			sq_remove(vm, 2);
   240 			sq_pop(vm, 2);
   242 			sq_remove(vm, 3);
       
   243 			return 0;
   241 			return 0;
   244 		}
   242 		}
   245 	};
   243 	};
   246 
   244 
   247 	/**
   245 	/**
   253 		{
   251 		{
   254 			Tretval ret = (instance->*func)(
   252 			Tretval ret = (instance->*func)(
   255 				GetParam(ForceType<Targ1>(), vm, 2),
   253 				GetParam(ForceType<Targ1>(), vm, 2),
   256 				GetParam(ForceType<Targ2>(), vm, 3)
   254 				GetParam(ForceType<Targ2>(), vm, 3)
   257 			);
   255 			);
   258 			sq_remove(vm, 2);
   256 			sq_pop(vm, 2);
   259 			sq_remove(vm, 3);
       
   260 			return Return(vm, ret);
   257 			return Return(vm, ret);
   261 		}
   258 		}
   262 	};
   259 	};
   263 
   260 
   264 	/**
   261 	/**
   270 		{
   267 		{
   271 			(instance->*func)(
   268 			(instance->*func)(
   272 				GetParam(ForceType<Targ1>(), vm, 2),
   269 				GetParam(ForceType<Targ1>(), vm, 2),
   273 				GetParam(ForceType<Targ2>(), vm, 3)
   270 				GetParam(ForceType<Targ2>(), vm, 3)
   274 			);
   271 			);
   275 			sq_remove(vm, 2);
   272 			sq_pop(vm, 2);
   276 			sq_remove(vm, 3);
       
   277 			return 0;
   273 			return 0;
   278 		}
   274 		}
   279 
   275 
   280 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2), HSQUIRRELVM vm)
   276 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2), HSQUIRRELVM vm)
   281 		{
   277 		{
   298 			Tretval ret = (*func)(
   294 			Tretval ret = (*func)(
   299 				GetParam(ForceType<Targ1>(), vm, 2),
   295 				GetParam(ForceType<Targ1>(), vm, 2),
   300 				GetParam(ForceType<Targ2>(), vm, 3),
   296 				GetParam(ForceType<Targ2>(), vm, 3),
   301 				GetParam(ForceType<Targ3>(), vm, 4)
   297 				GetParam(ForceType<Targ3>(), vm, 4)
   302 			);
   298 			);
   303 			sq_remove(vm, 2);
   299 			sq_pop(vm, 3);
   304 			sq_remove(vm, 3);
       
   305 			sq_remove(vm, 4);
       
   306 			return Return(vm, ret);
   300 			return Return(vm, ret);
   307 		}
   301 		}
   308 	};
   302 	};
   309 
   303 
   310 	/**
   304 	/**
   317 			(*func)(
   311 			(*func)(
   318 				GetParam(ForceType<Targ1>(), vm, 2),
   312 				GetParam(ForceType<Targ1>(), vm, 2),
   319 				GetParam(ForceType<Targ2>(), vm, 3),
   313 				GetParam(ForceType<Targ2>(), vm, 3),
   320 				GetParam(ForceType<Targ3>(), vm, 4)
   314 				GetParam(ForceType<Targ3>(), vm, 4)
   321 			);
   315 			);
   322 			sq_remove(vm, 2);
   316 			sq_pop(vm, 3);
   323 			sq_remove(vm, 3);
       
   324 			sq_remove(vm, 4);
       
   325 			return 0;
   317 			return 0;
   326 		}
   318 		}
   327 	};
   319 	};
   328 
   320 
   329 	/**
   321 	/**
   336 			Tretval ret = (instance->*func)(
   328 			Tretval ret = (instance->*func)(
   337 				GetParam(ForceType<Targ1>(), vm, 2),
   329 				GetParam(ForceType<Targ1>(), vm, 2),
   338 				GetParam(ForceType<Targ2>(), vm, 3),
   330 				GetParam(ForceType<Targ2>(), vm, 3),
   339 				GetParam(ForceType<Targ3>(), vm, 4)
   331 				GetParam(ForceType<Targ3>(), vm, 4)
   340 			);
   332 			);
   341 			sq_remove(vm, 2);
   333 			sq_pop(vm, 3);
   342 			sq_remove(vm, 3);
       
   343 			sq_remove(vm, 4);
       
   344 			return Return(vm, ret);
   334 			return Return(vm, ret);
   345 		}
   335 		}
   346 	};
   336 	};
   347 
   337 
   348 	/**
   338 	/**
   355 			(instance->*func)(
   345 			(instance->*func)(
   356 				GetParam(ForceType<Targ1>(), vm, 2),
   346 				GetParam(ForceType<Targ1>(), vm, 2),
   357 				GetParam(ForceType<Targ2>(), vm, 3),
   347 				GetParam(ForceType<Targ2>(), vm, 3),
   358 				GetParam(ForceType<Targ3>(), vm, 4)
   348 				GetParam(ForceType<Targ3>(), vm, 4)
   359 			);
   349 			);
   360 			sq_remove(vm, 2);
   350 			sq_pop(vm, 3);
   361 			sq_remove(vm, 3);
       
   362 			sq_remove(vm, 4);
       
   363 			return 0;
   351 			return 0;
   364 		}
   352 		}
   365 
   353 
   366 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
   354 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
   367 		{
   355 		{
   386 				GetParam(ForceType<Targ1>(), vm, 2),
   374 				GetParam(ForceType<Targ1>(), vm, 2),
   387 				GetParam(ForceType<Targ2>(), vm, 3),
   375 				GetParam(ForceType<Targ2>(), vm, 3),
   388 				GetParam(ForceType<Targ3>(), vm, 4),
   376 				GetParam(ForceType<Targ3>(), vm, 4),
   389 				GetParam(ForceType<Targ4>(), vm, 5)
   377 				GetParam(ForceType<Targ4>(), vm, 5)
   390 			);
   378 			);
   391 			sq_remove(vm, 2);
   379 			sq_pop(vm, 4);
   392 			sq_remove(vm, 3);
       
   393 			sq_remove(vm, 4);
       
   394 			sq_remove(vm, 5);
       
   395 			return Return(vm, ret);
   380 			return Return(vm, ret);
   396 		}
   381 		}
   397 	};
   382 	};
   398 
   383 
   399 	/**
   384 	/**
   407 				GetParam(ForceType<Targ1>(), vm, 2),
   392 				GetParam(ForceType<Targ1>(), vm, 2),
   408 				GetParam(ForceType<Targ2>(), vm, 3),
   393 				GetParam(ForceType<Targ2>(), vm, 3),
   409 				GetParam(ForceType<Targ3>(), vm, 4),
   394 				GetParam(ForceType<Targ3>(), vm, 4),
   410 				GetParam(ForceType<Targ4>(), vm, 5)
   395 				GetParam(ForceType<Targ4>(), vm, 5)
   411 			);
   396 			);
   412 			sq_remove(vm, 2);
   397 			sq_pop(vm, 4);
   413 			sq_remove(vm, 3);
       
   414 			sq_remove(vm, 4);
       
   415 			sq_remove(vm, 5);
       
   416 			return 0;
   398 			return 0;
   417 		}
   399 		}
   418 	};
   400 	};
   419 
   401 
   420 	/**
   402 	/**
   428 				GetParam(ForceType<Targ1>(), vm, 2),
   410 				GetParam(ForceType<Targ1>(), vm, 2),
   429 				GetParam(ForceType<Targ2>(), vm, 3),
   411 				GetParam(ForceType<Targ2>(), vm, 3),
   430 				GetParam(ForceType<Targ3>(), vm, 4),
   412 				GetParam(ForceType<Targ3>(), vm, 4),
   431 				GetParam(ForceType<Targ4>(), vm, 5)
   413 				GetParam(ForceType<Targ4>(), vm, 5)
   432 			);
   414 			);
   433 			sq_remove(vm, 2);
   415 			sq_pop(vm, 4);
   434 			sq_remove(vm, 3);
       
   435 			sq_remove(vm, 4);
       
   436 			sq_remove(vm, 5);
       
   437 			return Return(vm, ret);
   416 			return Return(vm, ret);
   438 		}
   417 		}
   439 	};
   418 	};
   440 
   419 
   441 	/**
   420 	/**
   449 				GetParam(ForceType<Targ1>(), vm, 2),
   428 				GetParam(ForceType<Targ1>(), vm, 2),
   450 				GetParam(ForceType<Targ2>(), vm, 3),
   429 				GetParam(ForceType<Targ2>(), vm, 3),
   451 				GetParam(ForceType<Targ3>(), vm, 4),
   430 				GetParam(ForceType<Targ3>(), vm, 4),
   452 				GetParam(ForceType<Targ4>(), vm, 5)
   431 				GetParam(ForceType<Targ4>(), vm, 5)
   453 			);
   432 			);
   454 			sq_remove(vm, 2);
   433 			sq_pop(vm, 4);
   455 			sq_remove(vm, 3);
       
   456 			sq_remove(vm, 4);
       
   457 			sq_remove(vm, 5);
       
   458 			return 0;
   434 			return 0;
   459 		}
   435 		}
   460 
   436 
   461 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
   437 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
   462 		{
   438 		{
   483 				GetParam(ForceType<Targ2>(), vm, 3),
   459 				GetParam(ForceType<Targ2>(), vm, 3),
   484 				GetParam(ForceType<Targ3>(), vm, 4),
   460 				GetParam(ForceType<Targ3>(), vm, 4),
   485 				GetParam(ForceType<Targ4>(), vm, 5),
   461 				GetParam(ForceType<Targ4>(), vm, 5),
   486 				GetParam(ForceType<Targ5>(), vm, 6)
   462 				GetParam(ForceType<Targ5>(), vm, 6)
   487 			);
   463 			);
   488 			sq_remove(vm, 2);
   464 			sq_pop(vm, 5);
   489 			sq_remove(vm, 3);
       
   490 			sq_remove(vm, 4);
       
   491 			sq_remove(vm, 5);
       
   492 			sq_remove(vm, 6);
       
   493 			return Return(vm, ret);
   465 			return Return(vm, ret);
   494 		}
   466 		}
   495 	};
   467 	};
   496 
   468 
   497 	/**
   469 	/**
   506 				GetParam(ForceType<Targ2>(), vm, 3),
   478 				GetParam(ForceType<Targ2>(), vm, 3),
   507 				GetParam(ForceType<Targ3>(), vm, 4),
   479 				GetParam(ForceType<Targ3>(), vm, 4),
   508 				GetParam(ForceType<Targ4>(), vm, 5),
   480 				GetParam(ForceType<Targ4>(), vm, 5),
   509 				GetParam(ForceType<Targ5>(), vm, 6)
   481 				GetParam(ForceType<Targ5>(), vm, 6)
   510 			);
   482 			);
   511 			sq_remove(vm, 2);
   483 			sq_pop(vm, 5);
   512 			sq_remove(vm, 3);
       
   513 			sq_remove(vm, 4);
       
   514 			sq_remove(vm, 5);
       
   515 			sq_remove(vm, 6);
       
   516 			return 0;
   484 			return 0;
   517 		}
   485 		}
   518 	};
   486 	};
   519 
   487 
   520 	/**
   488 	/**
   529 				GetParam(ForceType<Targ2>(), vm, 3),
   497 				GetParam(ForceType<Targ2>(), vm, 3),
   530 				GetParam(ForceType<Targ3>(), vm, 4),
   498 				GetParam(ForceType<Targ3>(), vm, 4),
   531 				GetParam(ForceType<Targ4>(), vm, 5),
   499 				GetParam(ForceType<Targ4>(), vm, 5),
   532 				GetParam(ForceType<Targ5>(), vm, 6)
   500 				GetParam(ForceType<Targ5>(), vm, 6)
   533 			);
   501 			);
   534 			sq_remove(vm, 2);
   502 			sq_pop(vm, 5);
   535 			sq_remove(vm, 3);
       
   536 			sq_remove(vm, 4);
       
   537 			sq_remove(vm, 5);
       
   538 			sq_remove(vm, 6);
       
   539 			return Return(vm, ret);
   503 			return Return(vm, ret);
   540 		}
   504 		}
   541 	};
   505 	};
   542 
   506 
   543 	/**
   507 	/**
   552 				GetParam(ForceType<Targ2>(), vm, 3),
   516 				GetParam(ForceType<Targ2>(), vm, 3),
   553 				GetParam(ForceType<Targ3>(), vm, 4),
   517 				GetParam(ForceType<Targ3>(), vm, 4),
   554 				GetParam(ForceType<Targ4>(), vm, 5),
   518 				GetParam(ForceType<Targ4>(), vm, 5),
   555 				GetParam(ForceType<Targ5>(), vm, 6)
   519 				GetParam(ForceType<Targ5>(), vm, 6)
   556 			);
   520 			);
   557 			sq_remove(vm, 2);
   521 			sq_pop(vm, 5);
   558 			sq_remove(vm, 3);
       
   559 			sq_remove(vm, 4);
       
   560 			sq_remove(vm, 5);
       
   561 			sq_remove(vm, 6);
       
   562 			return 0;
   522 			return 0;
   563 		}
   523 		}
   564 
   524 
   565 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
   525 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
   566 		{
   526 		{
   598 		sq_pushroottable(vm);
   558 		sq_pushroottable(vm);
   599 		sq_pushstring(vm, OTTD2FS(Tcls::GetClassName()), -1);
   559 		sq_pushstring(vm, OTTD2FS(Tcls::GetClassName()), -1);
   600 		sq_get(vm, -2);
   560 		sq_get(vm, -2);
   601 		sq_pushobject(vm, instance);
   561 		sq_pushobject(vm, instance);
   602 		if (sq_instanceof(vm) != SQTrue) return sq_throwerror(vm, _SC("class method is non-static"));
   562 		if (sq_instanceof(vm) != SQTrue) return sq_throwerror(vm, _SC("class method is non-static"));
   603 		sq_settop(vm, nparam);
   563 		sq_pop(vm, 3);
   604 
   564 
   605 		/* Get the 'real' instance of this class */
   565 		/* Get the 'real' instance of this class */
   606 		sq_getinstanceup(vm, 1, &real_instance, 0);
   566 		sq_getinstanceup(vm, 1, &real_instance, 0);
   607 		/* Get the real function pointer */
   567 		/* Get the real function pointer */
   608 		sq_getuserdata(vm, nparam, &ptr, 0);
   568 		sq_getuserdata(vm, nparam, &ptr, 0);
   609 		if (real_instance == NULL) return sq_throwerror(vm, _SC("couldn't detect real instance of class for non-static call"));
   569 		if (real_instance == NULL) return sq_throwerror(vm, _SC("couldn't detect real instance of class for non-static call"));
       
   570 		/* Remove the userdata from the stack */
       
   571 		sq_pop(vm, 1);
   610 
   572 
   611 		/* Delegate it to a template that can handle this specific function */
   573 		/* Delegate it to a template that can handle this specific function */
   612 		return HelperT<Tmethod>::SQCall((Tcls *)real_instance, *(Tmethod *)ptr, vm);
   574 		return HelperT<Tmethod>::SQCall((Tcls *)real_instance, *(Tmethod *)ptr, vm);
       
   575 	}
       
   576 
       
   577 	/**
       
   578 	 * A general template for all non-static advanced method callbacks from Squirrel.
       
   579 	 *  In here the function_proc is recovered, and the SQCall is called that
       
   580 	 *  can handle this exact amount of params.
       
   581 	 */
       
   582 	template <typename Tcls, typename Tmethod>
       
   583 	inline SQInteger DefSQAdvancedNonStaticCallback(HSQUIRRELVM vm)
       
   584 	{
       
   585 		/* Find the amount of params we got */
       
   586 		int nparam = sq_gettop(vm);
       
   587 		SQUserPointer ptr = NULL;
       
   588 		SQUserPointer real_instance = NULL;
       
   589 		HSQOBJECT instance;
       
   590 
       
   591 		/* Get the 'SQ' instance of this class */
       
   592 		Squirrel::GetInstance(vm, &instance);
       
   593 
       
   594 		/* Protect against calls to a non-static method in a static way */
       
   595 		sq_pushroottable(vm);
       
   596 		sq_pushstring(vm, OTTD2FS(Tcls::GetClassName()), -1);
       
   597 		sq_get(vm, -2);
       
   598 		sq_pushobject(vm, instance);
       
   599 		if (sq_instanceof(vm) != SQTrue) return sq_throwerror(vm, _SC("class method is non-static"));
       
   600 		sq_pop(vm, 3);
       
   601 
       
   602 		/* Get the 'real' instance of this class */
       
   603 		sq_getinstanceup(vm, 1, &real_instance, 0);
       
   604 		/* Get the real function pointer */
       
   605 		sq_getuserdata(vm, nparam, &ptr, 0);
       
   606 		if (real_instance == NULL) return sq_throwerror(vm, _SC("couldn't detect real instance of class for non-static call"));
       
   607 		/* Remove the userdata from the stack */
       
   608 		sq_pop(vm, 1);
       
   609 
       
   610 		/* Call the function, which its only param is always the VM */
       
   611 		return (SQInteger)(((Tcls *)real_instance)->*(*(Tmethod *)ptr))(vm);
   613 	}
   612 	}
   614 
   613 
   615 	/**
   614 	/**
   616 	 * A general template for all function/static method callbacks from Squirrel.
   615 	 * A general template for all function/static method callbacks from Squirrel.
   617 	 *  In here the function_proc is recovered, and the SQCall is called that
   616 	 *  In here the function_proc is recovered, and the SQCall is called that