Lines Matching defs:I
35 for (int I = 0, E = R[0]; I < E; ++I)
36 Field[I] = R[I + 1];
151 NamespaceInfo *I) {
154 return decodeRecord(R, I->USR, Blob);
156 return decodeRecord(R, I->Name, Blob);
158 return decodeRecord(R, I->Path, Blob);
166 RecordInfo *I) {
169 return decodeRecord(R, I->USR, Blob);
171 return decodeRecord(R, I->Name, Blob);
173 return decodeRecord(R, I->Path, Blob);
175 return decodeRecord(R, I->DefLoc, Blob);
177 return decodeRecord(R, I->Loc, Blob);
179 return decodeRecord(R, I->TagType, Blob);
181 return decodeRecord(R, I->IsTypeDef, Blob);
189 BaseRecordInfo *I) {
192 return decodeRecord(R, I->USR, Blob);
194 return decodeRecord(R, I->Name, Blob);
196 return decodeRecord(R, I->Path, Blob);
198 return decodeRecord(R, I->TagType, Blob);
200 return decodeRecord(R, I->IsVirtual, Blob);
202 return decodeRecord(R, I->Access, Blob);
204 return decodeRecord(R, I->IsParent, Blob);
212 EnumInfo *I) {
215 return decodeRecord(R, I->USR, Blob);
217 return decodeRecord(R, I->Name, Blob);
219 return decodeRecord(R, I->DefLoc, Blob);
221 return decodeRecord(R, I->Loc, Blob);
223 return decodeRecord(R, I->Scoped, Blob);
231 TypedefInfo *I) {
234 return decodeRecord(R, I->USR, Blob);
236 return decodeRecord(R, I->Name, Blob);
238 return decodeRecord(R, I->DefLoc, Blob);
240 return decodeRecord(R, I->IsUsing, Blob);
248 EnumValueInfo *I) {
251 return decodeRecord(R, I->Name, Blob);
253 return decodeRecord(R, I->Value, Blob);
255 return decodeRecord(R, I->ValueExpr, Blob);
263 FunctionInfo *I) {
266 return decodeRecord(R, I->USR, Blob);
268 return decodeRecord(R, I->Name, Blob);
270 return decodeRecord(R, I->DefLoc, Blob);
272 return decodeRecord(R, I->Loc, Blob);
274 return decodeRecord(R, I->Access, Blob);
276 return decodeRecord(R, I->IsMethod, Blob);
284 TypeInfo *I) {
289 FieldTypeInfo *I) {
292 return decodeRecord(R, I->Name, Blob);
294 return decodeRecord(R, I->DefaultValue, Blob);
302 MemberTypeInfo *I) {
305 return decodeRecord(R, I->Name, Blob);
307 return decodeRecord(R, I->Access, Blob);
315 CommentInfo *I) {
318 return decodeRecord(R, I->Kind, Blob);
320 return decodeRecord(R, I->Text, Blob);
322 return decodeRecord(R, I->Name, Blob);
324 return decodeRecord(R, I->Direction, Blob);
326 return decodeRecord(R, I->ParamName, Blob);
328 return decodeRecord(R, I->CloseName, Blob);
330 return decodeRecord(R, I->AttrKeys, Blob);
332 return decodeRecord(R, I->AttrValues, Blob);
334 return decodeRecord(R, I->Args, Blob);
336 return decodeRecord(R, I->SelfClosing, Blob);
338 return decodeRecord(R, I->Explicit, Blob);
346 Reference *I, FieldId &F) {
349 return decodeRecord(R, I->USR, Blob);
351 return decodeRecord(R, I->Name, Blob);
353 return decodeRecord(R, I->QualName, Blob);
355 return decodeRecord(R, I->RefType, Blob);
357 return decodeRecord(R, I->Path, Blob);
367 TemplateInfo *I) {
374 TemplateSpecializationInfo *I) {
376 return decodeRecord(R, I->SpecializationOf, Blob);
382 TemplateParamInfo *I) {
384 return decodeRecord(R, I->Contents, Blob);
389 template <typename T> llvm::Expected<CommentInfo *> getCommentInfo(T I) {
394 template <> llvm::Expected<CommentInfo *> getCommentInfo(FunctionInfo *I) {
395 return &I->Description.emplace_back();
398 template <> llvm::Expected<CommentInfo *> getCommentInfo(NamespaceInfo *I) {
399 return &I->Description.emplace_back();
402 template <> llvm::Expected<CommentInfo *> getCommentInfo(RecordInfo *I) {
403 return &I->Description.emplace_back();
406 template <> llvm::Expected<CommentInfo *> getCommentInfo(MemberTypeInfo *I) {
407 return &I->Description.emplace_back();
410 template <> llvm::Expected<CommentInfo *> getCommentInfo(EnumInfo *I) {
411 return &I->Description.emplace_back();
414 template <> llvm::Expected<CommentInfo *> getCommentInfo(TypedefInfo *I) {
415 return &I->Description.emplace_back();
418 template <> llvm::Expected<CommentInfo *> getCommentInfo(EnumValueInfo *I) {
419 return &I->Description.emplace_back();
422 template <> llvm::Expected<CommentInfo *> getCommentInfo(CommentInfo *I) {
423 I->Children.emplace_back(std::make_unique<CommentInfo>());
424 return I->Children.back().get();
428 llvm::Expected<CommentInfo *> getCommentInfo(std::unique_ptr<CommentInfo> &I) {
429 return getCommentInfo(I.get());
436 llvm::Error addTypeInfo(T I, TTypeInfo &&TI) {
441 template <> llvm::Error addTypeInfo(RecordInfo *I, MemberTypeInfo &&T) {
442 I->Members.emplace_back(std::move(T));
446 template <> llvm::Error addTypeInfo(BaseRecordInfo *I, MemberTypeInfo &&T) {
447 I->Members.emplace_back(std::move(T));
451 template <> llvm::Error addTypeInfo(FunctionInfo *I, TypeInfo &&T) {
452 I->ReturnType = std::move(T);
456 template <> llvm::Error addTypeInfo(FunctionInfo *I, FieldTypeInfo &&T) {
457 I->Params.emplace_back(std::move(T));
461 template <> llvm::Error addTypeInfo(EnumInfo *I, TypeInfo &&T) {
462 I->BaseType = std::move(T);
466 template <> llvm::Error addTypeInfo(TypedefInfo *I, TypeInfo &&T) {
467 I->Underlying = std::move(T);
471 template <typename T> llvm::Error addReference(T I, Reference &&R, FieldId F) {
476 template <> llvm::Error addReference(TypeInfo *I, Reference &&R, FieldId F) {
479 I->Type = std::move(R);
488 llvm::Error addReference(FieldTypeInfo *I, Reference &&R, FieldId F) {
491 I->Type = std::move(R);
500 llvm::Error addReference(MemberTypeInfo *I, Reference &&R, FieldId F) {
503 I->Type = std::move(R);
511 template <> llvm::Error addReference(EnumInfo *I, Reference &&R, FieldId F) {
514 I->Namespace.emplace_back(std::move(R));
522 template <> llvm::Error addReference(TypedefInfo *I, Reference &&R, FieldId F) {
525 I->Namespace.emplace_back(std::move(R));
534 llvm::Error addReference(NamespaceInfo *I, Reference &&R, FieldId F) {
537 I->Namespace.emplace_back(std::move(R));
540 I->Children.Namespaces.emplace_back(std::move(R));
543 I->Children.Records.emplace_back(std::move(R));
552 llvm::Error addReference(FunctionInfo *I, Reference &&R, FieldId F) {
555 I->Namespace.emplace_back(std::move(R));
558 I->Parent = std::move(R);
566 template <> llvm::Error addReference(RecordInfo *I, Reference &&R, FieldId F) {
569 I->Namespace.emplace_back(std::move(R));
572 I->Parents.emplace_back(std::move(R));
575 I->VirtualParents.emplace_back(std::move(R));
578 I->Children.Records.emplace_back(std::move(R));
587 void addChild(T I, ChildInfoType &&R) {
593 template <> void addChild(NamespaceInfo *I, FunctionInfo &&R) {
594 I->Children.Functions.emplace_back(std::move(R));
596 template <> void addChild(NamespaceInfo *I, EnumInfo &&R) {
597 I->Children.Enums.emplace_back(std::move(R));
599 template <> void addChild(NamespaceInfo *I, TypedefInfo &&R) {
600 I->Children.Typedefs.emplace_back(std::move(R));
604 template <> void addChild(RecordInfo *I, FunctionInfo &&R) {
605 I->Children.Functions.emplace_back(std::move(R));
607 template <> void addChild(RecordInfo *I, EnumInfo &&R) {
608 I->Children.Enums.emplace_back(std::move(R));
610 template <> void addChild(RecordInfo *I, TypedefInfo &&R) {
611 I->Children.Typedefs.emplace_back(std::move(R));
615 template <> void addChild(EnumInfo *I, EnumValueInfo &&R) {
616 I->Members.emplace_back(std::move(R));
618 template <> void addChild(RecordInfo *I, BaseRecordInfo &&R) {
619 I->Bases.emplace_back(std::move(R));
621 template <> void addChild(BaseRecordInfo *I, FunctionInfo &&R) {
622 I->Children.Functions.emplace_back(std::move(R));
628 template <typename T> void addTemplateParam(T I, TemplateParamInfo &&P) {
632 template <> void addTemplateParam(TemplateInfo *I, TemplateParamInfo &&P) {
633 I->Params.emplace_back(std::move(P));
636 void addTemplateParam(TemplateSpecializationInfo *I, TemplateParamInfo &&P) {
637 I->Params.emplace_back(std::move(P));
641 template <typename T> void addTemplate(T I, TemplateInfo &&P) {
645 template <> void addTemplate(RecordInfo *I, TemplateInfo &&P) {
646 I->Template.emplace(std::move(P));
648 template <> void addTemplate(FunctionInfo *I, TemplateInfo &&P) {
649 I->Template.emplace(std::move(P));
654 void addTemplateSpecialization(T I, TemplateSpecializationInfo &&TSI) {
659 void addTemplateSpecialization(TemplateInfo *I,
661 I->Specialization.emplace(std::move(TSI));
666 llvm::Error ClangDocBitcodeReader::readRecord(unsigned ID, T I) {
672 return parseRecord(R, MaybeRecID.get(), Blob, I);
676 llvm::Error ClangDocBitcodeReader::readRecord(unsigned ID, Reference *I) {
682 return parseRecord(R, MaybeRecID.get(), Blob, I, CurrentReferenceField);
687 llvm::Error ClangDocBitcodeReader::readBlock(unsigned ID, T I) {
702 if (llvm::Error Err = readSubBlock(BlockOrCode, I)) {
711 if (auto Err = readRecord(BlockOrCode, I))
717 llvm::Error ClangDocBitcodeReader::readSubBlock(unsigned ID, T I) {
721 auto Comment = getCommentInfo(I);
732 if (auto Err = addTypeInfo(I, std::move(TI)))
740 if (auto Err = addTypeInfo(I, std::move(TI)))
748 if (auto Err = addTypeInfo(I, std::move(TI)))
756 if (auto Err = addReference(I, std::move(R), CurrentReferenceField))
764 addChild(I, std::move(F));
771 addChild(I, std::move(BR));
778 addChild(I, std::move(E));
785 addChild(I, std::move(EV));
792 addTemplate(I, std::move(TI));
799 addTemplateSpecialization(I, std::move(TSI));
806 addTemplateParam(I, std::move(TPI));
813 addChild(I, std::move(TI));
901 std::unique_ptr<Info> I = std::make_unique<T>();
902 if (auto Err = readBlock(ID, static_cast<T *>(I.get())))
904 return std::unique_ptr<Info>{std::move(I)};