2
0

gdscript_parser.cpp 254 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261526252635264526552665267526852695270527152725273527452755276527752785279528052815282528352845285528652875288528952905291529252935294529552965297529852995300530153025303530453055306530753085309531053115312531353145315531653175318531953205321532253235324532553265327532853295330533153325333533453355336533753385339534053415342534353445345534653475348534953505351535253535354535553565357535853595360536153625363536453655366536753685369537053715372537353745375537653775378537953805381538253835384538553865387538853895390539153925393539453955396539753985399540054015402540354045405540654075408540954105411541254135414541554165417541854195420542154225423542454255426542754285429543054315432543354345435543654375438543954405441544254435444544554465447544854495450545154525453545454555456545754585459546054615462546354645465546654675468546954705471547254735474547554765477547854795480548154825483548454855486548754885489549054915492549354945495549654975498549955005501550255035504550555065507550855095510551155125513551455155516551755185519552055215522552355245525552655275528552955305531553255335534553555365537553855395540554155425543554455455546554755485549555055515552555355545555555655575558555955605561556255635564556555665567556855695570557155725573557455755576557755785579558055815582558355845585558655875588558955905591559255935594559555965597559855995600560156025603560456055606560756085609561056115612561356145615561656175618561956205621562256235624562556265627562856295630563156325633563456355636563756385639564056415642564356445645564656475648564956505651565256535654565556565657565856595660566156625663566456655666566756685669567056715672567356745675567656775678567956805681568256835684568556865687568856895690569156925693569456955696569756985699570057015702570357045705570657075708570957105711571257135714571557165717571857195720572157225723572457255726572757285729573057315732573357345735573657375738573957405741574257435744574557465747574857495750575157525753575457555756575757585759576057615762576357645765576657675768576957705771577257735774577557765777577857795780578157825783578457855786578757885789579057915792579357945795579657975798579958005801580258035804580558065807580858095810581158125813581458155816581758185819582058215822582358245825582658275828582958305831583258335834583558365837583858395840584158425843584458455846584758485849585058515852585358545855585658575858585958605861586258635864586558665867586858695870587158725873587458755876587758785879588058815882588358845885588658875888588958905891589258935894589558965897589858995900590159025903590459055906590759085909591059115912591359145915591659175918591959205921592259235924592559265927592859295930593159325933593459355936593759385939594059415942594359445945594659475948594959505951595259535954595559565957595859595960596159625963596459655966596759685969597059715972597359745975597659775978597959805981598259835984598559865987598859895990599159925993599459955996599759985999600060016002600360046005600660076008600960106011601260136014601560166017601860196020602160226023602460256026602760286029603060316032603360346035603660376038603960406041604260436044604560466047604860496050605160526053605460556056605760586059606060616062606360646065606660676068606960706071607260736074607560766077607860796080608160826083608460856086608760886089609060916092609360946095609660976098609961006101610261036104610561066107610861096110611161126113611461156116611761186119612061216122612361246125612661276128612961306131613261336134613561366137613861396140614161426143614461456146614761486149615061516152615361546155615661576158615961606161616261636164616561666167616861696170617161726173617461756176617761786179618061816182618361846185618661876188618961906191619261936194619561966197619861996200620162026203620462056206620762086209621062116212621362146215621662176218621962206221622262236224622562266227622862296230623162326233623462356236623762386239624062416242624362446245624662476248624962506251625262536254625562566257625862596260626162626263626462656266626762686269627062716272627362746275627662776278627962806281628262836284628562866287628862896290629162926293629462956296629762986299630063016302630363046305630663076308630963106311631263136314631563166317631863196320632163226323632463256326632763286329633063316332633363346335633663376338633963406341634263436344634563466347634863496350635163526353635463556356635763586359636063616362636363646365636663676368636963706371637263736374637563766377637863796380638163826383638463856386638763886389639063916392639363946395639663976398639964006401640264036404640564066407640864096410641164126413641464156416641764186419642064216422642364246425642664276428642964306431643264336434643564366437643864396440644164426443644464456446644764486449645064516452645364546455645664576458645964606461646264636464646564666467646864696470647164726473647464756476647764786479648064816482648364846485648664876488648964906491649264936494649564966497649864996500650165026503650465056506650765086509651065116512651365146515651665176518651965206521652265236524652565266527652865296530653165326533653465356536653765386539654065416542654365446545654665476548654965506551655265536554655565566557655865596560656165626563656465656566656765686569657065716572657365746575657665776578657965806581658265836584658565866587658865896590659165926593659465956596659765986599660066016602660366046605660666076608660966106611661266136614661566166617661866196620662166226623662466256626662766286629663066316632663366346635663666376638663966406641664266436644664566466647664866496650665166526653665466556656665766586659666066616662666366646665666666676668666966706671667266736674667566766677667866796680668166826683668466856686668766886689669066916692669366946695669666976698669967006701670267036704670567066707670867096710671167126713671467156716671767186719672067216722672367246725672667276728672967306731673267336734673567366737673867396740674167426743674467456746674767486749675067516752675367546755675667576758675967606761676267636764676567666767676867696770677167726773677467756776677767786779678067816782678367846785678667876788678967906791679267936794679567966797679867996800680168026803680468056806680768086809681068116812681368146815681668176818681968206821682268236824682568266827682868296830683168326833683468356836683768386839684068416842684368446845684668476848684968506851685268536854685568566857685868596860686168626863686468656866686768686869687068716872687368746875687668776878687968806881688268836884688568866887688868896890689168926893689468956896689768986899690069016902690369046905690669076908690969106911691269136914691569166917691869196920692169226923692469256926692769286929693069316932693369346935693669376938693969406941694269436944694569466947694869496950695169526953695469556956695769586959696069616962696369646965696669676968696969706971697269736974697569766977697869796980698169826983698469856986698769886989699069916992699369946995699669976998699970007001700270037004700570067007700870097010701170127013701470157016701770187019702070217022702370247025702670277028702970307031703270337034703570367037703870397040704170427043704470457046704770487049705070517052705370547055705670577058705970607061706270637064706570667067706870697070707170727073707470757076707770787079708070817082708370847085708670877088708970907091709270937094709570967097709870997100710171027103710471057106710771087109711071117112711371147115711671177118711971207121712271237124712571267127712871297130713171327133713471357136713771387139714071417142714371447145714671477148714971507151715271537154715571567157715871597160716171627163716471657166716771687169717071717172717371747175717671777178717971807181718271837184718571867187718871897190719171927193719471957196719771987199720072017202720372047205720672077208720972107211721272137214721572167217721872197220722172227223722472257226722772287229723072317232723372347235723672377238723972407241724272437244724572467247724872497250725172527253725472557256725772587259726072617262726372647265726672677268726972707271727272737274727572767277727872797280728172827283728472857286728772887289729072917292729372947295729672977298729973007301730273037304730573067307730873097310731173127313731473157316731773187319732073217322732373247325732673277328732973307331733273337334733573367337733873397340734173427343734473457346734773487349735073517352735373547355735673577358735973607361736273637364736573667367736873697370737173727373737473757376737773787379738073817382738373847385738673877388738973907391739273937394739573967397739873997400740174027403740474057406740774087409741074117412741374147415741674177418741974207421742274237424742574267427742874297430743174327433743474357436743774387439744074417442744374447445744674477448744974507451745274537454745574567457745874597460746174627463746474657466746774687469747074717472747374747475747674777478747974807481748274837484748574867487748874897490749174927493749474957496749774987499750075017502750375047505750675077508750975107511751275137514751575167517751875197520752175227523752475257526752775287529753075317532753375347535753675377538753975407541754275437544754575467547754875497550755175527553755475557556755775587559756075617562756375647565756675677568756975707571757275737574757575767577757875797580758175827583758475857586758775887589759075917592759375947595759675977598759976007601760276037604760576067607760876097610761176127613761476157616761776187619762076217622762376247625762676277628762976307631763276337634763576367637763876397640764176427643764476457646764776487649765076517652765376547655765676577658765976607661766276637664766576667667766876697670767176727673767476757676767776787679768076817682768376847685768676877688768976907691769276937694769576967697769876997700770177027703770477057706770777087709771077117712771377147715771677177718771977207721772277237724772577267727772877297730773177327733773477357736773777387739774077417742774377447745774677477748774977507751775277537754775577567757775877597760776177627763776477657766776777687769777077717772777377747775777677777778777977807781778277837784778577867787778877897790779177927793779477957796779777987799780078017802780378047805780678077808780978107811781278137814781578167817781878197820782178227823782478257826782778287829783078317832783378347835783678377838783978407841784278437844784578467847784878497850785178527853785478557856785778587859786078617862786378647865786678677868786978707871787278737874787578767877787878797880788178827883788478857886788778887889789078917892789378947895789678977898789979007901790279037904790579067907790879097910791179127913791479157916791779187919792079217922792379247925792679277928792979307931793279337934793579367937793879397940794179427943794479457946794779487949795079517952795379547955795679577958795979607961796279637964796579667967796879697970797179727973797479757976797779787979798079817982798379847985798679877988798979907991799279937994799579967997799879998000800180028003800480058006800780088009801080118012801380148015801680178018801980208021802280238024802580268027802880298030803180328033803480358036803780388039804080418042804380448045804680478048804980508051805280538054805580568057805880598060806180628063806480658066806780688069807080718072807380748075807680778078807980808081808280838084808580868087808880898090809180928093809480958096809780988099810081018102810381048105810681078108810981108111811281138114811581168117811881198120812181228123812481258126812781288129813081318132813381348135813681378138813981408141814281438144814581468147814881498150815181528153815481558156815781588159816081618162816381648165816681678168816981708171817281738174817581768177817881798180818181828183818481858186818781888189819081918192819381948195819681978198819982008201820282038204820582068207820882098210821182128213821482158216821782188219822082218222822382248225822682278228822982308231823282338234823582368237823882398240824182428243824482458246824782488249825082518252825382548255825682578258825982608261826282638264826582668267826882698270827182728273827482758276827782788279828082818282828382848285828682878288828982908291829282938294829582968297829882998300830183028303830483058306830783088309831083118312831383148315831683178318831983208321832283238324832583268327832883298330
  1. /*************************************************************************/
  2. /* gdscript_parser.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2019 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_parser.h"
  31. #include "core/core_string_names.h"
  32. #include "core/engine.h"
  33. #include "core/io/resource_loader.h"
  34. #include "core/os/file_access.h"
  35. #include "core/print_string.h"
  36. #include "core/project_settings.h"
  37. #include "core/reference.h"
  38. #include "core/script_language.h"
  39. #include "gdscript.h"
  40. template <class T>
  41. T *GDScriptParser::alloc_node() {
  42. T *t = memnew(T);
  43. t->next = list;
  44. list = t;
  45. if (!head)
  46. head = t;
  47. t->line = tokenizer->get_token_line();
  48. t->column = tokenizer->get_token_column();
  49. return t;
  50. }
  51. #ifdef DEBUG_ENABLED
  52. static String _find_function_name(const GDScriptParser::OperatorNode *p_call);
  53. #endif // DEBUG_ENABLED
  54. bool GDScriptParser::_end_statement() {
  55. if (tokenizer->get_token() == GDScriptTokenizer::TK_SEMICOLON) {
  56. tokenizer->advance();
  57. return true; //handle next
  58. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE || tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
  59. return true; //will be handled properly
  60. }
  61. return false;
  62. }
  63. bool GDScriptParser::_enter_indent_block(BlockNode *p_block) {
  64. if (tokenizer->get_token() != GDScriptTokenizer::TK_COLON) {
  65. // report location at the previous token (on the previous line)
  66. int error_line = tokenizer->get_token_line(-1);
  67. int error_column = tokenizer->get_token_column(-1);
  68. _set_error("':' expected at end of line.", error_line, error_column);
  69. return false;
  70. }
  71. tokenizer->advance();
  72. if (tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
  73. return false;
  74. }
  75. if (tokenizer->get_token() != GDScriptTokenizer::TK_NEWLINE) {
  76. // be more python-like
  77. int current = tab_level.back()->get();
  78. tab_level.push_back(current);
  79. return true;
  80. //_set_error("newline expected after ':'.");
  81. //return false;
  82. }
  83. while (true) {
  84. if (tokenizer->get_token() != GDScriptTokenizer::TK_NEWLINE) {
  85. return false; //wtf
  86. } else if (tokenizer->get_token(1) == GDScriptTokenizer::TK_EOF) {
  87. return false;
  88. } else if (tokenizer->get_token(1) != GDScriptTokenizer::TK_NEWLINE) {
  89. int indent = tokenizer->get_token_line_indent();
  90. int current = tab_level.back()->get();
  91. if (indent <= current) {
  92. return false;
  93. }
  94. tab_level.push_back(indent);
  95. tokenizer->advance();
  96. return true;
  97. } else if (p_block) {
  98. NewLineNode *nl = alloc_node<NewLineNode>();
  99. nl->line = tokenizer->get_token_line();
  100. p_block->statements.push_back(nl);
  101. }
  102. tokenizer->advance(); // go to next newline
  103. }
  104. }
  105. bool GDScriptParser::_parse_arguments(Node *p_parent, Vector<Node *> &p_args, bool p_static, bool p_can_codecomplete) {
  106. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  107. tokenizer->advance();
  108. } else {
  109. parenthesis++;
  110. int argidx = 0;
  111. while (true) {
  112. if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
  113. _make_completable_call(argidx);
  114. completion_node = p_parent;
  115. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING && tokenizer->get_token(1) == GDScriptTokenizer::TK_CURSOR) {
  116. //completing a string argument..
  117. completion_cursor = tokenizer->get_token_constant();
  118. _make_completable_call(argidx);
  119. completion_node = p_parent;
  120. tokenizer->advance(1);
  121. return false;
  122. }
  123. Node *arg = _parse_expression(p_parent, p_static);
  124. if (!arg) {
  125. return false;
  126. }
  127. p_args.push_back(arg);
  128. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  129. tokenizer->advance();
  130. break;
  131. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  132. if (tokenizer->get_token(1) == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  133. _set_error("Expression expected");
  134. return false;
  135. }
  136. tokenizer->advance();
  137. argidx++;
  138. } else {
  139. // something is broken
  140. _set_error("Expected ',' or ')'");
  141. return false;
  142. }
  143. }
  144. parenthesis--;
  145. }
  146. return true;
  147. }
  148. void GDScriptParser::_make_completable_call(int p_arg) {
  149. completion_cursor = StringName();
  150. completion_type = COMPLETION_CALL_ARGUMENTS;
  151. completion_class = current_class;
  152. completion_function = current_function;
  153. completion_line = tokenizer->get_token_line();
  154. completion_argument = p_arg;
  155. completion_block = current_block;
  156. completion_found = true;
  157. tokenizer->advance();
  158. }
  159. bool GDScriptParser::_get_completable_identifier(CompletionType p_type, StringName &identifier) {
  160. identifier = StringName();
  161. if (tokenizer->is_token_literal()) {
  162. identifier = tokenizer->get_token_literal();
  163. tokenizer->advance();
  164. }
  165. if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
  166. completion_cursor = identifier;
  167. completion_type = p_type;
  168. completion_class = current_class;
  169. completion_function = current_function;
  170. completion_line = tokenizer->get_token_line();
  171. completion_block = current_block;
  172. completion_found = true;
  173. completion_ident_is_call = false;
  174. tokenizer->advance();
  175. if (tokenizer->is_token_literal()) {
  176. identifier = identifier.operator String() + tokenizer->get_token_literal().operator String();
  177. tokenizer->advance();
  178. }
  179. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
  180. completion_ident_is_call = true;
  181. }
  182. return true;
  183. }
  184. return false;
  185. }
  186. GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_static, bool p_allow_assign, bool p_parsing_constant) {
  187. //Vector<Node*> expressions;
  188. //Vector<OperatorNode::Operator> operators;
  189. Vector<Expression> expression;
  190. Node *expr = NULL;
  191. int op_line = tokenizer->get_token_line(); // when operators are created at the bottom, the line might have been changed (\n found)
  192. while (true) {
  193. /*****************/
  194. /* Parse Operand */
  195. /*****************/
  196. if (parenthesis > 0) {
  197. //remove empty space (only allowed if inside parenthesis
  198. while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
  199. tokenizer->advance();
  200. }
  201. }
  202. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
  203. //subexpression ()
  204. tokenizer->advance();
  205. parenthesis++;
  206. Node *subexpr = _parse_expression(p_parent, p_static, p_allow_assign, p_parsing_constant);
  207. parenthesis--;
  208. if (!subexpr)
  209. return NULL;
  210. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  211. _set_error("Expected ')' in expression");
  212. return NULL;
  213. }
  214. tokenizer->advance();
  215. expr = subexpr;
  216. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_DOLLAR) {
  217. tokenizer->advance();
  218. String path;
  219. bool need_identifier = true;
  220. bool done = false;
  221. int line = tokenizer->get_token_line();
  222. while (!done) {
  223. switch (tokenizer->get_token()) {
  224. case GDScriptTokenizer::TK_CURSOR: {
  225. completion_cursor = StringName();
  226. completion_type = COMPLETION_GET_NODE;
  227. completion_class = current_class;
  228. completion_function = current_function;
  229. completion_line = tokenizer->get_token_line();
  230. completion_cursor = path;
  231. completion_argument = 0;
  232. completion_block = current_block;
  233. completion_found = true;
  234. tokenizer->advance();
  235. } break;
  236. case GDScriptTokenizer::TK_CONSTANT: {
  237. if (!need_identifier) {
  238. done = true;
  239. break;
  240. }
  241. if (tokenizer->get_token_constant().get_type() != Variant::STRING) {
  242. _set_error("Expected string constant or identifier after '$' or '/'.");
  243. return NULL;
  244. }
  245. path += String(tokenizer->get_token_constant());
  246. tokenizer->advance();
  247. need_identifier = false;
  248. } break;
  249. case GDScriptTokenizer::TK_OP_DIV: {
  250. if (need_identifier) {
  251. done = true;
  252. break;
  253. }
  254. path += "/";
  255. tokenizer->advance();
  256. need_identifier = true;
  257. } break;
  258. default: {
  259. // Instead of checking for TK_IDENTIFIER, we check with is_token_literal, as this allows us to use match/sync/etc. as a name
  260. if (need_identifier && tokenizer->is_token_literal()) {
  261. path += String(tokenizer->get_token_literal());
  262. tokenizer->advance();
  263. need_identifier = false;
  264. } else {
  265. done = true;
  266. }
  267. break;
  268. }
  269. }
  270. }
  271. if (path == "") {
  272. _set_error("Path expected after $.");
  273. return NULL;
  274. }
  275. OperatorNode *op = alloc_node<OperatorNode>();
  276. op->op = OperatorNode::OP_CALL;
  277. op->line = line;
  278. op->arguments.push_back(alloc_node<SelfNode>());
  279. op->arguments[0]->line = line;
  280. IdentifierNode *funcname = alloc_node<IdentifierNode>();
  281. funcname->name = "get_node";
  282. funcname->line = line;
  283. op->arguments.push_back(funcname);
  284. ConstantNode *nodepath = alloc_node<ConstantNode>();
  285. nodepath->value = NodePath(StringName(path));
  286. nodepath->datatype = _type_from_variant(nodepath->value);
  287. nodepath->line = line;
  288. op->arguments.push_back(nodepath);
  289. expr = op;
  290. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
  291. tokenizer->advance();
  292. continue; //no point in cursor in the middle of expression
  293. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT) {
  294. //constant defined by tokenizer
  295. ConstantNode *constant = alloc_node<ConstantNode>();
  296. constant->value = tokenizer->get_token_constant();
  297. constant->datatype = _type_from_variant(constant->value);
  298. tokenizer->advance();
  299. expr = constant;
  300. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONST_PI) {
  301. //constant defined by tokenizer
  302. ConstantNode *constant = alloc_node<ConstantNode>();
  303. constant->value = Math_PI;
  304. constant->datatype = _type_from_variant(constant->value);
  305. tokenizer->advance();
  306. expr = constant;
  307. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONST_TAU) {
  308. //constant defined by tokenizer
  309. ConstantNode *constant = alloc_node<ConstantNode>();
  310. constant->value = Math_TAU;
  311. constant->datatype = _type_from_variant(constant->value);
  312. tokenizer->advance();
  313. expr = constant;
  314. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONST_INF) {
  315. //constant defined by tokenizer
  316. ConstantNode *constant = alloc_node<ConstantNode>();
  317. constant->value = Math_INF;
  318. constant->datatype = _type_from_variant(constant->value);
  319. tokenizer->advance();
  320. expr = constant;
  321. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONST_NAN) {
  322. //constant defined by tokenizer
  323. ConstantNode *constant = alloc_node<ConstantNode>();
  324. constant->value = Math_NAN;
  325. constant->datatype = _type_from_variant(constant->value);
  326. tokenizer->advance();
  327. expr = constant;
  328. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_PRELOAD) {
  329. //constant defined by tokenizer
  330. tokenizer->advance();
  331. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
  332. _set_error("Expected '(' after 'preload'");
  333. return NULL;
  334. }
  335. tokenizer->advance();
  336. if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
  337. completion_cursor = StringName();
  338. completion_node = p_parent;
  339. completion_type = COMPLETION_RESOURCE_PATH;
  340. completion_class = current_class;
  341. completion_function = current_function;
  342. completion_line = tokenizer->get_token_line();
  343. completion_block = current_block;
  344. completion_argument = 0;
  345. completion_found = true;
  346. tokenizer->advance();
  347. }
  348. String path;
  349. bool found_constant = false;
  350. bool valid = false;
  351. ConstantNode *cn;
  352. Node *subexpr = _parse_and_reduce_expression(p_parent, p_static);
  353. if (subexpr) {
  354. if (subexpr->type == Node::TYPE_CONSTANT) {
  355. cn = static_cast<ConstantNode *>(subexpr);
  356. found_constant = true;
  357. }
  358. if (subexpr->type == Node::TYPE_IDENTIFIER) {
  359. IdentifierNode *in = static_cast<IdentifierNode *>(subexpr);
  360. // Try to find the constant expression by the identifier
  361. if (current_class->constant_expressions.has(in->name)) {
  362. Node *cn_exp = current_class->constant_expressions[in->name].expression;
  363. if (cn_exp->type == Node::TYPE_CONSTANT) {
  364. cn = static_cast<ConstantNode *>(cn_exp);
  365. found_constant = true;
  366. }
  367. }
  368. }
  369. if (found_constant && cn->value.get_type() == Variant::STRING) {
  370. valid = true;
  371. path = (String)cn->value;
  372. }
  373. }
  374. if (!valid) {
  375. _set_error("expected string constant as 'preload' argument.");
  376. return NULL;
  377. }
  378. if (!path.is_abs_path() && base_path != "")
  379. path = base_path + "/" + path;
  380. path = path.replace("///", "//").simplify_path();
  381. if (path == self_path) {
  382. _set_error("Can't preload itself (use 'get_script()').");
  383. return NULL;
  384. }
  385. Ref<Resource> res;
  386. if (!validating) {
  387. //this can be too slow for just validating code
  388. if (for_completion && ScriptCodeCompletionCache::get_singleton() && FileAccess::exists(path)) {
  389. res = ScriptCodeCompletionCache::get_singleton()->get_cached_resource(path);
  390. } else if (!for_completion || FileAccess::exists(path)) {
  391. res = ResourceLoader::load(path);
  392. }
  393. } else {
  394. if (!FileAccess::exists(path)) {
  395. _set_error("Can't preload resource at path: " + path);
  396. return NULL;
  397. } else if (ScriptCodeCompletionCache::get_singleton()) {
  398. res = ScriptCodeCompletionCache::get_singleton()->get_cached_resource(path);
  399. }
  400. }
  401. if (!res.is_valid()) {
  402. _set_error("Can't preload resource at path: " + path);
  403. return NULL;
  404. }
  405. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  406. _set_error("Expected ')' after 'preload' path");
  407. return NULL;
  408. }
  409. Ref<GDScript> gds = res;
  410. if (gds.is_valid() && !gds->is_valid()) {
  411. _set_error("Could not fully preload the script, possible cyclic reference or compilation error.");
  412. return NULL;
  413. }
  414. tokenizer->advance();
  415. ConstantNode *constant = alloc_node<ConstantNode>();
  416. constant->value = res;
  417. constant->datatype = _type_from_variant(constant->value);
  418. expr = constant;
  419. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_YIELD) {
  420. if (!current_function) {
  421. _set_error("yield() can only be used inside function blocks.");
  422. return NULL;
  423. }
  424. current_function->has_yield = true;
  425. tokenizer->advance();
  426. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
  427. _set_error("Expected '(' after 'yield'");
  428. return NULL;
  429. }
  430. tokenizer->advance();
  431. OperatorNode *yield = alloc_node<OperatorNode>();
  432. yield->op = OperatorNode::OP_YIELD;
  433. while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
  434. tokenizer->advance();
  435. }
  436. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  437. expr = yield;
  438. tokenizer->advance();
  439. } else {
  440. parenthesis++;
  441. Node *object = _parse_and_reduce_expression(p_parent, p_static);
  442. if (!object)
  443. return NULL;
  444. yield->arguments.push_back(object);
  445. if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
  446. _set_error("Expected ',' after first argument of 'yield'");
  447. return NULL;
  448. }
  449. tokenizer->advance();
  450. if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
  451. completion_cursor = StringName();
  452. completion_node = object;
  453. completion_type = COMPLETION_YIELD;
  454. completion_class = current_class;
  455. completion_function = current_function;
  456. completion_line = tokenizer->get_token_line();
  457. completion_argument = 0;
  458. completion_block = current_block;
  459. completion_found = true;
  460. tokenizer->advance();
  461. }
  462. Node *signal = _parse_and_reduce_expression(p_parent, p_static);
  463. if (!signal)
  464. return NULL;
  465. yield->arguments.push_back(signal);
  466. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  467. _set_error("Expected ')' after second argument of 'yield'");
  468. return NULL;
  469. }
  470. parenthesis--;
  471. tokenizer->advance();
  472. expr = yield;
  473. }
  474. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_SELF) {
  475. if (p_static) {
  476. _set_error("'self'' not allowed in static function or constant expression");
  477. return NULL;
  478. }
  479. //constant defined by tokenizer
  480. SelfNode *self = alloc_node<SelfNode>();
  481. tokenizer->advance();
  482. expr = self;
  483. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE && tokenizer->get_token(1) == GDScriptTokenizer::TK_PERIOD) {
  484. Variant::Type bi_type = tokenizer->get_token_type();
  485. tokenizer->advance(2);
  486. StringName identifier;
  487. if (_get_completable_identifier(COMPLETION_BUILT_IN_TYPE_CONSTANT, identifier)) {
  488. completion_built_in_constant = bi_type;
  489. }
  490. if (identifier == StringName()) {
  491. _set_error("Built-in type constant or static function expected after '.'");
  492. return NULL;
  493. }
  494. if (!Variant::has_constant(bi_type, identifier)) {
  495. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN &&
  496. Variant::is_method_const(bi_type, identifier) &&
  497. Variant::get_method_return_type(bi_type, identifier) == bi_type) {
  498. tokenizer->advance();
  499. OperatorNode *construct = alloc_node<OperatorNode>();
  500. construct->op = OperatorNode::OP_CALL;
  501. TypeNode *tn = alloc_node<TypeNode>();
  502. tn->vtype = bi_type;
  503. construct->arguments.push_back(tn);
  504. OperatorNode *op = alloc_node<OperatorNode>();
  505. op->op = OperatorNode::OP_CALL;
  506. op->arguments.push_back(construct);
  507. IdentifierNode *id = alloc_node<IdentifierNode>();
  508. id->name = identifier;
  509. op->arguments.push_back(id);
  510. if (!_parse_arguments(op, op->arguments, p_static, true))
  511. return NULL;
  512. expr = op;
  513. } else {
  514. // Object is a special case
  515. bool valid = false;
  516. if (bi_type == Variant::OBJECT) {
  517. int object_constant = ClassDB::get_integer_constant("Object", identifier, &valid);
  518. if (valid) {
  519. ConstantNode *cn = alloc_node<ConstantNode>();
  520. cn->value = object_constant;
  521. cn->datatype = _type_from_variant(cn->value);
  522. expr = cn;
  523. }
  524. }
  525. if (!valid) {
  526. _set_error("Static constant '" + identifier.operator String() + "' not present in built-in type " + Variant::get_type_name(bi_type) + ".");
  527. return NULL;
  528. }
  529. }
  530. } else {
  531. ConstantNode *cn = alloc_node<ConstantNode>();
  532. cn->value = Variant::get_constant_value(bi_type, identifier);
  533. cn->datatype = _type_from_variant(cn->value);
  534. expr = cn;
  535. }
  536. } else if (tokenizer->get_token(1) == GDScriptTokenizer::TK_PARENTHESIS_OPEN && tokenizer->is_token_literal()) {
  537. // We check with is_token_literal, as this allows us to use match/sync/etc. as a name
  538. //function or constructor
  539. OperatorNode *op = alloc_node<OperatorNode>();
  540. op->op = OperatorNode::OP_CALL;
  541. //Do a quick Array and Dictionary Check. Replace if either require no arguments.
  542. bool replaced = false;
  543. if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE) {
  544. Variant::Type ct = tokenizer->get_token_type();
  545. if (!p_parsing_constant) {
  546. if (ct == Variant::ARRAY) {
  547. if (tokenizer->get_token(2) == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  548. ArrayNode *arr = alloc_node<ArrayNode>();
  549. expr = arr;
  550. replaced = true;
  551. tokenizer->advance(3);
  552. }
  553. }
  554. if (ct == Variant::DICTIONARY) {
  555. if (tokenizer->get_token(2) == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  556. DictionaryNode *dict = alloc_node<DictionaryNode>();
  557. expr = dict;
  558. replaced = true;
  559. tokenizer->advance(3);
  560. }
  561. }
  562. }
  563. if (!replaced) {
  564. TypeNode *tn = alloc_node<TypeNode>();
  565. tn->vtype = tokenizer->get_token_type();
  566. op->arguments.push_back(tn);
  567. tokenizer->advance(2);
  568. }
  569. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_FUNC) {
  570. BuiltInFunctionNode *bn = alloc_node<BuiltInFunctionNode>();
  571. bn->function = tokenizer->get_token_built_in_func();
  572. op->arguments.push_back(bn);
  573. tokenizer->advance(2);
  574. } else {
  575. SelfNode *self = alloc_node<SelfNode>();
  576. op->arguments.push_back(self);
  577. StringName identifier;
  578. if (_get_completable_identifier(COMPLETION_FUNCTION, identifier)) {
  579. }
  580. IdentifierNode *id = alloc_node<IdentifierNode>();
  581. id->name = identifier;
  582. op->arguments.push_back(id);
  583. tokenizer->advance(1);
  584. }
  585. if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
  586. _make_completable_call(0);
  587. completion_node = op;
  588. }
  589. if (!replaced) {
  590. if (!_parse_arguments(op, op->arguments, p_static, true))
  591. return NULL;
  592. expr = op;
  593. }
  594. } else if (tokenizer->is_token_literal(0, true)) {
  595. // We check with is_token_literal, as this allows us to use match/sync/etc. as a name
  596. //identifier (reference)
  597. const ClassNode *cln = current_class;
  598. bool bfn = false;
  599. StringName identifier;
  600. int id_line = tokenizer->get_token_line();
  601. if (_get_completable_identifier(COMPLETION_IDENTIFIER, identifier)) {
  602. }
  603. BlockNode *b = current_block;
  604. while (!bfn && b) {
  605. if (b->variables.has(identifier)) {
  606. IdentifierNode *id = alloc_node<IdentifierNode>();
  607. id->name = identifier;
  608. id->declared_block = b;
  609. id->line = id_line;
  610. expr = id;
  611. bfn = true;
  612. #ifdef DEBUG_ENABLED
  613. LocalVarNode *lv = b->variables[identifier];
  614. switch (tokenizer->get_token()) {
  615. case GDScriptTokenizer::TK_OP_ASSIGN_ADD:
  616. case GDScriptTokenizer::TK_OP_ASSIGN_BIT_AND:
  617. case GDScriptTokenizer::TK_OP_ASSIGN_BIT_OR:
  618. case GDScriptTokenizer::TK_OP_ASSIGN_BIT_XOR:
  619. case GDScriptTokenizer::TK_OP_ASSIGN_DIV:
  620. case GDScriptTokenizer::TK_OP_ASSIGN_MOD:
  621. case GDScriptTokenizer::TK_OP_ASSIGN_MUL:
  622. case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_LEFT:
  623. case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_RIGHT:
  624. case GDScriptTokenizer::TK_OP_ASSIGN_SUB: {
  625. if (lv->assignments == 0) {
  626. if (!lv->datatype.has_type) {
  627. _set_error("Using assignment with operation on a variable that was never assigned.");
  628. return NULL;
  629. }
  630. _add_warning(GDScriptWarning::UNASSIGNED_VARIABLE_OP_ASSIGN, -1, identifier.operator String());
  631. }
  632. } // fallthrough
  633. case GDScriptTokenizer::TK_OP_ASSIGN: {
  634. lv->assignments += 1;
  635. lv->usages--; // Assignment is not really usage
  636. } break;
  637. default: {
  638. lv->usages++;
  639. }
  640. }
  641. #endif // DEBUG_ENABLED
  642. break;
  643. }
  644. b = b->parent_block;
  645. }
  646. if (!bfn && p_parsing_constant) {
  647. if (cln->constant_expressions.has(identifier)) {
  648. expr = cln->constant_expressions[identifier].expression;
  649. bfn = true;
  650. } else if (GDScriptLanguage::get_singleton()->get_global_map().has(identifier)) {
  651. //check from constants
  652. ConstantNode *constant = alloc_node<ConstantNode>();
  653. constant->value = GDScriptLanguage::get_singleton()->get_global_array()[GDScriptLanguage::get_singleton()->get_global_map()[identifier]];
  654. constant->datatype = _type_from_variant(constant->value);
  655. constant->line = id_line;
  656. expr = constant;
  657. bfn = true;
  658. }
  659. if (!bfn && GDScriptLanguage::get_singleton()->get_named_globals_map().has(identifier)) {
  660. //check from singletons
  661. ConstantNode *constant = alloc_node<ConstantNode>();
  662. constant->value = GDScriptLanguage::get_singleton()->get_named_globals_map()[identifier];
  663. expr = constant;
  664. bfn = true;
  665. }
  666. // Check parents for the constant
  667. if (!bfn && cln->extends_file != StringName()) {
  668. Ref<GDScript> parent = ResourceLoader::load(cln->extends_file);
  669. if (parent.is_valid() && parent->is_valid()) {
  670. Map<StringName, Variant> parent_constants;
  671. parent->get_constants(&parent_constants);
  672. if (parent_constants.has(identifier)) {
  673. ConstantNode *constant = alloc_node<ConstantNode>();
  674. constant->value = parent_constants[identifier];
  675. expr = constant;
  676. bfn = true;
  677. }
  678. }
  679. }
  680. }
  681. if (!bfn) {
  682. #ifdef DEBUG_ENABLED
  683. if (current_function) {
  684. int arg_idx = current_function->arguments.find(identifier);
  685. if (arg_idx != -1) {
  686. switch (tokenizer->get_token()) {
  687. case GDScriptTokenizer::TK_OP_ASSIGN_ADD:
  688. case GDScriptTokenizer::TK_OP_ASSIGN_BIT_AND:
  689. case GDScriptTokenizer::TK_OP_ASSIGN_BIT_OR:
  690. case GDScriptTokenizer::TK_OP_ASSIGN_BIT_XOR:
  691. case GDScriptTokenizer::TK_OP_ASSIGN_DIV:
  692. case GDScriptTokenizer::TK_OP_ASSIGN_MOD:
  693. case GDScriptTokenizer::TK_OP_ASSIGN_MUL:
  694. case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_LEFT:
  695. case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_RIGHT:
  696. case GDScriptTokenizer::TK_OP_ASSIGN_SUB:
  697. case GDScriptTokenizer::TK_OP_ASSIGN: {
  698. // Assignment is not really usage
  699. current_function->arguments_usage.write[arg_idx] = current_function->arguments_usage[arg_idx] - 1;
  700. } break;
  701. default: {
  702. current_function->arguments_usage.write[arg_idx] = current_function->arguments_usage[arg_idx] + 1;
  703. }
  704. }
  705. }
  706. }
  707. #endif // DEBUG_ENABLED
  708. IdentifierNode *id = alloc_node<IdentifierNode>();
  709. id->name = identifier;
  710. id->line = id_line;
  711. expr = id;
  712. }
  713. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ADD || tokenizer->get_token() == GDScriptTokenizer::TK_OP_SUB || tokenizer->get_token() == GDScriptTokenizer::TK_OP_NOT || tokenizer->get_token() == GDScriptTokenizer::TK_OP_BIT_INVERT) {
  714. //single prefix operators like !expr +expr -expr ++expr --expr
  715. alloc_node<OperatorNode>();
  716. Expression e;
  717. e.is_op = true;
  718. switch (tokenizer->get_token()) {
  719. case GDScriptTokenizer::TK_OP_ADD: e.op = OperatorNode::OP_POS; break;
  720. case GDScriptTokenizer::TK_OP_SUB: e.op = OperatorNode::OP_NEG; break;
  721. case GDScriptTokenizer::TK_OP_NOT: e.op = OperatorNode::OP_NOT; break;
  722. case GDScriptTokenizer::TK_OP_BIT_INVERT: e.op = OperatorNode::OP_BIT_INVERT; break;
  723. default: {}
  724. }
  725. tokenizer->advance();
  726. if (e.op != OperatorNode::OP_NOT && tokenizer->get_token() == GDScriptTokenizer::TK_OP_NOT) {
  727. _set_error("Misplaced 'not'.");
  728. return NULL;
  729. }
  730. expression.push_back(e);
  731. continue; //only exception, must continue...
  732. /*
  733. Node *subexpr=_parse_expression(op,p_static);
  734. if (!subexpr)
  735. return NULL;
  736. op->arguments.push_back(subexpr);
  737. expr=op;*/
  738. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_IS && tokenizer->get_token(1) == GDScriptTokenizer::TK_BUILT_IN_TYPE) {
  739. // 'is' operator with built-in type
  740. OperatorNode *op = alloc_node<OperatorNode>();
  741. op->op = OperatorNode::OP_IS_BUILTIN;
  742. op->arguments.push_back(expr);
  743. tokenizer->advance();
  744. TypeNode *tn = alloc_node<TypeNode>();
  745. tn->vtype = tokenizer->get_token_type();
  746. op->arguments.push_back(tn);
  747. tokenizer->advance();
  748. expr = op;
  749. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_OPEN) {
  750. // array
  751. tokenizer->advance();
  752. ArrayNode *arr = alloc_node<ArrayNode>();
  753. bool expecting_comma = false;
  754. while (true) {
  755. if (tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
  756. _set_error("Unterminated array");
  757. return NULL;
  758. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_CLOSE) {
  759. tokenizer->advance();
  760. break;
  761. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
  762. tokenizer->advance(); //ignore newline
  763. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  764. if (!expecting_comma) {
  765. _set_error("expression or ']' expected");
  766. return NULL;
  767. }
  768. expecting_comma = false;
  769. tokenizer->advance(); //ignore newline
  770. } else {
  771. //parse expression
  772. if (expecting_comma) {
  773. _set_error("',' or ']' expected");
  774. return NULL;
  775. }
  776. Node *n = _parse_expression(arr, p_static, p_allow_assign, p_parsing_constant);
  777. if (!n)
  778. return NULL;
  779. arr->elements.push_back(n);
  780. expecting_comma = true;
  781. }
  782. }
  783. expr = arr;
  784. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_OPEN) {
  785. // array
  786. tokenizer->advance();
  787. DictionaryNode *dict = alloc_node<DictionaryNode>();
  788. enum DictExpect {
  789. DICT_EXPECT_KEY,
  790. DICT_EXPECT_COLON,
  791. DICT_EXPECT_VALUE,
  792. DICT_EXPECT_COMMA
  793. };
  794. Node *key = NULL;
  795. Set<Variant> keys;
  796. DictExpect expecting = DICT_EXPECT_KEY;
  797. while (true) {
  798. if (tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
  799. _set_error("Unterminated dictionary");
  800. return NULL;
  801. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
  802. if (expecting == DICT_EXPECT_COLON) {
  803. _set_error("':' expected");
  804. return NULL;
  805. }
  806. if (expecting == DICT_EXPECT_VALUE) {
  807. _set_error("value expected");
  808. return NULL;
  809. }
  810. tokenizer->advance();
  811. break;
  812. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
  813. tokenizer->advance(); //ignore newline
  814. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  815. if (expecting == DICT_EXPECT_KEY) {
  816. _set_error("key or '}' expected");
  817. return NULL;
  818. }
  819. if (expecting == DICT_EXPECT_VALUE) {
  820. _set_error("value expected");
  821. return NULL;
  822. }
  823. if (expecting == DICT_EXPECT_COLON) {
  824. _set_error("':' expected");
  825. return NULL;
  826. }
  827. expecting = DICT_EXPECT_KEY;
  828. tokenizer->advance(); //ignore newline
  829. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
  830. if (expecting == DICT_EXPECT_KEY) {
  831. _set_error("key or '}' expected");
  832. return NULL;
  833. }
  834. if (expecting == DICT_EXPECT_VALUE) {
  835. _set_error("value expected");
  836. return NULL;
  837. }
  838. if (expecting == DICT_EXPECT_COMMA) {
  839. _set_error("',' or '}' expected");
  840. return NULL;
  841. }
  842. expecting = DICT_EXPECT_VALUE;
  843. tokenizer->advance(); //ignore newline
  844. } else {
  845. if (expecting == DICT_EXPECT_COMMA) {
  846. _set_error("',' or '}' expected");
  847. return NULL;
  848. }
  849. if (expecting == DICT_EXPECT_COLON) {
  850. _set_error("':' expected");
  851. return NULL;
  852. }
  853. if (expecting == DICT_EXPECT_KEY) {
  854. if (tokenizer->is_token_literal() && tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
  855. // We check with is_token_literal, as this allows us to use match/sync/etc. as a name
  856. //lua style identifier, easier to write
  857. ConstantNode *cn = alloc_node<ConstantNode>();
  858. cn->value = tokenizer->get_token_literal();
  859. cn->datatype = _type_from_variant(cn->value);
  860. key = cn;
  861. tokenizer->advance(2);
  862. expecting = DICT_EXPECT_VALUE;
  863. } else {
  864. //python/js style more flexible
  865. key = _parse_expression(dict, p_static, p_allow_assign, p_parsing_constant);
  866. if (!key)
  867. return NULL;
  868. expecting = DICT_EXPECT_COLON;
  869. }
  870. }
  871. if (expecting == DICT_EXPECT_VALUE) {
  872. Node *value = _parse_expression(dict, p_static, p_allow_assign, p_parsing_constant);
  873. if (!value)
  874. return NULL;
  875. expecting = DICT_EXPECT_COMMA;
  876. if (key->type == GDScriptParser::Node::TYPE_CONSTANT) {
  877. Variant const &keyName = static_cast<const GDScriptParser::ConstantNode *>(key)->value;
  878. if (keys.has(keyName)) {
  879. _set_error("Duplicate key found in Dictionary literal");
  880. return NULL;
  881. }
  882. keys.insert(keyName);
  883. }
  884. DictionaryNode::Pair pair;
  885. pair.key = key;
  886. pair.value = value;
  887. dict->elements.push_back(pair);
  888. key = NULL;
  889. }
  890. }
  891. }
  892. expr = dict;
  893. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD && (tokenizer->is_token_literal(1) || tokenizer->get_token(1) == GDScriptTokenizer::TK_CURSOR)) {
  894. // We check with is_token_literal, as this allows us to use match/sync/etc. as a name
  895. // parent call
  896. tokenizer->advance(); //goto identifier
  897. OperatorNode *op = alloc_node<OperatorNode>();
  898. op->op = OperatorNode::OP_PARENT_CALL;
  899. /*SelfNode *self = alloc_node<SelfNode>();
  900. op->arguments.push_back(self);
  901. forbidden for now */
  902. StringName identifier;
  903. bool is_completion = _get_completable_identifier(COMPLETION_PARENT_FUNCTION, identifier) && for_completion;
  904. IdentifierNode *id = alloc_node<IdentifierNode>();
  905. id->name = identifier;
  906. op->arguments.push_back(id);
  907. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
  908. if (!is_completion) {
  909. _set_error("Expected '(' for parent function call.");
  910. return NULL;
  911. }
  912. } else {
  913. tokenizer->advance();
  914. if (!_parse_arguments(op, op->arguments, p_static)) {
  915. return NULL;
  916. }
  917. }
  918. expr = op;
  919. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE && expression.size() > 0 && expression[expression.size() - 1].is_op && expression[expression.size() - 1].op == OperatorNode::OP_IS) {
  920. Expression e = expression[expression.size() - 1];
  921. e.op = OperatorNode::OP_IS_BUILTIN;
  922. expression.write[expression.size() - 1] = e;
  923. TypeNode *tn = alloc_node<TypeNode>();
  924. tn->vtype = tokenizer->get_token_type();
  925. expr = tn;
  926. tokenizer->advance();
  927. } else {
  928. //find list [ or find dictionary {
  929. _set_error("Error parsing expression, misplaced: " + String(tokenizer->get_token_name(tokenizer->get_token())));
  930. return NULL; //nothing
  931. }
  932. if (!expr) {
  933. ERR_EXPLAIN("GDScriptParser bug, couldn't figure out what expression is...");
  934. ERR_FAIL_COND_V(!expr, NULL);
  935. }
  936. /******************/
  937. /* Parse Indexing */
  938. /******************/
  939. while (true) {
  940. //expressions can be indexed any number of times
  941. if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD) {
  942. //indexing using "."
  943. if (tokenizer->get_token(1) != GDScriptTokenizer::TK_CURSOR && !tokenizer->is_token_literal(1)) {
  944. // We check with is_token_literal, as this allows us to use match/sync/etc. as a name
  945. _set_error("Expected identifier as member");
  946. return NULL;
  947. } else if (tokenizer->get_token(2) == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
  948. //call!!
  949. OperatorNode *op = alloc_node<OperatorNode>();
  950. op->op = OperatorNode::OP_CALL;
  951. tokenizer->advance();
  952. IdentifierNode *id = alloc_node<IdentifierNode>();
  953. if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_FUNC) {
  954. //small hack so built in funcs don't obfuscate methods
  955. id->name = GDScriptFunctions::get_func_name(tokenizer->get_token_built_in_func());
  956. tokenizer->advance();
  957. } else {
  958. StringName identifier;
  959. if (_get_completable_identifier(COMPLETION_METHOD, identifier)) {
  960. completion_node = op;
  961. //indexing stuff
  962. }
  963. id->name = identifier;
  964. }
  965. op->arguments.push_back(expr); // call what
  966. op->arguments.push_back(id); // call func
  967. //get arguments
  968. tokenizer->advance(1);
  969. if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
  970. _make_completable_call(0);
  971. completion_node = op;
  972. }
  973. if (!_parse_arguments(op, op->arguments, p_static, true))
  974. return NULL;
  975. expr = op;
  976. } else {
  977. //simple indexing!
  978. OperatorNode *op = alloc_node<OperatorNode>();
  979. op->op = OperatorNode::OP_INDEX_NAMED;
  980. tokenizer->advance();
  981. StringName identifier;
  982. if (_get_completable_identifier(COMPLETION_INDEX, identifier)) {
  983. if (identifier == StringName()) {
  984. identifier = "@temp"; //so it parses allright
  985. }
  986. completion_node = op;
  987. //indexing stuff
  988. }
  989. IdentifierNode *id = alloc_node<IdentifierNode>();
  990. id->name = identifier;
  991. op->arguments.push_back(expr);
  992. op->arguments.push_back(id);
  993. expr = op;
  994. }
  995. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_OPEN) {
  996. //indexing using "[]"
  997. OperatorNode *op = alloc_node<OperatorNode>();
  998. op->op = OperatorNode::OP_INDEX;
  999. tokenizer->advance(1);
  1000. Node *subexpr = _parse_expression(op, p_static, p_allow_assign, p_parsing_constant);
  1001. if (!subexpr) {
  1002. return NULL;
  1003. }
  1004. if (tokenizer->get_token() != GDScriptTokenizer::TK_BRACKET_CLOSE) {
  1005. _set_error("Expected ']'");
  1006. return NULL;
  1007. }
  1008. op->arguments.push_back(expr);
  1009. op->arguments.push_back(subexpr);
  1010. tokenizer->advance(1);
  1011. expr = op;
  1012. } else
  1013. break;
  1014. }
  1015. /*****************/
  1016. /* Parse Casting */
  1017. /*****************/
  1018. bool has_casting = expr->type == Node::TYPE_CAST;
  1019. if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_AS) {
  1020. if (has_casting) {
  1021. _set_error("Unexpected 'as'.");
  1022. return NULL;
  1023. }
  1024. CastNode *cn = alloc_node<CastNode>();
  1025. if (!_parse_type(cn->cast_type)) {
  1026. _set_error("Expected type after 'as'.");
  1027. return NULL;
  1028. }
  1029. has_casting = true;
  1030. cn->source_node = expr;
  1031. expr = cn;
  1032. }
  1033. /******************/
  1034. /* Parse Operator */
  1035. /******************/
  1036. if (parenthesis > 0) {
  1037. //remove empty space (only allowed if inside parenthesis
  1038. while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
  1039. tokenizer->advance();
  1040. }
  1041. }
  1042. Expression e;
  1043. e.is_op = false;
  1044. e.node = expr;
  1045. expression.push_back(e);
  1046. // determine which operator is next
  1047. OperatorNode::Operator op;
  1048. bool valid = true;
  1049. //assign, if allowed is only allowed on the first operator
  1050. #define _VALIDATE_ASSIGN \
  1051. if (!p_allow_assign || has_casting) { \
  1052. _set_error("Unexpected assign."); \
  1053. return NULL; \
  1054. } \
  1055. p_allow_assign = false;
  1056. switch (tokenizer->get_token()) { //see operator
  1057. case GDScriptTokenizer::TK_OP_IN: op = OperatorNode::OP_IN; break;
  1058. case GDScriptTokenizer::TK_OP_EQUAL: op = OperatorNode::OP_EQUAL; break;
  1059. case GDScriptTokenizer::TK_OP_NOT_EQUAL: op = OperatorNode::OP_NOT_EQUAL; break;
  1060. case GDScriptTokenizer::TK_OP_LESS: op = OperatorNode::OP_LESS; break;
  1061. case GDScriptTokenizer::TK_OP_LESS_EQUAL: op = OperatorNode::OP_LESS_EQUAL; break;
  1062. case GDScriptTokenizer::TK_OP_GREATER: op = OperatorNode::OP_GREATER; break;
  1063. case GDScriptTokenizer::TK_OP_GREATER_EQUAL: op = OperatorNode::OP_GREATER_EQUAL; break;
  1064. case GDScriptTokenizer::TK_OP_AND: op = OperatorNode::OP_AND; break;
  1065. case GDScriptTokenizer::TK_OP_OR: op = OperatorNode::OP_OR; break;
  1066. case GDScriptTokenizer::TK_OP_ADD: op = OperatorNode::OP_ADD; break;
  1067. case GDScriptTokenizer::TK_OP_SUB: op = OperatorNode::OP_SUB; break;
  1068. case GDScriptTokenizer::TK_OP_MUL: op = OperatorNode::OP_MUL; break;
  1069. case GDScriptTokenizer::TK_OP_DIV: op = OperatorNode::OP_DIV; break;
  1070. case GDScriptTokenizer::TK_OP_MOD:
  1071. op = OperatorNode::OP_MOD;
  1072. break;
  1073. //case GDScriptTokenizer::TK_OP_NEG: op=OperatorNode::OP_NEG ; break;
  1074. case GDScriptTokenizer::TK_OP_SHIFT_LEFT: op = OperatorNode::OP_SHIFT_LEFT; break;
  1075. case GDScriptTokenizer::TK_OP_SHIFT_RIGHT: op = OperatorNode::OP_SHIFT_RIGHT; break;
  1076. case GDScriptTokenizer::TK_OP_ASSIGN: {
  1077. _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN;
  1078. if (tokenizer->get_token(1) == GDScriptTokenizer::TK_CURSOR) {
  1079. //code complete assignment
  1080. completion_type = COMPLETION_ASSIGN;
  1081. completion_node = expr;
  1082. completion_class = current_class;
  1083. completion_function = current_function;
  1084. completion_line = tokenizer->get_token_line();
  1085. completion_block = current_block;
  1086. completion_found = true;
  1087. tokenizer->advance();
  1088. }
  1089. } break;
  1090. case GDScriptTokenizer::TK_OP_ASSIGN_ADD: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_ADD; break;
  1091. case GDScriptTokenizer::TK_OP_ASSIGN_SUB: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_SUB; break;
  1092. case GDScriptTokenizer::TK_OP_ASSIGN_MUL: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_MUL; break;
  1093. case GDScriptTokenizer::TK_OP_ASSIGN_DIV: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_DIV; break;
  1094. case GDScriptTokenizer::TK_OP_ASSIGN_MOD: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_MOD; break;
  1095. case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_LEFT: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_SHIFT_LEFT; break;
  1096. case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_RIGHT: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_SHIFT_RIGHT; break;
  1097. case GDScriptTokenizer::TK_OP_ASSIGN_BIT_AND: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_BIT_AND; break;
  1098. case GDScriptTokenizer::TK_OP_ASSIGN_BIT_OR: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_BIT_OR; break;
  1099. case GDScriptTokenizer::TK_OP_ASSIGN_BIT_XOR: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_BIT_XOR; break;
  1100. case GDScriptTokenizer::TK_OP_BIT_AND: op = OperatorNode::OP_BIT_AND; break;
  1101. case GDScriptTokenizer::TK_OP_BIT_OR: op = OperatorNode::OP_BIT_OR; break;
  1102. case GDScriptTokenizer::TK_OP_BIT_XOR: op = OperatorNode::OP_BIT_XOR; break;
  1103. case GDScriptTokenizer::TK_PR_IS: op = OperatorNode::OP_IS; break;
  1104. case GDScriptTokenizer::TK_CF_IF: op = OperatorNode::OP_TERNARY_IF; break;
  1105. case GDScriptTokenizer::TK_CF_ELSE: op = OperatorNode::OP_TERNARY_ELSE; break;
  1106. default: valid = false; break;
  1107. }
  1108. if (valid) {
  1109. e.is_op = true;
  1110. e.op = op;
  1111. expression.push_back(e);
  1112. tokenizer->advance();
  1113. } else {
  1114. break;
  1115. }
  1116. }
  1117. /* Reduce the set set of expressions and place them in an operator tree, respecting precedence */
  1118. while (expression.size() > 1) {
  1119. int next_op = -1;
  1120. int min_priority = 0xFFFFF;
  1121. bool is_unary = false;
  1122. bool is_ternary = false;
  1123. for (int i = 0; i < expression.size(); i++) {
  1124. if (!expression[i].is_op) {
  1125. continue;
  1126. }
  1127. int priority;
  1128. bool unary = false;
  1129. bool ternary = false;
  1130. bool error = false;
  1131. bool right_to_left = false;
  1132. switch (expression[i].op) {
  1133. case OperatorNode::OP_IS:
  1134. case OperatorNode::OP_IS_BUILTIN:
  1135. priority = -1;
  1136. break; //before anything
  1137. case OperatorNode::OP_BIT_INVERT:
  1138. priority = 0;
  1139. unary = true;
  1140. break;
  1141. case OperatorNode::OP_NEG:
  1142. priority = 1;
  1143. unary = true;
  1144. break;
  1145. case OperatorNode::OP_POS:
  1146. priority = 1;
  1147. unary = true;
  1148. break;
  1149. case OperatorNode::OP_MUL: priority = 2; break;
  1150. case OperatorNode::OP_DIV: priority = 2; break;
  1151. case OperatorNode::OP_MOD: priority = 2; break;
  1152. case OperatorNode::OP_ADD: priority = 3; break;
  1153. case OperatorNode::OP_SUB: priority = 3; break;
  1154. case OperatorNode::OP_SHIFT_LEFT: priority = 4; break;
  1155. case OperatorNode::OP_SHIFT_RIGHT: priority = 4; break;
  1156. case OperatorNode::OP_BIT_AND: priority = 5; break;
  1157. case OperatorNode::OP_BIT_XOR: priority = 6; break;
  1158. case OperatorNode::OP_BIT_OR: priority = 7; break;
  1159. case OperatorNode::OP_LESS: priority = 8; break;
  1160. case OperatorNode::OP_LESS_EQUAL: priority = 8; break;
  1161. case OperatorNode::OP_GREATER: priority = 8; break;
  1162. case OperatorNode::OP_GREATER_EQUAL: priority = 8; break;
  1163. case OperatorNode::OP_EQUAL: priority = 8; break;
  1164. case OperatorNode::OP_NOT_EQUAL: priority = 8; break;
  1165. case OperatorNode::OP_IN: priority = 10; break;
  1166. case OperatorNode::OP_NOT:
  1167. priority = 11;
  1168. unary = true;
  1169. break;
  1170. case OperatorNode::OP_AND: priority = 12; break;
  1171. case OperatorNode::OP_OR: priority = 13; break;
  1172. case OperatorNode::OP_TERNARY_IF:
  1173. priority = 14;
  1174. ternary = true;
  1175. right_to_left = true;
  1176. break;
  1177. case OperatorNode::OP_TERNARY_ELSE:
  1178. priority = 14;
  1179. error = true;
  1180. // Rigth-to-left should be false in this case, otherwise it would always error.
  1181. break;
  1182. case OperatorNode::OP_ASSIGN: priority = 15; break;
  1183. case OperatorNode::OP_ASSIGN_ADD: priority = 15; break;
  1184. case OperatorNode::OP_ASSIGN_SUB: priority = 15; break;
  1185. case OperatorNode::OP_ASSIGN_MUL: priority = 15; break;
  1186. case OperatorNode::OP_ASSIGN_DIV: priority = 15; break;
  1187. case OperatorNode::OP_ASSIGN_MOD: priority = 15; break;
  1188. case OperatorNode::OP_ASSIGN_SHIFT_LEFT: priority = 15; break;
  1189. case OperatorNode::OP_ASSIGN_SHIFT_RIGHT: priority = 15; break;
  1190. case OperatorNode::OP_ASSIGN_BIT_AND: priority = 15; break;
  1191. case OperatorNode::OP_ASSIGN_BIT_OR: priority = 15; break;
  1192. case OperatorNode::OP_ASSIGN_BIT_XOR: priority = 15; break;
  1193. default: {
  1194. _set_error("GDScriptParser bug, invalid operator in expression: " + itos(expression[i].op));
  1195. return NULL;
  1196. }
  1197. }
  1198. if (priority < min_priority || (right_to_left && priority == min_priority)) {
  1199. // < is used for left to right (default)
  1200. // <= is used for right to left
  1201. if (error) {
  1202. _set_error("Unexpected operator");
  1203. return NULL;
  1204. }
  1205. next_op = i;
  1206. min_priority = priority;
  1207. is_unary = unary;
  1208. is_ternary = ternary;
  1209. }
  1210. }
  1211. if (next_op == -1) {
  1212. _set_error("Yet another parser bug....");
  1213. ERR_FAIL_COND_V(next_op == -1, NULL);
  1214. }
  1215. // OK! create operator..
  1216. if (is_unary) {
  1217. int expr_pos = next_op;
  1218. while (expression[expr_pos].is_op) {
  1219. expr_pos++;
  1220. if (expr_pos == expression.size()) {
  1221. //can happen..
  1222. _set_error("Unexpected end of expression...");
  1223. return NULL;
  1224. }
  1225. }
  1226. //consecutively do unary opeators
  1227. for (int i = expr_pos - 1; i >= next_op; i--) {
  1228. OperatorNode *op = alloc_node<OperatorNode>();
  1229. op->op = expression[i].op;
  1230. op->arguments.push_back(expression[i + 1].node);
  1231. op->line = op_line; //line might have been changed from a \n
  1232. expression.write[i].is_op = false;
  1233. expression.write[i].node = op;
  1234. expression.remove(i + 1);
  1235. }
  1236. } else if (is_ternary) {
  1237. if (next_op < 1 || next_op >= (expression.size() - 1)) {
  1238. _set_error("Parser bug...");
  1239. ERR_FAIL_V(NULL);
  1240. }
  1241. if (next_op >= (expression.size() - 2) || expression[next_op + 2].op != OperatorNode::OP_TERNARY_ELSE) {
  1242. _set_error("Expected else after ternary if.");
  1243. return NULL;
  1244. }
  1245. if (next_op >= (expression.size() - 3)) {
  1246. _set_error("Expected value after ternary else.");
  1247. return NULL;
  1248. }
  1249. OperatorNode *op = alloc_node<OperatorNode>();
  1250. op->op = expression[next_op].op;
  1251. op->line = op_line; //line might have been changed from a \n
  1252. if (expression[next_op - 1].is_op) {
  1253. _set_error("Parser bug...");
  1254. ERR_FAIL_V(NULL);
  1255. }
  1256. if (expression[next_op + 1].is_op) {
  1257. // this is not invalid and can really appear
  1258. // but it becomes invalid anyway because no binary op
  1259. // can be followed by a unary op in a valid combination,
  1260. // due to how precedence works, unaries will always disappear first
  1261. _set_error("Unexpected two consecutive operators after ternary if.");
  1262. return NULL;
  1263. }
  1264. if (expression[next_op + 3].is_op) {
  1265. // this is not invalid and can really appear
  1266. // but it becomes invalid anyway because no binary op
  1267. // can be followed by a unary op in a valid combination,
  1268. // due to how precedence works, unaries will always disappear first
  1269. _set_error("Unexpected two consecutive operators after ternary else.");
  1270. return NULL;
  1271. }
  1272. op->arguments.push_back(expression[next_op + 1].node); //next expression goes as first
  1273. op->arguments.push_back(expression[next_op - 1].node); //left expression goes as when-true
  1274. op->arguments.push_back(expression[next_op + 3].node); //expression after next goes as when-false
  1275. //replace all 3 nodes by this operator and make it an expression
  1276. expression.write[next_op - 1].node = op;
  1277. expression.remove(next_op);
  1278. expression.remove(next_op);
  1279. expression.remove(next_op);
  1280. expression.remove(next_op);
  1281. } else {
  1282. if (next_op < 1 || next_op >= (expression.size() - 1)) {
  1283. _set_error("Parser bug...");
  1284. ERR_FAIL_V(NULL);
  1285. }
  1286. OperatorNode *op = alloc_node<OperatorNode>();
  1287. op->op = expression[next_op].op;
  1288. op->line = op_line; //line might have been changed from a \n
  1289. if (expression[next_op - 1].is_op) {
  1290. _set_error("Parser bug...");
  1291. ERR_FAIL_V(NULL);
  1292. }
  1293. if (expression[next_op + 1].is_op) {
  1294. // this is not invalid and can really appear
  1295. // but it becomes invalid anyway because no binary op
  1296. // can be followed by a unary op in a valid combination,
  1297. // due to how precedence works, unaries will always disappear first
  1298. _set_error("Unexpected two consecutive operators.");
  1299. return NULL;
  1300. }
  1301. op->arguments.push_back(expression[next_op - 1].node); //expression goes as left
  1302. op->arguments.push_back(expression[next_op + 1].node); //next expression goes as right
  1303. //replace all 3 nodes by this operator and make it an expression
  1304. expression.write[next_op - 1].node = op;
  1305. expression.remove(next_op);
  1306. expression.remove(next_op);
  1307. }
  1308. }
  1309. return expression[0].node;
  1310. }
  1311. GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to_const) {
  1312. switch (p_node->type) {
  1313. case Node::TYPE_BUILT_IN_FUNCTION: {
  1314. //many may probably be optimizable
  1315. return p_node;
  1316. } break;
  1317. case Node::TYPE_ARRAY: {
  1318. ArrayNode *an = static_cast<ArrayNode *>(p_node);
  1319. bool all_constants = true;
  1320. for (int i = 0; i < an->elements.size(); i++) {
  1321. an->elements.write[i] = _reduce_expression(an->elements[i], p_to_const);
  1322. if (an->elements[i]->type != Node::TYPE_CONSTANT)
  1323. all_constants = false;
  1324. }
  1325. if (all_constants && p_to_const) {
  1326. //reduce constant array expression
  1327. ConstantNode *cn = alloc_node<ConstantNode>();
  1328. Array arr;
  1329. arr.resize(an->elements.size());
  1330. for (int i = 0; i < an->elements.size(); i++) {
  1331. ConstantNode *acn = static_cast<ConstantNode *>(an->elements[i]);
  1332. arr[i] = acn->value;
  1333. }
  1334. cn->value = arr;
  1335. cn->datatype = _type_from_variant(cn->value);
  1336. return cn;
  1337. }
  1338. return an;
  1339. } break;
  1340. case Node::TYPE_DICTIONARY: {
  1341. DictionaryNode *dn = static_cast<DictionaryNode *>(p_node);
  1342. bool all_constants = true;
  1343. for (int i = 0; i < dn->elements.size(); i++) {
  1344. dn->elements.write[i].key = _reduce_expression(dn->elements[i].key, p_to_const);
  1345. if (dn->elements[i].key->type != Node::TYPE_CONSTANT)
  1346. all_constants = false;
  1347. dn->elements.write[i].value = _reduce_expression(dn->elements[i].value, p_to_const);
  1348. if (dn->elements[i].value->type != Node::TYPE_CONSTANT)
  1349. all_constants = false;
  1350. }
  1351. if (all_constants && p_to_const) {
  1352. //reduce constant array expression
  1353. ConstantNode *cn = alloc_node<ConstantNode>();
  1354. Dictionary dict;
  1355. for (int i = 0; i < dn->elements.size(); i++) {
  1356. ConstantNode *key_c = static_cast<ConstantNode *>(dn->elements[i].key);
  1357. ConstantNode *value_c = static_cast<ConstantNode *>(dn->elements[i].value);
  1358. dict[key_c->value] = value_c->value;
  1359. }
  1360. cn->value = dict;
  1361. cn->datatype = _type_from_variant(cn->value);
  1362. return cn;
  1363. }
  1364. return dn;
  1365. } break;
  1366. case Node::TYPE_OPERATOR: {
  1367. OperatorNode *op = static_cast<OperatorNode *>(p_node);
  1368. bool all_constants = true;
  1369. int last_not_constant = -1;
  1370. for (int i = 0; i < op->arguments.size(); i++) {
  1371. op->arguments.write[i] = _reduce_expression(op->arguments[i], p_to_const);
  1372. if (op->arguments[i]->type != Node::TYPE_CONSTANT) {
  1373. all_constants = false;
  1374. last_not_constant = i;
  1375. }
  1376. }
  1377. if (op->op == OperatorNode::OP_IS) {
  1378. //nothing much
  1379. return op;
  1380. }
  1381. if (op->op == OperatorNode::OP_PARENT_CALL) {
  1382. //nothing much
  1383. return op;
  1384. } else if (op->op == OperatorNode::OP_CALL) {
  1385. //can reduce base type constructors
  1386. if ((op->arguments[0]->type == Node::TYPE_TYPE || (op->arguments[0]->type == Node::TYPE_BUILT_IN_FUNCTION && GDScriptFunctions::is_deterministic(static_cast<BuiltInFunctionNode *>(op->arguments[0])->function))) && last_not_constant == 0) {
  1387. //native type constructor or intrinsic function
  1388. const Variant **vptr = NULL;
  1389. Vector<Variant *> ptrs;
  1390. if (op->arguments.size() > 1) {
  1391. ptrs.resize(op->arguments.size() - 1);
  1392. for (int i = 0; i < ptrs.size(); i++) {
  1393. ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[i + 1]);
  1394. ptrs.write[i] = &cn->value;
  1395. }
  1396. vptr = (const Variant **)&ptrs[0];
  1397. }
  1398. Variant::CallError ce;
  1399. Variant v;
  1400. if (op->arguments[0]->type == Node::TYPE_TYPE) {
  1401. TypeNode *tn = static_cast<TypeNode *>(op->arguments[0]);
  1402. v = Variant::construct(tn->vtype, vptr, ptrs.size(), ce);
  1403. } else {
  1404. GDScriptFunctions::Function func = static_cast<BuiltInFunctionNode *>(op->arguments[0])->function;
  1405. GDScriptFunctions::call(func, vptr, ptrs.size(), v, ce);
  1406. }
  1407. if (ce.error != Variant::CallError::CALL_OK) {
  1408. String errwhere;
  1409. if (op->arguments[0]->type == Node::TYPE_TYPE) {
  1410. TypeNode *tn = static_cast<TypeNode *>(op->arguments[0]);
  1411. errwhere = "'" + Variant::get_type_name(tn->vtype) + "' constructor";
  1412. } else {
  1413. GDScriptFunctions::Function func = static_cast<BuiltInFunctionNode *>(op->arguments[0])->function;
  1414. errwhere = String("'") + GDScriptFunctions::get_func_name(func) + "' intrinsic function";
  1415. }
  1416. switch (ce.error) {
  1417. case Variant::CallError::CALL_ERROR_INVALID_ARGUMENT: {
  1418. _set_error("Invalid argument (#" + itos(ce.argument + 1) + ") for " + errwhere + ".");
  1419. } break;
  1420. case Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS: {
  1421. _set_error("Too many arguments for " + errwhere + ".");
  1422. } break;
  1423. case Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS: {
  1424. _set_error("Too few arguments for " + errwhere + ".");
  1425. } break;
  1426. default: {
  1427. _set_error("Invalid arguments for " + errwhere + ".");
  1428. } break;
  1429. }
  1430. error_line = op->line;
  1431. return p_node;
  1432. }
  1433. ConstantNode *cn = alloc_node<ConstantNode>();
  1434. cn->value = v;
  1435. cn->datatype = _type_from_variant(v);
  1436. return cn;
  1437. } else if (op->arguments[0]->type == Node::TYPE_BUILT_IN_FUNCTION && last_not_constant == 0) {
  1438. }
  1439. return op; //don't reduce yet
  1440. } else if (op->op == OperatorNode::OP_YIELD) {
  1441. return op;
  1442. } else if (op->op == OperatorNode::OP_INDEX) {
  1443. //can reduce indices into constant arrays or dictionaries
  1444. if (all_constants) {
  1445. ConstantNode *ca = static_cast<ConstantNode *>(op->arguments[0]);
  1446. ConstantNode *cb = static_cast<ConstantNode *>(op->arguments[1]);
  1447. bool valid;
  1448. Variant v = ca->value.get(cb->value, &valid);
  1449. if (!valid) {
  1450. _set_error("invalid index in constant expression");
  1451. error_line = op->line;
  1452. return op;
  1453. }
  1454. ConstantNode *cn = alloc_node<ConstantNode>();
  1455. cn->value = v;
  1456. cn->datatype = _type_from_variant(v);
  1457. return cn;
  1458. }
  1459. return op;
  1460. } else if (op->op == OperatorNode::OP_INDEX_NAMED) {
  1461. if (op->arguments[0]->type == Node::TYPE_CONSTANT && op->arguments[1]->type == Node::TYPE_IDENTIFIER) {
  1462. ConstantNode *ca = static_cast<ConstantNode *>(op->arguments[0]);
  1463. IdentifierNode *ib = static_cast<IdentifierNode *>(op->arguments[1]);
  1464. bool valid;
  1465. Variant v = ca->value.get_named(ib->name, &valid);
  1466. if (!valid) {
  1467. _set_error("invalid index '" + String(ib->name) + "' in constant expression");
  1468. error_line = op->line;
  1469. return op;
  1470. }
  1471. ConstantNode *cn = alloc_node<ConstantNode>();
  1472. cn->value = v;
  1473. cn->datatype = _type_from_variant(v);
  1474. return cn;
  1475. }
  1476. return op;
  1477. }
  1478. //validate assignment (don't assign to constant expression
  1479. switch (op->op) {
  1480. case OperatorNode::OP_ASSIGN:
  1481. case OperatorNode::OP_ASSIGN_ADD:
  1482. case OperatorNode::OP_ASSIGN_SUB:
  1483. case OperatorNode::OP_ASSIGN_MUL:
  1484. case OperatorNode::OP_ASSIGN_DIV:
  1485. case OperatorNode::OP_ASSIGN_MOD:
  1486. case OperatorNode::OP_ASSIGN_SHIFT_LEFT:
  1487. case OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
  1488. case OperatorNode::OP_ASSIGN_BIT_AND:
  1489. case OperatorNode::OP_ASSIGN_BIT_OR:
  1490. case OperatorNode::OP_ASSIGN_BIT_XOR: {
  1491. if (op->arguments[0]->type == Node::TYPE_CONSTANT) {
  1492. _set_error("Can't assign to constant", tokenizer->get_token_line() - 1);
  1493. error_line = op->line;
  1494. return op;
  1495. }
  1496. if (op->arguments[0]->type == Node::TYPE_OPERATOR) {
  1497. OperatorNode *on = static_cast<OperatorNode *>(op->arguments[0]);
  1498. if (on->op != OperatorNode::OP_INDEX && on->op != OperatorNode::OP_INDEX_NAMED) {
  1499. _set_error("Can't assign to an expression", tokenizer->get_token_line() - 1);
  1500. error_line = op->line;
  1501. return op;
  1502. }
  1503. }
  1504. } break;
  1505. default: { break; }
  1506. }
  1507. //now se if all are constants
  1508. if (!all_constants)
  1509. return op; //nothing to reduce from here on
  1510. #define _REDUCE_UNARY(m_vop) \
  1511. bool valid = false; \
  1512. Variant res; \
  1513. Variant::evaluate(m_vop, static_cast<ConstantNode *>(op->arguments[0])->value, Variant(), res, valid); \
  1514. if (!valid) { \
  1515. _set_error("Invalid operand for unary operator"); \
  1516. error_line = op->line; \
  1517. return p_node; \
  1518. } \
  1519. ConstantNode *cn = alloc_node<ConstantNode>(); \
  1520. cn->value = res; \
  1521. cn->datatype = _type_from_variant(res); \
  1522. return cn;
  1523. #define _REDUCE_BINARY(m_vop) \
  1524. bool valid = false; \
  1525. Variant res; \
  1526. Variant::evaluate(m_vop, static_cast<ConstantNode *>(op->arguments[0])->value, static_cast<ConstantNode *>(op->arguments[1])->value, res, valid); \
  1527. if (!valid) { \
  1528. _set_error("Invalid operands for operator"); \
  1529. error_line = op->line; \
  1530. return p_node; \
  1531. } \
  1532. ConstantNode *cn = alloc_node<ConstantNode>(); \
  1533. cn->value = res; \
  1534. cn->datatype = _type_from_variant(res); \
  1535. return cn;
  1536. switch (op->op) {
  1537. //unary operators
  1538. case OperatorNode::OP_NEG: {
  1539. _REDUCE_UNARY(Variant::OP_NEGATE);
  1540. } break;
  1541. case OperatorNode::OP_POS: {
  1542. _REDUCE_UNARY(Variant::OP_POSITIVE);
  1543. } break;
  1544. case OperatorNode::OP_NOT: {
  1545. _REDUCE_UNARY(Variant::OP_NOT);
  1546. } break;
  1547. case OperatorNode::OP_BIT_INVERT: {
  1548. _REDUCE_UNARY(Variant::OP_BIT_NEGATE);
  1549. } break;
  1550. //binary operators (in precedence order)
  1551. case OperatorNode::OP_IN: {
  1552. _REDUCE_BINARY(Variant::OP_IN);
  1553. } break;
  1554. case OperatorNode::OP_EQUAL: {
  1555. _REDUCE_BINARY(Variant::OP_EQUAL);
  1556. } break;
  1557. case OperatorNode::OP_NOT_EQUAL: {
  1558. _REDUCE_BINARY(Variant::OP_NOT_EQUAL);
  1559. } break;
  1560. case OperatorNode::OP_LESS: {
  1561. _REDUCE_BINARY(Variant::OP_LESS);
  1562. } break;
  1563. case OperatorNode::OP_LESS_EQUAL: {
  1564. _REDUCE_BINARY(Variant::OP_LESS_EQUAL);
  1565. } break;
  1566. case OperatorNode::OP_GREATER: {
  1567. _REDUCE_BINARY(Variant::OP_GREATER);
  1568. } break;
  1569. case OperatorNode::OP_GREATER_EQUAL: {
  1570. _REDUCE_BINARY(Variant::OP_GREATER_EQUAL);
  1571. } break;
  1572. case OperatorNode::OP_AND: {
  1573. _REDUCE_BINARY(Variant::OP_AND);
  1574. } break;
  1575. case OperatorNode::OP_OR: {
  1576. _REDUCE_BINARY(Variant::OP_OR);
  1577. } break;
  1578. case OperatorNode::OP_ADD: {
  1579. _REDUCE_BINARY(Variant::OP_ADD);
  1580. } break;
  1581. case OperatorNode::OP_SUB: {
  1582. _REDUCE_BINARY(Variant::OP_SUBTRACT);
  1583. } break;
  1584. case OperatorNode::OP_MUL: {
  1585. _REDUCE_BINARY(Variant::OP_MULTIPLY);
  1586. } break;
  1587. case OperatorNode::OP_DIV: {
  1588. _REDUCE_BINARY(Variant::OP_DIVIDE);
  1589. } break;
  1590. case OperatorNode::OP_MOD: {
  1591. _REDUCE_BINARY(Variant::OP_MODULE);
  1592. } break;
  1593. case OperatorNode::OP_SHIFT_LEFT: {
  1594. _REDUCE_BINARY(Variant::OP_SHIFT_LEFT);
  1595. } break;
  1596. case OperatorNode::OP_SHIFT_RIGHT: {
  1597. _REDUCE_BINARY(Variant::OP_SHIFT_RIGHT);
  1598. } break;
  1599. case OperatorNode::OP_BIT_AND: {
  1600. _REDUCE_BINARY(Variant::OP_BIT_AND);
  1601. } break;
  1602. case OperatorNode::OP_BIT_OR: {
  1603. _REDUCE_BINARY(Variant::OP_BIT_OR);
  1604. } break;
  1605. case OperatorNode::OP_BIT_XOR: {
  1606. _REDUCE_BINARY(Variant::OP_BIT_XOR);
  1607. } break;
  1608. case OperatorNode::OP_TERNARY_IF: {
  1609. if (static_cast<ConstantNode *>(op->arguments[0])->value.booleanize()) {
  1610. return op->arguments[1];
  1611. } else {
  1612. return op->arguments[2];
  1613. }
  1614. } break;
  1615. default: { ERR_FAIL_V(op); }
  1616. }
  1617. ERR_FAIL_V(op);
  1618. } break;
  1619. default: {
  1620. return p_node;
  1621. } break;
  1622. }
  1623. }
  1624. GDScriptParser::Node *GDScriptParser::_parse_and_reduce_expression(Node *p_parent, bool p_static, bool p_reduce_const, bool p_allow_assign) {
  1625. Node *expr = _parse_expression(p_parent, p_static, p_allow_assign, p_reduce_const);
  1626. if (!expr || error_set)
  1627. return NULL;
  1628. expr = _reduce_expression(expr, p_reduce_const);
  1629. if (!expr || error_set)
  1630. return NULL;
  1631. return expr;
  1632. }
  1633. bool GDScriptParser::_recover_from_completion() {
  1634. if (!completion_found) {
  1635. return false; //can't recover if no completion
  1636. }
  1637. //skip stuff until newline
  1638. while (tokenizer->get_token() != GDScriptTokenizer::TK_NEWLINE && tokenizer->get_token() != GDScriptTokenizer::TK_EOF && tokenizer->get_token() != GDScriptTokenizer::TK_ERROR) {
  1639. tokenizer->advance();
  1640. }
  1641. completion_found = false;
  1642. error_set = false;
  1643. if (tokenizer->get_token() == GDScriptTokenizer::TK_ERROR) {
  1644. error_set = true;
  1645. }
  1646. return true;
  1647. }
  1648. GDScriptParser::PatternNode *GDScriptParser::_parse_pattern(bool p_static) {
  1649. PatternNode *pattern = alloc_node<PatternNode>();
  1650. GDScriptTokenizer::Token token = tokenizer->get_token();
  1651. if (error_set)
  1652. return NULL;
  1653. if (token == GDScriptTokenizer::TK_EOF) {
  1654. return NULL;
  1655. }
  1656. switch (token) {
  1657. // array
  1658. case GDScriptTokenizer::TK_BRACKET_OPEN: {
  1659. tokenizer->advance();
  1660. pattern->pt_type = GDScriptParser::PatternNode::PT_ARRAY;
  1661. while (true) {
  1662. if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_CLOSE) {
  1663. tokenizer->advance();
  1664. break;
  1665. }
  1666. if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD && tokenizer->get_token(1) == GDScriptTokenizer::TK_PERIOD) {
  1667. // match everything
  1668. tokenizer->advance(2);
  1669. PatternNode *sub_pattern = alloc_node<PatternNode>();
  1670. sub_pattern->pt_type = GDScriptParser::PatternNode::PT_IGNORE_REST;
  1671. pattern->array.push_back(sub_pattern);
  1672. if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA && tokenizer->get_token(1) == GDScriptTokenizer::TK_BRACKET_CLOSE) {
  1673. tokenizer->advance(2);
  1674. break;
  1675. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_CLOSE) {
  1676. tokenizer->advance(1);
  1677. break;
  1678. } else {
  1679. _set_error("'..' pattern only allowed at the end of an array pattern");
  1680. return NULL;
  1681. }
  1682. }
  1683. PatternNode *sub_pattern = _parse_pattern(p_static);
  1684. if (!sub_pattern) {
  1685. return NULL;
  1686. }
  1687. pattern->array.push_back(sub_pattern);
  1688. if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  1689. tokenizer->advance();
  1690. continue;
  1691. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_CLOSE) {
  1692. tokenizer->advance();
  1693. break;
  1694. } else {
  1695. _set_error("Not a valid pattern");
  1696. return NULL;
  1697. }
  1698. }
  1699. } break;
  1700. // bind
  1701. case GDScriptTokenizer::TK_PR_VAR: {
  1702. tokenizer->advance();
  1703. if (!tokenizer->is_token_literal()) {
  1704. _set_error("Expected identifier for binding variable name.");
  1705. return NULL;
  1706. }
  1707. pattern->pt_type = GDScriptParser::PatternNode::PT_BIND;
  1708. pattern->bind = tokenizer->get_token_identifier();
  1709. // Check if variable name is already used
  1710. BlockNode *bl = current_block;
  1711. while (bl) {
  1712. if (bl->variables.has(pattern->bind)) {
  1713. _set_error("Binding name of '" + pattern->bind.operator String() + "' is already declared in this scope.");
  1714. return NULL;
  1715. }
  1716. bl = bl->parent_block;
  1717. }
  1718. // Create local variable for proper identifier detection later
  1719. LocalVarNode *lv = alloc_node<LocalVarNode>();
  1720. lv->name = pattern->bind;
  1721. current_block->variables.insert(lv->name, lv);
  1722. tokenizer->advance();
  1723. } break;
  1724. // dictionary
  1725. case GDScriptTokenizer::TK_CURLY_BRACKET_OPEN: {
  1726. tokenizer->advance();
  1727. pattern->pt_type = GDScriptParser::PatternNode::PT_DICTIONARY;
  1728. while (true) {
  1729. if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
  1730. tokenizer->advance();
  1731. break;
  1732. }
  1733. if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD && tokenizer->get_token(1) == GDScriptTokenizer::TK_PERIOD) {
  1734. // match everything
  1735. tokenizer->advance(2);
  1736. PatternNode *sub_pattern = alloc_node<PatternNode>();
  1737. sub_pattern->pt_type = PatternNode::PT_IGNORE_REST;
  1738. pattern->array.push_back(sub_pattern);
  1739. if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA && tokenizer->get_token(1) == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
  1740. tokenizer->advance(2);
  1741. break;
  1742. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
  1743. tokenizer->advance(1);
  1744. break;
  1745. } else {
  1746. _set_error("'..' pattern only allowed at the end of a dictionary pattern");
  1747. return NULL;
  1748. }
  1749. }
  1750. Node *key = _parse_and_reduce_expression(pattern, p_static);
  1751. if (!key) {
  1752. _set_error("Not a valid key in pattern");
  1753. return NULL;
  1754. }
  1755. if (key->type != GDScriptParser::Node::TYPE_CONSTANT) {
  1756. _set_error("Not a constant expression as key");
  1757. return NULL;
  1758. }
  1759. if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
  1760. tokenizer->advance();
  1761. PatternNode *value = _parse_pattern(p_static);
  1762. if (!value) {
  1763. _set_error("Expected pattern in dictionary value");
  1764. return NULL;
  1765. }
  1766. pattern->dictionary.insert(static_cast<ConstantNode *>(key), value);
  1767. } else {
  1768. pattern->dictionary.insert(static_cast<ConstantNode *>(key), NULL);
  1769. }
  1770. if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  1771. tokenizer->advance();
  1772. continue;
  1773. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
  1774. tokenizer->advance();
  1775. break;
  1776. } else {
  1777. _set_error("Not a valid pattern");
  1778. return NULL;
  1779. }
  1780. }
  1781. } break;
  1782. case GDScriptTokenizer::TK_WILDCARD: {
  1783. tokenizer->advance();
  1784. pattern->pt_type = PatternNode::PT_WILDCARD;
  1785. } break;
  1786. // all the constants like strings and numbers
  1787. default: {
  1788. Node *value = _parse_and_reduce_expression(pattern, p_static);
  1789. if (!value) {
  1790. _set_error("Expect constant expression or variables in a pattern");
  1791. return NULL;
  1792. }
  1793. if (value->type == Node::TYPE_OPERATOR) {
  1794. // Maybe it's SomeEnum.VALUE
  1795. Node *current_value = value;
  1796. while (current_value->type == Node::TYPE_OPERATOR) {
  1797. OperatorNode *op_node = static_cast<OperatorNode *>(current_value);
  1798. if (op_node->op != OperatorNode::OP_INDEX_NAMED) {
  1799. _set_error("Invalid operator in pattern. Only index (`A.B`) is allowed");
  1800. return NULL;
  1801. }
  1802. current_value = op_node->arguments[0];
  1803. }
  1804. if (current_value->type != Node::TYPE_IDENTIFIER) {
  1805. _set_error("Only constant expression or variables allowed in a pattern");
  1806. return NULL;
  1807. }
  1808. } else if (value->type != Node::TYPE_IDENTIFIER && value->type != Node::TYPE_CONSTANT) {
  1809. _set_error("Only constant expressions or variables allowed in a pattern");
  1810. return NULL;
  1811. }
  1812. pattern->pt_type = PatternNode::PT_CONSTANT;
  1813. pattern->constant = value;
  1814. } break;
  1815. }
  1816. return pattern;
  1817. }
  1818. void GDScriptParser::_parse_pattern_block(BlockNode *p_block, Vector<PatternBranchNode *> &p_branches, bool p_static) {
  1819. int indent_level = tab_level.back()->get();
  1820. while (true) {
  1821. while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE && _parse_newline())
  1822. ;
  1823. // GDScriptTokenizer::Token token = tokenizer->get_token();
  1824. if (error_set)
  1825. return;
  1826. if (indent_level > tab_level.back()->get()) {
  1827. return; // go back a level
  1828. }
  1829. if (pending_newline != -1) {
  1830. pending_newline = -1;
  1831. }
  1832. PatternBranchNode *branch = alloc_node<PatternBranchNode>();
  1833. branch->body = alloc_node<BlockNode>();
  1834. branch->body->parent_block = p_block;
  1835. p_block->sub_blocks.push_back(branch->body);
  1836. current_block = branch->body;
  1837. branch->patterns.push_back(_parse_pattern(p_static));
  1838. if (!branch->patterns[0]) {
  1839. return;
  1840. }
  1841. bool has_binding = branch->patterns[0]->pt_type == PatternNode::PT_BIND;
  1842. bool catch_all = has_binding || branch->patterns[0]->pt_type == PatternNode::PT_WILDCARD;
  1843. while (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  1844. tokenizer->advance();
  1845. branch->patterns.push_back(_parse_pattern(p_static));
  1846. if (!branch->patterns[branch->patterns.size() - 1]) {
  1847. return;
  1848. }
  1849. PatternNode::PatternType pt = branch->patterns[branch->patterns.size() - 1]->pt_type;
  1850. if (pt == PatternNode::PT_BIND) {
  1851. _set_error("Cannot use bindings with multipattern.");
  1852. return;
  1853. }
  1854. catch_all = catch_all || pt == PatternNode::PT_WILDCARD;
  1855. }
  1856. if (!_enter_indent_block()) {
  1857. _set_error("Expected block in pattern branch");
  1858. return;
  1859. }
  1860. _parse_block(branch->body, p_static);
  1861. current_block = p_block;
  1862. if (catch_all && branch->body->has_return) {
  1863. p_block->has_return = true;
  1864. }
  1865. p_branches.push_back(branch);
  1866. }
  1867. }
  1868. void GDScriptParser::_generate_pattern(PatternNode *p_pattern, Node *p_node_to_match, Node *&p_resulting_node, Map<StringName, Node *> &p_bindings) {
  1869. const DataType &to_match_type = p_node_to_match->get_datatype();
  1870. switch (p_pattern->pt_type) {
  1871. case PatternNode::PT_CONSTANT: {
  1872. DataType pattern_type = _reduce_node_type(p_pattern->constant);
  1873. if (error_set) {
  1874. return;
  1875. }
  1876. OperatorNode *type_comp = NULL;
  1877. // static type check if possible
  1878. if (pattern_type.has_type && to_match_type.has_type) {
  1879. if (!_is_type_compatible(to_match_type, pattern_type) && !_is_type_compatible(pattern_type, to_match_type)) {
  1880. _set_error("Pattern type (" + pattern_type.to_string() + ") is not compatible with the type of the value to match (" + to_match_type.to_string() + ").",
  1881. p_pattern->line);
  1882. return;
  1883. }
  1884. } else {
  1885. // runtime typecheck
  1886. BuiltInFunctionNode *typeof_node = alloc_node<BuiltInFunctionNode>();
  1887. typeof_node->function = GDScriptFunctions::TYPE_OF;
  1888. OperatorNode *typeof_match_value = alloc_node<OperatorNode>();
  1889. typeof_match_value->op = OperatorNode::OP_CALL;
  1890. typeof_match_value->arguments.push_back(typeof_node);
  1891. typeof_match_value->arguments.push_back(p_node_to_match);
  1892. OperatorNode *typeof_pattern_value = alloc_node<OperatorNode>();
  1893. typeof_pattern_value->op = OperatorNode::OP_CALL;
  1894. typeof_pattern_value->arguments.push_back(typeof_node);
  1895. typeof_pattern_value->arguments.push_back(p_pattern->constant);
  1896. type_comp = alloc_node<OperatorNode>();
  1897. type_comp->op = OperatorNode::OP_EQUAL;
  1898. type_comp->arguments.push_back(typeof_match_value);
  1899. type_comp->arguments.push_back(typeof_pattern_value);
  1900. }
  1901. // compare the actual values
  1902. OperatorNode *value_comp = alloc_node<OperatorNode>();
  1903. value_comp->op = OperatorNode::OP_EQUAL;
  1904. value_comp->arguments.push_back(p_pattern->constant);
  1905. value_comp->arguments.push_back(p_node_to_match);
  1906. if (type_comp) {
  1907. OperatorNode *full_comparison = alloc_node<OperatorNode>();
  1908. full_comparison->op = OperatorNode::OP_AND;
  1909. full_comparison->arguments.push_back(type_comp);
  1910. full_comparison->arguments.push_back(value_comp);
  1911. p_resulting_node = full_comparison;
  1912. } else {
  1913. p_resulting_node = value_comp;
  1914. }
  1915. } break;
  1916. case PatternNode::PT_BIND: {
  1917. p_bindings[p_pattern->bind] = p_node_to_match;
  1918. // a bind always matches
  1919. ConstantNode *true_value = alloc_node<ConstantNode>();
  1920. true_value->value = Variant(true);
  1921. p_resulting_node = true_value;
  1922. } break;
  1923. case PatternNode::PT_ARRAY: {
  1924. bool open_ended = false;
  1925. if (p_pattern->array.size() > 0) {
  1926. if (p_pattern->array[p_pattern->array.size() - 1]->pt_type == PatternNode::PT_IGNORE_REST) {
  1927. open_ended = true;
  1928. }
  1929. }
  1930. // typeof(value_to_match) == TYPE_ARRAY && value_to_match.size() >= length
  1931. // typeof(value_to_match) == TYPE_ARRAY && value_to_match.size() == length
  1932. {
  1933. OperatorNode *type_comp = NULL;
  1934. // static type check if possible
  1935. if (to_match_type.has_type) {
  1936. // must be an array
  1937. if (to_match_type.kind != DataType::BUILTIN || to_match_type.builtin_type != Variant::ARRAY) {
  1938. _set_error("Cannot match an array pattern with a non-array expression.", p_pattern->line);
  1939. return;
  1940. }
  1941. } else {
  1942. // runtime typecheck
  1943. BuiltInFunctionNode *typeof_node = alloc_node<BuiltInFunctionNode>();
  1944. typeof_node->function = GDScriptFunctions::TYPE_OF;
  1945. OperatorNode *typeof_match_value = alloc_node<OperatorNode>();
  1946. typeof_match_value->op = OperatorNode::OP_CALL;
  1947. typeof_match_value->arguments.push_back(typeof_node);
  1948. typeof_match_value->arguments.push_back(p_node_to_match);
  1949. IdentifierNode *typeof_array = alloc_node<IdentifierNode>();
  1950. typeof_array->name = "TYPE_ARRAY";
  1951. type_comp = alloc_node<OperatorNode>();
  1952. type_comp->op = OperatorNode::OP_EQUAL;
  1953. type_comp->arguments.push_back(typeof_match_value);
  1954. type_comp->arguments.push_back(typeof_array);
  1955. }
  1956. // size
  1957. ConstantNode *length = alloc_node<ConstantNode>();
  1958. length->value = Variant(open_ended ? p_pattern->array.size() - 1 : p_pattern->array.size());
  1959. OperatorNode *call = alloc_node<OperatorNode>();
  1960. call->op = OperatorNode::OP_CALL;
  1961. call->arguments.push_back(p_node_to_match);
  1962. IdentifierNode *size = alloc_node<IdentifierNode>();
  1963. size->name = "size";
  1964. call->arguments.push_back(size);
  1965. OperatorNode *length_comparison = alloc_node<OperatorNode>();
  1966. length_comparison->op = open_ended ? OperatorNode::OP_GREATER_EQUAL : OperatorNode::OP_EQUAL;
  1967. length_comparison->arguments.push_back(call);
  1968. length_comparison->arguments.push_back(length);
  1969. if (type_comp) {
  1970. OperatorNode *type_and_length_comparison = alloc_node<OperatorNode>();
  1971. type_and_length_comparison->op = OperatorNode::OP_AND;
  1972. type_and_length_comparison->arguments.push_back(type_comp);
  1973. type_and_length_comparison->arguments.push_back(length_comparison);
  1974. p_resulting_node = type_and_length_comparison;
  1975. } else {
  1976. p_resulting_node = length_comparison;
  1977. }
  1978. }
  1979. for (int i = 0; i < p_pattern->array.size(); i++) {
  1980. PatternNode *pattern = p_pattern->array[i];
  1981. Node *condition = NULL;
  1982. ConstantNode *index = alloc_node<ConstantNode>();
  1983. index->value = Variant(i);
  1984. OperatorNode *indexed_value = alloc_node<OperatorNode>();
  1985. indexed_value->op = OperatorNode::OP_INDEX;
  1986. indexed_value->arguments.push_back(p_node_to_match);
  1987. indexed_value->arguments.push_back(index);
  1988. _generate_pattern(pattern, indexed_value, condition, p_bindings);
  1989. // concatenate all the patterns with &&
  1990. OperatorNode *and_node = alloc_node<OperatorNode>();
  1991. and_node->op = OperatorNode::OP_AND;
  1992. and_node->arguments.push_back(p_resulting_node);
  1993. and_node->arguments.push_back(condition);
  1994. p_resulting_node = and_node;
  1995. }
  1996. } break;
  1997. case PatternNode::PT_DICTIONARY: {
  1998. bool open_ended = false;
  1999. if (p_pattern->array.size() > 0) {
  2000. open_ended = true;
  2001. }
  2002. // typeof(value_to_match) == TYPE_DICTIONARY && value_to_match.size() >= length
  2003. // typeof(value_to_match) == TYPE_DICTIONARY && value_to_match.size() == length
  2004. {
  2005. OperatorNode *type_comp = NULL;
  2006. // static type check if possible
  2007. if (to_match_type.has_type) {
  2008. // must be an dictionary
  2009. if (to_match_type.kind != DataType::BUILTIN || to_match_type.builtin_type != Variant::DICTIONARY) {
  2010. _set_error("Cannot match an dictionary pattern with a non-dictionary expression.", p_pattern->line);
  2011. return;
  2012. }
  2013. } else {
  2014. // runtime typecheck
  2015. BuiltInFunctionNode *typeof_node = alloc_node<BuiltInFunctionNode>();
  2016. typeof_node->function = GDScriptFunctions::TYPE_OF;
  2017. OperatorNode *typeof_match_value = alloc_node<OperatorNode>();
  2018. typeof_match_value->op = OperatorNode::OP_CALL;
  2019. typeof_match_value->arguments.push_back(typeof_node);
  2020. typeof_match_value->arguments.push_back(p_node_to_match);
  2021. IdentifierNode *typeof_dictionary = alloc_node<IdentifierNode>();
  2022. typeof_dictionary->name = "TYPE_DICTIONARY";
  2023. type_comp = alloc_node<OperatorNode>();
  2024. type_comp->op = OperatorNode::OP_EQUAL;
  2025. type_comp->arguments.push_back(typeof_match_value);
  2026. type_comp->arguments.push_back(typeof_dictionary);
  2027. }
  2028. // size
  2029. ConstantNode *length = alloc_node<ConstantNode>();
  2030. length->value = Variant(open_ended ? p_pattern->dictionary.size() - 1 : p_pattern->dictionary.size());
  2031. OperatorNode *call = alloc_node<OperatorNode>();
  2032. call->op = OperatorNode::OP_CALL;
  2033. call->arguments.push_back(p_node_to_match);
  2034. IdentifierNode *size = alloc_node<IdentifierNode>();
  2035. size->name = "size";
  2036. call->arguments.push_back(size);
  2037. OperatorNode *length_comparison = alloc_node<OperatorNode>();
  2038. length_comparison->op = open_ended ? OperatorNode::OP_GREATER_EQUAL : OperatorNode::OP_EQUAL;
  2039. length_comparison->arguments.push_back(call);
  2040. length_comparison->arguments.push_back(length);
  2041. if (type_comp) {
  2042. OperatorNode *type_and_length_comparison = alloc_node<OperatorNode>();
  2043. type_and_length_comparison->op = OperatorNode::OP_AND;
  2044. type_and_length_comparison->arguments.push_back(type_comp);
  2045. type_and_length_comparison->arguments.push_back(length_comparison);
  2046. p_resulting_node = type_and_length_comparison;
  2047. } else {
  2048. p_resulting_node = length_comparison;
  2049. }
  2050. }
  2051. for (Map<ConstantNode *, PatternNode *>::Element *e = p_pattern->dictionary.front(); e; e = e->next()) {
  2052. Node *condition = NULL;
  2053. // check for has, then for pattern
  2054. IdentifierNode *has = alloc_node<IdentifierNode>();
  2055. has->name = "has";
  2056. OperatorNode *has_call = alloc_node<OperatorNode>();
  2057. has_call->op = OperatorNode::OP_CALL;
  2058. has_call->arguments.push_back(p_node_to_match);
  2059. has_call->arguments.push_back(has);
  2060. has_call->arguments.push_back(e->key());
  2061. if (e->value()) {
  2062. OperatorNode *indexed_value = alloc_node<OperatorNode>();
  2063. indexed_value->op = OperatorNode::OP_INDEX;
  2064. indexed_value->arguments.push_back(p_node_to_match);
  2065. indexed_value->arguments.push_back(e->key());
  2066. _generate_pattern(e->value(), indexed_value, condition, p_bindings);
  2067. OperatorNode *has_and_pattern = alloc_node<OperatorNode>();
  2068. has_and_pattern->op = OperatorNode::OP_AND;
  2069. has_and_pattern->arguments.push_back(has_call);
  2070. has_and_pattern->arguments.push_back(condition);
  2071. condition = has_and_pattern;
  2072. } else {
  2073. condition = has_call;
  2074. }
  2075. // concatenate all the patterns with &&
  2076. OperatorNode *and_node = alloc_node<OperatorNode>();
  2077. and_node->op = OperatorNode::OP_AND;
  2078. and_node->arguments.push_back(p_resulting_node);
  2079. and_node->arguments.push_back(condition);
  2080. p_resulting_node = and_node;
  2081. }
  2082. } break;
  2083. case PatternNode::PT_IGNORE_REST:
  2084. case PatternNode::PT_WILDCARD: {
  2085. // simply generate a `true`
  2086. ConstantNode *true_value = alloc_node<ConstantNode>();
  2087. true_value->value = Variant(true);
  2088. p_resulting_node = true_value;
  2089. } break;
  2090. default: {
  2091. } break;
  2092. }
  2093. }
  2094. void GDScriptParser::_transform_match_statment(MatchNode *p_match_statement) {
  2095. IdentifierNode *id = alloc_node<IdentifierNode>();
  2096. id->name = "#match_value";
  2097. id->line = p_match_statement->line;
  2098. id->datatype = _reduce_node_type(p_match_statement->val_to_match);
  2099. if (id->datatype.has_type) {
  2100. _mark_line_as_safe(id->line);
  2101. } else {
  2102. _mark_line_as_unsafe(id->line);
  2103. }
  2104. if (error_set) {
  2105. return;
  2106. }
  2107. for (int i = 0; i < p_match_statement->branches.size(); i++) {
  2108. PatternBranchNode *branch = p_match_statement->branches[i];
  2109. MatchNode::CompiledPatternBranch compiled_branch;
  2110. compiled_branch.compiled_pattern = NULL;
  2111. Map<StringName, Node *> binding;
  2112. for (int j = 0; j < branch->patterns.size(); j++) {
  2113. PatternNode *pattern = branch->patterns[j];
  2114. _mark_line_as_safe(pattern->line);
  2115. Map<StringName, Node *> bindings;
  2116. Node *resulting_node = NULL;
  2117. _generate_pattern(pattern, id, resulting_node, bindings);
  2118. if (!resulting_node) {
  2119. return;
  2120. }
  2121. if (!binding.empty() && !bindings.empty()) {
  2122. _set_error("Multipatterns can't contain bindings");
  2123. return;
  2124. } else {
  2125. binding = bindings;
  2126. }
  2127. // Result is always a boolean
  2128. DataType resulting_node_type;
  2129. resulting_node_type.has_type = true;
  2130. resulting_node_type.is_constant = true;
  2131. resulting_node_type.kind = DataType::BUILTIN;
  2132. resulting_node_type.builtin_type = Variant::BOOL;
  2133. resulting_node->set_datatype(resulting_node_type);
  2134. if (compiled_branch.compiled_pattern) {
  2135. OperatorNode *or_node = alloc_node<OperatorNode>();
  2136. or_node->op = OperatorNode::OP_OR;
  2137. or_node->arguments.push_back(compiled_branch.compiled_pattern);
  2138. or_node->arguments.push_back(resulting_node);
  2139. compiled_branch.compiled_pattern = or_node;
  2140. } else {
  2141. // single pattern | first one
  2142. compiled_branch.compiled_pattern = resulting_node;
  2143. }
  2144. }
  2145. // prepare the body ...hehe
  2146. for (Map<StringName, Node *>::Element *e = binding.front(); e; e = e->next()) {
  2147. if (!branch->body->variables.has(e->key())) {
  2148. _set_error("Parser bug: missing pattern bind variable.", branch->line);
  2149. ERR_FAIL();
  2150. }
  2151. LocalVarNode *local_var = branch->body->variables[e->key()];
  2152. local_var->assign = e->value();
  2153. local_var->set_datatype(local_var->assign->get_datatype());
  2154. IdentifierNode *id = alloc_node<IdentifierNode>();
  2155. id->name = local_var->name;
  2156. id->declared_block = branch->body;
  2157. id->set_datatype(local_var->assign->get_datatype());
  2158. OperatorNode *op = alloc_node<OperatorNode>();
  2159. op->op = OperatorNode::OP_ASSIGN;
  2160. op->arguments.push_back(id);
  2161. op->arguments.push_back(local_var->assign);
  2162. branch->body->statements.push_front(op);
  2163. branch->body->statements.push_front(local_var);
  2164. }
  2165. compiled_branch.body = branch->body;
  2166. p_match_statement->compiled_pattern_branches.push_back(compiled_branch);
  2167. }
  2168. }
  2169. void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
  2170. int indent_level = tab_level.back()->get();
  2171. #ifdef DEBUG_ENABLED
  2172. NewLineNode *nl = alloc_node<NewLineNode>();
  2173. nl->line = tokenizer->get_token_line();
  2174. p_block->statements.push_back(nl);
  2175. #endif
  2176. bool is_first_line = true;
  2177. while (true) {
  2178. if (!is_first_line && tab_level.back()->prev() && tab_level.back()->prev()->get() == indent_level) {
  2179. // pythonic single-line expression, don't parse future lines
  2180. tab_level.pop_back();
  2181. p_block->end_line = tokenizer->get_token_line();
  2182. return;
  2183. }
  2184. is_first_line = false;
  2185. GDScriptTokenizer::Token token = tokenizer->get_token();
  2186. if (error_set)
  2187. return;
  2188. if (indent_level > tab_level.back()->get()) {
  2189. p_block->end_line = tokenizer->get_token_line();
  2190. return; //go back a level
  2191. }
  2192. if (pending_newline != -1) {
  2193. NewLineNode *nl = alloc_node<NewLineNode>();
  2194. nl->line = pending_newline;
  2195. p_block->statements.push_back(nl);
  2196. pending_newline = -1;
  2197. }
  2198. #ifdef DEBUG_ENABLED
  2199. switch (token) {
  2200. case GDScriptTokenizer::TK_EOF:
  2201. case GDScriptTokenizer::TK_ERROR:
  2202. case GDScriptTokenizer::TK_NEWLINE:
  2203. case GDScriptTokenizer::TK_CF_PASS: {
  2204. // will check later
  2205. } break;
  2206. default: {
  2207. if (p_block->has_return && !current_function->has_unreachable_code) {
  2208. _add_warning(GDScriptWarning::UNREACHABLE_CODE, -1, current_function->name.operator String());
  2209. current_function->has_unreachable_code = true;
  2210. }
  2211. } break;
  2212. }
  2213. #endif // DEBUG_ENABLED
  2214. switch (token) {
  2215. case GDScriptTokenizer::TK_EOF:
  2216. p_block->end_line = tokenizer->get_token_line();
  2217. case GDScriptTokenizer::TK_ERROR: {
  2218. return; //go back
  2219. //end of file!
  2220. } break;
  2221. case GDScriptTokenizer::TK_NEWLINE: {
  2222. if (!_parse_newline()) {
  2223. if (!error_set) {
  2224. p_block->end_line = tokenizer->get_token_line();
  2225. pending_newline = p_block->end_line;
  2226. }
  2227. return;
  2228. }
  2229. NewLineNode *nl = alloc_node<NewLineNode>();
  2230. nl->line = tokenizer->get_token_line();
  2231. p_block->statements.push_back(nl);
  2232. } break;
  2233. case GDScriptTokenizer::TK_CF_PASS: {
  2234. if (tokenizer->get_token(1) != GDScriptTokenizer::TK_SEMICOLON && tokenizer->get_token(1) != GDScriptTokenizer::TK_NEWLINE && tokenizer->get_token(1) != GDScriptTokenizer::TK_EOF) {
  2235. _set_error("Expected ';' or <NewLine>.");
  2236. return;
  2237. }
  2238. _mark_line_as_safe(tokenizer->get_token_line());
  2239. tokenizer->advance();
  2240. if (tokenizer->get_token() == GDScriptTokenizer::TK_SEMICOLON) {
  2241. // Ignore semicolon after 'pass'
  2242. tokenizer->advance();
  2243. }
  2244. } break;
  2245. case GDScriptTokenizer::TK_PR_VAR: {
  2246. //variale declaration and (eventual) initialization
  2247. tokenizer->advance();
  2248. int var_line = tokenizer->get_token_line();
  2249. if (!tokenizer->is_token_literal(0, true)) {
  2250. _set_error("Expected identifier for local variable name.");
  2251. return;
  2252. }
  2253. StringName n = tokenizer->get_token_literal();
  2254. tokenizer->advance();
  2255. if (current_function) {
  2256. for (int i = 0; i < current_function->arguments.size(); i++) {
  2257. if (n == current_function->arguments[i]) {
  2258. _set_error("Variable '" + String(n) + "' already defined in the scope (at line: " + itos(current_function->line) + ").");
  2259. return;
  2260. }
  2261. }
  2262. }
  2263. BlockNode *check_block = p_block;
  2264. while (check_block) {
  2265. if (check_block->variables.has(n)) {
  2266. _set_error("Variable '" + String(n) + "' already defined in the scope (at line: " + itos(check_block->variables[n]->line) + ").");
  2267. return;
  2268. }
  2269. check_block = check_block->parent_block;
  2270. }
  2271. //must know when the local variable is declared
  2272. LocalVarNode *lv = alloc_node<LocalVarNode>();
  2273. lv->name = n;
  2274. lv->line = var_line;
  2275. p_block->statements.push_back(lv);
  2276. Node *assigned = NULL;
  2277. if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
  2278. if (tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
  2279. lv->datatype = DataType();
  2280. #ifdef DEBUG_ENABLED
  2281. lv->datatype.infer_type = true;
  2282. #endif
  2283. tokenizer->advance();
  2284. } else if (!_parse_type(lv->datatype)) {
  2285. _set_error("Expected type for variable.");
  2286. return;
  2287. }
  2288. }
  2289. if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ASSIGN) {
  2290. tokenizer->advance();
  2291. Node *subexpr = _parse_and_reduce_expression(p_block, p_static);
  2292. if (!subexpr) {
  2293. if (_recover_from_completion()) {
  2294. break;
  2295. }
  2296. return;
  2297. }
  2298. lv->assignments++;
  2299. assigned = subexpr;
  2300. } else {
  2301. ConstantNode *c = alloc_node<ConstantNode>();
  2302. if (lv->datatype.has_type && lv->datatype.kind == DataType::BUILTIN) {
  2303. Variant::CallError err;
  2304. c->value = Variant::construct(lv->datatype.builtin_type, NULL, 0, err);
  2305. } else {
  2306. c->value = Variant();
  2307. }
  2308. c->line = var_line;
  2309. assigned = c;
  2310. }
  2311. lv->assign = assigned;
  2312. //must be added later, to avoid self-referencing.
  2313. p_block->variables.insert(n, lv);
  2314. IdentifierNode *id = alloc_node<IdentifierNode>();
  2315. id->name = n;
  2316. id->declared_block = p_block;
  2317. id->line = var_line;
  2318. OperatorNode *op = alloc_node<OperatorNode>();
  2319. op->op = OperatorNode::OP_ASSIGN;
  2320. op->arguments.push_back(id);
  2321. op->arguments.push_back(assigned);
  2322. op->line = var_line;
  2323. p_block->statements.push_back(op);
  2324. lv->assign_op = op;
  2325. lv->assign = assigned;
  2326. lv->assign_op = op;
  2327. if (!_end_statement()) {
  2328. _set_error("Expected end of statement (var)");
  2329. return;
  2330. }
  2331. } break;
  2332. case GDScriptTokenizer::TK_CF_IF: {
  2333. tokenizer->advance();
  2334. Node *condition = _parse_and_reduce_expression(p_block, p_static);
  2335. if (!condition) {
  2336. if (_recover_from_completion()) {
  2337. break;
  2338. }
  2339. return;
  2340. }
  2341. ControlFlowNode *cf_if = alloc_node<ControlFlowNode>();
  2342. cf_if->cf_type = ControlFlowNode::CF_IF;
  2343. cf_if->arguments.push_back(condition);
  2344. cf_if->body = alloc_node<BlockNode>();
  2345. cf_if->body->parent_block = p_block;
  2346. cf_if->body->if_condition = condition; //helps code completion
  2347. p_block->sub_blocks.push_back(cf_if->body);
  2348. if (!_enter_indent_block(cf_if->body)) {
  2349. _set_error("Expected indented block after 'if'");
  2350. p_block->end_line = tokenizer->get_token_line();
  2351. return;
  2352. }
  2353. current_block = cf_if->body;
  2354. _parse_block(cf_if->body, p_static);
  2355. current_block = p_block;
  2356. if (error_set)
  2357. return;
  2358. p_block->statements.push_back(cf_if);
  2359. bool all_have_return = cf_if->body->has_return;
  2360. bool have_else = false;
  2361. while (true) {
  2362. while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE && _parse_newline())
  2363. ;
  2364. if (tab_level.back()->get() < indent_level) { //not at current indent level
  2365. p_block->end_line = tokenizer->get_token_line();
  2366. return;
  2367. }
  2368. if (tokenizer->get_token() == GDScriptTokenizer::TK_CF_ELIF) {
  2369. if (tab_level.back()->get() > indent_level) {
  2370. _set_error("Invalid indent");
  2371. return;
  2372. }
  2373. tokenizer->advance();
  2374. cf_if->body_else = alloc_node<BlockNode>();
  2375. cf_if->body_else->parent_block = p_block;
  2376. p_block->sub_blocks.push_back(cf_if->body_else);
  2377. ControlFlowNode *cf_else = alloc_node<ControlFlowNode>();
  2378. cf_else->cf_type = ControlFlowNode::CF_IF;
  2379. //condition
  2380. Node *condition = _parse_and_reduce_expression(p_block, p_static);
  2381. if (!condition) {
  2382. if (_recover_from_completion()) {
  2383. break;
  2384. }
  2385. return;
  2386. }
  2387. cf_else->arguments.push_back(condition);
  2388. cf_else->cf_type = ControlFlowNode::CF_IF;
  2389. cf_if->body_else->statements.push_back(cf_else);
  2390. cf_if = cf_else;
  2391. cf_if->body = alloc_node<BlockNode>();
  2392. cf_if->body->parent_block = p_block;
  2393. p_block->sub_blocks.push_back(cf_if->body);
  2394. if (!_enter_indent_block(cf_if->body)) {
  2395. _set_error("Expected indented block after 'elif'");
  2396. p_block->end_line = tokenizer->get_token_line();
  2397. return;
  2398. }
  2399. current_block = cf_else->body;
  2400. _parse_block(cf_else->body, p_static);
  2401. current_block = p_block;
  2402. if (error_set)
  2403. return;
  2404. all_have_return = all_have_return && cf_else->body->has_return;
  2405. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_CF_ELSE) {
  2406. if (tab_level.back()->get() > indent_level) {
  2407. _set_error("Invalid indent");
  2408. return;
  2409. }
  2410. tokenizer->advance();
  2411. cf_if->body_else = alloc_node<BlockNode>();
  2412. cf_if->body_else->parent_block = p_block;
  2413. p_block->sub_blocks.push_back(cf_if->body_else);
  2414. if (!_enter_indent_block(cf_if->body_else)) {
  2415. _set_error("Expected indented block after 'else'");
  2416. p_block->end_line = tokenizer->get_token_line();
  2417. return;
  2418. }
  2419. current_block = cf_if->body_else;
  2420. _parse_block(cf_if->body_else, p_static);
  2421. current_block = p_block;
  2422. if (error_set)
  2423. return;
  2424. all_have_return = all_have_return && cf_if->body_else->has_return;
  2425. have_else = true;
  2426. break; //after else, exit
  2427. } else
  2428. break;
  2429. }
  2430. cf_if->body->has_return = all_have_return;
  2431. // If there's no else block, path out of the if might not have a return
  2432. p_block->has_return = all_have_return && have_else;
  2433. } break;
  2434. case GDScriptTokenizer::TK_CF_WHILE: {
  2435. tokenizer->advance();
  2436. Node *condition = _parse_and_reduce_expression(p_block, p_static);
  2437. if (!condition) {
  2438. if (_recover_from_completion()) {
  2439. break;
  2440. }
  2441. return;
  2442. }
  2443. ControlFlowNode *cf_while = alloc_node<ControlFlowNode>();
  2444. cf_while->cf_type = ControlFlowNode::CF_WHILE;
  2445. cf_while->arguments.push_back(condition);
  2446. cf_while->body = alloc_node<BlockNode>();
  2447. cf_while->body->parent_block = p_block;
  2448. p_block->sub_blocks.push_back(cf_while->body);
  2449. if (!_enter_indent_block(cf_while->body)) {
  2450. _set_error("Expected indented block after 'while'");
  2451. p_block->end_line = tokenizer->get_token_line();
  2452. return;
  2453. }
  2454. current_block = cf_while->body;
  2455. _parse_block(cf_while->body, p_static);
  2456. current_block = p_block;
  2457. if (error_set)
  2458. return;
  2459. p_block->has_return = cf_while->body->has_return;
  2460. p_block->statements.push_back(cf_while);
  2461. } break;
  2462. case GDScriptTokenizer::TK_CF_FOR: {
  2463. tokenizer->advance();
  2464. if (!tokenizer->is_token_literal(0, true)) {
  2465. _set_error("identifier expected after 'for'");
  2466. }
  2467. IdentifierNode *id = alloc_node<IdentifierNode>();
  2468. id->name = tokenizer->get_token_identifier();
  2469. tokenizer->advance();
  2470. if (tokenizer->get_token() != GDScriptTokenizer::TK_OP_IN) {
  2471. _set_error("'in' expected after identifier");
  2472. return;
  2473. }
  2474. tokenizer->advance();
  2475. Node *container = _parse_and_reduce_expression(p_block, p_static);
  2476. if (!container) {
  2477. if (_recover_from_completion()) {
  2478. break;
  2479. }
  2480. return;
  2481. }
  2482. DataType iter_type;
  2483. iter_type.is_constant = true;
  2484. if (container->type == Node::TYPE_OPERATOR) {
  2485. OperatorNode *op = static_cast<OperatorNode *>(container);
  2486. if (op->op == OperatorNode::OP_CALL && op->arguments[0]->type == Node::TYPE_BUILT_IN_FUNCTION && static_cast<BuiltInFunctionNode *>(op->arguments[0])->function == GDScriptFunctions::GEN_RANGE) {
  2487. //iterating a range, so see if range() can be optimized without allocating memory, by replacing it by vectors (which can work as iterable too!)
  2488. Vector<Node *> args;
  2489. Vector<double> constants;
  2490. bool constant = false;
  2491. for (int i = 1; i < op->arguments.size(); i++) {
  2492. args.push_back(op->arguments[i]);
  2493. if (constant && op->arguments[i]->type == Node::TYPE_CONSTANT) {
  2494. ConstantNode *c = static_cast<ConstantNode *>(op->arguments[i]);
  2495. if (c->value.get_type() == Variant::REAL || c->value.get_type() == Variant::INT) {
  2496. constants.push_back(c->value);
  2497. constant = true;
  2498. }
  2499. } else {
  2500. constant = false;
  2501. }
  2502. }
  2503. if (args.size() > 0 && args.size() < 4) {
  2504. if (constant) {
  2505. ConstantNode *cn = alloc_node<ConstantNode>();
  2506. switch (args.size()) {
  2507. case 1: cn->value = (int)constants[0]; break;
  2508. case 2: cn->value = Vector2(constants[0], constants[1]); break;
  2509. case 3: cn->value = Vector3(constants[0], constants[1], constants[2]); break;
  2510. }
  2511. cn->datatype = _type_from_variant(cn->value);
  2512. container = cn;
  2513. } else {
  2514. OperatorNode *on = alloc_node<OperatorNode>();
  2515. on->op = OperatorNode::OP_CALL;
  2516. TypeNode *tn = alloc_node<TypeNode>();
  2517. on->arguments.push_back(tn);
  2518. switch (args.size()) {
  2519. case 1: tn->vtype = Variant::INT; break;
  2520. case 2: tn->vtype = Variant::VECTOR2; break;
  2521. case 3: tn->vtype = Variant::VECTOR3; break;
  2522. }
  2523. for (int i = 0; i < args.size(); i++) {
  2524. on->arguments.push_back(args[i]);
  2525. }
  2526. container = on;
  2527. }
  2528. }
  2529. iter_type.has_type = true;
  2530. iter_type.kind = DataType::BUILTIN;
  2531. iter_type.builtin_type = Variant::INT;
  2532. }
  2533. }
  2534. ControlFlowNode *cf_for = alloc_node<ControlFlowNode>();
  2535. cf_for->cf_type = ControlFlowNode::CF_FOR;
  2536. cf_for->arguments.push_back(id);
  2537. cf_for->arguments.push_back(container);
  2538. cf_for->body = alloc_node<BlockNode>();
  2539. cf_for->body->parent_block = p_block;
  2540. p_block->sub_blocks.push_back(cf_for->body);
  2541. if (!_enter_indent_block(cf_for->body)) {
  2542. _set_error("Expected indented block after 'for'");
  2543. p_block->end_line = tokenizer->get_token_line();
  2544. return;
  2545. }
  2546. current_block = cf_for->body;
  2547. // this is for checking variable for redefining
  2548. // inside this _parse_block
  2549. LocalVarNode *lv = alloc_node<LocalVarNode>();
  2550. lv->name = id->name;
  2551. lv->line = id->line;
  2552. lv->assignments++;
  2553. id->declared_block = cf_for->body;
  2554. lv->set_datatype(iter_type);
  2555. id->set_datatype(iter_type);
  2556. cf_for->body->variables.insert(id->name, lv);
  2557. _parse_block(cf_for->body, p_static);
  2558. current_block = p_block;
  2559. if (error_set)
  2560. return;
  2561. p_block->has_return = cf_for->body->has_return;
  2562. p_block->statements.push_back(cf_for);
  2563. } break;
  2564. case GDScriptTokenizer::TK_CF_CONTINUE: {
  2565. tokenizer->advance();
  2566. ControlFlowNode *cf_continue = alloc_node<ControlFlowNode>();
  2567. cf_continue->cf_type = ControlFlowNode::CF_CONTINUE;
  2568. p_block->statements.push_back(cf_continue);
  2569. if (!_end_statement()) {
  2570. _set_error("Expected end of statement (continue)");
  2571. return;
  2572. }
  2573. } break;
  2574. case GDScriptTokenizer::TK_CF_BREAK: {
  2575. tokenizer->advance();
  2576. ControlFlowNode *cf_break = alloc_node<ControlFlowNode>();
  2577. cf_break->cf_type = ControlFlowNode::CF_BREAK;
  2578. p_block->statements.push_back(cf_break);
  2579. if (!_end_statement()) {
  2580. _set_error("Expected end of statement (break)");
  2581. return;
  2582. }
  2583. } break;
  2584. case GDScriptTokenizer::TK_CF_RETURN: {
  2585. tokenizer->advance();
  2586. ControlFlowNode *cf_return = alloc_node<ControlFlowNode>();
  2587. cf_return->cf_type = ControlFlowNode::CF_RETURN;
  2588. cf_return->line = tokenizer->get_token_line(-1);
  2589. if (tokenizer->get_token() == GDScriptTokenizer::TK_SEMICOLON || tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE || tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
  2590. //expect end of statement
  2591. p_block->statements.push_back(cf_return);
  2592. if (!_end_statement()) {
  2593. return;
  2594. }
  2595. } else {
  2596. //expect expression
  2597. Node *retexpr = _parse_and_reduce_expression(p_block, p_static);
  2598. if (!retexpr) {
  2599. if (_recover_from_completion()) {
  2600. break;
  2601. }
  2602. return;
  2603. }
  2604. cf_return->arguments.push_back(retexpr);
  2605. p_block->statements.push_back(cf_return);
  2606. if (!_end_statement()) {
  2607. _set_error("Expected end of statement after return expression.");
  2608. return;
  2609. }
  2610. }
  2611. p_block->has_return = true;
  2612. } break;
  2613. case GDScriptTokenizer::TK_CF_MATCH: {
  2614. tokenizer->advance();
  2615. MatchNode *match_node = alloc_node<MatchNode>();
  2616. Node *val_to_match = _parse_and_reduce_expression(p_block, p_static);
  2617. if (!val_to_match) {
  2618. if (_recover_from_completion()) {
  2619. break;
  2620. }
  2621. return;
  2622. }
  2623. match_node->val_to_match = val_to_match;
  2624. if (!_enter_indent_block()) {
  2625. _set_error("Expected indented pattern matching block after 'match'");
  2626. return;
  2627. }
  2628. BlockNode *compiled_branches = alloc_node<BlockNode>();
  2629. compiled_branches->parent_block = p_block;
  2630. compiled_branches->parent_class = p_block->parent_class;
  2631. p_block->sub_blocks.push_back(compiled_branches);
  2632. _parse_pattern_block(compiled_branches, match_node->branches, p_static);
  2633. if (error_set) return;
  2634. ControlFlowNode *match_cf_node = alloc_node<ControlFlowNode>();
  2635. match_cf_node->cf_type = ControlFlowNode::CF_MATCH;
  2636. match_cf_node->match = match_node;
  2637. match_cf_node->body = compiled_branches;
  2638. p_block->has_return = p_block->has_return || compiled_branches->has_return;
  2639. p_block->statements.push_back(match_cf_node);
  2640. _end_statement();
  2641. } break;
  2642. case GDScriptTokenizer::TK_PR_ASSERT: {
  2643. tokenizer->advance();
  2644. Node *condition = _parse_and_reduce_expression(p_block, p_static);
  2645. if (!condition) {
  2646. if (_recover_from_completion()) {
  2647. break;
  2648. }
  2649. return;
  2650. }
  2651. AssertNode *an = alloc_node<AssertNode>();
  2652. an->condition = condition;
  2653. p_block->statements.push_back(an);
  2654. if (!_end_statement()) {
  2655. _set_error("Expected end of statement after assert.");
  2656. return;
  2657. }
  2658. } break;
  2659. case GDScriptTokenizer::TK_PR_BREAKPOINT: {
  2660. tokenizer->advance();
  2661. BreakpointNode *bn = alloc_node<BreakpointNode>();
  2662. p_block->statements.push_back(bn);
  2663. if (!_end_statement()) {
  2664. _set_error("Expected end of statement after breakpoint.");
  2665. return;
  2666. }
  2667. } break;
  2668. default: {
  2669. Node *expression = _parse_and_reduce_expression(p_block, p_static, false, true);
  2670. if (!expression) {
  2671. if (_recover_from_completion()) {
  2672. break;
  2673. }
  2674. return;
  2675. }
  2676. p_block->statements.push_back(expression);
  2677. if (!_end_statement()) {
  2678. _set_error("Expected end of statement after expression.");
  2679. return;
  2680. }
  2681. } break;
  2682. }
  2683. }
  2684. }
  2685. bool GDScriptParser::_parse_newline() {
  2686. if (tokenizer->get_token(1) != GDScriptTokenizer::TK_EOF && tokenizer->get_token(1) != GDScriptTokenizer::TK_NEWLINE) {
  2687. int indent = tokenizer->get_token_line_indent();
  2688. int current_indent = tab_level.back()->get();
  2689. if (indent > current_indent) {
  2690. _set_error("Unexpected indent.");
  2691. return false;
  2692. }
  2693. if (indent < current_indent) {
  2694. while (indent < current_indent) {
  2695. //exit block
  2696. if (tab_level.size() == 1) {
  2697. _set_error("Invalid indent. BUG?");
  2698. return false;
  2699. }
  2700. tab_level.pop_back();
  2701. if (tab_level.back()->get() < indent) {
  2702. _set_error("Unindent does not match any outer indentation level.");
  2703. return false;
  2704. }
  2705. current_indent = tab_level.back()->get();
  2706. }
  2707. tokenizer->advance();
  2708. return false;
  2709. }
  2710. }
  2711. tokenizer->advance();
  2712. return true;
  2713. }
  2714. void GDScriptParser::_parse_extends(ClassNode *p_class) {
  2715. if (p_class->extends_used) {
  2716. _set_error("'extends' already used for this class.");
  2717. return;
  2718. }
  2719. if (!p_class->constant_expressions.empty() || !p_class->subclasses.empty() || !p_class->functions.empty() || !p_class->variables.empty()) {
  2720. _set_error("'extends' must be used before anything else.");
  2721. return;
  2722. }
  2723. p_class->extends_used = true;
  2724. tokenizer->advance();
  2725. if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE && tokenizer->get_token_type() == Variant::OBJECT) {
  2726. p_class->extends_class.push_back(Variant::get_type_name(Variant::OBJECT));
  2727. tokenizer->advance();
  2728. return;
  2729. }
  2730. // see if inheritance happens from a file
  2731. if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT) {
  2732. Variant constant = tokenizer->get_token_constant();
  2733. if (constant.get_type() != Variant::STRING) {
  2734. _set_error("'extends' constant must be a string.");
  2735. return;
  2736. }
  2737. p_class->extends_file = constant;
  2738. tokenizer->advance();
  2739. if (tokenizer->get_token() != GDScriptTokenizer::TK_PERIOD) {
  2740. return;
  2741. } else
  2742. tokenizer->advance();
  2743. }
  2744. while (true) {
  2745. switch (tokenizer->get_token()) {
  2746. case GDScriptTokenizer::TK_IDENTIFIER: {
  2747. StringName identifier = tokenizer->get_token_identifier();
  2748. p_class->extends_class.push_back(identifier);
  2749. } break;
  2750. case GDScriptTokenizer::TK_PERIOD:
  2751. break;
  2752. default: {
  2753. _set_error("Invalid 'extends' syntax, expected string constant (path) and/or identifier (parent class).");
  2754. return;
  2755. }
  2756. }
  2757. tokenizer->advance(1);
  2758. switch (tokenizer->get_token()) {
  2759. case GDScriptTokenizer::TK_IDENTIFIER:
  2760. case GDScriptTokenizer::TK_PERIOD:
  2761. continue;
  2762. default:
  2763. return;
  2764. }
  2765. }
  2766. }
  2767. void GDScriptParser::_parse_class(ClassNode *p_class) {
  2768. int indent_level = tab_level.back()->get();
  2769. while (true) {
  2770. GDScriptTokenizer::Token token = tokenizer->get_token();
  2771. if (error_set)
  2772. return;
  2773. if (indent_level > tab_level.back()->get()) {
  2774. p_class->end_line = tokenizer->get_token_line();
  2775. return; //go back a level
  2776. }
  2777. switch (token) {
  2778. case GDScriptTokenizer::TK_CURSOR: {
  2779. tokenizer->advance();
  2780. } break;
  2781. case GDScriptTokenizer::TK_EOF:
  2782. p_class->end_line = tokenizer->get_token_line();
  2783. case GDScriptTokenizer::TK_ERROR: {
  2784. return; //go back
  2785. //end of file!
  2786. } break;
  2787. case GDScriptTokenizer::TK_NEWLINE: {
  2788. if (!_parse_newline()) {
  2789. if (!error_set) {
  2790. p_class->end_line = tokenizer->get_token_line();
  2791. }
  2792. return;
  2793. }
  2794. } break;
  2795. case GDScriptTokenizer::TK_PR_EXTENDS: {
  2796. _mark_line_as_safe(tokenizer->get_token_line());
  2797. _parse_extends(p_class);
  2798. if (error_set)
  2799. return;
  2800. if (!_end_statement()) {
  2801. _set_error("Expected end of statement after extends");
  2802. return;
  2803. }
  2804. } break;
  2805. case GDScriptTokenizer::TK_PR_CLASS_NAME: {
  2806. if (p_class->owner) {
  2807. _set_error("'class_name' is only valid for the main class namespace.");
  2808. return;
  2809. }
  2810. if (tokenizer->get_token(1) != GDScriptTokenizer::TK_IDENTIFIER) {
  2811. _set_error("'class_name' syntax: 'class_name <UniqueName>'");
  2812. return;
  2813. }
  2814. p_class->name = tokenizer->get_token_identifier(1);
  2815. if (self_path != String() && ScriptServer::is_global_class(p_class->name) && ScriptServer::get_global_class_path(p_class->name) != self_path) {
  2816. _set_error("Unique global class '" + p_class->name + "' already exists at path: " + ScriptServer::get_global_class_path(p_class->name));
  2817. return;
  2818. }
  2819. if (ClassDB::class_exists(p_class->name)) {
  2820. _set_error("Class '" + p_class->name + "' shadows a native class.");
  2821. return;
  2822. }
  2823. tokenizer->advance(2);
  2824. if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  2825. tokenizer->advance();
  2826. if ((tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING)) {
  2827. #ifdef TOOLS_ENABLED
  2828. if (Engine::get_singleton()->is_editor_hint()) {
  2829. Variant constant = tokenizer->get_token_constant();
  2830. String icon_path = constant.operator String();
  2831. String abs_icon_path = icon_path.is_rel_path() ? self_path.get_base_dir().plus_file(icon_path).simplify_path() : icon_path;
  2832. if (!FileAccess::exists(abs_icon_path)) {
  2833. _set_error("No class icon found at: " + abs_icon_path);
  2834. return;
  2835. }
  2836. p_class->icon_path = icon_path;
  2837. }
  2838. #endif
  2839. tokenizer->advance();
  2840. } else {
  2841. _set_error("Optional parameter after 'class_name' must be a string constant file path to an icon.");
  2842. return;
  2843. }
  2844. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT) {
  2845. _set_error("Class icon must be separated by a comma.");
  2846. return;
  2847. }
  2848. } break;
  2849. case GDScriptTokenizer::TK_PR_TOOL: {
  2850. if (p_class->tool) {
  2851. _set_error("tool used more than once");
  2852. return;
  2853. }
  2854. p_class->tool = true;
  2855. tokenizer->advance();
  2856. } break;
  2857. case GDScriptTokenizer::TK_PR_CLASS: {
  2858. //class inside class :D
  2859. StringName name;
  2860. if (tokenizer->get_token(1) != GDScriptTokenizer::TK_IDENTIFIER) {
  2861. _set_error("'class' syntax: 'class <Name>:' or 'class <Name> extends <BaseClass>:'");
  2862. return;
  2863. }
  2864. name = tokenizer->get_token_identifier(1);
  2865. tokenizer->advance(2);
  2866. // Check if name is shadowing something else
  2867. if (ClassDB::class_exists(name) || ClassDB::class_exists("_" + name.operator String())) {
  2868. _set_error("Class '" + String(name) + "' shadows a native class.");
  2869. return;
  2870. }
  2871. if (ScriptServer::is_global_class(name)) {
  2872. _set_error("Can't override name of unique global class '" + name + "' already exists at path: " + ScriptServer::get_global_class_path(p_class->name));
  2873. return;
  2874. }
  2875. ClassNode *outer_class = p_class;
  2876. while (outer_class) {
  2877. for (int i = 0; i < outer_class->subclasses.size(); i++) {
  2878. if (outer_class->subclasses[i]->name == name) {
  2879. _set_error("Another class named '" + String(name) + "' already exists in this scope (at line " + itos(outer_class->subclasses[i]->line) + ").");
  2880. return;
  2881. }
  2882. }
  2883. if (outer_class->constant_expressions.has(name)) {
  2884. _set_error("A constant named '" + String(name) + "' already exists in the outer class scope (at line" + itos(outer_class->constant_expressions[name].expression->line) + ").");
  2885. return;
  2886. }
  2887. outer_class = outer_class->owner;
  2888. }
  2889. ClassNode *newclass = alloc_node<ClassNode>();
  2890. newclass->initializer = alloc_node<BlockNode>();
  2891. newclass->initializer->parent_class = newclass;
  2892. newclass->ready = alloc_node<BlockNode>();
  2893. newclass->ready->parent_class = newclass;
  2894. newclass->name = name;
  2895. newclass->owner = p_class;
  2896. p_class->subclasses.push_back(newclass);
  2897. if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_EXTENDS) {
  2898. _parse_extends(newclass);
  2899. if (error_set)
  2900. return;
  2901. }
  2902. if (!_enter_indent_block()) {
  2903. _set_error("Indented block expected.");
  2904. return;
  2905. }
  2906. current_class = newclass;
  2907. _parse_class(newclass);
  2908. current_class = p_class;
  2909. } break;
  2910. /* this is for functions....
  2911. case GDScriptTokenizer::TK_CF_PASS: {
  2912. tokenizer->advance(1);
  2913. } break;
  2914. */
  2915. case GDScriptTokenizer::TK_PR_STATIC: {
  2916. tokenizer->advance();
  2917. if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
  2918. _set_error("Expected 'func'.");
  2919. return;
  2920. }
  2921. }; //fallthrough to function
  2922. case GDScriptTokenizer::TK_PR_FUNCTION: {
  2923. bool _static = false;
  2924. pending_newline = -1;
  2925. if (tokenizer->get_token(-1) == GDScriptTokenizer::TK_PR_STATIC) {
  2926. _static = true;
  2927. }
  2928. tokenizer->advance();
  2929. StringName name;
  2930. if (_get_completable_identifier(COMPLETION_VIRTUAL_FUNC, name)) {
  2931. }
  2932. if (name == StringName()) {
  2933. _set_error("Expected identifier after 'func' (syntax: 'func <identifier>([arguments]):' ).");
  2934. return;
  2935. }
  2936. for (int i = 0; i < p_class->functions.size(); i++) {
  2937. if (p_class->functions[i]->name == name) {
  2938. _set_error("Function '" + String(name) + "' already exists in this class (at line: " + itos(p_class->functions[i]->line) + ").");
  2939. }
  2940. }
  2941. for (int i = 0; i < p_class->static_functions.size(); i++) {
  2942. if (p_class->static_functions[i]->name == name) {
  2943. _set_error("Function '" + String(name) + "' already exists in this class (at line: " + itos(p_class->static_functions[i]->line) + ").");
  2944. }
  2945. }
  2946. #ifdef DEBUG_ENABLED
  2947. if (p_class->constant_expressions.has(name)) {
  2948. _add_warning(GDScriptWarning::FUNCTION_CONFLICTS_CONSTANT, -1, name);
  2949. }
  2950. for (int i = 0; i < p_class->variables.size(); i++) {
  2951. if (p_class->variables[i].identifier == name) {
  2952. _add_warning(GDScriptWarning::FUNCTION_CONFLICTS_VARIABLE, -1, name);
  2953. }
  2954. }
  2955. #endif // DEBUG_ENABLED
  2956. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
  2957. _set_error("Expected '(' after identifier (syntax: 'func <identifier>([arguments]):' ).");
  2958. return;
  2959. }
  2960. tokenizer->advance();
  2961. Vector<StringName> arguments;
  2962. Vector<DataType> argument_types;
  2963. Vector<Node *> default_values;
  2964. #ifdef DEBUG_ENABLED
  2965. Vector<int> arguments_usage;
  2966. #endif // DEBUG_ENABLED
  2967. int fnline = tokenizer->get_token_line();
  2968. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  2969. //has arguments
  2970. bool defaulting = false;
  2971. while (true) {
  2972. if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
  2973. tokenizer->advance();
  2974. continue;
  2975. }
  2976. if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_VAR) {
  2977. tokenizer->advance(); //var before the identifier is allowed
  2978. }
  2979. if (!tokenizer->is_token_literal(0, true)) {
  2980. _set_error("Expected identifier for argument.");
  2981. return;
  2982. }
  2983. StringName argname = tokenizer->get_token_identifier();
  2984. arguments.push_back(argname);
  2985. #ifdef DEBUG_ENABLED
  2986. arguments_usage.push_back(0);
  2987. #endif // DEBUG_ENABLED
  2988. tokenizer->advance();
  2989. DataType argtype;
  2990. if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
  2991. if (tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
  2992. argtype.infer_type = true;
  2993. tokenizer->advance();
  2994. } else if (!_parse_type(argtype)) {
  2995. _set_error("Expected type for argument.");
  2996. return;
  2997. }
  2998. }
  2999. argument_types.push_back(argtype);
  3000. if (defaulting && tokenizer->get_token() != GDScriptTokenizer::TK_OP_ASSIGN) {
  3001. _set_error("Default parameter expected.");
  3002. return;
  3003. }
  3004. //tokenizer->advance();
  3005. if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ASSIGN) {
  3006. defaulting = true;
  3007. tokenizer->advance(1);
  3008. Node *defval = _parse_and_reduce_expression(p_class, _static);
  3009. if (!defval || error_set)
  3010. return;
  3011. OperatorNode *on = alloc_node<OperatorNode>();
  3012. on->op = OperatorNode::OP_ASSIGN;
  3013. on->line = fnline;
  3014. IdentifierNode *in = alloc_node<IdentifierNode>();
  3015. in->name = argname;
  3016. in->line = fnline;
  3017. on->arguments.push_back(in);
  3018. on->arguments.push_back(defval);
  3019. /* no ..
  3020. if (defval->type!=Node::TYPE_CONSTANT) {
  3021. _set_error("default argument must be constant");
  3022. }
  3023. */
  3024. default_values.push_back(on);
  3025. }
  3026. while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
  3027. tokenizer->advance();
  3028. }
  3029. if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  3030. tokenizer->advance();
  3031. continue;
  3032. } else if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  3033. _set_error("Expected ',' or ')'.");
  3034. return;
  3035. }
  3036. break;
  3037. }
  3038. }
  3039. tokenizer->advance();
  3040. BlockNode *block = alloc_node<BlockNode>();
  3041. block->parent_class = p_class;
  3042. FunctionNode *function = alloc_node<FunctionNode>();
  3043. function->name = name;
  3044. function->arguments = arguments;
  3045. function->argument_types = argument_types;
  3046. function->default_values = default_values;
  3047. function->_static = _static;
  3048. function->line = fnline;
  3049. #ifdef DEBUG_ENABLED
  3050. function->arguments_usage = arguments_usage;
  3051. #endif // DEBUG_ENABLED
  3052. function->rpc_mode = rpc_mode;
  3053. rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
  3054. if (name == "_init") {
  3055. if (_static) {
  3056. _set_error("Constructor cannot be static.");
  3057. return;
  3058. }
  3059. if (p_class->extends_used) {
  3060. OperatorNode *cparent = alloc_node<OperatorNode>();
  3061. cparent->op = OperatorNode::OP_PARENT_CALL;
  3062. block->statements.push_back(cparent);
  3063. IdentifierNode *id = alloc_node<IdentifierNode>();
  3064. id->name = "_init";
  3065. cparent->arguments.push_back(id);
  3066. if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD) {
  3067. tokenizer->advance();
  3068. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
  3069. _set_error("expected '(' for parent constructor arguments.");
  3070. return;
  3071. }
  3072. tokenizer->advance();
  3073. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  3074. //has arguments
  3075. parenthesis++;
  3076. while (true) {
  3077. current_function = function;
  3078. Node *arg = _parse_and_reduce_expression(p_class, _static);
  3079. current_function = NULL;
  3080. cparent->arguments.push_back(arg);
  3081. if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  3082. tokenizer->advance();
  3083. continue;
  3084. } else if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  3085. _set_error("Expected ',' or ')'.");
  3086. return;
  3087. }
  3088. break;
  3089. }
  3090. parenthesis--;
  3091. }
  3092. tokenizer->advance();
  3093. }
  3094. } else {
  3095. if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD) {
  3096. _set_error("Parent constructor call found for a class without inheritance.");
  3097. return;
  3098. }
  3099. }
  3100. }
  3101. DataType return_type;
  3102. if (tokenizer->get_token() == GDScriptTokenizer::TK_FORWARD_ARROW) {
  3103. if (!_parse_type(return_type, true)) {
  3104. _set_error("Expected return type for function.");
  3105. return;
  3106. }
  3107. }
  3108. if (!_enter_indent_block(block)) {
  3109. _set_error("Indented block expected.");
  3110. return;
  3111. }
  3112. function->return_type = return_type;
  3113. if (_static)
  3114. p_class->static_functions.push_back(function);
  3115. else
  3116. p_class->functions.push_back(function);
  3117. current_function = function;
  3118. function->body = block;
  3119. current_block = block;
  3120. _parse_block(block, _static);
  3121. current_block = NULL;
  3122. //arguments
  3123. } break;
  3124. case GDScriptTokenizer::TK_PR_SIGNAL: {
  3125. tokenizer->advance();
  3126. if (!tokenizer->is_token_literal()) {
  3127. _set_error("Expected identifier after 'signal'.");
  3128. return;
  3129. }
  3130. ClassNode::Signal sig;
  3131. sig.name = tokenizer->get_token_identifier();
  3132. sig.emissions = 0;
  3133. sig.line = tokenizer->get_token_line();
  3134. tokenizer->advance();
  3135. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
  3136. tokenizer->advance();
  3137. while (true) {
  3138. if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
  3139. tokenizer->advance();
  3140. continue;
  3141. }
  3142. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  3143. tokenizer->advance();
  3144. break;
  3145. }
  3146. if (!tokenizer->is_token_literal(0, true)) {
  3147. _set_error("Expected identifier in signal argument.");
  3148. return;
  3149. }
  3150. sig.arguments.push_back(tokenizer->get_token_identifier());
  3151. tokenizer->advance();
  3152. while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
  3153. tokenizer->advance();
  3154. }
  3155. if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  3156. tokenizer->advance();
  3157. } else if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  3158. _set_error("Expected ',' or ')' after signal parameter identifier.");
  3159. return;
  3160. }
  3161. }
  3162. }
  3163. p_class->_signals.push_back(sig);
  3164. if (!_end_statement()) {
  3165. _set_error("Expected end of statement (signal)");
  3166. return;
  3167. }
  3168. } break;
  3169. case GDScriptTokenizer::TK_PR_EXPORT: {
  3170. tokenizer->advance();
  3171. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
  3172. tokenizer->advance();
  3173. String hint_prefix = "";
  3174. bool is_arrayed = false;
  3175. while (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE &&
  3176. tokenizer->get_token_type() == Variant::ARRAY &&
  3177. tokenizer->get_token(1) == GDScriptTokenizer::TK_COMMA) {
  3178. tokenizer->advance(); // Array
  3179. tokenizer->advance(); // Comma
  3180. if (is_arrayed) {
  3181. hint_prefix += itos(Variant::ARRAY) + ":";
  3182. } else {
  3183. is_arrayed = true;
  3184. }
  3185. }
  3186. if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE) {
  3187. Variant::Type type = tokenizer->get_token_type();
  3188. if (type == Variant::NIL) {
  3189. _set_error("Can't export null type.");
  3190. return;
  3191. }
  3192. if (type == Variant::OBJECT) {
  3193. _set_error("Can't export raw object type.");
  3194. return;
  3195. }
  3196. current_export.type = type;
  3197. current_export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
  3198. tokenizer->advance();
  3199. if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  3200. // hint expected next!
  3201. tokenizer->advance();
  3202. switch (type) {
  3203. case Variant::INT: {
  3204. if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "FLAGS") {
  3205. tokenizer->advance();
  3206. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  3207. ERR_EXPLAIN("Exporting bit flags hint requires string constants.");
  3208. WARN_DEPRECATED
  3209. break;
  3210. }
  3211. if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
  3212. _set_error("Expected ',' in bit flags hint.");
  3213. return;
  3214. }
  3215. current_export.hint = PROPERTY_HINT_FLAGS;
  3216. tokenizer->advance();
  3217. bool first = true;
  3218. while (true) {
  3219. if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
  3220. current_export = PropertyInfo();
  3221. _set_error("Expected a string constant in named bit flags hint.");
  3222. return;
  3223. }
  3224. String c = tokenizer->get_token_constant();
  3225. if (!first)
  3226. current_export.hint_string += ",";
  3227. else
  3228. first = false;
  3229. current_export.hint_string += c.xml_escape();
  3230. tokenizer->advance();
  3231. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE)
  3232. break;
  3233. if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
  3234. current_export = PropertyInfo();
  3235. _set_error("Expected ')' or ',' in named bit flags hint.");
  3236. return;
  3237. }
  3238. tokenizer->advance();
  3239. }
  3240. break;
  3241. }
  3242. if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING) {
  3243. //enumeration
  3244. current_export.hint = PROPERTY_HINT_ENUM;
  3245. bool first = true;
  3246. while (true) {
  3247. if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
  3248. current_export = PropertyInfo();
  3249. _set_error("Expected a string constant in enumeration hint.");
  3250. return;
  3251. }
  3252. String c = tokenizer->get_token_constant();
  3253. if (!first)
  3254. current_export.hint_string += ",";
  3255. else
  3256. first = false;
  3257. current_export.hint_string += c.xml_escape();
  3258. tokenizer->advance();
  3259. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE)
  3260. break;
  3261. if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
  3262. current_export = PropertyInfo();
  3263. _set_error("Expected ')' or ',' in enumeration hint.");
  3264. return;
  3265. }
  3266. tokenizer->advance();
  3267. }
  3268. break;
  3269. }
  3270. }; //fallthrough to use the same
  3271. case Variant::REAL: {
  3272. if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "EASE") {
  3273. current_export.hint = PROPERTY_HINT_EXP_EASING;
  3274. tokenizer->advance();
  3275. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  3276. _set_error("Expected ')' in hint.");
  3277. return;
  3278. }
  3279. break;
  3280. }
  3281. // range
  3282. if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "EXP") {
  3283. current_export.hint = PROPERTY_HINT_EXP_RANGE;
  3284. tokenizer->advance();
  3285. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE)
  3286. break;
  3287. else if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
  3288. _set_error("Expected ')' or ',' in exponential range hint.");
  3289. return;
  3290. }
  3291. tokenizer->advance();
  3292. } else
  3293. current_export.hint = PROPERTY_HINT_RANGE;
  3294. float sign = 1.0;
  3295. if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_SUB) {
  3296. sign = -1;
  3297. tokenizer->advance();
  3298. }
  3299. if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
  3300. current_export = PropertyInfo();
  3301. _set_error("Expected a range in numeric hint.");
  3302. return;
  3303. }
  3304. current_export.hint_string = rtos(sign * double(tokenizer->get_token_constant()));
  3305. tokenizer->advance();
  3306. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  3307. current_export.hint_string = "0," + current_export.hint_string;
  3308. break;
  3309. }
  3310. if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
  3311. current_export = PropertyInfo();
  3312. _set_error("Expected ',' or ')' in numeric range hint.");
  3313. return;
  3314. }
  3315. tokenizer->advance();
  3316. sign = 1.0;
  3317. if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_SUB) {
  3318. sign = -1;
  3319. tokenizer->advance();
  3320. }
  3321. if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
  3322. current_export = PropertyInfo();
  3323. _set_error("Expected a number as upper bound in numeric range hint.");
  3324. return;
  3325. }
  3326. current_export.hint_string += "," + rtos(sign * double(tokenizer->get_token_constant()));
  3327. tokenizer->advance();
  3328. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE)
  3329. break;
  3330. if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
  3331. current_export = PropertyInfo();
  3332. _set_error("Expected ',' or ')' in numeric range hint.");
  3333. return;
  3334. }
  3335. tokenizer->advance();
  3336. sign = 1.0;
  3337. if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_SUB) {
  3338. sign = -1;
  3339. tokenizer->advance();
  3340. }
  3341. if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
  3342. current_export = PropertyInfo();
  3343. _set_error("Expected a number as step in numeric range hint.");
  3344. return;
  3345. }
  3346. current_export.hint_string += "," + rtos(sign * double(tokenizer->get_token_constant()));
  3347. tokenizer->advance();
  3348. } break;
  3349. case Variant::STRING: {
  3350. if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING) {
  3351. //enumeration
  3352. current_export.hint = PROPERTY_HINT_ENUM;
  3353. bool first = true;
  3354. while (true) {
  3355. if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
  3356. current_export = PropertyInfo();
  3357. _set_error("Expected a string constant in enumeration hint.");
  3358. return;
  3359. }
  3360. String c = tokenizer->get_token_constant();
  3361. if (!first)
  3362. current_export.hint_string += ",";
  3363. else
  3364. first = false;
  3365. current_export.hint_string += c.xml_escape();
  3366. tokenizer->advance();
  3367. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE)
  3368. break;
  3369. if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
  3370. current_export = PropertyInfo();
  3371. _set_error("Expected ')' or ',' in enumeration hint.");
  3372. return;
  3373. }
  3374. tokenizer->advance();
  3375. }
  3376. break;
  3377. }
  3378. if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "DIR") {
  3379. tokenizer->advance();
  3380. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE)
  3381. current_export.hint = PROPERTY_HINT_DIR;
  3382. else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  3383. tokenizer->advance();
  3384. if (tokenizer->get_token() != GDScriptTokenizer::TK_IDENTIFIER || !(tokenizer->get_token_identifier() == "GLOBAL")) {
  3385. _set_error("Expected 'GLOBAL' after comma in directory hint.");
  3386. return;
  3387. }
  3388. if (!p_class->tool) {
  3389. _set_error("Global filesystem hints may only be used in tool scripts.");
  3390. return;
  3391. }
  3392. current_export.hint = PROPERTY_HINT_GLOBAL_DIR;
  3393. tokenizer->advance();
  3394. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  3395. _set_error("Expected ')' in hint.");
  3396. return;
  3397. }
  3398. } else {
  3399. _set_error("Expected ')' or ',' in hint.");
  3400. return;
  3401. }
  3402. break;
  3403. }
  3404. if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "FILE") {
  3405. current_export.hint = PROPERTY_HINT_FILE;
  3406. tokenizer->advance();
  3407. if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  3408. tokenizer->advance();
  3409. if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "GLOBAL") {
  3410. if (!p_class->tool) {
  3411. _set_error("Global filesystem hints may only be used in tool scripts.");
  3412. return;
  3413. }
  3414. current_export.hint = PROPERTY_HINT_GLOBAL_FILE;
  3415. tokenizer->advance();
  3416. if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE)
  3417. break;
  3418. else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA)
  3419. tokenizer->advance();
  3420. else {
  3421. _set_error("Expected ')' or ',' in hint.");
  3422. return;
  3423. }
  3424. }
  3425. if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
  3426. if (current_export.hint == PROPERTY_HINT_GLOBAL_FILE)
  3427. _set_error("Expected string constant with filter");
  3428. else
  3429. _set_error("Expected 'GLOBAL' or string constant with filter");
  3430. return;
  3431. }
  3432. current_export.hint_string = tokenizer->get_token_constant();
  3433. tokenizer->advance();
  3434. }
  3435. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  3436. _set_error("Expected ')' in hint.");
  3437. return;
  3438. }
  3439. break;
  3440. }
  3441. if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "MULTILINE") {
  3442. current_export.hint = PROPERTY_HINT_MULTILINE_TEXT;
  3443. tokenizer->advance();
  3444. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  3445. _set_error("Expected ')' in hint.");
  3446. return;
  3447. }
  3448. break;
  3449. }
  3450. } break;
  3451. case Variant::COLOR: {
  3452. if (tokenizer->get_token() != GDScriptTokenizer::TK_IDENTIFIER) {
  3453. current_export = PropertyInfo();
  3454. _set_error("Color type hint expects RGB or RGBA as hints");
  3455. return;
  3456. }
  3457. String identifier = tokenizer->get_token_identifier();
  3458. if (identifier == "RGB") {
  3459. current_export.hint = PROPERTY_HINT_COLOR_NO_ALPHA;
  3460. } else if (identifier == "RGBA") {
  3461. //none
  3462. } else {
  3463. current_export = PropertyInfo();
  3464. _set_error("Color type hint expects RGB or RGBA as hints");
  3465. return;
  3466. }
  3467. tokenizer->advance();
  3468. } break;
  3469. default: {
  3470. current_export = PropertyInfo();
  3471. _set_error("Type '" + Variant::get_type_name(type) + "' can't take hints.");
  3472. return;
  3473. } break;
  3474. }
  3475. }
  3476. } else {
  3477. parenthesis++;
  3478. Node *subexpr = _parse_and_reduce_expression(p_class, true, true);
  3479. if (!subexpr) {
  3480. if (_recover_from_completion()) {
  3481. break;
  3482. }
  3483. return;
  3484. }
  3485. parenthesis--;
  3486. if (subexpr->type != Node::TYPE_CONSTANT) {
  3487. current_export = PropertyInfo();
  3488. _set_error("Expected a constant expression.");
  3489. }
  3490. Variant constant = static_cast<ConstantNode *>(subexpr)->value;
  3491. if (constant.get_type() == Variant::OBJECT) {
  3492. GDScriptNativeClass *native_class = Object::cast_to<GDScriptNativeClass>(constant);
  3493. if (native_class && ClassDB::is_parent_class(native_class->get_name(), "Resource")) {
  3494. current_export.type = Variant::OBJECT;
  3495. current_export.hint = PROPERTY_HINT_RESOURCE_TYPE;
  3496. current_export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
  3497. current_export.hint_string = native_class->get_name();
  3498. current_export.class_name = native_class->get_name();
  3499. } else {
  3500. current_export = PropertyInfo();
  3501. _set_error("Export hint not a resource type.");
  3502. }
  3503. } else if (constant.get_type() == Variant::DICTIONARY) {
  3504. // Enumeration
  3505. bool is_flags = false;
  3506. if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  3507. tokenizer->advance();
  3508. if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "FLAGS") {
  3509. is_flags = true;
  3510. tokenizer->advance();
  3511. } else {
  3512. current_export = PropertyInfo();
  3513. _set_error("Expected 'FLAGS' after comma.");
  3514. }
  3515. }
  3516. current_export.type = Variant::INT;
  3517. current_export.hint = is_flags ? PROPERTY_HINT_FLAGS : PROPERTY_HINT_ENUM;
  3518. current_export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
  3519. Dictionary enum_values = constant;
  3520. List<Variant> keys;
  3521. enum_values.get_key_list(&keys);
  3522. bool first = true;
  3523. for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
  3524. if (enum_values[E->get()].get_type() == Variant::INT) {
  3525. if (!first)
  3526. current_export.hint_string += ",";
  3527. else
  3528. first = false;
  3529. current_export.hint_string += E->get().operator String().camelcase_to_underscore(true).capitalize().xml_escape();
  3530. if (!is_flags) {
  3531. current_export.hint_string += ":";
  3532. current_export.hint_string += enum_values[E->get()].operator String().xml_escape();
  3533. }
  3534. }
  3535. }
  3536. } else {
  3537. current_export = PropertyInfo();
  3538. _set_error("Expected type for export.");
  3539. return;
  3540. }
  3541. }
  3542. if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
  3543. current_export = PropertyInfo();
  3544. _set_error("Expected ')' or ',' after export hint.");
  3545. return;
  3546. }
  3547. if (is_arrayed) {
  3548. hint_prefix += itos(current_export.type);
  3549. if (current_export.hint) {
  3550. hint_prefix += "/" + itos(current_export.hint);
  3551. }
  3552. current_export.hint_string = hint_prefix + ":" + current_export.hint_string;
  3553. current_export.hint = PROPERTY_HINT_TYPE_STRING;
  3554. current_export.type = Variant::ARRAY;
  3555. }
  3556. tokenizer->advance();
  3557. }
  3558. if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_ONREADY && tokenizer->get_token() != GDScriptTokenizer::TK_PR_REMOTE && tokenizer->get_token() != GDScriptTokenizer::TK_PR_MASTER && tokenizer->get_token() != GDScriptTokenizer::TK_PR_PUPPET && tokenizer->get_token() != GDScriptTokenizer::TK_PR_SYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_REMOTESYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_MASTERSYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_PUPPETSYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_SLAVE) {
  3559. current_export = PropertyInfo();
  3560. _set_error("Expected 'var', 'onready', 'remote', 'master', 'puppet', 'sync', 'remotesync', 'mastersync', 'puppetsync'.");
  3561. return;
  3562. }
  3563. continue;
  3564. } break;
  3565. case GDScriptTokenizer::TK_PR_ONREADY: {
  3566. //may be fallthrough from export, ignore if so
  3567. tokenizer->advance();
  3568. if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR) {
  3569. _set_error("Expected 'var'.");
  3570. return;
  3571. }
  3572. continue;
  3573. } break;
  3574. case GDScriptTokenizer::TK_PR_REMOTE: {
  3575. //may be fallthrough from export, ignore if so
  3576. tokenizer->advance();
  3577. if (current_export.type) {
  3578. if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR) {
  3579. _set_error("Expected 'var'.");
  3580. return;
  3581. }
  3582. } else {
  3583. if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
  3584. _set_error("Expected 'var' or 'func'.");
  3585. return;
  3586. }
  3587. }
  3588. rpc_mode = MultiplayerAPI::RPC_MODE_REMOTE;
  3589. continue;
  3590. } break;
  3591. case GDScriptTokenizer::TK_PR_MASTER: {
  3592. //may be fallthrough from export, ignore if so
  3593. tokenizer->advance();
  3594. if (current_export.type) {
  3595. if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR) {
  3596. _set_error("Expected 'var'.");
  3597. return;
  3598. }
  3599. } else {
  3600. if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
  3601. _set_error("Expected 'var' or 'func'.");
  3602. return;
  3603. }
  3604. }
  3605. rpc_mode = MultiplayerAPI::RPC_MODE_MASTER;
  3606. continue;
  3607. } break;
  3608. case GDScriptTokenizer::TK_PR_SLAVE:
  3609. #ifdef DEBUG_ENABLED
  3610. _add_warning(GDScriptWarning::DEPRECATED_KEYWORD, tokenizer->get_token_line(), "slave", "puppet");
  3611. #endif
  3612. case GDScriptTokenizer::TK_PR_PUPPET: {
  3613. //may be fallthrough from export, ignore if so
  3614. tokenizer->advance();
  3615. if (current_export.type) {
  3616. if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR) {
  3617. _set_error("Expected 'var'.");
  3618. return;
  3619. }
  3620. } else {
  3621. if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
  3622. _set_error("Expected 'var' or 'func'.");
  3623. return;
  3624. }
  3625. }
  3626. rpc_mode = MultiplayerAPI::RPC_MODE_PUPPET;
  3627. continue;
  3628. } break;
  3629. case GDScriptTokenizer::TK_PR_REMOTESYNC:
  3630. case GDScriptTokenizer::TK_PR_SYNC: {
  3631. //may be fallthrough from export, ignore if so
  3632. tokenizer->advance();
  3633. if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
  3634. if (current_export.type)
  3635. _set_error("Expected 'var'.");
  3636. else
  3637. _set_error("Expected 'var' or 'func'.");
  3638. return;
  3639. }
  3640. rpc_mode = MultiplayerAPI::RPC_MODE_REMOTESYNC;
  3641. continue;
  3642. } break;
  3643. case GDScriptTokenizer::TK_PR_MASTERSYNC: {
  3644. //may be fallthrough from export, ignore if so
  3645. tokenizer->advance();
  3646. if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
  3647. if (current_export.type)
  3648. _set_error("Expected 'var'.");
  3649. else
  3650. _set_error("Expected 'var' or 'func'.");
  3651. return;
  3652. }
  3653. rpc_mode = MultiplayerAPI::RPC_MODE_MASTERSYNC;
  3654. continue;
  3655. } break;
  3656. case GDScriptTokenizer::TK_PR_PUPPETSYNC: {
  3657. //may be fallthrough from export, ignore if so
  3658. tokenizer->advance();
  3659. if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
  3660. if (current_export.type)
  3661. _set_error("Expected 'var'.");
  3662. else
  3663. _set_error("Expected 'var' or 'func'.");
  3664. return;
  3665. }
  3666. rpc_mode = MultiplayerAPI::RPC_MODE_PUPPETSYNC;
  3667. continue;
  3668. } break;
  3669. case GDScriptTokenizer::TK_PR_VAR: {
  3670. //variale declaration and (eventual) initialization
  3671. ClassNode::Member member;
  3672. bool autoexport = tokenizer->get_token(-1) == GDScriptTokenizer::TK_PR_EXPORT;
  3673. if (current_export.type != Variant::NIL) {
  3674. member._export = current_export;
  3675. current_export = PropertyInfo();
  3676. }
  3677. bool onready = tokenizer->get_token(-1) == GDScriptTokenizer::TK_PR_ONREADY;
  3678. tokenizer->advance();
  3679. if (!tokenizer->is_token_literal(0, true)) {
  3680. _set_error("Expected identifier for member variable name.");
  3681. return;
  3682. }
  3683. member.identifier = tokenizer->get_token_literal();
  3684. member.expression = NULL;
  3685. member._export.name = member.identifier;
  3686. member.line = tokenizer->get_token_line();
  3687. member.usages = 0;
  3688. member.rpc_mode = rpc_mode;
  3689. #ifdef TOOLS_ENABLED
  3690. Variant::CallError ce;
  3691. member.default_value = Variant::construct(member._export.type, NULL, 0, ce);
  3692. #endif
  3693. if (current_class->constant_expressions.has(member.identifier)) {
  3694. _set_error("A constant named '" + String(member.identifier) + "' already exists in this class (at line: " +
  3695. itos(current_class->constant_expressions[member.identifier].expression->line) + ").");
  3696. return;
  3697. }
  3698. for (int i = 0; i < current_class->variables.size(); i++) {
  3699. if (current_class->variables[i].identifier == member.identifier) {
  3700. _set_error("Variable '" + String(member.identifier) + "' already exists in this class (at line: " +
  3701. itos(current_class->variables[i].line) + ").");
  3702. return;
  3703. }
  3704. }
  3705. #ifdef DEBUG_ENABLED
  3706. for (int i = 0; i < current_class->functions.size(); i++) {
  3707. if (current_class->functions[i]->name == member.identifier) {
  3708. _add_warning(GDScriptWarning::VARIABLE_CONFLICTS_FUNCTION, member.line, member.identifier);
  3709. break;
  3710. }
  3711. }
  3712. for (int i = 0; i < current_class->static_functions.size(); i++) {
  3713. if (current_class->static_functions[i]->name == member.identifier) {
  3714. _add_warning(GDScriptWarning::VARIABLE_CONFLICTS_FUNCTION, member.line, member.identifier);
  3715. break;
  3716. }
  3717. }
  3718. #endif // DEBUG_ENABLED
  3719. tokenizer->advance();
  3720. rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
  3721. if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
  3722. if (tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
  3723. member.data_type = DataType();
  3724. #ifdef DEBUG_ENABLED
  3725. member.data_type.infer_type = true;
  3726. #endif
  3727. tokenizer->advance();
  3728. } else if (!_parse_type(member.data_type)) {
  3729. _set_error("Expected type for class variable.");
  3730. return;
  3731. }
  3732. }
  3733. if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ASSIGN) {
  3734. #ifdef DEBUG_ENABLED
  3735. int line = tokenizer->get_token_line();
  3736. #endif
  3737. tokenizer->advance();
  3738. Node *subexpr = _parse_and_reduce_expression(p_class, false, autoexport || member._export.type != Variant::NIL);
  3739. if (!subexpr) {
  3740. if (_recover_from_completion()) {
  3741. break;
  3742. }
  3743. return;
  3744. }
  3745. //discourage common error
  3746. if (!onready && subexpr->type == Node::TYPE_OPERATOR) {
  3747. OperatorNode *op = static_cast<OperatorNode *>(subexpr);
  3748. if (op->op == OperatorNode::OP_CALL && op->arguments[0]->type == Node::TYPE_SELF && op->arguments[1]->type == Node::TYPE_IDENTIFIER) {
  3749. IdentifierNode *id = static_cast<IdentifierNode *>(op->arguments[1]);
  3750. if (id->name == "get_node") {
  3751. _set_error("Use 'onready var " + String(member.identifier) + " = get_node(..)' instead");
  3752. return;
  3753. }
  3754. }
  3755. }
  3756. member.expression = subexpr;
  3757. if (autoexport && !member.data_type.has_type) {
  3758. if (subexpr->type != Node::TYPE_CONSTANT) {
  3759. _set_error("Type-less export needs a constant expression assigned to infer type.");
  3760. return;
  3761. }
  3762. ConstantNode *cn = static_cast<ConstantNode *>(subexpr);
  3763. if (cn->value.get_type() == Variant::NIL) {
  3764. _set_error("Can't accept a null constant expression for inferring export type.");
  3765. return;
  3766. }
  3767. member._export.type = cn->value.get_type();
  3768. member._export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
  3769. if (cn->value.get_type() == Variant::OBJECT) {
  3770. Object *obj = cn->value;
  3771. Resource *res = Object::cast_to<Resource>(obj);
  3772. if (res == NULL) {
  3773. _set_error("Exported constant not a type or resource.");
  3774. return;
  3775. }
  3776. member._export.hint = PROPERTY_HINT_RESOURCE_TYPE;
  3777. member._export.hint_string = res->get_class();
  3778. }
  3779. }
  3780. #ifdef TOOLS_ENABLED
  3781. if (subexpr->type == Node::TYPE_CONSTANT && (member._export.type != Variant::NIL || member.data_type.has_type)) {
  3782. ConstantNode *cn = static_cast<ConstantNode *>(subexpr);
  3783. if (cn->value.get_type() != Variant::NIL) {
  3784. member.default_value = cn->value;
  3785. }
  3786. }
  3787. #endif
  3788. IdentifierNode *id = alloc_node<IdentifierNode>();
  3789. id->name = member.identifier;
  3790. OperatorNode *op = alloc_node<OperatorNode>();
  3791. op->op = OperatorNode::OP_INIT_ASSIGN;
  3792. op->arguments.push_back(id);
  3793. op->arguments.push_back(subexpr);
  3794. #ifdef DEBUG_ENABLED
  3795. NewLineNode *nl = alloc_node<NewLineNode>();
  3796. nl->line = line;
  3797. if (onready)
  3798. p_class->ready->statements.push_back(nl);
  3799. else
  3800. p_class->initializer->statements.push_back(nl);
  3801. #endif
  3802. if (onready)
  3803. p_class->ready->statements.push_back(op);
  3804. else
  3805. p_class->initializer->statements.push_back(op);
  3806. member.initial_assignment = op;
  3807. } else {
  3808. if (autoexport && !member.data_type.has_type) {
  3809. _set_error("Type-less export needs a constant expression assigned to infer type.");
  3810. return;
  3811. }
  3812. }
  3813. if (autoexport && member.data_type.has_type) {
  3814. if (member.data_type.kind == DataType::BUILTIN) {
  3815. member._export.type = member.data_type.builtin_type;
  3816. } else if (member.data_type.kind == DataType::NATIVE) {
  3817. if (ClassDB::is_parent_class(member.data_type.native_type, "Resource")) {
  3818. member._export.type = Variant::OBJECT;
  3819. member._export.hint = PROPERTY_HINT_RESOURCE_TYPE;
  3820. member._export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
  3821. member._export.hint_string = member.data_type.native_type;
  3822. member._export.class_name = member.data_type.native_type;
  3823. } else {
  3824. _set_error("Invalid export type. Only built-in and native resource types can be exported.", member.line);
  3825. return;
  3826. }
  3827. } else {
  3828. _set_error("Invalid export type. Only built-in and native resource types can be exported.", member.line);
  3829. return;
  3830. }
  3831. }
  3832. if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_SETGET) {
  3833. tokenizer->advance();
  3834. if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
  3835. //just comma means using only getter
  3836. if (!tokenizer->is_token_literal()) {
  3837. _set_error("Expected identifier for setter function after 'setget'.");
  3838. }
  3839. member.setter = tokenizer->get_token_literal();
  3840. tokenizer->advance();
  3841. }
  3842. if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  3843. //there is a getter
  3844. tokenizer->advance();
  3845. if (!tokenizer->is_token_literal()) {
  3846. _set_error("Expected identifier for getter function after ','.");
  3847. }
  3848. member.getter = tokenizer->get_token_literal();
  3849. tokenizer->advance();
  3850. }
  3851. }
  3852. p_class->variables.push_back(member);
  3853. if (!_end_statement()) {
  3854. _set_error("Expected end of statement (continue)");
  3855. return;
  3856. }
  3857. } break;
  3858. case GDScriptTokenizer::TK_PR_CONST: {
  3859. // constant declaration and initialization
  3860. ClassNode::Constant constant;
  3861. tokenizer->advance();
  3862. if (!tokenizer->is_token_literal(0, true)) {
  3863. _set_error("Expected name (identifier) for constant.");
  3864. return;
  3865. }
  3866. StringName const_id = tokenizer->get_token_literal();
  3867. int line = tokenizer->get_token_line();
  3868. if (current_class->constant_expressions.has(const_id)) {
  3869. _set_error("Constant '" + String(const_id) + "' already exists in this class (at line: " +
  3870. itos(current_class->constant_expressions[const_id].expression->line) + ").");
  3871. return;
  3872. }
  3873. for (int i = 0; i < current_class->variables.size(); i++) {
  3874. if (current_class->variables[i].identifier == const_id) {
  3875. _set_error("A variable named '" + String(const_id) + "' already exists in this class (at line: " +
  3876. itos(current_class->variables[i].line) + ").");
  3877. return;
  3878. }
  3879. }
  3880. tokenizer->advance();
  3881. if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
  3882. if (tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
  3883. constant.type = DataType();
  3884. #ifdef DEBUG_ENABLED
  3885. constant.type.infer_type = true;
  3886. #endif
  3887. tokenizer->advance();
  3888. } else if (!_parse_type(constant.type)) {
  3889. _set_error("Expected type for class constant.");
  3890. return;
  3891. }
  3892. }
  3893. if (tokenizer->get_token() != GDScriptTokenizer::TK_OP_ASSIGN) {
  3894. _set_error("Constant expects assignment.");
  3895. return;
  3896. }
  3897. tokenizer->advance();
  3898. Node *subexpr = _parse_and_reduce_expression(p_class, true, true);
  3899. if (!subexpr) {
  3900. if (_recover_from_completion()) {
  3901. break;
  3902. }
  3903. return;
  3904. }
  3905. if (subexpr->type != Node::TYPE_CONSTANT) {
  3906. _set_error("Expected constant expression", line);
  3907. return;
  3908. }
  3909. subexpr->line = line;
  3910. constant.expression = subexpr;
  3911. p_class->constant_expressions.insert(const_id, constant);
  3912. if (!_end_statement()) {
  3913. _set_error("Expected end of statement (constant)", line);
  3914. return;
  3915. }
  3916. } break;
  3917. case GDScriptTokenizer::TK_PR_ENUM: {
  3918. //multiple constant declarations..
  3919. int last_assign = -1; // Incremented by 1 right before the assignment.
  3920. String enum_name;
  3921. Dictionary enum_dict;
  3922. tokenizer->advance();
  3923. if (tokenizer->is_token_literal(0, true)) {
  3924. enum_name = tokenizer->get_token_literal();
  3925. if (current_class->constant_expressions.has(enum_name)) {
  3926. _set_error("A constant named '" + String(enum_name) + "' already exists in this class (at line: " +
  3927. itos(current_class->constant_expressions[enum_name].expression->line) + ").");
  3928. return;
  3929. }
  3930. for (int i = 0; i < current_class->variables.size(); i++) {
  3931. if (current_class->variables[i].identifier == enum_name) {
  3932. _set_error("A variable named '" + String(enum_name) + "' already exists in this class (at line: " +
  3933. itos(current_class->variables[i].line) + ").");
  3934. return;
  3935. }
  3936. }
  3937. tokenizer->advance();
  3938. }
  3939. if (tokenizer->get_token() != GDScriptTokenizer::TK_CURLY_BRACKET_OPEN) {
  3940. _set_error("Expected '{' in enum declaration");
  3941. return;
  3942. }
  3943. tokenizer->advance();
  3944. while (true) {
  3945. if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
  3946. tokenizer->advance(); // Ignore newlines
  3947. } else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
  3948. tokenizer->advance();
  3949. break; // End of enum
  3950. } else if (!tokenizer->is_token_literal(0, true)) {
  3951. if (tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
  3952. _set_error("Unexpected end of file.");
  3953. } else {
  3954. _set_error(String("Unexpected ") + GDScriptTokenizer::get_token_name(tokenizer->get_token()) + ", expected identifier");
  3955. }
  3956. return;
  3957. } else { // tokenizer->is_token_literal(0, true)
  3958. StringName const_id = tokenizer->get_token_literal();
  3959. tokenizer->advance();
  3960. ConstantNode *enum_value_expr;
  3961. if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ASSIGN) {
  3962. tokenizer->advance();
  3963. Node *subexpr = _parse_and_reduce_expression(p_class, true, true);
  3964. if (!subexpr) {
  3965. if (_recover_from_completion()) {
  3966. break;
  3967. }
  3968. return;
  3969. }
  3970. if (subexpr->type != Node::TYPE_CONSTANT) {
  3971. _set_error("Expected constant expression");
  3972. return;
  3973. }
  3974. enum_value_expr = static_cast<ConstantNode *>(subexpr);
  3975. if (enum_value_expr->value.get_type() != Variant::INT) {
  3976. _set_error("Expected an int value for enum");
  3977. return;
  3978. }
  3979. last_assign = enum_value_expr->value;
  3980. } else {
  3981. last_assign = last_assign + 1;
  3982. enum_value_expr = alloc_node<ConstantNode>();
  3983. enum_value_expr->value = last_assign;
  3984. enum_value_expr->datatype = _type_from_variant(enum_value_expr->value);
  3985. }
  3986. if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
  3987. tokenizer->advance();
  3988. }
  3989. if (enum_name != "") {
  3990. enum_dict[const_id] = enum_value_expr->value;
  3991. } else {
  3992. if (current_class->constant_expressions.has(const_id)) {
  3993. _set_error("A constant named '" + String(const_id) + "' already exists in this class (at line: " +
  3994. itos(current_class->constant_expressions[const_id].expression->line) + ").");
  3995. return;
  3996. }
  3997. for (int i = 0; i < current_class->variables.size(); i++) {
  3998. if (current_class->variables[i].identifier == const_id) {
  3999. _set_error("A variable named '" + String(const_id) + "' already exists in this class (at line: " +
  4000. itos(current_class->variables[i].line) + ").");
  4001. return;
  4002. }
  4003. }
  4004. ClassNode::Constant constant;
  4005. constant.type.has_type = true;
  4006. constant.type.kind = DataType::BUILTIN;
  4007. constant.type.builtin_type = Variant::INT;
  4008. constant.expression = enum_value_expr;
  4009. p_class->constant_expressions.insert(const_id, constant);
  4010. }
  4011. }
  4012. }
  4013. if (enum_name != "") {
  4014. ClassNode::Constant enum_constant;
  4015. ConstantNode *cn = alloc_node<ConstantNode>();
  4016. cn->value = enum_dict;
  4017. cn->datatype = _type_from_variant(cn->value);
  4018. enum_constant.expression = cn;
  4019. enum_constant.type = cn->datatype;
  4020. p_class->constant_expressions.insert(enum_name, enum_constant);
  4021. }
  4022. if (!_end_statement()) {
  4023. _set_error("Expected end of statement (enum)");
  4024. return;
  4025. }
  4026. } break;
  4027. case GDScriptTokenizer::TK_CONSTANT: {
  4028. if (tokenizer->get_token_constant().get_type() == Variant::STRING) {
  4029. tokenizer->advance();
  4030. // Ignore
  4031. } else {
  4032. _set_error(String() + "Unexpected constant of type: " + Variant::get_type_name(tokenizer->get_token_constant().get_type()));
  4033. return;
  4034. }
  4035. } break;
  4036. default: {
  4037. _set_error(String() + "Unexpected token: " + tokenizer->get_token_name(tokenizer->get_token()) + ":" + tokenizer->get_token_identifier());
  4038. return;
  4039. } break;
  4040. }
  4041. }
  4042. }
  4043. void GDScriptParser::_determine_inheritance(ClassNode *p_class) {
  4044. if (p_class->extends_used) {
  4045. //do inheritance
  4046. String path = p_class->extends_file;
  4047. Ref<GDScript> script;
  4048. StringName native;
  4049. ClassNode *base_class = NULL;
  4050. if (path != "") {
  4051. //path (and optionally subclasses)
  4052. if (path.is_rel_path()) {
  4053. String base = base_path;
  4054. if (base == "" || base.is_rel_path()) {
  4055. _set_error("Could not resolve relative path for parent class: " + path, p_class->line);
  4056. return;
  4057. }
  4058. path = base.plus_file(path).simplify_path();
  4059. }
  4060. script = ResourceLoader::load(path);
  4061. if (script.is_null()) {
  4062. _set_error("Could not load base class: " + path, p_class->line);
  4063. return;
  4064. }
  4065. if (!script->is_valid()) {
  4066. _set_error("Script not fully loaded (cyclic preload?): " + path, p_class->line);
  4067. return;
  4068. }
  4069. if (p_class->extends_class.size()) {
  4070. for (int i = 0; i < p_class->extends_class.size(); i++) {
  4071. String sub = p_class->extends_class[i];
  4072. if (script->get_subclasses().has(sub)) {
  4073. Ref<Script> subclass = script->get_subclasses()[sub]; //avoid reference from disappearing
  4074. script = subclass;
  4075. } else {
  4076. _set_error("Could not find subclass: " + sub, p_class->line);
  4077. return;
  4078. }
  4079. }
  4080. }
  4081. } else {
  4082. if (p_class->extends_class.size() == 0) {
  4083. _set_error("Parser bug: undecidable inheritance.", p_class->line);
  4084. ERR_FAIL();
  4085. }
  4086. //look around for the subclasses
  4087. int extend_iter = 1;
  4088. String base = p_class->extends_class[0];
  4089. ClassNode *p = p_class->owner;
  4090. Ref<GDScript> base_script;
  4091. if (ScriptServer::is_global_class(base)) {
  4092. base_script = ResourceLoader::load(ScriptServer::get_global_class_path(base));
  4093. if (!base_script.is_valid()) {
  4094. _set_error("Class '" + base + "' could not be fully loaded (script error or cyclic dependency).", p_class->line);
  4095. return;
  4096. }
  4097. p = NULL;
  4098. }
  4099. while (p) {
  4100. bool found = false;
  4101. for (int i = 0; i < p->subclasses.size(); i++) {
  4102. if (p->subclasses[i]->name == base) {
  4103. ClassNode *test = p->subclasses[i];
  4104. while (test) {
  4105. if (test == p_class) {
  4106. _set_error("Cyclic inheritance.", test->line);
  4107. return;
  4108. }
  4109. if (test->base_type.kind == DataType::CLASS) {
  4110. test = test->base_type.class_type;
  4111. } else {
  4112. break;
  4113. }
  4114. }
  4115. found = true;
  4116. if (extend_iter < p_class->extends_class.size()) {
  4117. // Keep looking at current classes if possible
  4118. base = p_class->extends_class[extend_iter++];
  4119. p = p->subclasses[i];
  4120. } else {
  4121. base_class = p->subclasses[i];
  4122. }
  4123. break;
  4124. }
  4125. }
  4126. if (base_class) break;
  4127. if (found) continue;
  4128. if (p->constant_expressions.has(base)) {
  4129. if (p->constant_expressions[base].expression->type != Node::TYPE_CONSTANT) {
  4130. _set_error("Could not resolve constant '" + base + "'.", p_class->line);
  4131. return;
  4132. }
  4133. const ConstantNode *cn = static_cast<const ConstantNode *>(p->constant_expressions[base].expression);
  4134. base_script = cn->value;
  4135. if (base_script.is_null()) {
  4136. _set_error("Constant is not a class: " + base, p_class->line);
  4137. return;
  4138. }
  4139. break;
  4140. }
  4141. p = p->owner;
  4142. }
  4143. if (base_script.is_valid()) {
  4144. String ident = base;
  4145. for (int i = extend_iter; i < p_class->extends_class.size(); i++) {
  4146. String subclass = p_class->extends_class[i];
  4147. ident += ("." + subclass);
  4148. if (base_script->get_subclasses().has(subclass)) {
  4149. base_script = base_script->get_subclasses()[subclass];
  4150. } else if (base_script->get_constants().has(subclass)) {
  4151. Ref<GDScript> new_base_class = base_script->get_constants()[subclass];
  4152. if (new_base_class.is_null()) {
  4153. _set_error("Constant is not a class: " + ident, p_class->line);
  4154. return;
  4155. }
  4156. base_script = new_base_class;
  4157. } else {
  4158. _set_error("Could not find subclass: " + ident, p_class->line);
  4159. return;
  4160. }
  4161. }
  4162. script = base_script;
  4163. } else if (!base_class) {
  4164. if (p_class->extends_class.size() > 1) {
  4165. _set_error("Invalid inheritance (unknown class + subclasses)", p_class->line);
  4166. return;
  4167. }
  4168. //if not found, try engine classes
  4169. if (!GDScriptLanguage::get_singleton()->get_global_map().has(base)) {
  4170. _set_error("Unknown class: '" + base + "'", p_class->line);
  4171. return;
  4172. }
  4173. native = base;
  4174. }
  4175. }
  4176. if (base_class) {
  4177. p_class->base_type.has_type = true;
  4178. p_class->base_type.kind = DataType::CLASS;
  4179. p_class->base_type.class_type = base_class;
  4180. } else if (script.is_valid()) {
  4181. p_class->base_type.has_type = true;
  4182. p_class->base_type.kind = DataType::GDSCRIPT;
  4183. p_class->base_type.script_type = script;
  4184. p_class->base_type.native_type = script->get_instance_base_type();
  4185. } else if (native != StringName()) {
  4186. p_class->base_type.has_type = true;
  4187. p_class->base_type.kind = DataType::NATIVE;
  4188. p_class->base_type.native_type = native;
  4189. } else {
  4190. _set_error("Could not determine inheritance", p_class->line);
  4191. return;
  4192. }
  4193. } else {
  4194. // without extends, implicitly extend Reference
  4195. p_class->base_type.has_type = true;
  4196. p_class->base_type.kind = DataType::NATIVE;
  4197. p_class->base_type.native_type = "Reference";
  4198. }
  4199. // Recursively determine subclasses
  4200. for (int i = 0; i < p_class->subclasses.size(); i++) {
  4201. _determine_inheritance(p_class->subclasses[i]);
  4202. }
  4203. }
  4204. String GDScriptParser::DataType::to_string() const {
  4205. if (!has_type) return "var";
  4206. switch (kind) {
  4207. case BUILTIN: {
  4208. if (builtin_type == Variant::NIL) return "null";
  4209. return Variant::get_type_name(builtin_type);
  4210. } break;
  4211. case NATIVE: {
  4212. if (is_meta_type) {
  4213. return "GDScriptNativeClass";
  4214. }
  4215. return native_type.operator String();
  4216. } break;
  4217. case GDSCRIPT: {
  4218. Ref<GDScript> gds = script_type;
  4219. const String &gds_class = gds->get_script_class_name();
  4220. if (!gds_class.empty()) {
  4221. return gds_class;
  4222. }
  4223. } // fallthrough
  4224. case SCRIPT: {
  4225. if (is_meta_type) {
  4226. return script_type->get_class_name().operator String();
  4227. }
  4228. String name = script_type->get_name();
  4229. if (name != String()) {
  4230. return name;
  4231. }
  4232. name = script_type->get_path().get_file();
  4233. if (name != String()) {
  4234. return name;
  4235. }
  4236. return native_type.operator String();
  4237. } break;
  4238. case CLASS: {
  4239. ERR_FAIL_COND_V(!class_type, String());
  4240. if (is_meta_type) {
  4241. return "GDScript";
  4242. }
  4243. if (class_type->name == StringName()) {
  4244. return "self";
  4245. }
  4246. return class_type->name.operator String();
  4247. } break;
  4248. case UNRESOLVED: {
  4249. } break;
  4250. }
  4251. return "Unresolved";
  4252. }
  4253. bool GDScriptParser::_parse_type(DataType &r_type, bool p_can_be_void) {
  4254. tokenizer->advance();
  4255. r_type.has_type = true;
  4256. bool finished = false;
  4257. bool can_index = false;
  4258. String full_name;
  4259. if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
  4260. completion_cursor = StringName();
  4261. completion_type = COMPLETION_TYPE_HINT;
  4262. completion_class = current_class;
  4263. completion_function = current_function;
  4264. completion_line = tokenizer->get_token_line();
  4265. completion_argument = 0;
  4266. completion_block = current_block;
  4267. completion_found = true;
  4268. completion_ident_is_call = p_can_be_void;
  4269. tokenizer->advance();
  4270. }
  4271. switch (tokenizer->get_token()) {
  4272. case GDScriptTokenizer::TK_PR_VOID: {
  4273. if (!p_can_be_void) {
  4274. return false;
  4275. }
  4276. r_type.kind = DataType::BUILTIN;
  4277. r_type.builtin_type = Variant::NIL;
  4278. } break;
  4279. case GDScriptTokenizer::TK_BUILT_IN_TYPE: {
  4280. r_type.builtin_type = tokenizer->get_token_type();
  4281. if (tokenizer->get_token_type() == Variant::OBJECT) {
  4282. r_type.kind = DataType::NATIVE;
  4283. r_type.native_type = "Object";
  4284. } else {
  4285. r_type.kind = DataType::BUILTIN;
  4286. }
  4287. } break;
  4288. case GDScriptTokenizer::TK_IDENTIFIER: {
  4289. r_type.native_type = tokenizer->get_token_identifier();
  4290. if (ClassDB::class_exists(r_type.native_type) || ClassDB::class_exists("_" + r_type.native_type.operator String())) {
  4291. r_type.kind = DataType::NATIVE;
  4292. } else {
  4293. r_type.kind = DataType::UNRESOLVED;
  4294. can_index = true;
  4295. full_name = r_type.native_type;
  4296. }
  4297. } break;
  4298. default: {
  4299. return false;
  4300. }
  4301. }
  4302. tokenizer->advance();
  4303. if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
  4304. completion_cursor = r_type.native_type;
  4305. completion_type = COMPLETION_TYPE_HINT;
  4306. completion_class = current_class;
  4307. completion_function = current_function;
  4308. completion_line = tokenizer->get_token_line();
  4309. completion_argument = 0;
  4310. completion_block = current_block;
  4311. completion_found = true;
  4312. completion_ident_is_call = p_can_be_void;
  4313. tokenizer->advance();
  4314. }
  4315. if (can_index) {
  4316. while (!finished) {
  4317. switch (tokenizer->get_token()) {
  4318. case GDScriptTokenizer::TK_PERIOD: {
  4319. if (!can_index) {
  4320. _set_error("Unexpected '.'.");
  4321. return false;
  4322. }
  4323. can_index = false;
  4324. tokenizer->advance();
  4325. } break;
  4326. case GDScriptTokenizer::TK_IDENTIFIER: {
  4327. if (can_index) {
  4328. _set_error("Unexpected identifier.");
  4329. return false;
  4330. }
  4331. StringName id;
  4332. bool has_completion = _get_completable_identifier(COMPLETION_TYPE_HINT_INDEX, id);
  4333. if (id == StringName()) {
  4334. id = "@temp";
  4335. }
  4336. full_name += "." + id.operator String();
  4337. can_index = true;
  4338. if (has_completion) {
  4339. completion_cursor = full_name;
  4340. }
  4341. } break;
  4342. default: {
  4343. finished = true;
  4344. } break;
  4345. }
  4346. }
  4347. if (tokenizer->get_token(-1) == GDScriptTokenizer::TK_PERIOD) {
  4348. _set_error("Expected subclass identifier.");
  4349. return false;
  4350. }
  4351. r_type.native_type = full_name;
  4352. }
  4353. return true;
  4354. }
  4355. GDScriptParser::DataType GDScriptParser::_resolve_type(const DataType &p_source, int p_line) {
  4356. if (!p_source.has_type) return p_source;
  4357. if (p_source.kind != DataType::UNRESOLVED) return p_source;
  4358. Vector<String> full_name = p_source.native_type.operator String().split(".", false);
  4359. int name_part = 0;
  4360. DataType result;
  4361. result.has_type = true;
  4362. while (name_part < full_name.size()) {
  4363. bool found = false;
  4364. StringName id = full_name[name_part];
  4365. DataType base_type = result;
  4366. ClassNode *p = NULL;
  4367. if (name_part == 0) {
  4368. if (ScriptServer::is_global_class(id)) {
  4369. String script_path = ScriptServer::get_global_class_path(id);
  4370. if (script_path == self_path) {
  4371. result.kind = DataType::CLASS;
  4372. result.class_type = current_class;
  4373. } else {
  4374. Ref<Script> script = ResourceLoader::load(script_path);
  4375. Ref<GDScript> gds = script;
  4376. if (gds.is_valid()) {
  4377. if (!gds->is_valid()) {
  4378. _set_error("Class '" + id + "' could not be fully loaded (script error or cyclic dependency).", p_line);
  4379. return DataType();
  4380. }
  4381. result.kind = DataType::GDSCRIPT;
  4382. result.script_type = gds;
  4383. } else if (script.is_valid()) {
  4384. result.kind = DataType::SCRIPT;
  4385. result.script_type = script;
  4386. } else {
  4387. _set_error("Class '" + id + "' was found in global scope but its script could not be loaded.", p_line);
  4388. return DataType();
  4389. }
  4390. }
  4391. name_part++;
  4392. continue;
  4393. } else {
  4394. p = current_class;
  4395. }
  4396. } else if (base_type.kind == DataType::CLASS) {
  4397. p = base_type.class_type;
  4398. }
  4399. while (p) {
  4400. if (p->constant_expressions.has(id)) {
  4401. if (p->constant_expressions[id].expression->type != Node::TYPE_CONSTANT) {
  4402. _set_error("Parser bug: unresolved constant.", p_line);
  4403. ERR_FAIL_V(result);
  4404. }
  4405. const ConstantNode *cn = static_cast<const ConstantNode *>(p->constant_expressions[id].expression);
  4406. Ref<GDScript> gds = cn->value;
  4407. if (gds.is_valid()) {
  4408. result.kind = DataType::GDSCRIPT;
  4409. result.script_type = gds;
  4410. found = true;
  4411. } else {
  4412. Ref<Script> scr = cn->value;
  4413. if (scr.is_valid()) {
  4414. result.kind = DataType::SCRIPT;
  4415. result.script_type = scr;
  4416. found = true;
  4417. }
  4418. }
  4419. break;
  4420. }
  4421. // Inner classes
  4422. ClassNode *outer_class = p;
  4423. while (outer_class) {
  4424. if (outer_class->name == id) {
  4425. found = true;
  4426. result.kind = DataType::CLASS;
  4427. result.class_type = outer_class;
  4428. break;
  4429. }
  4430. for (int i = 0; i < outer_class->subclasses.size(); i++) {
  4431. if (outer_class->subclasses[i] == p) {
  4432. continue;
  4433. }
  4434. if (outer_class->subclasses[i]->name == id) {
  4435. found = true;
  4436. result.kind = DataType::CLASS;
  4437. result.class_type = outer_class->subclasses[i];
  4438. break;
  4439. }
  4440. }
  4441. if (found) {
  4442. break;
  4443. }
  4444. outer_class = outer_class->owner;
  4445. }
  4446. if (!found && p->base_type.kind == DataType::CLASS) {
  4447. p = p->base_type.class_type;
  4448. } else {
  4449. base_type = p->base_type;
  4450. break;
  4451. }
  4452. }
  4453. // Still look for class constants in parent script
  4454. if (!found && (base_type.kind == DataType::GDSCRIPT || base_type.kind == DataType::SCRIPT)) {
  4455. Ref<Script> scr = base_type.script_type;
  4456. ERR_FAIL_COND_V(scr.is_null(), result);
  4457. Map<StringName, Variant> constants;
  4458. scr->get_constants(&constants);
  4459. if (constants.has(id)) {
  4460. Ref<GDScript> gds = constants[id];
  4461. if (gds.is_valid()) {
  4462. result.kind = DataType::GDSCRIPT;
  4463. result.script_type = gds;
  4464. found = true;
  4465. } else {
  4466. Ref<Script> scr = constants[id];
  4467. if (scr.is_valid()) {
  4468. result.kind = DataType::SCRIPT;
  4469. result.script_type = scr;
  4470. found = true;
  4471. }
  4472. }
  4473. }
  4474. }
  4475. if (!found && !for_completion) {
  4476. String base;
  4477. if (name_part == 0) {
  4478. base = "self";
  4479. } else {
  4480. base = result.to_string();
  4481. }
  4482. _set_error("Identifier '" + String(id) + "' is not a valid type (not a script or class), or could not be found on base '" +
  4483. base + "'.",
  4484. p_line);
  4485. return DataType();
  4486. }
  4487. name_part++;
  4488. }
  4489. return result;
  4490. }
  4491. GDScriptParser::DataType GDScriptParser::_type_from_variant(const Variant &p_value) const {
  4492. DataType result;
  4493. result.has_type = true;
  4494. result.is_constant = true;
  4495. result.kind = DataType::BUILTIN;
  4496. result.builtin_type = p_value.get_type();
  4497. if (result.builtin_type == Variant::OBJECT) {
  4498. Object *obj = p_value.operator Object *();
  4499. if (!obj) {
  4500. return DataType();
  4501. }
  4502. result.native_type = obj->get_class_name();
  4503. Ref<Script> scr = p_value;
  4504. if (scr.is_valid()) {
  4505. result.is_meta_type = true;
  4506. } else {
  4507. result.is_meta_type = false;
  4508. scr = obj->get_script();
  4509. }
  4510. if (scr.is_valid()) {
  4511. result.script_type = scr;
  4512. Ref<GDScript> gds = scr;
  4513. if (gds.is_valid()) {
  4514. result.kind = DataType::GDSCRIPT;
  4515. } else {
  4516. result.kind = DataType::SCRIPT;
  4517. }
  4518. result.native_type = scr->get_instance_base_type();
  4519. } else {
  4520. result.kind = DataType::NATIVE;
  4521. }
  4522. }
  4523. return result;
  4524. }
  4525. GDScriptParser::DataType GDScriptParser::_type_from_property(const PropertyInfo &p_property, bool p_nil_is_variant) const {
  4526. DataType ret;
  4527. if (p_property.type == Variant::NIL && (p_nil_is_variant || (p_property.usage & PROPERTY_USAGE_NIL_IS_VARIANT))) {
  4528. // Variant
  4529. return ret;
  4530. }
  4531. ret.has_type = true;
  4532. ret.builtin_type = p_property.type;
  4533. if (p_property.type == Variant::OBJECT) {
  4534. ret.kind = DataType::NATIVE;
  4535. ret.native_type = p_property.class_name == StringName() ? "Object" : p_property.class_name;
  4536. } else {
  4537. ret.kind = DataType::BUILTIN;
  4538. }
  4539. return ret;
  4540. }
  4541. GDScriptParser::DataType GDScriptParser::_type_from_gdtype(const GDScriptDataType &p_gdtype) const {
  4542. DataType result;
  4543. if (!p_gdtype.has_type) {
  4544. return result;
  4545. }
  4546. result.has_type = true;
  4547. result.builtin_type = p_gdtype.builtin_type;
  4548. result.native_type = p_gdtype.native_type;
  4549. result.script_type = p_gdtype.script_type;
  4550. switch (p_gdtype.kind) {
  4551. case GDScriptDataType::BUILTIN: {
  4552. result.kind = DataType::BUILTIN;
  4553. } break;
  4554. case GDScriptDataType::NATIVE: {
  4555. result.kind = DataType::NATIVE;
  4556. } break;
  4557. case GDScriptDataType::GDSCRIPT: {
  4558. result.kind = DataType::GDSCRIPT;
  4559. } break;
  4560. case GDScriptDataType::SCRIPT: {
  4561. result.kind = DataType::SCRIPT;
  4562. } break;
  4563. }
  4564. return result;
  4565. }
  4566. GDScriptParser::DataType GDScriptParser::_get_operation_type(const Variant::Operator p_op, const DataType &p_a, const DataType &p_b, bool &r_valid) const {
  4567. if (!p_a.has_type || !p_b.has_type) {
  4568. r_valid = true;
  4569. return DataType();
  4570. }
  4571. Variant::Type a_type = p_a.kind == DataType::BUILTIN ? p_a.builtin_type : Variant::OBJECT;
  4572. Variant::Type b_type = p_b.kind == DataType::BUILTIN ? p_b.builtin_type : Variant::OBJECT;
  4573. Variant a;
  4574. REF a_ref;
  4575. if (a_type == Variant::OBJECT) {
  4576. a_ref.instance();
  4577. a = a_ref;
  4578. } else {
  4579. Variant::CallError err;
  4580. a = Variant::construct(a_type, NULL, 0, err);
  4581. if (err.error != Variant::CallError::CALL_OK) {
  4582. r_valid = false;
  4583. return DataType();
  4584. }
  4585. }
  4586. Variant b;
  4587. REF b_ref;
  4588. if (b_type == Variant::OBJECT) {
  4589. b_ref.instance();
  4590. b = b_ref;
  4591. } else {
  4592. Variant::CallError err;
  4593. b = Variant::construct(b_type, NULL, 0, err);
  4594. if (err.error != Variant::CallError::CALL_OK) {
  4595. r_valid = false;
  4596. return DataType();
  4597. }
  4598. }
  4599. // Avoid division by zero
  4600. if (a_type == Variant::INT || a_type == Variant::REAL) {
  4601. Variant::evaluate(Variant::OP_ADD, a, 1, a, r_valid);
  4602. }
  4603. if (b_type == Variant::INT || b_type == Variant::REAL) {
  4604. Variant::evaluate(Variant::OP_ADD, b, 1, b, r_valid);
  4605. }
  4606. if (a_type == Variant::STRING && b_type != Variant::ARRAY) {
  4607. a = "%s"; // Work around for formatting operator (%)
  4608. }
  4609. Variant ret;
  4610. Variant::evaluate(p_op, a, b, ret, r_valid);
  4611. if (r_valid) {
  4612. return _type_from_variant(ret);
  4613. }
  4614. return DataType();
  4615. }
  4616. Variant::Operator GDScriptParser::_get_variant_operation(const OperatorNode::Operator &p_op) const {
  4617. switch (p_op) {
  4618. case OperatorNode::OP_NEG: {
  4619. return Variant::OP_NEGATE;
  4620. } break;
  4621. case OperatorNode::OP_POS: {
  4622. return Variant::OP_POSITIVE;
  4623. } break;
  4624. case OperatorNode::OP_NOT: {
  4625. return Variant::OP_NOT;
  4626. } break;
  4627. case OperatorNode::OP_BIT_INVERT: {
  4628. return Variant::OP_BIT_NEGATE;
  4629. } break;
  4630. case OperatorNode::OP_IN: {
  4631. return Variant::OP_IN;
  4632. } break;
  4633. case OperatorNode::OP_EQUAL: {
  4634. return Variant::OP_EQUAL;
  4635. } break;
  4636. case OperatorNode::OP_NOT_EQUAL: {
  4637. return Variant::OP_NOT_EQUAL;
  4638. } break;
  4639. case OperatorNode::OP_LESS: {
  4640. return Variant::OP_LESS;
  4641. } break;
  4642. case OperatorNode::OP_LESS_EQUAL: {
  4643. return Variant::OP_LESS_EQUAL;
  4644. } break;
  4645. case OperatorNode::OP_GREATER: {
  4646. return Variant::OP_GREATER;
  4647. } break;
  4648. case OperatorNode::OP_GREATER_EQUAL: {
  4649. return Variant::OP_GREATER_EQUAL;
  4650. } break;
  4651. case OperatorNode::OP_AND: {
  4652. return Variant::OP_AND;
  4653. } break;
  4654. case OperatorNode::OP_OR: {
  4655. return Variant::OP_OR;
  4656. } break;
  4657. case OperatorNode::OP_ASSIGN_ADD:
  4658. case OperatorNode::OP_ADD: {
  4659. return Variant::OP_ADD;
  4660. } break;
  4661. case OperatorNode::OP_ASSIGN_SUB:
  4662. case OperatorNode::OP_SUB: {
  4663. return Variant::OP_SUBTRACT;
  4664. } break;
  4665. case OperatorNode::OP_ASSIGN_MUL:
  4666. case OperatorNode::OP_MUL: {
  4667. return Variant::OP_MULTIPLY;
  4668. } break;
  4669. case OperatorNode::OP_ASSIGN_DIV:
  4670. case OperatorNode::OP_DIV: {
  4671. return Variant::OP_DIVIDE;
  4672. } break;
  4673. case OperatorNode::OP_ASSIGN_MOD:
  4674. case OperatorNode::OP_MOD: {
  4675. return Variant::OP_MODULE;
  4676. } break;
  4677. case OperatorNode::OP_ASSIGN_BIT_AND:
  4678. case OperatorNode::OP_BIT_AND: {
  4679. return Variant::OP_BIT_AND;
  4680. } break;
  4681. case OperatorNode::OP_ASSIGN_BIT_OR:
  4682. case OperatorNode::OP_BIT_OR: {
  4683. return Variant::OP_BIT_OR;
  4684. } break;
  4685. case OperatorNode::OP_ASSIGN_BIT_XOR:
  4686. case OperatorNode::OP_BIT_XOR: {
  4687. return Variant::OP_BIT_XOR;
  4688. } break;
  4689. case OperatorNode::OP_ASSIGN_SHIFT_LEFT:
  4690. case OperatorNode::OP_SHIFT_LEFT: {
  4691. return Variant::OP_SHIFT_LEFT;
  4692. }
  4693. case OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
  4694. case OperatorNode::OP_SHIFT_RIGHT: {
  4695. return Variant::OP_SHIFT_RIGHT;
  4696. }
  4697. default: {
  4698. return Variant::OP_MAX;
  4699. } break;
  4700. }
  4701. }
  4702. bool GDScriptParser::_is_type_compatible(const DataType &p_container, const DataType &p_expression, bool p_allow_implicit_conversion) const {
  4703. // Ignore for completion
  4704. if (!check_types || for_completion) {
  4705. return true;
  4706. }
  4707. // Can't test if not all have type
  4708. if (!p_container.has_type || !p_expression.has_type) {
  4709. return true;
  4710. }
  4711. // Should never get here unresolved
  4712. ERR_FAIL_COND_V(p_container.kind == DataType::UNRESOLVED, false);
  4713. ERR_FAIL_COND_V(p_expression.kind == DataType::UNRESOLVED, false);
  4714. if (p_container.kind == DataType::BUILTIN && p_expression.kind == DataType::BUILTIN) {
  4715. bool valid = p_container.builtin_type == p_expression.builtin_type;
  4716. if (p_allow_implicit_conversion) {
  4717. valid = valid || Variant::can_convert_strict(p_expression.builtin_type, p_container.builtin_type);
  4718. }
  4719. return valid;
  4720. }
  4721. if (p_container.kind == DataType::BUILTIN && p_container.builtin_type == Variant::OBJECT) {
  4722. // Object built-in is a special case, it's compatible with any object and with null
  4723. if (p_expression.kind == DataType::BUILTIN && p_expression.builtin_type == Variant::NIL) {
  4724. return true;
  4725. }
  4726. if (p_expression.kind == DataType::BUILTIN) {
  4727. return false;
  4728. }
  4729. // If it's not a built-in, must be an object
  4730. return true;
  4731. }
  4732. if (p_container.kind == DataType::BUILTIN || (p_expression.kind == DataType::BUILTIN && p_expression.builtin_type != Variant::NIL)) {
  4733. // Can't mix built-ins with objects
  4734. return false;
  4735. }
  4736. // From now on everything is objects, check polymorphism
  4737. // The container must be the same class or a superclass of the expression
  4738. if (p_expression.kind == DataType::BUILTIN && p_expression.builtin_type == Variant::NIL) {
  4739. // Null can be assigned to object types
  4740. return true;
  4741. }
  4742. StringName expr_native;
  4743. Ref<Script> expr_script;
  4744. ClassNode *expr_class = NULL;
  4745. switch (p_expression.kind) {
  4746. case DataType::NATIVE: {
  4747. if (p_container.kind != DataType::NATIVE) {
  4748. // Non-native type can't be a superclass of a native type
  4749. return false;
  4750. }
  4751. if (p_expression.is_meta_type) {
  4752. expr_native = GDScriptNativeClass::get_class_static();
  4753. } else {
  4754. expr_native = p_expression.native_type;
  4755. }
  4756. } break;
  4757. case DataType::SCRIPT:
  4758. case DataType::GDSCRIPT: {
  4759. if (p_container.kind == DataType::CLASS) {
  4760. // This cannot be resolved without cyclic dependencies, so just bail out
  4761. return false;
  4762. }
  4763. if (p_expression.is_meta_type) {
  4764. expr_native = p_expression.script_type->get_class_name();
  4765. } else {
  4766. expr_script = p_expression.script_type;
  4767. expr_native = expr_script->get_instance_base_type();
  4768. }
  4769. } break;
  4770. case DataType::CLASS: {
  4771. if (p_expression.is_meta_type) {
  4772. expr_native = GDScript::get_class_static();
  4773. } else {
  4774. expr_class = p_expression.class_type;
  4775. ClassNode *base = expr_class;
  4776. while (base->base_type.kind == DataType::CLASS) {
  4777. base = base->base_type.class_type;
  4778. }
  4779. expr_native = base->base_type.native_type;
  4780. expr_script = base->base_type.script_type;
  4781. }
  4782. } break;
  4783. case DataType::BUILTIN: // Already handled above
  4784. case DataType::UNRESOLVED: // Not allowed, see above
  4785. break;
  4786. }
  4787. switch (p_container.kind) {
  4788. case DataType::NATIVE: {
  4789. if (p_container.is_meta_type) {
  4790. return ClassDB::is_parent_class(expr_native, GDScriptNativeClass::get_class_static());
  4791. } else {
  4792. return ClassDB::is_parent_class(expr_native, p_container.native_type);
  4793. }
  4794. } break;
  4795. case DataType::SCRIPT:
  4796. case DataType::GDSCRIPT: {
  4797. if (p_container.is_meta_type) {
  4798. return ClassDB::is_parent_class(expr_native, GDScript::get_class_static());
  4799. }
  4800. if (expr_class == head && p_container.script_type->get_path() == self_path) {
  4801. // Special case: container is self script and expression is self
  4802. return true;
  4803. }
  4804. while (expr_script.is_valid()) {
  4805. if (expr_script == p_container.script_type) {
  4806. return true;
  4807. }
  4808. expr_script = expr_script->get_base_script();
  4809. }
  4810. return false;
  4811. } break;
  4812. case DataType::CLASS: {
  4813. if (p_container.is_meta_type) {
  4814. return ClassDB::is_parent_class(expr_native, GDScript::get_class_static());
  4815. }
  4816. if (p_container.class_type == head && expr_script.is_valid() && expr_script->get_path() == self_path) {
  4817. // Special case: container is self and expression is self script
  4818. return true;
  4819. }
  4820. while (expr_class) {
  4821. if (expr_class == p_container.class_type) {
  4822. return true;
  4823. }
  4824. expr_class = expr_class->base_type.class_type;
  4825. }
  4826. return false;
  4827. } break;
  4828. case DataType::BUILTIN: // Already handled above
  4829. case DataType::UNRESOLVED: // Not allowed, see above
  4830. break;
  4831. }
  4832. return false;
  4833. }
  4834. GDScriptParser::DataType GDScriptParser::_reduce_node_type(Node *p_node) {
  4835. if (p_node->get_datatype().has_type) {
  4836. return p_node->get_datatype();
  4837. }
  4838. DataType node_type;
  4839. switch (p_node->type) {
  4840. case Node::TYPE_CONSTANT: {
  4841. node_type = _type_from_variant(static_cast<ConstantNode *>(p_node)->value);
  4842. } break;
  4843. case Node::TYPE_TYPE: {
  4844. TypeNode *tn = static_cast<TypeNode *>(p_node);
  4845. node_type.has_type = true;
  4846. node_type.is_meta_type = true;
  4847. node_type.kind = DataType::BUILTIN;
  4848. node_type.builtin_type = tn->vtype;
  4849. } break;
  4850. case Node::TYPE_ARRAY: {
  4851. node_type.has_type = true;
  4852. node_type.kind = DataType::BUILTIN;
  4853. node_type.builtin_type = Variant::ARRAY;
  4854. #ifdef DEBUG_ENABLED
  4855. // Check stuff inside the array
  4856. ArrayNode *an = static_cast<ArrayNode *>(p_node);
  4857. for (int i = 0; i < an->elements.size(); i++) {
  4858. _reduce_node_type(an->elements[i]);
  4859. }
  4860. #endif // DEBUG_ENABLED
  4861. } break;
  4862. case Node::TYPE_DICTIONARY: {
  4863. node_type.has_type = true;
  4864. node_type.kind = DataType::BUILTIN;
  4865. node_type.builtin_type = Variant::DICTIONARY;
  4866. #ifdef DEBUG_ENABLED
  4867. // Check stuff inside the dictionarty
  4868. DictionaryNode *dn = static_cast<DictionaryNode *>(p_node);
  4869. for (int i = 0; i < dn->elements.size(); i++) {
  4870. _reduce_node_type(dn->elements[i].key);
  4871. _reduce_node_type(dn->elements[i].value);
  4872. }
  4873. #endif // DEBUG_ENABLED
  4874. } break;
  4875. case Node::TYPE_SELF: {
  4876. node_type.has_type = true;
  4877. node_type.kind = DataType::CLASS;
  4878. node_type.class_type = current_class;
  4879. } break;
  4880. case Node::TYPE_IDENTIFIER: {
  4881. IdentifierNode *id = static_cast<IdentifierNode *>(p_node);
  4882. if (id->declared_block) {
  4883. node_type = id->declared_block->variables[id->name]->get_datatype();
  4884. id->declared_block->variables[id->name]->usages += 1;
  4885. } else if (id->name == "#match_value") {
  4886. // It's a special id just for the match statetement, ignore
  4887. break;
  4888. } else if (current_function && current_function->arguments.find(id->name) >= 0) {
  4889. int idx = current_function->arguments.find(id->name);
  4890. node_type = current_function->argument_types[idx];
  4891. } else {
  4892. node_type = _reduce_identifier_type(NULL, id->name, id->line, false);
  4893. }
  4894. } break;
  4895. case Node::TYPE_CAST: {
  4896. CastNode *cn = static_cast<CastNode *>(p_node);
  4897. DataType source_type = _reduce_node_type(cn->source_node);
  4898. cn->cast_type = _resolve_type(cn->cast_type, cn->line);
  4899. if (source_type.has_type) {
  4900. bool valid = false;
  4901. if (check_types) {
  4902. if (cn->cast_type.kind == DataType::BUILTIN && source_type.kind == DataType::BUILTIN) {
  4903. valid = Variant::can_convert(source_type.builtin_type, cn->cast_type.builtin_type);
  4904. }
  4905. if (cn->cast_type.kind != DataType::BUILTIN && source_type.kind != DataType::BUILTIN) {
  4906. valid = _is_type_compatible(cn->cast_type, source_type) || _is_type_compatible(source_type, cn->cast_type);
  4907. }
  4908. if (!valid) {
  4909. _set_error("Invalid cast. Cannot convert from '" + source_type.to_string() +
  4910. "' to '" + cn->cast_type.to_string() + "'.",
  4911. cn->line);
  4912. return DataType();
  4913. }
  4914. }
  4915. } else {
  4916. #ifdef DEBUG_ENABLED
  4917. _add_warning(GDScriptWarning::UNSAFE_CAST, cn->line, cn->cast_type.to_string());
  4918. #endif // DEBUG_ENABLED
  4919. _mark_line_as_unsafe(cn->line);
  4920. }
  4921. node_type = cn->cast_type;
  4922. } break;
  4923. case Node::TYPE_OPERATOR: {
  4924. OperatorNode *op = static_cast<OperatorNode *>(p_node);
  4925. switch (op->op) {
  4926. case OperatorNode::OP_CALL:
  4927. case OperatorNode::OP_PARENT_CALL: {
  4928. node_type = _reduce_function_call_type(op);
  4929. } break;
  4930. case OperatorNode::OP_YIELD: {
  4931. if (op->arguments.size() == 2) {
  4932. DataType base_type = _reduce_node_type(op->arguments[0]);
  4933. DataType signal_type = _reduce_node_type(op->arguments[1]);
  4934. // TODO: Check if signal exists when it's a constant
  4935. if (base_type.has_type && base_type.kind == DataType::BUILTIN && base_type.builtin_type != Variant::NIL && base_type.builtin_type != Variant::OBJECT) {
  4936. _set_error("First argument of 'yield()' must be an object.", op->line);
  4937. return DataType();
  4938. }
  4939. if (signal_type.has_type && (signal_type.kind != DataType::BUILTIN || signal_type.builtin_type != Variant::STRING)) {
  4940. _set_error("Second argument of 'yield()' must be a string.", op->line);
  4941. return DataType();
  4942. }
  4943. }
  4944. // yield can return anything
  4945. node_type.has_type = false;
  4946. } break;
  4947. case OperatorNode::OP_IS:
  4948. case OperatorNode::OP_IS_BUILTIN: {
  4949. if (op->arguments.size() != 2) {
  4950. _set_error("Parser bug: binary operation without 2 arguments.", op->line);
  4951. ERR_FAIL_V(DataType());
  4952. }
  4953. DataType value_type = _reduce_node_type(op->arguments[0]);
  4954. DataType type_type = _reduce_node_type(op->arguments[1]);
  4955. if (check_types && type_type.has_type) {
  4956. if (!type_type.is_meta_type && (type_type.kind != DataType::NATIVE || !ClassDB::is_parent_class(type_type.native_type, "Script"))) {
  4957. _set_error("Invalid 'is' test: right operand is not a type (not a native type nor a script).", op->line);
  4958. return DataType();
  4959. }
  4960. type_type.is_meta_type = false; // Test the actual type
  4961. if (!_is_type_compatible(type_type, value_type) && !_is_type_compatible(value_type, type_type)) {
  4962. if (op->op == OperatorNode::OP_IS) {
  4963. _set_error("A value of type '" + value_type.to_string() + "' will never be an instance of '" + type_type.to_string() + "'.", op->line);
  4964. } else {
  4965. _set_error("A value of type '" + value_type.to_string() + "' will never be of type '" + type_type.to_string() + "'.", op->line);
  4966. }
  4967. return DataType();
  4968. }
  4969. }
  4970. node_type.has_type = true;
  4971. node_type.is_constant = true;
  4972. node_type.is_meta_type = false;
  4973. node_type.kind = DataType::BUILTIN;
  4974. node_type.builtin_type = Variant::BOOL;
  4975. } break;
  4976. // Unary operators
  4977. case OperatorNode::OP_NEG:
  4978. case OperatorNode::OP_POS:
  4979. case OperatorNode::OP_NOT:
  4980. case OperatorNode::OP_BIT_INVERT: {
  4981. DataType argument_type = _reduce_node_type(op->arguments[0]);
  4982. if (!argument_type.has_type) {
  4983. break;
  4984. }
  4985. Variant::Operator var_op = _get_variant_operation(op->op);
  4986. bool valid = false;
  4987. node_type = _get_operation_type(var_op, argument_type, argument_type, valid);
  4988. if (check_types && !valid) {
  4989. _set_error("Invalid operand type ('" + argument_type.to_string() +
  4990. "') to unary operator '" + Variant::get_operator_name(var_op) + "'.",
  4991. op->line, op->column);
  4992. return DataType();
  4993. }
  4994. } break;
  4995. // Binary operators
  4996. case OperatorNode::OP_IN:
  4997. case OperatorNode::OP_EQUAL:
  4998. case OperatorNode::OP_NOT_EQUAL:
  4999. case OperatorNode::OP_LESS:
  5000. case OperatorNode::OP_LESS_EQUAL:
  5001. case OperatorNode::OP_GREATER:
  5002. case OperatorNode::OP_GREATER_EQUAL:
  5003. case OperatorNode::OP_AND:
  5004. case OperatorNode::OP_OR:
  5005. case OperatorNode::OP_ADD:
  5006. case OperatorNode::OP_SUB:
  5007. case OperatorNode::OP_MUL:
  5008. case OperatorNode::OP_DIV:
  5009. case OperatorNode::OP_MOD:
  5010. case OperatorNode::OP_SHIFT_LEFT:
  5011. case OperatorNode::OP_SHIFT_RIGHT:
  5012. case OperatorNode::OP_BIT_AND:
  5013. case OperatorNode::OP_BIT_OR:
  5014. case OperatorNode::OP_BIT_XOR: {
  5015. if (op->arguments.size() != 2) {
  5016. _set_error("Parser bug: binary operation without 2 arguments.", op->line);
  5017. ERR_FAIL_V(DataType());
  5018. }
  5019. DataType argument_a_type = _reduce_node_type(op->arguments[0]);
  5020. DataType argument_b_type = _reduce_node_type(op->arguments[1]);
  5021. if (!argument_a_type.has_type || !argument_b_type.has_type) {
  5022. _mark_line_as_unsafe(op->line);
  5023. break;
  5024. }
  5025. Variant::Operator var_op = _get_variant_operation(op->op);
  5026. bool valid = false;
  5027. node_type = _get_operation_type(var_op, argument_a_type, argument_b_type, valid);
  5028. if (check_types && !valid) {
  5029. _set_error("Invalid operand types ('" + argument_a_type.to_string() + "' and '" +
  5030. argument_b_type.to_string() + "') to operator '" + Variant::get_operator_name(var_op) + "'.",
  5031. op->line, op->column);
  5032. return DataType();
  5033. }
  5034. #ifdef DEBUG_ENABLED
  5035. if (var_op == Variant::OP_DIVIDE && argument_a_type.has_type && argument_a_type.kind == DataType::BUILTIN && argument_a_type.builtin_type == Variant::INT &&
  5036. argument_b_type.has_type && argument_b_type.kind == DataType::BUILTIN && argument_b_type.builtin_type == Variant::INT) {
  5037. _add_warning(GDScriptWarning::INTEGER_DIVISION, op->line);
  5038. }
  5039. #endif // DEBUG_ENABLED
  5040. } break;
  5041. // Ternary operators
  5042. case OperatorNode::OP_TERNARY_IF: {
  5043. if (op->arguments.size() != 3) {
  5044. _set_error("Parser bug: ternary operation without 3 arguments");
  5045. ERR_FAIL_V(DataType());
  5046. }
  5047. DataType true_type = _reduce_node_type(op->arguments[1]);
  5048. DataType false_type = _reduce_node_type(op->arguments[2]);
  5049. // If types are equal, then the expression is of the same type
  5050. // If they are compatible, return the broader type
  5051. if (true_type == false_type || _is_type_compatible(true_type, false_type)) {
  5052. node_type = true_type;
  5053. } else if (_is_type_compatible(false_type, true_type)) {
  5054. node_type = false_type;
  5055. } else {
  5056. #ifdef DEBUG_ENABLED
  5057. _add_warning(GDScriptWarning::INCOMPATIBLE_TERNARY, op->line);
  5058. #endif // DEBUG_ENABLED
  5059. }
  5060. } break;
  5061. // Assignment should never happen within an expression
  5062. case OperatorNode::OP_ASSIGN:
  5063. case OperatorNode::OP_ASSIGN_ADD:
  5064. case OperatorNode::OP_ASSIGN_SUB:
  5065. case OperatorNode::OP_ASSIGN_MUL:
  5066. case OperatorNode::OP_ASSIGN_DIV:
  5067. case OperatorNode::OP_ASSIGN_MOD:
  5068. case OperatorNode::OP_ASSIGN_SHIFT_LEFT:
  5069. case OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
  5070. case OperatorNode::OP_ASSIGN_BIT_AND:
  5071. case OperatorNode::OP_ASSIGN_BIT_OR:
  5072. case OperatorNode::OP_ASSIGN_BIT_XOR:
  5073. case OperatorNode::OP_INIT_ASSIGN: {
  5074. _set_error("Assignment inside expression is not allowed (parser bug?).", op->line);
  5075. return DataType();
  5076. } break;
  5077. case OperatorNode::OP_INDEX_NAMED: {
  5078. if (op->arguments.size() != 2) {
  5079. _set_error("Parser bug: named index with invalid arguments.", op->line);
  5080. ERR_FAIL_V(DataType());
  5081. }
  5082. if (op->arguments[1]->type != Node::TYPE_IDENTIFIER) {
  5083. _set_error("Parser bug: named index without identifier argument.", op->line);
  5084. ERR_FAIL_V(DataType());
  5085. }
  5086. DataType base_type = _reduce_node_type(op->arguments[0]);
  5087. IdentifierNode *member_id = static_cast<IdentifierNode *>(op->arguments[1]);
  5088. if (base_type.has_type) {
  5089. if (check_types && base_type.kind == DataType::BUILTIN) {
  5090. // Variant type, just test if it's possible
  5091. DataType result;
  5092. switch (base_type.builtin_type) {
  5093. case Variant::NIL:
  5094. case Variant::DICTIONARY: {
  5095. result.has_type = false;
  5096. } break;
  5097. default: {
  5098. Variant::CallError err;
  5099. Variant temp = Variant::construct(base_type.builtin_type, NULL, 0, err);
  5100. bool valid = false;
  5101. Variant res = temp.get(member_id->name.operator String(), &valid);
  5102. if (valid) {
  5103. result = _type_from_variant(res);
  5104. } else if (check_types) {
  5105. _set_error("Can't get index '" + String(member_id->name.operator String()) + "' on base '" +
  5106. base_type.to_string() + "'.",
  5107. op->line);
  5108. return DataType();
  5109. }
  5110. } break;
  5111. }
  5112. result.is_constant = false;
  5113. node_type = result;
  5114. } else {
  5115. node_type = _reduce_identifier_type(&base_type, member_id->name, op->line, true);
  5116. #ifdef DEBUG_ENABLED
  5117. if (!node_type.has_type) {
  5118. _add_warning(GDScriptWarning::UNSAFE_PROPERTY_ACCESS, op->line, member_id->name.operator String(), base_type.to_string());
  5119. }
  5120. #endif // DEBUG_ENABLED
  5121. }
  5122. } else {
  5123. _mark_line_as_unsafe(op->line);
  5124. }
  5125. if (error_set) {
  5126. return DataType();
  5127. }
  5128. } break;
  5129. case OperatorNode::OP_INDEX: {
  5130. if (op->arguments[1]->type == Node::TYPE_CONSTANT) {
  5131. ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[1]);
  5132. if (cn->value.get_type() == Variant::STRING) {
  5133. // Treat this as named indexing
  5134. IdentifierNode *id = alloc_node<IdentifierNode>();
  5135. id->name = cn->value.operator StringName();
  5136. op->op = OperatorNode::OP_INDEX_NAMED;
  5137. op->arguments.write[1] = id;
  5138. return _reduce_node_type(op);
  5139. }
  5140. }
  5141. DataType base_type = _reduce_node_type(op->arguments[0]);
  5142. DataType index_type = _reduce_node_type(op->arguments[1]);
  5143. if (!base_type.has_type) {
  5144. _mark_line_as_unsafe(op->line);
  5145. break;
  5146. }
  5147. if (check_types && index_type.has_type) {
  5148. if (base_type.kind == DataType::BUILTIN) {
  5149. // Check if indexing is valid
  5150. bool error = index_type.kind != DataType::BUILTIN && base_type.builtin_type != Variant::DICTIONARY;
  5151. if (!error) {
  5152. switch (base_type.builtin_type) {
  5153. // Expect int or real as index
  5154. case Variant::POOL_BYTE_ARRAY:
  5155. case Variant::POOL_COLOR_ARRAY:
  5156. case Variant::POOL_INT_ARRAY:
  5157. case Variant::POOL_REAL_ARRAY:
  5158. case Variant::POOL_STRING_ARRAY:
  5159. case Variant::POOL_VECTOR2_ARRAY:
  5160. case Variant::POOL_VECTOR3_ARRAY:
  5161. case Variant::ARRAY:
  5162. case Variant::STRING: {
  5163. error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::REAL;
  5164. } break;
  5165. // Expect String only
  5166. case Variant::RECT2:
  5167. case Variant::PLANE:
  5168. case Variant::QUAT:
  5169. case Variant::AABB:
  5170. case Variant::OBJECT: {
  5171. error = index_type.builtin_type != Variant::STRING;
  5172. } break;
  5173. // Expect String or number
  5174. case Variant::VECTOR2:
  5175. case Variant::VECTOR3:
  5176. case Variant::TRANSFORM2D:
  5177. case Variant::BASIS:
  5178. case Variant::TRANSFORM: {
  5179. error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::REAL &&
  5180. index_type.builtin_type != Variant::STRING;
  5181. } break;
  5182. // Expect String or int
  5183. case Variant::COLOR: {
  5184. error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::STRING;
  5185. } break;
  5186. default: {}
  5187. }
  5188. }
  5189. if (error) {
  5190. _set_error("Invalid index type (" + index_type.to_string() + ") for base '" + base_type.to_string() + "'.",
  5191. op->line);
  5192. return DataType();
  5193. }
  5194. if (op->arguments[1]->type == GDScriptParser::Node::TYPE_CONSTANT) {
  5195. ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[1]);
  5196. // Index is a constant, just try it if possible
  5197. switch (base_type.builtin_type) {
  5198. // Arrays/string have variable indexing, can't test directly
  5199. case Variant::STRING:
  5200. case Variant::ARRAY:
  5201. case Variant::DICTIONARY:
  5202. case Variant::POOL_BYTE_ARRAY:
  5203. case Variant::POOL_COLOR_ARRAY:
  5204. case Variant::POOL_INT_ARRAY:
  5205. case Variant::POOL_REAL_ARRAY:
  5206. case Variant::POOL_STRING_ARRAY:
  5207. case Variant::POOL_VECTOR2_ARRAY:
  5208. case Variant::POOL_VECTOR3_ARRAY: {
  5209. break;
  5210. }
  5211. default: {
  5212. Variant::CallError err;
  5213. Variant temp = Variant::construct(base_type.builtin_type, NULL, 0, err);
  5214. bool valid = false;
  5215. Variant res = temp.get(cn->value, &valid);
  5216. if (valid) {
  5217. node_type = _type_from_variant(res);
  5218. node_type.is_constant = false;
  5219. } else if (check_types) {
  5220. _set_error("Can't get index '" + String(cn->value) + "' on base '" +
  5221. base_type.to_string() + "'.",
  5222. op->line);
  5223. return DataType();
  5224. }
  5225. } break;
  5226. }
  5227. } else {
  5228. _mark_line_as_unsafe(op->line);
  5229. }
  5230. } else if (!for_completion && (index_type.kind != DataType::BUILTIN || index_type.builtin_type != Variant::STRING)) {
  5231. _set_error("Only strings can be used as index in the base type '" + base_type.to_string() + "'.", op->line);
  5232. return DataType();
  5233. }
  5234. }
  5235. if (check_types && !node_type.has_type) {
  5236. // Can infer indexing type for some variant types
  5237. DataType result;
  5238. result.has_type = true;
  5239. result.kind = DataType::BUILTIN;
  5240. switch (base_type.builtin_type) {
  5241. // Can't index at all
  5242. case Variant::NIL:
  5243. case Variant::BOOL:
  5244. case Variant::INT:
  5245. case Variant::REAL:
  5246. case Variant::NODE_PATH:
  5247. case Variant::_RID: {
  5248. _set_error("Can't index on a value of type '" + base_type.to_string() + "'.", op->line);
  5249. return DataType();
  5250. } break;
  5251. // Return int
  5252. case Variant::POOL_BYTE_ARRAY:
  5253. case Variant::POOL_INT_ARRAY: {
  5254. result.builtin_type = Variant::INT;
  5255. } break;
  5256. // Return real
  5257. case Variant::POOL_REAL_ARRAY:
  5258. case Variant::VECTOR2:
  5259. case Variant::VECTOR3:
  5260. case Variant::QUAT: {
  5261. result.builtin_type = Variant::REAL;
  5262. } break;
  5263. // Return color
  5264. case Variant::POOL_COLOR_ARRAY: {
  5265. result.builtin_type = Variant::COLOR;
  5266. } break;
  5267. // Return string
  5268. case Variant::POOL_STRING_ARRAY:
  5269. case Variant::STRING: {
  5270. result.builtin_type = Variant::STRING;
  5271. } break;
  5272. // Return Vector2
  5273. case Variant::POOL_VECTOR2_ARRAY:
  5274. case Variant::TRANSFORM2D:
  5275. case Variant::RECT2: {
  5276. result.builtin_type = Variant::VECTOR2;
  5277. } break;
  5278. // Return Vector3
  5279. case Variant::POOL_VECTOR3_ARRAY:
  5280. case Variant::AABB:
  5281. case Variant::BASIS: {
  5282. result.builtin_type = Variant::VECTOR3;
  5283. } break;
  5284. // Depends on the index
  5285. case Variant::TRANSFORM:
  5286. case Variant::PLANE:
  5287. case Variant::COLOR:
  5288. default: {
  5289. result.has_type = false;
  5290. } break;
  5291. }
  5292. node_type = result;
  5293. }
  5294. } break;
  5295. default: {
  5296. _set_error("Parser bug: unhandled operation.", op->line);
  5297. ERR_FAIL_V(DataType());
  5298. }
  5299. }
  5300. } break;
  5301. default: {}
  5302. }
  5303. p_node->set_datatype(_resolve_type(node_type, p_node->line));
  5304. return node_type;
  5305. }
  5306. bool GDScriptParser::_get_function_signature(DataType &p_base_type, const StringName &p_function, DataType &r_return_type, List<DataType> &r_arg_types, int &r_default_arg_count, bool &r_static, bool &r_vararg) const {
  5307. r_static = false;
  5308. r_default_arg_count = 0;
  5309. DataType original_type = p_base_type;
  5310. ClassNode *base = NULL;
  5311. FunctionNode *callee = NULL;
  5312. if (p_base_type.kind == DataType::CLASS) {
  5313. base = p_base_type.class_type;
  5314. }
  5315. // Look up the current file (parse tree)
  5316. while (!callee && base) {
  5317. for (int i = 0; i < base->static_functions.size(); i++) {
  5318. FunctionNode *func = base->static_functions[i];
  5319. if (p_function == func->name) {
  5320. r_static = true;
  5321. callee = func;
  5322. break;
  5323. }
  5324. }
  5325. if (!callee && !p_base_type.is_meta_type) {
  5326. for (int i = 0; i < base->functions.size(); i++) {
  5327. FunctionNode *func = base->functions[i];
  5328. if (p_function == func->name) {
  5329. callee = func;
  5330. break;
  5331. }
  5332. }
  5333. }
  5334. p_base_type = base->base_type;
  5335. if (p_base_type.kind == DataType::CLASS) {
  5336. base = p_base_type.class_type;
  5337. } else {
  5338. break;
  5339. }
  5340. }
  5341. if (callee) {
  5342. r_return_type = callee->get_datatype();
  5343. for (int i = 0; i < callee->argument_types.size(); i++) {
  5344. r_arg_types.push_back(callee->argument_types[i]);
  5345. }
  5346. r_default_arg_count = callee->default_values.size();
  5347. return true;
  5348. }
  5349. // Nothing in current file, check parent script
  5350. Ref<GDScript> base_gdscript;
  5351. Ref<Script> base_script;
  5352. StringName native;
  5353. if (p_base_type.kind == DataType::GDSCRIPT) {
  5354. base_gdscript = p_base_type.script_type;
  5355. if (base_gdscript.is_null() || !base_gdscript->is_valid()) {
  5356. // GDScript wasn't properly compíled, don't bother trying
  5357. return false;
  5358. }
  5359. } else if (p_base_type.kind == DataType::SCRIPT) {
  5360. base_script = p_base_type.script_type;
  5361. } else if (p_base_type.kind == DataType::NATIVE) {
  5362. native = p_base_type.native_type;
  5363. }
  5364. while (base_gdscript.is_valid()) {
  5365. native = base_gdscript->get_instance_base_type();
  5366. Map<StringName, GDScriptFunction *> funcs = base_gdscript->get_member_functions();
  5367. if (funcs.has(p_function)) {
  5368. GDScriptFunction *f = funcs[p_function];
  5369. r_static = f->is_static();
  5370. r_default_arg_count = f->get_default_argument_count();
  5371. r_return_type = _type_from_gdtype(f->get_return_type());
  5372. for (int i = 0; i < f->get_argument_count(); i++) {
  5373. r_arg_types.push_back(_type_from_gdtype(f->get_argument_type(i)));
  5374. }
  5375. return true;
  5376. }
  5377. base_gdscript = base_gdscript->get_base_script();
  5378. }
  5379. while (base_script.is_valid()) {
  5380. native = base_script->get_instance_base_type();
  5381. MethodInfo mi = base_script->get_method_info(p_function);
  5382. if (!(mi == MethodInfo())) {
  5383. r_return_type = _type_from_property(mi.return_val, false);
  5384. r_default_arg_count = mi.default_arguments.size();
  5385. for (List<PropertyInfo>::Element *E = mi.arguments.front(); E; E = E->next()) {
  5386. r_arg_types.push_back(_type_from_property(E->get()));
  5387. }
  5388. return true;
  5389. }
  5390. base_script = base_script->get_base_script();
  5391. }
  5392. if (native == StringName()) {
  5393. // Empty native class, might happen in some Script implementations
  5394. // Just ignore it
  5395. return false;
  5396. }
  5397. #ifdef DEBUG_METHODS_ENABLED
  5398. // Only native remains
  5399. if (!ClassDB::class_exists(native)) {
  5400. native = "_" + native.operator String();
  5401. }
  5402. if (!ClassDB::class_exists(native)) {
  5403. if (!check_types) return false;
  5404. ERR_EXPLAIN("Parser bug: Class '" + String(native) + "' not found.");
  5405. ERR_FAIL_V(false);
  5406. }
  5407. MethodBind *method = ClassDB::get_method(native, p_function);
  5408. if (!method) {
  5409. // Try virtual methods
  5410. List<MethodInfo> virtuals;
  5411. ClassDB::get_virtual_methods(native, &virtuals);
  5412. for (const List<MethodInfo>::Element *E = virtuals.front(); E; E = E->next()) {
  5413. const MethodInfo &mi = E->get();
  5414. if (mi.name == p_function) {
  5415. r_default_arg_count = mi.default_arguments.size();
  5416. for (const List<PropertyInfo>::Element *pi = mi.arguments.front(); pi; pi = pi->next()) {
  5417. r_arg_types.push_back(_type_from_property(pi->get()));
  5418. }
  5419. r_return_type = _type_from_property(mi.return_val, false);
  5420. r_vararg = mi.flags & METHOD_FLAG_VARARG;
  5421. return true;
  5422. }
  5423. }
  5424. // If the base is a script, it might be trying to access members of the Script class itself
  5425. if (original_type.is_meta_type && !(p_function == "new") && (original_type.kind == DataType::SCRIPT || original_type.kind == DataType::GDSCRIPT)) {
  5426. method = ClassDB::get_method(original_type.script_type->get_class_name(), p_function);
  5427. if (method) {
  5428. r_static = true;
  5429. } else {
  5430. // Try virtual methods of the script type
  5431. virtuals.clear();
  5432. ClassDB::get_virtual_methods(original_type.script_type->get_class_name(), &virtuals);
  5433. for (const List<MethodInfo>::Element *E = virtuals.front(); E; E = E->next()) {
  5434. const MethodInfo &mi = E->get();
  5435. if (mi.name == p_function) {
  5436. r_default_arg_count = mi.default_arguments.size();
  5437. for (const List<PropertyInfo>::Element *pi = mi.arguments.front(); pi; pi = pi->next()) {
  5438. r_arg_types.push_back(_type_from_property(pi->get()));
  5439. }
  5440. r_return_type = _type_from_property(mi.return_val, false);
  5441. r_static = true;
  5442. r_vararg = mi.flags & METHOD_FLAG_VARARG;
  5443. return true;
  5444. }
  5445. }
  5446. return false;
  5447. }
  5448. } else {
  5449. return false;
  5450. }
  5451. }
  5452. r_default_arg_count = method->get_default_argument_count();
  5453. r_return_type = _type_from_property(method->get_return_info(), false);
  5454. r_vararg = method->is_vararg();
  5455. for (int i = 0; i < method->get_argument_count(); i++) {
  5456. r_arg_types.push_back(_type_from_property(method->get_argument_info(i)));
  5457. }
  5458. return true;
  5459. #else
  5460. return false;
  5461. #endif
  5462. }
  5463. GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const OperatorNode *p_call) {
  5464. if (p_call->arguments.size() < 1) {
  5465. _set_error("Parser bug: function call without enough arguments.", p_call->line);
  5466. ERR_FAIL_V(DataType());
  5467. }
  5468. DataType return_type;
  5469. List<DataType> arg_types;
  5470. int default_args_count = 0;
  5471. int arg_count = p_call->arguments.size();
  5472. String callee_name;
  5473. bool is_vararg = false;
  5474. switch (p_call->arguments[0]->type) {
  5475. case GDScriptParser::Node::TYPE_TYPE: {
  5476. // Built-in constructor, special case
  5477. TypeNode *tn = static_cast<TypeNode *>(p_call->arguments[0]);
  5478. Vector<DataType> par_types;
  5479. par_types.resize(p_call->arguments.size() - 1);
  5480. for (int i = 1; i < p_call->arguments.size(); i++) {
  5481. par_types.write[i - 1] = _reduce_node_type(p_call->arguments[i]);
  5482. }
  5483. if (error_set) return DataType();
  5484. bool match = false;
  5485. List<MethodInfo> constructors;
  5486. Variant::get_constructor_list(tn->vtype, &constructors);
  5487. PropertyInfo return_type;
  5488. for (List<MethodInfo>::Element *E = constructors.front(); E; E = E->next()) {
  5489. MethodInfo &mi = E->get();
  5490. if (p_call->arguments.size() - 1 < mi.arguments.size() - mi.default_arguments.size()) {
  5491. continue;
  5492. }
  5493. if (p_call->arguments.size() - 1 > mi.arguments.size()) {
  5494. continue;
  5495. }
  5496. bool types_match = true;
  5497. for (int i = 0; i < par_types.size(); i++) {
  5498. DataType arg_type;
  5499. if (mi.arguments[i].type != Variant::NIL) {
  5500. arg_type.has_type = true;
  5501. arg_type.kind = mi.arguments[i].type == Variant::OBJECT ? DataType::NATIVE : DataType::BUILTIN;
  5502. arg_type.builtin_type = mi.arguments[i].type;
  5503. arg_type.native_type = mi.arguments[i].class_name;
  5504. }
  5505. if (!_is_type_compatible(arg_type, par_types[i], true)) {
  5506. types_match = false;
  5507. break;
  5508. } else {
  5509. #ifdef DEBUG_ENABLED
  5510. if (arg_type.kind == DataType::BUILTIN && arg_type.builtin_type == Variant::INT && par_types[i].kind == DataType::BUILTIN && par_types[i].builtin_type == Variant::REAL) {
  5511. _add_warning(GDScriptWarning::NARROWING_CONVERSION, p_call->line, Variant::get_type_name(tn->vtype));
  5512. }
  5513. if (par_types[i].may_yield && p_call->arguments[i + 1]->type == Node::TYPE_OPERATOR) {
  5514. _add_warning(GDScriptWarning::FUNCTION_MAY_YIELD, p_call->line, _find_function_name(static_cast<OperatorNode *>(p_call->arguments[i + 1])));
  5515. }
  5516. #endif // DEBUG_ENABLED
  5517. }
  5518. }
  5519. if (types_match) {
  5520. match = true;
  5521. return_type = mi.return_val;
  5522. break;
  5523. }
  5524. }
  5525. if (match) {
  5526. return _type_from_property(return_type, false);
  5527. } else if (check_types) {
  5528. String err = "No constructor of '";
  5529. err += Variant::get_type_name(tn->vtype);
  5530. err += "' matches the signature '";
  5531. err += Variant::get_type_name(tn->vtype) + "(";
  5532. for (int i = 0; i < par_types.size(); i++) {
  5533. if (i > 0) err += ", ";
  5534. err += par_types[i].to_string();
  5535. }
  5536. err += ")'.";
  5537. _set_error(err, p_call->line, p_call->column);
  5538. return DataType();
  5539. }
  5540. return DataType();
  5541. } break;
  5542. case GDScriptParser::Node::TYPE_BUILT_IN_FUNCTION: {
  5543. BuiltInFunctionNode *func = static_cast<BuiltInFunctionNode *>(p_call->arguments[0]);
  5544. MethodInfo mi = GDScriptFunctions::get_info(func->function);
  5545. return_type = _type_from_property(mi.return_val, false);
  5546. #ifdef DEBUG_ENABLED
  5547. // Check all arguments beforehand to solve warnings
  5548. for (int i = 1; i < p_call->arguments.size(); i++) {
  5549. _reduce_node_type(p_call->arguments[i]);
  5550. }
  5551. #endif // DEBUG_ENABLED
  5552. // Check arguments
  5553. is_vararg = mi.flags & METHOD_FLAG_VARARG;
  5554. default_args_count = mi.default_arguments.size();
  5555. callee_name = mi.name;
  5556. arg_count -= 1;
  5557. // Check each argument type
  5558. for (List<PropertyInfo>::Element *E = mi.arguments.front(); E; E = E->next()) {
  5559. arg_types.push_back(_type_from_property(E->get()));
  5560. }
  5561. } break;
  5562. default: {
  5563. if (p_call->op == OperatorNode::OP_CALL && p_call->arguments.size() < 2) {
  5564. _set_error("Parser bug: self method call without enough arguments.", p_call->line);
  5565. ERR_FAIL_V(DataType());
  5566. }
  5567. int arg_id = p_call->op == OperatorNode::OP_CALL ? 1 : 0;
  5568. if (p_call->arguments[arg_id]->type != Node::TYPE_IDENTIFIER) {
  5569. _set_error("Parser bug: invalid function call argument.", p_call->line);
  5570. ERR_FAIL_V(DataType());
  5571. }
  5572. #ifdef DEBUG_ENABLED
  5573. // Check all arguments beforehand to solve warnings
  5574. for (int i = arg_id + 1; i < p_call->arguments.size(); i++) {
  5575. _reduce_node_type(p_call->arguments[i]);
  5576. }
  5577. #endif // DEBUG_ENABLED
  5578. IdentifierNode *func_id = static_cast<IdentifierNode *>(p_call->arguments[arg_id]);
  5579. callee_name = func_id->name;
  5580. arg_count -= 1 + arg_id;
  5581. DataType base_type;
  5582. if (p_call->op == OperatorNode::OP_PARENT_CALL) {
  5583. base_type = current_class->base_type;
  5584. } else {
  5585. base_type = _reduce_node_type(p_call->arguments[0]);
  5586. }
  5587. if (!base_type.has_type || (base_type.kind == DataType::BUILTIN && base_type.builtin_type == Variant::NIL)) {
  5588. _mark_line_as_unsafe(p_call->line);
  5589. return DataType();
  5590. }
  5591. if (base_type.kind == DataType::BUILTIN) {
  5592. Variant::CallError err;
  5593. Variant tmp = Variant::construct(base_type.builtin_type, NULL, 0, err);
  5594. if (check_types) {
  5595. if (!tmp.has_method(callee_name)) {
  5596. _set_error("Method '" + callee_name + "' is not declared on base '" + base_type.to_string() + "'.", p_call->line);
  5597. return DataType();
  5598. }
  5599. default_args_count = Variant::get_method_default_arguments(base_type.builtin_type, callee_name).size();
  5600. const Vector<Variant::Type> &var_arg_types = Variant::get_method_argument_types(base_type.builtin_type, callee_name);
  5601. for (int i = 0; i < var_arg_types.size(); i++) {
  5602. DataType argtype;
  5603. if (var_arg_types[i] != Variant::NIL) {
  5604. argtype.has_type = true;
  5605. argtype.kind = DataType::BUILTIN;
  5606. argtype.builtin_type = var_arg_types[i];
  5607. }
  5608. arg_types.push_back(argtype);
  5609. }
  5610. }
  5611. bool rets = false;
  5612. return_type.has_type = true;
  5613. return_type.kind = DataType::BUILTIN;
  5614. return_type.builtin_type = Variant::get_method_return_type(base_type.builtin_type, callee_name, &rets);
  5615. // If the method returns, but it might return any type, (Variant::NIL), pretend we don't know the type.
  5616. // At least make sure we know that it returns
  5617. if (rets && return_type.builtin_type == Variant::NIL) {
  5618. return_type.has_type = false;
  5619. }
  5620. break;
  5621. }
  5622. DataType original_type = base_type;
  5623. bool is_initializer = callee_name == "new";
  5624. bool is_static = false;
  5625. bool valid = false;
  5626. if (is_initializer && original_type.is_meta_type) {
  5627. // Try to check it as initializer
  5628. base_type = original_type;
  5629. callee_name = "_init";
  5630. base_type.is_meta_type = false;
  5631. valid = _get_function_signature(base_type, callee_name, return_type, arg_types,
  5632. default_args_count, is_static, is_vararg);
  5633. return_type = original_type;
  5634. return_type.is_meta_type = false;
  5635. valid = true; // There's always an initializer, we can asume this is true
  5636. }
  5637. if (!valid) {
  5638. base_type = original_type;
  5639. return_type = DataType();
  5640. valid = _get_function_signature(base_type, callee_name, return_type, arg_types,
  5641. default_args_count, is_static, is_vararg);
  5642. }
  5643. if (!valid) {
  5644. #ifdef DEBUG_ENABLED
  5645. if (p_call->arguments[0]->type == Node::TYPE_SELF) {
  5646. _set_error("Method '" + callee_name + "' is not declared in the current class.", p_call->line);
  5647. return DataType();
  5648. }
  5649. DataType tmp_type;
  5650. valid = _get_member_type(original_type, func_id->name, tmp_type);
  5651. if (valid) {
  5652. if (tmp_type.is_constant) {
  5653. _add_warning(GDScriptWarning::CONSTANT_USED_AS_FUNCTION, p_call->line, callee_name, original_type.to_string());
  5654. } else {
  5655. _add_warning(GDScriptWarning::PROPERTY_USED_AS_FUNCTION, p_call->line, callee_name, original_type.to_string());
  5656. }
  5657. }
  5658. _add_warning(GDScriptWarning::UNSAFE_METHOD_ACCESS, p_call->line, callee_name, original_type.to_string());
  5659. _mark_line_as_unsafe(p_call->line);
  5660. #endif // DEBUG_ENABLED
  5661. return DataType();
  5662. }
  5663. #ifdef DEBUG_ENABLED
  5664. if (current_function && !for_completion && !is_static && p_call->arguments[0]->type == Node::TYPE_SELF && current_function->_static) {
  5665. if (current_function && current_function->_static && p_call->arguments[0]->type == Node::TYPE_SELF) {
  5666. _set_error("Can't call non-static function from a static function.", p_call->line);
  5667. return DataType();
  5668. }
  5669. }
  5670. if (check_types && !is_static && !is_initializer && base_type.is_meta_type) {
  5671. _set_error("Non-static function '" + String(callee_name) + "' can only be called from an instance.", p_call->line);
  5672. return DataType();
  5673. }
  5674. // Check signal emission for warnings
  5675. if (callee_name == "emit_signal" && p_call->op == OperatorNode::OP_CALL && p_call->arguments[0]->type == Node::TYPE_SELF && p_call->arguments.size() >= 3 && p_call->arguments[2]->type == Node::TYPE_CONSTANT) {
  5676. ConstantNode *sig = static_cast<ConstantNode *>(p_call->arguments[2]);
  5677. String emitted = sig->value.get_type() == Variant::STRING ? sig->value.operator String() : "";
  5678. for (int i = 0; i < current_class->_signals.size(); i++) {
  5679. if (current_class->_signals[i].name == emitted) {
  5680. current_class->_signals.write[i].emissions += 1;
  5681. break;
  5682. }
  5683. }
  5684. }
  5685. #endif // DEBUG_ENABLED
  5686. } break;
  5687. }
  5688. #ifdef DEBUG_ENABLED
  5689. if (!check_types) {
  5690. return return_type;
  5691. }
  5692. if (arg_count < arg_types.size() - default_args_count) {
  5693. _set_error("Too few arguments for '" + callee_name + "()' call. Expected at least " + itos(arg_types.size() - default_args_count) + ".", p_call->line);
  5694. return return_type;
  5695. }
  5696. if (!is_vararg && arg_count > arg_types.size()) {
  5697. _set_error("Too many arguments for '" + callee_name + "()' call. Expected at most " + itos(arg_types.size()) + ".", p_call->line);
  5698. return return_type;
  5699. }
  5700. int arg_diff = p_call->arguments.size() - arg_count;
  5701. for (int i = arg_diff; i < p_call->arguments.size(); i++) {
  5702. DataType par_type = _reduce_node_type(p_call->arguments[i]);
  5703. if ((i - arg_diff) >= arg_types.size()) {
  5704. continue;
  5705. }
  5706. DataType arg_type = arg_types[i - arg_diff];
  5707. if (!par_type.has_type) {
  5708. _mark_line_as_unsafe(p_call->line);
  5709. if (par_type.may_yield && p_call->arguments[i]->type == Node::TYPE_OPERATOR) {
  5710. _add_warning(GDScriptWarning::FUNCTION_MAY_YIELD, p_call->line, _find_function_name(static_cast<OperatorNode *>(p_call->arguments[i])));
  5711. }
  5712. } else if (!_is_type_compatible(arg_types[i - arg_diff], par_type, true)) {
  5713. // Supertypes are acceptable for dynamic compliance
  5714. if (!_is_type_compatible(par_type, arg_types[i - arg_diff])) {
  5715. _set_error("At '" + callee_name + "()' call, argument " + itos(i - arg_diff + 1) + ". Assigned type (" +
  5716. par_type.to_string() + ") doesn't match the function argument's type (" +
  5717. arg_types[i - arg_diff].to_string() + ").",
  5718. p_call->line);
  5719. return DataType();
  5720. } else {
  5721. _mark_line_as_unsafe(p_call->line);
  5722. }
  5723. } else {
  5724. if (arg_type.kind == DataType::BUILTIN && arg_type.builtin_type == Variant::INT && par_type.kind == DataType::BUILTIN && par_type.builtin_type == Variant::REAL) {
  5725. _add_warning(GDScriptWarning::NARROWING_CONVERSION, p_call->line, callee_name);
  5726. }
  5727. }
  5728. }
  5729. #endif // DEBUG_ENABLED
  5730. return return_type;
  5731. }
  5732. bool GDScriptParser::_get_member_type(const DataType &p_base_type, const StringName &p_member, DataType &r_member_type) const {
  5733. DataType base_type = p_base_type;
  5734. // Check classes in current file
  5735. ClassNode *base = NULL;
  5736. if (base_type.kind == DataType::CLASS) {
  5737. base = base_type.class_type;
  5738. }
  5739. while (base) {
  5740. if (base->constant_expressions.has(p_member)) {
  5741. r_member_type = base->constant_expressions[p_member].expression->get_datatype();
  5742. return true;
  5743. }
  5744. if (!base_type.is_meta_type) {
  5745. for (int i = 0; i < base->variables.size(); i++) {
  5746. if (base->variables[i].identifier == p_member) {
  5747. r_member_type = base->variables[i].data_type;
  5748. base->variables.write[i].usages += 1;
  5749. return true;
  5750. }
  5751. }
  5752. } else {
  5753. for (int i = 0; i < base->subclasses.size(); i++) {
  5754. ClassNode *c = base->subclasses[i];
  5755. if (c->name == p_member) {
  5756. DataType class_type;
  5757. class_type.has_type = true;
  5758. class_type.is_constant = true;
  5759. class_type.is_meta_type = true;
  5760. class_type.kind = DataType::CLASS;
  5761. class_type.class_type = c;
  5762. r_member_type = class_type;
  5763. return true;
  5764. }
  5765. }
  5766. }
  5767. base_type = base->base_type;
  5768. if (base_type.kind == DataType::CLASS) {
  5769. base = base_type.class_type;
  5770. } else {
  5771. break;
  5772. }
  5773. }
  5774. Ref<GDScript> gds;
  5775. if (base_type.kind == DataType::GDSCRIPT) {
  5776. gds = base_type.script_type;
  5777. if (gds.is_null() || !gds->is_valid()) {
  5778. // GDScript wasn't properly compíled, don't bother trying
  5779. return false;
  5780. }
  5781. }
  5782. Ref<Script> scr;
  5783. if (base_type.kind == DataType::SCRIPT) {
  5784. scr = base_type.script_type;
  5785. }
  5786. StringName native;
  5787. if (base_type.kind == DataType::NATIVE) {
  5788. native = base_type.native_type;
  5789. }
  5790. // Check GDScripts
  5791. while (gds.is_valid()) {
  5792. if (gds->get_constants().has(p_member)) {
  5793. Variant c = gds->get_constants()[p_member];
  5794. r_member_type = _type_from_variant(c);
  5795. return true;
  5796. }
  5797. if (!base_type.is_meta_type) {
  5798. if (gds->get_members().has(p_member)) {
  5799. r_member_type = _type_from_gdtype(gds->get_member_type(p_member));
  5800. return true;
  5801. }
  5802. }
  5803. native = gds->get_instance_base_type();
  5804. if (gds->get_base_script().is_valid()) {
  5805. gds = gds->get_base_script();
  5806. scr = gds->get_base_script();
  5807. bool is_meta = base_type.is_meta_type;
  5808. base_type = _type_from_variant(scr.operator Variant());
  5809. base_type.is_meta_type = is_meta;
  5810. } else {
  5811. break;
  5812. }
  5813. }
  5814. // Check other script types
  5815. while (scr.is_valid()) {
  5816. Map<StringName, Variant> constants;
  5817. scr->get_constants(&constants);
  5818. if (constants.has(p_member)) {
  5819. r_member_type = _type_from_variant(constants[p_member]);
  5820. return true;
  5821. }
  5822. List<PropertyInfo> properties;
  5823. scr->get_script_property_list(&properties);
  5824. for (List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
  5825. if (E->get().name == p_member) {
  5826. r_member_type = _type_from_property(E->get());
  5827. return true;
  5828. }
  5829. }
  5830. base_type = _type_from_variant(scr.operator Variant());
  5831. native = scr->get_instance_base_type();
  5832. scr = scr->get_base_script();
  5833. }
  5834. if (native == StringName()) {
  5835. // Empty native class, might happen in some Script implementations
  5836. // Just ignore it
  5837. return false;
  5838. }
  5839. // Check ClassDB
  5840. if (!ClassDB::class_exists(native)) {
  5841. native = "_" + native.operator String();
  5842. }
  5843. if (!ClassDB::class_exists(native)) {
  5844. if (!check_types) return false;
  5845. ERR_EXPLAIN("Parser bug: Class '" + String(native) + "' not found.");
  5846. ERR_FAIL_V(false);
  5847. }
  5848. bool valid = false;
  5849. ClassDB::get_integer_constant(native, p_member, &valid);
  5850. if (valid) {
  5851. DataType ct;
  5852. ct.has_type = true;
  5853. ct.is_constant = true;
  5854. ct.kind = DataType::BUILTIN;
  5855. ct.builtin_type = Variant::INT;
  5856. r_member_type = ct;
  5857. return true;
  5858. }
  5859. if (!base_type.is_meta_type) {
  5860. List<PropertyInfo> properties;
  5861. ClassDB::get_property_list(native, &properties);
  5862. for (List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
  5863. if (E->get().name == p_member) {
  5864. // Check if a getter exists
  5865. StringName getter_name = ClassDB::get_property_getter(native, p_member);
  5866. if (getter_name != StringName()) {
  5867. // Use the getter return type
  5868. #ifdef DEBUG_METHODS_ENABLED
  5869. MethodBind *getter_method = ClassDB::get_method(native, getter_name);
  5870. if (getter_method) {
  5871. r_member_type = _type_from_property(getter_method->get_return_info());
  5872. } else {
  5873. r_member_type = DataType();
  5874. }
  5875. #else
  5876. r_member_type = DataType();
  5877. #endif
  5878. } else {
  5879. r_member_type = _type_from_property(E->get());
  5880. }
  5881. return true;
  5882. }
  5883. }
  5884. }
  5885. // If the base is a script, it might be trying to access members of the Script class itself
  5886. if (p_base_type.is_meta_type && (p_base_type.kind == DataType::SCRIPT || p_base_type.kind == DataType::GDSCRIPT)) {
  5887. native = p_base_type.script_type->get_class_name();
  5888. ClassDB::get_integer_constant(native, p_member, &valid);
  5889. if (valid) {
  5890. DataType ct;
  5891. ct.has_type = true;
  5892. ct.is_constant = true;
  5893. ct.kind = DataType::BUILTIN;
  5894. ct.builtin_type = Variant::INT;
  5895. r_member_type = ct;
  5896. return true;
  5897. }
  5898. List<PropertyInfo> properties;
  5899. ClassDB::get_property_list(native, &properties);
  5900. for (List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
  5901. if (E->get().name == p_member) {
  5902. // Check if a getter exists
  5903. StringName getter_name = ClassDB::get_property_getter(native, p_member);
  5904. if (getter_name != StringName()) {
  5905. // Use the getter return type
  5906. #ifdef DEBUG_METHODS_ENABLED
  5907. MethodBind *getter_method = ClassDB::get_method(native, getter_name);
  5908. if (getter_method) {
  5909. r_member_type = _type_from_property(getter_method->get_return_info());
  5910. } else {
  5911. r_member_type = DataType();
  5912. }
  5913. #else
  5914. r_member_type = DataType();
  5915. #endif
  5916. } else {
  5917. r_member_type = _type_from_property(E->get());
  5918. }
  5919. return true;
  5920. }
  5921. }
  5922. }
  5923. return false;
  5924. }
  5925. GDScriptParser::DataType GDScriptParser::_reduce_identifier_type(const DataType *p_base_type, const StringName &p_identifier, int p_line, bool p_is_indexing) {
  5926. if (p_base_type && !p_base_type->has_type) {
  5927. return DataType();
  5928. }
  5929. DataType base_type;
  5930. DataType member_type;
  5931. if (!p_base_type) {
  5932. base_type.has_type = true;
  5933. base_type.is_constant = true;
  5934. base_type.kind = DataType::CLASS;
  5935. base_type.class_type = current_class;
  5936. } else {
  5937. base_type = DataType(*p_base_type);
  5938. }
  5939. if (_get_member_type(base_type, p_identifier, member_type)) {
  5940. return member_type;
  5941. }
  5942. if (p_is_indexing) {
  5943. // Don't look for globals since this is an indexed identifier
  5944. return DataType();
  5945. }
  5946. if (!p_base_type) {
  5947. // Possibly this is a global, check before failing
  5948. if (ClassDB::class_exists(p_identifier) || ClassDB::class_exists("_" + p_identifier.operator String())) {
  5949. DataType result;
  5950. result.has_type = true;
  5951. result.is_constant = true;
  5952. result.is_meta_type = true;
  5953. if (Engine::get_singleton()->has_singleton(p_identifier) || Engine::get_singleton()->has_singleton("_" + p_identifier.operator String())) {
  5954. result.is_meta_type = false;
  5955. }
  5956. result.kind = DataType::NATIVE;
  5957. result.native_type = p_identifier;
  5958. return result;
  5959. }
  5960. ClassNode *outer_class = current_class;
  5961. while (outer_class) {
  5962. if (outer_class->name == p_identifier) {
  5963. DataType result;
  5964. result.has_type = true;
  5965. result.is_constant = true;
  5966. result.is_meta_type = true;
  5967. result.kind = DataType::CLASS;
  5968. result.class_type = outer_class;
  5969. return result;
  5970. }
  5971. if (outer_class->constant_expressions.has(p_identifier)) {
  5972. return outer_class->constant_expressions[p_identifier].type;
  5973. }
  5974. for (int i = 0; i < outer_class->subclasses.size(); i++) {
  5975. if (outer_class->subclasses[i] == current_class) {
  5976. continue;
  5977. }
  5978. if (outer_class->subclasses[i]->name == p_identifier) {
  5979. DataType result;
  5980. result.has_type = true;
  5981. result.is_constant = true;
  5982. result.is_meta_type = true;
  5983. result.kind = DataType::CLASS;
  5984. result.class_type = outer_class->subclasses[i];
  5985. return result;
  5986. }
  5987. }
  5988. outer_class = outer_class->owner;
  5989. }
  5990. if (ScriptServer::is_global_class(p_identifier)) {
  5991. Ref<Script> scr = ResourceLoader::load(ScriptServer::get_global_class_path(p_identifier));
  5992. if (scr.is_valid()) {
  5993. DataType result;
  5994. result.has_type = true;
  5995. result.script_type = scr;
  5996. result.is_meta_type = true;
  5997. Ref<GDScript> gds = scr;
  5998. if (gds.is_valid()) {
  5999. if (!gds->is_valid()) {
  6000. _set_error("Class '" + p_identifier + "' could not be fully loaded (script error or cyclic dependency).");
  6001. return DataType();
  6002. }
  6003. result.kind = DataType::GDSCRIPT;
  6004. } else {
  6005. result.kind = DataType::SCRIPT;
  6006. }
  6007. return result;
  6008. }
  6009. _set_error("Class '" + p_identifier + "' was found in global scope but its script could not be loaded.");
  6010. return DataType();
  6011. }
  6012. if (GDScriptLanguage::get_singleton()->get_global_map().has(p_identifier)) {
  6013. int idx = GDScriptLanguage::get_singleton()->get_global_map()[p_identifier];
  6014. Variant g = GDScriptLanguage::get_singleton()->get_global_array()[idx];
  6015. return _type_from_variant(g);
  6016. }
  6017. if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(p_identifier)) {
  6018. Variant g = GDScriptLanguage::get_singleton()->get_named_globals_map()[p_identifier];
  6019. return _type_from_variant(g);
  6020. }
  6021. // Non-tool singletons aren't loaded, check project settings
  6022. List<PropertyInfo> props;
  6023. ProjectSettings::get_singleton()->get_property_list(&props);
  6024. for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
  6025. String s = E->get().name;
  6026. if (!s.begins_with("autoload/")) {
  6027. continue;
  6028. }
  6029. String name = s.get_slice("/", 1);
  6030. if (name == p_identifier) {
  6031. String script = ProjectSettings::get_singleton()->get(s);
  6032. if (script.begins_with("*")) {
  6033. script = script.right(1);
  6034. }
  6035. if (!script.begins_with("res://")) {
  6036. script = "res://" + script;
  6037. }
  6038. Ref<Script> singleton = ResourceLoader::load(script);
  6039. if (singleton.is_valid()) {
  6040. DataType result;
  6041. result.has_type = true;
  6042. result.script_type = singleton;
  6043. Ref<GDScript> gds = singleton;
  6044. if (gds.is_valid()) {
  6045. if (!gds->is_valid()) {
  6046. _set_error("Couldn't fully load singleton script '" + p_identifier + "' (possible cyclic reference or parse error).", p_line);
  6047. return DataType();
  6048. }
  6049. result.kind = DataType::GDSCRIPT;
  6050. } else {
  6051. result.kind = DataType::SCRIPT;
  6052. }
  6053. }
  6054. }
  6055. }
  6056. // This means looking in the current class, which type is always known
  6057. _set_error("Identifier '" + p_identifier.operator String() + "' is not declared in the current scope.", p_line);
  6058. }
  6059. #ifdef DEBUG_ENABLED
  6060. {
  6061. DataType tmp_type;
  6062. List<DataType> arg_types;
  6063. int argcount;
  6064. bool _static;
  6065. bool vararg;
  6066. if (_get_function_signature(base_type, p_identifier, tmp_type, arg_types, argcount, _static, vararg)) {
  6067. _add_warning(GDScriptWarning::FUNCTION_USED_AS_PROPERTY, p_line, p_identifier.operator String(), base_type.to_string());
  6068. }
  6069. }
  6070. #endif // DEBUG_ENABLED
  6071. _mark_line_as_unsafe(p_line);
  6072. return DataType();
  6073. }
  6074. void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
  6075. _mark_line_as_safe(p_class->line);
  6076. // Constants
  6077. for (Map<StringName, ClassNode::Constant>::Element *E = p_class->constant_expressions.front(); E; E = E->next()) {
  6078. ClassNode::Constant &c = E->get();
  6079. _mark_line_as_safe(c.expression->line);
  6080. DataType cont = _resolve_type(c.type, c.expression->line);
  6081. DataType expr = _resolve_type(c.expression->get_datatype(), c.expression->line);
  6082. if (check_types && !_is_type_compatible(cont, expr)) {
  6083. _set_error("Constant value type (" + expr.to_string() + ") is not compatible with declared type (" + cont.to_string() + ").",
  6084. c.expression->line);
  6085. return;
  6086. }
  6087. expr.is_constant = true;
  6088. c.type = expr;
  6089. c.expression->set_datatype(expr);
  6090. DataType tmp;
  6091. if (_get_member_type(p_class->base_type, E->key(), tmp)) {
  6092. _set_error("Member '" + String(E->key()) + "' already exists in parent class.", c.expression->line);
  6093. return;
  6094. }
  6095. }
  6096. // Function declarations
  6097. for (int i = 0; i < p_class->static_functions.size(); i++) {
  6098. _check_function_types(p_class->static_functions[i]);
  6099. if (error_set) return;
  6100. }
  6101. for (int i = 0; i < p_class->functions.size(); i++) {
  6102. _check_function_types(p_class->functions[i]);
  6103. if (error_set) return;
  6104. }
  6105. // Class variables
  6106. for (int i = 0; i < p_class->variables.size(); i++) {
  6107. ClassNode::Member &v = p_class->variables.write[i];
  6108. DataType tmp;
  6109. if (_get_member_type(p_class->base_type, v.identifier, tmp)) {
  6110. _set_error("Member '" + String(v.identifier) + "' already exists in parent class.", v.line);
  6111. return;
  6112. }
  6113. _mark_line_as_safe(v.line);
  6114. v.data_type = _resolve_type(v.data_type, v.line);
  6115. if (v.expression) {
  6116. DataType expr_type = _reduce_node_type(v.expression);
  6117. if (check_types && !_is_type_compatible(v.data_type, expr_type)) {
  6118. // Try supertype test
  6119. if (_is_type_compatible(expr_type, v.data_type)) {
  6120. _mark_line_as_unsafe(v.line);
  6121. } else {
  6122. // Try with implicit conversion
  6123. if (v.data_type.kind != DataType::BUILTIN || !_is_type_compatible(v.data_type, expr_type, true)) {
  6124. _set_error("Assigned expression type (" + expr_type.to_string() + ") doesn't match the variable's type (" +
  6125. v.data_type.to_string() + ").",
  6126. v.line);
  6127. return;
  6128. }
  6129. // Replace assignment with implict conversion
  6130. BuiltInFunctionNode *convert = alloc_node<BuiltInFunctionNode>();
  6131. convert->line = v.line;
  6132. convert->function = GDScriptFunctions::TYPE_CONVERT;
  6133. ConstantNode *tgt_type = alloc_node<ConstantNode>();
  6134. tgt_type->line = v.line;
  6135. tgt_type->value = (int)v.data_type.builtin_type;
  6136. OperatorNode *convert_call = alloc_node<OperatorNode>();
  6137. convert_call->line = v.line;
  6138. convert_call->op = OperatorNode::OP_CALL;
  6139. convert_call->arguments.push_back(convert);
  6140. convert_call->arguments.push_back(v.expression);
  6141. convert_call->arguments.push_back(tgt_type);
  6142. v.expression = convert_call;
  6143. v.initial_assignment->arguments.write[1] = convert_call;
  6144. }
  6145. }
  6146. if (v.data_type.infer_type) {
  6147. if (!expr_type.has_type) {
  6148. _set_error("Assigned value does not have a set type, variable type cannot be inferred.", v.line);
  6149. return;
  6150. }
  6151. v.data_type = expr_type;
  6152. v.data_type.is_constant = false;
  6153. }
  6154. } else if (v.data_type.has_type && v.data_type.kind == DataType::BUILTIN) {
  6155. // Create default value based on the type
  6156. IdentifierNode *id = alloc_node<IdentifierNode>();
  6157. id->line = v.line;
  6158. id->name = v.identifier;
  6159. ConstantNode *init = alloc_node<ConstantNode>();
  6160. init->line = v.line;
  6161. Variant::CallError err;
  6162. init->value = Variant::construct(v.data_type.builtin_type, NULL, 0, err);
  6163. OperatorNode *op = alloc_node<OperatorNode>();
  6164. op->line = v.line;
  6165. op->op = OperatorNode::OP_INIT_ASSIGN;
  6166. op->arguments.push_back(id);
  6167. op->arguments.push_back(init);
  6168. p_class->initializer->statements.push_front(op);
  6169. v.initial_assignment = op;
  6170. #ifdef DEBUG_ENABLED
  6171. NewLineNode *nl = alloc_node<NewLineNode>();
  6172. nl->line = v.line - 1;
  6173. p_class->initializer->statements.push_front(nl);
  6174. #endif
  6175. }
  6176. // Check export hint
  6177. if (v.data_type.has_type && v._export.type != Variant::NIL) {
  6178. DataType export_type = _type_from_property(v._export);
  6179. if (!_is_type_compatible(v.data_type, export_type, true)) {
  6180. _set_error("Export hint type (" + export_type.to_string() + ") doesn't match the variable's type (" +
  6181. v.data_type.to_string() + ").",
  6182. v.line);
  6183. return;
  6184. }
  6185. }
  6186. // Setter and getter
  6187. if (v.setter == StringName() && v.getter == StringName()) continue;
  6188. bool found_getter = false;
  6189. bool found_setter = false;
  6190. for (int j = 0; j < p_class->functions.size(); j++) {
  6191. if (v.setter == p_class->functions[j]->name) {
  6192. found_setter = true;
  6193. FunctionNode *setter = p_class->functions[j];
  6194. if (setter->arguments.size() != 1) {
  6195. _set_error("Setter function needs to receive exactly 1 argument. See '" + setter->name +
  6196. "()' definition at line " + itos(setter->line) + ".",
  6197. v.line);
  6198. return;
  6199. }
  6200. if (!_is_type_compatible(v.data_type, setter->argument_types[0])) {
  6201. _set_error("Setter argument type (" + setter->argument_types[0].to_string() +
  6202. ") doesn't match the variable's type (" + v.data_type.to_string() + "). See '" +
  6203. setter->name + "()' definition at line " + itos(setter->line) + ".",
  6204. v.line);
  6205. return;
  6206. }
  6207. continue;
  6208. }
  6209. if (v.getter == p_class->functions[j]->name) {
  6210. found_getter = true;
  6211. FunctionNode *getter = p_class->functions[j];
  6212. if (getter->arguments.size() != 0) {
  6213. _set_error("Getter function can't receive arguments. See '" + getter->name +
  6214. "()' definition at line " + itos(getter->line) + ".",
  6215. v.line);
  6216. return;
  6217. }
  6218. if (!_is_type_compatible(v.data_type, getter->get_datatype())) {
  6219. _set_error("Getter return type (" + getter->get_datatype().to_string() +
  6220. ") doesn't match the variable's type (" + v.data_type.to_string() +
  6221. "). See '" + getter->name + "()' definition at line " + itos(getter->line) + ".",
  6222. v.line);
  6223. return;
  6224. }
  6225. }
  6226. if (found_getter && found_setter) break;
  6227. }
  6228. if ((found_getter || v.getter == StringName()) && (found_setter || v.setter == StringName())) continue;
  6229. // Check for static functions
  6230. for (int j = 0; j < p_class->static_functions.size(); j++) {
  6231. if (v.setter == p_class->static_functions[j]->name) {
  6232. FunctionNode *setter = p_class->static_functions[j];
  6233. _set_error("Setter can't be a static function. See '" + setter->name + "()' definition at line " + itos(setter->line) + ".", v.line);
  6234. return;
  6235. }
  6236. if (v.getter == p_class->static_functions[j]->name) {
  6237. FunctionNode *getter = p_class->static_functions[j];
  6238. _set_error("Getter can't be a static function. See '" + getter->name + "()' definition at line " + itos(getter->line) + ".", v.line);
  6239. return;
  6240. }
  6241. }
  6242. if (!found_setter && v.setter != StringName()) {
  6243. _set_error("Setter function is not defined.", v.line);
  6244. return;
  6245. }
  6246. if (!found_getter && v.getter != StringName()) {
  6247. _set_error("Getter function is not defined.", v.line);
  6248. return;
  6249. }
  6250. }
  6251. // Inner classes
  6252. for (int i = 0; i < p_class->subclasses.size(); i++) {
  6253. current_class = p_class->subclasses[i];
  6254. _check_class_level_types(current_class);
  6255. if (error_set) return;
  6256. current_class = p_class;
  6257. }
  6258. }
  6259. void GDScriptParser::_check_function_types(FunctionNode *p_function) {
  6260. p_function->return_type = _resolve_type(p_function->return_type, p_function->line);
  6261. // Arguments
  6262. int defaults_ofs = p_function->arguments.size() - p_function->default_values.size();
  6263. for (int i = 0; i < p_function->arguments.size(); i++) {
  6264. if (i < defaults_ofs) {
  6265. p_function->argument_types.write[i] = _resolve_type(p_function->argument_types[i], p_function->line);
  6266. } else {
  6267. if (p_function->default_values[i - defaults_ofs]->type != Node::TYPE_OPERATOR) {
  6268. _set_error("Parser bug: invalid argument default value.", p_function->line, p_function->column);
  6269. return;
  6270. }
  6271. OperatorNode *op = static_cast<OperatorNode *>(p_function->default_values[i - defaults_ofs]);
  6272. if (op->op != OperatorNode::OP_ASSIGN || op->arguments.size() != 2) {
  6273. _set_error("Parser bug: invalid argument default value operation.", p_function->line);
  6274. return;
  6275. }
  6276. DataType def_type = _reduce_node_type(op->arguments[1]);
  6277. if (p_function->argument_types[i].infer_type) {
  6278. def_type.is_constant = false;
  6279. p_function->argument_types.write[i] = def_type;
  6280. } else {
  6281. p_function->return_type = _resolve_type(p_function->return_type, p_function->line);
  6282. if (!_is_type_compatible(p_function->argument_types[i], def_type, true)) {
  6283. String arg_name = p_function->arguments[i];
  6284. _set_error("Value type (" + def_type.to_string() + ") doesn't match the type of argument '" +
  6285. arg_name + "' (" + p_function->arguments[i] + ")",
  6286. p_function->line);
  6287. }
  6288. }
  6289. }
  6290. #ifdef DEBUG_ENABLED
  6291. if (p_function->arguments_usage[i] == 0 && !p_function->arguments[i].operator String().begins_with("_")) {
  6292. _add_warning(GDScriptWarning::UNUSED_ARGUMENT, p_function->line, p_function->name, p_function->arguments[i].operator String());
  6293. }
  6294. #endif // DEBUG_ENABLED
  6295. }
  6296. if (!(p_function->name == "_init")) {
  6297. // Signature for the initializer may vary
  6298. #ifdef DEBUG_ENABLED
  6299. DataType return_type;
  6300. List<DataType> arg_types;
  6301. int default_arg_count = 0;
  6302. bool _static = false;
  6303. bool vararg = false;
  6304. DataType base_type = current_class->base_type;
  6305. if (_get_function_signature(base_type, p_function->name, return_type, arg_types, default_arg_count, _static, vararg)) {
  6306. bool valid = _static == p_function->_static;
  6307. valid = valid && return_type == p_function->return_type;
  6308. int argsize_diff = p_function->arguments.size() - arg_types.size();
  6309. valid = valid && argsize_diff >= 0;
  6310. valid = valid && p_function->default_values.size() >= default_arg_count + argsize_diff;
  6311. int i = 0;
  6312. for (List<DataType>::Element *E = arg_types.front(); valid && E; E = E->next()) {
  6313. valid = valid && E->get() == p_function->argument_types[i++];
  6314. }
  6315. if (!valid) {
  6316. String parent_signature = return_type.has_type ? return_type.to_string() : "Variant";
  6317. if (parent_signature == "null") {
  6318. parent_signature = "void";
  6319. }
  6320. parent_signature += " " + p_function->name + "(";
  6321. if (arg_types.size()) {
  6322. int i = 0;
  6323. for (List<DataType>::Element *E = arg_types.front(); E; E = E->next()) {
  6324. if (E != arg_types.front()) {
  6325. parent_signature += ", ";
  6326. }
  6327. String arg = E->get().to_string();
  6328. if (arg == "null" || arg == "var") {
  6329. arg = "Variant";
  6330. }
  6331. parent_signature += arg;
  6332. if (i == arg_types.size() - default_arg_count) {
  6333. parent_signature += "=default";
  6334. }
  6335. i++;
  6336. }
  6337. }
  6338. parent_signature += ")";
  6339. _set_error("Function signature doesn't match the parent. Parent signature is: '" + parent_signature + "'.", p_function->line);
  6340. return;
  6341. }
  6342. }
  6343. #endif // DEBUG_ENABLED
  6344. } else {
  6345. if (p_function->return_type.has_type && (p_function->return_type.kind != DataType::BUILTIN || p_function->return_type.builtin_type != Variant::NIL)) {
  6346. _set_error("Constructor cannot return a value.", p_function->line);
  6347. return;
  6348. }
  6349. }
  6350. if (p_function->return_type.has_type && (p_function->return_type.kind != DataType::BUILTIN || p_function->return_type.builtin_type != Variant::NIL)) {
  6351. if (!p_function->body->has_return) {
  6352. _set_error("Non-void function must return a value in all possible paths.", p_function->line);
  6353. return;
  6354. }
  6355. }
  6356. if (p_function->has_yield) {
  6357. // yield() will make the function return a GDScriptFunctionState, so the type is ambiguous
  6358. p_function->return_type.has_type = false;
  6359. p_function->return_type.may_yield = true;
  6360. }
  6361. }
  6362. void GDScriptParser::_check_class_blocks_types(ClassNode *p_class) {
  6363. // Function blocks
  6364. for (int i = 0; i < p_class->static_functions.size(); i++) {
  6365. current_function = p_class->static_functions[i];
  6366. current_block = current_function->body;
  6367. _mark_line_as_safe(current_function->line);
  6368. _check_block_types(current_block);
  6369. current_block = NULL;
  6370. current_function = NULL;
  6371. if (error_set) return;
  6372. }
  6373. for (int i = 0; i < p_class->functions.size(); i++) {
  6374. current_function = p_class->functions[i];
  6375. current_block = current_function->body;
  6376. _mark_line_as_safe(current_function->line);
  6377. _check_block_types(current_block);
  6378. current_block = NULL;
  6379. current_function = NULL;
  6380. if (error_set) return;
  6381. }
  6382. #ifdef DEBUG_ENABLED
  6383. // Warnings
  6384. for (int i = 0; i < p_class->variables.size(); i++) {
  6385. if (p_class->variables[i].usages == 0) {
  6386. _add_warning(GDScriptWarning::UNUSED_CLASS_VARIABLE, p_class->variables[i].line, p_class->variables[i].identifier);
  6387. }
  6388. }
  6389. for (int i = 0; i < p_class->_signals.size(); i++) {
  6390. if (p_class->_signals[i].emissions == 0) {
  6391. _add_warning(GDScriptWarning::UNUSED_SIGNAL, p_class->_signals[i].line, p_class->_signals[i].name);
  6392. }
  6393. }
  6394. #endif // DEBUG_ENABLED
  6395. // Inner classes
  6396. for (int i = 0; i < p_class->subclasses.size(); i++) {
  6397. current_class = p_class->subclasses[i];
  6398. _check_class_blocks_types(current_class);
  6399. if (error_set) return;
  6400. current_class = p_class;
  6401. }
  6402. }
  6403. #ifdef DEBUG_ENABLED
  6404. static String _find_function_name(const GDScriptParser::OperatorNode *p_call) {
  6405. switch (p_call->arguments[0]->type) {
  6406. case GDScriptParser::Node::TYPE_TYPE: {
  6407. return Variant::get_type_name(static_cast<GDScriptParser::TypeNode *>(p_call->arguments[0])->vtype);
  6408. } break;
  6409. case GDScriptParser::Node::TYPE_BUILT_IN_FUNCTION: {
  6410. return GDScriptFunctions::get_func_name(static_cast<GDScriptParser::BuiltInFunctionNode *>(p_call->arguments[0])->function);
  6411. } break;
  6412. default: {
  6413. int id_index = p_call->op == GDScriptParser::OperatorNode::OP_PARENT_CALL ? 0 : 1;
  6414. if (p_call->arguments.size() > id_index && p_call->arguments[id_index]->type == GDScriptParser::Node::TYPE_IDENTIFIER) {
  6415. return static_cast<GDScriptParser::IdentifierNode *>(p_call->arguments[id_index])->name;
  6416. }
  6417. } break;
  6418. }
  6419. return String();
  6420. }
  6421. #endif // DEBUG_ENABLED
  6422. void GDScriptParser::_check_block_types(BlockNode *p_block) {
  6423. Node *last_var_assign = NULL;
  6424. // Check each statement
  6425. for (List<Node *>::Element *E = p_block->statements.front(); E; E = E->next()) {
  6426. Node *statement = E->get();
  6427. switch (statement->type) {
  6428. case Node::TYPE_NEWLINE:
  6429. case Node::TYPE_BREAKPOINT:
  6430. case Node::TYPE_ASSERT: {
  6431. // Nothing to do
  6432. } break;
  6433. case Node::TYPE_LOCAL_VAR: {
  6434. LocalVarNode *lv = static_cast<LocalVarNode *>(statement);
  6435. lv->datatype = _resolve_type(lv->datatype, lv->line);
  6436. _mark_line_as_safe(lv->line);
  6437. last_var_assign = lv->assign;
  6438. if (lv->assign) {
  6439. DataType assign_type = _reduce_node_type(lv->assign);
  6440. #ifdef DEBUG_ENABLED
  6441. if (assign_type.has_type && assign_type.kind == DataType::BUILTIN && assign_type.builtin_type == Variant::NIL) {
  6442. if (lv->assign->type == Node::TYPE_OPERATOR) {
  6443. OperatorNode *call = static_cast<OperatorNode *>(lv->assign);
  6444. if (call->op == OperatorNode::OP_CALL || call->op == OperatorNode::OP_PARENT_CALL) {
  6445. _add_warning(GDScriptWarning::VOID_ASSIGNMENT, lv->line, _find_function_name(call));
  6446. }
  6447. }
  6448. }
  6449. if (lv->datatype.has_type && assign_type.may_yield && lv->assign->type == Node::TYPE_OPERATOR) {
  6450. _add_warning(GDScriptWarning::FUNCTION_MAY_YIELD, lv->line, _find_function_name(static_cast<OperatorNode *>(lv->assign)));
  6451. }
  6452. #endif // DEBUG_ENABLED
  6453. if (!_is_type_compatible(lv->datatype, assign_type)) {
  6454. // Try supertype test
  6455. if (_is_type_compatible(assign_type, lv->datatype)) {
  6456. _mark_line_as_unsafe(lv->line);
  6457. } else {
  6458. // Try implict conversion
  6459. if (lv->datatype.kind != DataType::BUILTIN || !_is_type_compatible(lv->datatype, assign_type, true)) {
  6460. _set_error("Assigned value type (" + assign_type.to_string() + ") doesn't match the variable's type (" +
  6461. lv->datatype.to_string() + ").",
  6462. lv->line);
  6463. return;
  6464. }
  6465. // Replace assignment with implict conversion
  6466. BuiltInFunctionNode *convert = alloc_node<BuiltInFunctionNode>();
  6467. convert->line = lv->line;
  6468. convert->function = GDScriptFunctions::TYPE_CONVERT;
  6469. ConstantNode *tgt_type = alloc_node<ConstantNode>();
  6470. tgt_type->line = lv->line;
  6471. tgt_type->value = (int)lv->datatype.builtin_type;
  6472. OperatorNode *convert_call = alloc_node<OperatorNode>();
  6473. convert_call->line = lv->line;
  6474. convert_call->op = OperatorNode::OP_CALL;
  6475. convert_call->arguments.push_back(convert);
  6476. convert_call->arguments.push_back(lv->assign);
  6477. convert_call->arguments.push_back(tgt_type);
  6478. lv->assign = convert_call;
  6479. lv->assign_op->arguments.write[1] = convert_call;
  6480. #ifdef DEBUG_ENABLED
  6481. if (lv->datatype.builtin_type == Variant::INT && assign_type.builtin_type == Variant::REAL) {
  6482. _add_warning(GDScriptWarning::NARROWING_CONVERSION, lv->line);
  6483. }
  6484. #endif // DEBUG_ENABLED
  6485. }
  6486. }
  6487. if (lv->datatype.infer_type) {
  6488. if (!assign_type.has_type) {
  6489. _set_error("Assigned value does not have a set type, variable type cannot be inferred.", lv->line);
  6490. return;
  6491. }
  6492. lv->datatype = assign_type;
  6493. lv->datatype.is_constant = false;
  6494. }
  6495. if (lv->datatype.has_type && !assign_type.has_type) {
  6496. _mark_line_as_unsafe(lv->line);
  6497. }
  6498. }
  6499. } break;
  6500. case Node::TYPE_OPERATOR: {
  6501. OperatorNode *op = static_cast<OperatorNode *>(statement);
  6502. switch (op->op) {
  6503. case OperatorNode::OP_ASSIGN:
  6504. case OperatorNode::OP_ASSIGN_ADD:
  6505. case OperatorNode::OP_ASSIGN_SUB:
  6506. case OperatorNode::OP_ASSIGN_MUL:
  6507. case OperatorNode::OP_ASSIGN_DIV:
  6508. case OperatorNode::OP_ASSIGN_MOD:
  6509. case OperatorNode::OP_ASSIGN_SHIFT_LEFT:
  6510. case OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
  6511. case OperatorNode::OP_ASSIGN_BIT_AND:
  6512. case OperatorNode::OP_ASSIGN_BIT_OR:
  6513. case OperatorNode::OP_ASSIGN_BIT_XOR: {
  6514. if (op->arguments.size() < 2) {
  6515. _set_error("Parser bug: operation without enough arguments.", op->line, op->column);
  6516. return;
  6517. }
  6518. if (op->arguments[1] == last_var_assign) {
  6519. // Assignment was already checked
  6520. break;
  6521. }
  6522. _mark_line_as_safe(op->line);
  6523. DataType lh_type = _reduce_node_type(op->arguments[0]);
  6524. if (error_set) {
  6525. return;
  6526. }
  6527. if (!lh_type.has_type && check_types) {
  6528. if (op->arguments[0]->type == Node::TYPE_OPERATOR) {
  6529. _mark_line_as_unsafe(op->line);
  6530. }
  6531. } else if (lh_type.is_constant) {
  6532. _set_error("Cannot assign a new value to a constant.", op->line);
  6533. return;
  6534. }
  6535. DataType rh_type;
  6536. if (op->op != OperatorNode::OP_ASSIGN) {
  6537. // Validate operation
  6538. DataType arg_type = _reduce_node_type(op->arguments[1]);
  6539. if (!arg_type.has_type) {
  6540. _mark_line_as_unsafe(op->line);
  6541. break;
  6542. }
  6543. Variant::Operator oper = _get_variant_operation(op->op);
  6544. bool valid = false;
  6545. rh_type = _get_operation_type(oper, lh_type, arg_type, valid);
  6546. if (check_types && !valid) {
  6547. _set_error("Invalid operand types ('" + lh_type.to_string() + "' and '" + arg_type.to_string() +
  6548. "') to assignment operator '" + Variant::get_operator_name(oper) + "'.",
  6549. op->line);
  6550. return;
  6551. }
  6552. } else {
  6553. rh_type = _reduce_node_type(op->arguments[1]);
  6554. }
  6555. #ifdef DEBUG_ENABLED
  6556. if (rh_type.has_type && rh_type.kind == DataType::BUILTIN && rh_type.builtin_type == Variant::NIL) {
  6557. if (op->arguments[1]->type == Node::TYPE_OPERATOR) {
  6558. OperatorNode *call = static_cast<OperatorNode *>(op->arguments[1]);
  6559. if (call->op == OperatorNode::OP_CALL || call->op == OperatorNode::OP_PARENT_CALL) {
  6560. _add_warning(GDScriptWarning::VOID_ASSIGNMENT, op->line, _find_function_name(call));
  6561. }
  6562. }
  6563. }
  6564. if (lh_type.has_type && rh_type.may_yield && op->arguments[1]->type == Node::TYPE_OPERATOR) {
  6565. _add_warning(GDScriptWarning::FUNCTION_MAY_YIELD, op->line, _find_function_name(static_cast<OperatorNode *>(op->arguments[1])));
  6566. }
  6567. #endif // DEBUG_ENABLED
  6568. if (check_types && !_is_type_compatible(lh_type, rh_type)) {
  6569. // Try supertype test
  6570. if (_is_type_compatible(rh_type, lh_type)) {
  6571. _mark_line_as_unsafe(op->line);
  6572. } else {
  6573. // Try implict conversion
  6574. if (lh_type.kind != DataType::BUILTIN || !_is_type_compatible(lh_type, rh_type, true)) {
  6575. _set_error("Assigned value type (" + rh_type.to_string() + ") doesn't match the variable's type (" +
  6576. lh_type.to_string() + ").",
  6577. op->line);
  6578. return;
  6579. }
  6580. // Replace assignment with implict conversion
  6581. BuiltInFunctionNode *convert = alloc_node<BuiltInFunctionNode>();
  6582. convert->line = op->line;
  6583. convert->function = GDScriptFunctions::TYPE_CONVERT;
  6584. ConstantNode *tgt_type = alloc_node<ConstantNode>();
  6585. tgt_type->line = op->line;
  6586. tgt_type->value = (int)lh_type.builtin_type;
  6587. OperatorNode *convert_call = alloc_node<OperatorNode>();
  6588. convert_call->line = op->line;
  6589. convert_call->op = OperatorNode::OP_CALL;
  6590. convert_call->arguments.push_back(convert);
  6591. convert_call->arguments.push_back(op->arguments[1]);
  6592. convert_call->arguments.push_back(tgt_type);
  6593. op->arguments.write[1] = convert_call;
  6594. #ifdef DEBUG_ENABLED
  6595. if (lh_type.builtin_type == Variant::INT && rh_type.builtin_type == Variant::REAL) {
  6596. _add_warning(GDScriptWarning::NARROWING_CONVERSION, op->line);
  6597. }
  6598. #endif // DEBUG_ENABLED
  6599. }
  6600. }
  6601. #ifdef DEBUG_ENABLED
  6602. if (!rh_type.has_type && (op->op != OperatorNode::OP_ASSIGN || lh_type.has_type || op->arguments[0]->type == Node::TYPE_OPERATOR)) {
  6603. _mark_line_as_unsafe(op->line);
  6604. }
  6605. #endif // DEBUG_ENABLED
  6606. } break;
  6607. case OperatorNode::OP_CALL:
  6608. case OperatorNode::OP_PARENT_CALL: {
  6609. _mark_line_as_safe(op->line);
  6610. DataType func_type = _reduce_function_call_type(op);
  6611. #ifdef DEBUG_ENABLED
  6612. if (func_type.has_type && (func_type.kind != DataType::BUILTIN || func_type.builtin_type != Variant::NIL)) {
  6613. // Figure out function name for warning
  6614. String func_name = _find_function_name(op);
  6615. if (func_name.empty()) {
  6616. func_name = "<undetected name>";
  6617. }
  6618. _add_warning(GDScriptWarning::RETURN_VALUE_DISCARDED, op->line, func_name);
  6619. }
  6620. #endif // DEBUG_ENABLED
  6621. if (error_set) return;
  6622. } break;
  6623. case OperatorNode::OP_YIELD: {
  6624. _mark_line_as_safe(op->line);
  6625. _reduce_node_type(op);
  6626. } break;
  6627. default: {
  6628. _mark_line_as_safe(op->line);
  6629. _reduce_node_type(op); // Test for safety anyway
  6630. #ifdef DEBUG_ENABLED
  6631. _add_warning(GDScriptWarning::STANDALONE_EXPRESSION, statement->line);
  6632. #endif // DEBUG_ENABLED
  6633. }
  6634. }
  6635. } break;
  6636. case Node::TYPE_CONTROL_FLOW: {
  6637. ControlFlowNode *cf = static_cast<ControlFlowNode *>(statement);
  6638. _mark_line_as_safe(cf->line);
  6639. switch (cf->cf_type) {
  6640. case ControlFlowNode::CF_RETURN: {
  6641. DataType function_type = current_function->get_datatype();
  6642. DataType ret_type;
  6643. if (cf->arguments.size() > 0) {
  6644. ret_type = _reduce_node_type(cf->arguments[0]);
  6645. if (error_set) {
  6646. return;
  6647. }
  6648. }
  6649. if (!function_type.has_type) break;
  6650. if (function_type.kind == DataType::BUILTIN && function_type.builtin_type == Variant::NIL) {
  6651. // Return void, should not have arguments
  6652. if (cf->arguments.size() > 0) {
  6653. _set_error("Void function cannot return a value.", cf->line, cf->column);
  6654. return;
  6655. }
  6656. } else {
  6657. // Return something, cannot be empty
  6658. if (cf->arguments.size() == 0) {
  6659. _set_error("Non-void function must return a value.", cf->line, cf->column);
  6660. return;
  6661. }
  6662. if (!_is_type_compatible(function_type, ret_type)) {
  6663. _set_error("Returned value type (" + ret_type.to_string() + ") doesn't match the function return type (" +
  6664. function_type.to_string() + ").",
  6665. cf->line, cf->column);
  6666. return;
  6667. }
  6668. }
  6669. } break;
  6670. case ControlFlowNode::CF_MATCH: {
  6671. MatchNode *match_node = cf->match;
  6672. _transform_match_statment(match_node);
  6673. } break;
  6674. default: {
  6675. if (cf->body_else) {
  6676. _mark_line_as_safe(cf->body_else->line);
  6677. }
  6678. for (int i = 0; i < cf->arguments.size(); i++) {
  6679. _reduce_node_type(cf->arguments[i]);
  6680. }
  6681. } break;
  6682. }
  6683. } break;
  6684. case Node::TYPE_CONSTANT: {
  6685. ConstantNode *cn = static_cast<ConstantNode *>(statement);
  6686. // Strings are fine since they can be multiline comments
  6687. if (cn->value.get_type() == Variant::STRING) {
  6688. break;
  6689. }
  6690. } // falthrough
  6691. default: {
  6692. _mark_line_as_safe(statement->line);
  6693. _reduce_node_type(statement); // Test for safety anyway
  6694. #ifdef DEBUG_ENABLED
  6695. _add_warning(GDScriptWarning::STANDALONE_EXPRESSION, statement->line);
  6696. #endif // DEBUG_ENABLED
  6697. }
  6698. }
  6699. }
  6700. // Parse sub blocks
  6701. for (int i = 0; i < p_block->sub_blocks.size(); i++) {
  6702. current_block = p_block->sub_blocks[i];
  6703. _check_block_types(current_block);
  6704. current_block = p_block;
  6705. if (error_set) return;
  6706. }
  6707. #ifdef DEBUG_ENABLED
  6708. // Warnings check
  6709. for (Map<StringName, LocalVarNode *>::Element *E = p_block->variables.front(); E; E = E->next()) {
  6710. LocalVarNode *lv = E->get();
  6711. if (!lv->name.operator String().begins_with("_")) {
  6712. if (lv->usages == 0) {
  6713. _add_warning(GDScriptWarning::UNUSED_VARIABLE, lv->line, lv->name);
  6714. } else if (lv->assignments == 0) {
  6715. _add_warning(GDScriptWarning::UNASSIGNED_VARIABLE, lv->line, lv->name);
  6716. }
  6717. }
  6718. }
  6719. #endif // DEBUG_ENABLED
  6720. }
  6721. void GDScriptParser::_set_error(const String &p_error, int p_line, int p_column) {
  6722. if (error_set)
  6723. return; //allow no further errors
  6724. error = p_error;
  6725. error_line = p_line < 0 ? tokenizer->get_token_line() : p_line;
  6726. error_column = p_column < 0 ? tokenizer->get_token_column() : p_column;
  6727. error_set = true;
  6728. }
  6729. #ifdef DEBUG_ENABLED
  6730. void GDScriptParser::_add_warning(int p_code, int p_line, const String &p_symbol1, const String &p_symbol2, const String &p_symbol3, const String &p_symbol4) {
  6731. Vector<String> symbols;
  6732. if (!p_symbol1.empty()) {
  6733. symbols.push_back(p_symbol1);
  6734. }
  6735. if (!p_symbol2.empty()) {
  6736. symbols.push_back(p_symbol2);
  6737. }
  6738. if (!p_symbol3.empty()) {
  6739. symbols.push_back(p_symbol3);
  6740. }
  6741. if (!p_symbol4.empty()) {
  6742. symbols.push_back(p_symbol4);
  6743. }
  6744. _add_warning(p_code, p_line, symbols);
  6745. }
  6746. void GDScriptParser::_add_warning(int p_code, int p_line, const Vector<String> &p_symbols) {
  6747. if (tokenizer->is_ignoring_warnings() || !GLOBAL_GET("debug/gdscript/warnings/enable").booleanize()) {
  6748. return;
  6749. }
  6750. String warn_name = GDScriptWarning::get_name_from_code((GDScriptWarning::Code)p_code).to_lower();
  6751. if (tokenizer->get_warning_global_skips().has(warn_name)) {
  6752. return;
  6753. }
  6754. if (!GLOBAL_GET("debug/gdscript/warnings/" + warn_name)) {
  6755. return;
  6756. }
  6757. GDScriptWarning warn;
  6758. warn.code = (GDScriptWarning::Code)p_code;
  6759. warn.symbols = p_symbols;
  6760. warn.line = p_line == -1 ? tokenizer->get_token_line() : p_line;
  6761. List<GDScriptWarning>::Element *before = NULL;
  6762. for (List<GDScriptWarning>::Element *E = warnings.front(); E; E = E->next()) {
  6763. if (E->get().line > warn.line) {
  6764. break;
  6765. }
  6766. before = E;
  6767. }
  6768. if (before) {
  6769. warnings.insert_after(before, warn);
  6770. } else {
  6771. warnings.push_front(warn);
  6772. }
  6773. }
  6774. #endif // DEBUG_ENABLED
  6775. String GDScriptParser::get_error() const {
  6776. return error;
  6777. }
  6778. int GDScriptParser::get_error_line() const {
  6779. return error_line;
  6780. }
  6781. int GDScriptParser::get_error_column() const {
  6782. return error_column;
  6783. }
  6784. Error GDScriptParser::_parse(const String &p_base_path) {
  6785. base_path = p_base_path;
  6786. //assume class
  6787. ClassNode *main_class = alloc_node<ClassNode>();
  6788. main_class->initializer = alloc_node<BlockNode>();
  6789. main_class->initializer->parent_class = main_class;
  6790. main_class->ready = alloc_node<BlockNode>();
  6791. main_class->ready->parent_class = main_class;
  6792. current_class = main_class;
  6793. _parse_class(main_class);
  6794. if (tokenizer->get_token() == GDScriptTokenizer::TK_ERROR) {
  6795. error_set = false;
  6796. _set_error("Parse Error: " + tokenizer->get_token_error());
  6797. }
  6798. if (error_set && !for_completion) {
  6799. return ERR_PARSE_ERROR;
  6800. }
  6801. _determine_inheritance(main_class);
  6802. if (error_set) {
  6803. return ERR_PARSE_ERROR;
  6804. }
  6805. current_class = main_class;
  6806. current_function = NULL;
  6807. current_block = NULL;
  6808. #ifdef DEBUG_ENABLED
  6809. if (for_completion) check_types = false;
  6810. #else
  6811. check_types = false;
  6812. #endif
  6813. // Resolve all class-level stuff before getting into function blocks
  6814. _check_class_level_types(main_class);
  6815. if (error_set) {
  6816. return ERR_PARSE_ERROR;
  6817. }
  6818. // Resolve the function blocks
  6819. _check_class_blocks_types(main_class);
  6820. if (error_set) {
  6821. return ERR_PARSE_ERROR;
  6822. }
  6823. #ifdef DEBUG_ENABLED
  6824. // Resolve warning ignores
  6825. Vector<Pair<int, String> > warning_skips = tokenizer->get_warning_skips();
  6826. bool warning_is_error = GLOBAL_GET("debug/gdscript/warnings/treat_warnings_as_errors").booleanize();
  6827. for (List<GDScriptWarning>::Element *E = warnings.front(); E;) {
  6828. GDScriptWarning &w = E->get();
  6829. int skip_index = -1;
  6830. for (int i = 0; i < warning_skips.size(); i++) {
  6831. if (warning_skips[i].first >= w.line) {
  6832. break;
  6833. }
  6834. skip_index = i;
  6835. }
  6836. List<GDScriptWarning>::Element *next = E->next();
  6837. bool erase = false;
  6838. if (skip_index != -1) {
  6839. if (warning_skips[skip_index].second == GDScriptWarning::get_name_from_code(w.code).to_lower()) {
  6840. erase = true;
  6841. }
  6842. warning_skips.remove(skip_index);
  6843. }
  6844. if (erase) {
  6845. warnings.erase(E);
  6846. } else if (warning_is_error) {
  6847. _set_error(w.get_message() + " (warning treated as error)", w.line);
  6848. return ERR_PARSE_ERROR;
  6849. }
  6850. E = next;
  6851. }
  6852. #endif // DEBUG_ENABLED
  6853. return OK;
  6854. }
  6855. Error GDScriptParser::parse_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_base_path, const String &p_self_path) {
  6856. clear();
  6857. self_path = p_self_path;
  6858. GDScriptTokenizerBuffer *tb = memnew(GDScriptTokenizerBuffer);
  6859. tb->set_code_buffer(p_bytecode);
  6860. tokenizer = tb;
  6861. Error ret = _parse(p_base_path);
  6862. memdelete(tb);
  6863. tokenizer = NULL;
  6864. return ret;
  6865. }
  6866. Error GDScriptParser::parse(const String &p_code, const String &p_base_path, bool p_just_validate, const String &p_self_path, bool p_for_completion, Set<int> *r_safe_lines) {
  6867. clear();
  6868. self_path = p_self_path;
  6869. GDScriptTokenizerText *tt = memnew(GDScriptTokenizerText);
  6870. tt->set_code(p_code);
  6871. validating = p_just_validate;
  6872. for_completion = p_for_completion;
  6873. #ifdef DEBUG_ENABLED
  6874. safe_lines = r_safe_lines;
  6875. #endif // DEBUG_ENABLED
  6876. tokenizer = tt;
  6877. Error ret = _parse(p_base_path);
  6878. memdelete(tt);
  6879. tokenizer = NULL;
  6880. return ret;
  6881. }
  6882. bool GDScriptParser::is_tool_script() const {
  6883. return (head && head->type == Node::TYPE_CLASS && static_cast<const ClassNode *>(head)->tool);
  6884. }
  6885. const GDScriptParser::Node *GDScriptParser::get_parse_tree() const {
  6886. return head;
  6887. }
  6888. void GDScriptParser::clear() {
  6889. while (list) {
  6890. Node *l = list;
  6891. list = list->next;
  6892. memdelete(l);
  6893. }
  6894. head = NULL;
  6895. list = NULL;
  6896. completion_type = COMPLETION_NONE;
  6897. completion_node = NULL;
  6898. completion_class = NULL;
  6899. completion_function = NULL;
  6900. completion_block = NULL;
  6901. current_block = NULL;
  6902. current_class = NULL;
  6903. completion_found = false;
  6904. rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
  6905. current_function = NULL;
  6906. validating = false;
  6907. for_completion = false;
  6908. error_set = false;
  6909. tab_level.clear();
  6910. tab_level.push_back(0);
  6911. error_line = 0;
  6912. error_column = 0;
  6913. pending_newline = -1;
  6914. parenthesis = 0;
  6915. current_export.type = Variant::NIL;
  6916. check_types = true;
  6917. error = "";
  6918. #ifdef DEBUG_ENABLED
  6919. safe_lines = NULL;
  6920. #endif // DEBUG_ENABLED
  6921. }
  6922. GDScriptParser::CompletionType GDScriptParser::get_completion_type() {
  6923. return completion_type;
  6924. }
  6925. StringName GDScriptParser::get_completion_cursor() {
  6926. return completion_cursor;
  6927. }
  6928. int GDScriptParser::get_completion_line() {
  6929. return completion_line;
  6930. }
  6931. Variant::Type GDScriptParser::get_completion_built_in_constant() {
  6932. return completion_built_in_constant;
  6933. }
  6934. GDScriptParser::Node *GDScriptParser::get_completion_node() {
  6935. return completion_node;
  6936. }
  6937. GDScriptParser::BlockNode *GDScriptParser::get_completion_block() {
  6938. return completion_block;
  6939. }
  6940. GDScriptParser::ClassNode *GDScriptParser::get_completion_class() {
  6941. return completion_class;
  6942. }
  6943. GDScriptParser::FunctionNode *GDScriptParser::get_completion_function() {
  6944. return completion_function;
  6945. }
  6946. int GDScriptParser::get_completion_argument_index() {
  6947. return completion_argument;
  6948. }
  6949. int GDScriptParser::get_completion_identifier_is_function() {
  6950. return completion_ident_is_call;
  6951. }
  6952. GDScriptParser::GDScriptParser() {
  6953. head = NULL;
  6954. list = NULL;
  6955. tokenizer = NULL;
  6956. pending_newline = -1;
  6957. clear();
  6958. }
  6959. GDScriptParser::~GDScriptParser() {
  6960. clear();
  6961. }