Lines Matching +defs:list +defs:string
39 #include <string>
75 const std::string &TargetTest, uint32_t ArgMask)
80 std::string TargetTest;
89 std::string &Test,
90 std::string *FnName);
119 static std::string ReadPCHRecord(StringRef type) {
120 return StringSwitch<std::string>(type)
134 .Case("StringRef", "std::string")
139 static std::string WritePCHRecord(StringRef type, StringRef name) {
141 StringSwitch<std::string>(type)
180 typedef std::vector<std::pair<std::string, const Record *>> ParsedAttrMap;
185 std::set<std::string> Seen;
189 std::string AN;
213 std::string lowerName, upperName;
261 virtual std::string getIsOmitted() const { return "false"; }
277 std::string type;
280 SimpleArgument(const Record &Arg, StringRef Attr, std::string T)
283 std::string getType() const { return type; }
316 std::string read = ReadPCHRecord(type);
329 std::string getIsOmitted() const override {
330 auto IsOneOf = [](StringRef subject, auto... list) {
331 return ((subject == list) || ...);
352 // empty string but are then recorded as a nullptr.
371 // empty string but are then recorded as a nullptr.
403 std::string T, int64_t Default)
478 OS << " std::string " << getLowerName()
640 std::string getIsOmitted() const override {
676 std::string Type, ArgName, ArgSizeName, RangeName;
689 VariadicArgument(const Record &Arg, StringRef Attr, std::string T)
694 VariadicArgument(StringRef Arg, StringRef Attr, std::string T)
699 const std::string &getType() const { return Type; }
700 const std::string &getArgName() const { return ArgName; }
701 const std::string &getArgSizeName() const { return ArgSizeName; }
705 std::string IteratorType = getLowerName().str() + "_iterator";
706 std::string BeginFn = getLowerName().str() + "_begin()";
707 std::string EndFn = getLowerName().str() + "_end()";
786 std::string StorageType = getStorageType(getType()).str();
787 std::string StorageName = getLowerName().str();
797 std::string read = ReadPCHRecord(Type);
908 std::string fullType;
924 // string.
991 // as a string literal, while others require printing as an identifier.
1057 std::string fullType;
1066 // as a string literal, while others require printing as an identifier.
1084 // string.
1668 // To avoid printing parentheses around an empty argument list or
1669 // printing spurious commas at the end of an argument list, we need to
1690 std::string IsOmitted = arg->getIsOmitted();
1718 /// Return the index of a spelling in a spelling list.
1721 assert(!SpellingList.empty() && "Spelling list is empty!");
1739 "Attribute with empty spelling list can't have accessors!");
1758 assert(!Spellings.empty() && "An empty list of spellings was provided");
1769 typedef std::map<unsigned, std::string> SemanticSpellingMap;
1770 static std::string
1777 std::string Ret(" enum Spelling {\n");
1778 std::set<std::string> Uniques;
1792 std::string EnumName;
1828 << "llvm_unreachable(\"Unknown spelling list index\");\n";
1976 std::string getSpelling() const {
1977 std::string Result = MetaSubject->getValueAsString("Name").str();
1990 std::string getEnumValueName() const {
2002 return std::string(Result);
2005 std::string getEnumValue() const { return "attr::" + getEnumValueName(); }
2197 // An attribute subject list has a subject that isn't covered by one of the
2213 static std::string GenerateTestExpression(ArrayRef<const Record *> LangOpts) {
2214 std::string Test;
2323 std::string SubRuleFunction;
2391 std::string TargetTest;
2558 // Emits the list of arguments that should be parsed as unevaluated string
2570 // If we have a variadic string argument, set all the remaining bits to 1
2581 // Determine whether there are any string arguments.
2607 // Emits the list for attributes having StrictEnumParameters.
2715 std::string SuperName;
2795 std::string SpellingEnum;
2802 find_if(AttrMap, [R](const std::pair<std::string, const Record *> &P) {
2922 std::set<std::string> Uniques;
3106 assert(!SemanticToSyntacticMap.empty() && "Empty semantic mapping list");
3412 // TableGen flattens the superclass list, so we just need to walk it
3427 // Emits the enumeration list for attributes.
3451 // Emit the main attribute list.
3467 // Emits the enumeration list for attributes.
3568 static bool GenerateTargetSpecificAttrCheck(const Record *R, std::string &Test,
3569 std::string *FnName,
3595 // those checks to the Test string. If the FnName string pointer is non-null,
3600 std::string &Test,
3601 std::string *FnName) {
3610 // differently because GenerateTargetRequirements needs to combine the list
3671 std::string Name = "";
3688 std::string Test;
3711 std::string TestStr = !Test.empty()
3722 // Emits list of regular keyword attributes with info about their arguments.
3726 "A list of regular keyword attributes generated from the attribute"
3776 // Emits the list of spellings for attributes.
3787 // Walk over the list of all attributes, and split them out based on the
4074 // Emits the list of parsed attributes.
4117 static std::string GetDiagnosticSpelling(const Record &R) {
4131 static std::string CalculateDiagnostic(const Record &S) {
4138 std::vector<std::string> DiagList;
4142 std::string V = GetDiagnosticSpelling(R);
4148 // The node may contain a list of elements itself, so split the elements
4165 // should be part of the diagnostics engine itself with some sort of list
4168 // A single member of the list can be returned directly.
4175 // If there are more than two in the list, we serialize the first N - 1
4176 // elements with a comma. This leaves the string in the state: foo, bar,
4179 std::string Diag = join(DiagList.begin(), DiagList.end() - 1, ", ");
4183 static std::string GetSubjectWithSuffix(const Record *R) {
4184 const std::string B = R->getName().str();
4190 static std::string functionNameForCustomAppertainsTo(const Record &Subject) {
4195 std::string FnName = functionNameForCustomAppertainsTo(Subject);
4198 static std::set<std::string> CustomSubjectSet;
4234 // If the list of subjects is empty, it is assumed that the attribute
4242 // FIXME: subset subjects are added to the declaration list until there are
4358 std::vector<std::string> DeclAttrs, StmtAttrs;
4361 // the given attribute in the list of exclusions to generate the
4371 // This list of exclusions includes the attribute we're looking for, so
4372 // add the exclusive attributes to the proper list for checking.
4396 for (const std::string &A : DeclAttrs) {
4416 for (const std::string &A : DeclAttrs) {
4440 // the given list of semantic attributes contain any conflicts. It is assumed
4446 // FIXME: it would be nice not to walk over the list of potential attributes
4448 // have long lists of attributes on them, so re-walking the list should not
4510 // If the attribute has an empty or unset list of language requirements,
4529 // Get the list of architectures to be tested for.
4551 std::string FnName = "isTarget";
4552 std::string Test;
4570 std::string Test;
4591 std::string FnName = "isTargetSpelling";
4621 std::string Enum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
4622 std::string Name = Attr.getName().str() + "AttrSpellingMap";
4711 // Get the list of parsed attributes, and accept the optional list of
4731 std::string DeclMergeChecks, StmtMergeChecks;
4736 // TODO: If the attribute's kind appears in the list of duplicates, that is
4744 const std::string &AttrName = I->first;
4752 std::string Spelling;
4765 std::vector<std::string> ArgNames;
4866 // Emits the kind list of parsed attributes
4888 // generate a list of string to match based on the syntax, and emit
4889 // multiple string matchers depending on the syntax used.
4890 std::string AttrName;
4905 std::string Spelling;
4983 std::string FunctionContent;
5017 std::string FunctionContent;
5089 std::vector<std::string> Spellings[NumSpellingKinds];
5092 ArrayRef<std::string> operator[](SpellingKind K) const {
5107 std::string Name;
5133 std::string Heading;
5137 std::pair<std::string, SpellingList> HeadingAndSpellings)
5146 OS << Name << "\n" << std::string(Name.size(), '=') << "\n";
5156 static std::pair<std::string, SpellingList>
5171 std::string Heading = Documentation.getValueAsString("Heading").str();
5177 std::set<std::string> Uniques;
5180 std::string Spelling =
5213 OS << Doc.Heading << "\n" << std::string(Doc.Heading.length(), '-') << "\n";