ctags/parsers/cxx/cxx_parser_module.c

   1 /*
   2 *   Copyright (c) 2024, Masatake YAMATO
   3 *
   4 *   This source code is released for free distribution under the terms of the
   5 *   GNU General Public License version 2 or (at your option) any later version.
   6 *
   7 *   This module contains functions for parsing and scanning C++ source files
   8 *
   9 * Reference:
  10 * - https://en.cppreference.com/w/cpp/language/modules
  11 */
  12
  13 #include "cxx_parser.h"
  14 #include "cxx_parser_internal.h"
  15
  16 #include "cxx_debug.h"
  17 #include "cxx_keyword.h"
  18 #include "cxx_token.h"
  19 #include "cxx_token_chain.h"
  20 #include "cxx_scope.h"
  21
  22 #include "../cpreprocessor.h"
  23
  24 #include "parse.h"
  25 #include "vstring.h"
  26 #include "read.h"
  27 #include "trashbox.h"
  28
  29 static CXXToken * pCurrentModuleToken;
  30
  31 static void cxxParserSetCurrentModuleToken(CXXToken * pMod)
  32 {
  33         if (pCurrentModuleToken)
  34                 cxxTokenDestroy(pCurrentModuleToken);
  35         pCurrentModuleToken = pMod;
  36 }
  37
  38 void cxxParserDestroyCurrentModuleToken(void)
  39 {
  40         cxxParserSetCurrentModuleToken(NULL);
  41 }
  42
  43
  44 static CXXToken * cxxTokenModuleTokenCreate(CXXToken *pBegin, CXXToken *pEnd)
  45 {
  46         CXXToken * pRet = cxxTokenCopy(pBegin);
  47
  48         if (pBegin != pEnd)
  49         {
  50                 vString * pszRest = cxxTokenChainJoinRange(pBegin->pNext, pEnd, "",
  51                                                                                                    CXXTokenChainJoinNoTrailingSpaces);
  52                 vStringCat(pRet->pszWord, pszRest);
  53                 vStringDelete(pszRest);
  54         }
  55
  56         return pRet;
  57 }
  58
  59 bool cxxParserParseModule(void)
  60 {
  61         CXX_DEBUG_ENTER();
  62
  63         unsigned int uProperties = 0;
  64
  65         if(cxxTagFieldEnabled(CXXTagFieldProperties))
  66         {
  67                 if(g_cxx.uKeywordState & CXXParserKeywordStateSeenExport)
  68                         uProperties |= CXXTagPropertyExport;
  69         }
  70
  71         cxxParserNewStatement();
  72
  73         if(!cxxParserParseUpToOneOf(
  74                         CXXTokenTypeSemicolon | CXXTokenTypeEOF,
  75                         false
  76                 ))
  77         {
  78                 CXX_DEBUG_LEAVE_TEXT("Failed to parse up to the next ;");
  79                 return false;
  80         }
  81
  82         CXXToken * pFirst = cxxTokenChainFirst(g_cxx.pTokenChain);
  83         if (cxxTokenTypeIsOneOf(pFirst, CXXTokenTypeSemicolon | CXXTokenTypeEOF))
  84         {
  85                 CXXToken * pMod = cxxTokenCreateAnonymousIdentifier(CXXTagCPPKindMODULE, "__gmod_");
  86                 tagEntryInfo * tag = cxxTagBegin(CXXTagCPPKindMODULE,pMod);
  87                 if (tag)
  88                         cxxTagCommit(NULL);
  89                 cxxTokenDestroy(pMod);
  90         }
  91         else if (cxxTokenTypeIs(pFirst, CXXTokenTypeSingleColon)
  92                 && pFirst->pNext && cxxTokenIsKeyword(pFirst->pNext, CXXKeywordPRIVATE))
  93         {
  94                 CXXToken * pPart = pFirst->pNext;
  95                 if (pCurrentModuleToken)
  96                 {
  97                         CXXToken *pMod = cxxTokenCopy(pCurrentModuleToken);
  98                         cxxScopePush(pMod, CXXScopeTypeModule, CXXScopeAccessUnknown);
  99                 }
 100
 101                 tagEntryInfo * tag = cxxTagBegin(CXXTagCPPKindPARTITION,pPart);
 102                 if (tag)
 103                         cxxTagCommit(NULL);
 104                 /* export is never set to the private partition. */
 105
 106                 if (pCurrentModuleToken)
 107                         cxxScopePop();
 108         }
 109         else if (cxxTokenTypeIs(pFirst, CXXTokenTypeIdentifier))
 110         {
 111                 CXXToken * pModBegin = pFirst;
 112                 CXXToken * pSep = cxxTokenChainNextTokenOfType(pModBegin,
 113                                                                                                            CXXTokenTypeSingleColon
 114                                                                                                            | CXXTokenTypeSemicolon
 115                                                                                                            | CXXTokenTypeEOF);
 116                 bool bHasPart = (cxxTokenTypeIs(pSep, CXXTokenTypeSingleColon)
 117                                                  && pSep->pNext && cxxTokenTypeIs(pSep->pNext, CXXTokenTypeIdentifier)
 118                                                  && g_cxx.pToken->pPrev && g_cxx.pToken->pPrev != pSep);
 119
 120                 CXXToken * pMod = NULL;
 121                 {
 122                         pMod = cxxTokenModuleTokenCreate(pModBegin, pSep->pPrev);
 123                         tagEntryInfo * tag = cxxRefTagBegin(CXXTagCPPKindMODULE,
 124                                                                                                 bHasPart? CXXTagMODULERolePartOwner: ROLE_DEFINITION_INDEX,
 125                                                                                                 pMod);
 126                         if (tag)
 127                         {
 128                                 vString * pszProperties = (!bHasPart && uProperties) ? cxxTagSetProperties(uProperties) : NULL;
 129
 130                                 cxxTagCommit(NULL);
 131                                 cxxParserSetCurrentModuleToken(cxxTokenCopy(pMod));
 132                                 cxxScopePush(pMod, CXXScopeTypeModule, CXXScopeAccessUnknown);
 133                                 vStringDelete(pszProperties); /* NULL is acceptable. */
 134                         }
 135                         else
 136                         {
 137                                 cxxParserSetCurrentModuleToken(pMod);
 138                                 pMod = NULL;
 139                         }
 140                 }
 141
 142                 if (pMod && bHasPart)
 143                 {
 144                         CXXToken * pPart = cxxTokenModuleTokenCreate(pSep->pNext, g_cxx.pToken->pPrev);
 145
 146                         tagEntryInfo * tag = cxxTagBegin(CXXTagCPPKindPARTITION,pPart);
 147                         if (tag)
 148                         {
 149                                 vString * pszProperties = uProperties ? cxxTagSetProperties(uProperties) : NULL;
 150
 151                                 cxxTagCommit(NULL);
 152                                 vStringDelete(pszProperties); /* NULL is acceptable */
 153                         }
 154                         cxxTokenDestroy(pPart);
 155                 }
 156
 157                 if (pMod)
 158                         cxxScopePop();
 159         }
 160
 161         cxxTokenChainClear(g_cxx.pTokenChain);
 162         CXX_DEBUG_LEAVE();
 163         return true;
 164 }
 165
 166 bool cxxParserParseImport(void)
 167 {
 168         CXX_DEBUG_ENTER();
 169
 170         unsigned int uProperties = 0;
 171
 172         if(cxxTagFieldEnabled(CXXTagFieldProperties))
 173         {
 174                 if(g_cxx.uKeywordState & CXXParserKeywordStateSeenExport)
 175                         uProperties |= CXXTagPropertyExport;
 176         }
 177
 178         cxxParserNewStatement();
 179
 180         if(!cxxParserParseUpToOneOf(
 181                         CXXTokenTypeSemicolon | CXXTokenTypeEOF,
 182                         false
 183                 ))
 184         {
 185                 CXX_DEBUG_LEAVE_TEXT("Failed to parse up to the next ;");
 186                 return false;
 187         }
 188
 189         CXXToken *pFirst = cxxTokenChainFirst(g_cxx.pTokenChain);
 190         if (cxxTokenTypeIs(pFirst, CXXTokenTypeSmallerThanSign))
 191         {
 192                 if (pFirst->pNext == NULL
 193                         ||  cxxTokenTypeIsOneOf(pFirst->pNext, CXXTokenTypeGreaterThanSign
 194                                                                         | CXXTokenTypeSemicolon
 195                                                                         | CXXTokenTypeEOF))
 196                 {
 197                         cxxTokenChainClear(g_cxx.pTokenChain);
 198                         CXX_DEBUG_LEAVE_TEXT("Cannot find > on the chain");
 199                         return true;
 200                 }
 201
 202                 CXXToken * pHeaderBegin = pFirst->pNext;
 203                 CXXToken * pSep = cxxTokenChainNextTokenOfType(pHeaderBegin,
 204                                                                                                            CXXTokenTypeGreaterThanSign
 205                                                                                                            | CXXTokenTypeSemicolon
 206                                                                                                            | CXXTokenTypeEOF);
 207                 CXX_DEBUG_ASSERT(pSep,"Cannot find the end of header file");
 208                 CXX_DEBUG_ASSERT(pSep != pHeaderBegin, "Unexpected empty header file");
 209
 210                 CXXToken * pHeader = cxxTokenModuleTokenCreate(pHeaderBegin, pSep->pPrev);
 211                 tagEntryInfo * tag = cxxRefTagBegin(CXXTagKindINCLUDE,CR_HEADER_SYSTEM,pHeader);
 212                 if (tag)
 213                 {
 214                         assignRole(tag, CXXR_HEADER_IMPORTED);
 215                         if (uProperties & CXXTagPropertyExport)
 216                                 assignRole(tag, CXXR_HEADER_EXPORTED);
 217                         cxxTagCommit(NULL);
 218                 }
 219                 cxxTokenDestroy(pHeader);
 220         }
 221         else if (cxxTokenTypeIs(pFirst, CXXTokenTypeStringConstant))
 222         {
 223                 const vString *pHName = cppGetLastCharOrStringContents();
 224                 if (!pHName || vStringIsEmpty(pHName))
 225                 {
 226                         cxxTokenChainClear(g_cxx.pTokenChain);
 227                         CXX_DEBUG_LEAVE_TEXT("Empty header name");
 228                         return true;
 229                 }
 230
 231                 vStringCopy(pFirst->pszWord, pHName);
 232                 CXXToken *pHeader = pFirst;
 233
 234                 tagEntryInfo * tag = cxxRefTagBegin(CXXTagKindINCLUDE,CR_HEADER_LOCAL,pHeader);
 235                 if (tag)
 236                 {
 237                         assignRole(tag, CXXR_HEADER_IMPORTED);
 238                         if (uProperties & CXXTagPropertyExport)
 239                                 assignRole(tag, CXXR_HEADER_EXPORTED);
 240                         cxxTagCommit(NULL);
 241                 }
 242         }
 243         else if (cxxTokenTypeIs(pFirst, CXXTokenTypeSingleColon))
 244         {
 245                 CXXToken * pPartBegin = pFirst->pNext;
 246
 247                 if (pPartBegin == NULL
 248                         || pPartBegin == g_cxx.pToken
 249                         || cxxTokenTypeIsOneOf(pPartBegin, CXXTokenTypeSemicolon
 250                                                                    | CXXTokenTypeEOF))
 251                 {
 252                         cxxTokenChainClear(g_cxx.pTokenChain);
 253                         CXX_DEBUG_LEAVE_TEXT("Empty partition name");
 254                         return true;
 255                 }
 256
 257                 CXXToken * pPart = cxxTokenModuleTokenCreate(pPartBegin, g_cxx.pToken->pPrev);
 258                 if (pCurrentModuleToken)
 259                 {
 260                         CXXToken *pMod = cxxTokenCopy(pCurrentModuleToken);
 261                         cxxScopePush(pMod, CXXScopeTypeModule, CXXScopeAccessUnknown);
 262                 }
 263
 264                 tagEntryInfo * tag = cxxRefTagBegin(CXXTagCPPKindPARTITION,CXXTagPARTITIONRoleImported,pPart);
 265                 if (tag)
 266                 {
 267                         vString * pszProperties = uProperties ? cxxTagSetProperties(uProperties) : NULL;
 268                         cxxTagCommit(NULL);
 269                         vStringDelete(pszProperties); /* NULL is acceptable. */
 270                 }
 271                 cxxTokenDestroy(pPart);
 272
 273                 if (pCurrentModuleToken)
 274                         cxxScopePop();
 275         }
 276         else if (cxxTokenTypeIsOneOf(pFirst, CXXTokenTypeIdentifier))
 277         {
 278                 CXXToken *pModBegin = pFirst;
 279                 CXXToken * pSep = cxxTokenChainNextTokenOfType(pModBegin,
 280                                                                                                            CXXTokenTypeSingleColon
 281                                                                                                            | CXXTokenTypeSemicolon
 282                                                                                                            | CXXTokenTypeEOF);
 283                 bool bHasPart = (cxxTokenTypeIs(pSep, CXXTokenTypeSingleColon)
 284                                                  && pSep->pNext && cxxTokenTypeIs(pSep->pNext, CXXTokenTypeIdentifier)
 285                                                  && g_cxx.pToken->pPrev && g_cxx.pToken->pPrev != pSep);
 286
 287                 CXXToken * pMod = NULL;
 288                 {
 289                         pMod = cxxTokenModuleTokenCreate(pModBegin, pSep->pPrev);
 290                         tagEntryInfo * tag = cxxRefTagBegin(CXXTagCPPKindMODULE,
 291                                                                                                 bHasPart? CXXTagMODULERolePartOwner: CXXTagMODULERoleImported,
 292                                                                                                 pMod);
 293                         if (tag)
 294                         {
 295                                 vString * pszProperties = (!bHasPart && uProperties) ? cxxTagSetProperties(uProperties) : NULL;
 296
 297                                 cxxTagCommit(NULL);
 298                                 cxxScopePush(pMod, CXXScopeTypeModule, CXXScopeAccessUnknown);
 299                                 vStringDelete(pszProperties); /* NULL is acceptable. */
 300                         }
 301                         else
 302                         {
 303                                 cxxTokenDestroy(pMod);
 304                                 pMod = NULL;
 305                         }
 306                 }
 307
 308                 if (pMod && bHasPart)
 309                 {
 310                         CXXToken * pPart = cxxTokenModuleTokenCreate(pSep->pNext, g_cxx.pToken->pPrev);
 311
 312                         tagEntryInfo * tag = cxxRefTagBegin(CXXTagCPPKindPARTITION,
 313                                                                                                 CXXTagPARTITIONRoleImported, pPart);
 314                         if (tag)
 315                         {
 316                                 vString * pszProperties = uProperties ? cxxTagSetProperties(uProperties) : NULL;
 317
 318                                 cxxTagCommit(NULL);
 319                                 vStringDelete(pszProperties); /* NULL is acceptable */
 320                         }
 321                         cxxTokenDestroy(pPart);
 322                 }
 323
 324                 if (pMod)
 325                         cxxScopePop();
 326         }
 327
 328         cxxTokenChainClear(g_cxx.pTokenChain);
 329         CXX_DEBUG_LEAVE();
 330         return true;
 331 }