gdscript_vm.cpp 120 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699
  1. /**************************************************************************/
  2. /* gdscript_vm.cpp */
  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. #include "gdscript.h"
  31. #include "gdscript_function.h"
  32. #include "gdscript_lambda_callable.h"
  33. #include "core/os/os.h"
  34. #ifdef DEBUG_ENABLED
  35. static bool _profile_count_as_native(const Object *p_base_obj, const StringName &p_methodname) {
  36. if (!p_base_obj) {
  37. return false;
  38. }
  39. StringName cname = p_base_obj->get_class_name();
  40. if ((p_methodname == "new" && cname == "GDScript") || p_methodname == "call") {
  41. return false;
  42. }
  43. return ClassDB::class_exists(cname) && ClassDB::has_method(cname, p_methodname, false);
  44. }
  45. static String _get_element_type(Variant::Type builtin_type, const StringName &native_type, const Ref<Script> &script_type) {
  46. if (script_type.is_valid() && script_type->is_valid()) {
  47. return GDScript::debug_get_script_name(script_type);
  48. } else if (native_type != StringName()) {
  49. return native_type.operator String();
  50. } else {
  51. return Variant::get_type_name(builtin_type);
  52. }
  53. }
  54. static String _get_var_type(const Variant *p_var) {
  55. String basestr;
  56. if (p_var->get_type() == Variant::OBJECT) {
  57. bool was_freed;
  58. Object *bobj = p_var->get_validated_object_with_check(was_freed);
  59. if (!bobj) {
  60. if (was_freed) {
  61. basestr = "previously freed";
  62. } else {
  63. basestr = "null instance";
  64. }
  65. } else {
  66. if (bobj->is_class_ptr(GDScriptNativeClass::get_class_ptr_static())) {
  67. basestr = Object::cast_to<GDScriptNativeClass>(bobj)->get_name();
  68. } else {
  69. basestr = bobj->get_class();
  70. if (bobj->get_script_instance()) {
  71. basestr += " (" + GDScript::debug_get_script_name(bobj->get_script_instance()->get_script()) + ")";
  72. }
  73. }
  74. }
  75. } else {
  76. if (p_var->get_type() == Variant::ARRAY) {
  77. basestr = "Array";
  78. const Array *p_array = VariantInternal::get_array(p_var);
  79. Variant::Type builtin_type = (Variant::Type)p_array->get_typed_builtin();
  80. if (builtin_type != Variant::NIL) {
  81. basestr += "[" + _get_element_type(builtin_type, p_array->get_typed_class_name(), p_array->get_typed_script()) + "]";
  82. }
  83. } else {
  84. basestr = Variant::get_type_name(p_var->get_type());
  85. }
  86. }
  87. return basestr;
  88. }
  89. void GDScriptFunction::_profile_native_call(uint64_t p_t_taken, const String &p_func_name, const String &p_instance_class_name) {
  90. HashMap<String, Profile::NativeProfile>::Iterator inner_prof = profile.native_calls.find(p_func_name);
  91. if (inner_prof) {
  92. inner_prof->value.call_count += 1;
  93. } else {
  94. String sig = vformat("%s::0::%s%s%s", get_script()->get_script_path(), p_instance_class_name, p_instance_class_name.is_empty() ? "" : ".", p_func_name);
  95. inner_prof = profile.native_calls.insert(p_func_name, Profile::NativeProfile{ 1, 0, sig });
  96. }
  97. inner_prof->value.total_time += p_t_taken;
  98. }
  99. #endif // DEBUG_ENABLED
  100. Variant GDScriptFunction::_get_default_variant_for_data_type(const GDScriptDataType &p_data_type) {
  101. if (p_data_type.kind == GDScriptDataType::BUILTIN) {
  102. if (p_data_type.builtin_type == Variant::ARRAY) {
  103. Array array;
  104. // Typed array.
  105. if (p_data_type.has_container_element_type(0)) {
  106. const GDScriptDataType &element_type = p_data_type.get_container_element_type(0);
  107. array.set_typed(element_type.builtin_type, element_type.native_type, element_type.script_type);
  108. }
  109. return array;
  110. } else {
  111. Callable::CallError ce;
  112. Variant variant;
  113. Variant::construct(p_data_type.builtin_type, variant, nullptr, 0, ce);
  114. ERR_FAIL_COND_V(ce.error != Callable::CallError::CALL_OK, Variant());
  115. return variant;
  116. }
  117. }
  118. return Variant();
  119. }
  120. String GDScriptFunction::_get_call_error(const Callable::CallError &p_err, const String &p_where, const Variant **argptrs) const {
  121. String err_text;
  122. if (p_err.error == Callable::CallError::CALL_ERROR_INVALID_ARGUMENT) {
  123. int errorarg = p_err.argument;
  124. ERR_FAIL_COND_V_MSG(errorarg < 0 || argptrs[errorarg] == nullptr, "GDScript bug (please report): Invalid CallError argument index or null pointer.", "Invalid CallError argument index or null pointer.");
  125. // Handle the Object to Object case separately as we don't have further class details.
  126. #ifdef DEBUG_ENABLED
  127. if (p_err.expected == Variant::OBJECT && argptrs[errorarg]->get_type() == p_err.expected) {
  128. err_text = "Invalid type in " + p_where + ". The Object-derived class of argument " + itos(errorarg + 1) + " (" + _get_var_type(argptrs[errorarg]) + ") is not a subclass of the expected argument class.";
  129. } else if (p_err.expected == Variant::ARRAY && argptrs[errorarg]->get_type() == p_err.expected) {
  130. err_text = "Invalid type in " + p_where + ". The array of argument " + itos(errorarg + 1) + " (" + _get_var_type(argptrs[errorarg]) + ") does not have the same element type as the expected typed array argument.";
  131. } else
  132. #endif // DEBUG_ENABLED
  133. {
  134. err_text = "Invalid type in " + p_where + ". Cannot convert argument " + itos(errorarg + 1) + " from " + Variant::get_type_name(argptrs[errorarg]->get_type()) + " to " + Variant::get_type_name(Variant::Type(p_err.expected)) + ".";
  135. }
  136. } else if (p_err.error == Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS) {
  137. err_text = "Invalid call to " + p_where + ". Expected " + itos(p_err.expected) + " arguments.";
  138. } else if (p_err.error == Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS) {
  139. err_text = "Invalid call to " + p_where + ". Expected " + itos(p_err.expected) + " arguments.";
  140. } else if (p_err.error == Callable::CallError::CALL_ERROR_INVALID_METHOD) {
  141. err_text = "Invalid call. Nonexistent " + p_where + ".";
  142. } else if (p_err.error == Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL) {
  143. err_text = "Attempt to call " + p_where + " on a null instance.";
  144. } else if (p_err.error == Callable::CallError::CALL_ERROR_METHOD_NOT_CONST) {
  145. err_text = "Attempt to call " + p_where + " on a const instance.";
  146. } else {
  147. err_text = "Bug, call error: #" + itos(p_err.error);
  148. }
  149. return err_text;
  150. }
  151. void (*type_init_function_table[])(Variant *) = {
  152. nullptr, // NIL (shouldn't be called).
  153. &VariantInitializer<bool>::init, // BOOL.
  154. &VariantInitializer<int64_t>::init, // INT.
  155. &VariantInitializer<double>::init, // FLOAT.
  156. &VariantInitializer<String>::init, // STRING.
  157. &VariantInitializer<Vector2>::init, // VECTOR2.
  158. &VariantInitializer<Vector2i>::init, // VECTOR2I.
  159. &VariantInitializer<Rect2>::init, // RECT2.
  160. &VariantInitializer<Rect2i>::init, // RECT2I.
  161. &VariantInitializer<Vector3>::init, // VECTOR3.
  162. &VariantInitializer<Vector3i>::init, // VECTOR3I.
  163. &VariantInitializer<Transform2D>::init, // TRANSFORM2D.
  164. &VariantInitializer<Vector4>::init, // VECTOR4.
  165. &VariantInitializer<Vector4i>::init, // VECTOR4I.
  166. &VariantInitializer<Plane>::init, // PLANE.
  167. &VariantInitializer<Quaternion>::init, // QUATERNION.
  168. &VariantInitializer<AABB>::init, // AABB.
  169. &VariantInitializer<Basis>::init, // BASIS.
  170. &VariantInitializer<Transform3D>::init, // TRANSFORM3D.
  171. &VariantInitializer<Projection>::init, // PROJECTION.
  172. &VariantInitializer<Color>::init, // COLOR.
  173. &VariantInitializer<StringName>::init, // STRING_NAME.
  174. &VariantInitializer<NodePath>::init, // NODE_PATH.
  175. &VariantInitializer<RID>::init, // RID.
  176. &VariantInitializer<Object *>::init, // OBJECT.
  177. &VariantInitializer<Callable>::init, // CALLABLE.
  178. &VariantInitializer<Signal>::init, // SIGNAL.
  179. &VariantInitializer<Dictionary>::init, // DICTIONARY.
  180. &VariantInitializer<Array>::init, // ARRAY.
  181. &VariantInitializer<PackedByteArray>::init, // PACKED_BYTE_ARRAY.
  182. &VariantInitializer<PackedInt32Array>::init, // PACKED_INT32_ARRAY.
  183. &VariantInitializer<PackedInt64Array>::init, // PACKED_INT64_ARRAY.
  184. &VariantInitializer<PackedFloat32Array>::init, // PACKED_FLOAT32_ARRAY.
  185. &VariantInitializer<PackedFloat64Array>::init, // PACKED_FLOAT64_ARRAY.
  186. &VariantInitializer<PackedStringArray>::init, // PACKED_STRING_ARRAY.
  187. &VariantInitializer<PackedVector2Array>::init, // PACKED_VECTOR2_ARRAY.
  188. &VariantInitializer<PackedVector3Array>::init, // PACKED_VECTOR3_ARRAY.
  189. &VariantInitializer<PackedColorArray>::init, // PACKED_COLOR_ARRAY.
  190. &VariantInitializer<PackedVector4Array>::init, // PACKED_VECTOR4_ARRAY.
  191. };
  192. #if defined(__GNUC__)
  193. #define OPCODES_TABLE \
  194. static const void *switch_table_ops[] = { \
  195. &&OPCODE_OPERATOR, \
  196. &&OPCODE_OPERATOR_VALIDATED, \
  197. &&OPCODE_TYPE_TEST_BUILTIN, \
  198. &&OPCODE_TYPE_TEST_ARRAY, \
  199. &&OPCODE_TYPE_TEST_NATIVE, \
  200. &&OPCODE_TYPE_TEST_SCRIPT, \
  201. &&OPCODE_SET_KEYED, \
  202. &&OPCODE_SET_KEYED_VALIDATED, \
  203. &&OPCODE_SET_INDEXED_VALIDATED, \
  204. &&OPCODE_GET_KEYED, \
  205. &&OPCODE_GET_KEYED_VALIDATED, \
  206. &&OPCODE_GET_INDEXED_VALIDATED, \
  207. &&OPCODE_SET_NAMED, \
  208. &&OPCODE_SET_NAMED_VALIDATED, \
  209. &&OPCODE_GET_NAMED, \
  210. &&OPCODE_GET_NAMED_VALIDATED, \
  211. &&OPCODE_SET_MEMBER, \
  212. &&OPCODE_GET_MEMBER, \
  213. &&OPCODE_SET_STATIC_VARIABLE, \
  214. &&OPCODE_GET_STATIC_VARIABLE, \
  215. &&OPCODE_ASSIGN, \
  216. &&OPCODE_ASSIGN_NULL, \
  217. &&OPCODE_ASSIGN_TRUE, \
  218. &&OPCODE_ASSIGN_FALSE, \
  219. &&OPCODE_ASSIGN_TYPED_BUILTIN, \
  220. &&OPCODE_ASSIGN_TYPED_ARRAY, \
  221. &&OPCODE_ASSIGN_TYPED_NATIVE, \
  222. &&OPCODE_ASSIGN_TYPED_SCRIPT, \
  223. &&OPCODE_CAST_TO_BUILTIN, \
  224. &&OPCODE_CAST_TO_NATIVE, \
  225. &&OPCODE_CAST_TO_SCRIPT, \
  226. &&OPCODE_CONSTRUCT, \
  227. &&OPCODE_CONSTRUCT_VALIDATED, \
  228. &&OPCODE_CONSTRUCT_ARRAY, \
  229. &&OPCODE_CONSTRUCT_TYPED_ARRAY, \
  230. &&OPCODE_CONSTRUCT_DICTIONARY, \
  231. &&OPCODE_CALL, \
  232. &&OPCODE_CALL_RETURN, \
  233. &&OPCODE_CALL_ASYNC, \
  234. &&OPCODE_CALL_UTILITY, \
  235. &&OPCODE_CALL_UTILITY_VALIDATED, \
  236. &&OPCODE_CALL_GDSCRIPT_UTILITY, \
  237. &&OPCODE_CALL_BUILTIN_TYPE_VALIDATED, \
  238. &&OPCODE_CALL_SELF_BASE, \
  239. &&OPCODE_CALL_METHOD_BIND, \
  240. &&OPCODE_CALL_METHOD_BIND_RET, \
  241. &&OPCODE_CALL_BUILTIN_STATIC, \
  242. &&OPCODE_CALL_NATIVE_STATIC, \
  243. &&OPCODE_CALL_NATIVE_STATIC_VALIDATED_RETURN, \
  244. &&OPCODE_CALL_NATIVE_STATIC_VALIDATED_NO_RETURN, \
  245. &&OPCODE_CALL_METHOD_BIND_VALIDATED_RETURN, \
  246. &&OPCODE_CALL_METHOD_BIND_VALIDATED_NO_RETURN, \
  247. &&OPCODE_AWAIT, \
  248. &&OPCODE_AWAIT_RESUME, \
  249. &&OPCODE_CREATE_LAMBDA, \
  250. &&OPCODE_CREATE_SELF_LAMBDA, \
  251. &&OPCODE_JUMP, \
  252. &&OPCODE_JUMP_IF, \
  253. &&OPCODE_JUMP_IF_NOT, \
  254. &&OPCODE_JUMP_TO_DEF_ARGUMENT, \
  255. &&OPCODE_JUMP_IF_SHARED, \
  256. &&OPCODE_RETURN, \
  257. &&OPCODE_RETURN_TYPED_BUILTIN, \
  258. &&OPCODE_RETURN_TYPED_ARRAY, \
  259. &&OPCODE_RETURN_TYPED_NATIVE, \
  260. &&OPCODE_RETURN_TYPED_SCRIPT, \
  261. &&OPCODE_ITERATE_BEGIN, \
  262. &&OPCODE_ITERATE_BEGIN_INT, \
  263. &&OPCODE_ITERATE_BEGIN_FLOAT, \
  264. &&OPCODE_ITERATE_BEGIN_VECTOR2, \
  265. &&OPCODE_ITERATE_BEGIN_VECTOR2I, \
  266. &&OPCODE_ITERATE_BEGIN_VECTOR3, \
  267. &&OPCODE_ITERATE_BEGIN_VECTOR3I, \
  268. &&OPCODE_ITERATE_BEGIN_STRING, \
  269. &&OPCODE_ITERATE_BEGIN_DICTIONARY, \
  270. &&OPCODE_ITERATE_BEGIN_ARRAY, \
  271. &&OPCODE_ITERATE_BEGIN_PACKED_BYTE_ARRAY, \
  272. &&OPCODE_ITERATE_BEGIN_PACKED_INT32_ARRAY, \
  273. &&OPCODE_ITERATE_BEGIN_PACKED_INT64_ARRAY, \
  274. &&OPCODE_ITERATE_BEGIN_PACKED_FLOAT32_ARRAY, \
  275. &&OPCODE_ITERATE_BEGIN_PACKED_FLOAT64_ARRAY, \
  276. &&OPCODE_ITERATE_BEGIN_PACKED_STRING_ARRAY, \
  277. &&OPCODE_ITERATE_BEGIN_PACKED_VECTOR2_ARRAY, \
  278. &&OPCODE_ITERATE_BEGIN_PACKED_VECTOR3_ARRAY, \
  279. &&OPCODE_ITERATE_BEGIN_PACKED_COLOR_ARRAY, \
  280. &&OPCODE_ITERATE_BEGIN_PACKED_VECTOR4_ARRAY, \
  281. &&OPCODE_ITERATE_BEGIN_OBJECT, \
  282. &&OPCODE_ITERATE, \
  283. &&OPCODE_ITERATE_INT, \
  284. &&OPCODE_ITERATE_FLOAT, \
  285. &&OPCODE_ITERATE_VECTOR2, \
  286. &&OPCODE_ITERATE_VECTOR2I, \
  287. &&OPCODE_ITERATE_VECTOR3, \
  288. &&OPCODE_ITERATE_VECTOR3I, \
  289. &&OPCODE_ITERATE_STRING, \
  290. &&OPCODE_ITERATE_DICTIONARY, \
  291. &&OPCODE_ITERATE_ARRAY, \
  292. &&OPCODE_ITERATE_PACKED_BYTE_ARRAY, \
  293. &&OPCODE_ITERATE_PACKED_INT32_ARRAY, \
  294. &&OPCODE_ITERATE_PACKED_INT64_ARRAY, \
  295. &&OPCODE_ITERATE_PACKED_FLOAT32_ARRAY, \
  296. &&OPCODE_ITERATE_PACKED_FLOAT64_ARRAY, \
  297. &&OPCODE_ITERATE_PACKED_STRING_ARRAY, \
  298. &&OPCODE_ITERATE_PACKED_VECTOR2_ARRAY, \
  299. &&OPCODE_ITERATE_PACKED_VECTOR3_ARRAY, \
  300. &&OPCODE_ITERATE_PACKED_COLOR_ARRAY, \
  301. &&OPCODE_ITERATE_PACKED_VECTOR4_ARRAY, \
  302. &&OPCODE_ITERATE_OBJECT, \
  303. &&OPCODE_STORE_GLOBAL, \
  304. &&OPCODE_STORE_NAMED_GLOBAL, \
  305. &&OPCODE_TYPE_ADJUST_BOOL, \
  306. &&OPCODE_TYPE_ADJUST_INT, \
  307. &&OPCODE_TYPE_ADJUST_FLOAT, \
  308. &&OPCODE_TYPE_ADJUST_STRING, \
  309. &&OPCODE_TYPE_ADJUST_VECTOR2, \
  310. &&OPCODE_TYPE_ADJUST_VECTOR2I, \
  311. &&OPCODE_TYPE_ADJUST_RECT2, \
  312. &&OPCODE_TYPE_ADJUST_RECT2I, \
  313. &&OPCODE_TYPE_ADJUST_VECTOR3, \
  314. &&OPCODE_TYPE_ADJUST_VECTOR3I, \
  315. &&OPCODE_TYPE_ADJUST_TRANSFORM2D, \
  316. &&OPCODE_TYPE_ADJUST_VECTOR4, \
  317. &&OPCODE_TYPE_ADJUST_VECTOR4I, \
  318. &&OPCODE_TYPE_ADJUST_PLANE, \
  319. &&OPCODE_TYPE_ADJUST_QUATERNION, \
  320. &&OPCODE_TYPE_ADJUST_AABB, \
  321. &&OPCODE_TYPE_ADJUST_BASIS, \
  322. &&OPCODE_TYPE_ADJUST_TRANSFORM3D, \
  323. &&OPCODE_TYPE_ADJUST_PROJECTION, \
  324. &&OPCODE_TYPE_ADJUST_COLOR, \
  325. &&OPCODE_TYPE_ADJUST_STRING_NAME, \
  326. &&OPCODE_TYPE_ADJUST_NODE_PATH, \
  327. &&OPCODE_TYPE_ADJUST_RID, \
  328. &&OPCODE_TYPE_ADJUST_OBJECT, \
  329. &&OPCODE_TYPE_ADJUST_CALLABLE, \
  330. &&OPCODE_TYPE_ADJUST_SIGNAL, \
  331. &&OPCODE_TYPE_ADJUST_DICTIONARY, \
  332. &&OPCODE_TYPE_ADJUST_ARRAY, \
  333. &&OPCODE_TYPE_ADJUST_PACKED_BYTE_ARRAY, \
  334. &&OPCODE_TYPE_ADJUST_PACKED_INT32_ARRAY, \
  335. &&OPCODE_TYPE_ADJUST_PACKED_INT64_ARRAY, \
  336. &&OPCODE_TYPE_ADJUST_PACKED_FLOAT32_ARRAY, \
  337. &&OPCODE_TYPE_ADJUST_PACKED_FLOAT64_ARRAY, \
  338. &&OPCODE_TYPE_ADJUST_PACKED_STRING_ARRAY, \
  339. &&OPCODE_TYPE_ADJUST_PACKED_VECTOR2_ARRAY, \
  340. &&OPCODE_TYPE_ADJUST_PACKED_VECTOR3_ARRAY, \
  341. &&OPCODE_TYPE_ADJUST_PACKED_COLOR_ARRAY, \
  342. &&OPCODE_TYPE_ADJUST_PACKED_VECTOR4_ARRAY, \
  343. &&OPCODE_ASSERT, \
  344. &&OPCODE_BREAKPOINT, \
  345. &&OPCODE_LINE, \
  346. &&OPCODE_END \
  347. }; \
  348. static_assert((sizeof(switch_table_ops) / sizeof(switch_table_ops[0]) == (OPCODE_END + 1)), "Opcodes in jump table aren't the same as opcodes in enum.");
  349. #define OPCODE(m_op) \
  350. m_op:
  351. #define OPCODE_WHILE(m_test)
  352. #define OPCODES_END \
  353. OPSEXIT:
  354. #define OPCODES_OUT \
  355. OPSOUT:
  356. #define OPCODE_SWITCH(m_test) goto *switch_table_ops[m_test];
  357. #ifdef DEBUG_ENABLED
  358. #define DISPATCH_OPCODE \
  359. last_opcode = _code_ptr[ip]; \
  360. goto *switch_table_ops[last_opcode]
  361. #else
  362. #define DISPATCH_OPCODE goto *switch_table_ops[_code_ptr[ip]]
  363. #endif
  364. #define OPCODE_BREAK goto OPSEXIT
  365. #define OPCODE_OUT goto OPSOUT
  366. #else
  367. #define OPCODES_TABLE
  368. #define OPCODE(m_op) case m_op:
  369. #define OPCODE_WHILE(m_test) while (m_test)
  370. #define OPCODES_END
  371. #define OPCODES_OUT
  372. #define DISPATCH_OPCODE continue
  373. #ifdef _MSC_VER
  374. #define OPCODE_SWITCH(m_test) \
  375. __assume(m_test <= OPCODE_END); \
  376. switch (m_test)
  377. #else
  378. #define OPCODE_SWITCH(m_test) switch (m_test)
  379. #endif
  380. #define OPCODE_BREAK break
  381. #define OPCODE_OUT break
  382. #endif
  383. // Helpers for VariantInternal methods in macros.
  384. #define OP_GET_BOOL get_bool
  385. #define OP_GET_INT get_int
  386. #define OP_GET_FLOAT get_float
  387. #define OP_GET_VECTOR2 get_vector2
  388. #define OP_GET_VECTOR2I get_vector2i
  389. #define OP_GET_VECTOR3 get_vector3
  390. #define OP_GET_VECTOR3I get_vector3i
  391. #define OP_GET_RECT2 get_rect2
  392. #define OP_GET_VECTOR4 get_vector4
  393. #define OP_GET_VECTOR4I get_vector4i
  394. #define OP_GET_RECT2I get_rect2i
  395. #define OP_GET_QUATERNION get_quaternion
  396. #define OP_GET_COLOR get_color
  397. #define OP_GET_STRING get_string
  398. #define OP_GET_STRING_NAME get_string_name
  399. #define OP_GET_NODE_PATH get_node_path
  400. #define OP_GET_CALLABLE get_callable
  401. #define OP_GET_SIGNAL get_signal
  402. #define OP_GET_ARRAY get_array
  403. #define OP_GET_DICTIONARY get_dictionary
  404. #define OP_GET_PACKED_BYTE_ARRAY get_byte_array
  405. #define OP_GET_PACKED_INT32_ARRAY get_int32_array
  406. #define OP_GET_PACKED_INT64_ARRAY get_int64_array
  407. #define OP_GET_PACKED_FLOAT32_ARRAY get_float32_array
  408. #define OP_GET_PACKED_FLOAT64_ARRAY get_float64_array
  409. #define OP_GET_PACKED_STRING_ARRAY get_string_array
  410. #define OP_GET_PACKED_VECTOR2_ARRAY get_vector2_array
  411. #define OP_GET_PACKED_VECTOR3_ARRAY get_vector3_array
  412. #define OP_GET_PACKED_COLOR_ARRAY get_color_array
  413. #define OP_GET_PACKED_VECTOR4_ARRAY get_vector4_array
  414. #define OP_GET_TRANSFORM3D get_transform
  415. #define OP_GET_TRANSFORM2D get_transform2d
  416. #define OP_GET_PROJECTION get_projection
  417. #define OP_GET_PLANE get_plane
  418. #define OP_GET_AABB get_aabb
  419. #define OP_GET_BASIS get_basis
  420. #define OP_GET_RID get_rid
  421. #define METHOD_CALL_ON_NULL_VALUE_ERROR(method_pointer) "Cannot call method '" + (method_pointer)->get_name() + "' on a null value."
  422. #define METHOD_CALL_ON_FREED_INSTANCE_ERROR(method_pointer) "Cannot call method '" + (method_pointer)->get_name() + "' on a previously freed instance."
  423. Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_args, int p_argcount, Callable::CallError &r_err, CallState *p_state) {
  424. OPCODES_TABLE;
  425. if (!_code_ptr) {
  426. return _get_default_variant_for_data_type(return_type);
  427. }
  428. r_err.error = Callable::CallError::CALL_OK;
  429. static thread_local int call_depth = 0;
  430. if (unlikely(++call_depth > MAX_CALL_DEPTH)) {
  431. call_depth--;
  432. #ifdef DEBUG_ENABLED
  433. String err_file;
  434. if (p_instance && ObjectDB::get_instance(p_instance->owner_id) != nullptr && p_instance->script->is_valid() && !p_instance->script->path.is_empty()) {
  435. err_file = p_instance->script->path;
  436. } else if (_script) {
  437. err_file = _script->path;
  438. }
  439. if (err_file.is_empty()) {
  440. err_file = "<built-in>";
  441. }
  442. String err_func = name;
  443. if (p_instance && ObjectDB::get_instance(p_instance->owner_id) != nullptr && p_instance->script->is_valid() && p_instance->script->local_name != StringName()) {
  444. err_func = p_instance->script->local_name.operator String() + "." + err_func;
  445. }
  446. int err_line = _initial_line;
  447. const char *err_text = "Stack overflow. Check for infinite recursion in your script.";
  448. if (!GDScriptLanguage::get_singleton()->debug_break(err_text, false)) {
  449. // Debugger break did not happen.
  450. _err_print_error(err_func.utf8().get_data(), err_file.utf8().get_data(), err_line, err_text, false, ERR_HANDLER_SCRIPT);
  451. }
  452. #endif
  453. return _get_default_variant_for_data_type(return_type);
  454. }
  455. Variant retvalue;
  456. Variant *stack = nullptr;
  457. Variant **instruction_args = nullptr;
  458. int defarg = 0;
  459. #ifdef DEBUG_ENABLED
  460. //GDScriptLanguage::get_singleton()->calls++;
  461. #endif
  462. uint32_t alloca_size = 0;
  463. GDScript *script;
  464. int ip = 0;
  465. int line = _initial_line;
  466. if (p_state) {
  467. //use existing (supplied) state (awaited)
  468. stack = (Variant *)p_state->stack.ptr();
  469. instruction_args = (Variant **)&p_state->stack.ptr()[sizeof(Variant) * p_state->stack_size]; //ptr() to avoid bounds check
  470. line = p_state->line;
  471. ip = p_state->ip;
  472. alloca_size = p_state->stack.size();
  473. script = p_state->script;
  474. p_instance = p_state->instance;
  475. defarg = p_state->defarg;
  476. } else {
  477. if (p_argcount != _argument_count) {
  478. if (p_argcount > _argument_count) {
  479. r_err.error = Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
  480. r_err.expected = _argument_count;
  481. call_depth--;
  482. return _get_default_variant_for_data_type(return_type);
  483. } else if (p_argcount < _argument_count - _default_arg_count) {
  484. r_err.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
  485. r_err.expected = _argument_count - _default_arg_count;
  486. call_depth--;
  487. return _get_default_variant_for_data_type(return_type);
  488. } else {
  489. defarg = _argument_count - p_argcount;
  490. }
  491. }
  492. // Add 3 here for self, class, and nil.
  493. alloca_size = sizeof(Variant *) * 3 + sizeof(Variant *) * _instruction_args_size + sizeof(Variant) * _stack_size;
  494. uint8_t *aptr = (uint8_t *)alloca(alloca_size);
  495. stack = (Variant *)aptr;
  496. for (int i = 0; i < p_argcount; i++) {
  497. if (!argument_types[i].has_type) {
  498. memnew_placement(&stack[i + 3], Variant(*p_args[i]));
  499. continue;
  500. }
  501. // If types already match, don't call Variant::construct(). Constructors of some types
  502. // (e.g. packed arrays) do copies, whereas they pass by reference when inside a Variant.
  503. if (argument_types[i].is_type(*p_args[i], false)) {
  504. memnew_placement(&stack[i + 3], Variant(*p_args[i]));
  505. continue;
  506. }
  507. if (!argument_types[i].is_type(*p_args[i], true)) {
  508. r_err.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
  509. r_err.argument = i;
  510. r_err.expected = argument_types[i].builtin_type;
  511. call_depth--;
  512. return _get_default_variant_for_data_type(return_type);
  513. }
  514. if (argument_types[i].kind == GDScriptDataType::BUILTIN) {
  515. Variant arg;
  516. Variant::construct(argument_types[i].builtin_type, arg, &p_args[i], 1, r_err);
  517. memnew_placement(&stack[i + 3], Variant(arg));
  518. } else {
  519. memnew_placement(&stack[i + 3], Variant(*p_args[i]));
  520. }
  521. }
  522. for (int i = p_argcount + 3; i < _stack_size; i++) {
  523. memnew_placement(&stack[i], Variant);
  524. }
  525. if (_instruction_args_size) {
  526. instruction_args = (Variant **)&aptr[sizeof(Variant) * _stack_size];
  527. } else {
  528. instruction_args = nullptr;
  529. }
  530. for (const KeyValue<int, Variant::Type> &E : temporary_slots) {
  531. type_init_function_table[E.value](&stack[E.key]);
  532. }
  533. }
  534. if (p_instance) {
  535. memnew_placement(&stack[ADDR_STACK_SELF], Variant(p_instance->owner));
  536. script = p_instance->script.ptr();
  537. } else {
  538. memnew_placement(&stack[ADDR_STACK_SELF], Variant);
  539. script = _script;
  540. }
  541. memnew_placement(&stack[ADDR_STACK_CLASS], Variant(script));
  542. memnew_placement(&stack[ADDR_STACK_NIL], Variant);
  543. String err_text;
  544. #ifdef DEBUG_ENABLED
  545. if (EngineDebugger::is_active()) {
  546. GDScriptLanguage::get_singleton()->enter_function(p_instance, this, stack, &ip, &line);
  547. }
  548. #define GD_ERR_BREAK(m_cond) \
  549. { \
  550. if (unlikely(m_cond)) { \
  551. _err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Condition ' " _STR(m_cond) " ' is true. Breaking..:"); \
  552. OPCODE_BREAK; \
  553. } \
  554. }
  555. #define CHECK_SPACE(m_space) \
  556. GD_ERR_BREAK((ip + m_space) > _code_size)
  557. #define GET_VARIANT_PTR(m_v, m_code_ofs) \
  558. Variant *m_v; \
  559. { \
  560. int address = _code_ptr[ip + 1 + (m_code_ofs)]; \
  561. int address_type = (address & ADDR_TYPE_MASK) >> ADDR_BITS; \
  562. if (unlikely(address_type < 0 || address_type >= ADDR_TYPE_MAX)) { \
  563. err_text = "Bad address type."; \
  564. OPCODE_BREAK; \
  565. } \
  566. int address_index = address & ADDR_MASK; \
  567. if (unlikely(address_index < 0 || address_index >= variant_address_limits[address_type])) { \
  568. if (address_type == ADDR_TYPE_MEMBER && !p_instance) { \
  569. err_text = "Cannot access member without instance."; \
  570. } else { \
  571. err_text = "Bad address index."; \
  572. } \
  573. OPCODE_BREAK; \
  574. } \
  575. m_v = &variant_addresses[address_type][address_index]; \
  576. if (unlikely(!m_v)) \
  577. OPCODE_BREAK; \
  578. }
  579. #else
  580. #define GD_ERR_BREAK(m_cond)
  581. #define CHECK_SPACE(m_space)
  582. #define GET_VARIANT_PTR(m_v, m_code_ofs) \
  583. Variant *m_v; \
  584. { \
  585. int address = _code_ptr[ip + 1 + (m_code_ofs)]; \
  586. m_v = &variant_addresses[(address & ADDR_TYPE_MASK) >> ADDR_BITS][address & ADDR_MASK]; \
  587. if (unlikely(!m_v)) \
  588. OPCODE_BREAK; \
  589. }
  590. #endif
  591. #define LOAD_INSTRUCTION_ARGS \
  592. int instr_arg_count = _code_ptr[ip + 1]; \
  593. for (int i = 0; i < instr_arg_count; i++) { \
  594. GET_VARIANT_PTR(v, i + 1); \
  595. instruction_args[i] = v; \
  596. } \
  597. ip += 1; // Offset to skip instruction argcount.
  598. #define GET_INSTRUCTION_ARG(m_v, m_idx) \
  599. Variant *m_v = instruction_args[m_idx]
  600. #ifdef DEBUG_ENABLED
  601. uint64_t function_start_time = 0;
  602. uint64_t function_call_time = 0;
  603. if (GDScriptLanguage::get_singleton()->profiling) {
  604. function_start_time = OS::get_singleton()->get_ticks_usec();
  605. function_call_time = 0;
  606. profile.call_count.increment();
  607. profile.frame_call_count.increment();
  608. }
  609. bool exit_ok = false;
  610. bool awaited = false;
  611. int variant_address_limits[ADDR_TYPE_MAX] = { _stack_size, _constant_count, p_instance ? (int)p_instance->members.size() : 0 };
  612. #endif
  613. Variant *variant_addresses[ADDR_TYPE_MAX] = { stack, _constants_ptr, p_instance ? p_instance->members.ptrw() : nullptr };
  614. #ifdef DEBUG_ENABLED
  615. OPCODE_WHILE(ip < _code_size) {
  616. int last_opcode = _code_ptr[ip];
  617. #else
  618. OPCODE_WHILE(true) {
  619. #endif
  620. OPCODE_SWITCH(_code_ptr[ip]) {
  621. OPCODE(OPCODE_OPERATOR) {
  622. constexpr int _pointer_size = sizeof(Variant::ValidatedOperatorEvaluator) / sizeof(*_code_ptr);
  623. CHECK_SPACE(7 + _pointer_size);
  624. bool valid;
  625. Variant::Operator op = (Variant::Operator)_code_ptr[ip + 4];
  626. GD_ERR_BREAK(op >= Variant::OP_MAX);
  627. GET_VARIANT_PTR(a, 0);
  628. GET_VARIANT_PTR(b, 1);
  629. GET_VARIANT_PTR(dst, 2);
  630. // Compute signatures (types of operands) so it can be optimized when matching.
  631. uint32_t op_signature = _code_ptr[ip + 5];
  632. uint32_t actual_signature = (a->get_type() << 8) | (b->get_type());
  633. #ifdef DEBUG_ENABLED
  634. if (op == Variant::OP_DIVIDE || op == Variant::OP_MODULE) {
  635. // Don't optimize division and modulo since there's not check for division by zero with validated calls.
  636. op_signature = 0xFFFF;
  637. _code_ptr[ip + 5] = op_signature;
  638. }
  639. #endif
  640. // Check if this is the first run. If so, store the current signature for the optimized path.
  641. if (unlikely(op_signature == 0)) {
  642. static Mutex initializer_mutex;
  643. initializer_mutex.lock();
  644. Variant::Type a_type = (Variant::Type)((actual_signature >> 8) & 0xFF);
  645. Variant::Type b_type = (Variant::Type)(actual_signature & 0xFF);
  646. Variant::ValidatedOperatorEvaluator op_func = Variant::get_validated_operator_evaluator(op, a_type, b_type);
  647. if (unlikely(!op_func)) {
  648. #ifdef DEBUG_ENABLED
  649. err_text = "Invalid operands '" + Variant::get_type_name(a->get_type()) + "' and '" + Variant::get_type_name(b->get_type()) + "' in operator '" + Variant::get_operator_name(op) + "'.";
  650. #endif
  651. initializer_mutex.unlock();
  652. OPCODE_BREAK;
  653. } else {
  654. Variant::Type ret_type = Variant::get_operator_return_type(op, a_type, b_type);
  655. VariantInternal::initialize(dst, ret_type);
  656. op_func(a, b, dst);
  657. // Check again in case another thread already set it.
  658. if (_code_ptr[ip + 5] == 0) {
  659. _code_ptr[ip + 5] = actual_signature;
  660. _code_ptr[ip + 6] = static_cast<int>(ret_type);
  661. Variant::ValidatedOperatorEvaluator *tmp = reinterpret_cast<Variant::ValidatedOperatorEvaluator *>(&_code_ptr[ip + 7]);
  662. *tmp = op_func;
  663. }
  664. }
  665. initializer_mutex.unlock();
  666. } else if (likely(op_signature == actual_signature)) {
  667. // If the signature matches, we can use the optimized path.
  668. Variant::Type ret_type = static_cast<Variant::Type>(_code_ptr[ip + 6]);
  669. Variant::ValidatedOperatorEvaluator op_func = *reinterpret_cast<Variant::ValidatedOperatorEvaluator *>(&_code_ptr[ip + 7]);
  670. // Make sure the return value has the correct type.
  671. VariantInternal::initialize(dst, ret_type);
  672. op_func(a, b, dst);
  673. } else {
  674. // If the signature doesn't match, we have to use the slow path.
  675. #ifdef DEBUG_ENABLED
  676. Variant ret;
  677. Variant::evaluate(op, *a, *b, ret, valid);
  678. #else
  679. Variant::evaluate(op, *a, *b, *dst, valid);
  680. #endif
  681. #ifdef DEBUG_ENABLED
  682. if (!valid) {
  683. if (ret.get_type() == Variant::STRING) {
  684. //return a string when invalid with the error
  685. err_text = ret;
  686. err_text += " in operator '" + Variant::get_operator_name(op) + "'.";
  687. } else {
  688. err_text = "Invalid operands '" + Variant::get_type_name(a->get_type()) + "' and '" + Variant::get_type_name(b->get_type()) + "' in operator '" + Variant::get_operator_name(op) + "'.";
  689. }
  690. OPCODE_BREAK;
  691. }
  692. *dst = ret;
  693. #endif
  694. }
  695. ip += 7 + _pointer_size;
  696. }
  697. DISPATCH_OPCODE;
  698. OPCODE(OPCODE_OPERATOR_VALIDATED) {
  699. CHECK_SPACE(5);
  700. int operator_idx = _code_ptr[ip + 4];
  701. GD_ERR_BREAK(operator_idx < 0 || operator_idx >= _operator_funcs_count);
  702. Variant::ValidatedOperatorEvaluator operator_func = _operator_funcs_ptr[operator_idx];
  703. GET_VARIANT_PTR(a, 0);
  704. GET_VARIANT_PTR(b, 1);
  705. GET_VARIANT_PTR(dst, 2);
  706. operator_func(a, b, dst);
  707. ip += 5;
  708. }
  709. DISPATCH_OPCODE;
  710. OPCODE(OPCODE_TYPE_TEST_BUILTIN) {
  711. CHECK_SPACE(4);
  712. GET_VARIANT_PTR(dst, 0);
  713. GET_VARIANT_PTR(value, 1);
  714. Variant::Type builtin_type = (Variant::Type)_code_ptr[ip + 3];
  715. GD_ERR_BREAK(builtin_type < 0 || builtin_type >= Variant::VARIANT_MAX);
  716. *dst = value->get_type() == builtin_type;
  717. ip += 4;
  718. }
  719. DISPATCH_OPCODE;
  720. OPCODE(OPCODE_TYPE_TEST_ARRAY) {
  721. CHECK_SPACE(6);
  722. GET_VARIANT_PTR(dst, 0);
  723. GET_VARIANT_PTR(value, 1);
  724. GET_VARIANT_PTR(script_type, 2);
  725. Variant::Type builtin_type = (Variant::Type)_code_ptr[ip + 4];
  726. int native_type_idx = _code_ptr[ip + 5];
  727. GD_ERR_BREAK(native_type_idx < 0 || native_type_idx >= _global_names_count);
  728. const StringName native_type = _global_names_ptr[native_type_idx];
  729. bool result = false;
  730. if (value->get_type() == Variant::ARRAY) {
  731. Array *array = VariantInternal::get_array(value);
  732. result = array->get_typed_builtin() == ((uint32_t)builtin_type) && array->get_typed_class_name() == native_type && array->get_typed_script() == *script_type;
  733. }
  734. *dst = result;
  735. ip += 6;
  736. }
  737. DISPATCH_OPCODE;
  738. OPCODE(OPCODE_TYPE_TEST_NATIVE) {
  739. CHECK_SPACE(4);
  740. GET_VARIANT_PTR(dst, 0);
  741. GET_VARIANT_PTR(value, 1);
  742. int native_type_idx = _code_ptr[ip + 3];
  743. GD_ERR_BREAK(native_type_idx < 0 || native_type_idx >= _global_names_count);
  744. const StringName native_type = _global_names_ptr[native_type_idx];
  745. bool was_freed = false;
  746. Object *object = value->get_validated_object_with_check(was_freed);
  747. if (was_freed) {
  748. err_text = "Left operand of 'is' is a previously freed instance.";
  749. OPCODE_BREAK;
  750. }
  751. *dst = object && ClassDB::is_parent_class(object->get_class_name(), native_type);
  752. ip += 4;
  753. }
  754. DISPATCH_OPCODE;
  755. OPCODE(OPCODE_TYPE_TEST_SCRIPT) {
  756. CHECK_SPACE(4);
  757. GET_VARIANT_PTR(dst, 0);
  758. GET_VARIANT_PTR(value, 1);
  759. GET_VARIANT_PTR(type, 2);
  760. Script *script_type = Object::cast_to<Script>(type->operator Object *());
  761. GD_ERR_BREAK(!script_type);
  762. bool was_freed = false;
  763. Object *object = value->get_validated_object_with_check(was_freed);
  764. if (was_freed) {
  765. err_text = "Left operand of 'is' is a previously freed instance.";
  766. OPCODE_BREAK;
  767. }
  768. bool result = false;
  769. if (object && object->get_script_instance()) {
  770. Script *script_ptr = object->get_script_instance()->get_script().ptr();
  771. while (script_ptr) {
  772. if (script_ptr == script_type) {
  773. result = true;
  774. break;
  775. }
  776. script_ptr = script_ptr->get_base_script().ptr();
  777. }
  778. }
  779. *dst = result;
  780. ip += 4;
  781. }
  782. DISPATCH_OPCODE;
  783. OPCODE(OPCODE_SET_KEYED) {
  784. CHECK_SPACE(3);
  785. GET_VARIANT_PTR(dst, 0);
  786. GET_VARIANT_PTR(index, 1);
  787. GET_VARIANT_PTR(value, 2);
  788. bool valid;
  789. #ifdef DEBUG_ENABLED
  790. Variant::VariantSetError err_code;
  791. dst->set(*index, *value, &valid, &err_code);
  792. #else
  793. dst->set(*index, *value, &valid);
  794. #endif
  795. #ifdef DEBUG_ENABLED
  796. if (!valid) {
  797. if (dst->is_read_only()) {
  798. err_text = "Invalid assignment on read-only value (on base: '" + _get_var_type(dst) + "').";
  799. } else {
  800. Object *obj = dst->get_validated_object();
  801. String v = index->operator String();
  802. bool read_only_property = false;
  803. if (obj) {
  804. read_only_property = ClassDB::has_property(obj->get_class_name(), v) && (ClassDB::get_property_setter(obj->get_class_name(), v) == StringName());
  805. }
  806. if (read_only_property) {
  807. err_text = vformat(R"(Cannot set value into property "%s" (on base "%s") because it is read-only.)", v, _get_var_type(dst));
  808. } else {
  809. if (!v.is_empty()) {
  810. v = "'" + v + "'";
  811. } else {
  812. v = "of type '" + _get_var_type(index) + "'";
  813. }
  814. err_text = "Invalid assignment of property or key " + v + " with value of type '" + _get_var_type(value) + "' on a base object of type '" + _get_var_type(dst) + "'.";
  815. if (err_code == Variant::VariantSetError::SET_INDEXED_ERR) {
  816. err_text = "Invalid assignment of index " + v + " (on base: '" + _get_var_type(dst) + "') with value of type '" + _get_var_type(value) + "'.";
  817. }
  818. }
  819. }
  820. OPCODE_BREAK;
  821. }
  822. #endif
  823. ip += 4;
  824. }
  825. DISPATCH_OPCODE;
  826. OPCODE(OPCODE_SET_KEYED_VALIDATED) {
  827. CHECK_SPACE(4);
  828. GET_VARIANT_PTR(dst, 0);
  829. GET_VARIANT_PTR(index, 1);
  830. GET_VARIANT_PTR(value, 2);
  831. int index_setter = _code_ptr[ip + 4];
  832. GD_ERR_BREAK(index_setter < 0 || index_setter >= _keyed_setters_count);
  833. const Variant::ValidatedKeyedSetter setter = _keyed_setters_ptr[index_setter];
  834. bool valid;
  835. setter(dst, index, value, &valid);
  836. #ifdef DEBUG_ENABLED
  837. if (!valid) {
  838. if (dst->is_read_only()) {
  839. err_text = "Invalid assignment on read-only value (on base: '" + _get_var_type(dst) + "').";
  840. } else {
  841. String v = index->operator String();
  842. if (!v.is_empty()) {
  843. v = "'" + v + "'";
  844. } else {
  845. v = "of type '" + _get_var_type(index) + "'";
  846. }
  847. err_text = "Invalid assignment of property or key " + v + " with value of type '" + _get_var_type(value) + "' on a base object of type '" + _get_var_type(dst) + "'.";
  848. }
  849. OPCODE_BREAK;
  850. }
  851. #endif
  852. ip += 5;
  853. }
  854. DISPATCH_OPCODE;
  855. OPCODE(OPCODE_SET_INDEXED_VALIDATED) {
  856. CHECK_SPACE(4);
  857. GET_VARIANT_PTR(dst, 0);
  858. GET_VARIANT_PTR(index, 1);
  859. GET_VARIANT_PTR(value, 2);
  860. int index_setter = _code_ptr[ip + 4];
  861. GD_ERR_BREAK(index_setter < 0 || index_setter >= _indexed_setters_count);
  862. const Variant::ValidatedIndexedSetter setter = _indexed_setters_ptr[index_setter];
  863. int64_t int_index = *VariantInternal::get_int(index);
  864. bool oob;
  865. setter(dst, int_index, value, &oob);
  866. #ifdef DEBUG_ENABLED
  867. if (oob) {
  868. if (dst->is_read_only()) {
  869. err_text = "Invalid assignment on read-only value (on base: '" + _get_var_type(dst) + "').";
  870. } else {
  871. String v = index->operator String();
  872. if (!v.is_empty()) {
  873. v = "'" + v + "'";
  874. } else {
  875. v = "of type '" + _get_var_type(index) + "'";
  876. }
  877. err_text = "Out of bounds set index " + v + " (on base: '" + _get_var_type(dst) + "')";
  878. }
  879. OPCODE_BREAK;
  880. }
  881. #endif
  882. ip += 5;
  883. }
  884. DISPATCH_OPCODE;
  885. OPCODE(OPCODE_GET_KEYED) {
  886. CHECK_SPACE(3);
  887. GET_VARIANT_PTR(src, 0);
  888. GET_VARIANT_PTR(index, 1);
  889. GET_VARIANT_PTR(dst, 2);
  890. bool valid;
  891. #ifdef DEBUG_ENABLED
  892. // Allow better error message in cases where src and dst are the same stack position.
  893. Variant::VariantGetError err_code;
  894. Variant ret = src->get(*index, &valid, &err_code);
  895. #else
  896. *dst = src->get(*index, &valid);
  897. #endif
  898. #ifdef DEBUG_ENABLED
  899. if (!valid) {
  900. String v = index->operator String();
  901. if (!v.is_empty()) {
  902. v = "'" + v + "'";
  903. } else {
  904. v = "of type '" + _get_var_type(index) + "'";
  905. }
  906. err_text = "Invalid access to property or key " + v + " on a base object of type '" + _get_var_type(src) + "'.";
  907. if (err_code == Variant::VariantGetError::GET_INDEXED_ERR) {
  908. err_text = "Invalid access of index " + v + " on a base object of type: '" + _get_var_type(src) + "'.";
  909. }
  910. OPCODE_BREAK;
  911. }
  912. *dst = ret;
  913. #endif
  914. ip += 4;
  915. }
  916. DISPATCH_OPCODE;
  917. OPCODE(OPCODE_GET_KEYED_VALIDATED) {
  918. CHECK_SPACE(4);
  919. GET_VARIANT_PTR(src, 0);
  920. GET_VARIANT_PTR(key, 1);
  921. GET_VARIANT_PTR(dst, 2);
  922. int index_getter = _code_ptr[ip + 4];
  923. GD_ERR_BREAK(index_getter < 0 || index_getter >= _keyed_getters_count);
  924. const Variant::ValidatedKeyedGetter getter = _keyed_getters_ptr[index_getter];
  925. bool valid;
  926. #ifdef DEBUG_ENABLED
  927. // Allow better error message in cases where src and dst are the same stack position.
  928. Variant ret;
  929. getter(src, key, &ret, &valid);
  930. #else
  931. getter(src, key, dst, &valid);
  932. #endif
  933. #ifdef DEBUG_ENABLED
  934. if (!valid) {
  935. String v = key->operator String();
  936. if (!v.is_empty()) {
  937. v = "'" + v + "'";
  938. } else {
  939. v = "of type '" + _get_var_type(key) + "'";
  940. }
  941. err_text = "Invalid access to property or key " + v + " on a base object of type '" + _get_var_type(src) + "'.";
  942. OPCODE_BREAK;
  943. }
  944. *dst = ret;
  945. #endif
  946. ip += 5;
  947. }
  948. DISPATCH_OPCODE;
  949. OPCODE(OPCODE_GET_INDEXED_VALIDATED) {
  950. CHECK_SPACE(4);
  951. GET_VARIANT_PTR(src, 0);
  952. GET_VARIANT_PTR(index, 1);
  953. GET_VARIANT_PTR(dst, 2);
  954. int index_getter = _code_ptr[ip + 4];
  955. GD_ERR_BREAK(index_getter < 0 || index_getter >= _indexed_getters_count);
  956. const Variant::ValidatedIndexedGetter getter = _indexed_getters_ptr[index_getter];
  957. int64_t int_index = *VariantInternal::get_int(index);
  958. bool oob;
  959. getter(src, int_index, dst, &oob);
  960. #ifdef DEBUG_ENABLED
  961. if (oob) {
  962. String v = index->operator String();
  963. if (!v.is_empty()) {
  964. v = "'" + v + "'";
  965. } else {
  966. v = "of type '" + _get_var_type(index) + "'";
  967. }
  968. err_text = "Out of bounds get index " + v + " (on base: '" + _get_var_type(src) + "')";
  969. OPCODE_BREAK;
  970. }
  971. #endif
  972. ip += 5;
  973. }
  974. DISPATCH_OPCODE;
  975. OPCODE(OPCODE_SET_NAMED) {
  976. CHECK_SPACE(3);
  977. GET_VARIANT_PTR(dst, 0);
  978. GET_VARIANT_PTR(value, 1);
  979. int indexname = _code_ptr[ip + 3];
  980. GD_ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
  981. const StringName *index = &_global_names_ptr[indexname];
  982. bool valid;
  983. dst->set_named(*index, *value, valid);
  984. #ifdef DEBUG_ENABLED
  985. if (!valid) {
  986. if (dst->is_read_only()) {
  987. err_text = "Invalid assignment on read-only value (on base: '" + _get_var_type(dst) + "').";
  988. } else {
  989. Object *obj = dst->get_validated_object();
  990. bool read_only_property = false;
  991. if (obj) {
  992. read_only_property = ClassDB::has_property(obj->get_class_name(), *index) && (ClassDB::get_property_setter(obj->get_class_name(), *index) == StringName());
  993. }
  994. if (read_only_property) {
  995. err_text = vformat(R"(Cannot set value into property "%s" (on base "%s") because it is read-only.)", String(*index), _get_var_type(dst));
  996. } else {
  997. err_text = "Invalid assignment of property or key '" + String(*index) + "' with value of type '" + _get_var_type(value) + "' on a base object of type '" + _get_var_type(dst) + "'.";
  998. }
  999. }
  1000. OPCODE_BREAK;
  1001. }
  1002. #endif
  1003. ip += 4;
  1004. }
  1005. DISPATCH_OPCODE;
  1006. OPCODE(OPCODE_SET_NAMED_VALIDATED) {
  1007. CHECK_SPACE(3);
  1008. GET_VARIANT_PTR(dst, 0);
  1009. GET_VARIANT_PTR(value, 1);
  1010. int index_setter = _code_ptr[ip + 3];
  1011. GD_ERR_BREAK(index_setter < 0 || index_setter >= _setters_count);
  1012. const Variant::ValidatedSetter setter = _setters_ptr[index_setter];
  1013. setter(dst, value);
  1014. ip += 4;
  1015. }
  1016. DISPATCH_OPCODE;
  1017. OPCODE(OPCODE_GET_NAMED) {
  1018. CHECK_SPACE(4);
  1019. GET_VARIANT_PTR(src, 0);
  1020. GET_VARIANT_PTR(dst, 1);
  1021. int indexname = _code_ptr[ip + 3];
  1022. GD_ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
  1023. const StringName *index = &_global_names_ptr[indexname];
  1024. bool valid;
  1025. #ifdef DEBUG_ENABLED
  1026. //allow better error message in cases where src and dst are the same stack position
  1027. Variant ret = src->get_named(*index, valid);
  1028. #else
  1029. *dst = src->get_named(*index, valid);
  1030. #endif
  1031. #ifdef DEBUG_ENABLED
  1032. if (!valid) {
  1033. err_text = "Invalid access to property or key '" + index->operator String() + "' on a base object of type '" + _get_var_type(src) + "'.";
  1034. OPCODE_BREAK;
  1035. }
  1036. *dst = ret;
  1037. #endif
  1038. ip += 4;
  1039. }
  1040. DISPATCH_OPCODE;
  1041. OPCODE(OPCODE_GET_NAMED_VALIDATED) {
  1042. CHECK_SPACE(3);
  1043. GET_VARIANT_PTR(src, 0);
  1044. GET_VARIANT_PTR(dst, 1);
  1045. int index_getter = _code_ptr[ip + 3];
  1046. GD_ERR_BREAK(index_getter < 0 || index_getter >= _getters_count);
  1047. const Variant::ValidatedGetter getter = _getters_ptr[index_getter];
  1048. getter(src, dst);
  1049. ip += 4;
  1050. }
  1051. DISPATCH_OPCODE;
  1052. OPCODE(OPCODE_SET_MEMBER) {
  1053. CHECK_SPACE(3);
  1054. GET_VARIANT_PTR(src, 0);
  1055. int indexname = _code_ptr[ip + 2];
  1056. GD_ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
  1057. const StringName *index = &_global_names_ptr[indexname];
  1058. bool valid;
  1059. #ifndef DEBUG_ENABLED
  1060. ClassDB::set_property(p_instance->owner, *index, *src, &valid);
  1061. #else
  1062. bool ok = ClassDB::set_property(p_instance->owner, *index, *src, &valid);
  1063. if (!ok) {
  1064. err_text = "Internal error setting property: " + String(*index);
  1065. OPCODE_BREAK;
  1066. } else if (!valid) {
  1067. err_text = "Error setting property '" + String(*index) + "' with value of type " + Variant::get_type_name(src->get_type()) + ".";
  1068. OPCODE_BREAK;
  1069. }
  1070. #endif
  1071. ip += 3;
  1072. }
  1073. DISPATCH_OPCODE;
  1074. OPCODE(OPCODE_GET_MEMBER) {
  1075. CHECK_SPACE(3);
  1076. GET_VARIANT_PTR(dst, 0);
  1077. int indexname = _code_ptr[ip + 2];
  1078. GD_ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
  1079. const StringName *index = &_global_names_ptr[indexname];
  1080. #ifndef DEBUG_ENABLED
  1081. ClassDB::get_property(p_instance->owner, *index, *dst);
  1082. #else
  1083. bool ok = ClassDB::get_property(p_instance->owner, *index, *dst);
  1084. if (!ok) {
  1085. err_text = "Internal error getting property: " + String(*index);
  1086. OPCODE_BREAK;
  1087. }
  1088. #endif
  1089. ip += 3;
  1090. }
  1091. DISPATCH_OPCODE;
  1092. OPCODE(OPCODE_SET_STATIC_VARIABLE) {
  1093. CHECK_SPACE(4);
  1094. GET_VARIANT_PTR(value, 0);
  1095. GET_VARIANT_PTR(_class, 1);
  1096. GDScript *gdscript = Object::cast_to<GDScript>(_class->operator Object *());
  1097. GD_ERR_BREAK(!gdscript);
  1098. int index = _code_ptr[ip + 3];
  1099. GD_ERR_BREAK(index < 0 || index >= gdscript->static_variables.size());
  1100. gdscript->static_variables.write[index] = *value;
  1101. ip += 4;
  1102. }
  1103. DISPATCH_OPCODE;
  1104. OPCODE(OPCODE_GET_STATIC_VARIABLE) {
  1105. CHECK_SPACE(4);
  1106. GET_VARIANT_PTR(target, 0);
  1107. GET_VARIANT_PTR(_class, 1);
  1108. GDScript *gdscript = Object::cast_to<GDScript>(_class->operator Object *());
  1109. GD_ERR_BREAK(!gdscript);
  1110. int index = _code_ptr[ip + 3];
  1111. GD_ERR_BREAK(index < 0 || index >= gdscript->static_variables.size());
  1112. *target = gdscript->static_variables[index];
  1113. ip += 4;
  1114. }
  1115. DISPATCH_OPCODE;
  1116. OPCODE(OPCODE_ASSIGN) {
  1117. CHECK_SPACE(3);
  1118. GET_VARIANT_PTR(dst, 0);
  1119. GET_VARIANT_PTR(src, 1);
  1120. *dst = *src;
  1121. ip += 3;
  1122. }
  1123. DISPATCH_OPCODE;
  1124. OPCODE(OPCODE_ASSIGN_NULL) {
  1125. CHECK_SPACE(2);
  1126. GET_VARIANT_PTR(dst, 0);
  1127. *dst = Variant();
  1128. ip += 2;
  1129. }
  1130. DISPATCH_OPCODE;
  1131. OPCODE(OPCODE_ASSIGN_TRUE) {
  1132. CHECK_SPACE(2);
  1133. GET_VARIANT_PTR(dst, 0);
  1134. *dst = true;
  1135. ip += 2;
  1136. }
  1137. DISPATCH_OPCODE;
  1138. OPCODE(OPCODE_ASSIGN_FALSE) {
  1139. CHECK_SPACE(2);
  1140. GET_VARIANT_PTR(dst, 0);
  1141. *dst = false;
  1142. ip += 2;
  1143. }
  1144. DISPATCH_OPCODE;
  1145. OPCODE(OPCODE_ASSIGN_TYPED_BUILTIN) {
  1146. CHECK_SPACE(4);
  1147. GET_VARIANT_PTR(dst, 0);
  1148. GET_VARIANT_PTR(src, 1);
  1149. Variant::Type var_type = (Variant::Type)_code_ptr[ip + 3];
  1150. GD_ERR_BREAK(var_type < 0 || var_type >= Variant::VARIANT_MAX);
  1151. if (src->get_type() != var_type) {
  1152. #ifdef DEBUG_ENABLED
  1153. if (Variant::can_convert_strict(src->get_type(), var_type)) {
  1154. #endif // DEBUG_ENABLED
  1155. Callable::CallError ce;
  1156. Variant::construct(var_type, *dst, const_cast<const Variant **>(&src), 1, ce);
  1157. } else {
  1158. #ifdef DEBUG_ENABLED
  1159. err_text = "Trying to assign value of type '" + Variant::get_type_name(src->get_type()) +
  1160. "' to a variable of type '" + Variant::get_type_name(var_type) + "'.";
  1161. OPCODE_BREAK;
  1162. }
  1163. } else {
  1164. #endif // DEBUG_ENABLED
  1165. *dst = *src;
  1166. }
  1167. ip += 4;
  1168. }
  1169. DISPATCH_OPCODE;
  1170. OPCODE(OPCODE_ASSIGN_TYPED_ARRAY) {
  1171. CHECK_SPACE(6);
  1172. GET_VARIANT_PTR(dst, 0);
  1173. GET_VARIANT_PTR(src, 1);
  1174. GET_VARIANT_PTR(script_type, 2);
  1175. Variant::Type builtin_type = (Variant::Type)_code_ptr[ip + 4];
  1176. int native_type_idx = _code_ptr[ip + 5];
  1177. GD_ERR_BREAK(native_type_idx < 0 || native_type_idx >= _global_names_count);
  1178. const StringName native_type = _global_names_ptr[native_type_idx];
  1179. if (src->get_type() != Variant::ARRAY) {
  1180. #ifdef DEBUG_ENABLED
  1181. err_text = vformat(R"(Trying to assign a value of type "%s" to a variable of type "Array[%s]".)",
  1182. _get_var_type(src), _get_element_type(builtin_type, native_type, *script_type));
  1183. #endif // DEBUG_ENABLED
  1184. OPCODE_BREAK;
  1185. }
  1186. Array *array = VariantInternal::get_array(src);
  1187. if (array->get_typed_builtin() != ((uint32_t)builtin_type) || array->get_typed_class_name() != native_type || array->get_typed_script() != *script_type) {
  1188. #ifdef DEBUG_ENABLED
  1189. err_text = vformat(R"(Trying to assign an array of type "%s" to a variable of type "Array[%s]".)",
  1190. _get_var_type(src), _get_element_type(builtin_type, native_type, *script_type));
  1191. #endif // DEBUG_ENABLED
  1192. OPCODE_BREAK;
  1193. }
  1194. *dst = *src;
  1195. ip += 6;
  1196. }
  1197. DISPATCH_OPCODE;
  1198. OPCODE(OPCODE_ASSIGN_TYPED_NATIVE) {
  1199. CHECK_SPACE(4);
  1200. GET_VARIANT_PTR(dst, 0);
  1201. GET_VARIANT_PTR(src, 1);
  1202. #ifdef DEBUG_ENABLED
  1203. GET_VARIANT_PTR(type, 2);
  1204. GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(type->operator Object *());
  1205. GD_ERR_BREAK(!nc);
  1206. if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
  1207. err_text = "Trying to assign value of type '" + Variant::get_type_name(src->get_type()) +
  1208. "' to a variable of type '" + nc->get_name() + "'.";
  1209. OPCODE_BREAK;
  1210. }
  1211. if (src->get_type() == Variant::OBJECT) {
  1212. bool was_freed = false;
  1213. Object *src_obj = src->get_validated_object_with_check(was_freed);
  1214. if (!src_obj && was_freed) {
  1215. err_text = "Trying to assign invalid previously freed instance.";
  1216. OPCODE_BREAK;
  1217. }
  1218. if (src_obj && !ClassDB::is_parent_class(src_obj->get_class_name(), nc->get_name())) {
  1219. err_text = "Trying to assign value of type '" + src_obj->get_class_name() +
  1220. "' to a variable of type '" + nc->get_name() + "'.";
  1221. OPCODE_BREAK;
  1222. }
  1223. }
  1224. #endif // DEBUG_ENABLED
  1225. *dst = *src;
  1226. ip += 4;
  1227. }
  1228. DISPATCH_OPCODE;
  1229. OPCODE(OPCODE_ASSIGN_TYPED_SCRIPT) {
  1230. CHECK_SPACE(4);
  1231. GET_VARIANT_PTR(dst, 0);
  1232. GET_VARIANT_PTR(src, 1);
  1233. #ifdef DEBUG_ENABLED
  1234. GET_VARIANT_PTR(type, 2);
  1235. Script *base_type = Object::cast_to<Script>(type->operator Object *());
  1236. GD_ERR_BREAK(!base_type);
  1237. if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
  1238. err_text = "Trying to assign a non-object value to a variable of type '" + base_type->get_path().get_file() + "'.";
  1239. OPCODE_BREAK;
  1240. }
  1241. if (src->get_type() == Variant::OBJECT) {
  1242. bool was_freed = false;
  1243. Object *val_obj = src->get_validated_object_with_check(was_freed);
  1244. if (!val_obj && was_freed) {
  1245. err_text = "Trying to assign invalid previously freed instance.";
  1246. OPCODE_BREAK;
  1247. }
  1248. if (val_obj) { // src is not null
  1249. ScriptInstance *scr_inst = val_obj->get_script_instance();
  1250. if (!scr_inst) {
  1251. err_text = "Trying to assign value of type '" + val_obj->get_class_name() +
  1252. "' to a variable of type '" + base_type->get_path().get_file() + "'.";
  1253. OPCODE_BREAK;
  1254. }
  1255. Script *src_type = scr_inst->get_script().ptr();
  1256. bool valid = false;
  1257. while (src_type) {
  1258. if (src_type == base_type) {
  1259. valid = true;
  1260. break;
  1261. }
  1262. src_type = src_type->get_base_script().ptr();
  1263. }
  1264. if (!valid) {
  1265. err_text = "Trying to assign value of type '" + val_obj->get_script_instance()->get_script()->get_path().get_file() +
  1266. "' to a variable of type '" + base_type->get_path().get_file() + "'.";
  1267. OPCODE_BREAK;
  1268. }
  1269. }
  1270. }
  1271. #endif // DEBUG_ENABLED
  1272. *dst = *src;
  1273. ip += 4;
  1274. }
  1275. DISPATCH_OPCODE;
  1276. OPCODE(OPCODE_CAST_TO_BUILTIN) {
  1277. CHECK_SPACE(4);
  1278. GET_VARIANT_PTR(src, 0);
  1279. GET_VARIANT_PTR(dst, 1);
  1280. Variant::Type to_type = (Variant::Type)_code_ptr[ip + 3];
  1281. GD_ERR_BREAK(to_type < 0 || to_type >= Variant::VARIANT_MAX);
  1282. #ifdef DEBUG_ENABLED
  1283. if (src->operator Object *() && !src->get_validated_object()) {
  1284. err_text = "Trying to cast a freed object.";
  1285. OPCODE_BREAK;
  1286. }
  1287. #endif
  1288. Callable::CallError err;
  1289. Variant::construct(to_type, *dst, (const Variant **)&src, 1, err);
  1290. #ifdef DEBUG_ENABLED
  1291. if (err.error != Callable::CallError::CALL_OK) {
  1292. err_text = "Invalid cast: could not convert value to '" + Variant::get_type_name(to_type) + "'.";
  1293. OPCODE_BREAK;
  1294. }
  1295. #endif
  1296. ip += 4;
  1297. }
  1298. DISPATCH_OPCODE;
  1299. OPCODE(OPCODE_CAST_TO_NATIVE) {
  1300. CHECK_SPACE(4);
  1301. GET_VARIANT_PTR(src, 0);
  1302. GET_VARIANT_PTR(dst, 1);
  1303. GET_VARIANT_PTR(to_type, 2);
  1304. GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(to_type->operator Object *());
  1305. GD_ERR_BREAK(!nc);
  1306. #ifdef DEBUG_ENABLED
  1307. if (src->operator Object *() && !src->get_validated_object()) {
  1308. err_text = "Trying to cast a freed object.";
  1309. OPCODE_BREAK;
  1310. }
  1311. if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
  1312. err_text = "Invalid cast: can't convert a non-object value to an object type.";
  1313. OPCODE_BREAK;
  1314. }
  1315. #endif
  1316. Object *src_obj = src->operator Object *();
  1317. if (src_obj && !ClassDB::is_parent_class(src_obj->get_class_name(), nc->get_name())) {
  1318. *dst = Variant(); // invalid cast, assign NULL
  1319. } else {
  1320. *dst = *src;
  1321. }
  1322. ip += 4;
  1323. }
  1324. DISPATCH_OPCODE;
  1325. OPCODE(OPCODE_CAST_TO_SCRIPT) {
  1326. CHECK_SPACE(4);
  1327. GET_VARIANT_PTR(src, 0);
  1328. GET_VARIANT_PTR(dst, 1);
  1329. GET_VARIANT_PTR(to_type, 2);
  1330. Script *base_type = Object::cast_to<Script>(to_type->operator Object *());
  1331. GD_ERR_BREAK(!base_type);
  1332. #ifdef DEBUG_ENABLED
  1333. if (src->operator Object *() && !src->get_validated_object()) {
  1334. err_text = "Trying to cast a freed object.";
  1335. OPCODE_BREAK;
  1336. }
  1337. if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
  1338. err_text = "Trying to assign a non-object value to a variable of type '" + base_type->get_path().get_file() + "'.";
  1339. OPCODE_BREAK;
  1340. }
  1341. #endif
  1342. bool valid = false;
  1343. if (src->get_type() != Variant::NIL && src->operator Object *() != nullptr) {
  1344. ScriptInstance *scr_inst = src->operator Object *()->get_script_instance();
  1345. if (scr_inst) {
  1346. Script *src_type = src->operator Object *()->get_script_instance()->get_script().ptr();
  1347. while (src_type) {
  1348. if (src_type == base_type) {
  1349. valid = true;
  1350. break;
  1351. }
  1352. src_type = src_type->get_base_script().ptr();
  1353. }
  1354. }
  1355. }
  1356. if (valid) {
  1357. *dst = *src; // Valid cast, copy the source object
  1358. } else {
  1359. *dst = Variant(); // invalid cast, assign NULL
  1360. }
  1361. ip += 4;
  1362. }
  1363. DISPATCH_OPCODE;
  1364. OPCODE(OPCODE_CONSTRUCT) {
  1365. LOAD_INSTRUCTION_ARGS
  1366. CHECK_SPACE(2 + instr_arg_count);
  1367. ip += instr_arg_count;
  1368. int argc = _code_ptr[ip + 1];
  1369. Variant::Type t = Variant::Type(_code_ptr[ip + 2]);
  1370. Variant **argptrs = instruction_args;
  1371. GET_INSTRUCTION_ARG(dst, argc);
  1372. Callable::CallError err;
  1373. Variant::construct(t, *dst, (const Variant **)argptrs, argc, err);
  1374. #ifdef DEBUG_ENABLED
  1375. if (err.error != Callable::CallError::CALL_OK) {
  1376. err_text = _get_call_error(err, "'" + Variant::get_type_name(t) + "' constructor", (const Variant **)argptrs);
  1377. OPCODE_BREAK;
  1378. }
  1379. #endif
  1380. ip += 3;
  1381. }
  1382. DISPATCH_OPCODE;
  1383. OPCODE(OPCODE_CONSTRUCT_VALIDATED) {
  1384. LOAD_INSTRUCTION_ARGS
  1385. CHECK_SPACE(2 + instr_arg_count);
  1386. ip += instr_arg_count;
  1387. int argc = _code_ptr[ip + 1];
  1388. int constructor_idx = _code_ptr[ip + 2];
  1389. GD_ERR_BREAK(constructor_idx < 0 || constructor_idx >= _constructors_count);
  1390. Variant::ValidatedConstructor constructor = _constructors_ptr[constructor_idx];
  1391. Variant **argptrs = instruction_args;
  1392. GET_INSTRUCTION_ARG(dst, argc);
  1393. constructor(dst, (const Variant **)argptrs);
  1394. ip += 3;
  1395. }
  1396. DISPATCH_OPCODE;
  1397. OPCODE(OPCODE_CONSTRUCT_ARRAY) {
  1398. LOAD_INSTRUCTION_ARGS
  1399. CHECK_SPACE(1 + instr_arg_count);
  1400. ip += instr_arg_count;
  1401. int argc = _code_ptr[ip + 1];
  1402. Array array;
  1403. array.resize(argc);
  1404. for (int i = 0; i < argc; i++) {
  1405. array[i] = *(instruction_args[i]);
  1406. }
  1407. GET_INSTRUCTION_ARG(dst, argc);
  1408. *dst = Variant(); // Clear potential previous typed array.
  1409. *dst = array;
  1410. ip += 2;
  1411. }
  1412. DISPATCH_OPCODE;
  1413. OPCODE(OPCODE_CONSTRUCT_TYPED_ARRAY) {
  1414. LOAD_INSTRUCTION_ARGS
  1415. CHECK_SPACE(3 + instr_arg_count);
  1416. ip += instr_arg_count;
  1417. int argc = _code_ptr[ip + 1];
  1418. GET_INSTRUCTION_ARG(script_type, argc + 1);
  1419. Variant::Type builtin_type = (Variant::Type)_code_ptr[ip + 2];
  1420. int native_type_idx = _code_ptr[ip + 3];
  1421. GD_ERR_BREAK(native_type_idx < 0 || native_type_idx >= _global_names_count);
  1422. const StringName native_type = _global_names_ptr[native_type_idx];
  1423. Array array;
  1424. array.resize(argc);
  1425. for (int i = 0; i < argc; i++) {
  1426. array[i] = *(instruction_args[i]);
  1427. }
  1428. GET_INSTRUCTION_ARG(dst, argc);
  1429. *dst = Variant(); // Clear potential previous typed array.
  1430. *dst = Array(array, builtin_type, native_type, *script_type);
  1431. ip += 4;
  1432. }
  1433. DISPATCH_OPCODE;
  1434. OPCODE(OPCODE_CONSTRUCT_DICTIONARY) {
  1435. LOAD_INSTRUCTION_ARGS
  1436. CHECK_SPACE(2 + instr_arg_count);
  1437. ip += instr_arg_count;
  1438. int argc = _code_ptr[ip + 1];
  1439. Dictionary dict;
  1440. for (int i = 0; i < argc; i++) {
  1441. GET_INSTRUCTION_ARG(k, i * 2 + 0);
  1442. GET_INSTRUCTION_ARG(v, i * 2 + 1);
  1443. dict[*k] = *v;
  1444. }
  1445. GET_INSTRUCTION_ARG(dst, argc * 2);
  1446. *dst = dict;
  1447. ip += 2;
  1448. }
  1449. DISPATCH_OPCODE;
  1450. OPCODE(OPCODE_CALL_ASYNC)
  1451. OPCODE(OPCODE_CALL_RETURN)
  1452. OPCODE(OPCODE_CALL) {
  1453. bool call_ret = (_code_ptr[ip]) != OPCODE_CALL;
  1454. #ifdef DEBUG_ENABLED
  1455. bool call_async = (_code_ptr[ip]) == OPCODE_CALL_ASYNC;
  1456. #endif
  1457. LOAD_INSTRUCTION_ARGS
  1458. CHECK_SPACE(3 + instr_arg_count);
  1459. ip += instr_arg_count;
  1460. int argc = _code_ptr[ip + 1];
  1461. GD_ERR_BREAK(argc < 0);
  1462. int methodname_idx = _code_ptr[ip + 2];
  1463. GD_ERR_BREAK(methodname_idx < 0 || methodname_idx >= _global_names_count);
  1464. const StringName *methodname = &_global_names_ptr[methodname_idx];
  1465. GET_INSTRUCTION_ARG(base, argc);
  1466. Variant **argptrs = instruction_args;
  1467. #ifdef DEBUG_ENABLED
  1468. uint64_t call_time = 0;
  1469. if (GDScriptLanguage::get_singleton()->profiling) {
  1470. call_time = OS::get_singleton()->get_ticks_usec();
  1471. }
  1472. Variant::Type base_type = base->get_type();
  1473. Object *base_obj = base->get_validated_object();
  1474. StringName base_class = base_obj ? base_obj->get_class_name() : StringName();
  1475. #endif
  1476. Callable::CallError err;
  1477. if (call_ret) {
  1478. GET_INSTRUCTION_ARG(ret, argc + 1);
  1479. base->callp(*methodname, (const Variant **)argptrs, argc, *ret, err);
  1480. #ifdef DEBUG_ENABLED
  1481. if (ret->get_type() == Variant::NIL) {
  1482. if (base_type == Variant::OBJECT) {
  1483. if (base_obj) {
  1484. MethodBind *method = ClassDB::get_method(base_class, *methodname);
  1485. if (*methodname == CoreStringName(free_) || (method && !method->has_return())) {
  1486. err_text = R"(Trying to get a return value of a method that returns "void")";
  1487. OPCODE_BREAK;
  1488. }
  1489. }
  1490. } else if (Variant::has_builtin_method(base_type, *methodname) && !Variant::has_builtin_method_return_value(base_type, *methodname)) {
  1491. err_text = R"(Trying to get a return value of a method that returns "void")";
  1492. OPCODE_BREAK;
  1493. }
  1494. }
  1495. if (!call_async && ret->get_type() == Variant::OBJECT) {
  1496. // Check if getting a function state without await.
  1497. bool was_freed = false;
  1498. Object *obj = ret->get_validated_object_with_check(was_freed);
  1499. if (obj && obj->is_class_ptr(GDScriptFunctionState::get_class_ptr_static())) {
  1500. err_text = R"(Trying to call an async function without "await".)";
  1501. OPCODE_BREAK;
  1502. }
  1503. }
  1504. #endif
  1505. } else {
  1506. Variant ret;
  1507. base->callp(*methodname, (const Variant **)argptrs, argc, ret, err);
  1508. }
  1509. #ifdef DEBUG_ENABLED
  1510. if (GDScriptLanguage::get_singleton()->profiling) {
  1511. uint64_t t_taken = OS::get_singleton()->get_ticks_usec() - call_time;
  1512. if (GDScriptLanguage::get_singleton()->profile_native_calls && _profile_count_as_native(base_obj, *methodname)) {
  1513. _profile_native_call(t_taken, *methodname, base_class);
  1514. }
  1515. function_call_time += t_taken;
  1516. }
  1517. if (err.error != Callable::CallError::CALL_OK) {
  1518. String methodstr = *methodname;
  1519. String basestr = _get_var_type(base);
  1520. bool is_callable = false;
  1521. if (methodstr == "call") {
  1522. if (argc >= 1 && base->get_type() != Variant::CALLABLE) {
  1523. methodstr = String(*argptrs[0]) + " (via call)";
  1524. if (err.error == Callable::CallError::CALL_ERROR_INVALID_ARGUMENT) {
  1525. err.argument += 1;
  1526. }
  1527. } else {
  1528. methodstr = base->operator String() + " (Callable)";
  1529. is_callable = true;
  1530. }
  1531. } else if (methodstr == "free") {
  1532. if (err.error == Callable::CallError::CALL_ERROR_INVALID_METHOD) {
  1533. if (base->is_ref_counted()) {
  1534. err_text = "Attempted to free a RefCounted object.";
  1535. OPCODE_BREAK;
  1536. } else if (base->get_type() == Variant::OBJECT) {
  1537. err_text = "Attempted to free a locked object (calling or emitting).";
  1538. OPCODE_BREAK;
  1539. }
  1540. }
  1541. } else if (methodstr == "call_recursive" && basestr == "TreeItem") {
  1542. if (argc >= 1) {
  1543. methodstr = String(*argptrs[0]) + " (via TreeItem.call_recursive)";
  1544. if (err.error == Callable::CallError::CALL_ERROR_INVALID_ARGUMENT) {
  1545. err.argument += 1;
  1546. }
  1547. }
  1548. }
  1549. err_text = _get_call_error(err, "function '" + methodstr + (is_callable ? "" : "' in base '" + basestr) + "'", (const Variant **)argptrs);
  1550. OPCODE_BREAK;
  1551. }
  1552. #endif
  1553. ip += 3;
  1554. }
  1555. DISPATCH_OPCODE;
  1556. OPCODE(OPCODE_CALL_METHOD_BIND)
  1557. OPCODE(OPCODE_CALL_METHOD_BIND_RET) {
  1558. bool call_ret = (_code_ptr[ip]) == OPCODE_CALL_METHOD_BIND_RET;
  1559. LOAD_INSTRUCTION_ARGS
  1560. CHECK_SPACE(3 + instr_arg_count);
  1561. ip += instr_arg_count;
  1562. int argc = _code_ptr[ip + 1];
  1563. GD_ERR_BREAK(argc < 0);
  1564. GD_ERR_BREAK(_code_ptr[ip + 2] < 0 || _code_ptr[ip + 2] >= _methods_count);
  1565. MethodBind *method = _methods_ptr[_code_ptr[ip + 2]];
  1566. GET_INSTRUCTION_ARG(base, argc);
  1567. #ifdef DEBUG_ENABLED
  1568. bool freed = false;
  1569. Object *base_obj = base->get_validated_object_with_check(freed);
  1570. if (freed) {
  1571. err_text = METHOD_CALL_ON_FREED_INSTANCE_ERROR(method);
  1572. OPCODE_BREAK;
  1573. } else if (!base_obj) {
  1574. err_text = METHOD_CALL_ON_NULL_VALUE_ERROR(method);
  1575. OPCODE_BREAK;
  1576. }
  1577. #else
  1578. Object *base_obj = base->operator Object *();
  1579. #endif
  1580. Variant **argptrs = instruction_args;
  1581. #ifdef DEBUG_ENABLED
  1582. uint64_t call_time = 0;
  1583. if (GDScriptLanguage::get_singleton()->profiling && GDScriptLanguage::get_singleton()->profile_native_calls) {
  1584. call_time = OS::get_singleton()->get_ticks_usec();
  1585. }
  1586. #endif
  1587. Callable::CallError err;
  1588. if (call_ret) {
  1589. GET_INSTRUCTION_ARG(ret, argc + 1);
  1590. *ret = method->call(base_obj, (const Variant **)argptrs, argc, err);
  1591. } else {
  1592. method->call(base_obj, (const Variant **)argptrs, argc, err);
  1593. }
  1594. #ifdef DEBUG_ENABLED
  1595. if (GDScriptLanguage::get_singleton()->profiling && GDScriptLanguage::get_singleton()->profile_native_calls) {
  1596. uint64_t t_taken = OS::get_singleton()->get_ticks_usec() - call_time;
  1597. _profile_native_call(t_taken, method->get_name(), method->get_instance_class());
  1598. function_call_time += t_taken;
  1599. }
  1600. if (err.error != Callable::CallError::CALL_OK) {
  1601. String methodstr = method->get_name();
  1602. String basestr = _get_var_type(base);
  1603. if (methodstr == "call") {
  1604. if (argc >= 1) {
  1605. methodstr = String(*argptrs[0]) + " (via call)";
  1606. if (err.error == Callable::CallError::CALL_ERROR_INVALID_ARGUMENT) {
  1607. err.argument += 1;
  1608. }
  1609. }
  1610. } else if (methodstr == "free") {
  1611. if (err.error == Callable::CallError::CALL_ERROR_INVALID_METHOD) {
  1612. if (base->is_ref_counted()) {
  1613. err_text = "Attempted to free a RefCounted object.";
  1614. OPCODE_BREAK;
  1615. } else if (base->get_type() == Variant::OBJECT) {
  1616. err_text = "Attempted to free a locked object (calling or emitting).";
  1617. OPCODE_BREAK;
  1618. }
  1619. }
  1620. }
  1621. err_text = _get_call_error(err, "function '" + methodstr + "' in base '" + basestr + "'", (const Variant **)argptrs);
  1622. OPCODE_BREAK;
  1623. }
  1624. #endif
  1625. ip += 3;
  1626. }
  1627. DISPATCH_OPCODE;
  1628. OPCODE(OPCODE_CALL_BUILTIN_STATIC) {
  1629. LOAD_INSTRUCTION_ARGS
  1630. CHECK_SPACE(4 + instr_arg_count);
  1631. ip += instr_arg_count;
  1632. GD_ERR_BREAK(_code_ptr[ip + 1] < 0 || _code_ptr[ip + 1] >= Variant::VARIANT_MAX);
  1633. Variant::Type builtin_type = (Variant::Type)_code_ptr[ip + 1];
  1634. int methodname_idx = _code_ptr[ip + 2];
  1635. GD_ERR_BREAK(methodname_idx < 0 || methodname_idx >= _global_names_count);
  1636. const StringName *methodname = &_global_names_ptr[methodname_idx];
  1637. int argc = _code_ptr[ip + 3];
  1638. GD_ERR_BREAK(argc < 0);
  1639. GET_INSTRUCTION_ARG(ret, argc);
  1640. const Variant **argptrs = const_cast<const Variant **>(instruction_args);
  1641. Callable::CallError err;
  1642. Variant::call_static(builtin_type, *methodname, argptrs, argc, *ret, err);
  1643. #ifdef DEBUG_ENABLED
  1644. if (err.error != Callable::CallError::CALL_OK) {
  1645. err_text = _get_call_error(err, "static function '" + methodname->operator String() + "' in type '" + Variant::get_type_name(builtin_type) + "'", argptrs);
  1646. OPCODE_BREAK;
  1647. }
  1648. #endif
  1649. ip += 4;
  1650. }
  1651. DISPATCH_OPCODE;
  1652. OPCODE(OPCODE_CALL_NATIVE_STATIC) {
  1653. LOAD_INSTRUCTION_ARGS
  1654. CHECK_SPACE(3 + instr_arg_count);
  1655. ip += instr_arg_count;
  1656. GD_ERR_BREAK(_code_ptr[ip + 1] < 0 || _code_ptr[ip + 1] >= _methods_count);
  1657. MethodBind *method = _methods_ptr[_code_ptr[ip + 1]];
  1658. int argc = _code_ptr[ip + 2];
  1659. GD_ERR_BREAK(argc < 0);
  1660. GET_INSTRUCTION_ARG(ret, argc);
  1661. const Variant **argptrs = const_cast<const Variant **>(instruction_args);
  1662. #ifdef DEBUG_ENABLED
  1663. uint64_t call_time = 0;
  1664. if (GDScriptLanguage::get_singleton()->profiling && GDScriptLanguage::get_singleton()->profile_native_calls) {
  1665. call_time = OS::get_singleton()->get_ticks_usec();
  1666. }
  1667. #endif
  1668. Callable::CallError err;
  1669. *ret = method->call(nullptr, argptrs, argc, err);
  1670. #ifdef DEBUG_ENABLED
  1671. if (GDScriptLanguage::get_singleton()->profiling && GDScriptLanguage::get_singleton()->profile_native_calls) {
  1672. uint64_t t_taken = OS::get_singleton()->get_ticks_usec() - call_time;
  1673. _profile_native_call(t_taken, method->get_name(), method->get_instance_class());
  1674. function_call_time += t_taken;
  1675. }
  1676. #endif
  1677. if (err.error != Callable::CallError::CALL_OK) {
  1678. err_text = _get_call_error(err, "static function '" + method->get_name().operator String() + "' in type '" + method->get_instance_class().operator String() + "'", argptrs);
  1679. OPCODE_BREAK;
  1680. }
  1681. ip += 3;
  1682. }
  1683. DISPATCH_OPCODE;
  1684. OPCODE(OPCODE_CALL_NATIVE_STATIC_VALIDATED_RETURN) {
  1685. LOAD_INSTRUCTION_ARGS
  1686. CHECK_SPACE(3 + instr_arg_count);
  1687. ip += instr_arg_count;
  1688. int argc = _code_ptr[ip + 1];
  1689. GD_ERR_BREAK(argc < 0);
  1690. GD_ERR_BREAK(_code_ptr[ip + 2] < 0 || _code_ptr[ip + 2] >= _methods_count);
  1691. MethodBind *method = _methods_ptr[_code_ptr[ip + 2]];
  1692. Variant **argptrs = instruction_args;
  1693. #ifdef DEBUG_ENABLED
  1694. uint64_t call_time = 0;
  1695. if (GDScriptLanguage::get_singleton()->profiling && GDScriptLanguage::get_singleton()->profile_native_calls) {
  1696. call_time = OS::get_singleton()->get_ticks_usec();
  1697. }
  1698. #endif
  1699. GET_INSTRUCTION_ARG(ret, argc);
  1700. method->validated_call(nullptr, (const Variant **)argptrs, ret);
  1701. #ifdef DEBUG_ENABLED
  1702. if (GDScriptLanguage::get_singleton()->profiling && GDScriptLanguage::get_singleton()->profile_native_calls) {
  1703. uint64_t t_taken = OS::get_singleton()->get_ticks_usec() - call_time;
  1704. _profile_native_call(t_taken, method->get_name(), method->get_instance_class());
  1705. function_call_time += t_taken;
  1706. }
  1707. #endif
  1708. ip += 3;
  1709. }
  1710. DISPATCH_OPCODE;
  1711. OPCODE(OPCODE_CALL_NATIVE_STATIC_VALIDATED_NO_RETURN) {
  1712. LOAD_INSTRUCTION_ARGS
  1713. CHECK_SPACE(3 + instr_arg_count);
  1714. ip += instr_arg_count;
  1715. int argc = _code_ptr[ip + 1];
  1716. GD_ERR_BREAK(argc < 0);
  1717. GD_ERR_BREAK(_code_ptr[ip + 2] < 0 || _code_ptr[ip + 2] >= _methods_count);
  1718. MethodBind *method = _methods_ptr[_code_ptr[ip + 2]];
  1719. Variant **argptrs = instruction_args;
  1720. #ifdef DEBUG_ENABLED
  1721. uint64_t call_time = 0;
  1722. if (GDScriptLanguage::get_singleton()->profiling && GDScriptLanguage::get_singleton()->profile_native_calls) {
  1723. call_time = OS::get_singleton()->get_ticks_usec();
  1724. }
  1725. #endif
  1726. GET_INSTRUCTION_ARG(ret, argc);
  1727. VariantInternal::initialize(ret, Variant::NIL);
  1728. method->validated_call(nullptr, (const Variant **)argptrs, nullptr);
  1729. #ifdef DEBUG_ENABLED
  1730. if (GDScriptLanguage::get_singleton()->profiling && GDScriptLanguage::get_singleton()->profile_native_calls) {
  1731. uint64_t t_taken = OS::get_singleton()->get_ticks_usec() - call_time;
  1732. _profile_native_call(t_taken, method->get_name(), method->get_instance_class());
  1733. function_call_time += t_taken;
  1734. }
  1735. #endif
  1736. ip += 3;
  1737. }
  1738. DISPATCH_OPCODE;
  1739. OPCODE(OPCODE_CALL_METHOD_BIND_VALIDATED_RETURN) {
  1740. LOAD_INSTRUCTION_ARGS
  1741. CHECK_SPACE(3 + instr_arg_count);
  1742. ip += instr_arg_count;
  1743. int argc = _code_ptr[ip + 1];
  1744. GD_ERR_BREAK(argc < 0);
  1745. GD_ERR_BREAK(_code_ptr[ip + 2] < 0 || _code_ptr[ip + 2] >= _methods_count);
  1746. MethodBind *method = _methods_ptr[_code_ptr[ip + 2]];
  1747. GET_INSTRUCTION_ARG(base, argc);
  1748. #ifdef DEBUG_ENABLED
  1749. bool freed = false;
  1750. Object *base_obj = base->get_validated_object_with_check(freed);
  1751. if (freed) {
  1752. err_text = METHOD_CALL_ON_FREED_INSTANCE_ERROR(method);
  1753. OPCODE_BREAK;
  1754. } else if (!base_obj) {
  1755. err_text = METHOD_CALL_ON_NULL_VALUE_ERROR(method);
  1756. OPCODE_BREAK;
  1757. }
  1758. #else
  1759. Object *base_obj = *VariantInternal::get_object(base);
  1760. #endif
  1761. Variant **argptrs = instruction_args;
  1762. #ifdef DEBUG_ENABLED
  1763. uint64_t call_time = 0;
  1764. if (GDScriptLanguage::get_singleton()->profiling && GDScriptLanguage::get_singleton()->profile_native_calls) {
  1765. call_time = OS::get_singleton()->get_ticks_usec();
  1766. }
  1767. #endif
  1768. GET_INSTRUCTION_ARG(ret, argc + 1);
  1769. method->validated_call(base_obj, (const Variant **)argptrs, ret);
  1770. #ifdef DEBUG_ENABLED
  1771. if (GDScriptLanguage::get_singleton()->profiling && GDScriptLanguage::get_singleton()->profile_native_calls) {
  1772. uint64_t t_taken = OS::get_singleton()->get_ticks_usec() - call_time;
  1773. _profile_native_call(t_taken, method->get_name(), method->get_instance_class());
  1774. function_call_time += t_taken;
  1775. }
  1776. #endif
  1777. ip += 3;
  1778. }
  1779. DISPATCH_OPCODE;
  1780. OPCODE(OPCODE_CALL_METHOD_BIND_VALIDATED_NO_RETURN) {
  1781. LOAD_INSTRUCTION_ARGS
  1782. CHECK_SPACE(3 + instr_arg_count);
  1783. ip += instr_arg_count;
  1784. int argc = _code_ptr[ip + 1];
  1785. GD_ERR_BREAK(argc < 0);
  1786. GD_ERR_BREAK(_code_ptr[ip + 2] < 0 || _code_ptr[ip + 2] >= _methods_count);
  1787. MethodBind *method = _methods_ptr[_code_ptr[ip + 2]];
  1788. GET_INSTRUCTION_ARG(base, argc);
  1789. #ifdef DEBUG_ENABLED
  1790. bool freed = false;
  1791. Object *base_obj = base->get_validated_object_with_check(freed);
  1792. if (freed) {
  1793. err_text = METHOD_CALL_ON_FREED_INSTANCE_ERROR(method);
  1794. OPCODE_BREAK;
  1795. } else if (!base_obj) {
  1796. err_text = METHOD_CALL_ON_NULL_VALUE_ERROR(method);
  1797. OPCODE_BREAK;
  1798. }
  1799. #else
  1800. Object *base_obj = *VariantInternal::get_object(base);
  1801. #endif
  1802. Variant **argptrs = instruction_args;
  1803. #ifdef DEBUG_ENABLED
  1804. uint64_t call_time = 0;
  1805. if (GDScriptLanguage::get_singleton()->profiling && GDScriptLanguage::get_singleton()->profile_native_calls) {
  1806. call_time = OS::get_singleton()->get_ticks_usec();
  1807. }
  1808. #endif
  1809. GET_INSTRUCTION_ARG(ret, argc + 1);
  1810. VariantInternal::initialize(ret, Variant::NIL);
  1811. method->validated_call(base_obj, (const Variant **)argptrs, nullptr);
  1812. #ifdef DEBUG_ENABLED
  1813. if (GDScriptLanguage::get_singleton()->profiling && GDScriptLanguage::get_singleton()->profile_native_calls) {
  1814. uint64_t t_taken = OS::get_singleton()->get_ticks_usec() - call_time;
  1815. _profile_native_call(t_taken, method->get_name(), method->get_instance_class());
  1816. function_call_time += t_taken;
  1817. }
  1818. #endif
  1819. ip += 3;
  1820. }
  1821. DISPATCH_OPCODE;
  1822. OPCODE(OPCODE_CALL_BUILTIN_TYPE_VALIDATED) {
  1823. LOAD_INSTRUCTION_ARGS
  1824. CHECK_SPACE(3 + instr_arg_count);
  1825. ip += instr_arg_count;
  1826. int argc = _code_ptr[ip + 1];
  1827. GD_ERR_BREAK(argc < 0);
  1828. GET_INSTRUCTION_ARG(base, argc);
  1829. GD_ERR_BREAK(_code_ptr[ip + 2] < 0 || _code_ptr[ip + 2] >= _builtin_methods_count);
  1830. Variant::ValidatedBuiltInMethod method = _builtin_methods_ptr[_code_ptr[ip + 2]];
  1831. Variant **argptrs = instruction_args;
  1832. GET_INSTRUCTION_ARG(ret, argc + 1);
  1833. method(base, (const Variant **)argptrs, argc, ret);
  1834. ip += 3;
  1835. }
  1836. DISPATCH_OPCODE;
  1837. OPCODE(OPCODE_CALL_UTILITY) {
  1838. LOAD_INSTRUCTION_ARGS
  1839. CHECK_SPACE(3 + instr_arg_count);
  1840. ip += instr_arg_count;
  1841. int argc = _code_ptr[ip + 1];
  1842. GD_ERR_BREAK(argc < 0);
  1843. GD_ERR_BREAK(_code_ptr[ip + 2] < 0 || _code_ptr[ip + 2] >= _global_names_count);
  1844. StringName function = _global_names_ptr[_code_ptr[ip + 2]];
  1845. Variant **argptrs = instruction_args;
  1846. GET_INSTRUCTION_ARG(dst, argc);
  1847. Callable::CallError err;
  1848. Variant::call_utility_function(function, dst, (const Variant **)argptrs, argc, err);
  1849. #ifdef DEBUG_ENABLED
  1850. if (err.error != Callable::CallError::CALL_OK) {
  1851. String methodstr = function;
  1852. if (dst->get_type() == Variant::STRING && !dst->operator String().is_empty()) {
  1853. // Call provided error string.
  1854. err_text = vformat(R"*(Error calling utility function "%s()": %s)*", methodstr, *dst);
  1855. } else {
  1856. err_text = _get_call_error(err, vformat(R"*(utility function "%s()")*", methodstr), (const Variant **)argptrs);
  1857. }
  1858. OPCODE_BREAK;
  1859. }
  1860. #endif
  1861. ip += 3;
  1862. }
  1863. DISPATCH_OPCODE;
  1864. OPCODE(OPCODE_CALL_UTILITY_VALIDATED) {
  1865. LOAD_INSTRUCTION_ARGS
  1866. CHECK_SPACE(3 + instr_arg_count);
  1867. ip += instr_arg_count;
  1868. int argc = _code_ptr[ip + 1];
  1869. GD_ERR_BREAK(argc < 0);
  1870. GD_ERR_BREAK(_code_ptr[ip + 2] < 0 || _code_ptr[ip + 2] >= _utilities_count);
  1871. Variant::ValidatedUtilityFunction function = _utilities_ptr[_code_ptr[ip + 2]];
  1872. Variant **argptrs = instruction_args;
  1873. GET_INSTRUCTION_ARG(dst, argc);
  1874. function(dst, (const Variant **)argptrs, argc);
  1875. ip += 3;
  1876. }
  1877. DISPATCH_OPCODE;
  1878. OPCODE(OPCODE_CALL_GDSCRIPT_UTILITY) {
  1879. LOAD_INSTRUCTION_ARGS
  1880. CHECK_SPACE(3 + instr_arg_count);
  1881. ip += instr_arg_count;
  1882. int argc = _code_ptr[ip + 1];
  1883. GD_ERR_BREAK(argc < 0);
  1884. GD_ERR_BREAK(_code_ptr[ip + 2] < 0 || _code_ptr[ip + 2] >= _gds_utilities_count);
  1885. GDScriptUtilityFunctions::FunctionPtr function = _gds_utilities_ptr[_code_ptr[ip + 2]];
  1886. Variant **argptrs = instruction_args;
  1887. GET_INSTRUCTION_ARG(dst, argc);
  1888. Callable::CallError err;
  1889. function(dst, (const Variant **)argptrs, argc, err);
  1890. #ifdef DEBUG_ENABLED
  1891. if (err.error != Callable::CallError::CALL_OK) {
  1892. String methodstr = gds_utilities_names[_code_ptr[ip + 2]];
  1893. if (dst->get_type() == Variant::STRING && !dst->operator String().is_empty()) {
  1894. // Call provided error string.
  1895. err_text = vformat(R"*(Error calling GDScript utility function "%s()": %s)*", methodstr, *dst);
  1896. } else {
  1897. err_text = _get_call_error(err, vformat(R"*(GDScript utility function "%s()")*", methodstr), (const Variant **)argptrs);
  1898. }
  1899. OPCODE_BREAK;
  1900. }
  1901. #endif
  1902. ip += 3;
  1903. }
  1904. DISPATCH_OPCODE;
  1905. OPCODE(OPCODE_CALL_SELF_BASE) {
  1906. LOAD_INSTRUCTION_ARGS
  1907. CHECK_SPACE(3 + instr_arg_count);
  1908. ip += instr_arg_count;
  1909. int argc = _code_ptr[ip + 1];
  1910. GD_ERR_BREAK(argc < 0);
  1911. int self_fun = _code_ptr[ip + 2];
  1912. #ifdef DEBUG_ENABLED
  1913. if (self_fun < 0 || self_fun >= _global_names_count) {
  1914. err_text = "compiler bug, function name not found";
  1915. OPCODE_BREAK;
  1916. }
  1917. #endif
  1918. const StringName *methodname = &_global_names_ptr[self_fun];
  1919. Variant **argptrs = instruction_args;
  1920. GET_INSTRUCTION_ARG(dst, argc);
  1921. const GDScript *gds = _script;
  1922. HashMap<StringName, GDScriptFunction *>::ConstIterator E;
  1923. while (gds->base.ptr()) {
  1924. gds = gds->base.ptr();
  1925. E = gds->member_functions.find(*methodname);
  1926. if (E) {
  1927. break;
  1928. }
  1929. }
  1930. Callable::CallError err;
  1931. if (E) {
  1932. *dst = E->value->call(p_instance, (const Variant **)argptrs, argc, err);
  1933. } else if (gds->native.ptr()) {
  1934. if (*methodname != GDScriptLanguage::get_singleton()->strings._init) {
  1935. MethodBind *mb = ClassDB::get_method(gds->native->get_name(), *methodname);
  1936. if (!mb) {
  1937. err.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
  1938. } else {
  1939. *dst = mb->call(p_instance->owner, (const Variant **)argptrs, argc, err);
  1940. }
  1941. } else {
  1942. err.error = Callable::CallError::CALL_OK;
  1943. }
  1944. } else {
  1945. if (*methodname != GDScriptLanguage::get_singleton()->strings._init) {
  1946. err.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
  1947. } else {
  1948. err.error = Callable::CallError::CALL_OK;
  1949. }
  1950. }
  1951. if (err.error != Callable::CallError::CALL_OK) {
  1952. String methodstr = *methodname;
  1953. err_text = _get_call_error(err, "function '" + methodstr + "'", (const Variant **)argptrs);
  1954. OPCODE_BREAK;
  1955. }
  1956. ip += 3;
  1957. }
  1958. DISPATCH_OPCODE;
  1959. OPCODE(OPCODE_AWAIT) {
  1960. CHECK_SPACE(2);
  1961. // Do the one-shot connect.
  1962. GET_VARIANT_PTR(argobj, 0);
  1963. Signal sig;
  1964. bool is_signal = true;
  1965. {
  1966. Variant result = *argobj;
  1967. if (argobj->get_type() == Variant::OBJECT) {
  1968. bool was_freed = false;
  1969. Object *obj = argobj->get_validated_object_with_check(was_freed);
  1970. if (was_freed) {
  1971. err_text = "Trying to await on a freed object.";
  1972. OPCODE_BREAK;
  1973. }
  1974. // Is this even possible to be null at this point?
  1975. if (obj) {
  1976. if (obj->is_class_ptr(GDScriptFunctionState::get_class_ptr_static())) {
  1977. result = Signal(obj, "completed");
  1978. }
  1979. }
  1980. }
  1981. if (result.get_type() != Variant::SIGNAL) {
  1982. // Not async, return immediately using the target from OPCODE_AWAIT_RESUME.
  1983. GET_VARIANT_PTR(target, 2);
  1984. *target = result;
  1985. ip += 4; // Skip OPCODE_AWAIT_RESUME and its data.
  1986. is_signal = false;
  1987. } else {
  1988. sig = result;
  1989. }
  1990. }
  1991. if (is_signal) {
  1992. Ref<GDScriptFunctionState> gdfs = memnew(GDScriptFunctionState);
  1993. gdfs->function = this;
  1994. gdfs->state.stack.resize(alloca_size);
  1995. // First 3 stack addresses are special, so we just skip them here.
  1996. for (int i = 3; i < _stack_size; i++) {
  1997. memnew_placement(&gdfs->state.stack.write[sizeof(Variant) * i], Variant(stack[i]));
  1998. }
  1999. gdfs->state.stack_size = _stack_size;
  2000. gdfs->state.alloca_size = alloca_size;
  2001. gdfs->state.ip = ip + 2;
  2002. gdfs->state.line = line;
  2003. gdfs->state.script = _script;
  2004. {
  2005. MutexLock lock(GDScriptLanguage::get_singleton()->mutex);
  2006. _script->pending_func_states.add(&gdfs->scripts_list);
  2007. if (p_instance) {
  2008. gdfs->state.instance = p_instance;
  2009. p_instance->pending_func_states.add(&gdfs->instances_list);
  2010. } else {
  2011. gdfs->state.instance = nullptr;
  2012. }
  2013. }
  2014. #ifdef DEBUG_ENABLED
  2015. gdfs->state.function_name = name;
  2016. gdfs->state.script_path = _script->get_script_path();
  2017. #endif
  2018. gdfs->state.defarg = defarg;
  2019. gdfs->function = this;
  2020. retvalue = gdfs;
  2021. Error err = sig.connect(Callable(gdfs.ptr(), "_signal_callback").bind(retvalue), Object::CONNECT_ONE_SHOT);
  2022. if (err != OK) {
  2023. err_text = "Error connecting to signal: " + sig.get_name() + " during await.";
  2024. OPCODE_BREAK;
  2025. }
  2026. #ifdef DEBUG_ENABLED
  2027. exit_ok = true;
  2028. awaited = true;
  2029. #endif
  2030. OPCODE_BREAK;
  2031. }
  2032. }
  2033. DISPATCH_OPCODE; // Needed for synchronous calls (when result is immediately available).
  2034. OPCODE(OPCODE_AWAIT_RESUME) {
  2035. CHECK_SPACE(2);
  2036. #ifdef DEBUG_ENABLED
  2037. if (!p_state) {
  2038. err_text = ("Invalid Resume (bug?)");
  2039. OPCODE_BREAK;
  2040. }
  2041. #endif
  2042. GET_VARIANT_PTR(result, 0);
  2043. *result = p_state->result;
  2044. ip += 2;
  2045. }
  2046. DISPATCH_OPCODE;
  2047. OPCODE(OPCODE_CREATE_LAMBDA) {
  2048. LOAD_INSTRUCTION_ARGS
  2049. CHECK_SPACE(2 + instr_arg_count);
  2050. ip += instr_arg_count;
  2051. int captures_count = _code_ptr[ip + 1];
  2052. GD_ERR_BREAK(captures_count < 0);
  2053. int lambda_index = _code_ptr[ip + 2];
  2054. GD_ERR_BREAK(lambda_index < 0 || lambda_index >= _lambdas_count);
  2055. GDScriptFunction *lambda = _lambdas_ptr[lambda_index];
  2056. Vector<Variant> captures;
  2057. captures.resize(captures_count);
  2058. for (int i = 0; i < captures_count; i++) {
  2059. GET_INSTRUCTION_ARG(arg, i);
  2060. captures.write[i] = *arg;
  2061. }
  2062. GDScriptLambdaCallable *callable = memnew(GDScriptLambdaCallable(Ref<GDScript>(script), lambda, captures));
  2063. GET_INSTRUCTION_ARG(result, captures_count);
  2064. *result = Callable(callable);
  2065. ip += 3;
  2066. }
  2067. DISPATCH_OPCODE;
  2068. OPCODE(OPCODE_CREATE_SELF_LAMBDA) {
  2069. LOAD_INSTRUCTION_ARGS
  2070. CHECK_SPACE(2 + instr_arg_count);
  2071. GD_ERR_BREAK(p_instance == nullptr);
  2072. ip += instr_arg_count;
  2073. int captures_count = _code_ptr[ip + 1];
  2074. GD_ERR_BREAK(captures_count < 0);
  2075. int lambda_index = _code_ptr[ip + 2];
  2076. GD_ERR_BREAK(lambda_index < 0 || lambda_index >= _lambdas_count);
  2077. GDScriptFunction *lambda = _lambdas_ptr[lambda_index];
  2078. Vector<Variant> captures;
  2079. captures.resize(captures_count);
  2080. for (int i = 0; i < captures_count; i++) {
  2081. GET_INSTRUCTION_ARG(arg, i);
  2082. captures.write[i] = *arg;
  2083. }
  2084. GDScriptLambdaSelfCallable *callable;
  2085. if (Object::cast_to<RefCounted>(p_instance->owner)) {
  2086. callable = memnew(GDScriptLambdaSelfCallable(Ref<RefCounted>(Object::cast_to<RefCounted>(p_instance->owner)), lambda, captures));
  2087. } else {
  2088. callable = memnew(GDScriptLambdaSelfCallable(p_instance->owner, lambda, captures));
  2089. }
  2090. GET_INSTRUCTION_ARG(result, captures_count);
  2091. *result = Callable(callable);
  2092. ip += 3;
  2093. }
  2094. DISPATCH_OPCODE;
  2095. OPCODE(OPCODE_JUMP) {
  2096. CHECK_SPACE(2);
  2097. int to = _code_ptr[ip + 1];
  2098. GD_ERR_BREAK(to < 0 || to > _code_size);
  2099. ip = to;
  2100. }
  2101. DISPATCH_OPCODE;
  2102. OPCODE(OPCODE_JUMP_IF) {
  2103. CHECK_SPACE(3);
  2104. GET_VARIANT_PTR(test, 0);
  2105. bool result = test->booleanize();
  2106. if (result) {
  2107. int to = _code_ptr[ip + 2];
  2108. GD_ERR_BREAK(to < 0 || to > _code_size);
  2109. ip = to;
  2110. } else {
  2111. ip += 3;
  2112. }
  2113. }
  2114. DISPATCH_OPCODE;
  2115. OPCODE(OPCODE_JUMP_IF_NOT) {
  2116. CHECK_SPACE(3);
  2117. GET_VARIANT_PTR(test, 0);
  2118. bool result = test->booleanize();
  2119. if (!result) {
  2120. int to = _code_ptr[ip + 2];
  2121. GD_ERR_BREAK(to < 0 || to > _code_size);
  2122. ip = to;
  2123. } else {
  2124. ip += 3;
  2125. }
  2126. }
  2127. DISPATCH_OPCODE;
  2128. OPCODE(OPCODE_JUMP_TO_DEF_ARGUMENT) {
  2129. CHECK_SPACE(2);
  2130. ip = _default_arg_ptr[defarg];
  2131. }
  2132. DISPATCH_OPCODE;
  2133. OPCODE(OPCODE_JUMP_IF_SHARED) {
  2134. CHECK_SPACE(3);
  2135. GET_VARIANT_PTR(val, 0);
  2136. if (val->is_shared()) {
  2137. int to = _code_ptr[ip + 2];
  2138. GD_ERR_BREAK(to < 0 || to > _code_size);
  2139. ip = to;
  2140. } else {
  2141. ip += 3;
  2142. }
  2143. }
  2144. DISPATCH_OPCODE;
  2145. OPCODE(OPCODE_RETURN) {
  2146. CHECK_SPACE(2);
  2147. GET_VARIANT_PTR(r, 0);
  2148. retvalue = *r;
  2149. #ifdef DEBUG_ENABLED
  2150. exit_ok = true;
  2151. #endif
  2152. OPCODE_BREAK;
  2153. }
  2154. OPCODE(OPCODE_RETURN_TYPED_BUILTIN) {
  2155. CHECK_SPACE(3);
  2156. GET_VARIANT_PTR(r, 0);
  2157. Variant::Type ret_type = (Variant::Type)_code_ptr[ip + 2];
  2158. GD_ERR_BREAK(ret_type < 0 || ret_type >= Variant::VARIANT_MAX);
  2159. if (r->get_type() != ret_type) {
  2160. if (Variant::can_convert_strict(r->get_type(), ret_type)) {
  2161. Callable::CallError ce;
  2162. Variant::construct(ret_type, retvalue, const_cast<const Variant **>(&r), 1, ce);
  2163. } else {
  2164. #ifdef DEBUG_ENABLED
  2165. err_text = vformat(R"(Trying to return value of type "%s" from a function whose return type is "%s".)",
  2166. Variant::get_type_name(r->get_type()), Variant::get_type_name(ret_type));
  2167. #endif // DEBUG_ENABLED
  2168. // Construct a base type anyway so type constraints are met.
  2169. Callable::CallError ce;
  2170. Variant::construct(ret_type, retvalue, nullptr, 0, ce);
  2171. OPCODE_BREAK;
  2172. }
  2173. } else {
  2174. retvalue = *r;
  2175. }
  2176. #ifdef DEBUG_ENABLED
  2177. exit_ok = true;
  2178. #endif // DEBUG_ENABLED
  2179. OPCODE_BREAK;
  2180. }
  2181. OPCODE(OPCODE_RETURN_TYPED_ARRAY) {
  2182. CHECK_SPACE(5);
  2183. GET_VARIANT_PTR(r, 0);
  2184. GET_VARIANT_PTR(script_type, 1);
  2185. Variant::Type builtin_type = (Variant::Type)_code_ptr[ip + 3];
  2186. int native_type_idx = _code_ptr[ip + 4];
  2187. GD_ERR_BREAK(native_type_idx < 0 || native_type_idx >= _global_names_count);
  2188. const StringName native_type = _global_names_ptr[native_type_idx];
  2189. if (r->get_type() != Variant::ARRAY) {
  2190. #ifdef DEBUG_ENABLED
  2191. err_text = vformat(R"(Trying to return value of type "%s" from a function whose return type is "Array[%s]".)",
  2192. Variant::get_type_name(r->get_type()), Variant::get_type_name(builtin_type));
  2193. #endif
  2194. OPCODE_BREAK;
  2195. }
  2196. Array *array = VariantInternal::get_array(r);
  2197. if (array->get_typed_builtin() != ((uint32_t)builtin_type) || array->get_typed_class_name() != native_type || array->get_typed_script() != *script_type) {
  2198. #ifdef DEBUG_ENABLED
  2199. err_text = vformat(R"(Trying to return an array of type "%s" where expected return type is "Array[%s]".)",
  2200. _get_var_type(r), _get_element_type(builtin_type, native_type, *script_type));
  2201. #endif // DEBUG_ENABLED
  2202. OPCODE_BREAK;
  2203. }
  2204. retvalue = *array;
  2205. #ifdef DEBUG_ENABLED
  2206. exit_ok = true;
  2207. #endif // DEBUG_ENABLED
  2208. OPCODE_BREAK;
  2209. }
  2210. OPCODE(OPCODE_RETURN_TYPED_NATIVE) {
  2211. CHECK_SPACE(3);
  2212. GET_VARIANT_PTR(r, 0);
  2213. GET_VARIANT_PTR(type, 1);
  2214. GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(type->operator Object *());
  2215. GD_ERR_BREAK(!nc);
  2216. if (r->get_type() != Variant::OBJECT && r->get_type() != Variant::NIL) {
  2217. err_text = vformat(R"(Trying to return value of type "%s" from a function whose return type is "%s".)",
  2218. Variant::get_type_name(r->get_type()), nc->get_name());
  2219. OPCODE_BREAK;
  2220. }
  2221. #ifdef DEBUG_ENABLED
  2222. bool freed = false;
  2223. Object *ret_obj = r->get_validated_object_with_check(freed);
  2224. if (freed) {
  2225. err_text = "Trying to return a previously freed instance.";
  2226. OPCODE_BREAK;
  2227. }
  2228. #else
  2229. Object *ret_obj = r->operator Object *();
  2230. #endif // DEBUG_ENABLED
  2231. if (ret_obj && !ClassDB::is_parent_class(ret_obj->get_class_name(), nc->get_name())) {
  2232. #ifdef DEBUG_ENABLED
  2233. err_text = vformat(R"(Trying to return value of type "%s" from a function whose return type is "%s".)",
  2234. ret_obj->get_class_name(), nc->get_name());
  2235. #endif // DEBUG_ENABLED
  2236. OPCODE_BREAK;
  2237. }
  2238. retvalue = *r;
  2239. #ifdef DEBUG_ENABLED
  2240. exit_ok = true;
  2241. #endif // DEBUG_ENABLED
  2242. OPCODE_BREAK;
  2243. }
  2244. OPCODE(OPCODE_RETURN_TYPED_SCRIPT) {
  2245. CHECK_SPACE(3);
  2246. GET_VARIANT_PTR(r, 0);
  2247. GET_VARIANT_PTR(type, 1);
  2248. Script *base_type = Object::cast_to<Script>(type->operator Object *());
  2249. GD_ERR_BREAK(!base_type);
  2250. if (r->get_type() != Variant::OBJECT && r->get_type() != Variant::NIL) {
  2251. #ifdef DEBUG_ENABLED
  2252. err_text = vformat(R"(Trying to return value of type "%s" from a function whose return type is "%s".)",
  2253. Variant::get_type_name(r->get_type()), GDScript::debug_get_script_name(Ref<Script>(base_type)));
  2254. #endif // DEBUG_ENABLED
  2255. OPCODE_BREAK;
  2256. }
  2257. #ifdef DEBUG_ENABLED
  2258. bool freed = false;
  2259. Object *ret_obj = r->get_validated_object_with_check(freed);
  2260. if (freed) {
  2261. err_text = "Trying to return a previously freed instance.";
  2262. OPCODE_BREAK;
  2263. }
  2264. #else
  2265. Object *ret_obj = r->operator Object *();
  2266. #endif // DEBUG_ENABLED
  2267. if (ret_obj) {
  2268. ScriptInstance *ret_inst = ret_obj->get_script_instance();
  2269. if (!ret_inst) {
  2270. #ifdef DEBUG_ENABLED
  2271. err_text = vformat(R"(Trying to return value of type "%s" from a function whose return type is "%s".)",
  2272. ret_obj->get_class_name(), GDScript::debug_get_script_name(Ref<GDScript>(base_type)));
  2273. #endif // DEBUG_ENABLED
  2274. OPCODE_BREAK;
  2275. }
  2276. Script *ret_type = ret_obj->get_script_instance()->get_script().ptr();
  2277. bool valid = false;
  2278. while (ret_type) {
  2279. if (ret_type == base_type) {
  2280. valid = true;
  2281. break;
  2282. }
  2283. ret_type = ret_type->get_base_script().ptr();
  2284. }
  2285. if (!valid) {
  2286. #ifdef DEBUG_ENABLED
  2287. err_text = vformat(R"(Trying to return value of type "%s" from a function whose return type is "%s".)",
  2288. GDScript::debug_get_script_name(ret_obj->get_script_instance()->get_script()), GDScript::debug_get_script_name(Ref<GDScript>(base_type)));
  2289. #endif // DEBUG_ENABLED
  2290. OPCODE_BREAK;
  2291. }
  2292. }
  2293. retvalue = *r;
  2294. #ifdef DEBUG_ENABLED
  2295. exit_ok = true;
  2296. #endif // DEBUG_ENABLED
  2297. OPCODE_BREAK;
  2298. }
  2299. OPCODE(OPCODE_ITERATE_BEGIN) {
  2300. CHECK_SPACE(8); // Space for this and a regular iterate.
  2301. GET_VARIANT_PTR(counter, 0);
  2302. GET_VARIANT_PTR(container, 1);
  2303. *counter = Variant();
  2304. bool valid;
  2305. if (!container->iter_init(*counter, valid)) {
  2306. #ifdef DEBUG_ENABLED
  2307. if (!valid) {
  2308. err_text = "Unable to iterate on object of type '" + Variant::get_type_name(container->get_type()) + "'.";
  2309. OPCODE_BREAK;
  2310. }
  2311. #endif
  2312. int jumpto = _code_ptr[ip + 4];
  2313. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2314. ip = jumpto;
  2315. } else {
  2316. GET_VARIANT_PTR(iterator, 2);
  2317. *iterator = container->iter_get(*counter, valid);
  2318. #ifdef DEBUG_ENABLED
  2319. if (!valid) {
  2320. err_text = "Unable to obtain iterator object of type '" + Variant::get_type_name(container->get_type()) + "'.";
  2321. OPCODE_BREAK;
  2322. }
  2323. #endif
  2324. ip += 5; // Skip regular iterate which is always next.
  2325. }
  2326. }
  2327. DISPATCH_OPCODE;
  2328. OPCODE(OPCODE_ITERATE_BEGIN_INT) {
  2329. CHECK_SPACE(8); // Check space for iterate instruction too.
  2330. GET_VARIANT_PTR(counter, 0);
  2331. GET_VARIANT_PTR(container, 1);
  2332. int64_t size = *VariantInternal::get_int(container);
  2333. VariantInternal::initialize(counter, Variant::INT);
  2334. *VariantInternal::get_int(counter) = 0;
  2335. if (size > 0) {
  2336. GET_VARIANT_PTR(iterator, 2);
  2337. VariantInternal::initialize(iterator, Variant::INT);
  2338. *VariantInternal::get_int(iterator) = 0;
  2339. // Skip regular iterate.
  2340. ip += 5;
  2341. } else {
  2342. // Jump to end of loop.
  2343. int jumpto = _code_ptr[ip + 4];
  2344. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2345. ip = jumpto;
  2346. }
  2347. }
  2348. DISPATCH_OPCODE;
  2349. OPCODE(OPCODE_ITERATE_BEGIN_FLOAT) {
  2350. CHECK_SPACE(8); // Check space for iterate instruction too.
  2351. GET_VARIANT_PTR(counter, 0);
  2352. GET_VARIANT_PTR(container, 1);
  2353. double size = *VariantInternal::get_float(container);
  2354. VariantInternal::initialize(counter, Variant::FLOAT);
  2355. *VariantInternal::get_float(counter) = 0.0;
  2356. if (size > 0) {
  2357. GET_VARIANT_PTR(iterator, 2);
  2358. VariantInternal::initialize(iterator, Variant::FLOAT);
  2359. *VariantInternal::get_float(iterator) = 0;
  2360. // Skip regular iterate.
  2361. ip += 5;
  2362. } else {
  2363. // Jump to end of loop.
  2364. int jumpto = _code_ptr[ip + 4];
  2365. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2366. ip = jumpto;
  2367. }
  2368. }
  2369. DISPATCH_OPCODE;
  2370. OPCODE(OPCODE_ITERATE_BEGIN_VECTOR2) {
  2371. CHECK_SPACE(8); // Check space for iterate instruction too.
  2372. GET_VARIANT_PTR(counter, 0);
  2373. GET_VARIANT_PTR(container, 1);
  2374. Vector2 *bounds = VariantInternal::get_vector2(container);
  2375. VariantInternal::initialize(counter, Variant::FLOAT);
  2376. *VariantInternal::get_float(counter) = bounds->x;
  2377. if (bounds->x < bounds->y) {
  2378. GET_VARIANT_PTR(iterator, 2);
  2379. VariantInternal::initialize(iterator, Variant::FLOAT);
  2380. *VariantInternal::get_float(iterator) = bounds->x;
  2381. // Skip regular iterate.
  2382. ip += 5;
  2383. } else {
  2384. // Jump to end of loop.
  2385. int jumpto = _code_ptr[ip + 4];
  2386. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2387. ip = jumpto;
  2388. }
  2389. }
  2390. DISPATCH_OPCODE;
  2391. OPCODE(OPCODE_ITERATE_BEGIN_VECTOR2I) {
  2392. CHECK_SPACE(8); // Check space for iterate instruction too.
  2393. GET_VARIANT_PTR(counter, 0);
  2394. GET_VARIANT_PTR(container, 1);
  2395. Vector2i *bounds = VariantInternal::get_vector2i(container);
  2396. VariantInternal::initialize(counter, Variant::FLOAT);
  2397. *VariantInternal::get_int(counter) = bounds->x;
  2398. if (bounds->x < bounds->y) {
  2399. GET_VARIANT_PTR(iterator, 2);
  2400. VariantInternal::initialize(iterator, Variant::INT);
  2401. *VariantInternal::get_int(iterator) = bounds->x;
  2402. // Skip regular iterate.
  2403. ip += 5;
  2404. } else {
  2405. // Jump to end of loop.
  2406. int jumpto = _code_ptr[ip + 4];
  2407. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2408. ip = jumpto;
  2409. }
  2410. }
  2411. DISPATCH_OPCODE;
  2412. OPCODE(OPCODE_ITERATE_BEGIN_VECTOR3) {
  2413. CHECK_SPACE(8); // Check space for iterate instruction too.
  2414. GET_VARIANT_PTR(counter, 0);
  2415. GET_VARIANT_PTR(container, 1);
  2416. Vector3 *bounds = VariantInternal::get_vector3(container);
  2417. double from = bounds->x;
  2418. double to = bounds->y;
  2419. double step = bounds->z;
  2420. VariantInternal::initialize(counter, Variant::FLOAT);
  2421. *VariantInternal::get_float(counter) = from;
  2422. bool do_continue = from == to ? false : (from < to ? step > 0 : step < 0);
  2423. if (do_continue) {
  2424. GET_VARIANT_PTR(iterator, 2);
  2425. VariantInternal::initialize(iterator, Variant::FLOAT);
  2426. *VariantInternal::get_float(iterator) = from;
  2427. // Skip regular iterate.
  2428. ip += 5;
  2429. } else {
  2430. // Jump to end of loop.
  2431. int jumpto = _code_ptr[ip + 4];
  2432. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2433. ip = jumpto;
  2434. }
  2435. }
  2436. DISPATCH_OPCODE;
  2437. OPCODE(OPCODE_ITERATE_BEGIN_VECTOR3I) {
  2438. CHECK_SPACE(8); // Check space for iterate instruction too.
  2439. GET_VARIANT_PTR(counter, 0);
  2440. GET_VARIANT_PTR(container, 1);
  2441. Vector3i *bounds = VariantInternal::get_vector3i(container);
  2442. int64_t from = bounds->x;
  2443. int64_t to = bounds->y;
  2444. int64_t step = bounds->z;
  2445. VariantInternal::initialize(counter, Variant::INT);
  2446. *VariantInternal::get_int(counter) = from;
  2447. bool do_continue = from == to ? false : (from < to ? step > 0 : step < 0);
  2448. if (do_continue) {
  2449. GET_VARIANT_PTR(iterator, 2);
  2450. VariantInternal::initialize(iterator, Variant::INT);
  2451. *VariantInternal::get_int(iterator) = from;
  2452. // Skip regular iterate.
  2453. ip += 5;
  2454. } else {
  2455. // Jump to end of loop.
  2456. int jumpto = _code_ptr[ip + 4];
  2457. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2458. ip = jumpto;
  2459. }
  2460. }
  2461. DISPATCH_OPCODE;
  2462. OPCODE(OPCODE_ITERATE_BEGIN_STRING) {
  2463. CHECK_SPACE(8); // Check space for iterate instruction too.
  2464. GET_VARIANT_PTR(counter, 0);
  2465. GET_VARIANT_PTR(container, 1);
  2466. String *str = VariantInternal::get_string(container);
  2467. VariantInternal::initialize(counter, Variant::INT);
  2468. *VariantInternal::get_int(counter) = 0;
  2469. if (!str->is_empty()) {
  2470. GET_VARIANT_PTR(iterator, 2);
  2471. VariantInternal::initialize(iterator, Variant::STRING);
  2472. *VariantInternal::get_string(iterator) = str->substr(0, 1);
  2473. // Skip regular iterate.
  2474. ip += 5;
  2475. } else {
  2476. // Jump to end of loop.
  2477. int jumpto = _code_ptr[ip + 4];
  2478. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2479. ip = jumpto;
  2480. }
  2481. }
  2482. DISPATCH_OPCODE;
  2483. OPCODE(OPCODE_ITERATE_BEGIN_DICTIONARY) {
  2484. CHECK_SPACE(8); // Check space for iterate instruction too.
  2485. GET_VARIANT_PTR(counter, 0);
  2486. GET_VARIANT_PTR(container, 1);
  2487. Dictionary *dict = VariantInternal::get_dictionary(container);
  2488. const Variant *next = dict->next(nullptr);
  2489. if (!dict->is_empty()) {
  2490. GET_VARIANT_PTR(iterator, 2);
  2491. *counter = *next;
  2492. *iterator = *next;
  2493. // Skip regular iterate.
  2494. ip += 5;
  2495. } else {
  2496. // Jump to end of loop.
  2497. int jumpto = _code_ptr[ip + 4];
  2498. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2499. ip = jumpto;
  2500. }
  2501. }
  2502. DISPATCH_OPCODE;
  2503. OPCODE(OPCODE_ITERATE_BEGIN_ARRAY) {
  2504. CHECK_SPACE(8); // Check space for iterate instruction too.
  2505. GET_VARIANT_PTR(counter, 0);
  2506. GET_VARIANT_PTR(container, 1);
  2507. Array *array = VariantInternal::get_array(container);
  2508. VariantInternal::initialize(counter, Variant::INT);
  2509. *VariantInternal::get_int(counter) = 0;
  2510. if (!array->is_empty()) {
  2511. GET_VARIANT_PTR(iterator, 2);
  2512. *iterator = array->get(0);
  2513. // Skip regular iterate.
  2514. ip += 5;
  2515. } else {
  2516. // Jump to end of loop.
  2517. int jumpto = _code_ptr[ip + 4];
  2518. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2519. ip = jumpto;
  2520. }
  2521. }
  2522. DISPATCH_OPCODE;
  2523. #define OPCODE_ITERATE_BEGIN_PACKED_ARRAY(m_var_type, m_elem_type, m_get_func, m_var_ret_type, m_ret_type, m_ret_get_func) \
  2524. OPCODE(OPCODE_ITERATE_BEGIN_PACKED_##m_var_type##_ARRAY) { \
  2525. CHECK_SPACE(8); \
  2526. GET_VARIANT_PTR(counter, 0); \
  2527. GET_VARIANT_PTR(container, 1); \
  2528. Vector<m_elem_type> *array = VariantInternal::m_get_func(container); \
  2529. VariantInternal::initialize(counter, Variant::INT); \
  2530. *VariantInternal::get_int(counter) = 0; \
  2531. if (!array->is_empty()) { \
  2532. GET_VARIANT_PTR(iterator, 2); \
  2533. VariantInternal::initialize(iterator, Variant::m_var_ret_type); \
  2534. m_ret_type *it = VariantInternal::m_ret_get_func(iterator); \
  2535. *it = array->get(0); \
  2536. ip += 5; \
  2537. } else { \
  2538. int jumpto = _code_ptr[ip + 4]; \
  2539. GD_ERR_BREAK(jumpto<0 || jumpto> _code_size); \
  2540. ip = jumpto; \
  2541. } \
  2542. } \
  2543. DISPATCH_OPCODE
  2544. OPCODE_ITERATE_BEGIN_PACKED_ARRAY(BYTE, uint8_t, get_byte_array, INT, int64_t, get_int);
  2545. OPCODE_ITERATE_BEGIN_PACKED_ARRAY(INT32, int32_t, get_int32_array, INT, int64_t, get_int);
  2546. OPCODE_ITERATE_BEGIN_PACKED_ARRAY(INT64, int64_t, get_int64_array, INT, int64_t, get_int);
  2547. OPCODE_ITERATE_BEGIN_PACKED_ARRAY(FLOAT32, float, get_float32_array, FLOAT, double, get_float);
  2548. OPCODE_ITERATE_BEGIN_PACKED_ARRAY(FLOAT64, double, get_float64_array, FLOAT, double, get_float);
  2549. OPCODE_ITERATE_BEGIN_PACKED_ARRAY(STRING, String, get_string_array, STRING, String, get_string);
  2550. OPCODE_ITERATE_BEGIN_PACKED_ARRAY(VECTOR2, Vector2, get_vector2_array, VECTOR2, Vector2, get_vector2);
  2551. OPCODE_ITERATE_BEGIN_PACKED_ARRAY(VECTOR3, Vector3, get_vector3_array, VECTOR3, Vector3, get_vector3);
  2552. OPCODE_ITERATE_BEGIN_PACKED_ARRAY(COLOR, Color, get_color_array, COLOR, Color, get_color);
  2553. OPCODE_ITERATE_BEGIN_PACKED_ARRAY(VECTOR4, Vector4, get_vector4_array, VECTOR4, Vector4, get_vector4);
  2554. OPCODE(OPCODE_ITERATE_BEGIN_OBJECT) {
  2555. CHECK_SPACE(4);
  2556. GET_VARIANT_PTR(counter, 0);
  2557. GET_VARIANT_PTR(container, 1);
  2558. #ifdef DEBUG_ENABLED
  2559. bool freed = false;
  2560. Object *obj = container->get_validated_object_with_check(freed);
  2561. if (freed) {
  2562. err_text = "Trying to iterate on a previously freed object.";
  2563. OPCODE_BREAK;
  2564. } else if (!obj) {
  2565. err_text = "Trying to iterate on a null value.";
  2566. OPCODE_BREAK;
  2567. }
  2568. #else
  2569. Object *obj = *VariantInternal::get_object(container);
  2570. #endif
  2571. *counter = Variant();
  2572. Array ref;
  2573. ref.push_back(*counter);
  2574. Variant vref;
  2575. VariantInternal::initialize(&vref, Variant::ARRAY);
  2576. *VariantInternal::get_array(&vref) = ref;
  2577. const Variant *args[] = { &vref };
  2578. Callable::CallError ce;
  2579. Variant has_next = obj->callp(CoreStringName(_iter_init), args, 1, ce);
  2580. #ifdef DEBUG_ENABLED
  2581. if (ref.size() != 1 || ce.error != Callable::CallError::CALL_OK) {
  2582. err_text = vformat(R"(There was an error calling "_iter_next" on iterator object of type %s.)", *container);
  2583. OPCODE_BREAK;
  2584. }
  2585. #endif
  2586. if (!has_next.booleanize()) {
  2587. int jumpto = _code_ptr[ip + 4];
  2588. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2589. ip = jumpto;
  2590. } else {
  2591. *counter = ref[0];
  2592. GET_VARIANT_PTR(iterator, 2);
  2593. *iterator = obj->callp(CoreStringName(_iter_get), (const Variant **)&counter, 1, ce);
  2594. #ifdef DEBUG_ENABLED
  2595. if (ce.error != Callable::CallError::CALL_OK) {
  2596. err_text = vformat(R"(There was an error calling "_iter_get" on iterator object of type %s.)", *container);
  2597. OPCODE_BREAK;
  2598. }
  2599. #endif
  2600. ip += 5; // Loop again.
  2601. }
  2602. }
  2603. DISPATCH_OPCODE;
  2604. OPCODE(OPCODE_ITERATE) {
  2605. CHECK_SPACE(4);
  2606. GET_VARIANT_PTR(counter, 0);
  2607. GET_VARIANT_PTR(container, 1);
  2608. bool valid;
  2609. if (!container->iter_next(*counter, valid)) {
  2610. #ifdef DEBUG_ENABLED
  2611. if (!valid) {
  2612. err_text = "Unable to iterate on object of type '" + Variant::get_type_name(container->get_type()) + "' (type changed since first iteration?).";
  2613. OPCODE_BREAK;
  2614. }
  2615. #endif
  2616. int jumpto = _code_ptr[ip + 4];
  2617. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2618. ip = jumpto;
  2619. } else {
  2620. GET_VARIANT_PTR(iterator, 2);
  2621. *iterator = container->iter_get(*counter, valid);
  2622. #ifdef DEBUG_ENABLED
  2623. if (!valid) {
  2624. err_text = "Unable to obtain iterator object of type '" + Variant::get_type_name(container->get_type()) + "' (but was obtained on first iteration?).";
  2625. OPCODE_BREAK;
  2626. }
  2627. #endif
  2628. ip += 5; //loop again
  2629. }
  2630. }
  2631. DISPATCH_OPCODE;
  2632. OPCODE(OPCODE_ITERATE_INT) {
  2633. CHECK_SPACE(4);
  2634. GET_VARIANT_PTR(counter, 0);
  2635. GET_VARIANT_PTR(container, 1);
  2636. int64_t size = *VariantInternal::get_int(container);
  2637. int64_t *count = VariantInternal::get_int(counter);
  2638. (*count)++;
  2639. if (*count >= size) {
  2640. int jumpto = _code_ptr[ip + 4];
  2641. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2642. ip = jumpto;
  2643. } else {
  2644. GET_VARIANT_PTR(iterator, 2);
  2645. *VariantInternal::get_int(iterator) = *count;
  2646. ip += 5; // Loop again.
  2647. }
  2648. }
  2649. DISPATCH_OPCODE;
  2650. OPCODE(OPCODE_ITERATE_FLOAT) {
  2651. CHECK_SPACE(4);
  2652. GET_VARIANT_PTR(counter, 0);
  2653. GET_VARIANT_PTR(container, 1);
  2654. double size = *VariantInternal::get_float(container);
  2655. double *count = VariantInternal::get_float(counter);
  2656. (*count)++;
  2657. if (*count >= size) {
  2658. int jumpto = _code_ptr[ip + 4];
  2659. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2660. ip = jumpto;
  2661. } else {
  2662. GET_VARIANT_PTR(iterator, 2);
  2663. *VariantInternal::get_float(iterator) = *count;
  2664. ip += 5; // Loop again.
  2665. }
  2666. }
  2667. DISPATCH_OPCODE;
  2668. OPCODE(OPCODE_ITERATE_VECTOR2) {
  2669. CHECK_SPACE(4);
  2670. GET_VARIANT_PTR(counter, 0);
  2671. GET_VARIANT_PTR(container, 1);
  2672. const Vector2 *bounds = VariantInternal::get_vector2((const Variant *)container);
  2673. double *count = VariantInternal::get_float(counter);
  2674. (*count)++;
  2675. if (*count >= bounds->y) {
  2676. int jumpto = _code_ptr[ip + 4];
  2677. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2678. ip = jumpto;
  2679. } else {
  2680. GET_VARIANT_PTR(iterator, 2);
  2681. *VariantInternal::get_float(iterator) = *count;
  2682. ip += 5; // Loop again.
  2683. }
  2684. }
  2685. DISPATCH_OPCODE;
  2686. OPCODE(OPCODE_ITERATE_VECTOR2I) {
  2687. CHECK_SPACE(4);
  2688. GET_VARIANT_PTR(counter, 0);
  2689. GET_VARIANT_PTR(container, 1);
  2690. const Vector2i *bounds = VariantInternal::get_vector2i((const Variant *)container);
  2691. int64_t *count = VariantInternal::get_int(counter);
  2692. (*count)++;
  2693. if (*count >= bounds->y) {
  2694. int jumpto = _code_ptr[ip + 4];
  2695. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2696. ip = jumpto;
  2697. } else {
  2698. GET_VARIANT_PTR(iterator, 2);
  2699. *VariantInternal::get_int(iterator) = *count;
  2700. ip += 5; // Loop again.
  2701. }
  2702. }
  2703. DISPATCH_OPCODE;
  2704. OPCODE(OPCODE_ITERATE_VECTOR3) {
  2705. CHECK_SPACE(4);
  2706. GET_VARIANT_PTR(counter, 0);
  2707. GET_VARIANT_PTR(container, 1);
  2708. const Vector3 *bounds = VariantInternal::get_vector3((const Variant *)container);
  2709. double *count = VariantInternal::get_float(counter);
  2710. *count += bounds->z;
  2711. if ((bounds->z < 0 && *count <= bounds->y) || (bounds->z > 0 && *count >= bounds->y)) {
  2712. int jumpto = _code_ptr[ip + 4];
  2713. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2714. ip = jumpto;
  2715. } else {
  2716. GET_VARIANT_PTR(iterator, 2);
  2717. *VariantInternal::get_float(iterator) = *count;
  2718. ip += 5; // Loop again.
  2719. }
  2720. }
  2721. DISPATCH_OPCODE;
  2722. OPCODE(OPCODE_ITERATE_VECTOR3I) {
  2723. CHECK_SPACE(4);
  2724. GET_VARIANT_PTR(counter, 0);
  2725. GET_VARIANT_PTR(container, 1);
  2726. const Vector3i *bounds = VariantInternal::get_vector3i((const Variant *)container);
  2727. int64_t *count = VariantInternal::get_int(counter);
  2728. *count += bounds->z;
  2729. if ((bounds->z < 0 && *count <= bounds->y) || (bounds->z > 0 && *count >= bounds->y)) {
  2730. int jumpto = _code_ptr[ip + 4];
  2731. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2732. ip = jumpto;
  2733. } else {
  2734. GET_VARIANT_PTR(iterator, 2);
  2735. *VariantInternal::get_int(iterator) = *count;
  2736. ip += 5; // Loop again.
  2737. }
  2738. }
  2739. DISPATCH_OPCODE;
  2740. OPCODE(OPCODE_ITERATE_STRING) {
  2741. CHECK_SPACE(4);
  2742. GET_VARIANT_PTR(counter, 0);
  2743. GET_VARIANT_PTR(container, 1);
  2744. const String *str = VariantInternal::get_string((const Variant *)container);
  2745. int64_t *idx = VariantInternal::get_int(counter);
  2746. (*idx)++;
  2747. if (*idx >= str->length()) {
  2748. int jumpto = _code_ptr[ip + 4];
  2749. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2750. ip = jumpto;
  2751. } else {
  2752. GET_VARIANT_PTR(iterator, 2);
  2753. *VariantInternal::get_string(iterator) = str->substr(*idx, 1);
  2754. ip += 5; // Loop again.
  2755. }
  2756. }
  2757. DISPATCH_OPCODE;
  2758. OPCODE(OPCODE_ITERATE_DICTIONARY) {
  2759. CHECK_SPACE(4);
  2760. GET_VARIANT_PTR(counter, 0);
  2761. GET_VARIANT_PTR(container, 1);
  2762. const Dictionary *dict = VariantInternal::get_dictionary((const Variant *)container);
  2763. const Variant *next = dict->next(counter);
  2764. if (!next) {
  2765. int jumpto = _code_ptr[ip + 4];
  2766. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2767. ip = jumpto;
  2768. } else {
  2769. GET_VARIANT_PTR(iterator, 2);
  2770. *counter = *next;
  2771. *iterator = *next;
  2772. ip += 5; // Loop again.
  2773. }
  2774. }
  2775. DISPATCH_OPCODE;
  2776. OPCODE(OPCODE_ITERATE_ARRAY) {
  2777. CHECK_SPACE(4);
  2778. GET_VARIANT_PTR(counter, 0);
  2779. GET_VARIANT_PTR(container, 1);
  2780. const Array *array = VariantInternal::get_array((const Variant *)container);
  2781. int64_t *idx = VariantInternal::get_int(counter);
  2782. (*idx)++;
  2783. if (*idx >= array->size()) {
  2784. int jumpto = _code_ptr[ip + 4];
  2785. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2786. ip = jumpto;
  2787. } else {
  2788. GET_VARIANT_PTR(iterator, 2);
  2789. *iterator = array->get(*idx);
  2790. ip += 5; // Loop again.
  2791. }
  2792. }
  2793. DISPATCH_OPCODE;
  2794. #define OPCODE_ITERATE_PACKED_ARRAY(m_var_type, m_elem_type, m_get_func, m_ret_get_func) \
  2795. OPCODE(OPCODE_ITERATE_PACKED_##m_var_type##_ARRAY) { \
  2796. CHECK_SPACE(4); \
  2797. GET_VARIANT_PTR(counter, 0); \
  2798. GET_VARIANT_PTR(container, 1); \
  2799. const Vector<m_elem_type> *array = VariantInternal::m_get_func((const Variant *)container); \
  2800. int64_t *idx = VariantInternal::get_int(counter); \
  2801. (*idx)++; \
  2802. if (*idx >= array->size()) { \
  2803. int jumpto = _code_ptr[ip + 4]; \
  2804. GD_ERR_BREAK(jumpto<0 || jumpto> _code_size); \
  2805. ip = jumpto; \
  2806. } else { \
  2807. GET_VARIANT_PTR(iterator, 2); \
  2808. *VariantInternal::m_ret_get_func(iterator) = array->get(*idx); \
  2809. ip += 5; \
  2810. } \
  2811. } \
  2812. DISPATCH_OPCODE
  2813. OPCODE_ITERATE_PACKED_ARRAY(BYTE, uint8_t, get_byte_array, get_int);
  2814. OPCODE_ITERATE_PACKED_ARRAY(INT32, int32_t, get_int32_array, get_int);
  2815. OPCODE_ITERATE_PACKED_ARRAY(INT64, int64_t, get_int64_array, get_int);
  2816. OPCODE_ITERATE_PACKED_ARRAY(FLOAT32, float, get_float32_array, get_float);
  2817. OPCODE_ITERATE_PACKED_ARRAY(FLOAT64, double, get_float64_array, get_float);
  2818. OPCODE_ITERATE_PACKED_ARRAY(STRING, String, get_string_array, get_string);
  2819. OPCODE_ITERATE_PACKED_ARRAY(VECTOR2, Vector2, get_vector2_array, get_vector2);
  2820. OPCODE_ITERATE_PACKED_ARRAY(VECTOR3, Vector3, get_vector3_array, get_vector3);
  2821. OPCODE_ITERATE_PACKED_ARRAY(COLOR, Color, get_color_array, get_color);
  2822. OPCODE_ITERATE_PACKED_ARRAY(VECTOR4, Vector4, get_vector4_array, get_vector4);
  2823. OPCODE(OPCODE_ITERATE_OBJECT) {
  2824. CHECK_SPACE(4);
  2825. GET_VARIANT_PTR(counter, 0);
  2826. GET_VARIANT_PTR(container, 1);
  2827. #ifdef DEBUG_ENABLED
  2828. bool freed = false;
  2829. Object *obj = container->get_validated_object_with_check(freed);
  2830. if (freed) {
  2831. err_text = "Trying to iterate on a previously freed object.";
  2832. OPCODE_BREAK;
  2833. } else if (!obj) {
  2834. err_text = "Trying to iterate on a null value.";
  2835. OPCODE_BREAK;
  2836. }
  2837. #else
  2838. Object *obj = *VariantInternal::get_object(container);
  2839. #endif
  2840. Array ref;
  2841. ref.push_back(*counter);
  2842. Variant vref;
  2843. VariantInternal::initialize(&vref, Variant::ARRAY);
  2844. *VariantInternal::get_array(&vref) = ref;
  2845. const Variant *args[] = { &vref };
  2846. Callable::CallError ce;
  2847. Variant has_next = obj->callp(CoreStringName(_iter_next), args, 1, ce);
  2848. #ifdef DEBUG_ENABLED
  2849. if (ref.size() != 1 || ce.error != Callable::CallError::CALL_OK) {
  2850. err_text = vformat(R"(There was an error calling "_iter_next" on iterator object of type %s.)", *container);
  2851. OPCODE_BREAK;
  2852. }
  2853. #endif
  2854. if (!has_next.booleanize()) {
  2855. int jumpto = _code_ptr[ip + 4];
  2856. GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
  2857. ip = jumpto;
  2858. } else {
  2859. *counter = ref[0];
  2860. GET_VARIANT_PTR(iterator, 2);
  2861. *iterator = obj->callp(CoreStringName(_iter_get), (const Variant **)&counter, 1, ce);
  2862. #ifdef DEBUG_ENABLED
  2863. if (ce.error != Callable::CallError::CALL_OK) {
  2864. err_text = vformat(R"(There was an error calling "_iter_get" on iterator object of type %s.)", *container);
  2865. OPCODE_BREAK;
  2866. }
  2867. #endif
  2868. ip += 5; // Loop again.
  2869. }
  2870. }
  2871. DISPATCH_OPCODE;
  2872. OPCODE(OPCODE_STORE_GLOBAL) {
  2873. CHECK_SPACE(3);
  2874. int global_idx = _code_ptr[ip + 2];
  2875. GD_ERR_BREAK(global_idx < 0 || global_idx >= GDScriptLanguage::get_singleton()->get_global_array_size());
  2876. GET_VARIANT_PTR(dst, 0);
  2877. *dst = GDScriptLanguage::get_singleton()->get_global_array()[global_idx];
  2878. ip += 3;
  2879. }
  2880. DISPATCH_OPCODE;
  2881. OPCODE(OPCODE_STORE_NAMED_GLOBAL) {
  2882. CHECK_SPACE(3);
  2883. int globalname_idx = _code_ptr[ip + 2];
  2884. GD_ERR_BREAK(globalname_idx < 0 || globalname_idx >= _global_names_count);
  2885. const StringName *globalname = &_global_names_ptr[globalname_idx];
  2886. GD_ERR_BREAK(!GDScriptLanguage::get_singleton()->get_named_globals_map().has(*globalname));
  2887. GET_VARIANT_PTR(dst, 0);
  2888. *dst = GDScriptLanguage::get_singleton()->get_named_globals_map()[*globalname];
  2889. ip += 3;
  2890. }
  2891. DISPATCH_OPCODE;
  2892. #define OPCODE_TYPE_ADJUST(m_v_type, m_c_type) \
  2893. OPCODE(OPCODE_TYPE_ADJUST_##m_v_type) { \
  2894. CHECK_SPACE(2); \
  2895. GET_VARIANT_PTR(arg, 0); \
  2896. VariantTypeAdjust<m_c_type>::adjust(arg); \
  2897. ip += 2; \
  2898. } \
  2899. DISPATCH_OPCODE
  2900. OPCODE_TYPE_ADJUST(BOOL, bool);
  2901. OPCODE_TYPE_ADJUST(INT, int64_t);
  2902. OPCODE_TYPE_ADJUST(FLOAT, double);
  2903. OPCODE_TYPE_ADJUST(STRING, String);
  2904. OPCODE_TYPE_ADJUST(VECTOR2, Vector2);
  2905. OPCODE_TYPE_ADJUST(VECTOR2I, Vector2i);
  2906. OPCODE_TYPE_ADJUST(RECT2, Rect2);
  2907. OPCODE_TYPE_ADJUST(RECT2I, Rect2i);
  2908. OPCODE_TYPE_ADJUST(VECTOR3, Vector3);
  2909. OPCODE_TYPE_ADJUST(VECTOR3I, Vector3i);
  2910. OPCODE_TYPE_ADJUST(TRANSFORM2D, Transform2D);
  2911. OPCODE_TYPE_ADJUST(VECTOR4, Vector4);
  2912. OPCODE_TYPE_ADJUST(VECTOR4I, Vector4i);
  2913. OPCODE_TYPE_ADJUST(PLANE, Plane);
  2914. OPCODE_TYPE_ADJUST(QUATERNION, Quaternion);
  2915. OPCODE_TYPE_ADJUST(AABB, AABB);
  2916. OPCODE_TYPE_ADJUST(BASIS, Basis);
  2917. OPCODE_TYPE_ADJUST(TRANSFORM3D, Transform3D);
  2918. OPCODE_TYPE_ADJUST(PROJECTION, Projection);
  2919. OPCODE_TYPE_ADJUST(COLOR, Color);
  2920. OPCODE_TYPE_ADJUST(STRING_NAME, StringName);
  2921. OPCODE_TYPE_ADJUST(NODE_PATH, NodePath);
  2922. OPCODE_TYPE_ADJUST(RID, RID);
  2923. OPCODE_TYPE_ADJUST(OBJECT, Object *);
  2924. OPCODE_TYPE_ADJUST(CALLABLE, Callable);
  2925. OPCODE_TYPE_ADJUST(SIGNAL, Signal);
  2926. OPCODE_TYPE_ADJUST(DICTIONARY, Dictionary);
  2927. OPCODE_TYPE_ADJUST(ARRAY, Array);
  2928. OPCODE_TYPE_ADJUST(PACKED_BYTE_ARRAY, PackedByteArray);
  2929. OPCODE_TYPE_ADJUST(PACKED_INT32_ARRAY, PackedInt32Array);
  2930. OPCODE_TYPE_ADJUST(PACKED_INT64_ARRAY, PackedInt64Array);
  2931. OPCODE_TYPE_ADJUST(PACKED_FLOAT32_ARRAY, PackedFloat32Array);
  2932. OPCODE_TYPE_ADJUST(PACKED_FLOAT64_ARRAY, PackedFloat64Array);
  2933. OPCODE_TYPE_ADJUST(PACKED_STRING_ARRAY, PackedStringArray);
  2934. OPCODE_TYPE_ADJUST(PACKED_VECTOR2_ARRAY, PackedVector2Array);
  2935. OPCODE_TYPE_ADJUST(PACKED_VECTOR3_ARRAY, PackedVector3Array);
  2936. OPCODE_TYPE_ADJUST(PACKED_COLOR_ARRAY, PackedColorArray);
  2937. OPCODE_TYPE_ADJUST(PACKED_VECTOR4_ARRAY, PackedVector4Array);
  2938. OPCODE(OPCODE_ASSERT) {
  2939. CHECK_SPACE(3);
  2940. #ifdef DEBUG_ENABLED
  2941. GET_VARIANT_PTR(test, 0);
  2942. bool result = test->booleanize();
  2943. if (!result) {
  2944. String message_str;
  2945. if (_code_ptr[ip + 2] != 0) {
  2946. GET_VARIANT_PTR(message, 1);
  2947. Variant message_var = *message;
  2948. if (message->get_type() != Variant::NIL) {
  2949. message_str = message_var;
  2950. }
  2951. }
  2952. if (message_str.is_empty()) {
  2953. err_text = "Assertion failed.";
  2954. } else {
  2955. err_text = "Assertion failed: " + message_str;
  2956. }
  2957. OPCODE_BREAK;
  2958. }
  2959. #endif
  2960. ip += 3;
  2961. }
  2962. DISPATCH_OPCODE;
  2963. OPCODE(OPCODE_BREAKPOINT) {
  2964. #ifdef DEBUG_ENABLED
  2965. if (EngineDebugger::is_active()) {
  2966. GDScriptLanguage::get_singleton()->debug_break("Breakpoint Statement", true);
  2967. }
  2968. #endif
  2969. ip += 1;
  2970. }
  2971. DISPATCH_OPCODE;
  2972. OPCODE(OPCODE_LINE) {
  2973. CHECK_SPACE(2);
  2974. line = _code_ptr[ip + 1];
  2975. ip += 2;
  2976. if (EngineDebugger::is_active()) {
  2977. // line
  2978. bool do_break = false;
  2979. if (unlikely(EngineDebugger::get_script_debugger()->get_lines_left() > 0)) {
  2980. if (EngineDebugger::get_script_debugger()->get_depth() <= 0) {
  2981. EngineDebugger::get_script_debugger()->set_lines_left(EngineDebugger::get_script_debugger()->get_lines_left() - 1);
  2982. }
  2983. if (EngineDebugger::get_script_debugger()->get_lines_left() <= 0) {
  2984. do_break = true;
  2985. }
  2986. }
  2987. if (EngineDebugger::get_script_debugger()->is_breakpoint(line, source)) {
  2988. do_break = true;
  2989. }
  2990. if (unlikely(do_break)) {
  2991. GDScriptLanguage::get_singleton()->debug_break("Breakpoint", true);
  2992. }
  2993. EngineDebugger::get_singleton()->line_poll();
  2994. }
  2995. }
  2996. DISPATCH_OPCODE;
  2997. OPCODE(OPCODE_END) {
  2998. #ifdef DEBUG_ENABLED
  2999. exit_ok = true;
  3000. #endif
  3001. OPCODE_BREAK;
  3002. }
  3003. #if 0 // Enable for debugging.
  3004. default: {
  3005. err_text = "Illegal opcode " + itos(_code_ptr[ip]) + " at address " + itos(ip);
  3006. OPCODE_BREAK;
  3007. }
  3008. #endif
  3009. }
  3010. OPCODES_END
  3011. #ifdef DEBUG_ENABLED
  3012. if (exit_ok) {
  3013. OPCODE_OUT;
  3014. }
  3015. //error
  3016. // function, file, line, error, explanation
  3017. String err_file;
  3018. bool instance_valid_with_script = p_instance && ObjectDB::get_instance(p_instance->owner_id) != nullptr && p_instance->script->is_valid();
  3019. if (instance_valid_with_script && !get_script()->path.is_empty()) {
  3020. err_file = get_script()->path;
  3021. } else if (script) {
  3022. err_file = script->path;
  3023. }
  3024. if (err_file.is_empty()) {
  3025. err_file = "<built-in>";
  3026. }
  3027. String err_func = name;
  3028. if (instance_valid_with_script && p_instance->script->local_name != StringName()) {
  3029. err_func = p_instance->script->local_name.operator String() + "." + err_func;
  3030. }
  3031. int err_line = line;
  3032. if (err_text.is_empty()) {
  3033. err_text = "Internal script error! Opcode: " + itos(last_opcode) + " (please report).";
  3034. }
  3035. if (!GDScriptLanguage::get_singleton()->debug_break(err_text, false)) {
  3036. // debugger break did not happen
  3037. _err_print_error(err_func.utf8().get_data(), err_file.utf8().get_data(), err_line, err_text.utf8().get_data(), false, ERR_HANDLER_SCRIPT);
  3038. }
  3039. // Get a default return type in case of failure
  3040. retvalue = _get_default_variant_for_data_type(return_type);
  3041. #endif
  3042. OPCODE_OUT;
  3043. }
  3044. OPCODES_OUT
  3045. #ifdef DEBUG_ENABLED
  3046. if (GDScriptLanguage::get_singleton()->profiling) {
  3047. uint64_t time_taken = OS::get_singleton()->get_ticks_usec() - function_start_time;
  3048. profile.total_time.add(time_taken);
  3049. profile.self_time.add(time_taken - function_call_time);
  3050. profile.frame_total_time.add(time_taken);
  3051. profile.frame_self_time.add(time_taken - function_call_time);
  3052. if (Thread::get_caller_id() == Thread::get_main_id()) {
  3053. GDScriptLanguage::get_singleton()->script_frame_time += time_taken - function_call_time;
  3054. }
  3055. }
  3056. // Check if this is not the last time it was interrupted by `await` or if it's the first time executing.
  3057. // If that is the case then we exit the function as normal. Otherwise we postpone it until the last `await` is completed.
  3058. // This ensures the call stack can be properly shown when using `await`, showing what resumed the function.
  3059. if (!p_state || awaited) {
  3060. if (EngineDebugger::is_active()) {
  3061. GDScriptLanguage::get_singleton()->exit_function();
  3062. }
  3063. #endif
  3064. // Free stack, except reserved addresses.
  3065. for (int i = FIXED_ADDRESSES_MAX; i < _stack_size; i++) {
  3066. stack[i].~Variant();
  3067. }
  3068. #ifdef DEBUG_ENABLED
  3069. }
  3070. #endif
  3071. // Always free reserved addresses, since they are never copied.
  3072. for (int i = 0; i < FIXED_ADDRESSES_MAX; i++) {
  3073. stack[i].~Variant();
  3074. }
  3075. call_depth--;
  3076. return retvalue;
  3077. }