1 /****************************************************************************** 2 * 3 * 4 * 5 * Copyright (C) 1997-2015 by Dimitri van Heesch. 6 * 7 * Permission to use, copy, modify, and distribute this software and its 8 * documentation under the terms of the GNU General Public License is hereby 9 * granted. No representations are made about the suitability of this software 10 * for any purpose. It is provided "as is" without express or implied warranty. 11 * See the GNU General Public License for more details. 12 * 13 * Documents produced by Doxygen are derivative works derived from the 14 * input used in their production; they are not affected by this license. 15 * 16 */ 17 18 #ifndef ENTRY_H 19 #define ENTRY_H 20 21 #include <vector> 22 #include <memory> 23 #include <sstream> 24 25 #include "types.h" 26 #include "arguments.h" 27 #include "reflist.h" 28 #include "textstream.h" 29 30 class SectionInfo; 31 class FileDef; 32 33 /** This class stores information about an inheritance relation 34 */ 35 struct BaseInfo 36 { 37 /*! Creates an object representing an inheritance relation */ BaseInfoBaseInfo38 BaseInfo(const QCString &n,Protection p,Specifier v) : 39 name(n),prot(p),virt(v) {} 40 QCString name; //!< the name of the base class 41 Protection prot; //!< inheritance type 42 Specifier virt; //!< virtualness 43 }; 44 45 /** This struct is used to capture the tag file information 46 * for an Entry. 47 */ 48 struct TagInfo 49 { 50 QCString tagName; 51 QCString fileName; 52 QCString anchor; 53 }; 54 55 /** Represents an unstructured piece of information, about an 56 * entity found in the sources. 57 * 58 * parseMain() in scanner.l will generate a tree of these 59 * entries. 60 */ 61 class Entry 62 { 63 public: 64 65 /*! Kind of entries that are supported */ 66 enum Sections { 67 CLASS_SEC = 0x00000001, 68 NAMESPACE_SEC = 0x00000010, 69 CONCEPT_SEC = 0x00000020, 70 COMPOUND_MASK = CLASS_SEC, 71 SCOPE_MASK = COMPOUND_MASK | NAMESPACE_SEC, 72 73 CLASSDOC_SEC = 0x00000800, 74 STRUCTDOC_SEC = 0x00001000, 75 UNIONDOC_SEC = 0x00002000, 76 EXCEPTIONDOC_SEC = 0x00004000, 77 NAMESPACEDOC_SEC = 0x00008000, 78 INTERFACEDOC_SEC = 0x00010000, 79 PROTOCOLDOC_SEC = 0x00020000, 80 CATEGORYDOC_SEC = 0x00040000, 81 SERVICEDOC_SEC = 0x00080000, 82 SINGLETONDOC_SEC = 0x00100000, 83 CONCEPTDOC_SEC = 0x00200000, 84 COMPOUNDDOC_MASK = CLASSDOC_SEC | STRUCTDOC_SEC | UNIONDOC_SEC | 85 INTERFACEDOC_SEC | EXCEPTIONDOC_SEC | PROTOCOLDOC_SEC | 86 CATEGORYDOC_SEC | SERVICEDOC_SEC | SINGLETONDOC_SEC, 87 88 SOURCE_SEC = 0x00400000, 89 HEADER_SEC = 0x00800000, 90 FILE_MASK = SOURCE_SEC | HEADER_SEC, 91 92 ENUMDOC_SEC = 0x01000000, 93 ENUM_SEC = 0x02000000, 94 EMPTY_SEC = 0x03000000, 95 PAGEDOC_SEC = 0x04000000, 96 VARIABLE_SEC = 0x05000000, 97 FUNCTION_SEC = 0x06000000, 98 TYPEDEF_SEC = 0x07000000, 99 MEMBERDOC_SEC = 0x08000000, 100 OVERLOADDOC_SEC = 0x09000000, 101 EXAMPLE_SEC = 0x0a000000, 102 VARIABLEDOC_SEC = 0x0b000000, 103 FILEDOC_SEC = 0x0c000000, 104 DEFINEDOC_SEC = 0x0d000000, 105 INCLUDE_SEC = 0x0e000000, 106 DEFINE_SEC = 0x0f000000, 107 GROUPDOC_SEC = 0x10000000, 108 USINGDIR_SEC = 0x11000000, 109 MAINPAGEDOC_SEC = 0x12000000, 110 MEMBERGRP_SEC = 0x13000000, 111 USINGDECL_SEC = 0x14000000, 112 PACKAGE_SEC = 0x15000000, 113 PACKAGEDOC_SEC = 0x16000000, 114 OBJCIMPL_SEC = 0x17000000, 115 DIRDOC_SEC = 0x18000000, 116 EXPORTED_INTERFACE_SEC = 0x19000000, 117 INCLUDED_SERVICE_SEC = 0x1A000000, 118 EXAMPLE_LINENO_SEC = 0x1B000000, 119 }; 120 121 // class specifiers (add new items to the end) 122 static const uint64 Template = (1ULL<<0); 123 static const uint64 Generic = (1ULL<<1); 124 static const uint64 Ref = (1ULL<<2); 125 static const uint64 Value = (1ULL<<3); 126 static const uint64 Interface = (1ULL<<4); 127 static const uint64 Struct = (1ULL<<5); 128 static const uint64 Union = (1ULL<<6); 129 static const uint64 Exception = (1ULL<<7); 130 static const uint64 Protocol = (1ULL<<8); 131 static const uint64 Category = (1ULL<<9); 132 static const uint64 SealedClass = (1ULL<<10); 133 static const uint64 AbstractClass = (1ULL<<11); 134 static const uint64 Enum = (1ULL<<12); // for Java-style enums 135 static const uint64 Service = (1ULL<<13); // UNO IDL 136 static const uint64 Singleton = (1ULL<<14); // UNO IDL 137 static const uint64 ForwardDecl = (1ULL<<15); // forward declared template classes 138 static const uint64 Local = (1ULL<<16); // for Slice types 139 140 // member specifiers (add new items to the beginning) 141 static const uint64 EnumStruct = (1ULL<<18); 142 static const uint64 ConstExpr = (1ULL<<19); // C++11 constexpr 143 static const uint64 PrivateGettable = (1ULL<<20); // C# private getter 144 static const uint64 ProtectedGettable = (1ULL<<21); // C# protected getter 145 static const uint64 PrivateSettable = (1ULL<<22); // C# private setter 146 static const uint64 ProtectedSettable = (1ULL<<23); // C# protected setter 147 static const uint64 Inline = (1ULL<<24); 148 static const uint64 Explicit = (1ULL<<25); 149 static const uint64 Mutable = (1ULL<<26); 150 static const uint64 Settable = (1ULL<<27); 151 static const uint64 Gettable = (1ULL<<28); 152 static const uint64 Readable = (1ULL<<29); 153 static const uint64 Writable = (1ULL<<30); 154 static const uint64 Final = (1ULL<<31); 155 static const uint64 Abstract = (1ULL<<32); 156 static const uint64 Addable = (1ULL<<33); 157 static const uint64 Removable = (1ULL<<34); 158 static const uint64 Raisable = (1ULL<<35); 159 static const uint64 Override = (1ULL<<36); 160 static const uint64 New = (1ULL<<37); 161 static const uint64 Sealed = (1ULL<<38); 162 static const uint64 Initonly = (1ULL<<39); 163 static const uint64 Optional = (1ULL<<40); 164 static const uint64 Required = (1ULL<<41); 165 static const uint64 NonAtomic = (1ULL<<42); 166 static const uint64 Copy = (1ULL<<43); 167 static const uint64 Retain = (1ULL<<44); 168 static const uint64 Assign = (1ULL<<45); 169 static const uint64 Strong = (1ULL<<46); 170 static const uint64 Weak = (1ULL<<47); 171 static const uint64 Unretained = (1ULL<<48); 172 static const uint64 Alias = (1ULL<<49); 173 static const uint64 ConstExp = (1ULL<<50); 174 static const uint64 Default = (1ULL<<51); 175 static const uint64 Delete = (1ULL<<52); 176 static const uint64 NoExcept = (1ULL<<53); 177 static const uint64 Attribute = (1ULL<<54); // UNO IDL attribute 178 static const uint64 Property = (1ULL<<55); // UNO IDL property 179 static const uint64 Readonly = (1ULL<<56); // on UNO IDL attribute or property 180 static const uint64 Bound = (1ULL<<57); // on UNO IDL attribute or property 181 static const uint64 Constrained = (1ULL<<58); // on UNO IDL property 182 static const uint64 Transient = (1ULL<<59); // on UNO IDL property 183 static const uint64 MaybeVoid = (1ULL<<60); // on UNO IDL property 184 static const uint64 MaybeDefault = (1ULL<<61); // on UNO IDL property 185 static const uint64 MaybeAmbiguous = (1ULL<<62); // on UNO IDL property 186 static const uint64 Published = (1ULL<<63); // UNO IDL keyword 187 188 enum GroupDocType 189 { 190 GROUPDOC_NORMAL, //!< defgroup 191 GROUPDOC_ADD, //!< addtogroup 192 GROUPDOC_WEAK //!< weakgroup 193 }; //!< kind of group 194 195 Entry(); 196 Entry(const Entry &); 197 ~Entry(); 198 199 /*! Returns the parent for this Entry or 0 if this entry has no parent. */ parent()200 Entry *parent() const { return m_parent; } 201 202 /*! Returns the list of children for this Entry 203 * @see addSubEntry() and removeSubEntry() 204 */ children()205 const std::vector< std::shared_ptr<Entry> > &children() const { return m_sublist; } 206 207 /*! @name add entry as a child and pass ownership. 208 * @note This makes the entry passed invalid! 209 * @{ 210 */ 211 void moveToSubEntryAndKeep(Entry* e); 212 void moveToSubEntryAndKeep(std::shared_ptr<Entry> e); 213 /*! @} */ 214 215 /*! @name add entry as a child, pass ownership and reinitialize entry */ 216 void moveToSubEntryAndRefresh(Entry* &e); 217 void moveToSubEntryAndRefresh(std::shared_ptr<Entry> &e); 218 219 /*! make a copy of \a e and add it as a child to this entry */ 220 void copyToSubEntry (Entry* e); 221 void copyToSubEntry (const std::shared_ptr<Entry> &e); 222 223 /*! Removes entry \a e from the list of children. 224 * The entry will be deleted if found. 225 */ 226 void removeSubEntry(const Entry *e); 227 228 /*! Restore the state of this Entry to the default value it has 229 * at construction time. 230 */ 231 void reset(); 232 markAsProcessed()233 void markAsProcessed() const { ((Entry*)(this))->section = Entry::EMPTY_SEC; } 234 void setFileDef(FileDef *fd); fileDef()235 FileDef *fileDef() const { return m_fileDef; } 236 237 // identification 238 int section; //!< entry type (see Sections); 239 QCString type; //!< member type 240 QCString name; //!< member name 241 bool hasTagInfo; //!< is tag info valid 242 TagInfo tagInfoData; //!< tag file info data tagInfo()243 const TagInfo *tagInfo() const { return hasTagInfo ? &tagInfoData : 0; } 244 245 // content 246 Protection protection; //!< class protection 247 MethodTypes mtype; //!< signal, slot, (dcop) method, or property? 248 uint64 spec; //!< class/member specifiers 249 int initLines; //!< define/variable initializer lines to show 250 bool stat; //!< static ? 251 bool explicitExternal; //!< explicitly defined as external? 252 bool proto; //!< prototype ? 253 bool subGrouping; //!< automatically group class members? 254 bool callGraph; //!< do we need to draw the call graph? 255 bool callerGraph; //!< do we need to draw the caller graph? 256 bool referencedByRelation;//!< do we need to show the referenced by relation? 257 bool referencesRelation; //!< do we need to show the references relation? 258 Specifier virt; //!< virtualness of the entry 259 QCString args; //!< member argument string 260 QCString bitfields; //!< member's bit fields 261 ArgumentList argList; //!< member arguments as a list 262 ArgumentLists tArgLists; //!< template argument declarations 263 TextStream program; //!< the program text 264 TextStream initializer; //!< initial value (for variables) 265 QCString includeFile; //!< include file (2 arg of \\class, must be unique) 266 QCString includeName; //!< include name (3 arg of \\class) 267 QCString doc; //!< documentation block (partly parsed) 268 int docLine; //!< line number at which the documentation was found 269 QCString docFile; //!< file in which the documentation was found 270 QCString brief; //!< brief description (doc block) 271 int briefLine; //!< line number at which the brief desc. was found 272 QCString briefFile; //!< file in which the brief desc. was found 273 QCString inbodyDocs; //!< documentation inside the body of a function 274 int inbodyLine; //!< line number at which the body doc was found 275 QCString inbodyFile; //!< file in which the body doc was found 276 QCString relates; //!< related class (doc block) 277 RelatesType relatesType; //!< how relates is handled 278 QCString read; //!< property read accessor 279 QCString write; //!< property write accessor 280 QCString inside; //!< name of the class in which documents are found 281 QCString exception; //!< throw specification 282 ArgumentList typeConstr; //!< where clause (C#) for type constraints 283 int bodyLine; //!< line number of the body in the source 284 int bodyColumn; //!< column of the body in the source 285 int endBodyLine; //!< line number where the definition ends 286 int mGrpId; //!< member group id 287 std::vector<BaseInfo> extends; //!< list of base classes 288 std::vector<Grouping> groups; //!< list of groups this entry belongs to 289 std::vector<const SectionInfo*> anchors; //!< list of anchors defined in this entry 290 QCString fileName; //!< file this entry was extracted from 291 int startLine; //!< start line of entry in the source 292 int startColumn; //!< start column of entry in the source 293 RefItemVector sli; //!< special lists (test/todo/bug/deprecated/..) this entry is in 294 SrcLangExt lang; //!< programming language in which this entry was found 295 bool hidden; //!< does this represent an entity that is hidden from the output 296 bool artificial; //!< Artificially introduced item 297 GroupDocType groupDocType; 298 QCString id; //!< libclang id 299 LocalToc localToc; 300 QCString metaData; //!< Slice metadata 301 QCString req; //!< C++20 requires clause 302 303 /// return the command name used to define GROUPDOC_SEC groupDocCmd()304 const char *groupDocCmd() const 305 { 306 switch( groupDocType ) 307 { 308 case GROUPDOC_NORMAL: return "\\defgroup"; 309 case GROUPDOC_ADD: return "\\addtogroup"; 310 case GROUPDOC_WEAK: return "\\weakgroup"; 311 default: return "unknown group command"; 312 } 313 } groupingPri()314 Grouping::GroupPri_t groupingPri() const 315 { 316 if( section != GROUPDOC_SEC ) 317 { 318 return Grouping::GROUPING_LOWEST; 319 } 320 switch( groupDocType ) 321 { 322 case GROUPDOC_NORMAL: return Grouping::GROUPING_AUTO_DEF; 323 case GROUPDOC_ADD: return Grouping::GROUPING_AUTO_ADD; 324 case GROUPDOC_WEAK: return Grouping::GROUPING_AUTO_WEAK; 325 default: return Grouping::GROUPING_LOWEST; 326 } 327 } 328 329 private: 330 Entry *m_parent; //!< parent node in the tree 331 std::vector< std::shared_ptr<Entry> > m_sublist; 332 Entry &operator=(const Entry &); 333 FileDef *m_fileDef; 334 }; 335 336 typedef std::vector< std::shared_ptr<Entry> > EntryList; 337 338 #endif 339