ctags/parsers/cxx/cxx_qtmoc.c

   1 /*
   2  *  Copyright (c) 2017, Red Hat, Inc.
   3 *   Copyright (c) 2017, Masatake YAMATO
   4 *
   5 *   This source code is released for free distribution under the terms of the
   6 *   GNU General Public License version 2 or (at your option) any later version.
   7 *
   8 *   This module contains functions for handling Qt Moc tokens
   9 */
  10
  11 #include "general.h"
  12
  13 #include "types.h"
  14
  15 #include "debug.h"
  16 #include "cxx_debug.h"
  17
  18 #include "cxx_scope.h"
  19 #include "cxx_parser_internal.h"
  20
  21 #include "cxx_subparser.h"
  22
  23 #include "keyword.h"
  24 #include "read.h"
  25
  26 #include <string.h>
  27
  28
  29 typedef enum {
  30         K_SLOT,
  31         K_SIGNAL,
  32         K_PROPERTY,
  33 } qtMocKind;
  34
  35 static kindDefinition QtMocKinds [] = {
  36         { true, 's', "slot", "slots" },
  37         { true, 'S', "signal", "signals" },
  38         { true, 'p', "property", "properties" },
  39 };
  40
  41 enum {
  42         KEYWORD_QOBJECT,
  43         KEYWORD_SIGNALS,
  44         KEYWORD_SLOTS,
  45         KEYWORD_PROPERTY,
  46 };
  47
  48 typedef int keywordId; /* to allow KEYWORD_NONE */
  49
  50 static const keywordTable QtMocKeywordTable[] = {
  51         /* keyword                      keyword ID */
  52         { "Q_OBJECT",   KEYWORD_QOBJECT  },
  53         { "Q_SIGNALS",  KEYWORD_SIGNALS  },
  54         { "signals",    KEYWORD_SIGNALS  },
  55         { "Q_SLOTS",    KEYWORD_SLOTS    },
  56         { "slots",              KEYWORD_SLOTS    },
  57         { "Q_PROPERTY", KEYWORD_PROPERTY },
  58 };
  59
  60 enum QtMocMemberMarker
  61 {
  62         QtMocMemberMarkerNone = 0,
  63         QtMocMemberMarkerSlot,
  64         QtMocMemberMarkerSignal,
  65 };
  66
  67 struct sQtMocSubparser {
  68         struct sCxxSubparser cxx;
  69         int iBlockDepth;
  70         int iDepthOfQtClass;
  71         enum QtMocMemberMarker eMemberMarker;
  72 };
  73
  74 static langType Lang_QtMoc;
  75
  76 static bool cxxParserSkipToClosingParenthesisOrEOF(void)
  77 {
  78         if(cxxTokenTypeIsOneOf(g_cxx.pToken,CXXTokenTypeClosingParenthesis | CXXTokenTypeEOF))
  79                 return true;
  80
  81         return cxxParserParseUpToOneOf(CXXTokenTypeClosingParenthesis | CXXTokenTypeEOF,
  82                                                                    false);
  83 }
  84
  85 static void qtMocMakeTagForProperty (CXXToken * pToken, const char *pszType)
  86 {
  87         tagEntryInfo tag;
  88
  89         initTagEntry(&tag,
  90                                  vStringValue(pToken->pszWord),
  91                                  K_PROPERTY);
  92         updateTagLine (&tag, pToken->iLineNumber, pToken->oFilePosition);
  93         tag.isFileScope = false;
  94
  95         if(!cxxScopeIsGlobal())
  96         {
  97                 tag.extensionFields.scopeLangType = getNamedLanguage ("C++", 0); /* ??? */
  98                 tag.extensionFields.scopeKindIndex = cxxScopeGetKind();
  99                 tag.extensionFields.scopeName = cxxScopeGetFullName();
 100         }
 101
 102         tag.extensionFields.typeRef[0] = "typename";
 103         tag.extensionFields.typeRef[1] = pszType;
 104
 105         makeTagEntry(&tag);
 106 }
 107
 108 static bool qtMocParseProperty(void)
 109 {
 110         char *pszPropType;
 111
 112         CXX_DEBUG_ENTER();
 113
 114         if(!cxxParserParseNextToken())
 115         {
 116                 CXX_DEBUG_LEAVE_TEXT("EOF in cxxParserParseNextToken");
 117                 return false;
 118         }
 119         if (!cxxTokenTypeIs(g_cxx.pToken, CXXTokenTypeOpeningParenthesis))
 120         {
 121                 CXX_DEBUG_LEAVE_TEXT("Found no Opening Parenthesis after Q_PROPERTY");
 122                 return false;
 123         }
 124
 125         if (!cxxParserParseNextToken())
 126         {
 127                 CXX_DEBUG_LEAVE_TEXT("EOF in cxxParserParseNextToken");
 128                 return false;
 129         }
 130         if (!(cxxTokenTypeIs(g_cxx.pToken, CXXTokenTypeIdentifier)
 131                   || (cxxTokenTypeIs(g_cxx.pToken, CXXTokenTypeKeyword)
 132                           && cxxKeywordMayBePartOfTypeName (g_cxx.pToken->eKeyword))))
 133
 134         {
 135                 CXX_DEBUG_LEAVE_TEXT("Found no identifier after Q_PROPERTY(");
 136
 137                 cxxParserSkipToClosingParenthesisOrEOF ();
 138                 return false;
 139         }
 140
 141         pszPropType = vStringStrdup (g_cxx.pToken->pszWord);
 142         if(!cxxParserParseNextToken())
 143         {
 144                 CXX_DEBUG_LEAVE_TEXT("EOF in cxxParserParseNextToken");
 145                 eFree (pszPropType);
 146                 return false;
 147         }
 148
 149         if (!cxxTokenTypeIs(g_cxx.pToken, CXXTokenTypeIdentifier))
 150         {
 151                 CXX_DEBUG_LEAVE_TEXT("Found no identifier after Q_PROPERTY(%s", pszPropType);
 152                 cxxParserSkipToClosingParenthesisOrEOF ();
 153                 eFree (pszPropType);
 154                 return false;
 155         }
 156
 157         qtMocMakeTagForProperty (g_cxx.pToken, pszPropType);
 158
 159         eFree (pszPropType);
 160         cxxParserSkipToClosingParenthesisOrEOF ();
 161
 162         CXX_DEBUG_LEAVE();
 163         return true;
 164 }
 165
 166 static void inputStart(subparser *s)
 167 {
 168         struct sQtMocSubparser *pQtMoc = (struct sQtMocSubparser*)s;
 169
 170         pQtMoc->iBlockDepth = 0;
 171         pQtMoc->iDepthOfQtClass = 0;
 172         pQtMoc->eMemberMarker = QtMocMemberMarkerNone;
 173 }
 174
 175 static void makeTagEntryNotify (subparser *s, const tagEntryInfo *entry, int corkIndex)
 176 {
 177         struct sQtMocSubparser *pQtMoc = (struct sQtMocSubparser*)s;
 178
 179         if (pQtMoc->iDepthOfQtClass == 0)
 180                 return;
 181
 182         if ((pQtMoc->eMemberMarker != QtMocMemberMarkerNone) &&
 183                 entry->kindIndex == CXXTagKindPROTOTYPE)
 184         {
 185                 tagEntryInfo parasiteTag = *entry;
 186                 parasiteTag.langType = getInputLanguage ();
 187                 parasiteTag.kindIndex = (pQtMoc->eMemberMarker == QtMocMemberMarkerSlot)
 188                         ? K_SLOT
 189                         : K_SIGNAL;
 190
 191                 parasiteTag.extensionFields.scopeLangType = entry->langType;
 192                 makeTagEntry (&parasiteTag);
 193         }
 194 }
 195
 196 static void enterBlockNotify (struct sCxxSubparser *pSubparser)
 197 {
 198         struct sQtMocSubparser *pQtMoc = (struct sQtMocSubparser *)pSubparser;
 199
 200         pQtMoc->iBlockDepth++;
 201 }
 202
 203 static void leaveBlockNotify (struct sCxxSubparser *pSubparser)
 204 {
 205         struct sQtMocSubparser *pQtMoc = (struct sQtMocSubparser *)pSubparser;
 206
 207         if (pQtMoc->iDepthOfQtClass == pQtMoc->iBlockDepth)
 208                 pQtMoc->iDepthOfQtClass = 0;
 209
 210         pQtMoc->iBlockDepth--;
 211 }
 212
 213 static bool newIdentifierAsHeadOfMemberNotify (struct sCxxSubparser *pSubparser,
 214                                                                                            CXXToken *pToken)
 215 {
 216         struct sQtMocSubparser *pQtMoc = (struct sQtMocSubparser *)pSubparser;
 217         keywordId keyword = lookupKeyword (vStringValue (pToken->pszWord), Lang_QtMoc);
 218
 219         if (keyword == KEYWORD_QOBJECT)
 220         {
 221                 if (pQtMoc->iDepthOfQtClass == 0)
 222                         pQtMoc->iDepthOfQtClass = pQtMoc->iBlockDepth;
 223                 CXX_DEBUG_PRINT("Found \"Q_OBJECT\" Qt Object Marker in depth: %d",
 224                                                 pQtMoc->iDepthOfQtClass);
 225                 return true;
 226         }
 227         return false;
 228 }
 229
 230 static bool unknownIdentifierInClassNotify (struct sCxxSubparser *pSubparser,
 231                                                                                         CXXToken *pToken)
 232 {
 233         struct sQtMocSubparser *pQtMoc = (struct sQtMocSubparser *)pSubparser;
 234
 235         if (pQtMoc->iDepthOfQtClass == 0)
 236                 return false;
 237
 238         keywordId keyword = lookupKeyword (vStringValue (pToken->pszWord), Lang_QtMoc);
 239
 240         switch (keyword)
 241         {
 242         case KEYWORD_SIGNALS:
 243                 CXX_DEBUG_PRINT("Found \"signals\" QtMoc Keyword");
 244                 pToken->eType = CXXTokenTypeKeyword;
 245                 pToken->eKeyword = CXXKeywordPUBLIC;
 246                 cxxParserParseAccessSpecifier();
 247                 pQtMoc->eMemberMarker = QtMocMemberMarkerSignal;
 248                 return true;
 249         case KEYWORD_SLOTS:
 250                 CXX_DEBUG_PRINT("Found \"slots\" QtMoc Keyword");
 251                 pToken->eType = CXXTokenTypeKeyword;
 252                 g_cxx.pToken->eKeyword = CXXKeywordPUBLIC; /* ??? */
 253                 cxxParserParseAccessSpecifier();
 254                 pQtMoc->eMemberMarker = QtMocMemberMarkerSlot;
 255                 return true;
 256         case KEYWORD_PROPERTY:
 257                 CXX_DEBUG_PRINT("Found \"Q_PROPERTY\" QtMoc Keyword");
 258                 qtMocParseProperty ();
 259                 return true;
 260         default:
 261                 break;
 262         }
 263
 264         return false;
 265 }
 266
 267 static bool parseAccessSpecifierNotify(struct sCxxSubparser *pSubparser)
 268 {
 269         struct sQtMocSubparser *pQtMoc = (struct sQtMocSubparser *)pSubparser;
 270
 271         if (pQtMoc->iBlockDepth > 0)
 272         {
 273                 CXX_DEBUG_PRINT("Reset QtMoc member marker state");
 274                 pQtMoc->eMemberMarker = QtMocMemberMarkerNone;
 275                 return true;
 276         }
 277         return false;
 278 }
 279
 280 static void foundExtraIdentifierAsAccessSpecifier(struct sCxxSubparser *pSubparser,
 281                                                                                                   CXXToken *pToken)
 282 {
 283         struct sQtMocSubparser *pQtMoc = (struct sQtMocSubparser *)pSubparser;
 284         keywordId keyword = lookupKeyword (vStringValue (pToken->pszWord), Lang_QtMoc);
 285
 286         if (keyword == KEYWORD_SLOTS)
 287         {
 288                 CXX_DEBUG_PRINT("Found \"slots\" QtMoc Keyword");
 289                 pQtMoc->eMemberMarker = QtMocMemberMarkerSlot;
 290         }
 291 }
 292
 293 static void findQtMocTags(void)
 294 {
 295         scheduleRunningBaseparser (0);
 296 }
 297
 298 static void initialize (langType lang)
 299 {
 300         Lang_QtMoc = lang;
 301 }
 302
 303 extern parserDefinition* QtMocParser (void)
 304 {
 305         parserDefinition* const def = parserNew("QtMoc");
 306
 307         static struct sQtMocSubparser qtMocSubparser = {
 308                 .cxx = {
 309                         .subparser = {
 310                                 .direction = SUBPARSER_BI_DIRECTION,
 311                                 .inputStart = inputStart,
 312                                 .makeTagEntryNotify = makeTagEntryNotify,
 313                         },
 314                         .enterBlockNotify = enterBlockNotify,
 315                         .leaveBlockNotify = leaveBlockNotify,
 316                         .newIdentifierAsHeadOfMemberNotify = newIdentifierAsHeadOfMemberNotify,
 317                         .unknownIdentifierInClassNotify = unknownIdentifierInClassNotify,
 318                         .parseAccessSpecifierNotify = parseAccessSpecifierNotify,
 319                         .foundExtraIdentifierAsAccessSpecifier = foundExtraIdentifierAsAccessSpecifier,
 320                 }
 321                 /* The rest fields are initialized in inputStart(). */
 322         };
 323         static parserDependency dependencies [] = {
 324                 [0] = { DEPTYPE_SUBPARSER, "C++", &qtMocSubparser },
 325         };
 326
 327         def->dependencies = dependencies;
 328         def->dependencyCount = ARRAY_SIZE (dependencies);
 329
 330         def->kindTable = QtMocKinds;
 331         def->kindCount = ARRAY_SIZE(QtMocKinds);
 332
 333         def->keywordTable = QtMocKeywordTable;
 334         def->keywordCount = ARRAY_SIZE (QtMocKeywordTable);
 335
 336         def->parser = findQtMocTags;
 337         def->initialize = initialize;
 338         def->useCork = CORK_QUEUE;
 339
 340         return def;
 341 }