variant_op.h 66 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556
  1. /**************************************************************************/
  2. /* variant_op.h */
  3. /**************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /**************************************************************************/
  8. /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
  9. /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /**************************************************************************/
  30. #pragma once
  31. #include "variant.h"
  32. #include "core/debugger/engine_debugger.h"
  33. #include "core/object/class_db.h"
  34. template <typename R, typename A, typename B>
  35. class OperatorEvaluatorAdd {
  36. public:
  37. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  38. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  39. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  40. *r_ret = a + b;
  41. r_valid = true;
  42. }
  43. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  44. *VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) + *VariantGetInternalPtr<B>::get_ptr(right);
  45. }
  46. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  47. PtrToArg<R>::encode(PtrToArg<A>::convert(left) + PtrToArg<B>::convert(right), r_ret);
  48. }
  49. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  50. };
  51. template <typename R, typename A, typename B>
  52. class OperatorEvaluatorSub {
  53. public:
  54. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  55. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  56. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  57. *r_ret = a - b;
  58. r_valid = true;
  59. }
  60. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  61. *VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) - *VariantGetInternalPtr<B>::get_ptr(right);
  62. }
  63. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  64. PtrToArg<R>::encode(PtrToArg<A>::convert(left) - PtrToArg<B>::convert(right), r_ret);
  65. }
  66. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  67. };
  68. template <typename R, typename A, typename B>
  69. class OperatorEvaluatorMul {
  70. public:
  71. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  72. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  73. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  74. *r_ret = a * b;
  75. r_valid = true;
  76. }
  77. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  78. *VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) * *VariantGetInternalPtr<B>::get_ptr(right);
  79. }
  80. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  81. PtrToArg<R>::encode(PtrToArg<A>::convert(left) * PtrToArg<B>::convert(right), r_ret);
  82. }
  83. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  84. };
  85. template <typename R, typename A, typename B>
  86. class OperatorEvaluatorPow {
  87. public:
  88. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  89. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  90. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  91. *r_ret = R(Math::pow((double)a, (double)b));
  92. r_valid = true;
  93. }
  94. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  95. *VariantGetInternalPtr<R>::get_ptr(r_ret) = R(Math::pow((double)*VariantGetInternalPtr<A>::get_ptr(left), (double)*VariantGetInternalPtr<B>::get_ptr(right)));
  96. }
  97. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  98. PtrToArg<R>::encode(R(Math::pow((double)PtrToArg<A>::convert(left), (double)PtrToArg<B>::convert(right))), r_ret);
  99. }
  100. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  101. };
  102. template <typename R, typename A, typename B>
  103. class OperatorEvaluatorXForm {
  104. public:
  105. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  106. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  107. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  108. *r_ret = a.xform(b);
  109. r_valid = true;
  110. }
  111. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  112. *VariantGetInternalPtr<R>::get_ptr(r_ret) = VariantGetInternalPtr<A>::get_ptr(left)->xform(*VariantGetInternalPtr<B>::get_ptr(right));
  113. }
  114. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  115. PtrToArg<R>::encode(PtrToArg<A>::convert(left).xform(PtrToArg<B>::convert(right)), r_ret);
  116. }
  117. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  118. };
  119. template <typename R, typename A, typename B>
  120. class OperatorEvaluatorXFormInv {
  121. public:
  122. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  123. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  124. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  125. *r_ret = b.xform_inv(a);
  126. r_valid = true;
  127. }
  128. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  129. *VariantGetInternalPtr<R>::get_ptr(r_ret) = VariantGetInternalPtr<B>::get_ptr(right)->xform_inv(*VariantGetInternalPtr<A>::get_ptr(left));
  130. }
  131. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  132. PtrToArg<R>::encode(PtrToArg<B>::convert(right).xform_inv(PtrToArg<A>::convert(left)), r_ret);
  133. }
  134. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  135. };
  136. template <typename R, typename A, typename B>
  137. class OperatorEvaluatorDiv {
  138. public:
  139. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  140. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  141. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  142. *r_ret = a / b;
  143. r_valid = true;
  144. }
  145. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  146. *VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) / *VariantGetInternalPtr<B>::get_ptr(right);
  147. }
  148. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  149. PtrToArg<R>::encode(PtrToArg<A>::convert(left) / PtrToArg<B>::convert(right), r_ret);
  150. }
  151. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  152. };
  153. template <typename R, typename A, typename B>
  154. class OperatorEvaluatorDivNZ {
  155. public:
  156. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  157. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  158. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  159. if (b == 0) {
  160. r_valid = false;
  161. *r_ret = "Division by zero error";
  162. return;
  163. }
  164. *r_ret = a / b;
  165. r_valid = true;
  166. }
  167. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  168. *VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) / *VariantGetInternalPtr<B>::get_ptr(right);
  169. }
  170. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  171. PtrToArg<R>::encode(PtrToArg<A>::convert(left) / PtrToArg<B>::convert(right), r_ret);
  172. }
  173. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  174. };
  175. template <>
  176. class OperatorEvaluatorDivNZ<Vector2i, Vector2i, Vector2i> {
  177. public:
  178. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  179. const Vector2i &a = *VariantGetInternalPtr<Vector2i>::get_ptr(&p_left);
  180. const Vector2i &b = *VariantGetInternalPtr<Vector2i>::get_ptr(&p_right);
  181. if (unlikely(b.x == 0 || b.y == 0)) {
  182. r_valid = false;
  183. *r_ret = "Division by zero error";
  184. return;
  185. }
  186. *r_ret = a / b;
  187. r_valid = true;
  188. }
  189. static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  190. VariantTypeChanger<Vector2i>::change(r_ret);
  191. *VariantGetInternalPtr<Vector2i>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector2i>::get_ptr(left) / *VariantGetInternalPtr<Vector2i>::get_ptr(right);
  192. }
  193. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  194. PtrToArg<Vector2i>::encode(PtrToArg<Vector2i>::convert(left) / PtrToArg<Vector2i>::convert(right), r_ret);
  195. }
  196. static Variant::Type get_return_type() { return GetTypeInfo<Vector2i>::VARIANT_TYPE; }
  197. };
  198. template <>
  199. class OperatorEvaluatorDivNZ<Vector3i, Vector3i, Vector3i> {
  200. public:
  201. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  202. const Vector3i &a = *VariantGetInternalPtr<Vector3i>::get_ptr(&p_left);
  203. const Vector3i &b = *VariantGetInternalPtr<Vector3i>::get_ptr(&p_right);
  204. if (unlikely(b.x == 0 || b.y == 0 || b.z == 0)) {
  205. r_valid = false;
  206. *r_ret = "Division by zero error";
  207. return;
  208. }
  209. *r_ret = a / b;
  210. r_valid = true;
  211. }
  212. static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  213. VariantTypeChanger<Vector3i>::change(r_ret);
  214. *VariantGetInternalPtr<Vector3i>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector3i>::get_ptr(left) / *VariantGetInternalPtr<Vector3i>::get_ptr(right);
  215. }
  216. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  217. PtrToArg<Vector3i>::encode(PtrToArg<Vector3i>::convert(left) / PtrToArg<Vector3i>::convert(right), r_ret);
  218. }
  219. static Variant::Type get_return_type() { return GetTypeInfo<Vector3i>::VARIANT_TYPE; }
  220. };
  221. template <>
  222. class OperatorEvaluatorDivNZ<Vector4i, Vector4i, Vector4i> {
  223. public:
  224. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  225. const Vector4i &a = *VariantGetInternalPtr<Vector4i>::get_ptr(&p_left);
  226. const Vector4i &b = *VariantGetInternalPtr<Vector4i>::get_ptr(&p_right);
  227. if (unlikely(b.x == 0 || b.y == 0 || b.z == 0 || b.w == 0)) {
  228. r_valid = false;
  229. *r_ret = "Division by zero error";
  230. return;
  231. }
  232. *r_ret = a / b;
  233. r_valid = true;
  234. }
  235. static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  236. VariantTypeChanger<Vector4i>::change(r_ret);
  237. *VariantGetInternalPtr<Vector4i>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector4i>::get_ptr(left) / *VariantGetInternalPtr<Vector4i>::get_ptr(right);
  238. }
  239. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  240. PtrToArg<Vector4i>::encode(PtrToArg<Vector4i>::convert(left) / PtrToArg<Vector4i>::convert(right), r_ret);
  241. }
  242. static Variant::Type get_return_type() { return GetTypeInfo<Vector4i>::VARIANT_TYPE; }
  243. };
  244. template <typename R, typename A, typename B>
  245. class OperatorEvaluatorMod {
  246. public:
  247. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  248. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  249. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  250. *r_ret = a % b;
  251. r_valid = true;
  252. }
  253. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  254. *VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) % *VariantGetInternalPtr<B>::get_ptr(right);
  255. }
  256. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  257. PtrToArg<R>::encode(PtrToArg<A>::convert(left) % PtrToArg<B>::convert(right), r_ret);
  258. }
  259. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  260. };
  261. template <typename R, typename A, typename B>
  262. class OperatorEvaluatorModNZ {
  263. public:
  264. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  265. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  266. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  267. if (b == 0) {
  268. r_valid = false;
  269. *r_ret = "Modulo by zero error";
  270. return;
  271. }
  272. *r_ret = a % b;
  273. r_valid = true;
  274. }
  275. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  276. *VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) % *VariantGetInternalPtr<B>::get_ptr(right);
  277. }
  278. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  279. PtrToArg<R>::encode(PtrToArg<A>::convert(left) % PtrToArg<B>::convert(right), r_ret);
  280. }
  281. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  282. };
  283. template <>
  284. class OperatorEvaluatorModNZ<Vector2i, Vector2i, Vector2i> {
  285. public:
  286. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  287. const Vector2i &a = *VariantGetInternalPtr<Vector2i>::get_ptr(&p_left);
  288. const Vector2i &b = *VariantGetInternalPtr<Vector2i>::get_ptr(&p_right);
  289. if (unlikely(b.x == 0 || b.y == 0)) {
  290. r_valid = false;
  291. *r_ret = "Modulo by zero error";
  292. return;
  293. }
  294. *r_ret = a % b;
  295. r_valid = true;
  296. }
  297. static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  298. VariantTypeChanger<Vector2i>::change(r_ret);
  299. *VariantGetInternalPtr<Vector2i>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector2i>::get_ptr(left) % *VariantGetInternalPtr<Vector2i>::get_ptr(right);
  300. }
  301. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  302. PtrToArg<Vector2i>::encode(PtrToArg<Vector2i>::convert(left) % PtrToArg<Vector2i>::convert(right), r_ret);
  303. }
  304. static Variant::Type get_return_type() { return GetTypeInfo<Vector2i>::VARIANT_TYPE; }
  305. };
  306. template <>
  307. class OperatorEvaluatorModNZ<Vector3i, Vector3i, Vector3i> {
  308. public:
  309. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  310. const Vector3i &a = *VariantGetInternalPtr<Vector3i>::get_ptr(&p_left);
  311. const Vector3i &b = *VariantGetInternalPtr<Vector3i>::get_ptr(&p_right);
  312. if (unlikely(b.x == 0 || b.y == 0 || b.z == 0)) {
  313. r_valid = false;
  314. *r_ret = "Modulo by zero error";
  315. return;
  316. }
  317. *r_ret = a % b;
  318. r_valid = true;
  319. }
  320. static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  321. VariantTypeChanger<Vector3i>::change(r_ret);
  322. *VariantGetInternalPtr<Vector3i>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector3i>::get_ptr(left) % *VariantGetInternalPtr<Vector3i>::get_ptr(right);
  323. }
  324. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  325. PtrToArg<Vector3i>::encode(PtrToArg<Vector3i>::convert(left) % PtrToArg<Vector3i>::convert(right), r_ret);
  326. }
  327. static Variant::Type get_return_type() { return GetTypeInfo<Vector3i>::VARIANT_TYPE; }
  328. };
  329. template <>
  330. class OperatorEvaluatorModNZ<Vector4i, Vector4i, Vector4i> {
  331. public:
  332. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  333. const Vector4i &a = *VariantGetInternalPtr<Vector4i>::get_ptr(&p_left);
  334. const Vector4i &b = *VariantGetInternalPtr<Vector4i>::get_ptr(&p_right);
  335. if (unlikely(b.x == 0 || b.y == 0 || b.z == 0 || b.w == 0)) {
  336. r_valid = false;
  337. *r_ret = "Modulo by zero error";
  338. return;
  339. }
  340. *r_ret = a % b;
  341. r_valid = true;
  342. }
  343. static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  344. VariantTypeChanger<Vector4i>::change(r_ret);
  345. *VariantGetInternalPtr<Vector4i>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector4i>::get_ptr(left) % *VariantGetInternalPtr<Vector4i>::get_ptr(right);
  346. }
  347. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  348. PtrToArg<Vector4i>::encode(PtrToArg<Vector4i>::convert(left) % PtrToArg<Vector4i>::convert(right), r_ret);
  349. }
  350. static Variant::Type get_return_type() { return GetTypeInfo<Vector4i>::VARIANT_TYPE; }
  351. };
  352. template <typename R, typename A>
  353. class OperatorEvaluatorNeg {
  354. public:
  355. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  356. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  357. *r_ret = -a;
  358. r_valid = true;
  359. }
  360. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  361. *VariantGetInternalPtr<R>::get_ptr(r_ret) = -*VariantGetInternalPtr<A>::get_ptr(left);
  362. }
  363. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  364. PtrToArg<R>::encode(-PtrToArg<A>::convert(left), r_ret);
  365. }
  366. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  367. };
  368. template <typename R, typename A>
  369. class OperatorEvaluatorPos {
  370. public:
  371. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  372. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  373. *r_ret = a;
  374. r_valid = true;
  375. }
  376. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  377. *VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left);
  378. }
  379. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  380. PtrToArg<R>::encode(PtrToArg<A>::convert(left), r_ret);
  381. }
  382. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  383. };
  384. template <typename R, typename A, typename B>
  385. class OperatorEvaluatorShiftLeft {
  386. public:
  387. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  388. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  389. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  390. #if defined(DEBUG_ENABLED)
  391. if (b < 0 || a < 0) {
  392. *r_ret = "Invalid operands for bit shifting. Only positive operands are supported.";
  393. r_valid = false;
  394. return;
  395. }
  396. #endif
  397. *r_ret = a << b;
  398. r_valid = true;
  399. }
  400. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  401. *VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) << *VariantGetInternalPtr<B>::get_ptr(right);
  402. }
  403. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  404. PtrToArg<R>::encode(PtrToArg<A>::convert(left) << PtrToArg<B>::convert(right), r_ret);
  405. }
  406. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  407. };
  408. template <typename R, typename A, typename B>
  409. class OperatorEvaluatorShiftRight {
  410. public:
  411. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  412. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  413. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  414. #if defined(DEBUG_ENABLED)
  415. if (b < 0 || a < 0) {
  416. *r_ret = "Invalid operands for bit shifting. Only positive operands are supported.";
  417. r_valid = false;
  418. return;
  419. }
  420. #endif
  421. *r_ret = a >> b;
  422. r_valid = true;
  423. }
  424. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  425. *VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) >> *VariantGetInternalPtr<B>::get_ptr(right);
  426. }
  427. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  428. PtrToArg<R>::encode(PtrToArg<A>::convert(left) >> PtrToArg<B>::convert(right), r_ret);
  429. }
  430. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  431. };
  432. template <typename R, typename A, typename B>
  433. class OperatorEvaluatorBitOr {
  434. public:
  435. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  436. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  437. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  438. *r_ret = a | b;
  439. r_valid = true;
  440. }
  441. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  442. *VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) | *VariantGetInternalPtr<B>::get_ptr(right);
  443. }
  444. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  445. PtrToArg<R>::encode(PtrToArg<A>::convert(left) | PtrToArg<B>::convert(right), r_ret);
  446. }
  447. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  448. };
  449. template <typename R, typename A, typename B>
  450. class OperatorEvaluatorBitAnd {
  451. public:
  452. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  453. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  454. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  455. *r_ret = a & b;
  456. r_valid = true;
  457. }
  458. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  459. *VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) & *VariantGetInternalPtr<B>::get_ptr(right);
  460. }
  461. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  462. PtrToArg<R>::encode(PtrToArg<A>::convert(left) & PtrToArg<B>::convert(right), r_ret);
  463. }
  464. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  465. };
  466. template <typename R, typename A, typename B>
  467. class OperatorEvaluatorBitXor {
  468. public:
  469. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  470. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  471. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  472. *r_ret = a ^ b;
  473. r_valid = true;
  474. }
  475. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  476. *VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) ^ *VariantGetInternalPtr<B>::get_ptr(right);
  477. }
  478. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  479. PtrToArg<R>::encode(PtrToArg<A>::convert(left) ^ PtrToArg<B>::convert(right), r_ret);
  480. }
  481. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  482. };
  483. template <typename R, typename A>
  484. class OperatorEvaluatorBitNeg {
  485. public:
  486. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  487. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  488. *r_ret = ~a;
  489. r_valid = true;
  490. }
  491. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  492. *VariantGetInternalPtr<R>::get_ptr(r_ret) = ~*VariantGetInternalPtr<A>::get_ptr(left);
  493. }
  494. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  495. PtrToArg<R>::encode(~PtrToArg<A>::convert(left), r_ret);
  496. }
  497. static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
  498. };
  499. template <typename A, typename B>
  500. class OperatorEvaluatorEqual {
  501. public:
  502. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  503. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  504. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  505. *r_ret = a == b;
  506. r_valid = true;
  507. }
  508. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  509. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) == *VariantGetInternalPtr<B>::get_ptr(right);
  510. }
  511. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  512. PtrToArg<bool>::encode(PtrToArg<A>::convert(left) == PtrToArg<B>::convert(right), r_ret);
  513. }
  514. static Variant::Type get_return_type() { return Variant::BOOL; }
  515. };
  516. class OperatorEvaluatorEqualObject {
  517. public:
  518. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  519. const Object *a = p_left.get_validated_object();
  520. const Object *b = p_right.get_validated_object();
  521. *r_ret = a == b;
  522. r_valid = true;
  523. }
  524. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  525. const Object *a = left->get_validated_object();
  526. const Object *b = right->get_validated_object();
  527. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = a == b;
  528. }
  529. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  530. PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == PtrToArg<Object *>::convert(right), r_ret);
  531. }
  532. static Variant::Type get_return_type() { return Variant::BOOL; }
  533. };
  534. class OperatorEvaluatorEqualObjectNil {
  535. public:
  536. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  537. const Object *a = p_left.get_validated_object();
  538. *r_ret = a == nullptr;
  539. r_valid = true;
  540. }
  541. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  542. const Object *a = left->get_validated_object();
  543. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = a == nullptr;
  544. }
  545. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  546. PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == nullptr, r_ret);
  547. }
  548. static Variant::Type get_return_type() { return Variant::BOOL; }
  549. };
  550. class OperatorEvaluatorEqualNilObject {
  551. public:
  552. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  553. const Object *b = p_right.get_validated_object();
  554. *r_ret = nullptr == b;
  555. r_valid = true;
  556. }
  557. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  558. const Object *b = right->get_validated_object();
  559. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = nullptr == b;
  560. }
  561. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  562. PtrToArg<bool>::encode(nullptr == PtrToArg<Object *>::convert(right), r_ret);
  563. }
  564. static Variant::Type get_return_type() { return Variant::BOOL; }
  565. };
  566. template <typename A, typename B>
  567. class OperatorEvaluatorNotEqual {
  568. public:
  569. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  570. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  571. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  572. *r_ret = a != b;
  573. r_valid = true;
  574. }
  575. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  576. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) != *VariantGetInternalPtr<B>::get_ptr(right);
  577. }
  578. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  579. PtrToArg<bool>::encode(PtrToArg<A>::convert(left) != PtrToArg<B>::convert(right), r_ret);
  580. }
  581. static Variant::Type get_return_type() { return Variant::BOOL; }
  582. };
  583. class OperatorEvaluatorNotEqualObject {
  584. public:
  585. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  586. Object *a = p_left.get_validated_object();
  587. Object *b = p_right.get_validated_object();
  588. *r_ret = a != b;
  589. r_valid = true;
  590. }
  591. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  592. Object *a = left->get_validated_object();
  593. Object *b = right->get_validated_object();
  594. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = a != b;
  595. }
  596. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  597. PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) != PtrToArg<Object *>::convert(right), r_ret);
  598. }
  599. static Variant::Type get_return_type() { return Variant::BOOL; }
  600. };
  601. class OperatorEvaluatorNotEqualObjectNil {
  602. public:
  603. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  604. Object *a = p_left.get_validated_object();
  605. *r_ret = a != nullptr;
  606. r_valid = true;
  607. }
  608. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  609. Object *a = left->get_validated_object();
  610. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = a != nullptr;
  611. }
  612. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  613. PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) != nullptr, r_ret);
  614. }
  615. static Variant::Type get_return_type() { return Variant::BOOL; }
  616. };
  617. class OperatorEvaluatorNotEqualNilObject {
  618. public:
  619. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  620. Object *b = p_right.get_validated_object();
  621. *r_ret = nullptr != b;
  622. r_valid = true;
  623. }
  624. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  625. Object *b = right->get_validated_object();
  626. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = nullptr != b;
  627. }
  628. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  629. PtrToArg<bool>::encode(nullptr != PtrToArg<Object *>::convert(right), r_ret);
  630. }
  631. static Variant::Type get_return_type() { return Variant::BOOL; }
  632. };
  633. template <typename A, typename B>
  634. class OperatorEvaluatorLess {
  635. public:
  636. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  637. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  638. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  639. *r_ret = a < b;
  640. r_valid = true;
  641. }
  642. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  643. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) < *VariantGetInternalPtr<B>::get_ptr(right);
  644. }
  645. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  646. PtrToArg<bool>::encode(PtrToArg<A>::convert(left) < PtrToArg<B>::convert(right), r_ret);
  647. }
  648. static Variant::Type get_return_type() { return Variant::BOOL; }
  649. };
  650. template <typename A, typename B>
  651. class OperatorEvaluatorLessEqual {
  652. public:
  653. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  654. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  655. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  656. *r_ret = a <= b;
  657. r_valid = true;
  658. }
  659. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  660. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) <= *VariantGetInternalPtr<B>::get_ptr(right);
  661. }
  662. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  663. PtrToArg<bool>::encode(PtrToArg<A>::convert(left) <= PtrToArg<B>::convert(right), r_ret);
  664. }
  665. static Variant::Type get_return_type() { return Variant::BOOL; }
  666. };
  667. template <typename A, typename B>
  668. class OperatorEvaluatorGreater {
  669. public:
  670. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  671. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  672. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  673. *r_ret = a > b;
  674. r_valid = true;
  675. }
  676. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  677. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) > *VariantGetInternalPtr<B>::get_ptr(right);
  678. }
  679. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  680. PtrToArg<bool>::encode(PtrToArg<A>::convert(left) > PtrToArg<B>::convert(right), r_ret);
  681. }
  682. static Variant::Type get_return_type() { return Variant::BOOL; }
  683. };
  684. template <typename A, typename B>
  685. class OperatorEvaluatorGreaterEqual {
  686. public:
  687. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  688. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  689. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  690. *r_ret = a >= b;
  691. r_valid = true;
  692. }
  693. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  694. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) >= *VariantGetInternalPtr<B>::get_ptr(right);
  695. }
  696. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  697. PtrToArg<bool>::encode(PtrToArg<A>::convert(left) >= PtrToArg<B>::convert(right), r_ret);
  698. }
  699. static Variant::Type get_return_type() { return Variant::BOOL; }
  700. };
  701. template <typename A, typename B>
  702. class OperatorEvaluatorAnd {
  703. public:
  704. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  705. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  706. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  707. *r_ret = a && b;
  708. r_valid = true;
  709. }
  710. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  711. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) && *VariantGetInternalPtr<B>::get_ptr(right);
  712. }
  713. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  714. PtrToArg<bool>::encode(PtrToArg<A>::convert(left) && PtrToArg<B>::convert(right), r_ret);
  715. }
  716. static Variant::Type get_return_type() { return Variant::BOOL; }
  717. };
  718. template <typename A, typename B>
  719. class OperatorEvaluatorOr {
  720. public:
  721. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  722. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  723. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  724. *r_ret = a || b;
  725. r_valid = true;
  726. }
  727. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  728. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) || *VariantGetInternalPtr<B>::get_ptr(right);
  729. }
  730. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  731. PtrToArg<bool>::encode(PtrToArg<A>::convert(left) || PtrToArg<B>::convert(right), r_ret);
  732. }
  733. static Variant::Type get_return_type() { return Variant::BOOL; }
  734. };
  735. #define XOR_OP(m_a, m_b) (((m_a) || (m_b)) && !((m_a) && (m_b)))
  736. template <typename A, typename B>
  737. class OperatorEvaluatorXor {
  738. public:
  739. _FORCE_INLINE_ static bool xor_op(const A &a, const B &b) {
  740. return ((a) || (b)) && !((a) && (b));
  741. }
  742. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  743. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  744. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  745. *r_ret = xor_op(a, b);
  746. r_valid = true;
  747. }
  748. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  749. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = xor_op(*VariantGetInternalPtr<A>::get_ptr(left), *VariantGetInternalPtr<B>::get_ptr(right));
  750. }
  751. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  752. PtrToArg<bool>::encode(xor_op(PtrToArg<A>::convert(left), PtrToArg<B>::convert(right)), r_ret);
  753. }
  754. static Variant::Type get_return_type() { return Variant::BOOL; }
  755. };
  756. template <typename A>
  757. class OperatorEvaluatorNot {
  758. public:
  759. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  760. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  761. *r_ret = a == A();
  762. r_valid = true;
  763. }
  764. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  765. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) == A();
  766. }
  767. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  768. PtrToArg<bool>::encode(PtrToArg<A>::convert(left) == A(), r_ret);
  769. }
  770. static Variant::Type get_return_type() { return Variant::BOOL; }
  771. };
  772. //// CUSTOM ////
  773. class OperatorEvaluatorAddArray {
  774. public:
  775. _FORCE_INLINE_ static void _add_arrays(Array &sum, const Array &array_a, const Array &array_b) {
  776. int asize = array_a.size();
  777. int bsize = array_b.size();
  778. if (array_a.is_typed() && array_a.is_same_typed(array_b)) {
  779. sum.set_typed(array_a.get_typed_builtin(), array_a.get_typed_class_name(), array_a.get_typed_script());
  780. }
  781. sum.resize(asize + bsize);
  782. for (int i = 0; i < asize; i++) {
  783. sum[i] = array_a[i];
  784. }
  785. for (int i = 0; i < bsize; i++) {
  786. sum[i + asize] = array_b[i];
  787. }
  788. }
  789. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  790. const Array &array_a = *VariantGetInternalPtr<Array>::get_ptr(&p_left);
  791. const Array &array_b = *VariantGetInternalPtr<Array>::get_ptr(&p_right);
  792. Array sum;
  793. _add_arrays(sum, array_a, array_b);
  794. *r_ret = sum;
  795. r_valid = true;
  796. }
  797. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  798. *r_ret = Array();
  799. _add_arrays(*VariantGetInternalPtr<Array>::get_ptr(r_ret), *VariantGetInternalPtr<Array>::get_ptr(left), *VariantGetInternalPtr<Array>::get_ptr(right));
  800. }
  801. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  802. Array ret;
  803. _add_arrays(ret, PtrToArg<Array>::convert(left), PtrToArg<Array>::convert(right));
  804. PtrToArg<Array>::encode(ret, r_ret);
  805. }
  806. static Variant::Type get_return_type() { return Variant::ARRAY; }
  807. };
  808. template <typename T>
  809. class OperatorEvaluatorAppendArray {
  810. public:
  811. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  812. const Vector<T> &array_a = *VariantGetInternalPtr<Vector<T>>::get_ptr(&p_left);
  813. const Vector<T> &array_b = *VariantGetInternalPtr<Vector<T>>::get_ptr(&p_right);
  814. Vector<T> sum = array_a;
  815. sum.append_array(array_b);
  816. *r_ret = sum;
  817. r_valid = true;
  818. }
  819. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  820. *VariantGetInternalPtr<Vector<T>>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector<T>>::get_ptr(left);
  821. VariantGetInternalPtr<Vector<T>>::get_ptr(r_ret)->append_array(*VariantGetInternalPtr<Vector<T>>::get_ptr(right));
  822. }
  823. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  824. Vector<T> sum = PtrToArg<Vector<T>>::convert(left);
  825. sum.append_array(PtrToArg<Vector<T>>::convert(right));
  826. PtrToArg<Vector<T>>::encode(sum, r_ret);
  827. }
  828. static Variant::Type get_return_type() { return GetTypeInfo<Vector<T>>::VARIANT_TYPE; }
  829. };
  830. template <typename Left, typename Right>
  831. class OperatorEvaluatorStringConcat {
  832. public:
  833. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  834. const String a(*VariantGetInternalPtr<Left>::get_ptr(&p_left));
  835. const String b(*VariantGetInternalPtr<Right>::get_ptr(&p_right));
  836. *r_ret = a + b;
  837. r_valid = true;
  838. }
  839. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  840. const String a(*VariantGetInternalPtr<Left>::get_ptr(left));
  841. const String b(*VariantGetInternalPtr<Right>::get_ptr(right));
  842. *VariantGetInternalPtr<String>::get_ptr(r_ret) = a + b;
  843. }
  844. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  845. const String a(PtrToArg<Left>::convert(left));
  846. const String b(PtrToArg<Right>::convert(right));
  847. PtrToArg<String>::encode(a + b, r_ret);
  848. }
  849. static Variant::Type get_return_type() { return Variant::STRING; }
  850. };
  851. template <typename S, typename T>
  852. class OperatorEvaluatorStringFormat;
  853. template <typename S>
  854. class OperatorEvaluatorStringFormat<S, void> {
  855. public:
  856. _FORCE_INLINE_ static String do_mod(const String &s, bool *r_valid) {
  857. Array values = { Variant() };
  858. String a = s.sprintf(values, r_valid);
  859. if (r_valid) {
  860. *r_valid = !*r_valid;
  861. }
  862. return a;
  863. }
  864. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  865. *r_ret = do_mod(*VariantGetInternalPtr<S>::get_ptr(&p_left), &r_valid);
  866. }
  867. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  868. bool valid = true;
  869. String result = do_mod(*VariantGetInternalPtr<S>::get_ptr(left), &valid);
  870. if (unlikely(!valid)) {
  871. *VariantGetInternalPtr<String>::get_ptr(r_ret) = *VariantGetInternalPtr<S>::get_ptr(left);
  872. ERR_FAIL_MSG(vformat("String formatting error: %s.", result));
  873. }
  874. *VariantGetInternalPtr<String>::get_ptr(r_ret) = result;
  875. }
  876. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  877. PtrToArg<String>::encode(do_mod(PtrToArg<S>::convert(left), nullptr), r_ret);
  878. }
  879. static Variant::Type get_return_type() { return Variant::STRING; }
  880. };
  881. template <typename S>
  882. class OperatorEvaluatorStringFormat<S, Array> {
  883. public:
  884. _FORCE_INLINE_ static String do_mod(const String &s, const Array &p_values, bool *r_valid) {
  885. String a = s.sprintf(p_values, r_valid);
  886. if (r_valid) {
  887. *r_valid = !*r_valid;
  888. }
  889. return a;
  890. }
  891. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  892. *r_ret = do_mod(*VariantGetInternalPtr<S>::get_ptr(&p_left), *VariantGetInternalPtr<Array>::get_ptr(&p_right), &r_valid);
  893. }
  894. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  895. bool valid = true;
  896. String result = do_mod(*VariantGetInternalPtr<S>::get_ptr(left), *VariantGetInternalPtr<Array>::get_ptr(right), &valid);
  897. if (unlikely(!valid)) {
  898. *VariantGetInternalPtr<String>::get_ptr(r_ret) = *VariantGetInternalPtr<S>::get_ptr(left);
  899. ERR_FAIL_MSG(vformat("String formatting error: %s.", result));
  900. }
  901. *VariantGetInternalPtr<String>::get_ptr(r_ret) = result;
  902. }
  903. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  904. PtrToArg<String>::encode(do_mod(PtrToArg<S>::convert(left), PtrToArg<Array>::convert(right), nullptr), r_ret);
  905. }
  906. static Variant::Type get_return_type() { return Variant::STRING; }
  907. };
  908. template <typename S>
  909. class OperatorEvaluatorStringFormat<S, Object> {
  910. public:
  911. _FORCE_INLINE_ static String do_mod(const String &s, const Object *p_object, bool *r_valid) {
  912. Array values = { p_object };
  913. String a = s.sprintf(values, r_valid);
  914. if (r_valid) {
  915. *r_valid = !*r_valid;
  916. }
  917. return a;
  918. }
  919. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  920. *r_ret = do_mod(*VariantGetInternalPtr<S>::get_ptr(&p_left), p_right.get_validated_object(), &r_valid);
  921. }
  922. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  923. bool valid = true;
  924. String result = do_mod(*VariantGetInternalPtr<S>::get_ptr(left), right->get_validated_object(), &valid);
  925. if (unlikely(!valid)) {
  926. *VariantGetInternalPtr<String>::get_ptr(r_ret) = *VariantGetInternalPtr<S>::get_ptr(left);
  927. ERR_FAIL_MSG(vformat("String formatting error: %s.", result));
  928. }
  929. *VariantGetInternalPtr<String>::get_ptr(r_ret) = result;
  930. }
  931. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  932. PtrToArg<String>::encode(do_mod(PtrToArg<S>::convert(left), PtrToArg<Object *>::convert(right), nullptr), r_ret);
  933. }
  934. static Variant::Type get_return_type() { return Variant::STRING; }
  935. };
  936. template <typename S, typename T>
  937. class OperatorEvaluatorStringFormat {
  938. public:
  939. _FORCE_INLINE_ static String do_mod(const String &s, const T &p_value, bool *r_valid) {
  940. Array values = { p_value };
  941. String a = s.sprintf(values, r_valid);
  942. if (r_valid) {
  943. *r_valid = !*r_valid;
  944. }
  945. return a;
  946. }
  947. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  948. *r_ret = do_mod(*VariantGetInternalPtr<S>::get_ptr(&p_left), *VariantGetInternalPtr<T>::get_ptr(&p_right), &r_valid);
  949. }
  950. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  951. bool valid = true;
  952. String result = do_mod(*VariantGetInternalPtr<S>::get_ptr(left), *VariantGetInternalPtr<T>::get_ptr(right), &valid);
  953. if (unlikely(!valid)) {
  954. *VariantGetInternalPtr<String>::get_ptr(r_ret) = *VariantGetInternalPtr<S>::get_ptr(left);
  955. ERR_FAIL_MSG(vformat("String formatting error: %s.", result));
  956. }
  957. *VariantGetInternalPtr<String>::get_ptr(r_ret) = result;
  958. }
  959. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  960. PtrToArg<String>::encode(do_mod(PtrToArg<S>::convert(left), PtrToArg<T>::convert(right), nullptr), r_ret);
  961. }
  962. static Variant::Type get_return_type() { return Variant::STRING; }
  963. };
  964. template <Variant::Operator op, Variant::Type type_left, Variant::Type type_right>
  965. class OperatorEvaluatorAlwaysTrue {
  966. public:
  967. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  968. *r_ret = true;
  969. r_valid = true;
  970. }
  971. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  972. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = true;
  973. }
  974. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  975. PtrToArg<bool>::encode(true, r_ret);
  976. }
  977. static Variant::Type get_return_type() { return Variant::BOOL; }
  978. };
  979. template <Variant::Operator op, Variant::Type type_left, Variant::Type type_right>
  980. class OperatorEvaluatorAlwaysFalse {
  981. public:
  982. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  983. *r_ret = false;
  984. r_valid = true;
  985. }
  986. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  987. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = false;
  988. }
  989. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  990. PtrToArg<bool>::encode(false, r_ret);
  991. }
  992. static Variant::Type get_return_type() { return Variant::BOOL; }
  993. };
  994. ///// OR ///////
  995. _FORCE_INLINE_ static bool _operate_or(bool p_left, bool p_right) {
  996. return p_left || p_right;
  997. }
  998. _FORCE_INLINE_ static bool _operate_and(bool p_left, bool p_right) {
  999. return p_left && p_right;
  1000. }
  1001. _FORCE_INLINE_ static bool _operate_xor(bool p_left, bool p_right) {
  1002. return (p_left || p_right) && !(p_left && p_right);
  1003. }
  1004. _FORCE_INLINE_ static bool _operate_get_nil(const Variant *p_ptr) {
  1005. return p_ptr->get_validated_object() != nullptr;
  1006. }
  1007. _FORCE_INLINE_ static bool _operate_get_bool(const Variant *p_ptr) {
  1008. return *VariantGetInternalPtr<bool>::get_ptr(p_ptr);
  1009. }
  1010. _FORCE_INLINE_ static bool _operate_get_int(const Variant *p_ptr) {
  1011. return *VariantGetInternalPtr<int64_t>::get_ptr(p_ptr) != 0;
  1012. }
  1013. _FORCE_INLINE_ static bool _operate_get_float(const Variant *p_ptr) {
  1014. return *VariantGetInternalPtr<double>::get_ptr(p_ptr) != 0.0;
  1015. }
  1016. _FORCE_INLINE_ static bool _operate_get_object(const Variant *p_ptr) {
  1017. return p_ptr->get_validated_object() != nullptr;
  1018. }
  1019. _FORCE_INLINE_ static bool _operate_get_ptr_nil(const void *p_ptr) {
  1020. return false;
  1021. }
  1022. _FORCE_INLINE_ static bool _operate_get_ptr_bool(const void *p_ptr) {
  1023. return PtrToArg<bool>::convert(p_ptr);
  1024. }
  1025. _FORCE_INLINE_ static bool _operate_get_ptr_int(const void *p_ptr) {
  1026. return PtrToArg<int64_t>::convert(p_ptr) != 0;
  1027. }
  1028. _FORCE_INLINE_ static bool _operate_get_ptr_float(const void *p_ptr) {
  1029. return PtrToArg<double>::convert(p_ptr) != 0.0;
  1030. }
  1031. _FORCE_INLINE_ static bool _operate_get_ptr_object(const void *p_ptr) {
  1032. return PtrToArg<Object *>::convert(p_ptr) != nullptr;
  1033. }
  1034. #define OP_EVALUATOR(m_class_name, m_left, m_right, m_op) \
  1035. class m_class_name { \
  1036. public: \
  1037. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) { \
  1038. *r_ret = m_op(_operate_get_##m_left(&p_left), _operate_get_##m_right(&p_right)); \
  1039. r_valid = true; \
  1040. } \
  1041. \
  1042. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { \
  1043. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = m_op(_operate_get_##m_left(left), _operate_get_##m_right(right)); \
  1044. } \
  1045. \
  1046. static void ptr_evaluate(const void *left, const void *right, void *r_ret) { \
  1047. PtrToArg<bool>::encode(m_op(_operate_get_ptr_##m_left(left), _operate_get_ptr_##m_right(right)), r_ret); \
  1048. } \
  1049. \
  1050. static Variant::Type get_return_type() { \
  1051. return Variant::BOOL; \
  1052. } \
  1053. };
  1054. // OR
  1055. // nil
  1056. OP_EVALUATOR(OperatorEvaluatorNilXBoolOr, nil, bool, _operate_or)
  1057. OP_EVALUATOR(OperatorEvaluatorBoolXNilOr, bool, nil, _operate_or)
  1058. OP_EVALUATOR(OperatorEvaluatorNilXIntOr, nil, int, _operate_or)
  1059. OP_EVALUATOR(OperatorEvaluatorIntXNilOr, int, nil, _operate_or)
  1060. OP_EVALUATOR(OperatorEvaluatorNilXFloatOr, nil, float, _operate_or)
  1061. OP_EVALUATOR(OperatorEvaluatorFloatXNilOr, float, nil, _operate_or)
  1062. OP_EVALUATOR(OperatorEvaluatorObjectXNilOr, object, nil, _operate_or)
  1063. OP_EVALUATOR(OperatorEvaluatorNilXObjectOr, nil, object, _operate_or)
  1064. // bool
  1065. OP_EVALUATOR(OperatorEvaluatorBoolXBoolOr, bool, bool, _operate_or)
  1066. OP_EVALUATOR(OperatorEvaluatorBoolXIntOr, bool, int, _operate_or)
  1067. OP_EVALUATOR(OperatorEvaluatorIntXBoolOr, int, bool, _operate_or)
  1068. OP_EVALUATOR(OperatorEvaluatorBoolXFloatOr, bool, float, _operate_or)
  1069. OP_EVALUATOR(OperatorEvaluatorFloatXBoolOr, float, bool, _operate_or)
  1070. OP_EVALUATOR(OperatorEvaluatorBoolXObjectOr, bool, object, _operate_or)
  1071. OP_EVALUATOR(OperatorEvaluatorObjectXBoolOr, object, bool, _operate_or)
  1072. // int
  1073. OP_EVALUATOR(OperatorEvaluatorIntXIntOr, int, int, _operate_or)
  1074. OP_EVALUATOR(OperatorEvaluatorIntXFloatOr, int, float, _operate_or)
  1075. OP_EVALUATOR(OperatorEvaluatorFloatXIntOr, float, int, _operate_or)
  1076. OP_EVALUATOR(OperatorEvaluatorIntXObjectOr, int, object, _operate_or)
  1077. OP_EVALUATOR(OperatorEvaluatorObjectXIntOr, object, int, _operate_or)
  1078. // float
  1079. OP_EVALUATOR(OperatorEvaluatorFloatXFloatOr, float, float, _operate_or)
  1080. OP_EVALUATOR(OperatorEvaluatorFloatXObjectOr, float, object, _operate_or)
  1081. OP_EVALUATOR(OperatorEvaluatorObjectXFloatOr, object, float, _operate_or)
  1082. // object
  1083. OP_EVALUATOR(OperatorEvaluatorObjectXObjectOr, object, object, _operate_or)
  1084. // AND
  1085. // nil
  1086. OP_EVALUATOR(OperatorEvaluatorNilXBoolAnd, nil, bool, _operate_and)
  1087. OP_EVALUATOR(OperatorEvaluatorBoolXNilAnd, bool, nil, _operate_and)
  1088. OP_EVALUATOR(OperatorEvaluatorNilXIntAnd, nil, int, _operate_and)
  1089. OP_EVALUATOR(OperatorEvaluatorIntXNilAnd, int, nil, _operate_and)
  1090. OP_EVALUATOR(OperatorEvaluatorNilXFloatAnd, nil, float, _operate_and)
  1091. OP_EVALUATOR(OperatorEvaluatorFloatXNilAnd, float, nil, _operate_and)
  1092. OP_EVALUATOR(OperatorEvaluatorObjectXNilAnd, object, nil, _operate_and)
  1093. OP_EVALUATOR(OperatorEvaluatorNilXObjectAnd, nil, object, _operate_and)
  1094. // bool
  1095. OP_EVALUATOR(OperatorEvaluatorBoolXBoolAnd, bool, bool, _operate_and)
  1096. OP_EVALUATOR(OperatorEvaluatorBoolXIntAnd, bool, int, _operate_and)
  1097. OP_EVALUATOR(OperatorEvaluatorIntXBoolAnd, int, bool, _operate_and)
  1098. OP_EVALUATOR(OperatorEvaluatorBoolXFloatAnd, bool, float, _operate_and)
  1099. OP_EVALUATOR(OperatorEvaluatorFloatXBoolAnd, float, bool, _operate_and)
  1100. OP_EVALUATOR(OperatorEvaluatorBoolXObjectAnd, bool, object, _operate_and)
  1101. OP_EVALUATOR(OperatorEvaluatorObjectXBoolAnd, object, bool, _operate_and)
  1102. // int
  1103. OP_EVALUATOR(OperatorEvaluatorIntXIntAnd, int, int, _operate_and)
  1104. OP_EVALUATOR(OperatorEvaluatorIntXFloatAnd, int, float, _operate_and)
  1105. OP_EVALUATOR(OperatorEvaluatorFloatXIntAnd, float, int, _operate_and)
  1106. OP_EVALUATOR(OperatorEvaluatorIntXObjectAnd, int, object, _operate_and)
  1107. OP_EVALUATOR(OperatorEvaluatorObjectXIntAnd, object, int, _operate_and)
  1108. // float
  1109. OP_EVALUATOR(OperatorEvaluatorFloatXFloatAnd, float, float, _operate_and)
  1110. OP_EVALUATOR(OperatorEvaluatorFloatXObjectAnd, float, object, _operate_and)
  1111. OP_EVALUATOR(OperatorEvaluatorObjectXFloatAnd, object, float, _operate_and)
  1112. // object
  1113. OP_EVALUATOR(OperatorEvaluatorObjectXObjectAnd, object, object, _operate_and)
  1114. // XOR
  1115. // nil
  1116. OP_EVALUATOR(OperatorEvaluatorNilXBoolXor, nil, bool, _operate_xor)
  1117. OP_EVALUATOR(OperatorEvaluatorBoolXNilXor, bool, nil, _operate_xor)
  1118. OP_EVALUATOR(OperatorEvaluatorNilXIntXor, nil, int, _operate_xor)
  1119. OP_EVALUATOR(OperatorEvaluatorIntXNilXor, int, nil, _operate_xor)
  1120. OP_EVALUATOR(OperatorEvaluatorNilXFloatXor, nil, float, _operate_xor)
  1121. OP_EVALUATOR(OperatorEvaluatorFloatXNilXor, float, nil, _operate_xor)
  1122. OP_EVALUATOR(OperatorEvaluatorObjectXNilXor, object, nil, _operate_xor)
  1123. OP_EVALUATOR(OperatorEvaluatorNilXObjectXor, nil, object, _operate_xor)
  1124. // bool
  1125. OP_EVALUATOR(OperatorEvaluatorBoolXBoolXor, bool, bool, _operate_xor)
  1126. OP_EVALUATOR(OperatorEvaluatorBoolXIntXor, bool, int, _operate_xor)
  1127. OP_EVALUATOR(OperatorEvaluatorIntXBoolXor, int, bool, _operate_xor)
  1128. OP_EVALUATOR(OperatorEvaluatorBoolXFloatXor, bool, float, _operate_xor)
  1129. OP_EVALUATOR(OperatorEvaluatorFloatXBoolXor, float, bool, _operate_xor)
  1130. OP_EVALUATOR(OperatorEvaluatorBoolXObjectXor, bool, object, _operate_xor)
  1131. OP_EVALUATOR(OperatorEvaluatorObjectXBoolXor, object, bool, _operate_xor)
  1132. // int
  1133. OP_EVALUATOR(OperatorEvaluatorIntXIntXor, int, int, _operate_xor)
  1134. OP_EVALUATOR(OperatorEvaluatorIntXFloatXor, int, float, _operate_xor)
  1135. OP_EVALUATOR(OperatorEvaluatorFloatXIntXor, float, int, _operate_xor)
  1136. OP_EVALUATOR(OperatorEvaluatorIntXObjectXor, int, object, _operate_xor)
  1137. OP_EVALUATOR(OperatorEvaluatorObjectXIntXor, object, int, _operate_xor)
  1138. // float
  1139. OP_EVALUATOR(OperatorEvaluatorFloatXFloatXor, float, float, _operate_xor)
  1140. OP_EVALUATOR(OperatorEvaluatorFloatXObjectXor, float, object, _operate_xor)
  1141. OP_EVALUATOR(OperatorEvaluatorObjectXFloatXor, object, float, _operate_xor)
  1142. // object
  1143. OP_EVALUATOR(OperatorEvaluatorObjectXObjectXor, object, object, _operate_xor)
  1144. class OperatorEvaluatorNotBool {
  1145. public:
  1146. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  1147. *r_ret = !*VariantGetInternalPtr<bool>::get_ptr(&p_left);
  1148. r_valid = true;
  1149. }
  1150. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  1151. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = !*VariantGetInternalPtr<bool>::get_ptr(left);
  1152. }
  1153. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  1154. PtrToArg<bool>::encode(!PtrToArg<bool>::convert(left), r_ret);
  1155. }
  1156. static Variant::Type get_return_type() { return Variant::BOOL; }
  1157. };
  1158. class OperatorEvaluatorNotInt {
  1159. public:
  1160. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  1161. *r_ret = !*VariantGetInternalPtr<int64_t>::get_ptr(&p_left);
  1162. r_valid = true;
  1163. }
  1164. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  1165. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = !*VariantGetInternalPtr<int64_t>::get_ptr(left);
  1166. }
  1167. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  1168. PtrToArg<bool>::encode(!PtrToArg<int64_t>::convert(left), r_ret);
  1169. }
  1170. static Variant::Type get_return_type() { return Variant::BOOL; }
  1171. };
  1172. class OperatorEvaluatorNotFloat {
  1173. public:
  1174. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  1175. *r_ret = !*VariantGetInternalPtr<double>::get_ptr(&p_left);
  1176. r_valid = true;
  1177. }
  1178. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  1179. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = !*VariantGetInternalPtr<double>::get_ptr(left);
  1180. }
  1181. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  1182. PtrToArg<bool>::encode(!PtrToArg<double>::convert(left), r_ret);
  1183. }
  1184. static Variant::Type get_return_type() { return Variant::BOOL; }
  1185. };
  1186. class OperatorEvaluatorNotObject {
  1187. public:
  1188. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  1189. *r_ret = p_left.get_validated_object() == nullptr;
  1190. r_valid = true;
  1191. }
  1192. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  1193. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = left->get_validated_object() == nullptr;
  1194. }
  1195. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  1196. PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == nullptr, r_ret);
  1197. }
  1198. static Variant::Type get_return_type() { return Variant::BOOL; }
  1199. };
  1200. ////
  1201. template <typename Left, typename Right>
  1202. class OperatorEvaluatorInStringFind;
  1203. template <typename Left>
  1204. class OperatorEvaluatorInStringFind<Left, String> {
  1205. public:
  1206. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  1207. const Left &str_a = *VariantGetInternalPtr<Left>::get_ptr(&p_left);
  1208. const String &str_b = *VariantGetInternalPtr<String>::get_ptr(&p_right);
  1209. *r_ret = str_b.find(str_a) != -1;
  1210. r_valid = true;
  1211. }
  1212. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  1213. const Left &str_a = *VariantGetInternalPtr<Left>::get_ptr(left);
  1214. const String &str_b = *VariantGetInternalPtr<String>::get_ptr(right);
  1215. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = str_b.find(str_a) != -1;
  1216. }
  1217. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  1218. PtrToArg<bool>::encode(PtrToArg<String>::convert(right).find(PtrToArg<Left>::convert(left)) != -1, r_ret);
  1219. }
  1220. static Variant::Type get_return_type() { return Variant::BOOL; }
  1221. };
  1222. template <typename Left>
  1223. class OperatorEvaluatorInStringFind<Left, StringName> {
  1224. public:
  1225. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  1226. const Left &str_a = *VariantGetInternalPtr<Left>::get_ptr(&p_left);
  1227. const String str_b = VariantGetInternalPtr<StringName>::get_ptr(&p_right)->operator String();
  1228. *r_ret = str_b.find(str_a) != -1;
  1229. r_valid = true;
  1230. }
  1231. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  1232. const Left &str_a = *VariantGetInternalPtr<Left>::get_ptr(left);
  1233. const String str_b = VariantGetInternalPtr<StringName>::get_ptr(right)->operator String();
  1234. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = str_b.find(str_a) != -1;
  1235. }
  1236. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  1237. PtrToArg<bool>::encode(PtrToArg<StringName>::convert(right).operator String().find(PtrToArg<Left>::convert(left)) != -1, r_ret);
  1238. }
  1239. static Variant::Type get_return_type() { return Variant::BOOL; }
  1240. };
  1241. template <typename A, typename B>
  1242. class OperatorEvaluatorInArrayFind {
  1243. public:
  1244. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  1245. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  1246. const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
  1247. *r_ret = b.find(a) != -1;
  1248. r_valid = true;
  1249. }
  1250. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  1251. const A &a = *VariantGetInternalPtr<A>::get_ptr(left);
  1252. const B &b = *VariantGetInternalPtr<B>::get_ptr(right);
  1253. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.find(a) != -1;
  1254. }
  1255. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  1256. PtrToArg<bool>::encode(PtrToArg<B>::convert(right).find(PtrToArg<A>::convert(left)) != -1, r_ret);
  1257. }
  1258. static Variant::Type get_return_type() { return Variant::BOOL; }
  1259. };
  1260. class OperatorEvaluatorInArrayFindNil {
  1261. public:
  1262. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  1263. const Array &b = *VariantGetInternalPtr<Array>::get_ptr(&p_right);
  1264. *r_ret = b.find(Variant()) != -1;
  1265. r_valid = true;
  1266. }
  1267. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  1268. const Array &b = *VariantGetInternalPtr<Array>::get_ptr(right);
  1269. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.find(Variant()) != -1;
  1270. }
  1271. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  1272. PtrToArg<bool>::encode(PtrToArg<Array>::convert(right).find(Variant()) != -1, r_ret);
  1273. }
  1274. static Variant::Type get_return_type() { return Variant::BOOL; }
  1275. };
  1276. class OperatorEvaluatorInArrayFindObject {
  1277. public:
  1278. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  1279. const Array &b = *VariantGetInternalPtr<Array>::get_ptr(&p_right);
  1280. *r_ret = b.find(p_left) != -1;
  1281. r_valid = true;
  1282. }
  1283. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  1284. const Array &b = *VariantGetInternalPtr<Array>::get_ptr(right);
  1285. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.find(*left) != -1;
  1286. }
  1287. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  1288. PtrToArg<bool>::encode(PtrToArg<Array>::convert(right).find(PtrToArg<Object *>::convert(left)) != -1, r_ret);
  1289. }
  1290. static Variant::Type get_return_type() { return Variant::BOOL; }
  1291. };
  1292. template <typename A>
  1293. class OperatorEvaluatorInDictionaryHas {
  1294. public:
  1295. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  1296. const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(&p_right);
  1297. const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
  1298. *r_ret = b.has(a);
  1299. r_valid = true;
  1300. }
  1301. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  1302. const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(right);
  1303. const A &a = *VariantGetInternalPtr<A>::get_ptr(left);
  1304. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.has(a);
  1305. }
  1306. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  1307. PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(PtrToArg<A>::convert(left)), r_ret);
  1308. }
  1309. static Variant::Type get_return_type() { return Variant::BOOL; }
  1310. };
  1311. class OperatorEvaluatorInDictionaryHasNil {
  1312. public:
  1313. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  1314. const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(&p_right);
  1315. *r_ret = b.has(Variant());
  1316. r_valid = true;
  1317. }
  1318. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  1319. const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(right);
  1320. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.has(Variant());
  1321. }
  1322. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  1323. PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(Variant()), r_ret);
  1324. }
  1325. static Variant::Type get_return_type() { return Variant::BOOL; }
  1326. };
  1327. class OperatorEvaluatorInDictionaryHasObject {
  1328. public:
  1329. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  1330. const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(&p_right);
  1331. *r_ret = b.has(p_left);
  1332. r_valid = true;
  1333. }
  1334. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  1335. const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(right);
  1336. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.has(*left);
  1337. }
  1338. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  1339. PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(PtrToArg<Object *>::convert(left)), r_ret);
  1340. }
  1341. static Variant::Type get_return_type() { return Variant::BOOL; }
  1342. };
  1343. class OperatorEvaluatorObjectHasPropertyString {
  1344. public:
  1345. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  1346. Object *b = p_right.get_validated_object();
  1347. if (!b) {
  1348. *r_ret = "Invalid base object for 'in'";
  1349. r_valid = false;
  1350. return;
  1351. }
  1352. const String &a = *VariantGetInternalPtr<String>::get_ptr(&p_left);
  1353. bool exist;
  1354. b->get(a, &exist);
  1355. *r_ret = exist;
  1356. r_valid = true;
  1357. }
  1358. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  1359. Object *l = right->get_validated_object();
  1360. if (unlikely(!l)) {
  1361. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = false;
  1362. ERR_FAIL_MSG("Invalid base object for 'in'.");
  1363. }
  1364. const String &a = *VariantGetInternalPtr<String>::get_ptr(left);
  1365. bool valid;
  1366. l->get(a, &valid);
  1367. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = valid;
  1368. }
  1369. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  1370. bool valid;
  1371. PtrToArg<Object *>::convert(right)->get(PtrToArg<String>::convert(left), &valid);
  1372. PtrToArg<bool>::encode(valid, r_ret);
  1373. }
  1374. static Variant::Type get_return_type() { return Variant::BOOL; }
  1375. };
  1376. class OperatorEvaluatorObjectHasPropertyStringName {
  1377. public:
  1378. static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
  1379. Object *b = p_right.get_validated_object();
  1380. if (!b) {
  1381. *r_ret = "Invalid base object for 'in'";
  1382. r_valid = false;
  1383. return;
  1384. }
  1385. const StringName &a = *VariantGetInternalPtr<StringName>::get_ptr(&p_left);
  1386. bool exist;
  1387. b->get(a, &exist);
  1388. *r_ret = exist;
  1389. r_valid = true;
  1390. }
  1391. static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
  1392. Object *l = right->get_validated_object();
  1393. if (unlikely(!l)) {
  1394. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = false;
  1395. ERR_FAIL_MSG("Invalid base object for 'in'.");
  1396. }
  1397. const StringName &a = *VariantGetInternalPtr<StringName>::get_ptr(left);
  1398. bool valid;
  1399. l->get(a, &valid);
  1400. *VariantGetInternalPtr<bool>::get_ptr(r_ret) = valid;
  1401. }
  1402. static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
  1403. bool valid;
  1404. PtrToArg<Object *>::convert(right)->get(PtrToArg<StringName>::convert(left), &valid);
  1405. PtrToArg<bool>::encode(valid, r_ret);
  1406. }
  1407. static Variant::Type get_return_type() { return Variant::BOOL; }
  1408. };