gdscript_compiler.cpp 96 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645
  1. /*************************************************************************/
  2. /* gdscript_compiler.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
  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_compiler.h"
  31. #include "gdscript.h"
  32. #include "gdscript_byte_codegen.h"
  33. #include "gdscript_cache.h"
  34. #include "gdscript_utility_functions.h"
  35. bool GDScriptCompiler::_is_class_member_property(CodeGen &codegen, const StringName &p_name) {
  36. if (codegen.function_node && codegen.function_node->is_static) {
  37. return false;
  38. }
  39. if (codegen.locals.has(p_name)) {
  40. return false; //shadowed
  41. }
  42. return _is_class_member_property(codegen.script, p_name);
  43. }
  44. bool GDScriptCompiler::_is_class_member_property(GDScript *owner, const StringName &p_name) {
  45. GDScript *scr = owner;
  46. GDScriptNativeClass *nc = nullptr;
  47. while (scr) {
  48. if (scr->native.is_valid()) {
  49. nc = scr->native.ptr();
  50. }
  51. scr = scr->_base;
  52. }
  53. ERR_FAIL_COND_V(!nc, false);
  54. return ClassDB::has_property(nc->get_name(), p_name);
  55. }
  56. void GDScriptCompiler::_set_error(const String &p_error, const GDScriptParser::Node *p_node) {
  57. if (error != "") {
  58. return;
  59. }
  60. error = p_error;
  61. if (p_node) {
  62. err_line = p_node->start_line;
  63. err_column = p_node->leftmost_column;
  64. } else {
  65. err_line = 0;
  66. err_column = 0;
  67. }
  68. }
  69. GDScriptDataType GDScriptCompiler::_gdtype_from_datatype(const GDScriptParser::DataType &p_datatype, GDScript *p_owner) const {
  70. if (!p_datatype.is_set() || !p_datatype.is_hard_type()) {
  71. return GDScriptDataType();
  72. }
  73. GDScriptDataType result;
  74. result.has_type = true;
  75. switch (p_datatype.kind) {
  76. case GDScriptParser::DataType::VARIANT: {
  77. result.has_type = false;
  78. } break;
  79. case GDScriptParser::DataType::BUILTIN: {
  80. result.kind = GDScriptDataType::BUILTIN;
  81. result.builtin_type = p_datatype.builtin_type;
  82. } break;
  83. case GDScriptParser::DataType::NATIVE: {
  84. result.kind = GDScriptDataType::NATIVE;
  85. result.native_type = p_datatype.native_type;
  86. } break;
  87. case GDScriptParser::DataType::SCRIPT: {
  88. result.kind = GDScriptDataType::SCRIPT;
  89. result.script_type_ref = Ref<Script>(p_datatype.script_type);
  90. result.script_type = result.script_type_ref.ptr();
  91. result.native_type = result.script_type->get_instance_base_type();
  92. } break;
  93. case GDScriptParser::DataType::CLASS: {
  94. // Locate class by constructing the path to it and following that path
  95. GDScriptParser::ClassNode *class_type = p_datatype.class_type;
  96. if (class_type) {
  97. if ((!main_script->path.is_empty() && class_type->fqcn.begins_with(main_script->path)) || (!main_script->name.is_empty() && class_type->fqcn.begins_with(main_script->name))) {
  98. // Local class.
  99. List<StringName> names;
  100. while (class_type->outer) {
  101. names.push_back(class_type->identifier->name);
  102. class_type = class_type->outer;
  103. }
  104. Ref<GDScript> script = Ref<GDScript>(main_script);
  105. while (names.back()) {
  106. if (!script->subclasses.has(names.back()->get())) {
  107. ERR_PRINT("Parser bug: Cannot locate datatype class.");
  108. result.has_type = false;
  109. return GDScriptDataType();
  110. }
  111. script = script->subclasses[names.back()->get()];
  112. names.pop_back();
  113. }
  114. result.kind = GDScriptDataType::GDSCRIPT;
  115. result.script_type_ref = script;
  116. result.script_type = result.script_type_ref.ptr();
  117. result.native_type = script->get_instance_base_type();
  118. } else {
  119. result.kind = GDScriptDataType::GDSCRIPT;
  120. result.script_type_ref = GDScriptCache::get_shallow_script(p_datatype.script_path, main_script->path);
  121. result.script_type = result.script_type_ref.ptr();
  122. result.native_type = p_datatype.native_type;
  123. }
  124. }
  125. } break;
  126. case GDScriptParser::DataType::ENUM:
  127. case GDScriptParser::DataType::ENUM_VALUE:
  128. result.has_type = true;
  129. result.kind = GDScriptDataType::BUILTIN;
  130. result.builtin_type = Variant::INT;
  131. break;
  132. case GDScriptParser::DataType::UNRESOLVED: {
  133. ERR_PRINT("Parser bug: converting unresolved type.");
  134. return GDScriptDataType();
  135. }
  136. }
  137. if (p_datatype.has_container_element_type()) {
  138. result.set_container_element_type(_gdtype_from_datatype(p_datatype.get_container_element_type()));
  139. }
  140. // Only hold strong reference to the script if it's not the owner of the
  141. // element qualified with this type, to avoid cyclic references (leaks).
  142. if (result.script_type && result.script_type == p_owner) {
  143. result.script_type_ref = Ref<Script>();
  144. }
  145. return result;
  146. }
  147. static bool _is_exact_type(const PropertyInfo &p_par_type, const GDScriptDataType &p_arg_type) {
  148. if (!p_arg_type.has_type) {
  149. return false;
  150. }
  151. if (p_par_type.type == Variant::NIL) {
  152. return false;
  153. }
  154. if (p_par_type.type == Variant::OBJECT) {
  155. if (p_arg_type.kind == GDScriptDataType::BUILTIN) {
  156. return false;
  157. }
  158. StringName class_name;
  159. if (p_arg_type.kind == GDScriptDataType::NATIVE) {
  160. class_name = p_arg_type.native_type;
  161. } else {
  162. class_name = p_arg_type.native_type == StringName() ? p_arg_type.script_type->get_instance_base_type() : p_arg_type.native_type;
  163. }
  164. return p_par_type.class_name == class_name || ClassDB::is_parent_class(class_name, p_par_type.class_name);
  165. } else {
  166. if (p_arg_type.kind != GDScriptDataType::BUILTIN) {
  167. return false;
  168. }
  169. return p_par_type.type == p_arg_type.builtin_type;
  170. }
  171. }
  172. static bool _have_exact_arguments(const MethodBind *p_method, const Vector<GDScriptCodeGenerator::Address> &p_arguments) {
  173. if (p_method->get_argument_count() != p_arguments.size()) {
  174. // ptrcall won't work with default arguments.
  175. return false;
  176. }
  177. MethodInfo info;
  178. ClassDB::get_method_info(p_method->get_instance_class(), p_method->get_name(), &info);
  179. for (int i = 0; i < p_arguments.size(); i++) {
  180. const PropertyInfo &prop = info.arguments[i];
  181. if (!_is_exact_type(prop, p_arguments[i].type)) {
  182. return false;
  183. }
  184. }
  185. return true;
  186. }
  187. GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &codegen, Error &r_error, const GDScriptParser::ExpressionNode *p_expression, bool p_root, bool p_initializer, const GDScriptCodeGenerator::Address &p_index_addr) {
  188. if (p_expression->is_constant) {
  189. return codegen.add_constant(p_expression->reduced_value);
  190. }
  191. GDScriptCodeGenerator *gen = codegen.generator;
  192. switch (p_expression->type) {
  193. case GDScriptParser::Node::IDENTIFIER: {
  194. // Look for identifiers in current scope.
  195. const GDScriptParser::IdentifierNode *in = static_cast<const GDScriptParser::IdentifierNode *>(p_expression);
  196. StringName identifier = in->name;
  197. // Try function parameters.
  198. if (codegen.parameters.has(identifier)) {
  199. return codegen.parameters[identifier];
  200. }
  201. // Try local variables and constants.
  202. if (!p_initializer && codegen.locals.has(identifier)) {
  203. return codegen.locals[identifier];
  204. }
  205. // Try class members.
  206. if (_is_class_member_property(codegen, identifier)) {
  207. // Get property.
  208. GDScriptCodeGenerator::Address temp = codegen.add_temporary(); // TODO: Could get the type of the class member here.
  209. gen->write_get_member(temp, identifier);
  210. return temp;
  211. }
  212. // Try members.
  213. if (!codegen.function_node || !codegen.function_node->is_static) {
  214. // Try member variables.
  215. if (codegen.script->member_indices.has(identifier)) {
  216. if (codegen.script->member_indices[identifier].getter != StringName() && codegen.script->member_indices[identifier].getter != codegen.function_name) {
  217. // Perform getter.
  218. GDScriptCodeGenerator::Address temp = codegen.add_temporary();
  219. Vector<GDScriptCodeGenerator::Address> args; // No argument needed.
  220. gen->write_call_self(temp, codegen.script->member_indices[identifier].getter, args);
  221. return temp;
  222. } else {
  223. // No getter or inside getter: direct member access.,
  224. int idx = codegen.script->member_indices[identifier].index;
  225. return GDScriptCodeGenerator::Address(GDScriptCodeGenerator::Address::MEMBER, idx, codegen.script->get_member_type(identifier));
  226. }
  227. }
  228. }
  229. // Try class constants.
  230. {
  231. GDScript *owner = codegen.script;
  232. while (owner) {
  233. GDScript *scr = owner;
  234. GDScriptNativeClass *nc = nullptr;
  235. while (scr) {
  236. if (scr->constants.has(identifier)) {
  237. return codegen.add_constant(scr->constants[identifier]); // TODO: Get type here.
  238. }
  239. if (scr->native.is_valid()) {
  240. nc = scr->native.ptr();
  241. }
  242. scr = scr->_base;
  243. }
  244. // Class C++ integer constant.
  245. if (nc) {
  246. bool success = false;
  247. int constant = ClassDB::get_integer_constant(nc->get_name(), identifier, &success);
  248. if (success) {
  249. return codegen.add_constant(constant);
  250. }
  251. }
  252. owner = owner->_owner;
  253. }
  254. }
  255. // Try signals and methods (can be made callables).
  256. {
  257. if (codegen.class_node->members_indices.has(identifier)) {
  258. const GDScriptParser::ClassNode::Member &member = codegen.class_node->members[codegen.class_node->members_indices[identifier]];
  259. if (member.type == GDScriptParser::ClassNode::Member::FUNCTION || member.type == GDScriptParser::ClassNode::Member::SIGNAL) {
  260. // Get like it was a property.
  261. GDScriptCodeGenerator::Address temp = codegen.add_temporary(); // TODO: Get type here.
  262. GDScriptCodeGenerator::Address self(GDScriptCodeGenerator::Address::SELF);
  263. gen->write_get_named(temp, identifier, self);
  264. return temp;
  265. }
  266. }
  267. // Try in native base.
  268. GDScript *scr = codegen.script;
  269. GDScriptNativeClass *nc = nullptr;
  270. while (scr) {
  271. if (scr->native.is_valid()) {
  272. nc = scr->native.ptr();
  273. }
  274. scr = scr->_base;
  275. }
  276. if (nc && (ClassDB::has_signal(nc->get_name(), identifier) || ClassDB::has_method(nc->get_name(), identifier))) {
  277. // Get like it was a property.
  278. GDScriptCodeGenerator::Address temp = codegen.add_temporary(); // TODO: Get type here.
  279. GDScriptCodeGenerator::Address self(GDScriptCodeGenerator::Address::SELF);
  280. gen->write_get_named(temp, identifier, self);
  281. return temp;
  282. }
  283. }
  284. if (GDScriptLanguage::get_singleton()->get_global_map().has(identifier)) {
  285. int idx = GDScriptLanguage::get_singleton()->get_global_map()[identifier];
  286. Variant global = GDScriptLanguage::get_singleton()->get_global_array()[idx];
  287. return codegen.add_constant(global); // TODO: Get type.
  288. }
  289. // Try global classes.
  290. if (ScriptServer::is_global_class(identifier)) {
  291. const GDScriptParser::ClassNode *class_node = codegen.class_node;
  292. while (class_node->outer) {
  293. class_node = class_node->outer;
  294. }
  295. RES res;
  296. if (class_node->identifier && class_node->identifier->name == identifier) {
  297. res = Ref<GDScript>(main_script);
  298. } else {
  299. res = ResourceLoader::load(ScriptServer::get_global_class_path(identifier));
  300. if (res.is_null()) {
  301. _set_error("Can't load global class " + String(identifier) + ", cyclic reference?", p_expression);
  302. r_error = ERR_COMPILATION_FAILED;
  303. return GDScriptCodeGenerator::Address();
  304. }
  305. }
  306. return codegen.add_constant(res);
  307. }
  308. #ifdef TOOLS_ENABLED
  309. if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(identifier)) {
  310. GDScriptCodeGenerator::Address global = codegen.add_temporary(); // TODO: Get type.
  311. gen->write_store_named_global(global, identifier);
  312. return global;
  313. }
  314. #endif
  315. // Not found, error.
  316. _set_error("Identifier not found: " + String(identifier), p_expression);
  317. r_error = ERR_COMPILATION_FAILED;
  318. return GDScriptCodeGenerator::Address();
  319. } break;
  320. case GDScriptParser::Node::LITERAL: {
  321. // Return constant.
  322. const GDScriptParser::LiteralNode *cn = static_cast<const GDScriptParser::LiteralNode *>(p_expression);
  323. return codegen.add_constant(cn->value);
  324. } break;
  325. case GDScriptParser::Node::SELF: {
  326. //return constant
  327. if (codegen.function_node && codegen.function_node->is_static) {
  328. _set_error("'self' not present in static function!", p_expression);
  329. r_error = ERR_COMPILATION_FAILED;
  330. return GDScriptCodeGenerator::Address();
  331. }
  332. return GDScriptCodeGenerator::Address(GDScriptCodeGenerator::Address::SELF);
  333. } break;
  334. case GDScriptParser::Node::ARRAY: {
  335. const GDScriptParser::ArrayNode *an = static_cast<const GDScriptParser::ArrayNode *>(p_expression);
  336. Vector<GDScriptCodeGenerator::Address> values;
  337. // Create the result temporary first since it's the last to be killed.
  338. GDScriptDataType array_type = _gdtype_from_datatype(an->get_datatype());
  339. GDScriptCodeGenerator::Address result = codegen.add_temporary(array_type);
  340. for (int i = 0; i < an->elements.size(); i++) {
  341. GDScriptCodeGenerator::Address val = _parse_expression(codegen, r_error, an->elements[i]);
  342. if (r_error) {
  343. return GDScriptCodeGenerator::Address();
  344. }
  345. values.push_back(val);
  346. }
  347. if (array_type.has_container_element_type()) {
  348. gen->write_construct_typed_array(result, array_type.get_container_element_type(), values);
  349. } else {
  350. gen->write_construct_array(result, values);
  351. }
  352. for (int i = 0; i < values.size(); i++) {
  353. if (values[i].mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  354. gen->pop_temporary();
  355. }
  356. }
  357. return result;
  358. } break;
  359. case GDScriptParser::Node::DICTIONARY: {
  360. const GDScriptParser::DictionaryNode *dn = static_cast<const GDScriptParser::DictionaryNode *>(p_expression);
  361. Vector<GDScriptCodeGenerator::Address> elements;
  362. // Create the result temporary first since it's the last to be killed.
  363. GDScriptDataType dict_type;
  364. dict_type.has_type = true;
  365. dict_type.kind = GDScriptDataType::BUILTIN;
  366. dict_type.builtin_type = Variant::DICTIONARY;
  367. GDScriptCodeGenerator::Address result = codegen.add_temporary(dict_type);
  368. for (int i = 0; i < dn->elements.size(); i++) {
  369. // Key.
  370. GDScriptCodeGenerator::Address element;
  371. switch (dn->style) {
  372. case GDScriptParser::DictionaryNode::PYTHON_DICT:
  373. // Python-style: key is any expression.
  374. element = _parse_expression(codegen, r_error, dn->elements[i].key);
  375. if (r_error) {
  376. return GDScriptCodeGenerator::Address();
  377. }
  378. break;
  379. case GDScriptParser::DictionaryNode::LUA_TABLE:
  380. // Lua-style: key is an identifier interpreted as StringName.
  381. StringName key = static_cast<const GDScriptParser::IdentifierNode *>(dn->elements[i].key)->name;
  382. element = codegen.add_constant(key);
  383. break;
  384. }
  385. elements.push_back(element);
  386. element = _parse_expression(codegen, r_error, dn->elements[i].value);
  387. if (r_error) {
  388. return GDScriptCodeGenerator::Address();
  389. }
  390. elements.push_back(element);
  391. }
  392. gen->write_construct_dictionary(result, elements);
  393. for (int i = 0; i < elements.size(); i++) {
  394. if (elements[i].mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  395. gen->pop_temporary();
  396. }
  397. }
  398. return result;
  399. } break;
  400. case GDScriptParser::Node::CAST: {
  401. const GDScriptParser::CastNode *cn = static_cast<const GDScriptParser::CastNode *>(p_expression);
  402. GDScriptDataType cast_type = _gdtype_from_datatype(cn->cast_type->get_datatype());
  403. // Create temporary for result first since it will be deleted last.
  404. GDScriptCodeGenerator::Address result = codegen.add_temporary(cast_type);
  405. GDScriptCodeGenerator::Address source = _parse_expression(codegen, r_error, cn->operand);
  406. gen->write_cast(result, source, cast_type);
  407. if (source.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  408. gen->pop_temporary();
  409. }
  410. return result;
  411. } break;
  412. case GDScriptParser::Node::CALL: {
  413. const GDScriptParser::CallNode *call = static_cast<const GDScriptParser::CallNode *>(p_expression);
  414. GDScriptDataType type = _gdtype_from_datatype(call->get_datatype());
  415. GDScriptCodeGenerator::Address result = codegen.add_temporary(type);
  416. Vector<GDScriptCodeGenerator::Address> arguments;
  417. for (int i = 0; i < call->arguments.size(); i++) {
  418. GDScriptCodeGenerator::Address arg = _parse_expression(codegen, r_error, call->arguments[i]);
  419. if (r_error) {
  420. return GDScriptCodeGenerator::Address();
  421. }
  422. arguments.push_back(arg);
  423. }
  424. if (!call->is_super && call->callee->type == GDScriptParser::Node::IDENTIFIER && GDScriptParser::get_builtin_type(call->function_name) != Variant::VARIANT_MAX) {
  425. // Construct a built-in type.
  426. Variant::Type vtype = GDScriptParser::get_builtin_type(static_cast<GDScriptParser::IdentifierNode *>(call->callee)->name);
  427. gen->write_construct(result, vtype, arguments);
  428. } else if (!call->is_super && call->callee->type == GDScriptParser::Node::IDENTIFIER && Variant::has_utility_function(call->function_name)) {
  429. // Variant utility function.
  430. gen->write_call_utility(result, call->function_name, arguments);
  431. } else if (!call->is_super && call->callee->type == GDScriptParser::Node::IDENTIFIER && GDScriptUtilityFunctions::function_exists(call->function_name)) {
  432. // GDScript utility function.
  433. gen->write_call_gdscript_utility(result, GDScriptUtilityFunctions::get_function(call->function_name), arguments);
  434. } else {
  435. // Regular function.
  436. const GDScriptParser::ExpressionNode *callee = call->callee;
  437. if (call->is_super) {
  438. // Super call.
  439. gen->write_super_call(result, call->function_name, arguments);
  440. } else {
  441. if (callee->type == GDScriptParser::Node::IDENTIFIER) {
  442. // Self function call.
  443. if (ClassDB::has_method(codegen.script->native->get_name(), call->function_name)) {
  444. // Native method, use faster path.
  445. GDScriptCodeGenerator::Address self;
  446. self.mode = GDScriptCodeGenerator::Address::SELF;
  447. MethodBind *method = ClassDB::get_method(codegen.script->native->get_name(), call->function_name);
  448. if (_have_exact_arguments(method, arguments)) {
  449. // Exact arguments, use ptrcall.
  450. gen->write_call_ptrcall(result, self, method, arguments);
  451. } else {
  452. // Not exact arguments, but still can use method bind call.
  453. gen->write_call_method_bind(result, self, method, arguments);
  454. }
  455. } else if ((codegen.function_node && codegen.function_node->is_static) || call->function_name == "new") {
  456. GDScriptCodeGenerator::Address self;
  457. self.mode = GDScriptCodeGenerator::Address::CLASS;
  458. if (within_await) {
  459. gen->write_call_async(result, self, call->function_name, arguments);
  460. } else {
  461. gen->write_call(result, self, call->function_name, arguments);
  462. }
  463. } else {
  464. if (within_await) {
  465. gen->write_call_self_async(result, call->function_name, arguments);
  466. } else {
  467. gen->write_call_self(result, call->function_name, arguments);
  468. }
  469. }
  470. } else if (callee->type == GDScriptParser::Node::SUBSCRIPT) {
  471. const GDScriptParser::SubscriptNode *subscript = static_cast<const GDScriptParser::SubscriptNode *>(call->callee);
  472. if (subscript->is_attribute) {
  473. // May be static built-in method call.
  474. if (!call->is_super && subscript->base->type == GDScriptParser::Node::IDENTIFIER && GDScriptParser::get_builtin_type(static_cast<GDScriptParser::IdentifierNode *>(subscript->base)->name) < Variant::VARIANT_MAX) {
  475. gen->write_call_builtin_type_static(result, GDScriptParser::get_builtin_type(static_cast<GDScriptParser::IdentifierNode *>(subscript->base)->name), subscript->attribute->name, arguments);
  476. } else {
  477. GDScriptCodeGenerator::Address base = _parse_expression(codegen, r_error, subscript->base);
  478. if (r_error) {
  479. return GDScriptCodeGenerator::Address();
  480. }
  481. if (within_await) {
  482. gen->write_call_async(result, base, call->function_name, arguments);
  483. } else if (base.type.has_type && base.type.kind != GDScriptDataType::BUILTIN) {
  484. // Native method, use faster path.
  485. StringName class_name;
  486. if (base.type.kind == GDScriptDataType::NATIVE) {
  487. class_name = base.type.native_type;
  488. } else {
  489. class_name = base.type.native_type == StringName() ? base.type.script_type->get_instance_base_type() : base.type.native_type;
  490. }
  491. if (ClassDB::class_exists(class_name) && ClassDB::has_method(class_name, call->function_name)) {
  492. MethodBind *method = ClassDB::get_method(class_name, call->function_name);
  493. if (_have_exact_arguments(method, arguments)) {
  494. // Exact arguments, use ptrcall.
  495. gen->write_call_ptrcall(result, base, method, arguments);
  496. } else {
  497. // Not exact arguments, but still can use method bind call.
  498. gen->write_call_method_bind(result, base, method, arguments);
  499. }
  500. } else {
  501. gen->write_call(result, base, call->function_name, arguments);
  502. }
  503. } else if (base.type.has_type && base.type.kind == GDScriptDataType::BUILTIN) {
  504. gen->write_call_builtin_type(result, base, base.type.builtin_type, call->function_name, arguments);
  505. } else {
  506. gen->write_call(result, base, call->function_name, arguments);
  507. }
  508. if (base.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  509. gen->pop_temporary();
  510. }
  511. }
  512. } else {
  513. _set_error("Cannot call something that isn't a function.", call->callee);
  514. r_error = ERR_COMPILATION_FAILED;
  515. return GDScriptCodeGenerator::Address();
  516. }
  517. } else {
  518. r_error = ERR_COMPILATION_FAILED;
  519. return GDScriptCodeGenerator::Address();
  520. }
  521. }
  522. }
  523. for (int i = 0; i < arguments.size(); i++) {
  524. if (arguments[i].mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  525. gen->pop_temporary();
  526. }
  527. }
  528. return result;
  529. } break;
  530. case GDScriptParser::Node::GET_NODE: {
  531. const GDScriptParser::GetNodeNode *get_node = static_cast<const GDScriptParser::GetNodeNode *>(p_expression);
  532. String node_name;
  533. if (get_node->string != nullptr) {
  534. node_name += String(get_node->string->value);
  535. } else {
  536. for (int i = 0; i < get_node->chain.size(); i++) {
  537. if (i > 0) {
  538. node_name += "/";
  539. }
  540. node_name += get_node->chain[i]->name;
  541. }
  542. }
  543. Vector<GDScriptCodeGenerator::Address> args;
  544. args.push_back(codegen.add_constant(NodePath(node_name)));
  545. GDScriptCodeGenerator::Address result = codegen.add_temporary(_gdtype_from_datatype(get_node->get_datatype()));
  546. MethodBind *get_node_method = ClassDB::get_method("Node", "get_node");
  547. gen->write_call_ptrcall(result, GDScriptCodeGenerator::Address(GDScriptCodeGenerator::Address::SELF), get_node_method, args);
  548. return result;
  549. } break;
  550. case GDScriptParser::Node::PRELOAD: {
  551. const GDScriptParser::PreloadNode *preload = static_cast<const GDScriptParser::PreloadNode *>(p_expression);
  552. // Add resource as constant.
  553. return codegen.add_constant(preload->resource);
  554. } break;
  555. case GDScriptParser::Node::AWAIT: {
  556. const GDScriptParser::AwaitNode *await = static_cast<const GDScriptParser::AwaitNode *>(p_expression);
  557. GDScriptCodeGenerator::Address result = codegen.add_temporary(_gdtype_from_datatype(p_expression->get_datatype()));
  558. within_await = true;
  559. GDScriptCodeGenerator::Address argument = _parse_expression(codegen, r_error, await->to_await);
  560. within_await = false;
  561. if (r_error) {
  562. return GDScriptCodeGenerator::Address();
  563. }
  564. gen->write_await(result, argument);
  565. if (argument.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  566. gen->pop_temporary();
  567. }
  568. return result;
  569. } break;
  570. // Indexing operator.
  571. case GDScriptParser::Node::SUBSCRIPT: {
  572. const GDScriptParser::SubscriptNode *subscript = static_cast<const GDScriptParser::SubscriptNode *>(p_expression);
  573. GDScriptCodeGenerator::Address result = codegen.add_temporary(_gdtype_from_datatype(subscript->get_datatype()));
  574. GDScriptCodeGenerator::Address base = _parse_expression(codegen, r_error, subscript->base);
  575. if (r_error) {
  576. return GDScriptCodeGenerator::Address();
  577. }
  578. bool named = subscript->is_attribute;
  579. StringName name;
  580. GDScriptCodeGenerator::Address index;
  581. if (p_index_addr.mode != GDScriptCodeGenerator::Address::NIL) {
  582. index = p_index_addr;
  583. } else if (subscript->is_attribute) {
  584. if (subscript->base->type == GDScriptParser::Node::SELF && codegen.script) {
  585. GDScriptParser::IdentifierNode *identifier = subscript->attribute;
  586. const Map<StringName, GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(identifier->name);
  587. #ifdef DEBUG_ENABLED
  588. if (MI && MI->get().getter == codegen.function_name) {
  589. String n = identifier->name;
  590. _set_error("Must use '" + n + "' instead of 'self." + n + "' in getter.", identifier);
  591. r_error = ERR_COMPILATION_FAILED;
  592. return GDScriptCodeGenerator::Address();
  593. }
  594. #endif
  595. if (MI && MI->get().getter == "") {
  596. // Remove result temp as we don't need it.
  597. gen->pop_temporary();
  598. // Faster than indexing self (as if no self. had been used).
  599. return GDScriptCodeGenerator::Address(GDScriptCodeGenerator::Address::MEMBER, MI->get().index, _gdtype_from_datatype(subscript->get_datatype()));
  600. }
  601. }
  602. name = subscript->attribute->name;
  603. named = true;
  604. } else {
  605. if (subscript->index->is_constant && subscript->index->reduced_value.get_type() == Variant::STRING_NAME) {
  606. // Also, somehow, named (speed up anyway).
  607. name = subscript->index->reduced_value;
  608. named = true;
  609. } else {
  610. // Regular indexing.
  611. index = _parse_expression(codegen, r_error, subscript->index);
  612. if (r_error) {
  613. return GDScriptCodeGenerator::Address();
  614. }
  615. }
  616. }
  617. if (named) {
  618. gen->write_get_named(result, name, base);
  619. } else {
  620. gen->write_get(result, index, base);
  621. }
  622. if (index.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  623. gen->pop_temporary();
  624. }
  625. if (base.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  626. gen->pop_temporary();
  627. }
  628. return result;
  629. } break;
  630. case GDScriptParser::Node::UNARY_OPERATOR: {
  631. const GDScriptParser::UnaryOpNode *unary = static_cast<const GDScriptParser::UnaryOpNode *>(p_expression);
  632. GDScriptCodeGenerator::Address result = codegen.add_temporary(_gdtype_from_datatype(unary->get_datatype()));
  633. GDScriptCodeGenerator::Address operand = _parse_expression(codegen, r_error, unary->operand);
  634. if (r_error) {
  635. return GDScriptCodeGenerator::Address();
  636. }
  637. gen->write_unary_operator(result, unary->variant_op, operand);
  638. if (operand.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  639. gen->pop_temporary();
  640. }
  641. return result;
  642. }
  643. case GDScriptParser::Node::BINARY_OPERATOR: {
  644. const GDScriptParser::BinaryOpNode *binary = static_cast<const GDScriptParser::BinaryOpNode *>(p_expression);
  645. GDScriptCodeGenerator::Address result = codegen.add_temporary(_gdtype_from_datatype(binary->get_datatype()));
  646. switch (binary->operation) {
  647. case GDScriptParser::BinaryOpNode::OP_LOGIC_AND: {
  648. // AND operator with early out on failure.
  649. GDScriptCodeGenerator::Address left_operand = _parse_expression(codegen, r_error, binary->left_operand);
  650. gen->write_and_left_operand(left_operand);
  651. GDScriptCodeGenerator::Address right_operand = _parse_expression(codegen, r_error, binary->right_operand);
  652. gen->write_and_right_operand(right_operand);
  653. gen->write_end_and(result);
  654. if (right_operand.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  655. gen->pop_temporary();
  656. }
  657. if (left_operand.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  658. gen->pop_temporary();
  659. }
  660. } break;
  661. case GDScriptParser::BinaryOpNode::OP_LOGIC_OR: {
  662. // OR operator with early out on success.
  663. GDScriptCodeGenerator::Address left_operand = _parse_expression(codegen, r_error, binary->left_operand);
  664. gen->write_or_left_operand(left_operand);
  665. GDScriptCodeGenerator::Address right_operand = _parse_expression(codegen, r_error, binary->right_operand);
  666. gen->write_or_right_operand(right_operand);
  667. gen->write_end_or(result);
  668. if (right_operand.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  669. gen->pop_temporary();
  670. }
  671. if (left_operand.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  672. gen->pop_temporary();
  673. }
  674. } break;
  675. case GDScriptParser::BinaryOpNode::OP_TYPE_TEST: {
  676. GDScriptCodeGenerator::Address operand = _parse_expression(codegen, r_error, binary->left_operand);
  677. if (binary->right_operand->type == GDScriptParser::Node::IDENTIFIER && GDScriptParser::get_builtin_type(static_cast<const GDScriptParser::IdentifierNode *>(binary->right_operand)->name) != Variant::VARIANT_MAX) {
  678. // `is` with builtin type)
  679. Variant::Type type = GDScriptParser::get_builtin_type(static_cast<const GDScriptParser::IdentifierNode *>(binary->right_operand)->name);
  680. gen->write_type_test_builtin(result, operand, type);
  681. } else {
  682. GDScriptCodeGenerator::Address type = _parse_expression(codegen, r_error, binary->right_operand);
  683. if (r_error) {
  684. return GDScriptCodeGenerator::Address();
  685. }
  686. gen->write_type_test(result, operand, type);
  687. if (type.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  688. gen->pop_temporary();
  689. }
  690. }
  691. if (operand.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  692. gen->pop_temporary();
  693. }
  694. } break;
  695. default: {
  696. GDScriptCodeGenerator::Address left_operand = _parse_expression(codegen, r_error, binary->left_operand);
  697. GDScriptCodeGenerator::Address right_operand = _parse_expression(codegen, r_error, binary->right_operand);
  698. gen->write_binary_operator(result, binary->variant_op, left_operand, right_operand);
  699. if (right_operand.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  700. gen->pop_temporary();
  701. }
  702. if (left_operand.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  703. gen->pop_temporary();
  704. }
  705. }
  706. }
  707. return result;
  708. } break;
  709. case GDScriptParser::Node::TERNARY_OPERATOR: {
  710. // x IF a ELSE y operator with early out on failure.
  711. const GDScriptParser::TernaryOpNode *ternary = static_cast<const GDScriptParser::TernaryOpNode *>(p_expression);
  712. GDScriptCodeGenerator::Address result = codegen.add_temporary(_gdtype_from_datatype(ternary->get_datatype()));
  713. gen->write_start_ternary(result);
  714. GDScriptCodeGenerator::Address condition = _parse_expression(codegen, r_error, ternary->condition);
  715. if (r_error) {
  716. return GDScriptCodeGenerator::Address();
  717. }
  718. gen->write_ternary_condition(condition);
  719. if (condition.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  720. gen->pop_temporary();
  721. }
  722. GDScriptCodeGenerator::Address true_expr = _parse_expression(codegen, r_error, ternary->true_expr);
  723. if (r_error) {
  724. return GDScriptCodeGenerator::Address();
  725. }
  726. gen->write_ternary_true_expr(true_expr);
  727. if (true_expr.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  728. gen->pop_temporary();
  729. }
  730. GDScriptCodeGenerator::Address false_expr = _parse_expression(codegen, r_error, ternary->false_expr);
  731. if (r_error) {
  732. return GDScriptCodeGenerator::Address();
  733. }
  734. gen->write_ternary_false_expr(false_expr);
  735. if (false_expr.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  736. gen->pop_temporary();
  737. }
  738. gen->write_end_ternary();
  739. return result;
  740. } break;
  741. case GDScriptParser::Node::ASSIGNMENT: {
  742. const GDScriptParser::AssignmentNode *assignment = static_cast<const GDScriptParser::AssignmentNode *>(p_expression);
  743. if (assignment->assignee->type == GDScriptParser::Node::SUBSCRIPT) {
  744. // SET (chained) MODE!
  745. const GDScriptParser::SubscriptNode *subscript = static_cast<GDScriptParser::SubscriptNode *>(assignment->assignee);
  746. #ifdef DEBUG_ENABLED
  747. if (subscript->is_attribute && subscript->base->type == GDScriptParser::Node::SELF && codegen.script) {
  748. const Map<StringName, GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(subscript->attribute->name);
  749. if (MI && MI->get().setter == codegen.function_name) {
  750. String n = subscript->attribute->name;
  751. _set_error("Must use '" + n + "' instead of 'self." + n + "' in setter.", subscript);
  752. r_error = ERR_COMPILATION_FAILED;
  753. return GDScriptCodeGenerator::Address();
  754. }
  755. }
  756. #endif
  757. /* Find chain of sets */
  758. StringName assign_property;
  759. List<const GDScriptParser::SubscriptNode *> chain;
  760. {
  761. // Create get/set chain.
  762. const GDScriptParser::SubscriptNode *n = subscript;
  763. while (true) {
  764. chain.push_back(n);
  765. if (n->base->type != GDScriptParser::Node::SUBSCRIPT) {
  766. // Check for a built-in property.
  767. if (n->base->type == GDScriptParser::Node::IDENTIFIER) {
  768. GDScriptParser::IdentifierNode *identifier = static_cast<GDScriptParser::IdentifierNode *>(n->base);
  769. if (_is_class_member_property(codegen, identifier->name)) {
  770. assign_property = identifier->name;
  771. }
  772. }
  773. break;
  774. }
  775. n = static_cast<const GDScriptParser::SubscriptNode *>(n->base);
  776. }
  777. }
  778. /* Chain of gets */
  779. // Get at (potential) root stack pos, so it can be returned.
  780. GDScriptCodeGenerator::Address base = _parse_expression(codegen, r_error, chain.back()->get()->base);
  781. if (r_error) {
  782. return GDScriptCodeGenerator::Address();
  783. }
  784. GDScriptCodeGenerator::Address prev_base = base;
  785. struct ChainInfo {
  786. bool is_named = false;
  787. GDScriptCodeGenerator::Address base;
  788. GDScriptCodeGenerator::Address key;
  789. StringName name;
  790. };
  791. List<ChainInfo> set_chain;
  792. for (List<const GDScriptParser::SubscriptNode *>::Element *E = chain.back(); E; E = E->prev()) {
  793. if (E == chain.front()) {
  794. // Skip the main subscript, since we'll assign to that.
  795. break;
  796. }
  797. const GDScriptParser::SubscriptNode *subscript_elem = E->get();
  798. GDScriptCodeGenerator::Address value = codegen.add_temporary(_gdtype_from_datatype(subscript_elem->get_datatype()));
  799. GDScriptCodeGenerator::Address key;
  800. StringName name;
  801. if (subscript_elem->is_attribute) {
  802. name = subscript_elem->attribute->name;
  803. gen->write_get_named(value, name, prev_base);
  804. } else {
  805. key = _parse_expression(codegen, r_error, subscript_elem->index);
  806. if (r_error) {
  807. return GDScriptCodeGenerator::Address();
  808. }
  809. gen->write_get(value, key, prev_base);
  810. }
  811. // Store base and key for setting it back later.
  812. set_chain.push_front({ subscript_elem->is_attribute, prev_base, key, name }); // Push to front to invert the list.
  813. prev_base = value;
  814. }
  815. // Get value to assign.
  816. GDScriptCodeGenerator::Address assigned = _parse_expression(codegen, r_error, assignment->assigned_value);
  817. if (r_error) {
  818. return GDScriptCodeGenerator::Address();
  819. }
  820. // Get the key if needed.
  821. GDScriptCodeGenerator::Address key;
  822. StringName name;
  823. if (subscript->is_attribute) {
  824. name = subscript->attribute->name;
  825. } else {
  826. key = _parse_expression(codegen, r_error, subscript->index);
  827. if (r_error) {
  828. return GDScriptCodeGenerator::Address();
  829. }
  830. }
  831. // Perform operator if any.
  832. if (assignment->operation != GDScriptParser::AssignmentNode::OP_NONE) {
  833. GDScriptCodeGenerator::Address value = codegen.add_temporary();
  834. if (subscript->is_attribute) {
  835. gen->write_get_named(value, name, prev_base);
  836. } else {
  837. gen->write_get(value, key, prev_base);
  838. }
  839. gen->write_binary_operator(value, assignment->variant_op, value, assigned);
  840. if (assigned.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  841. gen->pop_temporary();
  842. }
  843. assigned = value;
  844. }
  845. // Perform assignment.
  846. if (subscript->is_attribute) {
  847. gen->write_set_named(prev_base, name, assigned);
  848. } else {
  849. gen->write_set(prev_base, key, assigned);
  850. }
  851. if (key.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  852. gen->pop_temporary();
  853. }
  854. if (assigned.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  855. gen->pop_temporary();
  856. }
  857. assigned = prev_base;
  858. // Set back the values into their bases.
  859. for (const ChainInfo &info : set_chain) {
  860. if (!info.is_named) {
  861. gen->write_set(info.base, info.key, assigned);
  862. if (info.key.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  863. gen->pop_temporary();
  864. }
  865. } else {
  866. gen->write_set_named(info.base, info.name, assigned);
  867. }
  868. if (assigned.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  869. gen->pop_temporary();
  870. }
  871. assigned = info.base;
  872. }
  873. // If this is a local member, also assign to it.
  874. // This allow things like: position.x += 2.0
  875. if (assign_property != StringName()) {
  876. gen->write_set_member(assigned, assign_property);
  877. }
  878. if (assigned.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  879. gen->pop_temporary();
  880. }
  881. } else if (assignment->assignee->type == GDScriptParser::Node::IDENTIFIER && _is_class_member_property(codegen, static_cast<GDScriptParser::IdentifierNode *>(assignment->assignee)->name)) {
  882. // Assignment to member property.
  883. GDScriptCodeGenerator::Address assigned = _parse_expression(codegen, r_error, assignment->assigned_value);
  884. if (r_error) {
  885. return GDScriptCodeGenerator::Address();
  886. }
  887. GDScriptCodeGenerator::Address assign_temp = assigned;
  888. StringName name = static_cast<GDScriptParser::IdentifierNode *>(assignment->assignee)->name;
  889. if (assignment->operation != GDScriptParser::AssignmentNode::OP_NONE) {
  890. GDScriptCodeGenerator::Address member = codegen.add_temporary();
  891. gen->write_get_member(member, name);
  892. gen->write_binary_operator(assigned, assignment->variant_op, member, assigned);
  893. gen->pop_temporary();
  894. }
  895. gen->write_set_member(assigned, name);
  896. if (assign_temp.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  897. gen->pop_temporary();
  898. }
  899. } else {
  900. // Regular assignment.
  901. GDScriptCodeGenerator::Address target;
  902. bool has_setter = false;
  903. bool is_in_setter = false;
  904. StringName setter_function;
  905. if (assignment->assignee->type == GDScriptParser::Node::IDENTIFIER) {
  906. StringName var_name = static_cast<const GDScriptParser::IdentifierNode *>(assignment->assignee)->name;
  907. if (!codegen.locals.has(var_name) && codegen.script->member_indices.has(var_name)) {
  908. setter_function = codegen.script->member_indices[var_name].setter;
  909. if (setter_function != StringName()) {
  910. has_setter = true;
  911. is_in_setter = setter_function == codegen.function_name;
  912. target.mode = GDScriptCodeGenerator::Address::MEMBER;
  913. target.address = codegen.script->member_indices[var_name].index;
  914. }
  915. }
  916. }
  917. if (has_setter) {
  918. if (!is_in_setter) {
  919. // Store stack slot for the temp value.
  920. target = codegen.add_temporary(_gdtype_from_datatype(assignment->assignee->get_datatype()));
  921. }
  922. } else {
  923. target = _parse_expression(codegen, r_error, assignment->assignee);
  924. if (r_error) {
  925. return GDScriptCodeGenerator::Address();
  926. }
  927. }
  928. GDScriptCodeGenerator::Address assigned = _parse_expression(codegen, r_error, assignment->assigned_value);
  929. GDScriptCodeGenerator::Address op_result;
  930. if (r_error) {
  931. return GDScriptCodeGenerator::Address();
  932. }
  933. if (assignment->operation != GDScriptParser::AssignmentNode::OP_NONE) {
  934. // Perform operation.
  935. op_result = codegen.add_temporary();
  936. gen->write_binary_operator(op_result, assignment->variant_op, target, assigned);
  937. } else {
  938. op_result = assigned;
  939. assigned = GDScriptCodeGenerator::Address();
  940. }
  941. GDScriptDataType assign_type = _gdtype_from_datatype(assignment->assignee->get_datatype());
  942. if (has_setter && !is_in_setter) {
  943. // Call setter.
  944. Vector<GDScriptCodeGenerator::Address> args;
  945. args.push_back(op_result);
  946. gen->write_call(GDScriptCodeGenerator::Address(), GDScriptCodeGenerator::Address(GDScriptCodeGenerator::Address::SELF), setter_function, args);
  947. } else {
  948. // Just assign.
  949. if (assignment->use_conversion_assign) {
  950. gen->write_assign_with_conversion(target, op_result);
  951. } else {
  952. gen->write_assign(target, op_result);
  953. }
  954. }
  955. if (op_result.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  956. gen->pop_temporary();
  957. }
  958. if (assigned.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  959. gen->pop_temporary();
  960. }
  961. if (target.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  962. gen->pop_temporary();
  963. }
  964. }
  965. return GDScriptCodeGenerator::Address(); // Assignment does not return a value.
  966. } break;
  967. case GDScriptParser::Node::LAMBDA: {
  968. const GDScriptParser::LambdaNode *lambda = static_cast<const GDScriptParser::LambdaNode *>(p_expression);
  969. GDScriptCodeGenerator::Address result = codegen.add_temporary(_gdtype_from_datatype(lambda->get_datatype()));
  970. Vector<GDScriptCodeGenerator::Address> captures;
  971. captures.resize(lambda->captures.size());
  972. for (int i = 0; i < lambda->captures.size(); i++) {
  973. captures.write[i] = _parse_expression(codegen, r_error, lambda->captures[i]);
  974. if (r_error) {
  975. return GDScriptCodeGenerator::Address();
  976. }
  977. }
  978. GDScriptFunction *function = _parse_function(r_error, codegen.script, codegen.class_node, lambda->function, false, true);
  979. if (r_error) {
  980. return GDScriptCodeGenerator::Address();
  981. }
  982. gen->write_lambda(result, function, captures);
  983. for (int i = 0; i < captures.size(); i++) {
  984. if (captures[i].mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  985. gen->pop_temporary();
  986. }
  987. }
  988. return result;
  989. } break;
  990. default: {
  991. ERR_FAIL_V_MSG(GDScriptCodeGenerator::Address(), "Bug in bytecode compiler, unexpected node in parse tree while parsing expression."); // Unreachable code.
  992. } break;
  993. }
  994. }
  995. GDScriptCodeGenerator::Address GDScriptCompiler::_parse_match_pattern(CodeGen &codegen, Error &r_error, const GDScriptParser::PatternNode *p_pattern, const GDScriptCodeGenerator::Address &p_value_addr, const GDScriptCodeGenerator::Address &p_type_addr, const GDScriptCodeGenerator::Address &p_previous_test, bool p_is_first, bool p_is_nested) {
  996. switch (p_pattern->pattern_type) {
  997. case GDScriptParser::PatternNode::PT_LITERAL: {
  998. if (p_is_nested) {
  999. codegen.generator->write_and_left_operand(p_previous_test);
  1000. } else if (!p_is_first) {
  1001. codegen.generator->write_or_left_operand(p_previous_test);
  1002. }
  1003. // Get literal type into constant map.
  1004. GDScriptCodeGenerator::Address literal_type_addr = codegen.add_constant((int)p_pattern->literal->value.get_type());
  1005. // Equality is always a boolean.
  1006. GDScriptDataType equality_type;
  1007. equality_type.has_type = true;
  1008. equality_type.kind = GDScriptDataType::BUILTIN;
  1009. equality_type.builtin_type = Variant::BOOL;
  1010. // Check type equality.
  1011. GDScriptCodeGenerator::Address type_equality_addr = codegen.add_temporary(equality_type);
  1012. codegen.generator->write_binary_operator(type_equality_addr, Variant::OP_EQUAL, p_type_addr, literal_type_addr);
  1013. codegen.generator->write_and_left_operand(type_equality_addr);
  1014. // Get literal.
  1015. GDScriptCodeGenerator::Address literal_addr = _parse_expression(codegen, r_error, p_pattern->literal);
  1016. if (r_error) {
  1017. return GDScriptCodeGenerator::Address();
  1018. }
  1019. // Check value equality.
  1020. GDScriptCodeGenerator::Address equality_addr = codegen.add_temporary(equality_type);
  1021. codegen.generator->write_binary_operator(equality_addr, Variant::OP_EQUAL, p_value_addr, literal_addr);
  1022. codegen.generator->write_and_right_operand(equality_addr);
  1023. // AND both together (reuse temporary location).
  1024. codegen.generator->write_end_and(type_equality_addr);
  1025. codegen.generator->pop_temporary(); // Remove equality_addr from stack.
  1026. if (literal_addr.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  1027. codegen.generator->pop_temporary();
  1028. }
  1029. // If this isn't the first, we need to OR with the previous pattern. If it's nested, we use AND instead.
  1030. if (p_is_nested) {
  1031. // Use the previous value as target, since we only need one temporary variable.
  1032. codegen.generator->write_and_right_operand(type_equality_addr);
  1033. codegen.generator->write_end_and(p_previous_test);
  1034. } else if (!p_is_first) {
  1035. // Use the previous value as target, since we only need one temporary variable.
  1036. codegen.generator->write_or_right_operand(type_equality_addr);
  1037. codegen.generator->write_end_or(p_previous_test);
  1038. } else {
  1039. // Just assign this value to the accumulator temporary.
  1040. codegen.generator->write_assign(p_previous_test, type_equality_addr);
  1041. }
  1042. codegen.generator->pop_temporary(); // Remove type_equality_addr.
  1043. return p_previous_test;
  1044. } break;
  1045. case GDScriptParser::PatternNode::PT_EXPRESSION: {
  1046. if (p_is_nested) {
  1047. codegen.generator->write_and_left_operand(p_previous_test);
  1048. } else if (!p_is_first) {
  1049. codegen.generator->write_or_left_operand(p_previous_test);
  1050. }
  1051. // Create the result temps first since it's the last to go away.
  1052. GDScriptCodeGenerator::Address result_addr = codegen.add_temporary();
  1053. GDScriptCodeGenerator::Address equality_test_addr = codegen.add_temporary();
  1054. // Evaluate expression.
  1055. GDScriptCodeGenerator::Address expr_addr;
  1056. expr_addr = _parse_expression(codegen, r_error, p_pattern->expression);
  1057. if (r_error) {
  1058. return GDScriptCodeGenerator::Address();
  1059. }
  1060. // Evaluate expression type.
  1061. Vector<GDScriptCodeGenerator::Address> typeof_args;
  1062. typeof_args.push_back(expr_addr);
  1063. codegen.generator->write_call_utility(result_addr, "typeof", typeof_args);
  1064. // Check type equality.
  1065. codegen.generator->write_binary_operator(result_addr, Variant::OP_EQUAL, p_type_addr, result_addr);
  1066. codegen.generator->write_and_left_operand(result_addr);
  1067. // Check value equality.
  1068. codegen.generator->write_binary_operator(equality_test_addr, Variant::OP_EQUAL, p_value_addr, expr_addr);
  1069. codegen.generator->write_and_right_operand(equality_test_addr);
  1070. // AND both type and value equality.
  1071. codegen.generator->write_end_and(result_addr);
  1072. // We don't need the expression temporary anymore.
  1073. if (expr_addr.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  1074. codegen.generator->pop_temporary();
  1075. }
  1076. codegen.generator->pop_temporary(); // Remove type equality temporary.
  1077. // If this isn't the first, we need to OR with the previous pattern. If it's nested, we use AND instead.
  1078. if (p_is_nested) {
  1079. // Use the previous value as target, since we only need one temporary variable.
  1080. codegen.generator->write_and_right_operand(result_addr);
  1081. codegen.generator->write_end_and(p_previous_test);
  1082. } else if (!p_is_first) {
  1083. // Use the previous value as target, since we only need one temporary variable.
  1084. codegen.generator->write_or_right_operand(result_addr);
  1085. codegen.generator->write_end_or(p_previous_test);
  1086. } else {
  1087. // Just assign this value to the accumulator temporary.
  1088. codegen.generator->write_assign(p_previous_test, result_addr);
  1089. }
  1090. codegen.generator->pop_temporary(); // Remove temp result addr.
  1091. return p_previous_test;
  1092. } break;
  1093. case GDScriptParser::PatternNode::PT_ARRAY: {
  1094. if (p_is_nested) {
  1095. codegen.generator->write_and_left_operand(p_previous_test);
  1096. } else if (!p_is_first) {
  1097. codegen.generator->write_or_left_operand(p_previous_test);
  1098. }
  1099. // Get array type into constant map.
  1100. GDScriptCodeGenerator::Address array_type_addr = codegen.add_constant((int)Variant::ARRAY);
  1101. // Equality is always a boolean.
  1102. GDScriptDataType temp_type;
  1103. temp_type.has_type = true;
  1104. temp_type.kind = GDScriptDataType::BUILTIN;
  1105. temp_type.builtin_type = Variant::BOOL;
  1106. // Check type equality.
  1107. GDScriptCodeGenerator::Address result_addr = codegen.add_temporary(temp_type);
  1108. codegen.generator->write_binary_operator(result_addr, Variant::OP_EQUAL, p_type_addr, array_type_addr);
  1109. codegen.generator->write_and_left_operand(result_addr);
  1110. // Store pattern length in constant map.
  1111. GDScriptCodeGenerator::Address array_length_addr = codegen.add_constant(p_pattern->rest_used ? p_pattern->array.size() - 1 : p_pattern->array.size());
  1112. // Get value length.
  1113. temp_type.builtin_type = Variant::INT;
  1114. GDScriptCodeGenerator::Address value_length_addr = codegen.add_temporary(temp_type);
  1115. Vector<GDScriptCodeGenerator::Address> len_args;
  1116. len_args.push_back(p_value_addr);
  1117. codegen.generator->write_call_gdscript_utility(value_length_addr, GDScriptUtilityFunctions::get_function("len"), len_args);
  1118. // Test length compatibility.
  1119. temp_type.builtin_type = Variant::BOOL;
  1120. GDScriptCodeGenerator::Address length_compat_addr = codegen.add_temporary(temp_type);
  1121. codegen.generator->write_binary_operator(length_compat_addr, p_pattern->rest_used ? Variant::OP_GREATER_EQUAL : Variant::OP_EQUAL, value_length_addr, array_length_addr);
  1122. codegen.generator->write_and_right_operand(length_compat_addr);
  1123. // AND type and length check.
  1124. codegen.generator->write_end_and(result_addr);
  1125. // Remove length temporaries.
  1126. codegen.generator->pop_temporary();
  1127. codegen.generator->pop_temporary();
  1128. // If this isn't the first, we need to OR with the previous pattern. If it's nested, we use AND instead.
  1129. if (p_is_nested) {
  1130. // Use the previous value as target, since we only need one temporary variable.
  1131. codegen.generator->write_and_right_operand(result_addr);
  1132. codegen.generator->write_end_and(p_previous_test);
  1133. } else if (!p_is_first) {
  1134. // Use the previous value as target, since we only need one temporary variable.
  1135. codegen.generator->write_or_right_operand(result_addr);
  1136. codegen.generator->write_end_or(p_previous_test);
  1137. } else {
  1138. // Just assign this value to the accumulator temporary.
  1139. codegen.generator->write_assign(p_previous_test, result_addr);
  1140. }
  1141. codegen.generator->pop_temporary(); // Remove temp result addr.
  1142. // Create temporaries outside the loop so they can be reused.
  1143. GDScriptCodeGenerator::Address element_addr = codegen.add_temporary();
  1144. GDScriptCodeGenerator::Address element_type_addr = codegen.add_temporary();
  1145. GDScriptCodeGenerator::Address test_addr = p_previous_test;
  1146. // Evaluate element by element.
  1147. for (int i = 0; i < p_pattern->array.size(); i++) {
  1148. if (p_pattern->array[i]->pattern_type == GDScriptParser::PatternNode::PT_REST) {
  1149. // Don't want to access an extra element of the user array.
  1150. break;
  1151. }
  1152. // Use AND here too, as we don't want to be checking elements if previous test failed (which means this might be an invalid get).
  1153. codegen.generator->write_and_left_operand(test_addr);
  1154. // Add index to constant map.
  1155. GDScriptCodeGenerator::Address index_addr = codegen.add_constant(i);
  1156. // Get the actual element from the user-sent array.
  1157. codegen.generator->write_get(element_addr, index_addr, p_value_addr);
  1158. // Also get type of element.
  1159. Vector<GDScriptCodeGenerator::Address> typeof_args;
  1160. typeof_args.push_back(element_addr);
  1161. codegen.generator->write_call_utility(element_type_addr, "typeof", typeof_args);
  1162. // Try the pattern inside the element.
  1163. test_addr = _parse_match_pattern(codegen, r_error, p_pattern->array[i], element_addr, element_type_addr, p_previous_test, false, true);
  1164. if (r_error != OK) {
  1165. return GDScriptCodeGenerator::Address();
  1166. }
  1167. codegen.generator->write_and_right_operand(test_addr);
  1168. codegen.generator->write_end_and(test_addr);
  1169. }
  1170. // Remove element temporaries.
  1171. codegen.generator->pop_temporary();
  1172. codegen.generator->pop_temporary();
  1173. return test_addr;
  1174. } break;
  1175. case GDScriptParser::PatternNode::PT_DICTIONARY: {
  1176. if (p_is_nested) {
  1177. codegen.generator->write_and_left_operand(p_previous_test);
  1178. } else if (!p_is_first) {
  1179. codegen.generator->write_or_left_operand(p_previous_test);
  1180. }
  1181. // Get dictionary type into constant map.
  1182. GDScriptCodeGenerator::Address dict_type_addr = codegen.add_constant((int)Variant::DICTIONARY);
  1183. // Equality is always a boolean.
  1184. GDScriptDataType temp_type;
  1185. temp_type.has_type = true;
  1186. temp_type.kind = GDScriptDataType::BUILTIN;
  1187. temp_type.builtin_type = Variant::BOOL;
  1188. // Check type equality.
  1189. GDScriptCodeGenerator::Address result_addr = codegen.add_temporary(temp_type);
  1190. codegen.generator->write_binary_operator(result_addr, Variant::OP_EQUAL, p_type_addr, dict_type_addr);
  1191. codegen.generator->write_and_left_operand(result_addr);
  1192. // Store pattern length in constant map.
  1193. GDScriptCodeGenerator::Address dict_length_addr = codegen.add_constant(p_pattern->rest_used ? p_pattern->dictionary.size() - 1 : p_pattern->dictionary.size());
  1194. // Get user's dictionary length.
  1195. temp_type.builtin_type = Variant::INT;
  1196. GDScriptCodeGenerator::Address value_length_addr = codegen.add_temporary(temp_type);
  1197. Vector<GDScriptCodeGenerator::Address> func_args;
  1198. func_args.push_back(p_value_addr);
  1199. codegen.generator->write_call_gdscript_utility(value_length_addr, GDScriptUtilityFunctions::get_function("len"), func_args);
  1200. // Test length compatibility.
  1201. temp_type.builtin_type = Variant::BOOL;
  1202. GDScriptCodeGenerator::Address length_compat_addr = codegen.add_temporary(temp_type);
  1203. codegen.generator->write_binary_operator(length_compat_addr, p_pattern->rest_used ? Variant::OP_GREATER_EQUAL : Variant::OP_EQUAL, value_length_addr, dict_length_addr);
  1204. codegen.generator->write_and_right_operand(length_compat_addr);
  1205. // AND type and length check.
  1206. codegen.generator->write_end_and(result_addr);
  1207. // Remove length temporaries.
  1208. codegen.generator->pop_temporary();
  1209. codegen.generator->pop_temporary();
  1210. // If this isn't the first, we need to OR with the previous pattern. If it's nested, we use AND instead.
  1211. if (p_is_nested) {
  1212. // Use the previous value as target, since we only need one temporary variable.
  1213. codegen.generator->write_and_right_operand(result_addr);
  1214. codegen.generator->write_end_and(p_previous_test);
  1215. } else if (!p_is_first) {
  1216. // Use the previous value as target, since we only need one temporary variable.
  1217. codegen.generator->write_or_right_operand(result_addr);
  1218. codegen.generator->write_end_or(p_previous_test);
  1219. } else {
  1220. // Just assign this value to the accumulator temporary.
  1221. codegen.generator->write_assign(p_previous_test, result_addr);
  1222. }
  1223. codegen.generator->pop_temporary(); // Remove temp result addr.
  1224. // Create temporaries outside the loop so they can be reused.
  1225. temp_type.builtin_type = Variant::BOOL;
  1226. GDScriptCodeGenerator::Address test_result = codegen.add_temporary(temp_type);
  1227. GDScriptCodeGenerator::Address element_addr = codegen.add_temporary();
  1228. GDScriptCodeGenerator::Address element_type_addr = codegen.add_temporary();
  1229. GDScriptCodeGenerator::Address test_addr = p_previous_test;
  1230. // Evaluate element by element.
  1231. for (int i = 0; i < p_pattern->dictionary.size(); i++) {
  1232. const GDScriptParser::PatternNode::Pair &element = p_pattern->dictionary[i];
  1233. if (element.value_pattern && element.value_pattern->pattern_type == GDScriptParser::PatternNode::PT_REST) {
  1234. // Ignore rest pattern.
  1235. break;
  1236. }
  1237. // Use AND here too, as we don't want to be checking elements if previous test failed (which means this might be an invalid get).
  1238. codegen.generator->write_and_left_operand(test_addr);
  1239. // Get the pattern key.
  1240. GDScriptCodeGenerator::Address pattern_key_addr = _parse_expression(codegen, r_error, element.key);
  1241. if (r_error) {
  1242. return GDScriptCodeGenerator::Address();
  1243. }
  1244. // Check if pattern key exists in user's dictionary. This will be AND-ed with next result.
  1245. func_args.clear();
  1246. func_args.push_back(pattern_key_addr);
  1247. codegen.generator->write_call(test_result, p_value_addr, "has", func_args);
  1248. if (element.value_pattern != nullptr) {
  1249. // Use AND here too, as we don't want to be checking elements if previous test failed (which means this might be an invalid get).
  1250. codegen.generator->write_and_left_operand(test_result);
  1251. // Get actual value from user dictionary.
  1252. codegen.generator->write_get(element_addr, pattern_key_addr, p_value_addr);
  1253. // Also get type of value.
  1254. func_args.clear();
  1255. func_args.push_back(element_addr);
  1256. codegen.generator->write_call_utility(element_type_addr, "typeof", func_args);
  1257. // Try the pattern inside the value.
  1258. test_addr = _parse_match_pattern(codegen, r_error, element.value_pattern, element_addr, element_type_addr, test_addr, false, true);
  1259. if (r_error != OK) {
  1260. return GDScriptCodeGenerator::Address();
  1261. }
  1262. codegen.generator->write_and_right_operand(test_addr);
  1263. codegen.generator->write_end_and(test_addr);
  1264. }
  1265. codegen.generator->write_and_right_operand(test_addr);
  1266. codegen.generator->write_end_and(test_addr);
  1267. // Remove pattern key temporary.
  1268. if (pattern_key_addr.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  1269. codegen.generator->pop_temporary();
  1270. }
  1271. }
  1272. // Remove element temporaries.
  1273. codegen.generator->pop_temporary();
  1274. codegen.generator->pop_temporary();
  1275. codegen.generator->pop_temporary();
  1276. return test_addr;
  1277. } break;
  1278. case GDScriptParser::PatternNode::PT_REST:
  1279. // Do nothing.
  1280. return p_previous_test;
  1281. break;
  1282. case GDScriptParser::PatternNode::PT_BIND: {
  1283. if (p_is_nested) {
  1284. codegen.generator->write_and_left_operand(p_previous_test);
  1285. } else if (!p_is_first) {
  1286. codegen.generator->write_or_left_operand(p_previous_test);
  1287. }
  1288. // Get the bind address.
  1289. GDScriptCodeGenerator::Address bind = codegen.locals[p_pattern->bind->name];
  1290. // Assign value to bound variable.
  1291. codegen.generator->write_assign(bind, p_value_addr);
  1292. }
  1293. [[fallthrough]]; // Act like matching anything too.
  1294. case GDScriptParser::PatternNode::PT_WILDCARD:
  1295. // If this is a fall through we don't want to do this again.
  1296. if (p_pattern->pattern_type != GDScriptParser::PatternNode::PT_BIND) {
  1297. if (p_is_nested) {
  1298. codegen.generator->write_and_left_operand(p_previous_test);
  1299. } else if (!p_is_first) {
  1300. codegen.generator->write_or_left_operand(p_previous_test);
  1301. }
  1302. }
  1303. // This matches anything so just do the same as `if(true)`.
  1304. // If this isn't the first, we need to OR with the previous pattern. If it's nested, we use AND instead.
  1305. if (p_is_nested) {
  1306. // Use the operator with the `true` constant so it works as always matching.
  1307. GDScriptCodeGenerator::Address constant = codegen.add_constant(true);
  1308. codegen.generator->write_and_right_operand(constant);
  1309. codegen.generator->write_end_and(p_previous_test);
  1310. } else if (!p_is_first) {
  1311. // Use the operator with the `true` constant so it works as always matching.
  1312. GDScriptCodeGenerator::Address constant = codegen.add_constant(true);
  1313. codegen.generator->write_or_right_operand(constant);
  1314. codegen.generator->write_end_or(p_previous_test);
  1315. } else {
  1316. // Just assign this value to the accumulator temporary.
  1317. codegen.generator->write_assign_true(p_previous_test);
  1318. }
  1319. return p_previous_test;
  1320. }
  1321. ERR_FAIL_V_MSG(p_previous_test, "Reaching the end of pattern compilation without matching a pattern.");
  1322. }
  1323. void GDScriptCompiler::_add_locals_in_block(CodeGen &codegen, const GDScriptParser::SuiteNode *p_block) {
  1324. for (int i = 0; i < p_block->locals.size(); i++) {
  1325. if (p_block->locals[i].type == GDScriptParser::SuiteNode::Local::PARAMETER || p_block->locals[i].type == GDScriptParser::SuiteNode::Local::FOR_VARIABLE) {
  1326. // Parameters are added directly from function and loop variables are declared explicitly.
  1327. continue;
  1328. }
  1329. codegen.add_local(p_block->locals[i].name, _gdtype_from_datatype(p_block->locals[i].get_datatype()));
  1330. }
  1331. }
  1332. Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::SuiteNode *p_block, bool p_add_locals) {
  1333. Error error = OK;
  1334. GDScriptCodeGenerator *gen = codegen.generator;
  1335. codegen.start_block();
  1336. if (p_add_locals) {
  1337. _add_locals_in_block(codegen, p_block);
  1338. }
  1339. for (int i = 0; i < p_block->statements.size(); i++) {
  1340. const GDScriptParser::Node *s = p_block->statements[i];
  1341. #ifdef DEBUG_ENABLED
  1342. // Add a newline before each statement, since the debugger needs those.
  1343. gen->write_newline(s->start_line);
  1344. #endif
  1345. switch (s->type) {
  1346. case GDScriptParser::Node::MATCH: {
  1347. const GDScriptParser::MatchNode *match = static_cast<const GDScriptParser::MatchNode *>(s);
  1348. gen->start_match();
  1349. codegen.start_block();
  1350. // Evaluate the match expression.
  1351. GDScriptCodeGenerator::Address value = codegen.add_local("@match_value", _gdtype_from_datatype(match->test->get_datatype()));
  1352. GDScriptCodeGenerator::Address value_expr = _parse_expression(codegen, error, match->test);
  1353. if (error) {
  1354. return error;
  1355. }
  1356. // Assign to local.
  1357. // TODO: This can be improved by passing the target to parse_expression().
  1358. gen->write_assign(value, value_expr);
  1359. if (value_expr.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  1360. codegen.generator->pop_temporary();
  1361. }
  1362. // Then, let's save the type of the value in the stack too, so we can reuse for later comparisons.
  1363. GDScriptDataType typeof_type;
  1364. typeof_type.has_type = true;
  1365. typeof_type.kind = GDScriptDataType::BUILTIN;
  1366. typeof_type.builtin_type = Variant::INT;
  1367. GDScriptCodeGenerator::Address type = codegen.add_local("@match_type", typeof_type);
  1368. Vector<GDScriptCodeGenerator::Address> typeof_args;
  1369. typeof_args.push_back(value);
  1370. gen->write_call_utility(type, "typeof", typeof_args);
  1371. // Now we can actually start testing.
  1372. // For each branch.
  1373. for (int j = 0; j < match->branches.size(); j++) {
  1374. if (j > 0) {
  1375. // Use `else` to not check the next branch after matching.
  1376. gen->write_else();
  1377. }
  1378. const GDScriptParser::MatchBranchNode *branch = match->branches[j];
  1379. gen->start_match_branch(); // Need so lower level code can patch 'continue' jumps.
  1380. codegen.start_block(); // Create an extra block around for binds.
  1381. // Add locals in block before patterns, so temporaries don't use the stack address for binds.
  1382. _add_locals_in_block(codegen, branch->block);
  1383. #ifdef DEBUG_ENABLED
  1384. // Add a newline before each branch, since the debugger needs those.
  1385. gen->write_newline(branch->start_line);
  1386. #endif
  1387. // For each pattern in branch.
  1388. GDScriptCodeGenerator::Address pattern_result = codegen.add_temporary();
  1389. for (int k = 0; k < branch->patterns.size(); k++) {
  1390. pattern_result = _parse_match_pattern(codegen, error, branch->patterns[k], value, type, pattern_result, k == 0, false);
  1391. if (error != OK) {
  1392. return error;
  1393. }
  1394. }
  1395. // Check if pattern did match.
  1396. gen->write_if(pattern_result);
  1397. // Remove the result from stack.
  1398. gen->pop_temporary();
  1399. // Parse the branch block.
  1400. error = _parse_block(codegen, branch->block, false); // Don't add locals again.
  1401. if (error) {
  1402. return error;
  1403. }
  1404. codegen.end_block(); // Get out of extra block.
  1405. }
  1406. // End all nested `if`s.
  1407. for (int j = 0; j < match->branches.size(); j++) {
  1408. gen->write_endif();
  1409. }
  1410. gen->end_match();
  1411. } break;
  1412. case GDScriptParser::Node::IF: {
  1413. const GDScriptParser::IfNode *if_n = static_cast<const GDScriptParser::IfNode *>(s);
  1414. GDScriptCodeGenerator::Address condition = _parse_expression(codegen, error, if_n->condition);
  1415. if (error) {
  1416. return error;
  1417. }
  1418. gen->write_if(condition);
  1419. if (condition.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  1420. codegen.generator->pop_temporary();
  1421. }
  1422. error = _parse_block(codegen, if_n->true_block);
  1423. if (error) {
  1424. return error;
  1425. }
  1426. if (if_n->false_block) {
  1427. gen->write_else();
  1428. error = _parse_block(codegen, if_n->false_block);
  1429. if (error) {
  1430. return error;
  1431. }
  1432. }
  1433. gen->write_endif();
  1434. } break;
  1435. case GDScriptParser::Node::FOR: {
  1436. const GDScriptParser::ForNode *for_n = static_cast<const GDScriptParser::ForNode *>(s);
  1437. codegen.start_block();
  1438. GDScriptCodeGenerator::Address iterator = codegen.add_local(for_n->variable->name, _gdtype_from_datatype(for_n->variable->get_datatype()));
  1439. gen->start_for(iterator.type, _gdtype_from_datatype(for_n->list->get_datatype()));
  1440. GDScriptCodeGenerator::Address list = _parse_expression(codegen, error, for_n->list);
  1441. if (error) {
  1442. return error;
  1443. }
  1444. gen->write_for_assignment(iterator, list);
  1445. if (list.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  1446. codegen.generator->pop_temporary();
  1447. }
  1448. gen->write_for();
  1449. error = _parse_block(codegen, for_n->loop);
  1450. if (error) {
  1451. return error;
  1452. }
  1453. gen->write_endfor();
  1454. codegen.end_block();
  1455. } break;
  1456. case GDScriptParser::Node::WHILE: {
  1457. const GDScriptParser::WhileNode *while_n = static_cast<const GDScriptParser::WhileNode *>(s);
  1458. gen->start_while_condition();
  1459. GDScriptCodeGenerator::Address condition = _parse_expression(codegen, error, while_n->condition);
  1460. if (error) {
  1461. return error;
  1462. }
  1463. gen->write_while(condition);
  1464. if (condition.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  1465. codegen.generator->pop_temporary();
  1466. }
  1467. error = _parse_block(codegen, while_n->loop);
  1468. if (error) {
  1469. return error;
  1470. }
  1471. gen->write_endwhile();
  1472. } break;
  1473. case GDScriptParser::Node::BREAK: {
  1474. gen->write_break();
  1475. } break;
  1476. case GDScriptParser::Node::CONTINUE: {
  1477. const GDScriptParser::ContinueNode *cont = static_cast<const GDScriptParser::ContinueNode *>(s);
  1478. if (cont->is_for_match) {
  1479. gen->write_continue_match();
  1480. } else {
  1481. gen->write_continue();
  1482. }
  1483. } break;
  1484. case GDScriptParser::Node::RETURN: {
  1485. const GDScriptParser::ReturnNode *return_n = static_cast<const GDScriptParser::ReturnNode *>(s);
  1486. GDScriptCodeGenerator::Address return_value;
  1487. if (return_n->return_value != nullptr) {
  1488. return_value = _parse_expression(codegen, error, return_n->return_value);
  1489. if (error) {
  1490. return error;
  1491. }
  1492. }
  1493. gen->write_return(return_value);
  1494. if (return_value.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  1495. codegen.generator->pop_temporary();
  1496. }
  1497. } break;
  1498. case GDScriptParser::Node::ASSERT: {
  1499. #ifdef DEBUG_ENABLED
  1500. const GDScriptParser::AssertNode *as = static_cast<const GDScriptParser::AssertNode *>(s);
  1501. GDScriptCodeGenerator::Address condition = _parse_expression(codegen, error, as->condition);
  1502. if (error) {
  1503. return error;
  1504. }
  1505. GDScriptCodeGenerator::Address message;
  1506. if (as->message) {
  1507. message = _parse_expression(codegen, error, as->message);
  1508. if (error) {
  1509. return error;
  1510. }
  1511. }
  1512. gen->write_assert(condition, message);
  1513. if (condition.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  1514. codegen.generator->pop_temporary();
  1515. }
  1516. if (message.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  1517. codegen.generator->pop_temporary();
  1518. }
  1519. #endif
  1520. } break;
  1521. case GDScriptParser::Node::BREAKPOINT: {
  1522. #ifdef DEBUG_ENABLED
  1523. gen->write_breakpoint();
  1524. #endif
  1525. } break;
  1526. case GDScriptParser::Node::VARIABLE: {
  1527. const GDScriptParser::VariableNode *lv = static_cast<const GDScriptParser::VariableNode *>(s);
  1528. // Should be already in stack when the block began.
  1529. GDScriptCodeGenerator::Address local = codegen.locals[lv->identifier->name];
  1530. GDScriptParser::DataType local_type = lv->get_datatype();
  1531. if (lv->initializer != nullptr) {
  1532. // For typed arrays we need to make sure this is already initialized correctly so typed assignment work.
  1533. if (local_type.is_hard_type() && local_type.builtin_type == Variant::ARRAY) {
  1534. if (local_type.has_container_element_type()) {
  1535. codegen.generator->write_construct_typed_array(local, _gdtype_from_datatype(local_type.get_container_element_type(), codegen.script), Vector<GDScriptCodeGenerator::Address>());
  1536. } else {
  1537. codegen.generator->write_construct_array(local, Vector<GDScriptCodeGenerator::Address>());
  1538. }
  1539. }
  1540. GDScriptCodeGenerator::Address src_address = _parse_expression(codegen, error, lv->initializer);
  1541. if (error) {
  1542. return error;
  1543. }
  1544. if (lv->use_conversion_assign) {
  1545. gen->write_assign_with_conversion(local, src_address);
  1546. } else {
  1547. gen->write_assign(local, src_address);
  1548. }
  1549. if (src_address.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  1550. codegen.generator->pop_temporary();
  1551. }
  1552. } else if (lv->get_datatype().is_hard_type()) {
  1553. // Initialize with default for type.
  1554. if (local_type.has_container_element_type()) {
  1555. codegen.generator->write_construct_typed_array(local, _gdtype_from_datatype(local_type.get_container_element_type(), codegen.script), Vector<GDScriptCodeGenerator::Address>());
  1556. } else if (local_type.kind == GDScriptParser::DataType::BUILTIN) {
  1557. codegen.generator->write_construct(local, local_type.builtin_type, Vector<GDScriptCodeGenerator::Address>());
  1558. }
  1559. // The `else` branch is for objects, in such case we leave it as `null`.
  1560. }
  1561. } break;
  1562. case GDScriptParser::Node::CONSTANT: {
  1563. // Local constants.
  1564. const GDScriptParser::ConstantNode *lc = static_cast<const GDScriptParser::ConstantNode *>(s);
  1565. if (!lc->initializer->is_constant) {
  1566. _set_error("Local constant must have a constant value as initializer.", lc->initializer);
  1567. return ERR_PARSE_ERROR;
  1568. }
  1569. codegen.add_local_constant(lc->identifier->name, lc->initializer->reduced_value);
  1570. } break;
  1571. case GDScriptParser::Node::PASS:
  1572. // Nothing to do.
  1573. break;
  1574. default: {
  1575. // Expression.
  1576. if (s->is_expression()) {
  1577. GDScriptCodeGenerator::Address expr = _parse_expression(codegen, error, static_cast<const GDScriptParser::ExpressionNode *>(s), true);
  1578. if (error) {
  1579. return error;
  1580. }
  1581. if (expr.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  1582. codegen.generator->pop_temporary();
  1583. }
  1584. } else {
  1585. ERR_FAIL_V_MSG(ERR_INVALID_DATA, "Bug in bytecode compiler, unexpected node in parse tree while parsing statement."); // Unreachable code.
  1586. }
  1587. } break;
  1588. }
  1589. }
  1590. codegen.end_block();
  1591. return OK;
  1592. }
  1593. GDScriptFunction *GDScriptCompiler::_parse_function(Error &r_error, GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::FunctionNode *p_func, bool p_for_ready, bool p_for_lambda) {
  1594. r_error = OK;
  1595. CodeGen codegen;
  1596. codegen.generator = memnew(GDScriptByteCodeGenerator);
  1597. codegen.class_node = p_class;
  1598. codegen.script = p_script;
  1599. codegen.function_node = p_func;
  1600. StringName func_name;
  1601. bool is_static = false;
  1602. MultiplayerAPI::RPCConfig rpc_config;
  1603. GDScriptDataType return_type;
  1604. return_type.has_type = true;
  1605. return_type.kind = GDScriptDataType::BUILTIN;
  1606. return_type.builtin_type = Variant::NIL;
  1607. if (p_func) {
  1608. if (p_func->identifier) {
  1609. func_name = p_func->identifier->name;
  1610. } else {
  1611. func_name = "<anonymous lambda>";
  1612. }
  1613. is_static = p_func->is_static;
  1614. rpc_config = p_func->rpc_config;
  1615. return_type = _gdtype_from_datatype(p_func->get_datatype(), p_script);
  1616. } else {
  1617. if (p_for_ready) {
  1618. func_name = "_ready";
  1619. } else {
  1620. func_name = "@implicit_new";
  1621. }
  1622. }
  1623. codegen.function_name = func_name;
  1624. codegen.generator->write_start(p_script, func_name, is_static, rpc_config, return_type);
  1625. int optional_parameters = 0;
  1626. if (p_func) {
  1627. for (int i = 0; i < p_func->parameters.size(); i++) {
  1628. const GDScriptParser::ParameterNode *parameter = p_func->parameters[i];
  1629. GDScriptDataType par_type = _gdtype_from_datatype(parameter->get_datatype(), p_script);
  1630. uint32_t par_addr = codegen.generator->add_parameter(parameter->identifier->name, parameter->default_value != nullptr, par_type);
  1631. codegen.parameters[parameter->identifier->name] = GDScriptCodeGenerator::Address(GDScriptCodeGenerator::Address::FUNCTION_PARAMETER, par_addr, par_type);
  1632. if (p_func->parameters[i]->default_value != nullptr) {
  1633. optional_parameters++;
  1634. }
  1635. }
  1636. }
  1637. // Parse initializer if applies.
  1638. bool is_implicit_initializer = !p_for_ready && !p_func && !p_for_lambda;
  1639. bool is_initializer = p_func && !p_for_lambda && String(p_func->identifier->name) == GDScriptLanguage::get_singleton()->strings._init;
  1640. bool is_for_ready = p_for_ready || (p_func && !p_for_lambda && String(p_func->identifier->name) == "_ready");
  1641. if (!p_for_lambda && (is_implicit_initializer || is_for_ready)) {
  1642. // Initialize class fields.
  1643. for (int i = 0; i < p_class->members.size(); i++) {
  1644. if (p_class->members[i].type != GDScriptParser::ClassNode::Member::VARIABLE) {
  1645. continue;
  1646. }
  1647. const GDScriptParser::VariableNode *field = p_class->members[i].variable;
  1648. if (field->onready != is_for_ready) {
  1649. // Only initialize in _ready.
  1650. continue;
  1651. }
  1652. GDScriptParser::DataType field_type = field->get_datatype();
  1653. GDScriptCodeGenerator::Address dst_address(GDScriptCodeGenerator::Address::MEMBER, codegen.script->member_indices[field->identifier->name].index, _gdtype_from_datatype(field->get_datatype()));
  1654. if (field->initializer) {
  1655. // Emit proper line change.
  1656. codegen.generator->write_newline(field->initializer->start_line);
  1657. // For typed arrays we need to make sure this is already initialized correctly so typed assignment work.
  1658. if (field_type.is_hard_type() && field_type.builtin_type == Variant::ARRAY && field_type.has_container_element_type()) {
  1659. if (field_type.has_container_element_type()) {
  1660. codegen.generator->write_construct_typed_array(dst_address, _gdtype_from_datatype(field_type.get_container_element_type(), codegen.script), Vector<GDScriptCodeGenerator::Address>());
  1661. } else {
  1662. codegen.generator->write_construct_array(dst_address, Vector<GDScriptCodeGenerator::Address>());
  1663. }
  1664. }
  1665. GDScriptCodeGenerator::Address src_address = _parse_expression(codegen, r_error, field->initializer, false, true);
  1666. if (r_error) {
  1667. memdelete(codegen.generator);
  1668. return nullptr;
  1669. }
  1670. if (field->use_conversion_assign) {
  1671. codegen.generator->write_assign_with_conversion(dst_address, src_address);
  1672. } else {
  1673. codegen.generator->write_assign(dst_address, src_address);
  1674. }
  1675. if (src_address.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  1676. codegen.generator->pop_temporary();
  1677. }
  1678. } else if (field->get_datatype().is_hard_type()) {
  1679. codegen.generator->write_newline(field->start_line);
  1680. // Initialize with default for type.
  1681. if (field_type.has_container_element_type()) {
  1682. codegen.generator->write_construct_typed_array(dst_address, _gdtype_from_datatype(field_type.get_container_element_type(), codegen.script), Vector<GDScriptCodeGenerator::Address>());
  1683. } else if (field_type.kind == GDScriptParser::DataType::BUILTIN) {
  1684. codegen.generator->write_construct(dst_address, field_type.builtin_type, Vector<GDScriptCodeGenerator::Address>());
  1685. }
  1686. // The `else` branch is for objects, in such case we leave it as `null`.
  1687. }
  1688. }
  1689. }
  1690. // Parse default argument code if applies.
  1691. if (p_func) {
  1692. if (optional_parameters > 0) {
  1693. codegen.generator->start_parameters();
  1694. for (int i = p_func->parameters.size() - optional_parameters; i < p_func->parameters.size(); i++) {
  1695. const GDScriptParser::ParameterNode *parameter = p_func->parameters[i];
  1696. GDScriptCodeGenerator::Address src_addr = _parse_expression(codegen, r_error, parameter->default_value, true);
  1697. if (r_error) {
  1698. memdelete(codegen.generator);
  1699. return nullptr;
  1700. }
  1701. GDScriptCodeGenerator::Address dst_addr = codegen.parameters[parameter->identifier->name];
  1702. codegen.generator->write_assign_default_parameter(dst_addr, src_addr);
  1703. if (src_addr.mode == GDScriptCodeGenerator::Address::TEMPORARY) {
  1704. codegen.generator->pop_temporary();
  1705. }
  1706. }
  1707. codegen.generator->end_parameters();
  1708. }
  1709. r_error = _parse_block(codegen, p_func->body);
  1710. if (r_error) {
  1711. memdelete(codegen.generator);
  1712. return nullptr;
  1713. }
  1714. }
  1715. #ifdef DEBUG_ENABLED
  1716. if (EngineDebugger::is_active()) {
  1717. String signature;
  1718. // Path.
  1719. if (p_script->get_path() != String()) {
  1720. signature += p_script->get_path();
  1721. }
  1722. // Location.
  1723. if (p_func) {
  1724. signature += "::" + itos(p_func->body->start_line);
  1725. } else {
  1726. signature += "::0";
  1727. }
  1728. // Function and class.
  1729. if (p_class->identifier) {
  1730. signature += "::" + String(p_class->identifier->name) + "." + String(func_name);
  1731. } else {
  1732. signature += "::" + String(func_name);
  1733. }
  1734. if (p_for_lambda) {
  1735. signature += "(lambda)";
  1736. }
  1737. codegen.generator->set_signature(signature);
  1738. }
  1739. #endif
  1740. if (p_func) {
  1741. codegen.generator->set_initial_line(p_func->start_line);
  1742. #ifdef TOOLS_ENABLED
  1743. if (!p_for_lambda) {
  1744. p_script->member_lines[func_name] = p_func->start_line;
  1745. p_script->doc_functions[func_name] = p_func->doc_description;
  1746. }
  1747. #endif
  1748. } else {
  1749. codegen.generator->set_initial_line(0);
  1750. }
  1751. GDScriptFunction *gd_function = codegen.generator->write_end();
  1752. if (is_initializer) {
  1753. p_script->initializer = gd_function;
  1754. } else if (is_implicit_initializer) {
  1755. p_script->implicit_initializer = gd_function;
  1756. }
  1757. if (p_func) {
  1758. // if no return statement -> return type is void not unresolved Variant
  1759. if (p_func->body->has_return) {
  1760. gd_function->return_type = _gdtype_from_datatype(p_func->get_datatype());
  1761. } else {
  1762. gd_function->return_type = GDScriptDataType();
  1763. gd_function->return_type.has_type = true;
  1764. gd_function->return_type.kind = GDScriptDataType::BUILTIN;
  1765. gd_function->return_type.builtin_type = Variant::NIL;
  1766. }
  1767. #ifdef TOOLS_ENABLED
  1768. gd_function->default_arg_values = p_func->default_arg_values;
  1769. #endif
  1770. }
  1771. if (!p_for_lambda) {
  1772. p_script->member_functions[func_name] = gd_function;
  1773. }
  1774. memdelete(codegen.generator);
  1775. return gd_function;
  1776. }
  1777. Error GDScriptCompiler::_parse_setter_getter(GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::VariableNode *p_variable, bool p_is_setter) {
  1778. Error error = OK;
  1779. CodeGen codegen;
  1780. codegen.generator = memnew(GDScriptByteCodeGenerator);
  1781. codegen.class_node = p_class;
  1782. codegen.script = p_script;
  1783. StringName func_name;
  1784. if (p_is_setter) {
  1785. func_name = "@" + p_variable->identifier->name + "_setter";
  1786. } else {
  1787. func_name = "@" + p_variable->identifier->name + "_getter";
  1788. }
  1789. codegen.function_name = func_name;
  1790. GDScriptDataType return_type;
  1791. if (p_is_setter) {
  1792. return_type.has_type = true;
  1793. return_type.kind = GDScriptDataType::BUILTIN;
  1794. return_type.builtin_type = Variant::NIL;
  1795. } else {
  1796. return_type = _gdtype_from_datatype(p_variable->get_datatype(), p_script);
  1797. }
  1798. codegen.generator->write_start(p_script, func_name, false, MultiplayerAPI::RPCConfig(), return_type);
  1799. if (p_is_setter) {
  1800. uint32_t par_addr = codegen.generator->add_parameter(p_variable->setter_parameter->name, false, _gdtype_from_datatype(p_variable->get_datatype()));
  1801. codegen.parameters[p_variable->setter_parameter->name] = GDScriptCodeGenerator::Address(GDScriptCodeGenerator::Address::FUNCTION_PARAMETER, par_addr, _gdtype_from_datatype(p_variable->get_datatype()));
  1802. }
  1803. error = _parse_block(codegen, p_is_setter ? p_variable->setter : p_variable->getter);
  1804. if (error) {
  1805. memdelete(codegen.generator);
  1806. return error;
  1807. }
  1808. GDScriptFunction *gd_function = codegen.generator->write_end();
  1809. p_script->member_functions[func_name] = gd_function;
  1810. #ifdef DEBUG_ENABLED
  1811. if (EngineDebugger::is_active()) {
  1812. String signature;
  1813. //path
  1814. if (p_script->get_path() != String()) {
  1815. signature += p_script->get_path();
  1816. }
  1817. //loc
  1818. signature += "::" + itos(p_is_setter ? p_variable->setter->start_line : p_variable->getter->start_line);
  1819. //function and class
  1820. if (p_class->identifier) {
  1821. signature += "::" + String(p_class->identifier->name) + "." + String(func_name);
  1822. } else {
  1823. signature += "::" + String(func_name);
  1824. }
  1825. codegen.generator->set_signature(signature);
  1826. }
  1827. #endif
  1828. codegen.generator->set_initial_line(p_is_setter ? p_variable->setter->start_line : p_variable->getter->start_line);
  1829. #ifdef TOOLS_ENABLED
  1830. p_script->member_lines[func_name] = p_is_setter ? p_variable->setter->start_line : p_variable->getter->start_line;
  1831. #endif
  1832. memdelete(codegen.generator);
  1833. return OK;
  1834. }
  1835. Error GDScriptCompiler::_parse_class_level(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) {
  1836. parsing_classes.insert(p_script);
  1837. if (p_class->outer && p_class->outer->outer) {
  1838. // Owner is not root
  1839. if (!parsed_classes.has(p_script->_owner)) {
  1840. if (parsing_classes.has(p_script->_owner)) {
  1841. _set_error("Cyclic class reference for '" + String(p_class->identifier->name) + "'.", p_class);
  1842. return ERR_PARSE_ERROR;
  1843. }
  1844. Error err = _parse_class_level(p_script->_owner, p_class->outer, p_keep_state);
  1845. if (err) {
  1846. return err;
  1847. }
  1848. }
  1849. }
  1850. #ifdef TOOLS_ENABLED
  1851. p_script->doc_functions.clear();
  1852. p_script->doc_variables.clear();
  1853. p_script->doc_constants.clear();
  1854. p_script->doc_enums.clear();
  1855. p_script->doc_signals.clear();
  1856. p_script->doc_tutorials.clear();
  1857. p_script->doc_brief_description = p_class->doc_brief_description;
  1858. p_script->doc_description = p_class->doc_description;
  1859. for (int i = 0; i < p_class->doc_tutorials.size(); i++) {
  1860. DocData::TutorialDoc td;
  1861. td.title = p_class->doc_tutorials[i].first;
  1862. td.link = p_class->doc_tutorials[i].second;
  1863. p_script->doc_tutorials.append(td);
  1864. }
  1865. #endif
  1866. p_script->native = Ref<GDScriptNativeClass>();
  1867. p_script->base = Ref<GDScript>();
  1868. p_script->_base = nullptr;
  1869. p_script->members.clear();
  1870. p_script->constants.clear();
  1871. for (Map<StringName, GDScriptFunction *>::Element *E = p_script->member_functions.front(); E; E = E->next()) {
  1872. memdelete(E->get());
  1873. }
  1874. p_script->member_functions.clear();
  1875. p_script->member_indices.clear();
  1876. p_script->member_info.clear();
  1877. p_script->_signals.clear();
  1878. p_script->initializer = nullptr;
  1879. p_script->tool = parser->is_tool();
  1880. p_script->name = p_class->identifier ? p_class->identifier->name : "";
  1881. Ref<GDScriptNativeClass> native;
  1882. GDScriptDataType base_type = _gdtype_from_datatype(p_class->base_type);
  1883. // Inheritance
  1884. switch (base_type.kind) {
  1885. case GDScriptDataType::NATIVE: {
  1886. int native_idx = GDScriptLanguage::get_singleton()->get_global_map()[base_type.native_type];
  1887. native = GDScriptLanguage::get_singleton()->get_global_array()[native_idx];
  1888. ERR_FAIL_COND_V(native.is_null(), ERR_BUG);
  1889. p_script->native = native;
  1890. } break;
  1891. case GDScriptDataType::GDSCRIPT: {
  1892. Ref<GDScript> base = Ref<GDScript>(base_type.script_type);
  1893. p_script->base = base;
  1894. p_script->_base = base.ptr();
  1895. if (p_class->base_type.kind == GDScriptParser::DataType::CLASS && p_class->base_type.class_type != nullptr) {
  1896. if (p_class->base_type.script_path == main_script->path) {
  1897. if (!parsed_classes.has(p_script->_base)) {
  1898. if (parsing_classes.has(p_script->_base)) {
  1899. String class_name = p_class->identifier ? p_class->identifier->name : "<main>";
  1900. _set_error("Cyclic class reference for '" + class_name + "'.", p_class);
  1901. return ERR_PARSE_ERROR;
  1902. }
  1903. Error err = _parse_class_level(p_script->_base, p_class->base_type.class_type, p_keep_state);
  1904. if (err) {
  1905. return err;
  1906. }
  1907. }
  1908. } else {
  1909. Error err = OK;
  1910. base = GDScriptCache::get_full_script(p_class->base_type.script_path, err, main_script->path);
  1911. if (err) {
  1912. return err;
  1913. }
  1914. if (base.is_null() || !base->is_valid()) {
  1915. return ERR_COMPILATION_FAILED;
  1916. }
  1917. }
  1918. }
  1919. p_script->member_indices = base->member_indices;
  1920. native = base->native;
  1921. p_script->native = native;
  1922. } break;
  1923. default: {
  1924. _set_error("Parser bug: invalid inheritance.", p_class);
  1925. return ERR_BUG;
  1926. } break;
  1927. }
  1928. for (int i = 0; i < p_class->members.size(); i++) {
  1929. const GDScriptParser::ClassNode::Member &member = p_class->members[i];
  1930. switch (member.type) {
  1931. case GDScriptParser::ClassNode::Member::VARIABLE: {
  1932. const GDScriptParser::VariableNode *variable = member.variable;
  1933. StringName name = variable->identifier->name;
  1934. GDScript::MemberInfo minfo;
  1935. minfo.index = p_script->member_indices.size();
  1936. switch (variable->property) {
  1937. case GDScriptParser::VariableNode::PROP_NONE:
  1938. break; // Nothing to do.
  1939. case GDScriptParser::VariableNode::PROP_SETGET:
  1940. if (variable->setter_pointer != nullptr) {
  1941. minfo.setter = variable->setter_pointer->name;
  1942. }
  1943. if (variable->getter_pointer != nullptr) {
  1944. minfo.getter = variable->getter_pointer->name;
  1945. }
  1946. break;
  1947. case GDScriptParser::VariableNode::PROP_INLINE:
  1948. if (variable->setter != nullptr) {
  1949. minfo.setter = "@" + variable->identifier->name + "_setter";
  1950. }
  1951. if (variable->getter != nullptr) {
  1952. minfo.getter = "@" + variable->identifier->name + "_getter";
  1953. }
  1954. break;
  1955. }
  1956. minfo.data_type = _gdtype_from_datatype(variable->get_datatype(), p_script);
  1957. PropertyInfo prop_info = minfo.data_type;
  1958. prop_info.name = name;
  1959. PropertyInfo export_info = variable->export_info;
  1960. if (variable->exported) {
  1961. if (!minfo.data_type.has_type) {
  1962. prop_info.type = export_info.type;
  1963. prop_info.class_name = export_info.class_name;
  1964. }
  1965. prop_info.hint = export_info.hint;
  1966. prop_info.hint_string = export_info.hint_string;
  1967. prop_info.usage = export_info.usage | PROPERTY_USAGE_SCRIPT_VARIABLE;
  1968. } else {
  1969. prop_info.usage = PROPERTY_USAGE_SCRIPT_VARIABLE;
  1970. }
  1971. #ifdef TOOLS_ENABLED
  1972. p_script->doc_variables[name] = variable->doc_description;
  1973. #endif
  1974. p_script->member_info[name] = prop_info;
  1975. p_script->member_indices[name] = minfo;
  1976. p_script->members.insert(name);
  1977. #ifdef TOOLS_ENABLED
  1978. if (variable->initializer != nullptr && variable->initializer->is_constant) {
  1979. p_script->member_default_values[name] = variable->initializer->reduced_value;
  1980. } else {
  1981. p_script->member_default_values.erase(name);
  1982. }
  1983. p_script->member_lines[name] = variable->start_line;
  1984. #endif
  1985. } break;
  1986. case GDScriptParser::ClassNode::Member::CONSTANT: {
  1987. const GDScriptParser::ConstantNode *constant = member.constant;
  1988. StringName name = constant->identifier->name;
  1989. p_script->constants.insert(name, constant->initializer->reduced_value);
  1990. #ifdef TOOLS_ENABLED
  1991. p_script->member_lines[name] = constant->start_line;
  1992. if (constant->doc_description != String()) {
  1993. p_script->doc_constants[name] = constant->doc_description;
  1994. }
  1995. #endif
  1996. } break;
  1997. case GDScriptParser::ClassNode::Member::ENUM_VALUE: {
  1998. const GDScriptParser::EnumNode::Value &enum_value = member.enum_value;
  1999. StringName name = enum_value.identifier->name;
  2000. p_script->constants.insert(name, enum_value.value);
  2001. #ifdef TOOLS_ENABLED
  2002. p_script->member_lines[name] = enum_value.identifier->start_line;
  2003. if (!p_script->doc_enums.has("@unnamed_enums")) {
  2004. p_script->doc_enums["@unnamed_enums"] = DocData::EnumDoc();
  2005. p_script->doc_enums["@unnamed_enums"].name = "@unnamed_enums";
  2006. }
  2007. DocData::ConstantDoc const_doc;
  2008. const_doc.name = enum_value.identifier->name;
  2009. const_doc.value = Variant(enum_value.value).operator String(); // TODO-DOC: enum value currently is int.
  2010. const_doc.description = enum_value.doc_description;
  2011. p_script->doc_enums["@unnamed_enums"].values.push_back(const_doc);
  2012. #endif
  2013. } break;
  2014. case GDScriptParser::ClassNode::Member::SIGNAL: {
  2015. const GDScriptParser::SignalNode *signal = member.signal;
  2016. StringName name = signal->identifier->name;
  2017. GDScript *c = p_script;
  2018. while (c) {
  2019. if (c->_signals.has(name)) {
  2020. _set_error("Signal '" + name + "' redefined (in current or parent class)", p_class);
  2021. return ERR_ALREADY_EXISTS;
  2022. }
  2023. if (c->base.is_valid()) {
  2024. c = c->base.ptr();
  2025. } else {
  2026. c = nullptr;
  2027. }
  2028. }
  2029. if (native.is_valid()) {
  2030. if (ClassDB::has_signal(native->get_name(), name)) {
  2031. _set_error("Signal '" + name + "' redefined (original in native class '" + String(native->get_name()) + "')", p_class);
  2032. return ERR_ALREADY_EXISTS;
  2033. }
  2034. }
  2035. Vector<StringName> parameters_names;
  2036. parameters_names.resize(signal->parameters.size());
  2037. for (int j = 0; j < signal->parameters.size(); j++) {
  2038. parameters_names.write[j] = signal->parameters[j]->identifier->name;
  2039. }
  2040. p_script->_signals[name] = parameters_names;
  2041. #ifdef TOOLS_ENABLED
  2042. if (!signal->doc_description.is_empty()) {
  2043. p_script->doc_signals[name] = signal->doc_description;
  2044. }
  2045. #endif
  2046. } break;
  2047. case GDScriptParser::ClassNode::Member::ENUM: {
  2048. const GDScriptParser::EnumNode *enum_n = member.m_enum;
  2049. // TODO: Make enums not be just a dictionary?
  2050. Dictionary new_enum;
  2051. for (int j = 0; j < enum_n->values.size(); j++) {
  2052. int value = enum_n->values[j].value;
  2053. // Needs to be string because Variant::get will convert to String.
  2054. new_enum[String(enum_n->values[j].identifier->name)] = value;
  2055. }
  2056. p_script->constants.insert(enum_n->identifier->name, new_enum);
  2057. #ifdef TOOLS_ENABLED
  2058. p_script->member_lines[enum_n->identifier->name] = enum_n->start_line;
  2059. p_script->doc_enums[enum_n->identifier->name] = DocData::EnumDoc();
  2060. p_script->doc_enums[enum_n->identifier->name].name = enum_n->identifier->name;
  2061. p_script->doc_enums[enum_n->identifier->name].description = enum_n->doc_description;
  2062. for (int j = 0; j < enum_n->values.size(); j++) {
  2063. DocData::ConstantDoc const_doc;
  2064. const_doc.name = enum_n->values[j].identifier->name;
  2065. const_doc.value = Variant(enum_n->values[j].value).operator String();
  2066. const_doc.description = enum_n->values[j].doc_description;
  2067. p_script->doc_enums[enum_n->identifier->name].values.push_back(const_doc);
  2068. }
  2069. #endif
  2070. } break;
  2071. default:
  2072. break; // Nothing to do here.
  2073. }
  2074. }
  2075. parsed_classes.insert(p_script);
  2076. parsing_classes.erase(p_script);
  2077. //parse sub-classes
  2078. for (int i = 0; i < p_class->members.size(); i++) {
  2079. const GDScriptParser::ClassNode::Member &member = p_class->members[i];
  2080. if (member.type != member.CLASS) {
  2081. continue;
  2082. }
  2083. const GDScriptParser::ClassNode *inner_class = member.m_class;
  2084. StringName name = inner_class->identifier->name;
  2085. Ref<GDScript> &subclass = p_script->subclasses[name];
  2086. GDScript *subclass_ptr = subclass.ptr();
  2087. // Subclass might still be parsing, just skip it
  2088. if (!parsed_classes.has(subclass_ptr) && !parsing_classes.has(subclass_ptr)) {
  2089. Error err = _parse_class_level(subclass_ptr, inner_class, p_keep_state);
  2090. if (err) {
  2091. return err;
  2092. }
  2093. }
  2094. #ifdef TOOLS_ENABLED
  2095. p_script->member_lines[name] = inner_class->start_line;
  2096. #endif
  2097. p_script->constants.insert(name, subclass); //once parsed, goes to the list of constants
  2098. }
  2099. return OK;
  2100. }
  2101. Error GDScriptCompiler::_parse_class_blocks(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) {
  2102. //parse methods
  2103. bool has_ready = false;
  2104. for (int i = 0; i < p_class->members.size(); i++) {
  2105. const GDScriptParser::ClassNode::Member &member = p_class->members[i];
  2106. if (member.type == member.FUNCTION) {
  2107. const GDScriptParser::FunctionNode *function = member.function;
  2108. if (!has_ready && function->identifier->name == "_ready") {
  2109. has_ready = true;
  2110. }
  2111. Error err = OK;
  2112. _parse_function(err, p_script, p_class, function);
  2113. if (err) {
  2114. return err;
  2115. }
  2116. } else if (member.type == member.VARIABLE) {
  2117. const GDScriptParser::VariableNode *variable = member.variable;
  2118. if (variable->property == GDScriptParser::VariableNode::PROP_INLINE) {
  2119. if (variable->setter != nullptr) {
  2120. Error err = _parse_setter_getter(p_script, p_class, variable, true);
  2121. if (err) {
  2122. return err;
  2123. }
  2124. }
  2125. if (variable->getter != nullptr) {
  2126. Error err = _parse_setter_getter(p_script, p_class, variable, false);
  2127. if (err) {
  2128. return err;
  2129. }
  2130. }
  2131. }
  2132. }
  2133. }
  2134. {
  2135. // Create an implicit constructor in any case.
  2136. Error err = OK;
  2137. _parse_function(err, p_script, p_class, nullptr);
  2138. if (err) {
  2139. return err;
  2140. }
  2141. }
  2142. if (!has_ready && p_class->onready_used) {
  2143. //create a _ready constructor
  2144. Error err = OK;
  2145. _parse_function(err, p_script, p_class, nullptr, true);
  2146. if (err) {
  2147. return err;
  2148. }
  2149. }
  2150. #ifdef DEBUG_ENABLED
  2151. //validate instances if keeping state
  2152. if (p_keep_state) {
  2153. for (Set<Object *>::Element *E = p_script->instances.front(); E;) {
  2154. Set<Object *>::Element *N = E->next();
  2155. ScriptInstance *si = E->get()->get_script_instance();
  2156. if (si->is_placeholder()) {
  2157. #ifdef TOOLS_ENABLED
  2158. PlaceHolderScriptInstance *psi = static_cast<PlaceHolderScriptInstance *>(si);
  2159. if (p_script->is_tool()) {
  2160. //re-create as an instance
  2161. p_script->placeholders.erase(psi); //remove placeholder
  2162. GDScriptInstance *instance = memnew(GDScriptInstance);
  2163. instance->base_ref_counted = Object::cast_to<RefCounted>(E->get());
  2164. instance->members.resize(p_script->member_indices.size());
  2165. instance->script = Ref<GDScript>(p_script);
  2166. instance->owner = E->get();
  2167. //needed for hot reloading
  2168. for (Map<StringName, GDScript::MemberInfo>::Element *F = p_script->member_indices.front(); F; F = F->next()) {
  2169. instance->member_indices_cache[F->key()] = F->get().index;
  2170. }
  2171. instance->owner->set_script_instance(instance);
  2172. /* STEP 2, INITIALIZE AND CONSTRUCT */
  2173. Callable::CallError ce;
  2174. p_script->initializer->call(instance, nullptr, 0, ce);
  2175. if (ce.error != Callable::CallError::CALL_OK) {
  2176. //well, tough luck, not gonna do anything here
  2177. }
  2178. }
  2179. #endif
  2180. } else {
  2181. GDScriptInstance *gi = static_cast<GDScriptInstance *>(si);
  2182. gi->reload_members();
  2183. }
  2184. E = N;
  2185. }
  2186. }
  2187. #endif
  2188. for (int i = 0; i < p_class->members.size(); i++) {
  2189. if (p_class->members[i].type != GDScriptParser::ClassNode::Member::CLASS) {
  2190. continue;
  2191. }
  2192. const GDScriptParser::ClassNode *inner_class = p_class->members[i].m_class;
  2193. StringName name = inner_class->identifier->name;
  2194. GDScript *subclass = p_script->subclasses[name].ptr();
  2195. Error err = _parse_class_blocks(subclass, inner_class, p_keep_state);
  2196. if (err) {
  2197. return err;
  2198. }
  2199. }
  2200. p_script->valid = true;
  2201. return OK;
  2202. }
  2203. void GDScriptCompiler::_make_scripts(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) {
  2204. Map<StringName, Ref<GDScript>> old_subclasses;
  2205. if (p_keep_state) {
  2206. old_subclasses = p_script->subclasses;
  2207. }
  2208. p_script->subclasses.clear();
  2209. for (int i = 0; i < p_class->members.size(); i++) {
  2210. if (p_class->members[i].type != GDScriptParser::ClassNode::Member::CLASS) {
  2211. continue;
  2212. }
  2213. const GDScriptParser::ClassNode *inner_class = p_class->members[i].m_class;
  2214. StringName name = inner_class->identifier->name;
  2215. Ref<GDScript> subclass;
  2216. String fully_qualified_name = p_script->fully_qualified_name + "::" + name;
  2217. if (old_subclasses.has(name)) {
  2218. subclass = old_subclasses[name];
  2219. } else {
  2220. Ref<GDScript> orphan_subclass = GDScriptLanguage::get_singleton()->get_orphan_subclass(fully_qualified_name);
  2221. if (orphan_subclass.is_valid()) {
  2222. subclass = orphan_subclass;
  2223. } else {
  2224. subclass.instantiate();
  2225. }
  2226. }
  2227. subclass->_owner = p_script;
  2228. subclass->fully_qualified_name = fully_qualified_name;
  2229. p_script->subclasses.insert(name, subclass);
  2230. _make_scripts(subclass.ptr(), inner_class, false);
  2231. }
  2232. }
  2233. Error GDScriptCompiler::compile(const GDScriptParser *p_parser, GDScript *p_script, bool p_keep_state) {
  2234. err_line = -1;
  2235. err_column = -1;
  2236. error = "";
  2237. parser = p_parser;
  2238. main_script = p_script;
  2239. const GDScriptParser::ClassNode *root = parser->get_tree();
  2240. source = p_script->get_path();
  2241. // The best fully qualified name for a base level script is its file path
  2242. p_script->fully_qualified_name = p_script->path;
  2243. // Create scripts for subclasses beforehand so they can be referenced
  2244. _make_scripts(p_script, root, p_keep_state);
  2245. p_script->_owner = nullptr;
  2246. Error err = _parse_class_level(p_script, root, p_keep_state);
  2247. if (err) {
  2248. return err;
  2249. }
  2250. err = _parse_class_blocks(p_script, root, p_keep_state);
  2251. if (err) {
  2252. return err;
  2253. }
  2254. return GDScriptCache::finish_compiling(p_script->get_path());
  2255. }
  2256. String GDScriptCompiler::get_error() const {
  2257. return error;
  2258. }
  2259. int GDScriptCompiler::get_error_line() const {
  2260. return err_line;
  2261. }
  2262. int GDScriptCompiler::get_error_column() const {
  2263. return err_column;
  2264. }
  2265. GDScriptCompiler::GDScriptCompiler() {
  2266. }