BfPrinter.cpp 76 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301
  1. #include "BfPrinter.h"
  2. #include "BfParser.h"
  3. #include "BfUtil.h"
  4. #include "BeefySysLib/util/UTF8.h"
  5. USING_NS_BF;
  6. // This is a really long line, I'm testing to see what's up. This is a really long line, I'm testing to see what's up. This is a really long line, I'm testing to see what's up.
  7. // This is a really long line, I'm testing to see what's up.
  8. BfPrinter::BfPrinter(BfRootNode *rootNode, BfRootNode *sidechannelRootNode, BfRootNode *errorRootNode)
  9. {
  10. mSource = rootNode->GetSourceData();
  11. mParser = mSource->ToParserData();
  12. if (sidechannelRootNode != NULL)
  13. mSidechannelItr = sidechannelRootNode->begin();
  14. mSidechannelNextNode = mSidechannelItr.Get();
  15. if (errorRootNode != NULL)
  16. mErrorItr = errorRootNode->begin();
  17. mErrorNextNode = mErrorItr.Get();
  18. mTriviaIdx = 0;
  19. mCurSrcIdx = 0;
  20. mCurIndentLevel = 0;
  21. mCurBlockState = NULL;
  22. mQueuedSpaceCount = 0;
  23. mLastSpaceOffset = 0;
  24. mReformatting = false;
  25. mDocPrep = false;
  26. mIgnoreTrivia = false;
  27. mForceUseTrivia = false;
  28. mIsFirstStatementInBlock = false;
  29. mFormatStart = -1;
  30. mFormatEnd = -1;
  31. mInSideChannel = false;
  32. mCharMapping = NULL;
  33. mExpectingNewLine = false;
  34. mCurBlockMember = NULL;
  35. mStateModifyVirtualIndentLevel = 0;
  36. mVirtualIndentLevel = 0;
  37. mVirtualNewLineIdx = 0;
  38. mHighestCharId = 0;
  39. mCurTypeDecl = NULL;
  40. mCurCol = 0;
  41. mMaxCol = 120;
  42. mTabSize = 4;
  43. mWantsTabsAsSpaces = false;
  44. mIndentCaseLabels = false;
  45. mFormatDisableCount = 0;
  46. }
  47. void BfPrinter::Write(const StringView& str)
  48. {
  49. if (str == '\n')
  50. mCurCol = 0;
  51. else if (mMaxCol > 0)
  52. {
  53. int startCol = mCurCol;
  54. for (int i = 0; i < (int)str.mLength; i++)
  55. {
  56. char c = str[i];
  57. if (c == '\t')
  58. mCurCol = ((mCurCol / mTabSize) + 1) * mTabSize;
  59. else
  60. mCurCol++;
  61. }
  62. }
  63. mOutString.Append(str);
  64. if (mCharMapping != NULL)
  65. {
  66. for (int i = 0; i < (int)str.length(); i++)
  67. {
  68. int prevSrcIdx = -1;
  69. if (mCharMapping->size() > 0)
  70. prevSrcIdx = mCharMapping->back();
  71. if (prevSrcIdx != -1)
  72. {
  73. bool matched = false;
  74. int curSrcIdx = prevSrcIdx + 1;
  75. // Search for char, skipping over whitespace
  76. while (curSrcIdx < mParser->mSrcLength)
  77. {
  78. char c = mParser->mSrc[curSrcIdx];
  79. if (c == str[i])
  80. {
  81. matched = true;
  82. break;
  83. }
  84. else if ((c == '\t') || (c == ' '))
  85. curSrcIdx++;
  86. else
  87. break;
  88. }
  89. if (matched)
  90. {
  91. // It matches the source character, extend...
  92. mCharMapping->push_back(curSrcIdx);
  93. }
  94. else
  95. {
  96. // New char
  97. mCharMapping->push_back(-1);
  98. }
  99. }
  100. else
  101. {
  102. mCharMapping->push_back(-1);
  103. }
  104. }
  105. }
  106. }
  107. void BfPrinter::FlushIndent()
  108. {
  109. while ((mQueuedSpaceCount >= mTabSize) && (!mWantsTabsAsSpaces))
  110. {
  111. Write("\t");
  112. mQueuedSpaceCount -= mTabSize;
  113. }
  114. while (mQueuedSpaceCount > 0)
  115. {
  116. Write(" ");
  117. mQueuedSpaceCount--;
  118. }
  119. }
  120. void BfPrinter::Write(BfAstNode* node, int start, int len)
  121. {
  122. FlushIndent();
  123. if (mMaxCol > 0)
  124. {
  125. int startCol = mCurCol;
  126. auto parserData = node->GetParserData();
  127. for (int i = 0; i < len; i++)
  128. {
  129. char c = parserData->mSrc[start + i];
  130. if (c == '\t')
  131. mCurCol = ((mCurCol / mTabSize) + 1) * mTabSize;
  132. else
  133. mCurCol++;
  134. }
  135. }
  136. mOutString.Append(node->GetSourceData()->mSrc + start, len);
  137. if (mCharMapping != NULL)
  138. {
  139. if (start < mParser->mSrcLength)
  140. {
  141. for (int i = 0; i < len; i++)
  142. {
  143. mCharMapping->push_back(start + i);
  144. }
  145. }
  146. else
  147. {
  148. for (int i = 0; i < len; i++)
  149. mCharMapping->push_back(-1);
  150. }
  151. }
  152. }
  153. void BfPrinter::WriteSourceString(BfAstNode* node)
  154. {
  155. Write(node, node->GetSrcStart(), node->GetSrcLength());
  156. }
  157. void BfPrinter::QueueVisitChild(BfAstNode* astNode)
  158. {
  159. if (astNode != NULL)
  160. {
  161. mNextStateModify.mQueuedNode = astNode;
  162. mChildNodeQueue.push_back(mNextStateModify);
  163. mNextStateModify.Clear();
  164. }
  165. }
  166. void BfPrinter::QueueVisitErrorNodes(BfRootNode* astNode)
  167. {
  168. for (auto& childNodeRef : *astNode)
  169. {
  170. BfAstNode* childNode = childNodeRef;
  171. if (childNode->IsA<BfErrorNode>())
  172. QueueVisitChild(childNode);
  173. }
  174. }
  175. static bool CompareNodeStart(const BfPrinter::StateModify& node1, const BfPrinter::StateModify& node2)
  176. {
  177. return node1.mQueuedNode->GetSrcStart() < node2.mQueuedNode->GetSrcStart();
  178. }
  179. void BfPrinter::FlushVisitChild()
  180. {
  181. if (mChildNodeQueue.size() == 0)
  182. return;
  183. auto nodeQueue = mChildNodeQueue;
  184. mChildNodeQueue.Clear();
  185. std::stable_sort(nodeQueue.begin(), nodeQueue.end(), CompareNodeStart);
  186. for (auto& node : nodeQueue)
  187. {
  188. mNextStateModify = node;
  189. VisitChild(node.mQueuedNode);
  190. if (mVirtualNewLineIdx == mNextStateModify.mWantNewLineIdx)
  191. mVirtualNewLineIdx = node.mWantNewLineIdx;
  192. }
  193. }
  194. void BfPrinter::VisitChildWithPrecedingSpace(BfAstNode* bfAstNode)
  195. {
  196. if (bfAstNode == NULL)
  197. return;
  198. ExpectSpace();
  199. VisitChild(bfAstNode);
  200. }
  201. void BfPrinter::VisitChildWithProceedingSpace(BfAstNode* bfAstNode)
  202. {
  203. if (bfAstNode == NULL)
  204. return;
  205. VisitChild(bfAstNode);
  206. ExpectSpace();
  207. }
  208. void BfPrinter::ExpectSpace()
  209. {
  210. mNextStateModify.mExpectingSpace = true;
  211. }
  212. void BfPrinter::ExpectNewLine()
  213. {
  214. mNextStateModify.mWantNewLineIdx++;
  215. }
  216. void BfPrinter::ExpectIndent()
  217. {
  218. mNextStateModify.mWantVirtualIndent++;
  219. ExpectNewLine();
  220. }
  221. void BfPrinter::ExpectUnindent()
  222. {
  223. mNextStateModify.mWantVirtualIndent--;
  224. ExpectNewLine();
  225. }
  226. void BfPrinter::VisitChildNextLine(BfAstNode* node)
  227. {
  228. if (node == NULL)
  229. return;
  230. if (node->IsA<BfBlock>())
  231. {
  232. VisitChild(node);
  233. }
  234. else
  235. {
  236. ExpectNewLine();
  237. ExpectIndent();
  238. VisitChild(node);
  239. ExpectUnindent();
  240. }
  241. }
  242. int BfPrinter::CalcOrigLineSpacing(BfAstNode* bfAstNode, int* lineStartIdx)
  243. {
  244. int origLineSpacing = 0;
  245. int checkIdx = bfAstNode->GetSrcStart() - 1;
  246. auto astNodeSrc = bfAstNode->GetSourceData();
  247. for ( ; checkIdx >= 0; checkIdx--)
  248. {
  249. char c = astNodeSrc->mSrc[checkIdx];
  250. if (c == '\n')
  251. break;
  252. if (c == '\t')
  253. origLineSpacing += mTabSize;
  254. else if (c == ' ')
  255. origLineSpacing += 1;
  256. else
  257. return -1;
  258. }
  259. if (lineStartIdx != NULL)
  260. *lineStartIdx = checkIdx + 1;
  261. return origLineSpacing;
  262. }
  263. void BfPrinter::WriteIgnoredNode(BfAstNode* node)
  264. {
  265. Update(node);
  266. if (!mReformatting)
  267. {
  268. int startIdx = BF_MAX(node->mTriviaStart, mTriviaIdx);
  269. Write(node, startIdx, node->mSrcEnd - startIdx);
  270. mTriviaIdx = node->mSrcEnd;
  271. return;
  272. }
  273. bool startsWithSpace = false;
  274. bool wasExpectingNewLine = mExpectingNewLine;
  275. mTriviaIdx = std::max(mTriviaIdx, node->GetTriviaStart());
  276. int endIdx = mTriviaIdx;
  277. int crCount = 0;
  278. auto astNodeSrc = node->GetSourceData();
  279. int srcEnd = node->GetSrcEnd();
  280. for (int i = mTriviaIdx; i < srcEnd; i++)
  281. {
  282. char c = astNodeSrc->mSrc[i];
  283. if ((i == mTriviaIdx) && (isspace((uint8)c)))
  284. startsWithSpace = true;
  285. if ((c == '\n') && (i < node->GetSrcStart()))
  286. crCount++;
  287. if (((c != ' ') && (c != '\t')) || (!mReformatting))
  288. endIdx = i + 1;
  289. }
  290. bool wantsPrefixSpace = (!mOutString.IsEmpty()) && (!isspace((uint8)mOutString[mOutString.mLength - 1]));
  291. bool expectingNewLine = mNextStateModify.mWantNewLineIdx != mVirtualNewLineIdx;
  292. int startIdx = mTriviaIdx;
  293. if ((expectingNewLine) && (mReformatting))
  294. {
  295. // Try to adjust the tabbing of this comment by the same amount that the previous line was adjusted
  296. int lineStart = -1;
  297. int origLineSpacing = CalcOrigLineSpacing(node, &lineStart);
  298. if ((origLineSpacing != -1) && (lineStart != -1))
  299. {
  300. for (int i = 0; i < crCount; i++)
  301. {
  302. Write("\n");
  303. wantsPrefixSpace = false;
  304. }
  305. startIdx = node->GetSrcStart();
  306. // Leave left-aligned preprocessor nodes
  307. if ((node->GetSourceData()->mSrc[node->GetSrcStart()] != '#') || (origLineSpacing > 0))
  308. mQueuedSpaceCount = origLineSpacing + mLastSpaceOffset;
  309. }
  310. }
  311. auto commentNode = BfNodeDynCast<BfCommentNode>(node);
  312. bool isBlockComment = false;
  313. bool isStarredBlockComment = false;
  314. if (commentNode != NULL)
  315. {
  316. if ((commentNode->mCommentKind == BfCommentKind_Block) ||
  317. (commentNode->mCommentKind == BfCommentKind_Documentation_Block_Pre) ||
  318. (commentNode->mCommentKind == BfCommentKind_Documentation_Block_Post))
  319. {
  320. isBlockComment = true;
  321. int lineCount = 0;
  322. bool onNewLine = false;
  323. for (int srcIdx = startIdx; srcIdx < endIdx; srcIdx++)
  324. {
  325. char checkC = astNodeSrc->mSrc[srcIdx];
  326. if (checkC == '\n')
  327. {
  328. onNewLine = true;
  329. lineCount++;
  330. if (lineCount >= 2)
  331. break;
  332. }
  333. else if ((checkC == '*') && (onNewLine))
  334. isStarredBlockComment = true;
  335. else if ((checkC != ' ') && (checkC != '\t'))
  336. onNewLine = false;
  337. }
  338. }
  339. }
  340. bool doWrap = (commentNode != NULL) && (mMaxCol > 0);
  341. bool prevHadWrap = false;
  342. if (commentNode != NULL)
  343. {
  344. Visit((BfAstNode*)node);
  345. startIdx = node->mSrcStart;
  346. if (doWrap)
  347. {
  348. bool wantWrap = false;
  349. int spacedWordCount = 0;
  350. bool inQuotes = false;
  351. auto src = astNodeSrc->mSrc;
  352. bool isDefinitelyCode = false;
  353. bool hadNonSlash = false;
  354. for (int i = node->mSrcStart + 1; i < node->mSrcEnd - 1; i++)
  355. {
  356. char c = src[i];
  357. if (c != '/')
  358. hadNonSlash = true;
  359. if (inQuotes)
  360. {
  361. if (c == '\\')
  362. {
  363. i++;
  364. }
  365. else if (c == '\"')
  366. {
  367. inQuotes = false;
  368. }
  369. }
  370. else if (c == '"')
  371. {
  372. inQuotes = true;
  373. }
  374. else if (c == ' ')
  375. {
  376. if ((isalpha((uint8)src[i - 1])) && (isalpha((uint8)src[i + 1])))
  377. spacedWordCount++;
  378. }
  379. else if ((c == '/') && (src[i - 1] == '/') && (hadNonSlash))
  380. isDefinitelyCode = true;
  381. }
  382. // If this doesn't look like a sentence then don't try to word wrap
  383. if ((isDefinitelyCode) || (spacedWordCount < 4))
  384. doWrap = false;
  385. }
  386. }
  387. int lineEmittedChars = 0;
  388. // This handles tab adjustment within multiline comments
  389. FlushIndent();
  390. bool isNewLine = false;
  391. for (int srcIdx = startIdx; srcIdx < endIdx; srcIdx++)
  392. {
  393. #ifdef A
  394. int zap = 999;
  395. #endif
  396. bool emitChar = true;
  397. char c = astNodeSrc->mSrc[srcIdx];
  398. if ((wantsPrefixSpace) && (isspace((uint8)c)))
  399. wantsPrefixSpace = false;
  400. if (c == '\n')
  401. {
  402. isNewLine = true;
  403. if (prevHadWrap)
  404. {
  405. bool merging = false;
  406. int blockContentStart = -1;
  407. bool foundStar = false;
  408. int startIdx = srcIdx;
  409. for (int checkIdx = srcIdx + 1; checkIdx < endIdx + 1; checkIdx++)
  410. {
  411. char checkC = astNodeSrc->mSrc[checkIdx];
  412. if (isBlockComment)
  413. {
  414. if (checkC == '\n')
  415. break;
  416. if ((isStarredBlockComment) && (!foundStar) && (checkC == '*'))
  417. {
  418. foundStar = true;
  419. continue;
  420. }
  421. if ((checkC != ' ') && (checkC != '\t'))
  422. {
  423. if (blockContentStart == -1)
  424. {
  425. blockContentStart = checkIdx;
  426. }
  427. // Only do merge if we have content on this line
  428. if (isalnum(checkC))
  429. {
  430. srcIdx = blockContentStart;
  431. merging = true;
  432. break;
  433. }
  434. }
  435. }
  436. else
  437. {
  438. if ((checkC == '/') && (astNodeSrc->mSrc[checkIdx + 1] == '/'))
  439. {
  440. srcIdx = checkIdx;
  441. while (srcIdx < endIdx)
  442. {
  443. char checkC = astNodeSrc->mSrc[srcIdx];
  444. if (checkC != '/')
  445. break;
  446. srcIdx++;
  447. }
  448. merging = true;
  449. break;
  450. }
  451. if ((checkC != ' ') && (checkC != '\t'))
  452. break;
  453. }
  454. }
  455. if (merging)
  456. {
  457. srcIdx--;
  458. while (srcIdx < endIdx - 1)
  459. {
  460. char checkC = astNodeSrc->mSrc[srcIdx + 1];
  461. if ((checkC != ' ') && (checkC != '\t'))
  462. break;
  463. srcIdx++;
  464. }
  465. Write(" ");
  466. continue;
  467. }
  468. }
  469. mCurCol = 0;
  470. prevHadWrap = false;
  471. }
  472. else if (isNewLine)
  473. {
  474. if (c == ' ')
  475. {
  476. mQueuedSpaceCount++;
  477. emitChar = false;
  478. }
  479. else if (c == '\t')
  480. {
  481. mQueuedSpaceCount += mTabSize;
  482. emitChar = false;
  483. }
  484. else
  485. {
  486. // Leave left-aligned preprocessor nodes that are commented out
  487. if ((c != '#') || (mQueuedSpaceCount > 0))
  488. mQueuedSpaceCount = std::max(0, mQueuedSpaceCount + mLastSpaceOffset);
  489. else
  490. mQueuedSpaceCount = mCurIndentLevel * mTabSize; // Do default indent
  491. isNewLine = false;
  492. }
  493. }
  494. if (emitChar)
  495. {
  496. int startIdx = srcIdx;
  497. if (c != '\n')
  498. {
  499. while (srcIdx < endIdx)
  500. {
  501. char c = astNodeSrc->mSrc[srcIdx + 1];
  502. if (isspace((uint8)c))
  503. break;
  504. srcIdx++;
  505. }
  506. }
  507. if (doWrap)
  508. {
  509. int len = 0;
  510. for (int idx = startIdx; idx <= srcIdx; idx++)
  511. {
  512. char c = astNodeSrc->mSrc[idx];
  513. if (isutf(c))
  514. len++;
  515. }
  516. if ((mCurCol + len > mMaxCol) && (lineEmittedChars >= 8))
  517. {
  518. Write("\n");
  519. mQueuedSpaceCount = mCurIndentLevel * mTabSize;
  520. FlushIndent();
  521. if (isStarredBlockComment)
  522. Write(" * ");
  523. else if (!isBlockComment)
  524. Write("// ");
  525. prevHadWrap = true;
  526. while (startIdx < endIdx)
  527. {
  528. char c = astNodeSrc->mSrc[startIdx];
  529. if (!isspace((uint8)c))
  530. break;
  531. startIdx++;
  532. }
  533. lineEmittedChars = 0;
  534. }
  535. }
  536. if (wantsPrefixSpace)
  537. {
  538. mQueuedSpaceCount++;
  539. wantsPrefixSpace = false;
  540. }
  541. FlushIndent();
  542. for (int idx = startIdx; idx <= BF_MIN(srcIdx, endIdx - 1); idx++)
  543. {
  544. char c = astNodeSrc->mSrc[idx];
  545. mOutString.Append(c);
  546. if (mCharMapping != NULL)
  547. {
  548. if (idx < mParser->mSrcLength)
  549. mCharMapping->push_back(idx);
  550. else
  551. mCharMapping->push_back(-1);
  552. }
  553. if (c == '\n')
  554. {
  555. mCurCol = 0;
  556. lineEmittedChars = 0;
  557. }
  558. else if (isutf(c))
  559. {
  560. mCurCol++;
  561. lineEmittedChars++;
  562. }
  563. }
  564. }
  565. }
  566. FlushIndent();
  567. mTriviaIdx = endIdx;
  568. mIsFirstStatementInBlock = false;
  569. mExpectingNewLine = wasExpectingNewLine;
  570. }
  571. void BfPrinter::CheckRawNode(BfAstNode* node)
  572. {
  573. if (node == NULL)
  574. return;
  575. if ((!BfNodeIsExact<BfTokenNode>(node)) &&
  576. (!BfNodeIsExact<BfIdentifierNode>(node)) &&
  577. (!BfNodeIsExact<BfLiteralExpression>(node)))
  578. return;
  579. //mForceUseTrivia = true;
  580. // Usually 'raw' nodes get merged into larger nodes like expressions/statements, but if they don't then this tries to help formatting
  581. mExpectingNewLine = false;
  582. mVirtualNewLineIdx = mNextStateModify.mWantNewLineIdx;
  583. mNextStateModify.mExpectingSpace = false;
  584. bool inLineStart = false;
  585. int spaceCount = 0;
  586. auto parserData = node->GetParserData();
  587. for (int i = node->mTriviaStart; i < node->mSrcStart; i++)
  588. {
  589. char c = parserData->mSrc[i];
  590. if (c == '\n')
  591. {
  592. ExpectNewLine();
  593. inLineStart = true;
  594. spaceCount = 0;
  595. }
  596. else if (c == '\t')
  597. {
  598. ExpectSpace();
  599. if (inLineStart)
  600. spaceCount += mTabSize;
  601. }
  602. else if (c == ' ')
  603. {
  604. ExpectSpace();
  605. if (inLineStart)
  606. spaceCount++;
  607. }
  608. else
  609. {
  610. inLineStart = false;
  611. }
  612. }
  613. if ((spaceCount > 0) && (mCurBlockState != NULL))
  614. {
  615. int indentCount = spaceCount / mTabSize;
  616. mNextStateModify.mWantVirtualIndent = BF_MAX(indentCount, mCurBlockState->mIndentStart + 1);
  617. }
  618. }
  619. void BfPrinter::Update(BfAstNode* bfAstNode)
  620. {
  621. // This won't be true if we move nodes around during refactoring
  622. if (bfAstNode->GetSrcStart() >= mCurSrcIdx)
  623. {
  624. mCurSrcIdx = bfAstNode->GetSrcStart();
  625. }
  626. if ((!mReformatting) && (mFormatDisableCount == 0) && (mFormatStart != -1) && (mCurSrcIdx >= mFormatStart) && ((mCurSrcIdx < mFormatEnd) || (mFormatEnd == -1)))
  627. {
  628. mReformatting = true;
  629. // We entered the format region, figure our what our current indent level is
  630. int backIdx = mCurSrcIdx - 1;
  631. int prevSpaceCount = 0;
  632. auto astNodeSrc = bfAstNode->GetSourceData();
  633. while (backIdx >= 0)
  634. {
  635. char c = astNodeSrc->mSrc[backIdx];
  636. if (c == ' ')
  637. prevSpaceCount++;
  638. else if (c == '\t')
  639. prevSpaceCount += mTabSize;
  640. else if (c == '\n')
  641. {
  642. // Found previous line
  643. mCurIndentLevel = prevSpaceCount / mTabSize;
  644. break;
  645. }
  646. else
  647. {
  648. prevSpaceCount = 0;
  649. }
  650. backIdx--;
  651. }
  652. }
  653. if (mFormatDisableCount != 0)
  654. mReformatting = false;
  655. if ((mCurSrcIdx >= mFormatEnd) && (mFormatEnd != -1))
  656. mReformatting = false;
  657. bool expectingNewLine = mNextStateModify.mWantNewLineIdx != mVirtualNewLineIdx;
  658. if (expectingNewLine)
  659. mExpectingNewLine = true;
  660. }
  661. void BfPrinter::Visit(BfAstNode* bfAstNode)
  662. {
  663. SetAndRestoreValue<bool> prevForceTrivia(mForceUseTrivia);
  664. bool newExpectingNewLine = mNextStateModify.mWantNewLineIdx != mVirtualNewLineIdx;
  665. if (newExpectingNewLine)
  666. mExpectingNewLine = true;
  667. bool expectingNewLine = mExpectingNewLine;
  668. int indentOffset = 0;
  669. if (bfAstNode->GetTriviaStart() != -1)
  670. {
  671. if (newExpectingNewLine)
  672. {
  673. indentOffset = mNextStateModify.mWantVirtualIndent - mVirtualIndentLevel;
  674. mVirtualIndentLevel += indentOffset;
  675. mCurIndentLevel += indentOffset;
  676. }
  677. }
  678. while (true)
  679. {
  680. int sidechannelDist = -1;
  681. if (mSidechannelNextNode != NULL)
  682. sidechannelDist = bfAstNode->GetSrcStart() - mSidechannelNextNode->GetSrcStart();
  683. int errorDist = -1;
  684. if (mErrorNextNode != NULL)
  685. errorDist = bfAstNode->GetSrcStart() - mErrorNextNode->GetSrcStart();
  686. if ((sidechannelDist > 0) && (sidechannelDist >= errorDist))
  687. {
  688. BF_ASSERT(!mInSideChannel);
  689. mInSideChannel = true;
  690. VisitChild(mSidechannelNextNode);
  691. mInSideChannel = false;
  692. ++mSidechannelItr;
  693. mSidechannelNextNode = mSidechannelItr.Get();
  694. }
  695. else if (errorDist > 0)
  696. {
  697. auto curErrorNode = mErrorNextNode;
  698. ++mErrorItr;
  699. mErrorNextNode = mErrorItr.Get();
  700. mForceUseTrivia = true;
  701. VisitChild(curErrorNode);
  702. }
  703. else
  704. break;
  705. }
  706. Update(bfAstNode);
  707. // When triviaStart == -1, that indicates it's a combined node where the text we want to process is on the inside
  708. if (bfAstNode->GetTriviaStart() != -1)
  709. {
  710. mTriviaIdx = std::max(mTriviaIdx, bfAstNode->GetTriviaStart());
  711. bool usedTrivia = false;
  712. if ((!mIgnoreTrivia) && (mTriviaIdx < bfAstNode->GetSrcStart()))
  713. {
  714. if ((!mReformatting) || (mForceUseTrivia))
  715. {
  716. Write(bfAstNode, mTriviaIdx, bfAstNode->GetSrcStart() - mTriviaIdx);
  717. usedTrivia = true;
  718. }
  719. }
  720. if ((mReformatting) && (!mInSideChannel))
  721. {
  722. // Check to see if our trivia contained a newline and duplicate whatever the
  723. // indent increase was from the previous line
  724. if ((!usedTrivia) && (mTriviaIdx < bfAstNode->GetSrcStart()) && (!mIsFirstStatementInBlock) && (!mNextStateModify.mDoingBlockOpen) && (!mNextStateModify.mDoingBlockClose))
  725. {
  726. bool hadNewline = true;
  727. bool hadPrevLineSpacing = false;
  728. int prevSpaceCount = -1;
  729. int spaceCount = 0;
  730. auto astNodeSrc = bfAstNode->GetSourceData();
  731. bool canUseTrivia = true;
  732. int spaceTriviaStart = -1;
  733. int triviaEnd = bfAstNode->GetSrcStart();
  734. for (int i = mTriviaIdx; i < triviaEnd; i++)
  735. {
  736. if (mIgnoreTrivia)
  737. break;
  738. char c = astNodeSrc->mSrc[i];
  739. if (c == ' ')
  740. {
  741. if (spaceTriviaStart == -1)
  742. spaceTriviaStart = i;
  743. spaceCount++;
  744. }
  745. else if (c == '\t')
  746. {
  747. if (spaceTriviaStart == -1)
  748. spaceTriviaStart = i;
  749. spaceCount += mTabSize;
  750. }
  751. if (((c == '\n') || (i == bfAstNode->GetSrcStart() - 1)) && (hadPrevLineSpacing) && (prevSpaceCount > 0))
  752. {
  753. mQueuedSpaceCount += std::max(0, spaceCount - prevSpaceCount) - std::max(0, indentOffset * mTabSize);
  754. prevSpaceCount = -1;
  755. hadPrevLineSpacing = false;
  756. }
  757. if (c == '\n')
  758. {
  759. canUseTrivia = false;
  760. hadNewline = true;
  761. int backIdx = i - 1;
  762. prevSpaceCount = 0;
  763. while (backIdx >= 0)
  764. {
  765. char c = astNodeSrc->mSrc[backIdx];
  766. if (c == ' ')
  767. prevSpaceCount++;
  768. else if (c == '\t')
  769. prevSpaceCount += mTabSize;
  770. if ((c == '\n') || (backIdx == 0))
  771. {
  772. // Found previous line
  773. usedTrivia = true;
  774. Write("\n");
  775. mQueuedSpaceCount = mCurIndentLevel * mTabSize;
  776. // Indents extra if we have a statement split over multiple lines
  777. if (!expectingNewLine)
  778. mQueuedSpaceCount += mTabSize;
  779. break;
  780. }
  781. else
  782. {
  783. hadPrevLineSpacing = true;
  784. prevSpaceCount = 0;
  785. }
  786. backIdx--;
  787. }
  788. spaceCount = 0;
  789. spaceTriviaStart = -1;
  790. }
  791. else if (!isspace((uint8)c))
  792. {
  793. spaceCount = 0;
  794. spaceTriviaStart = -1;
  795. }
  796. }
  797. if ((canUseTrivia) && (spaceCount > 1) && (spaceTriviaStart != -1))
  798. {
  799. Write(bfAstNode, spaceTriviaStart, triviaEnd - spaceTriviaStart);
  800. mNextStateModify.mExpectingSpace = false;
  801. usedTrivia = true;
  802. }
  803. }
  804. if (usedTrivia)
  805. {
  806. // Already did whitespace
  807. mNextStateModify.mExpectingSpace = false;
  808. }
  809. else if ((mNextStateModify.mDoingBlockOpen) || (mNextStateModify.mDoingBlockClose) || (mIsFirstStatementInBlock))
  810. {
  811. int wasOnNewLine = true;
  812. int idx = (int)mOutString.length() - 1;
  813. while (idx >= 0)
  814. {
  815. char c = mOutString[idx];
  816. if (c == '\n')
  817. break;
  818. if (!isspace((uint8)c))
  819. {
  820. Write("\n");
  821. mQueuedSpaceCount = mCurIndentLevel * mTabSize;
  822. if (!mNextStateModify.mDoingBlockClose)
  823. {
  824. int origLineSpacing = CalcOrigLineSpacing(bfAstNode, NULL);
  825. if (origLineSpacing != -1)
  826. mLastSpaceOffset = mQueuedSpaceCount - origLineSpacing;
  827. }
  828. break;
  829. }
  830. idx--;
  831. }
  832. }
  833. else if ((mNextStateModify.mExpectingSpace) || (newExpectingNewLine))
  834. {
  835. FlushIndent();
  836. char startChar = bfAstNode->GetSourceData()->mSrc[bfAstNode->GetSrcStart()];
  837. bool isEnding = (startChar == ';') || (startChar == ')');
  838. if ((!isEnding) && (mOutString.length() > 0) && (!isspace((uint8)mOutString[mOutString.length() - 1])))
  839. Write(" ");
  840. }
  841. }
  842. if (!mInSideChannel)
  843. {
  844. if (mNextStateModify.mDoingBlockOpen)
  845. mIsFirstStatementInBlock = true;
  846. else
  847. mIsFirstStatementInBlock = false;
  848. mNextStateModify.mExpectingSpace = false;
  849. mNextStateModify.mDoingBlockOpen = false;
  850. mNextStateModify.mDoingBlockClose = false;
  851. mNextStateModify.Clear();
  852. mVirtualNewLineIdx = mNextStateModify.mWantNewLineIdx;
  853. }
  854. mForceUseTrivia = false;
  855. if (bfAstNode->GetSrcStart() >= mTriviaIdx)
  856. mTriviaIdx = bfAstNode->GetSrcStart();
  857. // We either used this mExpectingNewLine to do an extra indent for a statement split over multiple lines or we didn't
  858. mExpectingNewLine = false;
  859. }
  860. }
  861. bool BfPrinter::CheckReplace(BfAstNode* astNode)
  862. {
  863. return false;
  864. }
  865. void BfPrinter::Visit(BfErrorNode* errorNode)
  866. {
  867. SetAndRestoreValue<bool> prevForceUseTrivia(mForceUseTrivia, true);
  868. SetAndRestoreValue<bool> prevFormatting(mReformatting, false);
  869. SetAndRestoreValue<int> prevFormatEndIdx(mFormatEnd, 0);
  870. VisitChild(errorNode->mRefNode);
  871. }
  872. void BfPrinter::Visit(BfScopeNode* scopeNode)
  873. {
  874. Visit(scopeNode->ToBase());
  875. VisitChild(scopeNode->mScopeToken);
  876. VisitChild(scopeNode->mColonToken);
  877. VisitChild(scopeNode->mTargetNode);
  878. if (scopeNode->mAttributes != NULL)
  879. {
  880. ExpectSpace();
  881. VisitChild(scopeNode->mAttributes);
  882. }
  883. }
  884. void BfPrinter::Visit(BfNewNode* newNode)
  885. {
  886. Visit(newNode->ToBase());
  887. VisitChild(newNode->mNewToken);
  888. VisitChild(newNode->mColonToken);
  889. VisitChild(newNode->mAllocNode);
  890. if (newNode->mAttributes != NULL)
  891. {
  892. ExpectSpace();
  893. VisitChild(newNode->mAttributes);
  894. }
  895. }
  896. void BfPrinter::Visit(BfExpression* expr)
  897. {
  898. Visit(expr->ToBase());
  899. }
  900. void BfPrinter::Visit(BfExpressionStatement* exprStmt)
  901. {
  902. //Visit((BfAstNode*)exprStmt);
  903. Visit(exprStmt->ToBase());
  904. VisitChild(exprStmt->mExpression);
  905. VisitChild(exprStmt->mTrailingSemicolon);
  906. }
  907. void BfPrinter::Visit(BfNamedExpression* namedExpr)
  908. {
  909. Visit(namedExpr->ToBase());
  910. VisitChild(namedExpr->mNameNode);
  911. VisitChild(namedExpr->mColonToken);
  912. ExpectSpace();
  913. VisitChild(namedExpr->mExpression);
  914. }
  915. void BfPrinter::Visit(BfAttributedExpression* attribExpr)
  916. {
  917. Visit(attribExpr->ToBase());
  918. if (auto indexerExpr = BfNodeDynCast<BfIndexerExpression>(attribExpr->mExpression))
  919. {
  920. VisitChild(indexerExpr->mTarget);
  921. VisitChild(indexerExpr->mOpenBracket);
  922. VisitChild(attribExpr->mAttributes);
  923. for (int i = 0; i < (int)indexerExpr->mArguments.size(); i++)
  924. {
  925. if (i > 0)
  926. {
  927. VisitChildNoRef(indexerExpr->mCommas.GetSafe(i - 1));
  928. ExpectSpace();
  929. }
  930. VisitChild(indexerExpr->mArguments[i]);
  931. }
  932. VisitChild(indexerExpr->mCloseBracket);
  933. }
  934. else
  935. {
  936. VisitChild(attribExpr->mAttributes);
  937. VisitChild(attribExpr->mExpression);
  938. }
  939. }
  940. void BfPrinter::Visit(BfStatement* stmt)
  941. {
  942. // Trailing semicolon must come after, so every derived type is responsible for printing it
  943. #ifdef BF_AST_HAS_PARENT_MEMBER
  944. // if (stmt->mParent != NULL)
  945. // {
  946. // if (auto block = BfNodeDynCast<BfBlock>(stmt->mParent))
  947. // {
  948. // if (block->mOpenBrace != NULL)
  949. // {
  950. // if (mReformatting)
  951. // BF_ASSERT(stmt == mCurBlockMember);
  952. // }
  953. // }
  954. // }
  955. #endif
  956. if (stmt == mCurBlockMember)
  957. ExpectNewLine();
  958. //Visit(stmt->ToBase());
  959. }
  960. void BfPrinter::Visit(BfLabelableStatement* labelableStmt)
  961. {
  962. Visit(labelableStmt->ToBase());
  963. if (labelableStmt->mLabelNode != NULL)
  964. {
  965. ExpectNewLine();
  966. VisitChild(labelableStmt->mLabelNode->mLabel);
  967. VisitChild(labelableStmt->mLabelNode->mColonToken);
  968. }
  969. }
  970. void BfPrinter::Visit(BfCommentNode* commentNode)
  971. {
  972. WriteIgnoredNode(commentNode);
  973. if (commentNode->mCommentKind == BfCommentKind_Line)
  974. ExpectNewLine();
  975. }
  976. void BfPrinter::Visit(BfPreprocesorIgnoredSectionNode* preprocesorIgnoredSection)
  977. {
  978. WriteIgnoredNode(preprocesorIgnoredSection);
  979. ExpectNewLine();
  980. }
  981. void BfPrinter::Visit(BfPreprocessorNode* preprocessorNode)
  982. {
  983. WriteIgnoredNode(preprocessorNode);
  984. if ((preprocessorNode->mCommand->ToStringView() == "pragma") &&
  985. (preprocessorNode->mArgument != NULL) &&
  986. (preprocessorNode->mArgument->mChildArr.mSize == 2) &&
  987. (preprocessorNode->mArgument->mChildArr[0] != NULL) &&
  988. (preprocessorNode->mArgument->mChildArr[0]->ToStringView() == "format") &&
  989. (preprocessorNode->mArgument->mChildArr[1] != NULL))
  990. {
  991. if (preprocessorNode->mArgument->mChildArr[1]->ToStringView() == "disable")
  992. mFormatDisableCount++;
  993. else if (preprocessorNode->mArgument->mChildArr[1]->ToStringView() == "restore")
  994. mFormatDisableCount = BF_MAX(0, mFormatDisableCount - 1);
  995. }
  996. ExpectNewLine();
  997. }
  998. void BfPrinter::Visit(BfAttributeDirective* attributeDirective)
  999. {
  1000. Visit(attributeDirective->ToBase());
  1001. if (attributeDirective->mAttrOpenToken != NULL)
  1002. {
  1003. if (attributeDirective->mAttrOpenToken->mToken == BfToken_Comma)
  1004. {
  1005. VisitChild(attributeDirective->mAttrOpenToken);
  1006. ExpectSpace();
  1007. }
  1008. else
  1009. {
  1010. SetAndRestoreValue<bool> prevExpectNewLine(mExpectingNewLine, true);
  1011. VisitChild(attributeDirective->mAttrOpenToken);
  1012. }
  1013. }
  1014. if (attributeDirective->mAttributeTargetSpecifier != NULL)
  1015. {
  1016. if (auto attributeTargetSpecifier = BfNodeDynCast<BfAttributeTargetSpecifier>(attributeDirective->mAttributeTargetSpecifier))
  1017. {
  1018. VisitChild(attributeTargetSpecifier->mTargetToken);
  1019. VisitChild(attributeTargetSpecifier->mColonToken);
  1020. ExpectSpace();
  1021. }
  1022. else
  1023. {
  1024. VisitChild(attributeDirective->mAttributeTargetSpecifier);
  1025. }
  1026. }
  1027. VisitChild(attributeDirective->mAttributeTypeRef);
  1028. VisitChild(attributeDirective->mCtorOpenParen);
  1029. for (int i = 0; i < (int)attributeDirective->mArguments.size(); i++)
  1030. {
  1031. if (i > 0)
  1032. {
  1033. VisitChildNoRef(attributeDirective->mCommas.GetSafe(i - 1));
  1034. ExpectSpace();
  1035. }
  1036. VisitChild(attributeDirective->mArguments[i]);
  1037. }
  1038. VisitChild(attributeDirective->mCtorCloseParen);
  1039. VisitChild(attributeDirective->mAttrCloseToken);
  1040. if ((attributeDirective->mNextAttribute != NULL) && (attributeDirective->mNextAttribute->mAttrOpenToken != NULL) &&
  1041. (attributeDirective->mNextAttribute->mAttrOpenToken->mToken == BfToken_LBracket))
  1042. ExpectNewLine();
  1043. VisitChild(attributeDirective->mNextAttribute);
  1044. }
  1045. void BfPrinter::Visit(BfGenericParamsDeclaration* genericParams)
  1046. {
  1047. Visit(genericParams->ToBase());
  1048. VisitChild(genericParams->mOpenChevron);
  1049. for (int i = 0; i < (int)genericParams->mGenericParams.size(); i++)
  1050. {
  1051. if (i > 0)
  1052. {
  1053. VisitChildNoRef(genericParams->mCommas.GetSafe(i - 1));
  1054. ExpectSpace();
  1055. }
  1056. VisitChild(genericParams->mGenericParams[i]);
  1057. }
  1058. VisitChild(genericParams->mCloseChevron);
  1059. }
  1060. void BfPrinter::Visit(BfGenericOperatorConstraint* genericConstraints)
  1061. {
  1062. Visit(genericConstraints->ToBase());
  1063. VisitChild(genericConstraints->mOperatorToken);
  1064. ExpectSpace();
  1065. VisitChild(genericConstraints->mLeftType);
  1066. ExpectSpace();
  1067. VisitChild(genericConstraints->mOpToken);
  1068. ExpectSpace();
  1069. VisitChild(genericConstraints->mRightType);
  1070. }
  1071. void BfPrinter::Visit(BfGenericConstraintsDeclaration* genericConstraints)
  1072. {
  1073. Visit(genericConstraints->ToBase());
  1074. for (auto genericConstraintNode : genericConstraints->mGenericConstraints)
  1075. {
  1076. auto genericConstraint = BfNodeDynCast<BfGenericConstraint>(genericConstraintNode);
  1077. ExpectSpace();
  1078. VisitChild(genericConstraint->mWhereToken);
  1079. ExpectSpace();
  1080. VisitChild(genericConstraint->mTypeRef);
  1081. ExpectSpace();
  1082. VisitChild(genericConstraint->mColonToken);
  1083. ExpectSpace();
  1084. for (int i = 0; i < (int)genericConstraint->mConstraintTypes.size(); i++)
  1085. {
  1086. if (i > 0)
  1087. {
  1088. if (!genericConstraint->mCommas.IsEmpty())
  1089. VisitChildNoRef(genericConstraint->mCommas.GetSafe(i - 1));
  1090. ExpectSpace();
  1091. }
  1092. VisitChild(genericConstraint->mConstraintTypes[i]);
  1093. }
  1094. }
  1095. }
  1096. void BfPrinter::Visit(BfGenericArgumentsNode* genericArgumentsNode)
  1097. {
  1098. Visit(genericArgumentsNode->ToBase());
  1099. VisitChild(genericArgumentsNode->mOpenChevron);
  1100. for (int i = 0; i < (int)genericArgumentsNode->mGenericArgs.size(); i++)
  1101. {
  1102. if (i > 0)
  1103. {
  1104. VisitChildNoRef(genericArgumentsNode->mCommas.GetSafe(i - 1));
  1105. ExpectSpace();
  1106. }
  1107. VisitChild(genericArgumentsNode->mGenericArgs[i]);
  1108. }
  1109. for (int i = (int)genericArgumentsNode->mGenericArgs.size() - 1; i < (int)genericArgumentsNode->mCommas.size(); i++)
  1110. VisitChildNoRef(genericArgumentsNode->mCommas.GetSafe(i));
  1111. VisitChild(genericArgumentsNode->mCloseChevron);
  1112. }
  1113. void BfPrinter::Visit(BfEmptyStatement* emptyStmt)
  1114. {
  1115. Visit(emptyStmt->ToBase());
  1116. VisitChild(emptyStmt->mTrailingSemicolon);
  1117. }
  1118. void BfPrinter::Visit(BfTokenNode* tokenNode)
  1119. {
  1120. Visit(tokenNode->ToBase());
  1121. if (mDocPrep)
  1122. {
  1123. if (tokenNode->mToken == BfToken_Mut)
  1124. return;
  1125. }
  1126. if (tokenNode->GetSrcEnd() == 0)
  1127. {
  1128. String tokenStr = BfTokenToString(tokenNode->GetToken());
  1129. Write(tokenStr);
  1130. }
  1131. else
  1132. {
  1133. BF_ASSERT(tokenNode->GetSrcEnd() > tokenNode->GetSrcStart());
  1134. WriteSourceString(tokenNode);
  1135. }
  1136. }
  1137. void BfPrinter::Visit(BfTokenPairNode* tokenPairNode)
  1138. {
  1139. Visit(tokenPairNode->ToBase());
  1140. VisitChild(tokenPairNode->mLeft);
  1141. if ((tokenPairNode->mRight != NULL) && (tokenPairNode->mRight->mToken != BfToken_Star))
  1142. ExpectSpace();
  1143. VisitChild(tokenPairNode->mRight);
  1144. }
  1145. void BfPrinter::Visit(BfUsingSpecifierNode* usingSpecifier)
  1146. {
  1147. Visit(usingSpecifier->ToBase());
  1148. VisitChild(usingSpecifier->mProtection);
  1149. ExpectSpace();
  1150. VisitChild(usingSpecifier->mUsingToken);
  1151. }
  1152. void BfPrinter::Visit(BfLiteralExpression* literalExpr)
  1153. {
  1154. Visit(literalExpr->ToBase());
  1155. if (literalExpr->mValue.mTypeCode == BfTypeCode_CharPtr)
  1156. {
  1157. bool isMultiLine = false;
  1158. auto sourceData = literalExpr->GetSourceData();
  1159. for (int i = literalExpr->GetSrcStart(); i < (int)literalExpr->GetSrcEnd(); i++)
  1160. {
  1161. char c = sourceData->mSrc[i];
  1162. if (c == '\n')
  1163. {
  1164. isMultiLine = true;
  1165. break;
  1166. }
  1167. }
  1168. if (isMultiLine)
  1169. {
  1170. int srcLineStart = 0;
  1171. bool startsOnEmptyLine = true;
  1172. int checkIdx = literalExpr->GetSrcStart() - 1;
  1173. while (checkIdx >= 0)
  1174. {
  1175. char c = sourceData->mSrc[checkIdx];
  1176. if (c == '\n')
  1177. {
  1178. srcLineStart = checkIdx + 1;
  1179. break;
  1180. }
  1181. if ((c != '\t') && (c != ' '))
  1182. startsOnEmptyLine = false;
  1183. checkIdx--;
  1184. }
  1185. int queuedSpaceCount = mQueuedSpaceCount;
  1186. FlushIndent();
  1187. if (!startsOnEmptyLine)
  1188. {
  1189. queuedSpaceCount = mCurIndentLevel * mTabSize;
  1190. }
  1191. for (int i = literalExpr->GetSrcStart(); i < (int)literalExpr->GetSrcEnd(); i++)
  1192. {
  1193. char c = sourceData->mSrc[i];
  1194. Write(c);
  1195. if (c == '\n')
  1196. {
  1197. i++;
  1198. int srcIdx = srcLineStart;
  1199. while (true)
  1200. {
  1201. char srcC = sourceData->mSrc[srcIdx++];
  1202. char litC = sourceData->mSrc[i];
  1203. if (srcC != litC)
  1204. break;
  1205. if ((srcC != ' ') && (srcC != '\t'))
  1206. break;
  1207. i++;
  1208. }
  1209. mQueuedSpaceCount = queuedSpaceCount;
  1210. FlushIndent();
  1211. i--;
  1212. }
  1213. }
  1214. // if (!startsOnEmptyLine)
  1215. // mCurIndentLevel--;
  1216. return;
  1217. }
  1218. }
  1219. WriteSourceString(literalExpr);
  1220. }
  1221. void BfPrinter::Visit(BfStringInterpolationExpression* stringInterpolationExpression)
  1222. {
  1223. Visit(stringInterpolationExpression->ToBase());
  1224. String str;
  1225. stringInterpolationExpression->ToString(str);
  1226. Write(str);
  1227. }
  1228. void BfPrinter::Visit(BfIdentifierNode* identifierNode)
  1229. {
  1230. Visit(identifierNode->ToBase());
  1231. if (!CheckReplace(identifierNode))
  1232. {
  1233. if (!mOutString.IsEmpty())
  1234. {
  1235. char endC = mOutString[mOutString.mLength - 1];
  1236. if ((endC == '_') || (isalnum((uint8)endC)))
  1237. {
  1238. // Can fix spacing in error conditions
  1239. if (identifierNode->mTriviaStart >= 0)
  1240. Write(identifierNode, identifierNode->mTriviaStart, identifierNode->mSrcStart - identifierNode->mTriviaStart);
  1241. }
  1242. }
  1243. WriteSourceString(identifierNode);
  1244. }
  1245. }
  1246. void BfPrinter::Visit(BfQualifiedNameNode* nameNode)
  1247. {
  1248. Visit((BfAstNode*)nameNode);
  1249. VisitChild(nameNode->mLeft);
  1250. VisitChild(nameNode->mDot);
  1251. VisitChild(nameNode->mRight);
  1252. }
  1253. void BfPrinter::Visit(BfThisExpression* thisExpr)
  1254. {
  1255. Visit((BfAstNode*)thisExpr);
  1256. WriteSourceString(thisExpr);
  1257. }
  1258. void BfPrinter::Visit(BfBaseExpression* baseExpr)
  1259. {
  1260. Visit((BfAstNode*)baseExpr);
  1261. WriteSourceString(baseExpr);
  1262. }
  1263. void BfPrinter::Visit(BfMixinExpression* mixinExpr)
  1264. {
  1265. Visit((BfAstNode*)mixinExpr);
  1266. WriteSourceString(mixinExpr);
  1267. }
  1268. void BfPrinter::Visit(BfSizedArrayCreateExpression* createExpr)
  1269. {
  1270. Visit(createExpr->ToBase());
  1271. VisitChild(createExpr->mTypeRef);
  1272. VisitChildWithPrecedingSpace(createExpr->mInitializer);
  1273. }
  1274. void BfPrinter::Visit(BfInitializerExpression* initExpr)
  1275. {
  1276. Visit(initExpr->ToBase());
  1277. VisitChild(initExpr->mTarget);
  1278. BlockState blockState;
  1279. DoBlockOpen(initExpr->mTarget, initExpr->mOpenBrace, initExpr->mCloseBrace, false, blockState);
  1280. for (int i = 0; i < (int)initExpr->mValues.size(); i++)
  1281. {
  1282. if (i > 0)
  1283. {
  1284. VisitChildNoRef(initExpr->mCommas.GetSafe(i - 1));
  1285. if (blockState.mDoInlineBlock)
  1286. ExpectSpace();
  1287. else
  1288. ExpectNewLine();
  1289. }
  1290. VisitChild(initExpr->mValues[i]);
  1291. }
  1292. DoBlockClose(initExpr->mTarget, initExpr->mOpenBrace, initExpr->mCloseBrace, false, blockState);
  1293. // Visit(initExpr->ToBase());
  1294. //
  1295. // VisitChild(initExpr->mTarget);
  1296. // ExpectSpace();
  1297. // VisitChild(initExpr->mOpenBrace);
  1298. // ExpectIndent();
  1299. // for (int i = 0; i < (int)initExpr->mValues.size(); i++)
  1300. // {
  1301. // if (i > 0)
  1302. // {
  1303. // VisitChildNoRef(initExpr->mCommas.GetSafe(i - 1));
  1304. // ExpectSpace();
  1305. // }
  1306. // VisitChild(initExpr->mValues[i]);
  1307. // }
  1308. // ExpectUnindent();
  1309. // VisitChild(initExpr->mCloseBrace);
  1310. }
  1311. void BfPrinter::Visit(BfCollectionInitializerExpression* initExpr)
  1312. {
  1313. Visit(initExpr->ToBase());
  1314. VisitChild(initExpr->mOpenBrace);
  1315. for (int i = 0; i < (int)initExpr->mValues.size(); i++)
  1316. {
  1317. if (i > 0)
  1318. {
  1319. VisitChildNoRef(initExpr->mCommas.GetSafe(i - 1));
  1320. ExpectSpace();
  1321. }
  1322. VisitChild(initExpr->mValues[i]);
  1323. }
  1324. VisitChild(initExpr->mCloseBrace);
  1325. }
  1326. void BfPrinter::Visit(BfTypeReference* typeRef)
  1327. {
  1328. Visit(typeRef->ToBase());
  1329. }
  1330. void BfPrinter::Visit(BfNamedTypeReference* typeRef)
  1331. {
  1332. Visit((BfAstNode*) typeRef);
  1333. VisitChild(typeRef->mNameNode);
  1334. }
  1335. void BfPrinter::Visit(BfQualifiedTypeReference* qualifiedTypeRef)
  1336. {
  1337. Visit(qualifiedTypeRef->ToBase());
  1338. VisitChild(qualifiedTypeRef->mLeft);
  1339. VisitChild(qualifiedTypeRef->mDot);
  1340. VisitChild(qualifiedTypeRef->mRight);
  1341. }
  1342. void BfPrinter::Visit(BfVarTypeReference* typeRef)
  1343. {
  1344. Visit(typeRef->ToBase());
  1345. VisitChild(typeRef->mVarToken);
  1346. }
  1347. void BfPrinter::Visit(BfLetTypeReference* typeRef)
  1348. {
  1349. Visit(typeRef->ToBase());
  1350. VisitChild(typeRef->mLetToken);
  1351. }
  1352. void BfPrinter::Visit(BfConstTypeRef* typeRef)
  1353. {
  1354. Visit(typeRef->ToBase());
  1355. VisitChild(typeRef->mConstToken);
  1356. ExpectSpace();
  1357. VisitChild(typeRef->mElementType);
  1358. }
  1359. void BfPrinter::Visit(BfConstExprTypeRef* typeRef)
  1360. {
  1361. Visit(typeRef->ToBase());
  1362. if (typeRef->mConstToken != NULL)
  1363. {
  1364. VisitChild(typeRef->mConstToken);
  1365. ExpectSpace();
  1366. }
  1367. VisitChild(typeRef->mConstExpr);
  1368. }
  1369. void BfPrinter::Visit(BfRefTypeRef* typeRef)
  1370. {
  1371. Visit(typeRef->ToBase());
  1372. VisitChild(typeRef->mRefToken);
  1373. ExpectSpace();
  1374. VisitChild(typeRef->mElementType);
  1375. }
  1376. void BfPrinter::Visit(BfArrayTypeRef* arrayTypeRef)
  1377. {
  1378. Visit((BfAstNode*)arrayTypeRef);
  1379. std::function<void(BfTypeReference*)> _VisitElements = [&](BfTypeReference* elementRef)
  1380. {
  1381. auto arrType = BfNodeDynCast<BfArrayTypeRef>(elementRef);
  1382. if (arrType != NULL)
  1383. {
  1384. _VisitElements(arrType->mElementType);
  1385. }
  1386. else
  1387. {
  1388. VisitChild(elementRef);
  1389. }
  1390. };
  1391. std::function<void(BfArrayTypeRef*)> _VisitBrackets = [&](BfArrayTypeRef* arrayTypeRef)
  1392. {
  1393. VisitChild(arrayTypeRef->mOpenBracket);
  1394. for (int paramIdx = 0; paramIdx < (int)arrayTypeRef->mParams.size(); paramIdx++)
  1395. {
  1396. auto param = arrayTypeRef->mParams[paramIdx];
  1397. if (paramIdx > 0)
  1398. {
  1399. if (auto tokenNode = BfNodeDynCast<BfTokenNode>(param))
  1400. {
  1401. }
  1402. else
  1403. {
  1404. ExpectSpace();
  1405. }
  1406. }
  1407. VisitChild(param);
  1408. }
  1409. VisitChild(arrayTypeRef->mCloseBracket);
  1410. if (auto innerArrayType = BfNodeDynCast<BfArrayTypeRef>(arrayTypeRef->mElementType))
  1411. _VisitBrackets(innerArrayType);
  1412. };
  1413. _VisitElements(arrayTypeRef);
  1414. _VisitBrackets(arrayTypeRef);
  1415. }
  1416. void BfPrinter::Visit(BfGenericInstanceTypeRef* genericInstTypeRef)
  1417. {
  1418. Visit((BfAstNode*) genericInstTypeRef);
  1419. VisitChild(genericInstTypeRef->mElementType);
  1420. VisitChild(genericInstTypeRef->mOpenChevron);
  1421. if (genericInstTypeRef->mGenericArguments.size() > 0)
  1422. {
  1423. for (int i = 0; i < (int)genericInstTypeRef->mGenericArguments.size(); i++)
  1424. {
  1425. if (i > 0)
  1426. {
  1427. VisitChildNoRef(genericInstTypeRef->mCommas.GetSafe(i - 1));
  1428. ExpectSpace();
  1429. }
  1430. VisitChild(genericInstTypeRef->mGenericArguments[i]);
  1431. }
  1432. }
  1433. else
  1434. {
  1435. for (auto comma : genericInstTypeRef->mCommas)
  1436. VisitChild(comma);
  1437. }
  1438. VisitChild(genericInstTypeRef->mCloseChevron);
  1439. }
  1440. void BfPrinter::Visit(BfTupleTypeRef* typeRef)
  1441. {
  1442. Visit((BfAstNode*) typeRef);
  1443. VisitChild(typeRef->mOpenParen);
  1444. for (int i = 0; i < (int)typeRef->mFieldTypes.size(); i++)
  1445. {
  1446. if (i > 0)
  1447. {
  1448. VisitChildNoRef(typeRef->mCommas.GetSafe(i - 1));
  1449. ExpectSpace();
  1450. }
  1451. VisitChild(typeRef->mFieldTypes[i]);
  1452. if (i < (int)typeRef->mFieldNames.size())
  1453. {
  1454. ExpectSpace();
  1455. auto fieldNameNode = typeRef->mFieldNames[i];
  1456. if (fieldNameNode != NULL)
  1457. VisitChild(fieldNameNode);
  1458. }
  1459. }
  1460. VisitChild(typeRef->mCloseParen);
  1461. }
  1462. void BfPrinter::Visit(BfTagTypeRef* typeRef)
  1463. {
  1464. Visit((BfAstNode*)typeRef);
  1465. VisitChild(typeRef->mTagNode);
  1466. ExpectSpace();
  1467. VisitChild(typeRef->mNameNode);
  1468. }
  1469. void BfPrinter::Visit(BfDelegateTypeRef* typeRef)
  1470. {
  1471. Visit((BfAstNode*)typeRef);
  1472. VisitChild(typeRef->mTypeToken);
  1473. ExpectSpace();
  1474. VisitChild(typeRef->mAttributes);
  1475. ExpectSpace();
  1476. VisitChild(typeRef->mReturnType);
  1477. VisitChild(typeRef->mOpenParen);
  1478. for (int i = 0; i < (int)typeRef->mParams.size(); i++)
  1479. {
  1480. if (i > 0)
  1481. {
  1482. VisitChildNoRef(typeRef->mCommas.GetSafe(i - 1));
  1483. ExpectSpace();
  1484. }
  1485. VisitChild(typeRef->mParams[i]);
  1486. }
  1487. VisitChild(typeRef->mCloseParen);
  1488. }
  1489. void BfPrinter::Visit(BfPointerTypeRef* ptrType)
  1490. {
  1491. Visit((BfAstNode*)ptrType);
  1492. VisitChild(ptrType->mElementType);
  1493. VisitChild(ptrType->mStarNode);
  1494. }
  1495. void BfPrinter::Visit(BfNullableTypeRef* ptrType)
  1496. {
  1497. Visit((BfAstNode*) ptrType);
  1498. VisitChild(ptrType->mElementType);
  1499. VisitChild(ptrType->mQuestionToken);
  1500. }
  1501. void BfPrinter::Visit(BfVariableDeclaration* varDecl)
  1502. {
  1503. //Visit(varDecl->ToBase());
  1504. VisitChild(varDecl->mAttributes);
  1505. VisitChildWithProceedingSpace(varDecl->mModSpecifier);
  1506. if (varDecl->mPrecedingComma != NULL)
  1507. {
  1508. mNextStateModify.mWantNewLineIdx--;
  1509. VisitChild(varDecl->mPrecedingComma);
  1510. }
  1511. else if (varDecl->mTypeRef != NULL)
  1512. {
  1513. if (varDecl->mTypeRef->mSrcStart >= varDecl->mSrcStart)
  1514. {
  1515. VisitChild(varDecl->mTypeRef);
  1516. }
  1517. else
  1518. {
  1519. // May be from a `for (int k = 1, m = 0; k <= 20; k++)`
  1520. }
  1521. }
  1522. VisitChildWithPrecedingSpace(varDecl->mNameNode);
  1523. VisitChildWithPrecedingSpace(varDecl->mEqualsNode);
  1524. if (varDecl->mInitializer != NULL)
  1525. {
  1526. if (varDecl->mNameNode != NULL)
  1527. ExpectSpace();
  1528. VisitChild(varDecl->mInitializer);
  1529. }
  1530. }
  1531. void BfPrinter::Visit(BfParameterDeclaration* paramDecl)
  1532. {
  1533. if (paramDecl->mModToken != NULL)
  1534. {
  1535. VisitChild(paramDecl->mModToken);
  1536. ExpectSpace();
  1537. }
  1538. Visit(paramDecl->ToBase());
  1539. }
  1540. void BfPrinter::Visit(BfTypeOfExpression* typeOfExpr)
  1541. {
  1542. Visit(typeOfExpr->ToBase());
  1543. VisitChild(typeOfExpr->mToken);
  1544. VisitChild(typeOfExpr->mOpenParen);
  1545. VisitChild(typeOfExpr->mTypeRef);
  1546. VisitChild(typeOfExpr->mCloseParen);
  1547. }
  1548. void BfPrinter::Visit(BfSizeOfExpression* sizeOfExpr)
  1549. {
  1550. Visit(sizeOfExpr->ToBase());
  1551. VisitChild(sizeOfExpr->mToken);
  1552. VisitChild(sizeOfExpr->mOpenParen);
  1553. VisitChild(sizeOfExpr->mTypeRef);
  1554. VisitChild(sizeOfExpr->mCloseParen);
  1555. }
  1556. void BfPrinter::Visit(BfOffsetOfExpression* offsetOfExpr)
  1557. {
  1558. VisitChild(offsetOfExpr->mToken);
  1559. VisitChild(offsetOfExpr->mOpenParen);
  1560. VisitChild(offsetOfExpr->mTypeRef);
  1561. VisitChild(offsetOfExpr->mCommaToken);
  1562. ExpectSpace();
  1563. VisitChild(offsetOfExpr->mMemberName);
  1564. VisitChild(offsetOfExpr->mCloseParen);
  1565. }
  1566. void BfPrinter::Visit(BfDefaultExpression* defaultExpr)
  1567. {
  1568. Visit(defaultExpr->ToBase());
  1569. VisitChild(defaultExpr->mDefaultToken);
  1570. VisitChild(defaultExpr->mOpenParen);
  1571. VisitChild(defaultExpr->mTypeRef);
  1572. VisitChild(defaultExpr->mCloseParen);
  1573. }
  1574. void BfPrinter::Visit(BfIsConstExpression* isConstExpr)
  1575. {
  1576. Visit(isConstExpr->ToBase());
  1577. VisitChild(isConstExpr->mIsConstToken);
  1578. VisitChild(isConstExpr->mOpenParen);
  1579. VisitChild(isConstExpr->mExpression);
  1580. VisitChild(isConstExpr->mCloseParen);
  1581. }
  1582. void BfPrinter::Visit(BfCheckTypeExpression* checkTypeExpr)
  1583. {
  1584. Visit(checkTypeExpr->ToBase());
  1585. VisitChild(checkTypeExpr->mTarget);
  1586. ExpectSpace();
  1587. VisitChild(checkTypeExpr->mIsToken);
  1588. ExpectSpace();
  1589. VisitChild(checkTypeExpr->mTypeRef);
  1590. }
  1591. void BfPrinter::Visit(BfDynamicCastExpression* dynCastExpr)
  1592. {
  1593. Visit(dynCastExpr->ToBase());
  1594. VisitChild(dynCastExpr->mTarget);
  1595. ExpectSpace();
  1596. VisitChild(dynCastExpr->mAsToken);
  1597. ExpectSpace();
  1598. VisitChild(dynCastExpr->mTypeRef);
  1599. }
  1600. void BfPrinter::Visit(BfCastExpression* castExpr)
  1601. {
  1602. Visit((BfAstNode*)castExpr);
  1603. VisitChild(castExpr->mOpenParen);
  1604. VisitChild(castExpr->mTypeRef);
  1605. VisitChild(castExpr->mCloseParen);
  1606. bool surroundWithParen = false;
  1607. if (surroundWithParen)
  1608. Write("(");
  1609. VisitChild(castExpr->mExpression);
  1610. if (surroundWithParen)
  1611. Write(")");
  1612. }
  1613. void BfPrinter::Visit(BfDelegateBindExpression* bindExpr)
  1614. {
  1615. Visit(bindExpr->ToBase());
  1616. VisitChild(bindExpr->mNewToken);
  1617. ExpectSpace();
  1618. VisitChild(bindExpr->mFatArrowToken);
  1619. ExpectSpace();
  1620. VisitChild(bindExpr->mTarget);
  1621. VisitChild(bindExpr->mGenericArgs);
  1622. }
  1623. void BfPrinter::Visit(BfLambdaBindExpression* lambdaBindExpr)
  1624. {
  1625. Visit(lambdaBindExpr->ToBase());
  1626. if (lambdaBindExpr->mNewToken != NULL)
  1627. {
  1628. VisitChild(lambdaBindExpr->mNewToken);
  1629. ExpectSpace();
  1630. }
  1631. VisitChild(lambdaBindExpr->mOpenParen);
  1632. for (int i = 0; i < (int)lambdaBindExpr->mParams.size(); i++)
  1633. {
  1634. if (i > 0)
  1635. {
  1636. VisitChildNoRef(lambdaBindExpr->mCommas.GetSafe(i - 1));
  1637. ExpectSpace();
  1638. }
  1639. VisitChild(lambdaBindExpr->mParams[i]);
  1640. }
  1641. VisitChild(lambdaBindExpr->mCloseParen);
  1642. ExpectSpace();
  1643. VisitChild(lambdaBindExpr->mFatArrowToken);
  1644. if (lambdaBindExpr->mBody != NULL)
  1645. {
  1646. if (lambdaBindExpr->mBody->IsA<BfBlock>())
  1647. {
  1648. ExpectNewLine();
  1649. ExpectIndent();
  1650. VisitChild(lambdaBindExpr->mBody);
  1651. ExpectUnindent();
  1652. }
  1653. else
  1654. {
  1655. ExpectSpace();
  1656. VisitChild(lambdaBindExpr->mBody);
  1657. }
  1658. }
  1659. VisitChild(lambdaBindExpr->mDtor);
  1660. mNextStateModify.mExpectingSpace = false;
  1661. mVirtualNewLineIdx = mNextStateModify.mWantNewLineIdx;
  1662. mCurIndentLevel = mNextStateModify.mWantVirtualIndent;
  1663. mVirtualIndentLevel = mNextStateModify.mWantVirtualIndent;
  1664. }
  1665. void BfPrinter::Visit(BfObjectCreateExpression* newExpr)
  1666. {
  1667. Visit(newExpr->ToBase());
  1668. VisitChild(newExpr->mNewNode);
  1669. ExpectSpace();
  1670. VisitChild(newExpr->mTypeRef);
  1671. VisitChild(newExpr->mCtorExplicit);
  1672. if (newExpr->mStarToken != NULL)
  1673. {
  1674. VisitChild(newExpr->mStarToken);
  1675. ExpectSpace();
  1676. }
  1677. auto _WriteToken = [&](BfAstNode* node, BfToken token)
  1678. {
  1679. if (node == NULL)
  1680. return;
  1681. Visit((BfAstNode*)node);
  1682. Write(node, node->GetSrcStart(), 0);
  1683. Write(BfTokenToString(token));
  1684. };
  1685. _WriteToken(newExpr->mOpenToken, BfToken_LParen);
  1686. for (int i = 0; i < (int)newExpr->mArguments.size(); i++)
  1687. {
  1688. if (i > 0)
  1689. {
  1690. VisitChildNoRef(newExpr->mCommas.GetSafe(i - 1));
  1691. ExpectSpace();
  1692. }
  1693. VisitChild(newExpr->mArguments[i]);
  1694. }
  1695. _WriteToken(newExpr->mCloseToken, BfToken_RParen);
  1696. }
  1697. void BfPrinter::Visit(BfBoxExpression* boxExpr)
  1698. {
  1699. Visit(boxExpr->ToBase());
  1700. VisitChild(boxExpr->mAllocNode);
  1701. ExpectSpace();
  1702. VisitChild(boxExpr->mBoxToken);
  1703. ExpectSpace();
  1704. VisitChild(boxExpr->mExpression);
  1705. }
  1706. void BfPrinter::Visit(BfThrowStatement* throwStmt)
  1707. {
  1708. Visit(throwStmt->ToBase());
  1709. VisitChild(throwStmt->mThrowToken);
  1710. ExpectSpace();
  1711. VisitChild(throwStmt->mExpression);
  1712. VisitChild(throwStmt->mTrailingSemicolon);
  1713. }
  1714. void BfPrinter::Visit(BfDeleteStatement* deleteStmt)
  1715. {
  1716. Visit(deleteStmt->ToBase());
  1717. VisitChild(deleteStmt->mDeleteToken);
  1718. VisitChild(deleteStmt->mTargetTypeToken);
  1719. VisitChild(deleteStmt->mAllocExpr);
  1720. ExpectSpace();
  1721. VisitChild(deleteStmt->mExpression);
  1722. VisitChild(deleteStmt->mTrailingSemicolon);
  1723. }
  1724. void BfPrinter::Visit(BfInvocationExpression* invocationExpr)
  1725. {
  1726. Visit(invocationExpr->ToBase());
  1727. VisitChild(invocationExpr->mTarget);
  1728. VisitChild(invocationExpr->mGenericArgs);
  1729. VisitChild(invocationExpr->mOpenParen);
  1730. for (int i = 0; i < (int) invocationExpr->mArguments.size(); i++)
  1731. {
  1732. if (i > 0)
  1733. {
  1734. VisitChildNoRef(invocationExpr->mCommas.GetSafe(i - 1));
  1735. ExpectSpace();
  1736. }
  1737. VisitChild(invocationExpr->mArguments[i]);
  1738. }
  1739. VisitChild(invocationExpr->mCloseParen);
  1740. }
  1741. void BfPrinter::Visit(BfDeferStatement* deferStmt)
  1742. {
  1743. Visit(deferStmt->ToBase());
  1744. VisitChild(deferStmt->mDeferToken);
  1745. VisitChild(deferStmt->mColonToken);
  1746. VisitChild(deferStmt->mScopeName);
  1747. if (deferStmt->mBind != NULL)
  1748. {
  1749. auto bind = deferStmt->mBind;
  1750. VisitChild(bind->mOpenBracket);
  1751. for (int i = 0; i < bind->mParams.size(); i++)
  1752. {
  1753. if (i > 0)
  1754. {
  1755. VisitChildNoRef(bind->mCommas.GetSafe(i - 1));
  1756. ExpectSpace();
  1757. }
  1758. VisitChild(bind->mParams[i]);
  1759. }
  1760. VisitChild(bind->mCloseBracket);
  1761. }
  1762. VisitChild(deferStmt->mOpenParen);
  1763. VisitChild(deferStmt->mScopeToken);
  1764. VisitChild(deferStmt->mCloseParen);
  1765. ExpectSpace();
  1766. VisitChild(deferStmt->mTargetNode);
  1767. VisitChild(deferStmt->mTrailingSemicolon);
  1768. }
  1769. void BfPrinter::Visit(BfEnumCaseBindExpression* caseBindExpr)
  1770. {
  1771. Visit(caseBindExpr->ToBase());
  1772. VisitChild(caseBindExpr->mBindToken);
  1773. VisitChild(caseBindExpr->mEnumMemberExpr);
  1774. VisitChild(caseBindExpr->mBindNames);
  1775. }
  1776. void BfPrinter::Visit(BfCaseExpression* caseExpr)
  1777. {
  1778. Visit(caseExpr->ToBase());
  1779. if ((caseExpr->mValueExpression == NULL) || (caseExpr->mCaseToken->GetSrcStart() < caseExpr->mValueExpression->GetSrcStart()))
  1780. {
  1781. // Old version
  1782. VisitChild(caseExpr->mCaseToken);
  1783. ExpectSpace();
  1784. VisitChild(caseExpr->mCaseExpression);
  1785. ExpectSpace();
  1786. VisitChild(caseExpr->mEqualsNode);
  1787. ExpectSpace();
  1788. VisitChild(caseExpr->mValueExpression);
  1789. }
  1790. else
  1791. {
  1792. VisitChild(caseExpr->mValueExpression);
  1793. ExpectSpace();
  1794. VisitChild(caseExpr->mNotToken);
  1795. ExpectSpace();
  1796. VisitChild(caseExpr->mCaseToken);
  1797. BF_ASSERT(caseExpr->mEqualsNode == NULL);
  1798. ExpectSpace();
  1799. VisitChild(caseExpr->mCaseExpression);
  1800. }
  1801. }
  1802. void BfPrinter::Visit(BfSwitchCase* switchCase)
  1803. {
  1804. if (mIndentCaseLabels)
  1805. ExpectIndent();
  1806. VisitChild(switchCase->mCaseToken);
  1807. for (int caseIdx = 0; caseIdx < (int) switchCase->mCaseExpressions.size(); caseIdx++)
  1808. {
  1809. if ((caseIdx == 0) || (caseIdx > (int)switchCase->mCaseCommas.size()))
  1810. ExpectSpace();
  1811. else
  1812. VisitChildNoRef(switchCase->mCaseCommas.GetSafe(caseIdx - 1));
  1813. VisitChild(switchCase->mCaseExpressions[caseIdx]);
  1814. }
  1815. VisitChild(switchCase->mColonToken);
  1816. ExpectNewLine();
  1817. ExpectIndent();
  1818. VisitChild(switchCase->mCodeBlock);
  1819. ExpectUnindent();
  1820. if (switchCase->mEndingToken != NULL)
  1821. {
  1822. ExpectNewLine();
  1823. VisitChild(switchCase->mEndingToken);
  1824. VisitChild(switchCase->mEndingSemicolonToken);
  1825. ExpectNewLine();
  1826. }
  1827. if (mIndentCaseLabels)
  1828. ExpectUnindent();
  1829. }
  1830. void BfPrinter::Visit(BfWhenExpression* whenExpr)
  1831. {
  1832. VisitChild(whenExpr->mWhenToken);
  1833. ExpectSpace();
  1834. VisitChild(whenExpr->mExpression);
  1835. }
  1836. void BfPrinter::Visit(BfSwitchStatement* switchStmt)
  1837. {
  1838. Visit(switchStmt->ToBase());
  1839. VisitChild(switchStmt->mSwitchToken);
  1840. ExpectSpace();
  1841. VisitChild(switchStmt->mOpenParen);
  1842. VisitChild(switchStmt->mSwitchValue);
  1843. VisitChild(switchStmt->mCloseParen);
  1844. ExpectNewLine();
  1845. VisitChild(switchStmt->mOpenBrace);
  1846. ExpectNewLine();
  1847. for (auto switchCase : switchStmt->mSwitchCases)
  1848. Visit(switchCase);
  1849. if (switchStmt->mDefaultCase != NULL)
  1850. Visit(switchStmt->mDefaultCase);
  1851. ExpectNewLine();
  1852. VisitChild(switchStmt->mCloseBrace);
  1853. VisitChild(switchStmt->mTrailingSemicolon);
  1854. }
  1855. void BfPrinter::Visit(BfTryStatement* tryStmt)
  1856. {
  1857. Visit(tryStmt->ToBase());
  1858. VisitChild(tryStmt->mTryToken);
  1859. VisitChild(tryStmt->mStatement);
  1860. }
  1861. void BfPrinter::Visit(BfCatchStatement* catchStmt)
  1862. {
  1863. Visit(catchStmt->ToBase());
  1864. WriteSourceString(catchStmt);
  1865. VisitChild(catchStmt->mTrailingSemicolon);
  1866. }
  1867. void BfPrinter::Visit(BfFinallyStatement* finallyStmt)
  1868. {
  1869. Visit(finallyStmt->ToBase());
  1870. VisitChild(finallyStmt->mFinallyToken);
  1871. VisitChild(finallyStmt->mStatement);
  1872. }
  1873. void BfPrinter::Visit(BfCheckedStatement* checkedStmt)
  1874. {
  1875. Visit(checkedStmt->ToBase());
  1876. VisitChild(checkedStmt->mCheckedToken);
  1877. VisitChild(checkedStmt->mStatement);
  1878. }
  1879. void BfPrinter::Visit(BfUncheckedStatement* uncheckedStmt)
  1880. {
  1881. Visit(uncheckedStmt->ToBase());
  1882. VisitChild(uncheckedStmt->mUncheckedToken);
  1883. VisitChild(uncheckedStmt->mStatement);
  1884. }
  1885. void BfPrinter::Visit(BfIfStatement* ifStmt)
  1886. {
  1887. Visit(ifStmt->ToBase());
  1888. VisitChild(ifStmt->mIfToken);
  1889. ExpectSpace();
  1890. VisitChild(ifStmt->mOpenParen);
  1891. VisitChild(ifStmt->mCondition);
  1892. VisitChild(ifStmt->mCloseParen);
  1893. ExpectSpace();
  1894. VisitChildNextLine(ifStmt->mTrueStatement);
  1895. VisitChild(ifStmt->mElseToken);
  1896. if (ifStmt->mFalseStatement != NULL)
  1897. {
  1898. ExpectSpace();
  1899. if (ifStmt->mFalseStatement->IsA<BfIfStatement>())
  1900. VisitChild(ifStmt->mFalseStatement);
  1901. else
  1902. VisitChildNextLine(ifStmt->mFalseStatement);
  1903. }
  1904. VisitChild(ifStmt->mTrailingSemicolon);
  1905. }
  1906. void BfPrinter::Visit(BfReturnStatement* returnStmt)
  1907. {
  1908. Visit(returnStmt->ToBase());
  1909. VisitChild(returnStmt->mReturnToken);
  1910. if (returnStmt->mExpression != NULL)
  1911. {
  1912. ExpectSpace();
  1913. VisitChild(returnStmt->mExpression);
  1914. }
  1915. VisitChild(returnStmt->mTrailingSemicolon);
  1916. }
  1917. void BfPrinter::Visit(BfUsingStatement* doStmt)
  1918. {
  1919. Visit(doStmt->ToBase());
  1920. VisitChild(doStmt->mUsingToken);
  1921. ExpectSpace();
  1922. VisitChild(doStmt->mOpenParen);
  1923. VisitChild(doStmt->mVariableDeclaration);
  1924. VisitChild(doStmt->mCloseParen);
  1925. VisitChildNextLine(doStmt->mEmbeddedStatement);
  1926. VisitChild(doStmt->mTrailingSemicolon);
  1927. }
  1928. void BfPrinter::Visit(BfDoStatement* doStmt)
  1929. {
  1930. Visit(doStmt->ToBase());
  1931. VisitChild(doStmt->mDoToken);
  1932. VisitChildNextLine(doStmt->mEmbeddedStatement);
  1933. }
  1934. void BfPrinter::Visit(BfRepeatStatement* repeatStmt)
  1935. {
  1936. Visit(repeatStmt->ToBase());
  1937. VisitChild(repeatStmt->mRepeatToken);
  1938. VisitChildNextLine(repeatStmt->mEmbeddedStatement);
  1939. VisitChild(repeatStmt->mWhileToken);
  1940. ExpectSpace();
  1941. VisitChild(repeatStmt->mOpenParen);
  1942. VisitChild(repeatStmt->mCondition);
  1943. VisitChild(repeatStmt->mCloseParen);
  1944. VisitChild(repeatStmt->mTrailingSemicolon);
  1945. }
  1946. void BfPrinter::Visit(BfWhileStatement* whileStmt)
  1947. {
  1948. Visit(whileStmt->ToBase());
  1949. VisitChild(whileStmt->mWhileToken);
  1950. ExpectSpace();
  1951. VisitChild(whileStmt->mOpenParen);
  1952. VisitChild(whileStmt->mCondition);
  1953. VisitChild(whileStmt->mCloseParen);
  1954. VisitChildNextLine(whileStmt->mEmbeddedStatement);
  1955. VisitChild(whileStmt->mTrailingSemicolon);
  1956. }
  1957. void BfPrinter::Visit(BfBreakStatement* breakStmt)
  1958. {
  1959. Visit(breakStmt->ToBase());
  1960. VisitChild(breakStmt->mBreakNode);
  1961. if (breakStmt->mLabel != NULL)
  1962. {
  1963. ExpectSpace();
  1964. VisitChild(breakStmt->mLabel);
  1965. }
  1966. VisitChild(breakStmt->mTrailingSemicolon);
  1967. }
  1968. void BfPrinter::Visit(BfContinueStatement* continueStmt)
  1969. {
  1970. Visit(continueStmt->ToBase());
  1971. VisitChild(continueStmt->mContinueNode);
  1972. if (continueStmt->mLabel != NULL)
  1973. {
  1974. ExpectSpace();
  1975. VisitChild(continueStmt->mLabel);
  1976. }
  1977. VisitChild(continueStmt->mTrailingSemicolon);
  1978. }
  1979. void BfPrinter::Visit(BfFallthroughStatement* fallthroughStmt)
  1980. {
  1981. Visit(fallthroughStmt->ToBase());
  1982. VisitChild(fallthroughStmt->mFallthroughToken);
  1983. if (fallthroughStmt->mLabel != NULL)
  1984. {
  1985. ExpectSpace();
  1986. VisitChild(fallthroughStmt->mLabel);
  1987. }
  1988. VisitChild(fallthroughStmt->mTrailingSemicolon);
  1989. }
  1990. void BfPrinter::Visit(BfForStatement* forStmt)
  1991. {
  1992. Visit(forStmt->ToBase());
  1993. VisitChild(forStmt->mForToken);
  1994. ExpectSpace();
  1995. VisitChild(forStmt->mOpenParen);
  1996. for (int i = 0; i < (int) forStmt->mInitializers.size(); i++)
  1997. {
  1998. if (i > 0)
  1999. VisitChildNoRef(forStmt->mInitializerCommas.GetSafe(i - 1));
  2000. VisitChild(forStmt->mInitializers[i]);
  2001. }
  2002. VisitChild(forStmt->mInitializerSemicolon);
  2003. ExpectSpace();
  2004. VisitChild(forStmt->mCondition);
  2005. VisitChild(forStmt->mConditionSemicolon);
  2006. ExpectSpace();
  2007. for (int i = 0; i < (int) forStmt->mIterators.size(); i++)
  2008. {
  2009. if (i > 0)
  2010. VisitChildNoRef(forStmt->mIteratorCommas.GetSafe(i - 1));
  2011. VisitChild(forStmt->mIterators[i]);
  2012. }
  2013. VisitChild(forStmt->mCloseParen);
  2014. VisitChildNextLine(forStmt->mEmbeddedStatement);
  2015. }
  2016. void BfPrinter::Visit(BfForEachStatement* forEachStmt)
  2017. {
  2018. Visit(forEachStmt->ToBase());
  2019. VisitChild(forEachStmt->mForToken);
  2020. ExpectSpace();
  2021. VisitChild(forEachStmt->mOpenParen);
  2022. if (forEachStmt->mReadOnlyToken != NULL)
  2023. {
  2024. VisitChild(forEachStmt->mReadOnlyToken);
  2025. ExpectSpace();
  2026. }
  2027. VisitChild(forEachStmt->mVariableTypeRef);
  2028. ExpectSpace();
  2029. VisitChild(forEachStmt->mVariableName);
  2030. ExpectSpace();
  2031. VisitChild(forEachStmt->mInToken);
  2032. ExpectSpace();
  2033. VisitChild(forEachStmt->mCollectionExpression);
  2034. VisitChild(forEachStmt->mCloseParen);
  2035. ExpectNewLine();
  2036. VisitChildNextLine(forEachStmt->mEmbeddedStatement);
  2037. VisitChild(forEachStmt->mTrailingSemicolon);
  2038. }
  2039. void BfPrinter::Visit(BfConditionalExpression* condExpr)
  2040. {
  2041. Visit(condExpr->ToBase());
  2042. VisitChild(condExpr->mConditionExpression);
  2043. ExpectSpace();
  2044. VisitChild(condExpr->mQuestionToken);
  2045. ExpectSpace();
  2046. VisitChild(condExpr->mTrueExpression);
  2047. ExpectSpace();
  2048. VisitChild(condExpr->mColonToken);
  2049. ExpectSpace();
  2050. VisitChild(condExpr->mFalseExpression);
  2051. }
  2052. void BfPrinter::Visit(BfAssignmentExpression* assignExpr)
  2053. {
  2054. Visit(assignExpr->ToBase());
  2055. VisitChild(assignExpr->mLeft);
  2056. ExpectSpace();
  2057. VisitChild(assignExpr->mOpToken);
  2058. ExpectSpace();
  2059. VisitChild(assignExpr->mRight);
  2060. }
  2061. void BfPrinter::Visit(BfParenthesizedExpression* parenExpr)
  2062. {
  2063. Visit(parenExpr->ToBase());
  2064. VisitChild(parenExpr->mOpenParen);
  2065. VisitChild(parenExpr->mExpression);
  2066. VisitChild(parenExpr->mCloseParen);
  2067. }
  2068. void BfPrinter::Visit(BfTupleExpression* tupleExpr)
  2069. {
  2070. Visit(tupleExpr->ToBase());
  2071. VisitChild(tupleExpr->mOpenParen);
  2072. for (int i = 0; i < (int)tupleExpr->mValues.size(); i++)
  2073. {
  2074. if (i > 0)
  2075. {
  2076. VisitChildNoRef(tupleExpr->mCommas.GetSafe(i - 1));
  2077. ExpectSpace();
  2078. }
  2079. if (i < (int)tupleExpr->mNames.size())
  2080. {
  2081. auto nameNode = tupleExpr->mNames[i];
  2082. if (nameNode != NULL)
  2083. {
  2084. VisitChild(nameNode->mNameNode);
  2085. VisitChild(nameNode->mColonToken);
  2086. ExpectSpace();
  2087. }
  2088. }
  2089. VisitChild(tupleExpr->mValues[i]);
  2090. }
  2091. VisitChild(tupleExpr->mCloseParen);
  2092. }
  2093. void BfPrinter::Visit(BfMemberReferenceExpression* memberRefExpr)
  2094. {
  2095. Visit(memberRefExpr->ToBase());
  2096. VisitChild(memberRefExpr->mTarget);
  2097. VisitChild(memberRefExpr->mDotToken);
  2098. VisitChild(memberRefExpr->mMemberName);
  2099. }
  2100. void BfPrinter::Visit(BfIndexerExpression* indexerExpr)
  2101. {
  2102. Visit(indexerExpr->ToBase());
  2103. VisitChild(indexerExpr->mTarget);
  2104. VisitChild(indexerExpr->mOpenBracket);
  2105. for (int i = 0; i < (int)indexerExpr->mArguments.size(); i++)
  2106. {
  2107. if (i > 0)
  2108. {
  2109. VisitChildNoRef(indexerExpr->mCommas.GetSafe(i - 1));
  2110. ExpectSpace();
  2111. }
  2112. VisitChild(indexerExpr->mArguments[i]);
  2113. }
  2114. VisitChild(indexerExpr->mCloseBracket);
  2115. }
  2116. void BfPrinter::Visit(BfUnaryOperatorExpression* unaryOpExpr)
  2117. {
  2118. Visit(unaryOpExpr->ToBase());
  2119. bool postOp = (unaryOpExpr->mOp == BfUnaryOp_PostIncrement) || (unaryOpExpr->mOp == BfUnaryOp_PostDecrement) || (unaryOpExpr->mOp == BfUnaryOp_PartialRangeFrom);
  2120. if (!postOp)
  2121. VisitChild(unaryOpExpr->mOpToken);
  2122. if ((unaryOpExpr->mOp == BfUnaryOp_Ref) || (unaryOpExpr->mOp == BfUnaryOp_Mut) || (unaryOpExpr->mOp == BfUnaryOp_Out) || (unaryOpExpr->mOp == BfUnaryOp_Params) || (unaryOpExpr->mOp == BfUnaryOp_Cascade))
  2123. ExpectSpace();
  2124. VisitChild(unaryOpExpr->mExpression);
  2125. if (postOp)
  2126. VisitChild(unaryOpExpr->mOpToken);
  2127. }
  2128. void BfPrinter::Visit(BfBinaryOperatorExpression* binOpExpr)
  2129. {
  2130. //Visit(binOpExpr->ToBase());
  2131. VisitChild(binOpExpr->mLeft);
  2132. ExpectSpace();
  2133. VisitChild(binOpExpr->mOpToken);
  2134. ExpectSpace();
  2135. VisitChild(binOpExpr->mRight);
  2136. }
  2137. void BfPrinter::Visit(BfConstructorDeclaration* ctorDeclaration)
  2138. {
  2139. //Visit((BfAstNode*)ctorDeclaration);
  2140. if (!ctorDeclaration->IsA<BfAutoConstructorDeclaration>())
  2141. ExpectNewLine();
  2142. if (ctorDeclaration->mAttributes != NULL)
  2143. {
  2144. QueueVisitChild(ctorDeclaration->mAttributes);
  2145. ExpectNewLine();
  2146. }
  2147. QueueVisitChild(ctorDeclaration->mProtectionSpecifier);
  2148. ExpectSpace();
  2149. QueueVisitChild(ctorDeclaration->mNewSpecifier);
  2150. ExpectSpace();
  2151. QueueVisitChild(ctorDeclaration->mStaticSpecifier);
  2152. ExpectSpace();
  2153. if (mDocPrep)
  2154. {
  2155. FlushVisitChild();
  2156. Write(" ");
  2157. VisitChild(mCurTypeDecl->mNameNode);
  2158. }
  2159. else
  2160. {
  2161. QueueVisitChild(ctorDeclaration->mThisToken);
  2162. }
  2163. QueueVisitChild(ctorDeclaration->mGenericParams);
  2164. QueueVisitChild(ctorDeclaration->mOpenParen);
  2165. for (int i = 0; i < (int) ctorDeclaration->mParams.size(); i++)
  2166. {
  2167. if (i > 0)
  2168. {
  2169. QueueVisitChild(ctorDeclaration->mCommas.GetSafe(i - 1));
  2170. ExpectSpace();
  2171. }
  2172. QueueVisitChild(ctorDeclaration->mParams[i]);
  2173. }
  2174. QueueVisitChild(ctorDeclaration->mCloseParen);
  2175. ExpectSpace();
  2176. QueueVisitChild(ctorDeclaration->mInitializerColonToken);
  2177. ExpectSpace();
  2178. QueueVisitChild(ctorDeclaration->mInitializer);
  2179. ExpectSpace();
  2180. QueueVisitChild(ctorDeclaration->mGenericConstraintsDeclaration);
  2181. if (ctorDeclaration->mFatArrowToken != NULL)
  2182. {
  2183. ExpectSpace();
  2184. QueueVisitChild(ctorDeclaration->mFatArrowToken);
  2185. ExpectSpace();
  2186. }
  2187. QueueVisitChild(ctorDeclaration->mBody);
  2188. QueueVisitChild(ctorDeclaration->mEndSemicolon);
  2189. FlushVisitChild();
  2190. }
  2191. void BfPrinter::Visit(BfAutoConstructorDeclaration* ctorDeclaration)
  2192. {
  2193. if (ctorDeclaration->mPrefix != NULL)
  2194. {
  2195. VisitChild(ctorDeclaration->mPrefix);
  2196. ExpectSpace();
  2197. }
  2198. Visit(ctorDeclaration->ToBase());
  2199. }
  2200. void BfPrinter::Visit(BfDestructorDeclaration* dtorDeclaration)
  2201. {
  2202. //Visit((BfAstNode*)dtorDeclaration);
  2203. QueueVisitChild(dtorDeclaration->mAttributes);
  2204. ExpectNewLine();
  2205. ExpectSpace();
  2206. QueueVisitChild(dtorDeclaration->mProtectionSpecifier);
  2207. ExpectSpace();
  2208. QueueVisitChild(dtorDeclaration->mNewSpecifier);
  2209. ExpectSpace();
  2210. QueueVisitChild(dtorDeclaration->mStaticSpecifier);
  2211. ExpectSpace();
  2212. QueueVisitChild(dtorDeclaration->mTildeToken);
  2213. if (mDocPrep)
  2214. {
  2215. FlushVisitChild();
  2216. VisitChild(mCurTypeDecl->mNameNode);
  2217. }
  2218. else
  2219. {
  2220. QueueVisitChild(dtorDeclaration->mThisToken);
  2221. }
  2222. QueueVisitChild(dtorDeclaration->mOpenParen);
  2223. for (int i = 0; i < (int) dtorDeclaration->mParams.size(); i++)
  2224. {
  2225. if (i > 0)
  2226. {
  2227. QueueVisitChild(dtorDeclaration->mCommas.GetSafe(i - 1));
  2228. ExpectSpace();
  2229. }
  2230. QueueVisitChild(dtorDeclaration->mParams[i]);
  2231. }
  2232. QueueVisitChild(dtorDeclaration->mCloseParen);
  2233. QueueVisitChild(dtorDeclaration->mFatArrowToken);
  2234. QueueVisitChild(dtorDeclaration->mBody);
  2235. FlushVisitChild();
  2236. }
  2237. void BfPrinter::QueueMethodDeclaration(BfMethodDeclaration* methodDeclaration)
  2238. {
  2239. if (methodDeclaration->mAttributes != NULL)
  2240. {
  2241. QueueVisitChild(methodDeclaration->mAttributes);
  2242. ExpectNewLine();
  2243. }
  2244. if (methodDeclaration->mExternSpecifier != NULL)
  2245. {
  2246. ExpectSpace();
  2247. QueueVisitChild(methodDeclaration->mExternSpecifier);
  2248. }
  2249. if (methodDeclaration->mProtectionSpecifier != NULL)
  2250. {
  2251. ExpectSpace();
  2252. QueueVisitChild(methodDeclaration->mProtectionSpecifier);
  2253. }
  2254. if (methodDeclaration->mNewSpecifier != NULL)
  2255. {
  2256. ExpectSpace();
  2257. QueueVisitChild(methodDeclaration->mNewSpecifier);
  2258. }
  2259. if (methodDeclaration->mVirtualSpecifier != NULL)
  2260. {
  2261. ExpectSpace();
  2262. QueueVisitChild(methodDeclaration->mVirtualSpecifier);
  2263. }
  2264. if (methodDeclaration->mStaticSpecifier != NULL)
  2265. {
  2266. ExpectSpace();
  2267. QueueVisitChild(methodDeclaration->mStaticSpecifier);
  2268. }
  2269. if (methodDeclaration->mReadOnlySpecifier != NULL)
  2270. {
  2271. ExpectSpace();
  2272. QueueVisitChild(methodDeclaration->mReadOnlySpecifier);
  2273. }
  2274. if (methodDeclaration->mMixinSpecifier != NULL)
  2275. {
  2276. ExpectSpace();
  2277. QueueVisitChild(methodDeclaration->mMixinSpecifier);
  2278. }
  2279. if (methodDeclaration->mPartialSpecifier != NULL)
  2280. {
  2281. ExpectSpace();
  2282. QueueVisitChild(methodDeclaration->mPartialSpecifier);
  2283. }
  2284. if ((methodDeclaration->mNameNode != NULL) || (methodDeclaration->mExplicitInterface != NULL))
  2285. ExpectSpace();
  2286. QueueVisitChild(methodDeclaration->mExplicitInterface);
  2287. QueueVisitChild(methodDeclaration->mExplicitInterfaceDotToken);
  2288. QueueVisitChild(methodDeclaration->mNameNode);
  2289. if (auto operatorDecl = BfNodeDynCast<BfOperatorDeclaration>(methodDeclaration))
  2290. {
  2291. if ((operatorDecl->mOpTypeToken != NULL) && (operatorDecl->mOpTypeToken->mToken == BfToken_LChevron))
  2292. ExpectSpace();
  2293. }
  2294. QueueVisitChild(methodDeclaration->mGenericParams);
  2295. if (auto operatorDecl = BfNodeDynCast<BfOperatorDeclaration>(methodDeclaration))
  2296. {
  2297. ExpectSpace();
  2298. QueueVisitChild(operatorDecl->mExplicitToken);
  2299. ExpectSpace();
  2300. QueueVisitChild(operatorDecl->mOperatorToken);
  2301. ExpectSpace();
  2302. QueueVisitChild(operatorDecl->mOpTypeToken);
  2303. ExpectSpace();
  2304. QueueVisitChild(methodDeclaration->mReturnType);
  2305. }
  2306. else if (methodDeclaration->mReturnType != NULL)
  2307. {
  2308. ExpectSpace();
  2309. QueueVisitChild(methodDeclaration->mReturnType);
  2310. }
  2311. QueueVisitChild(methodDeclaration->mOpenParen);
  2312. if (methodDeclaration->mThisToken != NULL)
  2313. {
  2314. QueueVisitChild(methodDeclaration->mThisToken);
  2315. ExpectSpace();
  2316. }
  2317. for (int i = 0; i < (int) methodDeclaration->mParams.size(); i++)
  2318. {
  2319. if (i > 0)
  2320. {
  2321. QueueVisitChild(methodDeclaration->mCommas.GetSafe(i - 1));
  2322. ExpectSpace();
  2323. }
  2324. QueueVisitChild(methodDeclaration->mParams[i]);
  2325. }
  2326. QueueVisitChild(methodDeclaration->mCloseParen);
  2327. ExpectSpace();
  2328. QueueVisitChild(methodDeclaration->mMutSpecifier);
  2329. ExpectSpace();
  2330. QueueVisitChild(methodDeclaration->mGenericConstraintsDeclaration);
  2331. if (methodDeclaration->mFatArrowToken != NULL)
  2332. {
  2333. ExpectSpace();
  2334. QueueVisitChild(methodDeclaration->mFatArrowToken);
  2335. ExpectSpace();
  2336. }
  2337. QueueVisitChild(methodDeclaration->mBody);
  2338. QueueVisitChild(methodDeclaration->mEndSemicolon);
  2339. }
  2340. void BfPrinter::Visit(BfMethodDeclaration* methodDeclaration)
  2341. {
  2342. //Visit(methodDeclaration->ToBase());
  2343. ExpectNewLine();
  2344. QueueMethodDeclaration(methodDeclaration);
  2345. //?? QueueVisitErrorNodes(methodDeclaration);
  2346. FlushVisitChild();
  2347. ExpectNewLine();
  2348. }
  2349. void BfPrinter::Visit(BfOperatorDeclaration* opreratorDeclaration)
  2350. {
  2351. Visit(opreratorDeclaration->ToBase());
  2352. }
  2353. void BfPrinter::Visit(BfPropertyMethodDeclaration* propertyMethodDeclaration)
  2354. {
  2355. ExpectNewLine();
  2356. QueueVisitChild(propertyMethodDeclaration->mAttributes);
  2357. ExpectNewLine();
  2358. QueueVisitChild(propertyMethodDeclaration->mProtectionSpecifier);
  2359. ExpectSpace();
  2360. QueueVisitChild(propertyMethodDeclaration->mNameNode);
  2361. ExpectSpace();
  2362. QueueVisitChild(propertyMethodDeclaration->mSetRefSpecifier);
  2363. ExpectSpace();
  2364. QueueVisitChild(propertyMethodDeclaration->mMutSpecifier);
  2365. ExpectSpace();
  2366. QueueVisitChild(propertyMethodDeclaration->mFatArrowToken);
  2367. ExpectSpace();
  2368. if (auto block = BfNodeDynCast<BfBlock>(propertyMethodDeclaration->mBody))
  2369. ExpectNewLine();
  2370. QueueVisitChild(propertyMethodDeclaration->mBody);
  2371. QueueVisitChild(propertyMethodDeclaration->mEndSemicolon);
  2372. }
  2373. void BfPrinter::Visit(BfPropertyBodyExpression* propertyBodyExpression)
  2374. {
  2375. VisitChild(propertyBodyExpression->mMutSpecifier);
  2376. ExpectSpace();
  2377. VisitChild(propertyBodyExpression->mFatTokenArrow);
  2378. }
  2379. void BfPrinter::Visit(BfPropertyDeclaration* propertyDeclaration)
  2380. {
  2381. auto indexerDeclaration = BfNodeDynCast<BfIndexerDeclaration>(propertyDeclaration);
  2382. ExpectNewLine();
  2383. QueueVisitChild(propertyDeclaration->mAttributes);
  2384. ExpectNewLine();
  2385. ExpectSpace();
  2386. QueueVisitChild(propertyDeclaration->mProtectionSpecifier);
  2387. ExpectSpace();
  2388. QueueVisitChild(propertyDeclaration->mConstSpecifier);
  2389. ExpectSpace();
  2390. QueueVisitChild(propertyDeclaration->mReadOnlySpecifier);
  2391. ExpectSpace();
  2392. QueueVisitChild(propertyDeclaration->mVolatileSpecifier);
  2393. ExpectSpace();
  2394. QueueVisitChild(propertyDeclaration->mNewSpecifier);
  2395. ExpectSpace();
  2396. QueueVisitChild(propertyDeclaration->mVirtualSpecifier);
  2397. ExpectSpace();
  2398. QueueVisitChild(propertyDeclaration->mExternSpecifier);
  2399. ExpectSpace();
  2400. QueueVisitChild(propertyDeclaration->mStaticSpecifier);
  2401. ExpectSpace();
  2402. QueueVisitChild(propertyDeclaration->mTypeRef);
  2403. ExpectSpace();
  2404. QueueVisitChild(propertyDeclaration->mExplicitInterface);
  2405. QueueVisitChild(propertyDeclaration->mExplicitInterfaceDotToken);
  2406. QueueVisitChild(propertyDeclaration->mNameNode);
  2407. ExpectSpace();
  2408. if (indexerDeclaration != NULL)
  2409. {
  2410. QueueVisitChild(indexerDeclaration->mThisToken);
  2411. QueueVisitChild(indexerDeclaration->mOpenBracket);
  2412. for (int i = 0; i < (int)indexerDeclaration->mParams.size(); i++)
  2413. {
  2414. if (i > 0)
  2415. {
  2416. QueueVisitChild(indexerDeclaration->mCommas.GetSafe(i - 1));
  2417. ExpectSpace();
  2418. }
  2419. QueueVisitChild(indexerDeclaration->mParams[i]);
  2420. }
  2421. QueueVisitChild(indexerDeclaration->mCloseBracket);
  2422. ExpectSpace();
  2423. }
  2424. if (auto block = BfNodeDynCast<BfBlock>(propertyDeclaration->mDefinitionBlock))
  2425. {
  2426. BlockState blockState;
  2427. DoBlockOpen(NULL, block->mOpenBrace, block->mCloseBrace, true, blockState);
  2428. for (auto method : propertyDeclaration->mMethods)
  2429. {
  2430. Visit(method);
  2431. }
  2432. FlushVisitChild();
  2433. DoBlockClose(NULL, block->mOpenBrace, block->mCloseBrace, true, blockState);
  2434. }
  2435. else
  2436. {
  2437. ExpectSpace();
  2438. QueueVisitChild(propertyDeclaration->mDefinitionBlock);
  2439. ExpectSpace();
  2440. for (auto method : propertyDeclaration->mMethods)
  2441. {
  2442. QueueVisitChild(method->mBody);
  2443. }
  2444. }
  2445. ExpectSpace();
  2446. QueueVisitChild(propertyDeclaration->mEqualsNode);
  2447. ExpectSpace();
  2448. QueueVisitChild(propertyDeclaration->mInitializer);
  2449. ExpectSpace();
  2450. QueueVisitChild(propertyDeclaration->mFieldDtor);
  2451. FlushVisitChild();
  2452. //QueueVisitChild(propertyDeclaration->mTrailingSemicolon);
  2453. // ??? QueueVisitErrorNodes(propertyDeclaration);
  2454. FlushVisitChild();
  2455. }
  2456. void BfPrinter::Visit(BfIndexerDeclaration* indexerDeclaration)
  2457. {
  2458. Visit((BfPropertyDeclaration*)indexerDeclaration);
  2459. }
  2460. void BfPrinter::Visit(BfFieldDeclaration* fieldDeclaration)
  2461. {
  2462. bool isEnumDecl = false;
  2463. if (auto enumEntry = BfNodeDynCast<BfEnumEntryDeclaration>(fieldDeclaration))
  2464. {
  2465. isEnumDecl = true;
  2466. }
  2467. if (fieldDeclaration->mPrecedingComma != NULL)
  2468. {
  2469. mVirtualNewLineIdx = mNextStateModify.mWantNewLineIdx;
  2470. QueueVisitChild(fieldDeclaration->mPrecedingComma);
  2471. ExpectSpace();
  2472. QueueVisitChild(fieldDeclaration->mNameNode);
  2473. }
  2474. else
  2475. {
  2476. if (!isEnumDecl)
  2477. ExpectNewLine();
  2478. if (fieldDeclaration->mAttributes != NULL)
  2479. {
  2480. QueueVisitChild(fieldDeclaration->mAttributes);
  2481. ExpectNewLine();
  2482. }
  2483. ExpectSpace();
  2484. QueueVisitChild(fieldDeclaration->mProtectionSpecifier);
  2485. ExpectSpace();
  2486. QueueVisitChild(fieldDeclaration->mConstSpecifier);
  2487. ExpectSpace();
  2488. QueueVisitChild(fieldDeclaration->mReadOnlySpecifier);
  2489. ExpectSpace();
  2490. QueueVisitChild(fieldDeclaration->mVolatileSpecifier);
  2491. ExpectSpace();
  2492. QueueVisitChild(fieldDeclaration->mNewSpecifier);
  2493. ExpectSpace();
  2494. QueueVisitChild(fieldDeclaration->mExternSpecifier);
  2495. ExpectSpace();
  2496. QueueVisitChild(fieldDeclaration->mStaticSpecifier);
  2497. ExpectSpace();
  2498. QueueVisitChild(fieldDeclaration->mPrecedingComma);
  2499. ExpectSpace();
  2500. if (isEnumDecl)
  2501. mNextStateModify.mExpectingSpace = false;
  2502. QueueVisitChild(fieldDeclaration->mTypeRef);
  2503. ExpectSpace();
  2504. QueueVisitChild(fieldDeclaration->mNameNode);
  2505. }
  2506. if (fieldDeclaration->mEqualsNode != NULL)
  2507. {
  2508. ExpectSpace();
  2509. QueueVisitChild(fieldDeclaration->mEqualsNode);
  2510. }
  2511. if (fieldDeclaration->mInitializer != NULL)
  2512. {
  2513. ExpectSpace();
  2514. QueueVisitChild(fieldDeclaration->mInitializer);
  2515. }
  2516. mNextStateModify.mExpectingSpace = false;
  2517. FlushVisitChild();
  2518. VisitChild(fieldDeclaration->mFieldDtor);
  2519. mNextStateModify.mExpectingSpace = false;
  2520. }
  2521. void BfPrinter::Visit(BfEnumCaseDeclaration* enumCaseDeclaration)
  2522. {
  2523. ExpectNewLine();
  2524. Visit(enumCaseDeclaration->ToBase());
  2525. if (mDocPrep)
  2526. {
  2527. for (int i = 0; i < (int)enumCaseDeclaration->mEntries.size(); i++)
  2528. {
  2529. auto fieldDecl = enumCaseDeclaration->mEntries[i];
  2530. Visit((BfAstNode*)fieldDecl);
  2531. Write("public static ");
  2532. Visit(mCurTypeDecl->mNameNode);
  2533. Write(" ");
  2534. VisitChild(fieldDecl);
  2535. Write(";");
  2536. }
  2537. return;
  2538. }
  2539. VisitChild(enumCaseDeclaration->mCaseToken);
  2540. ExpectSpace();
  2541. for (int i = 0; i < (int)enumCaseDeclaration->mEntries.size(); i++)
  2542. {
  2543. if (i > 0)
  2544. {
  2545. VisitChildNoRef(enumCaseDeclaration->mCommas.GetSafe(i - 1));
  2546. ExpectSpace();
  2547. }
  2548. VisitChild(enumCaseDeclaration->mEntries[i]);
  2549. }
  2550. }
  2551. void BfPrinter::Visit(BfTypeAliasDeclaration* typeDeclaration)
  2552. {
  2553. Visit(typeDeclaration->ToBase());
  2554. ExpectSpace();
  2555. VisitChild(typeDeclaration->mEqualsToken);
  2556. ExpectSpace();
  2557. VisitChild(typeDeclaration->mAliasToType);
  2558. VisitChild(typeDeclaration->mEndSemicolon);
  2559. }
  2560. void BfPrinter::Visit(BfFieldDtorDeclaration* fieldDtorDeclaration)
  2561. {
  2562. ExpectSpace();
  2563. if (fieldDtorDeclaration->mBody != NULL)
  2564. {
  2565. if (fieldDtorDeclaration->mBody->IsA<BfBlock>())
  2566. {
  2567. ExpectNewLine();
  2568. ExpectIndent();
  2569. VisitChild(fieldDtorDeclaration->mTildeToken);
  2570. VisitChild(fieldDtorDeclaration->mBody);
  2571. ExpectUnindent();
  2572. }
  2573. else
  2574. {
  2575. VisitChild(fieldDtorDeclaration->mTildeToken);
  2576. ExpectSpace();
  2577. VisitChild(fieldDtorDeclaration->mBody);
  2578. }
  2579. }
  2580. else
  2581. VisitChild(fieldDtorDeclaration->mTildeToken);
  2582. VisitChild(fieldDtorDeclaration->mNextFieldDtor);
  2583. }
  2584. void BfPrinter::Visit(BfTypeDeclaration* typeDeclaration)
  2585. {
  2586. SetAndRestoreValue<BfTypeDeclaration*> prevTypeDecl(mCurTypeDecl, typeDeclaration);
  2587. //Visit(typeDeclaration->ToBase());
  2588. bool isOneLine = true;
  2589. const char* src = typeDeclaration->GetSourceData()->mSrc;
  2590. for (int i = typeDeclaration->GetSrcStart(); i < typeDeclaration->GetSrcEnd(); i++)
  2591. {
  2592. if (src[i] == '\n')
  2593. {
  2594. isOneLine = false;
  2595. break;
  2596. }
  2597. }
  2598. ExpectNewLine();
  2599. QueueVisitChild(typeDeclaration->mAttributes);
  2600. if (!isOneLine)
  2601. ExpectNewLine();
  2602. ExpectSpace();
  2603. QueueVisitChild(typeDeclaration->mAbstractSpecifier);
  2604. ExpectSpace();
  2605. QueueVisitChild(typeDeclaration->mSealedSpecifier);
  2606. ExpectSpace();
  2607. QueueVisitChild(typeDeclaration->mProtectionSpecifier);
  2608. ExpectSpace();
  2609. QueueVisitChild(typeDeclaration->mStaticSpecifier);
  2610. ExpectSpace();
  2611. QueueVisitChild(typeDeclaration->mPartialSpecifier);
  2612. ExpectSpace();
  2613. bool isEnumDoc = false;
  2614. if ((mDocPrep) && (typeDeclaration->mTypeNode != NULL) && (typeDeclaration->mTypeNode->mToken == BfToken_Enum))
  2615. {
  2616. if (auto defineBlock = BfNodeDynCast<BfBlock>(typeDeclaration->mDefineNode))
  2617. {
  2618. if (auto enumEntryDecl = BfNodeDynCast<BfEnumEntryDeclaration>(defineBlock->GetFirst()))
  2619. {
  2620. }
  2621. else
  2622. {
  2623. isEnumDoc = true;
  2624. }
  2625. }
  2626. }
  2627. if (isEnumDoc)
  2628. {
  2629. FlushVisitChild();
  2630. Write(" struct");
  2631. }
  2632. else
  2633. QueueVisitChild(typeDeclaration->mTypeNode);
  2634. bool queueChildren = (typeDeclaration->mTypeNode != NULL) &&
  2635. ((typeDeclaration->mTypeNode->mToken == BfToken_Delegate) || (typeDeclaration->mTypeNode->mToken == BfToken_Function));
  2636. ExpectSpace();
  2637. QueueVisitChild(typeDeclaration->mNameNode);
  2638. QueueVisitChild(typeDeclaration->mGenericParams);
  2639. if (typeDeclaration->mColonToken != NULL)
  2640. {
  2641. ExpectSpace();
  2642. QueueVisitChild(typeDeclaration->mColonToken);
  2643. }
  2644. if (typeDeclaration->mAutoCtor != NULL)
  2645. {
  2646. ExpectSpace();
  2647. QueueVisitChild(typeDeclaration->mAutoCtor);
  2648. }
  2649. if (typeDeclaration->mColonToken != NULL)
  2650. {
  2651. int nextCommaIdx = -1;
  2652. if (typeDeclaration->mAutoCtor != NULL)
  2653. nextCommaIdx++;
  2654. for (int i = 0; i < (int)typeDeclaration->mBaseClasses.size(); i++)
  2655. {
  2656. ExpectSpace();
  2657. QueueVisitChild(typeDeclaration->mBaseClasses[i]);
  2658. if (nextCommaIdx >= 0)
  2659. QueueVisitChild(typeDeclaration->mBaseClassCommas.GetSafe(nextCommaIdx));
  2660. nextCommaIdx++;
  2661. }
  2662. if (nextCommaIdx >= 0)
  2663. QueueVisitChild(typeDeclaration->mBaseClassCommas.GetSafe(nextCommaIdx));
  2664. ExpectSpace();
  2665. }
  2666. QueueVisitChild(typeDeclaration->mGenericConstraintsDeclaration);
  2667. if (queueChildren)
  2668. {
  2669. if (auto defineBlock = BfNodeDynCast<BfBlock>(typeDeclaration->mDefineNode))
  2670. {
  2671. for (auto member : defineBlock->mChildArr)
  2672. {
  2673. SetAndRestoreValue<BfAstNode*> prevBlockMember(mCurBlockMember, member);
  2674. if (auto methodDecl = BfNodeDynCast<BfMethodDeclaration>(member))
  2675. {
  2676. QueueMethodDeclaration(methodDecl);
  2677. }
  2678. else
  2679. BF_FATAL("Error");
  2680. }
  2681. FlushVisitChild();
  2682. }
  2683. else
  2684. {
  2685. FlushVisitChild();
  2686. VisitChild(typeDeclaration->mDefineNode);
  2687. }
  2688. }
  2689. else
  2690. {
  2691. FlushVisitChild();
  2692. if (auto defineBlock = BfNodeDynCast<BfBlock>(typeDeclaration->mDefineNode))
  2693. {
  2694. if (!isOneLine)
  2695. {
  2696. ExpectNewLine();
  2697. mNextStateModify.mDoingBlockOpen = true;
  2698. }
  2699. else
  2700. ExpectSpace();
  2701. VisitChild(defineBlock->mOpenBrace);
  2702. ExpectIndent();
  2703. for (auto member : defineBlock->mChildArr)
  2704. {
  2705. SetAndRestoreValue<BfAstNode*> prevBlockMember(mCurBlockMember, member);
  2706. if (auto fieldDecl = BfNodeDynCast<BfFieldDeclaration>(member))
  2707. ExpectNewLine();
  2708. else if (auto tokenNode = BfNodeDynCast<BfTokenNode>(member))
  2709. {
  2710. mVirtualNewLineIdx = mNextStateModify.mWantNewLineIdx;
  2711. mNextStateModify.mExpectingSpace = false;
  2712. }
  2713. VisitChild(member);
  2714. }
  2715. ExpectUnindent();
  2716. VisitChild(defineBlock->mCloseBrace);
  2717. }
  2718. else
  2719. {
  2720. FlushVisitChild();
  2721. VisitChild(typeDeclaration->mDefineNode);
  2722. }
  2723. }
  2724. ExpectNewLine();
  2725. }
  2726. void BfPrinter::Visit(BfUsingDirective* usingDirective)
  2727. {
  2728. //Visit(usingDirective->ToBase());
  2729. ExpectNewLine();
  2730. VisitChild(usingDirective->mUsingToken);
  2731. ExpectSpace();
  2732. VisitChild(usingDirective->mNamespace);
  2733. VisitChild(usingDirective->mTrailingSemicolon);
  2734. ExpectNewLine();
  2735. }
  2736. void BfPrinter::Visit(BfUsingModDirective* usingDirective)
  2737. {
  2738. ExpectNewLine();
  2739. VisitChild(usingDirective->mUsingToken);
  2740. ExpectSpace();
  2741. VisitChild(usingDirective->mModToken);
  2742. ExpectSpace();
  2743. VisitChild(usingDirective->mTypeRef);
  2744. VisitChild(usingDirective->mTrailingSemicolon);
  2745. ExpectNewLine();
  2746. }
  2747. void BfPrinter::Visit(BfNamespaceDeclaration* namespaceDeclaration)
  2748. {
  2749. //Visit(namespaceDeclaration->ToBase());
  2750. ExpectNewLine();
  2751. VisitChild(namespaceDeclaration->mNamespaceNode);
  2752. ExpectSpace();
  2753. VisitChild(namespaceDeclaration->mNameNode);
  2754. VisitChild(namespaceDeclaration->mBody);
  2755. }
  2756. void BfPrinter::DoBlockOpen(BfAstNode* prevNode, BfTokenNode* blockOpen, BfTokenNode* blockClose, bool queue, BlockState& blockState)
  2757. {
  2758. blockState.mLastSpaceOffset = mLastSpaceOffset;
  2759. blockState.mIndentStart = mNextStateModify.mWantVirtualIndent;
  2760. bool doInlineBlock = true;
  2761. if (blockClose != NULL)
  2762. {
  2763. auto blockSrc = blockOpen->GetSourceData();
  2764. int srcEnd = blockClose->GetSrcEnd();
  2765. int srcStart = blockOpen->GetSrcStart();
  2766. if (prevNode != NULL)
  2767. srcStart = prevNode->GetSrcEnd();
  2768. for (int i = srcStart; i < srcEnd; i++)
  2769. {
  2770. if (blockSrc->mSrc[i] == '\n')
  2771. doInlineBlock = false;
  2772. }
  2773. }
  2774. if (!doInlineBlock)
  2775. {
  2776. ExpectNewLine();
  2777. mNextStateModify.mDoingBlockOpen = true;
  2778. if (prevNode != NULL)
  2779. ExpectIndent();
  2780. }
  2781. else
  2782. ExpectSpace();
  2783. if (queue)
  2784. QueueVisitChild(blockOpen);
  2785. else
  2786. VisitChild(blockOpen);
  2787. if (!doInlineBlock)
  2788. ExpectIndent();
  2789. else
  2790. ExpectSpace();
  2791. blockState.mDoInlineBlock = doInlineBlock;
  2792. }
  2793. void BfPrinter::DoBlockClose(BfAstNode* prevNode, BfTokenNode* blockOpen, BfTokenNode* blockClose, bool queue, BlockState& blockState)
  2794. {
  2795. if (!blockState.mDoInlineBlock)
  2796. {
  2797. ExpectUnindent();
  2798. mNextStateModify.mDoingBlockClose = true;
  2799. }
  2800. else
  2801. ExpectSpace();
  2802. if (queue)
  2803. QueueVisitChild(blockClose);
  2804. else
  2805. VisitChild(blockClose);
  2806. if (!blockState.mDoInlineBlock)
  2807. {
  2808. mNextStateModify.mWantVirtualIndent = blockState.mIndentStart;
  2809. mLastSpaceOffset = blockState.mLastSpaceOffset;
  2810. }
  2811. }
  2812. void BfPrinter::Visit(BfBlock* block)
  2813. {
  2814. BlockState blockState;
  2815. SetAndRestoreValue<BlockState*> prevBlockState(mCurBlockState, &blockState);
  2816. DoBlockOpen(NULL, block->mOpenBrace, block->mCloseBrace, false, blockState);
  2817. for (auto& childNodeRef : *block)
  2818. {
  2819. BfAstNode* child = childNodeRef;
  2820. SetAndRestoreValue<bool> prevForceTrivia(mForceUseTrivia);
  2821. SetAndRestoreValue<int> prevVirtualIndent(mNextStateModify.mWantVirtualIndent);
  2822. SetAndRestoreValue<BfAstNode*> prevBlockMember(mCurBlockMember, child);
  2823. CheckRawNode(child);
  2824. child->Accept(this);
  2825. }
  2826. DoBlockClose(NULL, block->mOpenBrace, block->mCloseBrace, false, blockState);
  2827. ExpectNewLine();
  2828. }
  2829. void BfPrinter::Visit(BfRootNode* rootNode)
  2830. {
  2831. for (auto child : rootNode->mChildArr)
  2832. {
  2833. SetAndRestoreValue<BfAstNode*> prevBlockMember(mCurBlockMember, child);
  2834. child->Accept(this);
  2835. }
  2836. // Flush whitespace at the end of the document
  2837. BfParserData* bfParser = rootNode->GetSourceData()->ToParserData();
  2838. if (bfParser != NULL)
  2839. {
  2840. BfAstNode* endNode = mSource->mAlloc.Alloc<BfAstNode>();
  2841. endNode->Init(rootNode->GetSrcEnd(), bfParser->mSrcLength, bfParser->mSrcLength);
  2842. Visit(endNode);
  2843. }
  2844. if (mCharMapping != NULL)
  2845. {
  2846. BF_ASSERT(mCharMapping->size() == mOutString.length());
  2847. }
  2848. }
  2849. void BfPrinter::Visit(BfInlineAsmStatement* asmStmt)
  2850. {
  2851. }