//
//===----------------------------------------------------------------------===//
-#define _LIBCPP_EXTERN_TEMPLATE(...)
+// FIXME: (possibly) incomplete list of features that clang mangles that this
+// file does not yet support:
+// - enable_if attribute
+// - decomposition declarations
+// - C++ modules TS
+
#define _LIBCPP_NO_EXCEPTIONS
#include "__cxxabi_config.h"
#include <vector>
#include <algorithm>
-#include <string>
#include <numeric>
+#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
success
};
-template <class C>
- const char* parse_type(const char* first, const char* last, C& db);
-template <class C>
- const char* parse_encoding(const char* first, const char* last, C& db);
-template <class C>
- const char* parse_name(const char* first, const char* last, C& db,
- bool* ends_with_template_args = 0);
-template <class C>
- const char* parse_expression(const char* first, const char* last, C& db);
-template <class C>
- const char* parse_template_args(const char* first, const char* last, C& db);
-template <class C>
- const char* parse_operator_name(const char* first, const char* last, C& db);
-template <class C>
- const char* parse_unqualified_name(const char* first, const char* last, C& db);
-template <class C>
- const char* parse_decltype(const char* first, const char* last, C& db);
-
-template <class C>
-void
-print_stack(const C& db)
+class StringView {
+ const char *First;
+ const char *Last;
+
+public:
+ template <size_t N>
+ StringView(const char (&Str)[N]) : First(Str), Last(Str + N - 1) {}
+ StringView(const char *First_, const char *Last_) : First(First_), Last(Last_) {}
+ StringView() : First(nullptr), Last(nullptr) {}
+
+ StringView substr(size_t From, size_t To) {
+ if (To >= size())
+ To = size() - 1;
+ if (From >= size())
+ From = size() - 1;
+ return StringView(First + From, First + To);
+ }
+
+ StringView dropFront(size_t N) const {
+ if (N >= size())
+ N = size() - 1;
+ return StringView(First + N, Last);
+ }
+
+ bool startsWith(StringView Str) const {
+ if (Str.size() > size())
+ return false;
+ return std::equal(Str.begin(), Str.end(), begin());
+ }
+
+ const char &operator[](size_t Idx) const { return *(begin() + Idx); }
+
+ const char *begin() const { return First; }
+ const char *end() const { return Last; }
+ size_t size() const { return static_cast<size_t>(Last - First); }
+};
+
+bool operator==(const StringView &LHS, const StringView &RHS) {
+ return LHS.size() == RHS.size() &&
+ std::equal(LHS.begin(), LHS.end(), RHS.begin());
+}
+
+// Stream that AST nodes write their string representation into after the AST
+// has been parsed.
+class OutputStream {
+ char *Buffer;
+ size_t CurrentPosition;
+ size_t BufferCapacity;
+
+ // Ensure there is at least n more positions in buffer.
+ void grow(size_t N) {
+ if (N + CurrentPosition >= BufferCapacity) {
+ BufferCapacity *= 2;
+ if (BufferCapacity < N + CurrentPosition)
+ BufferCapacity = N + CurrentPosition;
+ Buffer = static_cast<char *>(std::realloc(Buffer, BufferCapacity));
+ }
+ }
+
+public:
+ OutputStream(char *StartBuf, size_t Size)
+ : Buffer(StartBuf), CurrentPosition(0), BufferCapacity(Size) {}
+
+ OutputStream &operator+=(StringView R) {
+ size_t Size = R.size();
+ if (Size == 0)
+ return *this;
+ grow(Size);
+ memmove(Buffer + CurrentPosition, R.begin(), Size);
+ CurrentPosition += Size;
+ return *this;
+ }
+
+ OutputStream &operator+=(char C) {
+ grow(1);
+ Buffer[CurrentPosition++] = C;
+ return *this;
+ }
+
+ // Offset of position in buffer, used for building stream_string_view.
+ typedef unsigned StreamPosition;
+
+ // StringView into a stream, used for caching the ast nodes.
+ class StreamStringView {
+ StreamPosition First, Last;
+
+ friend class OutputStream;
+
+ public:
+ StreamStringView() : First(0), Last(0) {}
+
+ StreamStringView(StreamPosition First_, StreamPosition Last_)
+ : First(First_), Last(Last_) {}
+
+ bool empty() const { return First == Last; }
+ };
+
+ OutputStream &operator+=(StreamStringView &s) {
+ size_t Sz = static_cast<size_t>(s.Last - s.First);
+ if (Sz == 0)
+ return *this;
+ grow(Sz);
+ memmove(Buffer + CurrentPosition, Buffer + s.First, Sz);
+ CurrentPosition += Sz;
+ return *this;
+ }
+
+ StreamPosition getCurrentPosition() const {
+ return static_cast<StreamPosition>(CurrentPosition);
+ }
+
+ StreamStringView makeStringViewFromPastPosition(StreamPosition Pos) {
+ return StreamStringView(Pos, getCurrentPosition());
+ }
+
+ char back() const {
+ return CurrentPosition ? Buffer[CurrentPosition - 1] : '\0';
+ }
+
+ bool empty() const { return CurrentPosition == 0; }
+
+ char *getBuffer() { return Buffer; }
+ char *getBufferEnd() { return Buffer + CurrentPosition - 1; }
+ size_t getBufferCapacity() { return BufferCapacity; }
+};
+
+// Base class of all AST nodes. The AST is built by the parser, then is
+// traversed by the printLeft/Right functions to produce a demangled string.
+class Node {
+public:
+ enum Kind : unsigned char {
+ KDotSuffix,
+ KVendorExtQualType,
+ KQualType,
+ KConversionOperatorType,
+ KPostfixQualifiedType,
+ KNameType,
+ KAbiTagAttr,
+ KObjCProtoName,
+ KPointerType,
+ KLValueReferenceType,
+ KRValueReferenceType,
+ KPointerToMemberType,
+ KArrayType,
+ KFunctionType,
+ KTopLevelFunctionDecl,
+ KFunctionQualType,
+ KFunctionRefQualType,
+ KLiteralOperator,
+ KSpecialName,
+ KCtorVtableSpecialName,
+ KQualifiedName,
+ KEmptyName,
+ KVectorType,
+ KTemplateParams,
+ KNameWithTemplateArgs,
+ KGlobalQualifiedName,
+ KStdQualifiedName,
+ KExpandedSpecialSubstitution,
+ KSpecialSubstitution,
+ KCtorDtorName,
+ KDtorName,
+ KUnnamedTypeName,
+ KLambdaTypeName,
+ KExpr,
+ };
+
+ const Kind K;
+
+private:
+ // If this Node has any RHS part, potentally many Nodes further down.
+ const unsigned HasRHSComponent : 1;
+ const unsigned HasFunction : 1;
+ const unsigned HasArray : 1;
+
+public:
+ Node(Kind K_, bool HasRHS_ = false, bool HasFunction_ = false,
+ bool HasArray_ = false)
+ : K(K_), HasRHSComponent(HasRHS_), HasFunction(HasFunction_),
+ HasArray(HasArray_) {}
+
+ bool hasRHSComponent() const { return HasRHSComponent; }
+ bool hasArray() const { return HasArray; }
+ bool hasFunction() const { return HasFunction; }
+
+ void print(OutputStream &s) const {
+ printLeft(s);
+ if (hasRHSComponent())
+ printRight(s);
+ }
+
+ // Print the "left" side of this Node into OutputStream.
+ virtual void printLeft(OutputStream &) const = 0;
+
+ // Print the "right". This distinction is necessary to represent C++ types
+ // that appear on the RHS of their subtype, such as arrays or functions.
+ // Since most types don't have such a component, provide a default
+ // implemenation.
+ virtual void printRight(OutputStream &) const {}
+
+ virtual StringView getBaseName() const { return StringView(); }
+
+ // Silence compiler warnings, this dtor will never be called.
+ virtual ~Node() = default;
+};
+
+class NodeArray {
+ Node **Elements;
+ size_t NumElements;
+
+public:
+ NodeArray() : NumElements(0) {}
+ NodeArray(Node **Elements_, size_t NumElements_)
+ : Elements(Elements_), NumElements(NumElements_) {}
+
+ bool empty() const { return NumElements == 0; }
+ size_t size() const { return NumElements; }
+
+ void printWithSeperator(OutputStream &S, StringView Seperator) const {
+ for (size_t Idx = 0; Idx != NumElements; ++Idx) {
+ if (Idx)
+ S += Seperator;
+ Elements[Idx]->print(S);
+ }
+ }
+};
+
+class DotSuffix final : public Node {
+ const Node *Prefix;
+ const StringView Suffix;
+
+public:
+ DotSuffix(Node *Prefix_, StringView Suffix_)
+ : Node(KDotSuffix), Prefix(Prefix_), Suffix(Suffix_) {}
+
+ void printLeft(OutputStream &s) const override {
+ Prefix->print(s);
+ s += " (";
+ s += Suffix;
+ s += ")";
+ }
+};
+
+class VendorExtQualType final : public Node {
+ const Node *Ext;
+ const Node *Ty;
+
+public:
+ VendorExtQualType(Node *Ext_, Node *Ty_)
+ : Node(KVendorExtQualType), Ext(Ext_), Ty(Ty_) {}
+
+ void printLeft(OutputStream &S) const override {
+ Ext->print(S);
+ S += " ";
+ Ty->printLeft(S);
+ }
+
+ void printRight(OutputStream &S) const override { Ty->printRight(S); }
+};
+
+enum Qualifiers {
+ QualNone = 0,
+ QualConst = 0x1,
+ QualVolatile = 0x2,
+ QualRestrict = 0x4,
+};
+
+void addQualifiers(Qualifiers &Q1, Qualifiers Q2) {
+ Q1 = static_cast<Qualifiers>(Q1 | Q2);
+}
+
+class QualType : public Node {
+protected:
+ const Qualifiers Quals;
+ const Node *Child;
+
+ void printQuals(OutputStream &S) const {
+ if (Quals & QualConst)
+ S += " const";
+ if (Quals & QualVolatile)
+ S += " volatile";
+ if (Quals & QualRestrict)
+ S += " restrict";
+ }
+
+public:
+ QualType(Node *Child_, Qualifiers Quals_)
+ : Node(KQualType, Child_->hasRHSComponent(), Child_->hasFunction(),
+ Child_->hasArray()),
+ Quals(Quals_), Child(Child_) {}
+
+ QualType(Node::Kind ChildKind_, Node *Child_, Qualifiers Quals_)
+ : Node(ChildKind_, Child_->hasRHSComponent(), Child_->hasFunction(),
+ Child_->hasArray()),
+ Quals(Quals_), Child(Child_) {}
+
+ void printLeft(OutputStream &S) const override {
+ Child->printLeft(S);
+ printQuals(S);
+ }
+
+ void printRight(OutputStream &S) const override { Child->printRight(S); }
+};
+
+class ConversionOperatorType final : public Node {
+ const Node *Ty;
+
+public:
+ ConversionOperatorType(Node *Ty_) : Node(KConversionOperatorType), Ty(Ty_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "operator ";
+ Ty->print(S);
+ }
+};
+
+class PostfixQualifiedType final : public Node {
+ const Node *Ty;
+ const StringView Postfix;
+
+public:
+ PostfixQualifiedType(Node *Ty_, StringView Postfix_)
+ : Node(KPostfixQualifiedType), Ty(Ty_), Postfix(Postfix_) {}
+
+ void printLeft(OutputStream &s) const override {
+ Ty->printLeft(s);
+ s += Postfix;
+ }
+
+ void printRight(OutputStream &S) const override { Ty->printRight(S); }
+};
+
+class NameType final : public Node {
+ const StringView Name;
+
+public:
+ NameType(StringView Name_) : Node(KNameType), Name(Name_) {}
+
+ StringView getName() const { return Name; }
+ StringView getBaseName() const override { return Name; }
+
+ void printLeft(OutputStream &s) const override { s += Name; }
+};
+
+class AbiTagAttr final : public Node {
+ const Node* Base;
+ StringView Tag;
+public:
+ AbiTagAttr(const Node* Base_, StringView Tag_)
+ : Node(KAbiTagAttr), Base(Base_), Tag(Tag_) {}
+
+ void printLeft(OutputStream &S) const override {
+ Base->printLeft(S);
+ S += "[abi:";
+ S += Tag;
+ S += "]";
+ }
+};
+
+class ObjCProtoName : public Node {
+ Node *Ty;
+ Node *Protocol;
+
+ friend class PointerType;
+
+public:
+ ObjCProtoName(Node *Ty_, Node *Protocol_)
+ : Node(KObjCProtoName), Ty(Ty_), Protocol(Protocol_) {}
+
+ bool isObjCObject() const {
+ return Ty->K == KNameType &&
+ static_cast<NameType *>(Ty)->getName() == "objc_object";
+ }
+
+ void printLeft(OutputStream &S) const override {
+ Ty->printLeft(S);
+ S += "<";
+ Protocol->printLeft(S);
+ S += ">";
+ }
+};
+
+class PointerType final : public Node {
+ const Node *Pointee;
+
+public:
+ PointerType(Node *Pointee_)
+ : Node(KPointerType, Pointee_->hasRHSComponent()), Pointee(Pointee_) {}
+
+ void printLeft(OutputStream &s) const override {
+ // We rewrite objc_object<SomeProtocol>* into id<SomeProtocol>.
+ if (Pointee->K != KObjCProtoName ||
+ !static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()) {
+ Pointee->printLeft(s);
+ if (Pointee->hasArray())
+ s += " ";
+ if (Pointee->hasArray() || Pointee->hasFunction())
+ s += "(";
+ s += "*";
+ } else {
+ const auto *objcProto = static_cast<const ObjCProtoName *>(Pointee);
+ s += "id<";
+ objcProto->Protocol->print(s);
+ s += ">";
+ }
+ }
+
+ void printRight(OutputStream &s) const override {
+ if (Pointee->K != KObjCProtoName ||
+ !static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()) {
+ if (Pointee->hasArray() || Pointee->hasFunction())
+ s += ")";
+ Pointee->printRight(s);
+ }
+ }
+};
+
+class LValueReferenceType final : public Node {
+ const Node *Pointee;
+
+public:
+ LValueReferenceType(Node *Pointee_)
+ : Node(KLValueReferenceType, Pointee_->hasRHSComponent()),
+ Pointee(Pointee_) {}
+
+ void printLeft(OutputStream &s) const override {
+ Pointee->printLeft(s);
+ if (Pointee->hasArray())
+ s += " ";
+ if (Pointee->hasArray() || Pointee->hasFunction())
+ s += "(&";
+ else
+ s += "&";
+ }
+ void printRight(OutputStream &s) const override {
+ if (Pointee->hasArray() || Pointee->hasFunction())
+ s += ")";
+ Pointee->printRight(s);
+ }
+};
+
+class RValueReferenceType final : public Node {
+ const Node *Pointee;
+
+public:
+ RValueReferenceType(Node *Pointee_)
+ : Node(KRValueReferenceType, Pointee_->hasRHSComponent()),
+ Pointee(Pointee_) {}
+
+ void printLeft(OutputStream &s) const override {
+ Pointee->printLeft(s);
+ if (Pointee->hasArray())
+ s += " ";
+ if (Pointee->hasArray() || Pointee->hasFunction())
+ s += "(&&";
+ else
+ s += "&&";
+ }
+
+ void printRight(OutputStream &s) const override {
+ if (Pointee->hasArray() || Pointee->hasFunction())
+ s += ")";
+ Pointee->printRight(s);
+ }
+};
+
+class PointerToMemberType final : public Node {
+ const Node *ClassType;
+ const Node *MemberType;
+
+public:
+ PointerToMemberType(Node *ClassType_, Node *MemberType_)
+ : Node(KPointerToMemberType, MemberType_->hasRHSComponent()),
+ ClassType(ClassType_), MemberType(MemberType_) {}
+
+ void printLeft(OutputStream &s) const override {
+ MemberType->printLeft(s);
+ if (MemberType->hasArray() || MemberType->hasFunction())
+ s += "(";
+ else
+ s += " ";
+ ClassType->print(s);
+ s += "::*";
+ }
+
+ void printRight(OutputStream &s) const override {
+ if (MemberType->hasArray() || MemberType->hasFunction())
+ s += ")";
+ MemberType->printRight(s);
+ }
+};
+
+class NodeOrString {
+ const void *First;
+ const void *Second;
+
+public:
+ /* implicit */ NodeOrString(StringView Str) {
+ const char *FirstChar = Str.begin();
+ const char *SecondChar = Str.end();
+ if (SecondChar == nullptr) {
+ assert(FirstChar == SecondChar);
+ ++FirstChar, ++SecondChar;
+ }
+ First = static_cast<const void *>(FirstChar);
+ Second = static_cast<const void *>(SecondChar);
+ }
+
+ /* implicit */ NodeOrString(Node *N)
+ : First(static_cast<const void *>(N)), Second(nullptr) {}
+ NodeOrString() : First(nullptr), Second(nullptr) {}
+
+ bool isString() const { return Second && First; }
+ bool isNode() const { return First && !Second; }
+ bool isEmpty() const { return !First && !Second; }
+
+ StringView asString() const {
+ assert(isString());
+ return StringView(static_cast<const char *>(First),
+ static_cast<const char *>(Second));
+ }
+
+ const Node *asNode() const {
+ assert(isNode());
+ return static_cast<const Node *>(First);
+ }
+};
+
+class ArrayType final : public Node {
+ Node *Base;
+ NodeOrString Dimension;
+
+public:
+ ArrayType(Node *Base_, NodeOrString Dimension_)
+ : Node(KArrayType, true, false, true), Base(Base_), Dimension(Dimension_) {}
+
+ // Incomplete array type.
+ ArrayType(Node *Base_) : Node(KArrayType, true, false, true), Base(Base_) {}
+
+ void printLeft(OutputStream &S) const override { Base->printLeft(S); }
+
+ void printRight(OutputStream &S) const override {
+ if (S.back() != ']')
+ S += " ";
+ S += "[";
+ if (Dimension.isString())
+ S += Dimension.asString();
+ else if (Dimension.isNode())
+ Dimension.asNode()->print(S);
+ S += "]";
+ Base->printRight(S);
+ }
+};
+
+class FunctionType final : public Node {
+ Node *Ret;
+ NodeArray Params;
+
+public:
+ FunctionType(Node *Ret_, NodeArray Params_)
+ : Node(KFunctionType, true, true), Ret(Ret_), Params(Params_) {}
+
+ // Handle C++'s ... quirky decl grammer by using the left & right
+ // distinction. Consider:
+ // int (*f(float))(char) {}
+ // f is a function that takes a float and returns a pointer to a function
+ // that takes a char and returns an int. If we're trying to print f, start
+ // by printing out the return types's left, then print our parameters, then
+ // finally print right of the return type.
+ void printLeft(OutputStream &S) const override {
+ Ret->printLeft(S);
+ S += " ";
+ }
+
+ void printRight(OutputStream &S) const override {
+ S += "(";
+ Params.printWithSeperator(S, ", ");
+ S += ")";
+ Ret->printRight(S);
+ }
+};
+
+class TopLevelFunctionDecl final : public Node {
+ const Node *Ret;
+ const Node *Name;
+ NodeArray Params;
+
+public:
+ TopLevelFunctionDecl(Node *Ret_, Node *Name_, NodeArray Params_)
+ : Node(KTopLevelFunctionDecl, true, true), Ret(Ret_), Name(Name_),
+ Params(Params_) {}
+
+ void printLeft(OutputStream &S) const override {
+ if (Ret) {
+ Ret->printLeft(S);
+ if (!Ret->hasRHSComponent())
+ S += " ";
+ }
+ Name->print(S);
+ }
+
+ void printRight(OutputStream &S) const override {
+ S += "(";
+ Params.printWithSeperator(S, ", ");
+ S += ")";
+ if (Ret)
+ Ret->printRight(S);
+ }
+};
+
+enum FunctionRefQual : unsigned char {
+ FrefQualNone,
+ FrefQualLValue,
+ FrefQualRValue,
+};
+
+class FunctionRefQualType : public Node {
+ Node *Fn;
+ FunctionRefQual Quals;
+
+ friend class FunctionQualType;
+
+public:
+ FunctionRefQualType(Node *Fn_, FunctionRefQual Quals_)
+ : Node(KFunctionRefQualType, true, true), Fn(Fn_), Quals(Quals_) {}
+
+ void printQuals(OutputStream &S) const {
+ if (Quals == FrefQualLValue)
+ S += " &";
+ else
+ S += " &&";
+ }
+
+ void printLeft(OutputStream &S) const override { Fn->printLeft(S); }
+
+ void printRight(OutputStream &S) const override {
+ Fn->printRight(S);
+ printQuals(S);
+ }
+};
+
+class FunctionQualType final : public QualType {
+public:
+ FunctionQualType(Node *Child_, Qualifiers Quals_)
+ : QualType(KFunctionQualType, Child_, Quals_) {}
+
+ void printLeft(OutputStream &S) const override { Child->printLeft(S); }
+
+ void printRight(OutputStream &S) const override {
+ if (Child->K == KFunctionRefQualType) {
+ auto *RefQuals = static_cast<const FunctionRefQualType *>(Child);
+ RefQuals->Fn->printRight(S);
+ printQuals(S);
+ RefQuals->printQuals(S);
+ } else {
+ Child->printRight(S);
+ printQuals(S);
+ }
+ }
+};
+
+class LiteralOperator : public Node {
+ const Node *OpName;
+
+public:
+ LiteralOperator(Node *OpName_) : Node(KLiteralOperator), OpName(OpName_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "operator\"\" ";
+ OpName->print(S);
+ }
+};
+
+class SpecialName final : public Node {
+ const StringView Special;
+ const Node *Child;
+
+public:
+ SpecialName(StringView Special_, Node *Child_)
+ : Node(KSpecialName), Special(Special_), Child(Child_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += Special;
+ Child->print(S);
+ }
+};
+
+class CtorVtableSpecialName final : public Node {
+ const Node *FirstType;
+ const Node *SecondType;
+
+public:
+ CtorVtableSpecialName(Node *FirstType_, Node *SecondType_)
+ : Node(KCtorVtableSpecialName), FirstType(FirstType_),
+ SecondType(SecondType_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "construction vtable for ";
+ FirstType->print(S);
+ S += "-in-";
+ SecondType->print(S);
+ }
+};
+
+class QualifiedName final : public Node {
+ // qualifier::name
+ const Node *Qualifier;
+ const Node *Name;
+
+ mutable OutputStream::StreamStringView Cache;
+
+public:
+ QualifiedName(Node *Qualifier_, Node *Name_)
+ : Node(KQualifiedName), Qualifier(Qualifier_), Name(Name_) {}
+
+ StringView getBaseName() const override { return Name->getBaseName(); }
+
+ void printLeft(OutputStream &S) const override {
+ if (!Cache.empty()) {
+ S += Cache;
+ return;
+ }
+
+ OutputStream::StreamPosition Start = S.getCurrentPosition();
+ if (Qualifier->K != KEmptyName) {
+ Qualifier->print(S);
+ S += "::";
+ }
+ Name->print(S);
+ Cache = S.makeStringViewFromPastPosition(Start);
+ }
+};
+
+class EmptyName : public Node {
+public:
+ EmptyName() : Node(KEmptyName) {}
+ void printLeft(OutputStream &) const override {}
+};
+
+class VectorType final : public Node {
+ const Node *BaseType;
+ const NodeOrString Dimension;
+ const bool IsPixel;
+
+public:
+ VectorType(NodeOrString Dimension_)
+ : Node(KVectorType), BaseType(nullptr), Dimension(Dimension_),
+ IsPixel(true) {}
+ VectorType(Node *BaseType_, NodeOrString Dimension_)
+ : Node(KVectorType), BaseType(BaseType_), Dimension(Dimension_),
+ IsPixel(false) {}
+
+ void printLeft(OutputStream &S) const override {
+ if (IsPixel) {
+ S += "pixel vector[";
+ S += Dimension.asString();
+ S += "]";
+ } else {
+ BaseType->print(S);
+ S += " vector[";
+ if (Dimension.isNode())
+ Dimension.asNode()->print(S);
+ else if (Dimension.isString())
+ S += Dimension.asString();
+ S += "]";
+ }
+ }
+};
+
+class TemplateParams final : public Node {
+ NodeArray Params;
+
+ mutable OutputStream::StreamStringView Cache;
+
+public:
+ TemplateParams(NodeArray Params_) : Node(KTemplateParams), Params(Params_) {}
+
+ void printLeft(OutputStream &S) const override {
+ if (!Cache.empty()) {
+ S += Cache;
+ return;
+ }
+
+ OutputStream::StreamPosition Start = S.getCurrentPosition();
+
+ S += "<";
+ Params.printWithSeperator(S, ", ");
+ if (S.back() == '>')
+ S += " ";
+ S += ">";
+
+ Cache = S.makeStringViewFromPastPosition(Start);
+ }
+};
+
+class NameWithTemplateArgs final : public Node {
+ // name<template_args>
+ Node *Name;
+ Node *TemplateArgs;
+
+public:
+ NameWithTemplateArgs(Node *Name_, Node *TemplateArgs_)
+ : Node(KNameWithTemplateArgs), Name(Name_), TemplateArgs(TemplateArgs_) {}
+
+ StringView getBaseName() const override { return Name->getBaseName(); }
+
+ void printLeft(OutputStream &S) const override {
+ Name->print(S);
+ TemplateArgs->print(S);
+ }
+};
+
+class GlobalQualifiedName final : public Node {
+ Node *Child;
+
+public:
+ GlobalQualifiedName(Node *Child_) : Node(KGlobalQualifiedName), Child(Child_) {}
+
+ StringView getBaseName() const override { return Child->getBaseName(); }
+
+ void printLeft(OutputStream &S) const override {
+ S += "::";
+ Child->print(S);
+ }
+};
+
+class StdQualifiedName final : public Node {
+ Node *Child;
+
+public:
+ StdQualifiedName(Node *Child_) : Node(KStdQualifiedName), Child(Child_) {}
+
+ StringView getBaseName() const override { return Child->getBaseName(); }
+
+ void printLeft(OutputStream &S) const override {
+ S += "std::";
+ Child->print(S);
+ }
+};
+
+enum class SpecialSubKind {
+ allocator,
+ basic_string,
+ string,
+ istream,
+ ostream,
+ iostream,
+};
+
+class ExpandedSpecialSubstitution final : public Node {
+ SpecialSubKind SSK;
+
+public:
+ ExpandedSpecialSubstitution(SpecialSubKind SSK_)
+ : Node(KExpandedSpecialSubstitution), SSK(SSK_) {}
+
+ StringView getBaseName() const override {
+ switch (SSK) {
+ case SpecialSubKind::allocator:
+ return StringView("allocator");
+ case SpecialSubKind::basic_string:
+ return StringView("basic_string");
+ case SpecialSubKind::string:
+ return StringView("basic_string");
+ case SpecialSubKind::istream:
+ return StringView("basic_istream");
+ case SpecialSubKind::ostream:
+ return StringView("basic_ostream");
+ case SpecialSubKind::iostream:
+ return StringView("basic_iostream");
+ }
+ _LIBCPP_UNREACHABLE();
+ }
+
+ void printLeft(OutputStream &S) const override {
+ switch (SSK) {
+ case SpecialSubKind::allocator:
+ S += "std::basic_string<char, std::char_traits<char>, "
+ "std::allocator<char> >";
+ break;
+ case SpecialSubKind::basic_string:
+ case SpecialSubKind::string:
+ S += "std::basic_string<char, std::char_traits<char>, "
+ "std::allocator<char> >";
+ break;
+ case SpecialSubKind::istream:
+ S += "std::basic_istream<char, std::char_traits<char> >";
+ break;
+ case SpecialSubKind::ostream:
+ S += "std::basic_ostream<char, std::char_traits<char> >";
+ break;
+ case SpecialSubKind::iostream:
+ S += "std::basic_iostream<char, std::char_traits<char> >";
+ break;
+ }
+ }
+};
+
+class SpecialSubstitution final : public Node {
+public:
+ SpecialSubKind SSK;
+
+ SpecialSubstitution(SpecialSubKind SSK_)
+ : Node(KSpecialSubstitution), SSK(SSK_) {}
+
+ StringView getBaseName() const override {
+ switch (SSK) {
+ case SpecialSubKind::allocator:
+ return StringView("allocator");
+ case SpecialSubKind::basic_string:
+ return StringView("basic_string");
+ case SpecialSubKind::string:
+ return StringView("string");
+ case SpecialSubKind::istream:
+ return StringView("istream");
+ case SpecialSubKind::ostream:
+ return StringView("ostream");
+ case SpecialSubKind::iostream:
+ return StringView("iostream");
+ }
+ _LIBCPP_UNREACHABLE();
+ }
+
+ void printLeft(OutputStream &S) const override {
+ switch (SSK) {
+ case SpecialSubKind::allocator:
+ S += "std::allocator";
+ break;
+ case SpecialSubKind::basic_string:
+ S += "std::basic_string";
+ break;
+ case SpecialSubKind::string:
+ S += "std::string";
+ break;
+ case SpecialSubKind::istream:
+ S += "std::istream";
+ break;
+ case SpecialSubKind::ostream:
+ S += "std::ostream";
+ break;
+ case SpecialSubKind::iostream:
+ S += "std::iostream";
+ break;
+ }
+ }
+};
+
+class CtorDtorName final : public Node {
+ const Node *Basename;
+ const bool IsDtor;
+
+public:
+ CtorDtorName(Node *Basename_, bool IsDtor_)
+ : Node(KCtorDtorName), Basename(Basename_), IsDtor(IsDtor_) {}
+
+ void printLeft(OutputStream &S) const override {
+ if (IsDtor)
+ S += "~";
+ S += Basename->getBaseName();
+ }
+};
+
+class DtorName : public Node {
+ const Node *Base;
+
+public:
+ DtorName(Node *Base_) : Node(KDtorName), Base(Base_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "~";
+ Base->printLeft(S);
+ }
+};
+
+class UnnamedTypeName : public Node {
+ const StringView Count;
+
+public:
+ UnnamedTypeName(StringView Count_) : Node(KUnnamedTypeName), Count(Count_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "'unnamed";
+ S += Count;
+ S += "\'";
+ }
+};
+
+class LambdaTypeName : public Node {
+ NodeArray Params;
+ StringView Count;
+
+public:
+ LambdaTypeName(NodeArray Params_, StringView Count_)
+ : Node(KLambdaTypeName), Params(Params_), Count(Count_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "\'lambda";
+ S += Count;
+ S += "\'(";
+ Params.printWithSeperator(S, ", ");
+ S += ")";
+ }
+};
+
+// -- Expression Nodes --
+
+struct Expr : public Node {
+ Expr() : Node(KExpr) {}
+};
+
+class BinaryExpr : public Expr {
+ const Node *LHS;
+ const StringView InfixOperator;
+ const Node *RHS;
+
+public:
+ BinaryExpr(Node *LHS_, StringView InfixOperator_, Node *RHS_)
+ : LHS(LHS_), InfixOperator(InfixOperator_), RHS(RHS_) {}
+
+ void printLeft(OutputStream &S) const override {
+ // might be a template argument expression, then we need to disambiguate
+ // with parens.
+ if (InfixOperator == ">")
+ S += "(";
+
+ S += "(";
+ LHS->print(S);
+ S += ") ";
+ S += InfixOperator;
+ S += " (";
+ RHS->print(S);
+ S += ")";
+
+ if (InfixOperator == ">")
+ S += ")";
+ }
+};
+
+class ArraySubscriptExpr : public Expr {
+ const Node *Op1;
+ const Node *Op2;
+
+public:
+ ArraySubscriptExpr(Node *Op1_, Node *Op2_) : Op1(Op1_), Op2(Op2_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "(";
+ Op1->print(S);
+ S += ")[";
+ Op2->print(S);
+ S += "]";
+ }
+};
+
+class PostfixExpr : public Expr {
+ const Node *Child;
+ const StringView Operand;
+
+public:
+ PostfixExpr(Node *Child_, StringView Operand_)
+ : Child(Child_), Operand(Operand_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "(";
+ Child->print(S);
+ S += ")";
+ S += Operand;
+ }
+};
+
+class ConditionalExpr : public Expr {
+ const Node *Cond;
+ const Node *Then;
+ const Node *Else;
+
+public:
+ ConditionalExpr(Node *Cond_, Node *Then_, Node *Else_)
+ : Cond(Cond_), Then(Then_), Else(Else_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "(";
+ Cond->print(S);
+ S += ") ? (";
+ Then->print(S);
+ S += ") : (";
+ Else->print(S);
+ S += ")";
+ }
+};
+
+class MemberExpr : public Expr {
+ const Node *LHS;
+ const StringView Kind;
+ const Node *RHS;
+
+public:
+ MemberExpr(Node *LHS_, StringView Kind_, Node *RHS_)
+ : LHS(LHS_), Kind(Kind_), RHS(RHS_) {}
+
+ void printLeft(OutputStream &S) const override {
+ LHS->print(S);
+ S += Kind;
+ RHS->print(S);
+ }
+};
+
+class EnclosingExpr : public Expr {
+ const StringView Prefix;
+ const Node *Infix;
+ const StringView Postfix;
+
+public:
+ EnclosingExpr(StringView Prefix_, Node *Infix_, StringView Postfix_)
+ : Prefix(Prefix_), Infix(Infix_), Postfix(Postfix_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += Prefix;
+ Infix->print(S);
+ S += Postfix;
+ }
+};
+
+class CastExpr : public Expr {
+ // cast_kind<to>(from)
+ const StringView CastKind;
+ const Node *To;
+ const Node *From;
+
+public:
+ CastExpr(StringView CastKind_, Node *To_, Node *From_)
+ : CastKind(CastKind_), To(To_), From(From_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += CastKind;
+ S += "<";
+ To->printLeft(S);
+ S += ">(";
+ From->printLeft(S);
+ S += ")";
+ }
+};
+
+class SizeofParamPackExpr : public Expr {
+ NodeArray Args;
+
+public:
+ SizeofParamPackExpr(NodeArray Args_) : Args(Args_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "sizeof...(";
+ Args.printWithSeperator(S, ", ");
+ S += ")";
+ }
+};
+
+class CallExpr : public Expr {
+ const Node *Callee;
+ NodeArray Args;
+
+public:
+ CallExpr(Node *Callee_, NodeArray Args_) : Callee(Callee_), Args(Args_) {}
+
+ void printLeft(OutputStream &S) const override {
+ Callee->print(S);
+ S += "(";
+ Args.printWithSeperator(S, ", ");
+ S += ")";
+ }
+};
+
+class NewExpr : public Expr {
+ // new (expr_list) type(init_list)
+ NodeArray ExprList;
+ Node *Type;
+ NodeArray InitList;
+ bool IsGlobal; // ::operator new ?
+ bool IsArray; // new[] ?
+public:
+ NewExpr(NodeArray ExprList_, Node *Type_, NodeArray InitList_, bool IsGlobal_,
+ bool IsArray_)
+ : ExprList(ExprList_), Type(Type_), InitList(InitList_), IsGlobal(IsGlobal_),
+ IsArray(IsArray_) {}
+
+ void printLeft(OutputStream &S) const override {
+ if (IsGlobal)
+ S += "::operator ";
+ S += "new";
+ if (IsArray)
+ S += "[]";
+ if (!ExprList.empty()) {
+ S += "(";
+ ExprList.printWithSeperator(S, ", ");
+ S += ")";
+ }
+ Type->print(S);
+ if (!InitList.empty()) {
+ S += "(";
+ InitList.printWithSeperator(S, ", ");
+ S += ")";
+ }
+ }
+};
+
+class DeleteExpr : public Expr {
+ Node *Op;
+ bool IsGlobal;
+ bool IsArray;
+
+public:
+ DeleteExpr(Node *Op_, bool IsGlobal_, bool IsArray_)
+ : Op(Op_), IsGlobal(IsGlobal_), IsArray(IsArray_) {}
+
+ void printLeft(OutputStream &S) const override {
+ if (IsGlobal)
+ S += "::";
+ S += "delete";
+ if (IsArray)
+ S += "[] ";
+ Op->print(S);
+ }
+};
+
+class PrefixExpr : public Expr {
+ StringView Prefix;
+ Node *Child;
+
+public:
+ PrefixExpr(StringView Prefix_, Node *Child_) : Prefix(Prefix_), Child(Child_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += Prefix;
+ S += "(";
+ Child->print(S);
+ S += ")";
+ }
+};
+
+class FunctionParam : public Expr {
+ StringView Number;
+
+public:
+ FunctionParam(StringView Number_) : Number(Number_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "fp";
+ S += Number;
+ }
+};
+
+class ExprList : public Expr {
+ NodeArray SubExprs;
+
+public:
+ ExprList(NodeArray SubExprs_) : SubExprs(SubExprs_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "(";
+ SubExprs.printWithSeperator(S, ", ");
+ S += ")";
+ }
+};
+
+class ConversionExpr : public Expr {
+ NodeArray Expressions;
+ NodeArray Types;
+
+public:
+ ConversionExpr(NodeArray Expressions_, NodeArray Types_)
+ : Expressions(Expressions_), Types(Types_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "(";
+ Expressions.printWithSeperator(S, ", ");
+ S += ")(";
+ Types.printWithSeperator(S, ", ");
+ S += ")";
+ }
+};
+
+class ThrowExpr : public Expr {
+ const Node *Op;
+
+public:
+ ThrowExpr(Node *Op_) : Op(Op_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "throw ";
+ Op->print(S);
+ }
+};
+
+class BoolExpr : public Expr {
+ bool Value;
+
+public:
+ BoolExpr(bool Value_) : Value(Value_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += Value ? StringView("true") : StringView("false");
+ }
+};
+
+class IntegerCastExpr : public Expr {
+ // ty(integer)
+ Node *Ty;
+ StringView Integer;
+
+public:
+ IntegerCastExpr(Node *Ty_, StringView Integer_) : Ty(Ty_), Integer(Integer_) {}
+
+ void printLeft(OutputStream &S) const override {
+ S += "(";
+ Ty->print(S);
+ S += ")";
+ S += Integer;
+ }
+};
+
+class IntegerExpr : public Expr {
+ StringView Type;
+ StringView Value;
+
+public:
+ IntegerExpr(StringView Type_, StringView Value_) : Type(Type_), Value(Value_) {}
+
+ void printLeft(OutputStream &S) const override {
+ if (Type.size() > 3) {
+ S += "(";
+ S += Type;
+ S += ")";
+ }
+
+ if (Value[0] == 'n') {
+ S += "-";
+ S += Value.dropFront(1);
+ } else
+ S += Value;
+
+ if (Type.size() <= 3)
+ S += Type;
+ }
+};
+
+template <class Float> struct FloatData;
+
+template <class Float> class FloatExpr : public Expr {
+ const StringView Contents;
+
+public:
+ FloatExpr(StringView Contents_) : Contents(Contents_) {}
+
+ void printLeft(OutputStream &s) const override {
+ const char *first = Contents.begin();
+ const char *last = Contents.end() + 1;
+
+ const size_t N = FloatData<Float>::mangled_size;
+ if (static_cast<std::size_t>(last - first) > N) {
+ last = first + N;
+ union {
+ Float value;
+ char buf[sizeof(Float)];
+ };
+ const char *t = first;
+ char *e = buf;
+ for (; t != last; ++t, ++e) {
+ unsigned d1 = isdigit(*t) ? static_cast<unsigned>(*t - '0')
+ : static_cast<unsigned>(*t - 'a' + 10);
+ ++t;
+ unsigned d0 = isdigit(*t) ? static_cast<unsigned>(*t - '0')
+ : static_cast<unsigned>(*t - 'a' + 10);
+ *e = static_cast<char>((d1 << 4) + d0);
+ }
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+ std::reverse(buf, e);
+#endif
+ char num[FloatData<Float>::max_demangled_size] = {0};
+ int n = snprintf(num, sizeof(num), FloatData<Float>::spec, value);
+ s += StringView(num, num + n);
+ }
+ }
+};
+
+class BumpPointerAllocator {
+ struct BlockMeta {
+ BlockMeta* Next;
+ size_t Current;
+ };
+
+ static constexpr size_t AllocSize = 4096;
+ static constexpr size_t UsableAllocSize = AllocSize - sizeof(BlockMeta);
+
+ alignas(16) char InitialBuffer[AllocSize];
+ BlockMeta* BlockList = nullptr;
+
+ void grow() {
+ char* NewMeta = new char[AllocSize];
+ BlockList = new (NewMeta) BlockMeta{BlockList, 0};
+ }
+
+ void* allocateMassive(size_t NBytes) {
+ NBytes += sizeof(BlockMeta);
+ BlockMeta* NewMeta = reinterpret_cast<BlockMeta*>(new char[NBytes]);
+ BlockList->Next = new (NewMeta) BlockMeta{BlockList->Next, 0};
+ return static_cast<void*>(NewMeta + 1);
+ }
+
+public:
+ BumpPointerAllocator()
+ : BlockList(new (InitialBuffer) BlockMeta{nullptr, 0}) {}
+
+ void* allocate(size_t N) {
+ N = (N + 15u) & ~15u;
+ if (N + BlockList->Current >= UsableAllocSize) {
+ if (N > UsableAllocSize)
+ return allocateMassive(N);
+ grow();
+ }
+ BlockList->Current += N;
+ return static_cast<void*>(reinterpret_cast<char*>(BlockList + 1) +
+ BlockList->Current - N);
+ }
+
+ ~BumpPointerAllocator() {
+ while (BlockList) {
+ BlockMeta* Tmp = BlockList;
+ BlockList = BlockList->Next;
+ if (reinterpret_cast<char*>(Tmp) != InitialBuffer)
+ delete[] reinterpret_cast<char*>(Tmp);
+ }
+ }
+};
+
+template <class T, size_t N>
+class PODSmallVector {
+ static_assert(std::is_pod<T>::value,
+ "T is required to be a plain old data type");
+
+ T* First;
+ T* Last;
+ T* Cap;
+ T Inline[N];
+
+ bool isInline() const { return First == Inline; }
+
+ void clearInline() {
+ First = Inline;
+ Last = Inline;
+ Cap = Inline + N;
+ }
+
+ void reserve(size_t NewCap) {
+ size_t S = size();
+ if (isInline()) {
+ auto* Tmp = static_cast<T*>(std::malloc(NewCap * sizeof(T)));
+ std::copy(First, Last, Tmp);
+ First = Tmp;
+ } else
+ First = static_cast<T*>(std::realloc(First, NewCap * sizeof(T)));
+ Last = First + S;
+ Cap = First + NewCap;
+ }
+
+public:
+ PODSmallVector() : First(Inline), Last(First), Cap(Inline + N) {}
+
+ PODSmallVector(const PODSmallVector&) = delete;
+ PODSmallVector& operator=(const PODSmallVector&) = delete;
+
+ PODSmallVector(PODSmallVector&& Other) : PODSmallVector() {
+ if (Other.isInline()) {
+ std::copy(Other.begin(), Other.end(), First);
+ Last = First + Other.size();
+ Other.clear();
+ return;
+ }
+
+ First = Other.First;
+ Last = Other.Last;
+ Cap = Other.Cap;
+ Other.clearInline();
+ }
+
+ PODSmallVector& operator=(PODSmallVector&& Other) {
+ if (Other.isInline()) {
+ if (!isInline()) {
+ std::free(First);
+ clearInline();
+ }
+ std::copy(Other.begin(), Other.end(), First);
+ Last = First + Other.size();
+ Other.clear();
+ return *this;
+ }
+
+ if (isInline()) {
+ First = Other.First;
+ Last = Other.Last;
+ Cap = Other.Cap;
+ Other.clearInline();
+ return *this;
+ }
+
+ std::swap(First, Other.First);
+ std::swap(Last, Other.Last);
+ std::swap(Cap, Other.Cap);
+ Other.clear();
+ return *this;
+ }
+
+ void push_back(const T& Elem) {
+ if (Last == Cap)
+ reserve(size() * 2);
+ *Last++ = Elem;
+ }
+
+ void pop_back() {
+ assert(Last != First && "Popping empty vector!");
+ --Last;
+ }
+
+ void dropBack(size_t Index) {
+ assert(Index <= size() && "dropBack() can't expand!");
+ Last = First + Index;
+ }
+
+ T* begin() { return First; }
+ T* end() { return Last; }
+
+ bool empty() const { return First == Last; }
+ size_t size() const { return static_cast<size_t>(Last - First); }
+ T& back() {
+ assert(Last != First && "Calling back() on empty vector!");
+ return *(Last - 1);
+ }
+ T& operator[](size_t Index) {
+ assert(Index < size() && "Invalid access!");
+ return *(begin() + Index);
+ }
+ void clear() { Last = First; }
+
+ ~PODSmallVector() {
+ if (!isInline())
+ std::free(First);
+ }
+};
+
+// Substitution table. This type is used to track the substitutions that are
+// known by the parser.
+template <size_t Size>
+class SubstitutionTable {
+ // Substitutions hold the actual entries in the table, and PackIndices tells
+ // us which entries are members of which pack. For example, if the
+ // substitutions we're tracking are: {int, {float, FooBar}, char}, with
+ // {float, FooBar} being a parameter pack, we represent the substitutions as:
+ // Substitutions: int, float, FooBar, char
+ // PackIndices: 0, 1, 3
+ // So, PackIndicies[I] holds the offset of the begin of the Ith pack, and
+ // PackIndices[I + 1] holds the offset of the end.
+ PODSmallVector<Node*, Size> Substitutions;
+ PODSmallVector<unsigned, Size> PackIndices;
+
+public:
+ // Add a substitution that represents a single name to the table. This is
+ // modeled as a parameter pack with just one element.
+ void pushSubstitution(Node* Entry) {
+ pushPack();
+ pushSubstitutionIntoPack(Entry);
+ }
+
+ // Add a new empty pack to the table. Subsequent calls to
+ // pushSubstitutionIntoPack() will add to this pack.
+ void pushPack() {
+ PackIndices.push_back(static_cast<unsigned>(Substitutions.size()));
+ }
+ void pushSubstitutionIntoPack(Node* Entry) {
+ assert(!PackIndices.empty() && "No pack to push substitution into!");
+ Substitutions.push_back(Entry);
+ }
+
+ // Remove the last pack from the table.
+ void popPack() {
+ unsigned Last = PackIndices.back();
+ PackIndices.pop_back();
+ Substitutions.dropBack(Last);
+ }
+
+ // For use in a range-for loop.
+ struct NodeRange {
+ Node** First;
+ Node** Last;
+ Node** begin() { return First; }
+ Node** end() { return Last; }
+ };
+
+ // Retrieve the Nth substitution. This is represented as a range, as the
+ // substitution could be referring to a parameter pack.
+ NodeRange nthSubstitution(size_t N) {
+ assert(PackIndices[N] <= Substitutions.size());
+ // The Nth parameter pack starts at offset PackIndices[N], and ends at
+ // PackIndices[N + 1].
+ Node** Begin = Substitutions.begin() + PackIndices[N];
+ Node** End;
+ if (N + 1 != PackIndices.size()) {
+ assert(PackIndices[N + 1] <= Substitutions.size());
+ End = Substitutions.begin() + PackIndices[N + 1];
+ } else
+ End = Substitutions.end();
+ assert(Begin <= End);
+ return NodeRange{Begin, End};
+ }
+
+ size_t size() const { return PackIndices.size(); }
+ bool empty() const { return PackIndices.empty(); }
+ void clear() {
+ Substitutions.clear();
+ PackIndices.clear();
+ }
+};
+
+struct Db
{
- fprintf(stderr, "---------\n");
- fprintf(stderr, "names:\n");
- for (auto& s : db.names)
- fprintf(stderr, "{%s#%s}\n", s.first.c_str(), s.second.c_str());
- int i = -1;
- fprintf(stderr, "subs:\n");
- for (auto& v : db.subs)
+ // Name stack, this is used by the parser to hold temporary names that were
+ // parsed. The parser colapses multiple names into new nodes to construct
+ // the AST. Once the parser is finished, names.size() == 1.
+ PODSmallVector<Node*, 32> Names;
+
+ // Substitution table. Itanium supports name substitutions as a means of
+ // compression. The string "S42_" refers to the 42nd entry in this table.
+ SubstitutionTable<32> Subs;
+
+ // Template parameter table. Like the above, but referenced like "T42_".
+ // This has a smaller size compared to Subs and Names because it can be
+ // stored on the stack.
+ SubstitutionTable<4> TemplateParams;
+
+ Qualifiers CV = QualNone;
+ FunctionRefQual RefQuals = FrefQualNone;
+ unsigned EncodingDepth = 0;
+ bool ParsedCtorDtorCV = false;
+ bool TagTemplates = true;
+ bool FixForwardReferences = false;
+ bool TryToParseTemplateArgs = true;
+
+ BumpPointerAllocator ASTAllocator;
+
+ template <class T, class... Args> T* make(Args&& ...args)
{
- if (i >= 0)
- fprintf(stderr, "S%i_ = {", i);
- else
- fprintf(stderr, "S_ = {");
- for (auto& s : v)
- fprintf(stderr, "{%s#%s}", s.first.c_str(), s.second.c_str());
- fprintf(stderr, "}\n");
- ++i;
+ return new (ASTAllocator.allocate(sizeof(T)))
+ T(std::forward<Args>(args)...);
}
- fprintf(stderr, "template_param:\n");
- for (auto& t : db.template_param)
+
+ template <class It> NodeArray makeNodeArray(It begin, It end)
{
- fprintf(stderr, "--\n");
- i = -1;
- for (auto& v : t)
- {
- if (i >= 0)
- fprintf(stderr, "T%i_ = {", i);
- else
- fprintf(stderr, "T_ = {");
- for (auto& s : v)
- fprintf(stderr, "{%s#%s}", s.first.c_str(), s.second.c_str());
- fprintf(stderr, "}\n");
- ++i;
- }
+ size_t sz = static_cast<size_t>(end - begin);
+ void* mem = ASTAllocator.allocate(sizeof(Node*) * sz);
+ Node** data = new (mem) Node*[sz];
+ std::copy(begin, end, data);
+ return NodeArray(data, sz);
}
- fprintf(stderr, "---------\n\n");
-}
-template <class C>
-void
-print_state(const char* msg, const char* first, const char* last, const C& db)
-{
- fprintf(stderr, "%s: ", msg);
- for (; first != last; ++first)
- fprintf(stderr, "%c", *first);
- fprintf(stderr, "\n");
- print_stack(db);
-}
+ NodeArray popTrailingNodeArray(size_t FromPosition)
+ {
+ assert(FromPosition <= Names.size());
+ NodeArray res = makeNodeArray(
+ Names.begin() + (long)FromPosition, Names.end());
+ Names.dropBack(FromPosition);
+ return res;
+ }
+};
+
+const char* parse_type(const char* first, const char* last, Db& db);
+const char* parse_encoding(const char* first, const char* last, Db& db);
+const char* parse_name(const char* first, const char* last, Db& db,
+ bool* ends_with_template_args = 0);
+const char* parse_expression(const char* first, const char* last, Db& db);
+const char* parse_template_args(const char* first, const char* last, Db& db);
+const char* parse_operator_name(const char* first, const char* last, Db& db);
+const char* parse_unqualified_name(const char* first, const char* last, Db& db);
+const char* parse_decltype(const char* first, const char* last, Db& db);
// <number> ::= [n] <non-negative decimal integer>
}
template <class Float>
-struct float_data;
+struct FloatData;
template <>
-struct float_data<float>
+struct FloatData<float>
{
static const size_t mangled_size = 8;
static const size_t max_demangled_size = 24;
static constexpr const char* spec = "%af";
};
-constexpr const char* float_data<float>::spec;
+constexpr const char* FloatData<float>::spec;
template <>
-struct float_data<double>
+struct FloatData<double>
{
static const size_t mangled_size = 16;
static const size_t max_demangled_size = 32;
static constexpr const char* spec = "%a";
};
-constexpr const char* float_data<double>::spec;
+constexpr const char* FloatData<double>::spec;
template <>
-struct float_data<long double>
+struct FloatData<long double>
{
#if defined(__mips__) && defined(__mips_n64) || defined(__aarch64__) || \
defined(__wasm__)
static constexpr const char* spec = "%LaL";
};
-constexpr const char* float_data<long double>::spec;
+constexpr const char* FloatData<long double>::spec;
-template <class Float, class C>
+template <class Float>
const char*
-parse_floating_number(const char* first, const char* last, C& db)
+parse_floating_number(const char* first, const char* last, Db& db)
{
- const size_t N = float_data<Float>::mangled_size;
- if (static_cast<std::size_t>(last - first) > N)
+ const size_t N = FloatData<Float>::mangled_size;
+ if (static_cast<std::size_t>(last - first) <= N)
+ return first;
+ last = first + N;
+ const char* t = first;
+ for (; t != last; ++t)
{
- last = first + N;
- union
- {
- Float value;
- char buf[sizeof(Float)];
- };
- const char* t = first;
- char* e = buf;
- for (; t != last; ++t, ++e)
- {
- if (!isxdigit(*t))
- return first;
- unsigned d1 = isdigit(*t) ? static_cast<unsigned>(*t - '0') :
- static_cast<unsigned>(*t - 'a' + 10);
- ++t;
- unsigned d0 = isdigit(*t) ? static_cast<unsigned>(*t - '0') :
- static_cast<unsigned>(*t - 'a' + 10);
- *e = static_cast<char>((d1 << 4) + d0);
- }
- if (*t == 'E')
- {
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
- std::reverse(buf, e);
-#endif
- char num[float_data<Float>::max_demangled_size] = {0};
- int n = snprintf(num, sizeof(num), float_data<Float>::spec, value);
- if (static_cast<std::size_t>(n) >= sizeof(num))
- return first;
- db.names.push_back(typename C::String(num, static_cast<std::size_t>(n)));
- first = t+1;
- }
+ if (!isxdigit(*t))
+ return first;
+ }
+ if (*t == 'E')
+ {
+ db.Names.push_back(
+ db.make<FloatExpr<Float>>(StringView(first, t)));
+ first = t + 1;
}
return first;
}
-// <source-name> ::= <positive length number> <identifier>
-
-template <class C>
+// <positive length number> ::= [0-9]*
const char*
-parse_source_name(const char* first, const char* last, C& db)
+parse_positive_integer(const char* first, const char* last, size_t* out)
{
if (first != last)
{
if (++t == last)
return first;
}
- if (static_cast<size_t>(last - t) >= n)
- {
- typename C::String r(t, n);
- if (r.substr(0, 10) == "_GLOBAL__N")
- db.names.push_back("(anonymous namespace)");
- else
- db.names.push_back(std::move(r));
- first = t + n;
- }
+ *out = n;
+ first = t;
+ }
+ }
+ return first;
+}
+
+// extension
+// <abi-tag-seq> ::= <abi-tag>*
+// <abi-tag> ::= B <positive length number> <identifier>
+const char*
+parse_abi_tag_seq(const char* first, const char* last, Db& db)
+{
+ while (first != last && *first == 'B' && first+1 != last)
+ {
+ size_t length;
+ const char* t = parse_positive_integer(first+1, last, &length);
+ if (t == first+1)
+ return first;
+ if (static_cast<size_t>(last - t) < length || db.Names.empty())
+ return first;
+ db.Names.back() = db.make<AbiTagAttr>(
+ db.Names.back(), StringView(t, t + length));
+ first = t + length;
+ }
+ return first;
+}
+
+// <source-name> ::= <positive length number> <identifier> [<abi-tag-seq>]
+const char*
+parse_source_name(const char* first, const char* last, Db& db)
+{
+ if (first != last)
+ {
+ size_t length;
+ const char* t = parse_positive_integer(first, last, &length);
+ if (t == first)
+ return first;
+ if (static_cast<size_t>(last - t) >= length)
+ {
+ StringView r(t, t + length);
+ if (r.substr(0, 10) == "_GLOBAL__N")
+ db.Names.push_back(db.make<NameType>("(anonymous namespace)"));
+ else
+ db.Names.push_back(db.make<NameType>(r));
+ first = t + length;
+ first = parse_abi_tag_seq(first, last, db);
}
}
return first;
// <substitution> ::= So # ::std::basic_ostream<char, std::char_traits<char> >
// <substitution> ::= Sd # ::std::basic_iostream<char, std::char_traits<char> >
-template <class C>
const char*
-parse_substitution(const char* first, const char* last, C& db)
+parse_substitution(const char* first, const char* last, Db& db)
{
if (last - first >= 2)
{
switch (first[1])
{
case 'a':
- db.names.push_back("std::allocator");
+ db.Names.push_back(
+ db.make<SpecialSubstitution>(
+ SpecialSubKind::allocator));
first += 2;
break;
case 'b':
- db.names.push_back("std::basic_string");
+ db.Names.push_back(
+ db.make<SpecialSubstitution>(SpecialSubKind::basic_string));
first += 2;
break;
case 's':
- db.names.push_back("std::string");
+ db.Names.push_back(
+ db.make<SpecialSubstitution>(
+ SpecialSubKind::string));
first += 2;
break;
case 'i':
- db.names.push_back("std::istream");
+ db.Names.push_back(db.make<SpecialSubstitution>(SpecialSubKind::istream));
first += 2;
break;
case 'o':
- db.names.push_back("std::ostream");
+ db.Names.push_back(db.make<SpecialSubstitution>(SpecialSubKind::ostream));
first += 2;
break;
case 'd':
- db.names.push_back("std::iostream");
+ db.Names.push_back(db.make<SpecialSubstitution>(SpecialSubKind::iostream));
first += 2;
break;
case '_':
- if (!db.subs.empty())
+ if (!db.Subs.empty())
{
- for (const auto& n : db.subs.front())
- db.names.push_back(n);
+ for (Node* n : db.Subs.nthSubstitution(0))
+ db.Names.push_back(n);
first += 2;
}
break;
if (t == last || *t != '_')
return first;
++sub;
- if (sub < db.subs.size())
+ if (sub < db.Subs.size())
{
- for (const auto& n : db.subs[sub])
- db.names.push_back(n);
+ for (Node* n : db.Subs.nthSubstitution(sub))
+ db.Names.push_back(n);
first = t+1;
}
}
// ::= Dn # std::nullptr_t (i.e., decltype(nullptr))
// ::= u <source-name> # vendor extended type
-template <class C>
const char*
-parse_builtin_type(const char* first, const char* last, C& db)
+parse_builtin_type(const char* first, const char* last, Db& db)
{
if (first != last)
{
switch (*first)
{
case 'v':
- db.names.push_back("void");
+ db.Names.push_back(db.make<NameType>("void"));
++first;
break;
case 'w':
- db.names.push_back("wchar_t");
+ db.Names.push_back(db.make<NameType>("wchar_t"));
++first;
break;
case 'b':
- db.names.push_back("bool");
+ db.Names.push_back(db.make<NameType>("bool"));
++first;
break;
case 'c':
- db.names.push_back("char");
+ db.Names.push_back(db.make<NameType>("char"));
++first;
break;
case 'a':
- db.names.push_back("signed char");
+ db.Names.push_back(db.make<NameType>("signed char"));
++first;
break;
case 'h':
- db.names.push_back("unsigned char");
+ db.Names.push_back(db.make<NameType>("unsigned char"));
++first;
break;
case 's':
- db.names.push_back("short");
+ db.Names.push_back(db.make<NameType>("short"));
++first;
break;
case 't':
- db.names.push_back("unsigned short");
+ db.Names.push_back(db.make<NameType>("unsigned short"));
++first;
break;
case 'i':
- db.names.push_back("int");
+ db.Names.push_back(db.make<NameType>("int"));
++first;
break;
case 'j':
- db.names.push_back("unsigned int");
+ db.Names.push_back(db.make<NameType>("unsigned int"));
++first;
break;
case 'l':
- db.names.push_back("long");
+ db.Names.push_back(db.make<NameType>("long"));
++first;
break;
case 'm':
- db.names.push_back("unsigned long");
+ db.Names.push_back(db.make<NameType>("unsigned long"));
++first;
break;
case 'x':
- db.names.push_back("long long");
+ db.Names.push_back(db.make<NameType>("long long"));
++first;
break;
case 'y':
- db.names.push_back("unsigned long long");
+ db.Names.push_back(db.make<NameType>("unsigned long long"));
++first;
break;
case 'n':
- db.names.push_back("__int128");
+ db.Names.push_back(db.make<NameType>("__int128"));
++first;
break;
case 'o':
- db.names.push_back("unsigned __int128");
+ db.Names.push_back(db.make<NameType>("unsigned __int128"));
++first;
break;
case 'f':
- db.names.push_back("float");
+ db.Names.push_back(db.make<NameType>("float"));
++first;
break;
case 'd':
- db.names.push_back("double");
+ db.Names.push_back(db.make<NameType>("double"));
++first;
break;
case 'e':
- db.names.push_back("long double");
+ db.Names.push_back(db.make<NameType>("long double"));
++first;
break;
case 'g':
- db.names.push_back("__float128");
+ db.Names.push_back(db.make<NameType>("__float128"));
++first;
break;
case 'z':
- db.names.push_back("...");
+ db.Names.push_back(db.make<NameType>("..."));
++first;
break;
case 'u':
switch (first[1])
{
case 'd':
- db.names.push_back("decimal64");
+ db.Names.push_back(db.make<NameType>("decimal64"));
first += 2;
break;
case 'e':
- db.names.push_back("decimal128");
+ db.Names.push_back(db.make<NameType>("decimal128"));
first += 2;
break;
case 'f':
- db.names.push_back("decimal32");
+ db.Names.push_back(db.make<NameType>("decimal32"));
first += 2;
break;
case 'h':
- db.names.push_back("decimal16");
+ db.Names.push_back(db.make<NameType>("decimal16"));
first += 2;
break;
case 'i':
- db.names.push_back("char32_t");
+ db.Names.push_back(db.make<NameType>("char32_t"));
first += 2;
break;
case 's':
- db.names.push_back("char16_t");
+ db.Names.push_back(db.make<NameType>("char16_t"));
first += 2;
break;
case 'a':
- db.names.push_back("auto");
+ db.Names.push_back(db.make<NameType>("auto"));
first += 2;
break;
case 'c':
- db.names.push_back("decltype(auto)");
+ db.Names.push_back(db.make<NameType>("decltype(auto)"));
first += 2;
break;
case 'n':
- db.names.push_back("std::nullptr_t");
+ db.Names.push_back(db.make<NameType>("std::nullptr_t"));
first += 2;
break;
}
return first;
}
-// <CV-qualifiers> ::= [r] [V] [K]
+// <CV-Qualifiers> ::= [r] [V] [K]
const char*
-parse_cv_qualifiers(const char* first, const char* last, unsigned& cv)
+parse_cv_qualifiers(const char* first, const char* last, Qualifiers& cv)
{
- cv = 0;
+ cv = QualNone;
if (first != last)
{
if (*first == 'r')
{
- cv |= 4;
+ addQualifiers(cv, QualRestrict);
++first;
}
if (*first == 'V')
{
- cv |= 2;
+ addQualifiers(cv, QualVolatile);
++first;
}
if (*first == 'K')
{
- cv |= 1;
+ addQualifiers(cv, QualConst);
++first;
}
}
// <template-param> ::= T_ # first template parameter
// ::= T <parameter-2 non-negative number> _
-template <class C>
const char*
-parse_template_param(const char* first, const char* last, C& db)
+parse_template_param(const char* first, const char* last, Db& db)
{
if (last - first >= 2)
{
{
if (first[1] == '_')
{
- if (db.template_param.empty())
- return first;
- if (!db.template_param.back().empty())
+ if (!db.TemplateParams.empty())
{
- for (auto& t : db.template_param.back().front())
- db.names.push_back(t);
+ for (Node *t : db.TemplateParams.nthSubstitution(0))
+ db.Names.push_back(t);
first += 2;
}
else
{
- db.names.push_back("T_");
+ db.Names.push_back(db.make<NameType>("T_"));
first += 2;
- db.fix_forward_references = true;
+ db.FixForwardReferences = true;
}
}
else if (isdigit(first[1]))
sub *= 10;
sub += static_cast<size_t>(*t - '0');
}
- if (t == last || *t != '_' || db.template_param.empty())
+ if (t == last || *t != '_')
return first;
++sub;
- if (sub < db.template_param.back().size())
+ if (sub < db.TemplateParams.size())
{
- for (auto& temp : db.template_param.back()[sub])
- db.names.push_back(temp);
+ for (Node *temp : db.TemplateParams.nthSubstitution(sub))
+ db.Names.push_back(temp);
first = t+1;
}
else
{
- db.names.push_back(typename C::String(first, t+1));
+ db.Names.push_back(
+ db.make<NameType>(StringView(first, t + 1)));
first = t+1;
- db.fix_forward_references = true;
+ db.FixForwardReferences = true;
}
}
}
// cc <type> <expression> # const_cast<type> (expression)
-template <class C>
const char*
-parse_const_cast_expr(const char* first, const char* last, C& db)
+parse_const_cast_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 'c' && first[1] == 'c')
{
const char* t1 = parse_expression(t, last, db);
if (t1 != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto expr = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.empty())
+ auto from_expr = db.Names.back();
+ db.Names.pop_back();
+ if (db.Names.empty())
return first;
- db.names.back() = "const_cast<" + db.names.back().move_full() + ">(" + expr + ")";
+ db.Names.back() = db.make<CastExpr>(
+ "const_cast", db.Names.back(), from_expr);
first = t1;
}
}
// dc <type> <expression> # dynamic_cast<type> (expression)
-template <class C>
const char*
-parse_dynamic_cast_expr(const char* first, const char* last, C& db)
+parse_dynamic_cast_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 'd' && first[1] == 'c')
{
const char* t1 = parse_expression(t, last, db);
if (t1 != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto expr = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.empty())
+ auto from_expr = db.Names.back();
+ db.Names.pop_back();
+ if (db.Names.empty())
return first;
- db.names.back() = "dynamic_cast<" + db.names.back().move_full() + ">(" + expr + ")";
+ db.Names.back() = db.make<CastExpr>(
+ "dynamic_cast", db.Names.back(), from_expr);
first = t1;
}
}
// rc <type> <expression> # reinterpret_cast<type> (expression)
-template <class C>
const char*
-parse_reinterpret_cast_expr(const char* first, const char* last, C& db)
+parse_reinterpret_cast_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 'r' && first[1] == 'c')
{
const char* t1 = parse_expression(t, last, db);
if (t1 != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto expr = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.empty())
+ auto from_expr = db.Names.back();
+ db.Names.pop_back();
+ if (db.Names.empty())
return first;
- db.names.back() = "reinterpret_cast<" + db.names.back().move_full() + ">(" + expr + ")";
+ db.Names.back() = db.make<CastExpr>(
+ "reinterpret_cast", db.Names.back(), from_expr);
first = t1;
}
}
// sc <type> <expression> # static_cast<type> (expression)
-template <class C>
const char*
-parse_static_cast_expr(const char* first, const char* last, C& db)
+parse_static_cast_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 's' && first[1] == 'c')
{
const char* t1 = parse_expression(t, last, db);
if (t1 != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto expr = db.names.back().move_full();
- db.names.pop_back();
- db.names.back() = "static_cast<" + db.names.back().move_full() + ">(" + expr + ")";
+ auto from_expr = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() = db.make<CastExpr>(
+ "static_cast", db.Names.back(), from_expr);
first = t1;
}
}
// sp <expression> # pack expansion
-template <class C>
const char*
-parse_pack_expansion(const char* first, const char* last, C& db)
+parse_pack_expansion(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 's' && first[1] == 'p')
{
// st <type> # sizeof (a type)
-template <class C>
const char*
-parse_sizeof_type_expr(const char* first, const char* last, C& db)
+parse_sizeof_type_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 's' && first[1] == 't')
{
const char* t = parse_type(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back() = "sizeof (" + db.names.back().move_full() + ")";
+ db.Names.back() = db.make<EnclosingExpr>(
+ "sizeof (", db.Names.back(), ")");
first = t;
}
}
// sz <expr> # sizeof (a expression)
-template <class C>
const char*
-parse_sizeof_expr_expr(const char* first, const char* last, C& db)
+parse_sizeof_expr_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 's' && first[1] == 'z')
{
const char* t = parse_expression(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back() = "sizeof (" + db.names.back().move_full() + ")";
+ db.Names.back() = db.make<EnclosingExpr>(
+ "sizeof (", db.Names.back(), ")");
first = t;
}
}
// sZ <template-param> # size of a parameter pack
-template <class C>
const char*
-parse_sizeof_param_pack_expr(const char* first, const char* last, C& db)
+parse_sizeof_param_pack_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'T')
{
- size_t k0 = db.names.size();
+ size_t k0 = db.Names.size();
const char* t = parse_template_param(first+2, last, db);
- size_t k1 = db.names.size();
- if (t != first+2)
+ size_t k1 = db.Names.size();
+ if (t != first+2 && k0 <= k1)
{
- typename C::String tmp("sizeof...(");
- size_t k = k0;
- if (k != k1)
- {
- tmp += db.names[k].move_full();
- for (++k; k != k1; ++k)
- tmp += ", " + db.names[k].move_full();
- }
- tmp += ")";
- for (; k1 != k0; --k1)
- db.names.pop_back();
- db.names.push_back(std::move(tmp));
+ Node* sizeof_expr = db.make<SizeofParamPackExpr>(
+ db.popTrailingNodeArray(k0));
+ db.Names.push_back(sizeof_expr);
first = t;
}
}
return first;
}
-// <function-param> ::= fp <top-level CV-qualifiers> _ # L == 0, first parameter
-// ::= fp <top-level CV-
qualifiers> <parameter-2 non-negative number> _ # L == 0, second and later parameters
-// ::= fL <L-1 non-negative number> p <top-level CV-qualifiers> _ # L > 0, first parameter
-// ::= fL <L-1 non-negative number> p <top-level CV-
qualifiers> <parameter-2 non-negative number> _ # L > 0, second and later parameters
+// <function-param> ::= fp <top-level CV-Qualifiers> _ # L == 0, first parameter
+// ::= fp <top-level CV-
Qualifiers> <parameter-2 non-negative number> _ # L == 0, second and later parameters
+// ::= fL <L-1 non-negative number> p <top-level CV-Qualifiers> _ # L > 0, first parameter
+// ::= fL <L-1 non-negative number> p <top-level CV-
Qualifiers> <parameter-2 non-negative number> _ # L > 0, second and later parameters
-template <class C>
const char*
-parse_function_param(const char* first, const char* last, C& db)
+parse_function_param(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && *first == 'f')
{
if (first[1] == 'p')
{
- unsigned cv;
+ Qualifiers cv;
const char* t = parse_cv_qualifiers(first+2, last, cv);
const char* t1 = parse_number(t, last);
if (t1 != last && *t1 == '_')
{
- db.names.push_back("fp" + typename C::String(t, t1));
+ db.Names.push_back(
+ db.make<FunctionParam>(StringView(t, t1)));
first = t1+1;
}
}
else if (first[1] == 'L')
{
- unsigned cv;
+ Qualifiers cv;
const char* t0 = parse_number(first+2, last);
if (t0 != last && *t0 == 'p')
{
const char* t1 = parse_number(t, last);
if (t1 != last && *t1 == '_')
{
- db.names.push_back("fp" + typename C::String(t, t1));
+ db.Names.push_back(
+ db.make<FunctionParam>(StringView(t, t1)));
first = t1+1;
}
}
// sZ <function-param> # size of a function parameter pack
-template <class C>
const char*
-parse_sizeof_function_param_pack_expr(const char* first, const char* last, C& db)
+parse_sizeof_function_param_pack_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'f')
{
const char* t = parse_function_param(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back() = "sizeof...(" + db.names.back().move_full() + ")";
+ db.Names.back() = db.make<EnclosingExpr>(
+ "sizeof...(", db.Names.back(), ")");
first = t;
}
}
// te <expression> # typeid (expression)
// ti <type> # typeid (type)
-template <class C>
const char*
-parse_typeid_expr(const char* first, const char* last, C& db)
+parse_typeid_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 't' && (first[1] == 'e' || first[1] == 'i'))
{
t = parse_type(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back() = "typeid(" + db.names.back().move_full() + ")";
+ db.Names.back() = db.make<EnclosingExpr>(
+ "typeid(", db.Names.back(), ")");
first = t;
}
}
// tw <expression> # throw expression
-template <class C>
const char*
-parse_throw_expr(const char* first, const char* last, C& db)
+parse_throw_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 't' && first[1] == 'w')
{
const char* t = parse_expression(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back() = "throw " + db.names.back().move_full();
+ db.Names.back() = db.make<ThrowExpr>(db.Names.back());
first = t;
}
}
// ds <expression> <expression> # expr.*expr
-template <class C>
const char*
-parse_dot_star_expr(const char* first, const char* last, C& db)
+parse_dot_star_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 'd' && first[1] == 's')
{
const char* t1 = parse_expression(t, last, db);
if (t1 != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto expr = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first += ".*" + expr;
+ auto rhs_expr = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() = db.make<MemberExpr>(
+ db.Names.back(), ".*", rhs_expr);
first = t1;
}
}
// <simple-id> ::= <source-name> [ <template-args> ]
-template <class C>
const char*
-parse_simple_id(const char* first, const char* last, C& db)
+parse_simple_id(const char* first, const char* last, Db& db)
{
if (first != last)
{
const char* t1 = parse_template_args(t, last, db);
if (t1 != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto args = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first += std::move(args);
+ auto args = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() =
+ db.make<NameWithTemplateArgs>(db.Names.back(), args);
}
first = t1;
}
// ::= <decltype>
// ::= <substitution>
-template <class C>
const char*
-parse_unresolved_type(const char* first, const char* last, C& db)
+parse_unresolved_type(const char* first, const char* last, Db& db)
{
if (first != last)
{
{
case 'T':
{
- size_t k0 = db.names.size();
+ size_t k0 = db.Names.size();
t = parse_template_param(first, last, db);
- size_t k1 = db.names.size();
+ size_t k1 = db.Names.size();
if (t != first && k1 == k0 + 1)
{
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Subs.pushSubstitution(db.Names.back());
first = t;
}
else
{
for (; k1 != k0; --k1)
- db.names.pop_back();
+ db.Names.pop_back();
}
break;
}
t = parse_decltype(first, last, db);
if (t != first)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Subs.pushSubstitution(db.Names.back());
first = t;
}
break;
t = parse_unqualified_name(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "std::");
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Names.back() =
+ db.make<StdQualifiedName>(db.Names.back());
+ db.Subs.pushSubstitution(db.Names.back());
first = t;
}
}
// <destructor-name> ::= <unresolved-type> # e.g., ~T or ~decltype(f())
// ::= <simple-id> # e.g., ~A<2*N>
-template <class C>
const char*
-parse_destructor_name(const char* first, const char* last, C& db)
+parse_destructor_name(const char* first, const char* last, Db& db)
{
if (first != last)
{
t = parse_simple_id(first, last, db);
if (t != first)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "~");
+ db.Names.back() = db.make<DtorName>(db.Names.back());
first = t;
}
}
// ::= dn <destructor-name> # destructor or pseudo-destructor;
// # e.g. ~X or ~X<N-1>
-template <class C>
const char*
-parse_base_unresolved_name(const char* first, const char* last, C& db)
+parse_base_unresolved_name(const char* first, const char* last, Db& db)
{
if (last - first >= 2)
{
first = parse_template_args(t, last, db);
if (first != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto args = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first += std::move(args);
+ auto args = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() =
+ db.make<NameWithTemplateArgs>(
+ db.Names.back(), args);
}
}
}
first = parse_template_args(t, last, db);
if (first != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto args = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first += std::move(args);
+ auto args = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() =
+ db.make<NameWithTemplateArgs>(
+ db.Names.back(), args);
}
}
}
// <unresolved-qualifier-level> ::= <simple-id>
-template <class C>
const char*
-parse_unresolved_qualifier_level(const char* first, const char* last, C& db)
+parse_unresolved_qualifier_level(const char* first, const char* last, Db& db)
{
return parse_simple_id(first, last, db);
}
// # T::N::x /decltype(p)::N::x
// (ignored) ::= srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name>
-template <class C>
const char*
-parse_unresolved_name(const char* first, const char* last, C& db)
+parse_unresolved_name(const char* first, const char* last, Db& db)
{
if (last - first > 2)
{
{
if (global)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "::");
+ db.Names.back() =
+ db.make<GlobalQualifiedName>(db.Names.back());
}
first = t2;
}
t1 = parse_template_args(t, last, db);
if (t1 != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto args = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first += std::move(args);
+ auto args = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() = db.make<NameWithTemplateArgs>(
+ db.Names.back(), args);
t = t1;
if (t == last)
{
- db.names.pop_back();
+ db.Names.pop_back();
return first;
}
}
while (*t != 'E')
{
t1 = parse_unresolved_qualifier_level(t, last, db);
- if (t1 == t || t1 == last || db.names.size() < 2)
+ if (t1 == t || t1 == last || db.Names.size() < 2)
return first;
- auto s = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first += "::" + std::move(s);
+ auto s = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() =
+ db.make<QualifiedName>(db.Names.back(), s);
t = t1;
}
++t;
t1 = parse_base_unresolved_name(t, last, db);
if (t1 == t)
{
- if (!db.names.empty())
- db.names.pop_back();
+ if (!db.Names.empty())
+ db.Names.pop_back();
return first;
}
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto s = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first += "::" + std::move(s);
+ auto s = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() =
+ db.make<QualifiedName>(db.Names.back(), s);
first = t1;
}
else
t1 = parse_template_args(t, last, db);
if (t1 != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto args = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first += std::move(args);
+ auto args = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() =
+ db.make<NameWithTemplateArgs>(
+ db.Names.back(), args);
t = t1;
}
t1 = parse_base_unresolved_name(t, last, db);
if (t1 == t)
{
- if (!db.names.empty())
- db.names.pop_back();
+ if (!db.Names.empty())
+ db.Names.pop_back();
return first;
}
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto s = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first += "::" + std::move(s);
+ auto s = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() =
+ db.make<QualifiedName>(db.Names.back(), s);
first = t1;
}
else
t = t1;
if (global)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "::");
+ db.Names.back() =
+ db.make<GlobalQualifiedName>(
+ db.Names.back());
}
while (*t != 'E')
{
t1 = parse_unresolved_qualifier_level(t, last, db);
- if (t1 == t || t1 == last || db.names.size() < 2)
+ if (t1 == t || t1 == last || db.Names.size() < 2)
return first;
- auto s = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first += "::" + std::move(s);
+ auto s = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() = db.make<QualifiedName>(
+ db.Names.back(), s);
t = t1;
}
++t;
t1 = parse_base_unresolved_name(t, last, db);
if (t1 == t)
{
- if (!db.names.empty())
- db.names.pop_back();
+ if (!db.Names.empty())
+ db.Names.pop_back();
return first;
}
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto s = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first += "::" + std::move(s);
+ auto s = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() =
+ db.make<QualifiedName>(db.Names.back(), s);
first = t1;
}
}
// dt <expression> <unresolved-name> # expr.name
-template <class C>
const char*
-parse_dot_expr(const char* first, const char* last, C& db)
+parse_dot_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 'd' && first[1] == 't')
{
const char* t1 = parse_unresolved_name(t, last, db);
if (t1 != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto name = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.empty())
+ auto name = db.Names.back();
+ db.Names.pop_back();
+ if (db.Names.empty())
return first;
- db.names.back().first += "." + name;
+ db.Names.back() = db.make<MemberExpr>(db.Names.back(), ".", name);
first = t1;
}
}
// cl <expression>+ E # call
-template <class C>
-const char*
-parse_call_expr(const char* first, const char* last, C& db)
-{
- if (last - first >= 4 && first[0] == 'c' && first[1] == 'l')
- {
- const char* t = parse_expression(first+2, last, db);
- if (t != first+2)
- {
- if (t == last)
- return first;
- if (db.names.empty())
- return first;
- db.names.back().first += db.names.back().second;
- db.names.back().second = typename C::String();
- db.names.back().first.append("(");
- bool first_expr = true;
- while (*t != 'E')
- {
- const char* t1 = parse_expression(t, last, db);
- if (t1 == t || t1 == last)
- return first;
- if (db.names.empty())
- return first;
- auto tmp = db.names.back().move_full();
- db.names.pop_back();
- if (!tmp.empty())
- {
- if (db.names.empty())
- return first;
- if (!first_expr)
- {
- db.names.back().first.append(", ");
- first_expr = false;
- }
- db.names.back().first.append(tmp);
- }
- t = t1;
- }
- ++t;
- if (db.names.empty())
+const char*
+parse_call_expr(const char* first, const char* last, Db& db)
+{
+ if (last - first >= 4 && first[0] == 'c' && first[1] == 'l')
+ {
+ const char* t = parse_expression(first+2, last, db);
+ if (t == last || t == first + 2 || db.Names.empty())
+ return first;
+ Node* callee = db.Names.back();
+ db.Names.pop_back();
+ size_t args_begin = db.Names.size();
+ while (*t != 'E')
+ {
+ const char* t1 = parse_expression(t, last, db);
+ if (t1 == last || t1 == t)
return first;
- db.names.back().first.append(")");
- first = t;
+ t = t1;
}
+ if (db.Names.size() < args_begin)
+ return first;
+ ++t;
+ CallExpr* the_call = db.make<CallExpr>(
+ callee, db.popTrailingNodeArray(args_begin));
+ db.Names.push_back(the_call);
+ first = t;
}
return first;
}
// [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type (init)
// <initializer> ::= pi <expression>* E # parenthesized initialization
-template <class C>
const char*
-parse_new_expr(const char* first, const char* last, C& db)
+parse_new_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 4)
{
t += 2;
if (t == last)
return first;
- bool has_expr_list = false;
- bool first_expr = true;
+ size_t first_expr_in_list = db.Names.size();
+ NodeArray ExprList, init_list;
while (*t != '_')
{
const char* t1 = parse_expression(t, last, db);
if (t1 == t || t1 == last)
return first;
- has_expr_list = true;
- if (!first_expr)
- {
- if (db.names.empty())
- return first;
- auto tmp = db.names.back().move_full();
- db.names.pop_back();
- if (!tmp.empty())
- {
- if (db.names.empty())
- return first;
- db.names.back().first.append(", ");
- db.names.back().first.append(tmp);
- first_expr = false;
- }
- }
t = t1;
}
+ if (first_expr_in_list > db.Names.size())
+ return first;
+ ExprList = db.popTrailingNodeArray(first_expr_in_list);
++t;
const char* t1 = parse_type(t, last, db);
if (t1 == t || t1 == last)
{
t += 2;
has_init = true;
- first_expr = true;
+ size_t init_list_begin = db.Names.size();
while (*t != 'E')
{
t1 = parse_expression(t, last, db);
if (t1 == t || t1 == last)
return first;
- if (!first_expr)
- {
- if (db.names.empty())
- return first;
- auto tmp = db.names.back().move_full();
- db.names.pop_back();
- if (!tmp.empty())
- {
- if (db.names.empty())
- return first;
- db.names.back().first.append(", ");
- db.names.back().first.append(tmp);
- first_expr = false;
- }
- }
t = t1;
}
- }
- if (*t != 'E')
- return first;
- typename C::String init_list;
- if (has_init)
- {
- if (db.names.empty())
+ if (init_list_begin > db.Names.size())
return first;
- init_list = db.names.back().move_full();
- db.names.pop_back();
+ init_list = db.popTrailingNodeArray(init_list_begin);
}
- if (db.names.empty())
+ if (*t != 'E' || db.Names.empty())
return first;
- auto type = db.names.back().move_full();
- db.names.pop_back();
- typename C::String expr_list;
- if (has_expr_list)
- {
- if (db.names.empty())
- return first;
- expr_list = db.names.back().move_full();
- db.names.pop_back();
- }
- typename C::String r;
- if (parsed_gs)
- r = "::";
- if (is_array)
- r += "[] ";
- else
- r += " ";
- if (has_expr_list)
- r += "(" + expr_list + ") ";
- r += type;
- if (has_init)
- r += " (" + init_list + ")";
- db.names.push_back(std::move(r));
+ auto type = db.Names.back();
+ db.Names.pop_back();
+ db.Names.push_back(
+ db.make<NewExpr>(ExprList, type, init_list,
+ parsed_gs, is_array));
first = t+1;
}
}
// cv <type> <expression> # conversion with one argument
// cv <type> _ <expression>* E # conversion with a different number of arguments
-template <class C>
const char*
-parse_conversion_expr(const char* first, const char* last, C& db)
+parse_conversion_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 'c' && first[1] == 'v')
{
- bool try_to_parse_template_args = db.try_to_parse_template_args;
- db.try_to_parse_template_args = false;
+ bool TryToParseTemplateArgs = db.TryToParseTemplateArgs;
+ db.TryToParseTemplateArgs = false;
+ size_t type_begin = db.Names.size();
const char* t = parse_type(first+2, last, db);
- db.try_to_parse_template_args = try_to_parse_template_args;
+ db.TryToParseTemplateArgs = TryToParseTemplateArgs;
if (t != first+2 && t != last)
{
+ size_t expr_list_begin = db.Names.size();
if (*t != '_')
{
const char* t1 = parse_expression(t, last, db);
++t;
if (t == last)
return first;
- if (*t == 'E')
- db.names.emplace_back();
- else
+ if (*t != 'E')
{
- bool first_expr = true;
while (*t != 'E')
{
const char* t1 = parse_expression(t, last, db);
if (t1 == t || t1 == last)
return first;
- if (!first_expr)
- {
- if (db.names.empty())
- return first;
- auto tmp = db.names.back().move_full();
- db.names.pop_back();
- if (!tmp.empty())
- {
- if (db.names.empty())
- return first;
- db.names.back().first.append(", ");
- db.names.back().first.append(tmp);
- first_expr = false;
- }
- }
t = t1;
}
}
++t;
}
- if (db.names.size() < 2)
+ if (db.Names.size() < expr_list_begin ||
+ type_begin > expr_list_begin)
return first;
- auto tmp = db.names.back().move_full();
- db.names.pop_back();
- db.names.back() = "(" + db.names.back().move_full() + ")(" + tmp + ")";
+ NodeArray expressions = db.makeNodeArray(
+ db.Names.begin() + (long)expr_list_begin, db.Names.end());
+ NodeArray types = db.makeNodeArray(
+ db.Names.begin() + (long)type_begin,
+ db.Names.begin() + (long)expr_list_begin);
+ auto* conv_expr = db.make<ConversionExpr>(
+ types, expressions);
+ db.Names.dropBack(type_begin);
+ db.Names.push_back(conv_expr);
first = t;
}
}
// pt <expression> <expression> # expr->name
-template <class C>
const char*
-parse_arrow_expr(const char* first, const char* last, C& db)
+parse_arrow_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 'p' && first[1] == 't')
{
const char* t1 = parse_expression(t, last, db);
if (t1 != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto tmp = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first += "->";
- db.names.back().first += tmp;
+ auto tmp = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() = db.make<MemberExpr>(
+ db.Names.back(), "->", tmp);
first = t1;
}
}
// <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E
-template <class C>
const char*
-parse_function_type(const char* first, const char* last, C& db)
+parse_function_type(const char* first, const char* last, Db& db)
{
if (first != last && *first == 'F')
{
return first;
}
const char* t1 = parse_type(t, last, db);
- if (t1 != t)
+ if (t1 != t && !db.Names.empty())
{
+ Node* ret_type = db.Names.back();
+ db.Names.pop_back();
+ size_t params_begin = db.Names.size();
t = t1;
- typename C::String sig("(");
- int ref_qual = 0;
+ FunctionRefQual RefQuals = FrefQualNone;
while (true)
{
if (t == last)
{
- db.names.pop_back();
+ if (!db.Names.empty())
+ db.Names.pop_back();
return first;
}
if (*t == 'E')
}
if (*t == 'R' && t+1 != last && t[1] == 'E')
{
- ref_qual = 1;
+ RefQuals = FrefQualLValue;
++t;
continue;
}
if (*t == 'O' && t+1 != last && t[1] == 'E')
{
- ref_qual = 2;
+ RefQuals = FrefQualRValue;
++t;
continue;
}
- size_t k0 = db.names.size();
+ size_t k0 = db.Names.size();
t1 = parse_type(t, last, db);
- size_t k1 = db.names.size();
- if (t1 == t || t1 == last)
+ size_t k1 = db.Names.size();
+ if (t1 == t || t1 == last || k1 < k0)
return first;
- for (size_t k = k0; k < k1; ++k)
- {
- if (sig.size() > 1)
- sig += ", ";
- sig += db.names[k].move_full();
- }
- for (size_t k = k0; k < k1; ++k)
- db.names.pop_back();
t = t1;
}
- sig += ")";
- switch (ref_qual)
- {
- case 1:
- sig += " &";
- break;
- case 2:
- sig += " &&";
- break;
- }
- if (db.names.empty())
+ if (db.Names.empty() || params_begin > db.Names.size())
return first;
- db.names.back().first += " ";
- db.names.back().second.insert(0, sig);
+ Node* fty = db.make<FunctionType>(
+ ret_type, db.popTrailingNodeArray(params_begin));
+ if (RefQuals)
+ fty = db.make<FunctionRefQualType>(fty, RefQuals);
+ db.Names.push_back(fty);
first = t;
}
}
// <pointer-to-member-type> ::= M <class type> <member type>
-template <class C>
const char*
-parse_pointer_to_member_type(const char* first, const char* last, C& db)
+parse_pointer_to_member_type(const char* first, const char* last, Db& db)
{
if (first != last && *first == 'M')
{
const char* t2 = parse_type(t, last, db);
if (t2 != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto func = std::move(db.names.back());
- db.names.pop_back();
- auto class_type = std::move(db.names.back());
- if (!func.second.empty() && func.second.front() == '(')
- {
- db.names.back().first = std::move(func.first) + "(" + class_type.move_full() + "::*";
- db.names.back().second = ")" + std::move(func.second);
- }
- else
- {
- db.names.back().first = std::move(func.first) + " " + class_type.move_full() + "::*";
- db.names.back().second = std::move(func.second);
- }
+ auto func = std::move(db.Names.back());
+ db.Names.pop_back();
+ auto ClassType = std::move(db.Names.back());
+ db.Names.back() =
+ db.make<PointerToMemberType>(ClassType, func);
first = t2;
}
}
// <array-type> ::= A <positive dimension number> _ <element type>
// ::= A [<dimension expression>] _ <element type>
-template <class C>
const char*
-parse_array_type(const char* first, const char* last, C& db)
+parse_array_type(const char* first, const char* last, Db& db)
{
if (first != last && *first == 'A' && first+1 != last)
{
const char* t = parse_type(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- if (db.names.back().second.substr(0, 2) == " [")
- db.names.back().second.erase(0, 1);
- db.names.back().second.insert(0, " []");
+ db.Names.back() = db.make<ArrayType>(db.Names.back());
first = t;
}
}
const char* t2 = parse_type(t+1, last, db);
if (t2 != t+1)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- if (db.names.back().second.substr(0, 2) == " [")
- db.names.back().second.erase(0, 1);
- db.names.back().second.insert(0, " [" + typename C::String(first+1, t) + "]");
+ db.Names.back() =
+ db.make<ArrayType>(db.Names.back(),
+ StringView(first + 1, t));
first = t2;
}
}
const char* t2 = parse_type(++t, last, db);
if (t2 != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto type = std::move(db.names.back());
- db.names.pop_back();
- auto expr = std::move(db.names.back());
- db.names.back().first = std::move(type.first);
- if (type.second.substr(0, 2) == " [")
- type.second.erase(0, 1);
- db.names.back().second = " [" + expr.move_full() + "]" + std::move(type.second);
+ auto base_type = std::move(db.Names.back());
+ db.Names.pop_back();
+ auto dimension_expr = std::move(db.Names.back());
+ db.Names.back() =
+ db.make<ArrayType>(base_type, dimension_expr);
first = t2;
}
}
// <decltype> ::= Dt <expression> E # decltype of an id-expression or class member access (C++0x)
// ::= DT <expression> E # decltype of an expression (C++0x)
-template <class C>
const char*
-parse_decltype(const char* first, const char* last, C& db)
+parse_decltype(const char* first, const char* last, Db& db)
{
if (last - first >= 4 && first[0] == 'D')
{
const char* t = parse_expression(first+2, last, db);
if (t != first+2 && t != last && *t == 'E')
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back() = "decltype(" + db.names.back().move_full() + ")";
+ db.Names.back() = db.make<EnclosingExpr>(
+ "decltype(", db.Names.back(), ")");
first = t+1;
}
}
// <extended element type> ::= <element type>
// ::= p # AltiVec vector pixel
-template <class C>
const char*
-parse_vector_type(const char* first, const char* last, C& db)
+parse_vector_type(const char* first, const char* last, Db& db)
{
if (last - first > 3 && first[0] == 'D' && first[1] == 'v')
{
const char* t1 = parse_type(t, last, db);
if (t1 != t)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first += " vector[" + typename C::String(num, sz) + "]";
+ db.Names.back() =
+ db.make<VectorType>(db.Names.back(),
+ StringView(num, num + sz));
first = t1;
}
}
else
{
++t;
- db.names.push_back("pixel vector[" + typename C::String(num, sz) + "]");
+ db.Names.push_back(
+ db.make<VectorType>(StringView(num, num + sz)));
first = t;
}
}
}
else
{
- typename C::String num;
+ Node* num = nullptr;
const char* t1 = first+2;
if (*t1 != '_')
{
const char* t = parse_expression(t1, last, db);
if (t != t1)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- num = db.names.back().move_full();
- db.names.pop_back();
+ num = db.Names.back();
+ db.Names.pop_back();
t1 = t;
}
}
const char* t = parse_type(t1, last, db);
if (t != t1)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first += " vector[" + num + "]";
+ if (num)
+ db.Names.back() =
+ db.make<VectorType>(db.Names.back(), num);
+ else
+ db.Names.back() =
+ db.make<VectorType>(db.Names.back(), StringView());
first = t;
- }
+ } else if (num)
+ db.Names.push_back(num);
}
}
}
// ::= <template-template-param> <template-args>
// ::= <decltype>
// ::= <substitution>
-// ::= <CV-qualifiers> <type>
+// ::= <CV-Qualifiers> <type>
// ::= P <type> # pointer-to
// ::= R <type> # reference-to
// ::= O <type> # rvalue reference-to (C++0x)
// <objc-name> ::= <k0 number> objcproto <k1 number> <identifier> # k0 = 9 + <number of digits in k1> + k1
// <objc-type> := <source-name> # PU<11+>objcproto 11objc_object<source-name> 11objc_object -> id<source-name>
-template <class C>
const char*
-parse_type(const char* first, const char* last, C& db)
+parse_type(const char* first, const char* last, Db& db)
{
if (first != last)
{
case 'V':
case 'K':
{
- unsigned cv = 0;
+ Qualifiers cv = QualNone;
const char* t = parse_cv_qualifiers(first, last, cv);
if (t != first)
{
bool is_function = *t == 'F';
- size_t k0 = db.names.size();
+ size_t k0 = db.Names.size();
const char* t1 = parse_type(t, last, db);
- size_t k1 = db.names.size();
+ size_t k1 = db.Names.size();
if (t1 != t)
{
if (is_function)
- db.subs.pop_back();
- db.subs.emplace_back(db.names.get_allocator());
+ db.Subs.popPack();
+ db.Subs.pushPack();
for (size_t k = k0; k < k1; ++k)
{
- if (is_function)
- {
- size_t p = db.names[k].second.size();
- if (db.names[k].second[p-2] == '&')
- p -= 3;
- else if (db.names[k].second.back() == '&')
- p -= 2;
- if (cv & 1)
- {
- db.names[k].second.insert(p, " const");
- p += 6;
- }
- if (cv & 2)
- {
- db.names[k].second.insert(p, " volatile");
- p += 9;
- }
- if (cv & 4)
- db.names[k].second.insert(p, " restrict");
- }
- else
- {
- if (cv & 1)
- db.names[k].first.append(" const");
- if (cv & 2)
- db.names[k].first.append(" volatile");
- if (cv & 4)
- db.names[k].first.append(" restrict");
+ if (cv) {
+ if (is_function)
+ db.Names[k] = db.make<FunctionQualType>(
+ db.Names[k], cv);
+ else
+ db.Names[k] =
+ db.make<QualType>(db.Names[k], cv);
}
- db.subs.back().push_back(db.names[k]);
+ db.Subs.pushSubstitutionIntoPack(db.Names[k]);
}
first = t1;
}
t = parse_array_type(first, last, db);
if (t != first)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
first = t;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Subs.pushSubstitution(db.Names.back());
}
break;
case 'C':
t = parse_type(first+1, last, db);
if (t != first+1)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.append(" complex");
+ db.Names.back() = db.make<PostfixQualifiedType>(
+ db.Names.back(), " complex");
first = t;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Subs.pushSubstitution(db.Names.back());
}
break;
case 'F':
t = parse_function_type(first, last, db);
if (t != first)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
first = t;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Subs.pushSubstitution(db.Names.back());
}
break;
case 'G':
t = parse_type(first+1, last, db);
if (t != first+1)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.append(" imaginary");
+ db.Names.back() = db.make<PostfixQualifiedType>(
+ db.Names.back(), " imaginary");
first = t;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Subs.pushSubstitution(db.Names.back());
}
break;
case 'M':
t = parse_pointer_to_member_type(first, last, db);
if (t != first)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
first = t;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Subs.pushSubstitution(db.Names.back());
}
break;
case 'O':
{
- size_t k0 = db.names.size();
+ size_t k0 = db.Names.size();
t = parse_type(first+1, last, db);
- size_t k1 = db.names.size();
+ size_t k1 = db.Names.size();
if (t != first+1)
{
- db.subs.emplace_back(db.names.get_allocator());
+ db.Subs.pushPack();
for (size_t k = k0; k < k1; ++k)
{
- if (db.names[k].second.substr(0, 2) == " [")
- {
- db.names[k].first += " (";
- db.names[k].second.insert(0, ")");
- }
- else if (!db.names[k].second.empty() &&
- db.names[k].second.front() == '(')
- {
- db.names[k].first += "(";
- db.names[k].second.insert(0, ")");
- }
- db.names[k].first.append("&&");
- db.subs.back().push_back(db.names[k]);
+ db.Names[k] =
+ db.make<RValueReferenceType>(db.Names[k]);
+ db.Subs.pushSubstitutionIntoPack(db.Names[k]);
}
first = t;
}
}
case 'P':
{
- size_t k0 = db.names.size();
+ size_t k0 = db.Names.size();
t = parse_type(first+1, last, db);
- size_t k1 = db.names.size();
+ size_t k1 = db.Names.size();
if (t != first+1)
{
- db.subs.emplace_back(db.names.get_allocator());
+ db.Subs.pushPack();
for (size_t k = k0; k < k1; ++k)
{
- if (db.names[k].second.substr(0, 2) == " [")
- {
- db.names[k].first += " (";
- db.names[k].second.insert(0, ")");
- }
- else if (!db.names[k].second.empty() &&
- db.names[k].second.front() == '(')
- {
- db.names[k].first += "(";
- db.names[k].second.insert(0, ")");
- }
- if (first[1] != 'U' || db.names[k].first.substr(0, 12) != "objc_object<")
- {
- db.names[k].first.append("*");
- }
- else
- {
- db.names[k].first.replace(0, 11, "id");
- }
- db.subs.back().push_back(db.names[k]);
+ db.Names[k] = db.make<PointerType>(db.Names[k]);
+ db.Subs.pushSubstitutionIntoPack(db.Names[k]);
}
first = t;
}
}
case 'R':
{
- size_t k0 = db.names.size();
+ size_t k0 = db.Names.size();
t = parse_type(first+1, last, db);
- size_t k1 = db.names.size();
+ size_t k1 = db.Names.size();
if (t != first+1)
{
- db.subs.emplace_back(db.names.get_allocator());
+ db.Subs.pushPack();
for (size_t k = k0; k < k1; ++k)
{
- if (db.names[k].second.substr(0, 2) == " [")
- {
- db.names[k].first += " (";
- db.names[k].second.insert(0, ")");
- }
- else if (!db.names[k].second.empty() &&
- db.names[k].second.front() == '(')
- {
- db.names[k].first += "(";
- db.names[k].second.insert(0, ")");
- }
- db.names[k].first.append("&");
- db.subs.back().push_back(db.names[k]);
+ db.Names[k] =
+ db.make<LValueReferenceType>(db.Names[k]);
+ db.Subs.pushSubstitutionIntoPack(db.Names[k]);
}
first = t;
}
}
case 'T':
{
- size_t k0 = db.names.size();
+ size_t k0 = db.Names.size();
t = parse_template_param(first, last, db);
- size_t k1 = db.names.size();
+ size_t k1 = db.Names.size();
if (t != first)
{
- db.subs.emplace_back(db.names.get_allocator());
+ db.Subs.pushPack();
for (size_t k = k0; k < k1; ++k)
- db.subs.back().push_back(db.names[k]);
- if (db.try_to_parse_template_args && k1 == k0+1)
+ db.Subs.pushSubstitutionIntoPack(db.Names[k]);
+ if (db.TryToParseTemplateArgs && k1 == k0+1)
{
const char* t1 = parse_template_args(t, last, db);
if (t1 != t)
{
- auto args = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first += std::move(args);
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ auto args = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() = db.make<
+ NameWithTemplateArgs>(
+ db.Names.back(), args);
+ db.Subs.pushSubstitution(db.Names.back());
t = t1;
}
}
const char* t2 = parse_type(t, last, db);
if (t2 != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto type = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.back().first.substr(0, 9) != "objcproto")
+ auto type = db.Names.back();
+ db.Names.pop_back();
+ if (db.Names.back()->K != Node::KNameType ||
+ !static_cast<NameType*>(db.Names.back())->getName().startsWith("objcproto"))
{
- db.names.back() = type + " " + db.names.back().move_full();
+ db.Names.back() = db.make<VendorExtQualType>(type, db.Names.back());
}
else
{
- auto proto = db.names.back().move_full();
- db.names.pop_back();
- t = parse_source_name(proto.data() + 9, proto.data() + proto.size(), db);
- if (t != proto.data() + 9)
+ auto* proto = static_cast<NameType*>(db.Names.back());
+ db.Names.pop_back();
+ t = parse_source_name(proto->getName().begin() + 9, proto->getName().end(), db);
+ if (t != proto->getName().begin() + 9)
{
- db.names.back() = type + "<" + db.names.back().move_full() + ">";
+ db.Names.back() = db.make<ObjCProtoName>(type, db.Names.back());
}
else
{
- db.names.push_back(type + " " + proto);
+ db.Names.push_back(db.make<VendorExtQualType>(type, proto));
}
}
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Subs.pushSubstitution(db.Names.back());
first = t2;
}
}
t = parse_name(first, last, db);
if (t != first)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Subs.pushSubstitution(db.Names.back());
first = t;
}
}
first = t;
// Parsed a substitution. If the substitution is a
// <template-param> it might be followed by <template-args>.
- t = parse_template_args(first, last, db);
- if (t != first)
+ if (db.TryToParseTemplateArgs)
{
- if (db.names.size() < 2)
- return first;
- auto template_args = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first += template_args;
- // Need to create substitution for <template-template-param> <template-args>
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
- first = t;
+ t = parse_template_args(first, last, db);
+ if (t != first)
+ {
+ if (db.Names.size() < 2)
+ return first;
+ auto template_args = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() = db.make<
+ NameWithTemplateArgs>(
+ db.Names.back(), template_args);
+ // Need to create substitution for <template-template-param> <template-args>
+ db.Subs.pushSubstitution(db.Names.back());
+ first = t;
+ }
}
}
}
{
case 'p':
{
- size_t k0 = db.names.size();
+ size_t k0 = db.Names.size();
t = parse_type(first+2, last, db);
- size_t k1 = db.names.size();
+ size_t k1 = db.Names.size();
if (t != first+2)
{
- db.subs.emplace_back(db.names.get_allocator());
+ db.Subs.pushPack();
for (size_t k = k0; k < k1; ++k)
- db.subs.back().push_back(db.names[k]);
+ db.Subs.pushSubstitutionIntoPack(db.Names[k]);
first = t;
return first;
}
t = parse_decltype(first, last, db);
if (t != first)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Subs.pushSubstitution(db.Names.back());
first = t;
return first;
}
t = parse_vector_type(first, last, db);
if (t != first)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Subs.pushSubstitution(db.Names.back());
first = t;
return first;
}
break;
}
}
- // drop through
+ _LIBCPP_FALLTHROUGH();
default:
// must check for builtin-types before class-enum-types to avoid
// ambiguities with operator-names
t = parse_name(first, last, db);
if (t != first)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Subs.pushSubstitution(db.Names.back());
first = t;
}
}
// ::= rs # >>
// ::= rS # >>=
// ::= v <digit> <source-name> # vendor extended operator
-
-template <class C>
+// extension ::= <operator-name> <abi-tag-seq>
const char*
-parse_operator_name(const char* first, const char* last, C& db)
+parse_operator_name(const char* first, const char* last, Db& db)
{
+ const char* original_first = first;
if (last - first >= 2)
{
switch (first[0])
switch (first[1])
{
case 'a':
- db.names.push_back("operator&&");
+ db.Names.push_back(db.make<NameType>("operator&&"));
first += 2;
break;
case 'd':
case 'n':
- db.names.push_back("operator&");
+ db.Names.push_back(db.make<NameType>("operator&"));
first += 2;
break;
case 'N':
- db.names.push_back("operator&=");
+ db.Names.push_back(db.make<NameType>("operator&="));
first += 2;
break;
case 'S':
- db.names.push_back("operator=");
+ db.Names.push_back(db.make<NameType>("operator="));
first += 2;
break;
}
switch (first[1])
{
case 'l':
- db.names.push_back("operator()");
+ db.Names.push_back(db.make<NameType>("operator()"));
first += 2;
break;
case 'm':
- db.names.push_back("operator,");
+ db.Names.push_back(db.make<NameType>("operator,"));
first += 2;
break;
case 'o':
- db.names.push_back("operator~");
+ db.Names.push_back(db.make<NameType>("operator~"));
first += 2;
break;
case 'v':
{
- bool try_to_parse_template_args = db.try_to_parse_template_args;
- db.try_to_parse_template_args = false;
+ bool TryToParseTemplateArgs = db.TryToParseTemplateArgs;
+ db.TryToParseTemplateArgs = false;
const char* t = parse_type(first+2, last, db);
- db.try_to_parse_template_args = try_to_parse_template_args;
+ db.TryToParseTemplateArgs = TryToParseTemplateArgs;
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "operator ");
- db.parsed_ctor_dtor_cv = true;
+ db.Names.back() =
+ db.make<ConversionOperatorType>(db.Names.back());
+ db.ParsedCtorDtorCV = true;
first = t;
}
}
switch (first[1])
{
case 'a':
- db.names.push_back("operator delete[]");
+ db.Names.push_back(db.make<NameType>("operator delete[]"));
first += 2;
break;
case 'e':
- db.names.push_back("operator*");
+ db.Names.push_back(db.make<NameType>("operator*"));
first += 2;
break;
case 'l':
- db.names.push_back("operator delete");
+ db.Names.push_back(db.make<NameType>("operator delete"));
first += 2;
break;
case 'v':
- db.names.push_back("operator/");
+ db.Names.push_back(db.make<NameType>("operator/"));
first += 2;
break;
case 'V':
- db.names.push_back("operator/=");
+ db.Names.push_back(db.make<NameType>("operator/="));
first += 2;
break;
}
switch (first[1])
{
case 'o':
- db.names.push_back("operator^");
+ db.Names.push_back(db.make<NameType>("operator^"));
first += 2;
break;
case 'O':
- db.names.push_back("operator^=");
+ db.Names.push_back(db.make<NameType>("operator^="));
first += 2;
break;
case 'q':
- db.names.push_back("operator==");
+ db.Names.push_back(db.make<NameType>("operator=="));
first += 2;
break;
}
switch (first[1])
{
case 'e':
- db.names.push_back("operator>=");
+ db.Names.push_back(db.make<NameType>("operator>="));
first += 2;
break;
case 't':
- db.names.push_back("operator>");
+ db.Names.push_back(db.make<NameType>("operator>"));
first += 2;
break;
}
case 'i':
if (first[1] == 'x')
{
- db.names.push_back("operator[]");
+ db.Names.push_back(db.make<NameType>("operator[]"));
first += 2;
}
break;
switch (first[1])
{
case 'e':
- db.names.push_back("operator<=");
+ db.Names.push_back(db.make<NameType>("operator<="));
first += 2;
break;
case 'i':
const char* t = parse_source_name(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "operator\"\" ");
+ db.Names.back() =
+ db.make<LiteralOperator>(db.Names.back());
first = t;
}
}
break;
case 's':
- db.names.push_back("operator<<");
+ db.Names.push_back(db.make<NameType>("operator<<"));
first += 2;
break;
case 'S':
- db.names.push_back("operator<<=");
+ db.Names.push_back(db.make<NameType>("operator<<="));
first += 2;
break;
case 't':
- db.names.push_back("operator<");
+ db.Names.push_back(db.make<NameType>("operator<"));
first += 2;
break;
}
switch (first[1])
{
case 'i':
- db.names.push_back("operator-");
+ db.Names.push_back(db.make<NameType>("operator-"));
first += 2;
break;
case 'I':
- db.names.push_back("operator-=");
+ db.Names.push_back(db.make<NameType>("operator-="));
first += 2;
break;
case 'l':
- db.names.push_back("operator*");
+ db.Names.push_back(db.make<NameType>("operator*"));
first += 2;
break;
case 'L':
- db.names.push_back("operator*=");
+ db.Names.push_back(db.make<NameType>("operator*="));
first += 2;
break;
case 'm':
- db.names.push_back("operator--");
+ db.Names.push_back(db.make<NameType>("operator--"));
first += 2;
break;
}
switch (first[1])
{
case 'a':
- db.names.push_back("operator new[]");
+ db.Names.push_back(db.make<NameType>("operator new[]"));
first += 2;
break;
case 'e':
- db.names.push_back("operator!=");
+ db.Names.push_back(db.make<NameType>("operator!="));
first += 2;
break;
case 'g':
- db.names.push_back("operator-");
+ db.Names.push_back(db.make<NameType>("operator-"));
first += 2;
break;
case 't':
- db.names.push_back("operator!");
+ db.Names.push_back(db.make<NameType>("operator!"));
first += 2;
break;
case 'w':
- db.names.push_back("operator new");
+ db.Names.push_back(db.make<NameType>("operator new"));
first += 2;
break;
}
switch (first[1])
{
case 'o':
- db.names.push_back("operator||");
+ db.Names.push_back(db.make<NameType>("operator||"));
first += 2;
break;
case 'r':
- db.names.push_back("operator|");
+ db.Names.push_back(db.make<NameType>("operator|"));
first += 2;
break;
case 'R':
- db.names.push_back("operator|=");
+ db.Names.push_back(db.make<NameType>("operator|="));
first += 2;
break;
}
switch (first[1])
{
case 'm':
- db.names.push_back("operator->*");
+ db.Names.push_back(db.make<NameType>("operator->*"));
first += 2;
break;
case 'l':
- db.names.push_back("operator+");
+ db.Names.push_back(db.make<NameType>("operator+"));
first += 2;
break;
case 'L':
- db.names.push_back("operator+=");
+ db.Names.push_back(db.make<NameType>("operator+="));
first += 2;
break;
case 'p':
- db.names.push_back("operator++");
+ db.Names.push_back(db.make<NameType>("operator++"));
first += 2;
break;
case 's':
- db.names.push_back("operator+");
+ db.Names.push_back(db.make<NameType>("operator+"));
first += 2;
break;
case 't':
- db.names.push_back("operator->");
+ db.Names.push_back(db.make<NameType>("operator->"));
first += 2;
break;
}
case 'q':
if (first[1] == 'u')
{
- db.names.push_back("operator?");
+ db.Names.push_back(db.make<NameType>("operator?"));
first += 2;
}
break;
switch (first[1])
{
case 'm':
- db.names.push_back("operator%");
+ db.Names.push_back(db.make<NameType>("operator%"));
first += 2;
break;
case 'M':
- db.names.push_back("operator%=");
+ db.Names.push_back(db.make<NameType>("operator%="));
first += 2;
break;
case 's':
- db.names.push_back("operator>>");
+ db.Names.push_back(db.make<NameType>("operator>>"));
first += 2;
break;
case 'S':
- db.names.push_back("operator>>=");
+ db.Names.push_back(db.make<NameType>("operator>>="));
first += 2;
break;
}
const char* t = parse_source_name(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "operator ");
+ db.Names.back() =
+ db.make<ConversionOperatorType>(db.Names.back());
first = t;
}
}
break;
}
}
+
+ if (original_first != first)
+ first = parse_abi_tag_seq(first, last, db);
+
return first;
}
-template <class C>
const char*
-parse_integer_literal(const char* first, const char* last, const typename C::String& lit, C& db)
+parse_integer_literal(const char* first, const char* last, StringView lit, Db& db)
{
const char* t = parse_number(first, last);
if (t != first && t != last && *t == 'E')
{
- if (lit.size() > 3)
- db.names.push_back("(" + lit + ")");
- else
- db.names.emplace_back();
- if (*first == 'n')
- {
- db.names.back().first += '-';
- ++first;
- }
- db.names.back().first.append(first, t);
- if (lit.size() <= 3)
- db.names.back().first += lit;
+ db.Names.push_back(
+ db.make<IntegerExpr>(lit, StringView(first, t)));
first = t+1;
}
return first;
// ::= L <type> <real-part float> _ <imag-part float> E # complex floating point literal (C 2000)
// ::= L <mangled-name> E # external name
-template <class C>
const char*
-parse_expr_primary(const char* first, const char* last, C& db)
+parse_expr_primary(const char* first, const char* last, Db& db)
{
if (last - first >= 4 && *first == 'L')
{
switch (first[2])
{
case '0':
- db.names.push_back("false");
+ db.Names.push_back(db.make<BoolExpr>(0));
first += 4;
break;
case '1':
- db.names.push_back("true");
+ db.Names.push_back(db.make<BoolExpr>(1));
first += 4;
break;
}
;
if (n != t && n != last && *n == 'E')
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back() = "(" + db.names.back().move_full() + ")" + typename C::String(t, n);
+ db.Names.back() = db.make<IntegerCastExpr>(
+ db.Names.back(), StringView(t, n));
first = n+1;
break;
}
return first;
}
-template <class String>
-String
-base_name(String& s)
+Node* maybe_change_special_sub_name(Node* inp, Db& db)
{
- if (s.empty())
- return s;
- if (s == "std::string")
- {
- s = "std::basic_string<char, std::char_traits<char>, std::allocator<char> >";
- return "basic_string";
- }
- if (s == "std::istream")
- {
- s = "std::basic_istream<char, std::char_traits<char> >";
- return "basic_istream";
- }
- if (s == "std::ostream")
+ if (inp->K != Node::KSpecialSubstitution)
+ return inp;
+ auto Kind = static_cast<SpecialSubstitution*>(inp)->SSK;
+ switch (Kind)
{
- s = "std::basic_ostream<char, std::char_traits<char> >";
- return "basic_ostream";
+ case SpecialSubKind::string:
+ case SpecialSubKind::istream:
+ case SpecialSubKind::ostream:
+ case SpecialSubKind::iostream:
+ return db.make<ExpandedSpecialSubstitution>(Kind);
+ default:
+ break;
}
- if (s == "std::iostream")
- {
- s = "std::basic_iostream<char, std::char_traits<char> >";
- return "basic_iostream";
- }
- const char* const pf = s.data();
- const char* pe = pf + s.size();
- if (pe[-1] == '>')
- {
- unsigned c = 1;
- while (true)
- {
- if (--pe == pf)
- return String();
- if (pe[-1] == '<')
- {
- if (--c == 0)
- {
- --pe;
- break;
- }
- }
- else if (pe[-1] == '>')
- ++c;
- }
- }
- if (pe - pf <= 1)
- return String();
- const char* p0 = pe - 1;
- for (; p0 != pf; --p0)
- {
- if (*p0 == ':')
- {
- ++p0;
- break;
- }
- }
- return String(p0, pe);
+ return inp;
}
// <ctor-dtor-name> ::= C1 # complete object constructor
// ::= D1 # complete object destructor
// ::= D2 # base object destructor
// extension ::= D5 # ?
-
-template <class C>
+// extension ::= <ctor-dtor-name> <abi-tag-seq>
const char*
-parse_ctor_dtor_name(const char* first, const char* last, C& db)
+parse_ctor_dtor_name(const char* first, const char* last, Db& db)
{
- if (last-first >= 2 && !db.names.empty())
+ if (last-first >= 2 && !db.Names.empty())
{
switch (first[0])
{
case '2':
case '3':
case '5':
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.push_back(base_name(db.names.back().first));
+ db.Names.back() =
+ maybe_change_special_sub_name(db.Names.back(), db);
+ db.Names.push_back(
+ db.make<CtorDtorName>(db.Names.back(), false));
first += 2;
- db.parsed_ctor_dtor_cv = true;
+ first = parse_abi_tag_seq(first, last, db);
+ db.ParsedCtorDtorCV = true;
break;
}
break;
case '1':
case '2':
case '5':
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.push_back("~" + base_name(db.names.back().first));
+ db.Names.push_back(
+ db.make<CtorDtorName>(db.Names.back(), true));
first += 2;
- db.parsed_ctor_dtor_cv = true;
+ first = parse_abi_tag_seq(first, last, db);
+ db.ParsedCtorDtorCV = true;
break;
}
break;
return first;
}
-// <unnamed-type-name> ::= Ut [ <nonnegative number> ] _
+// <unnamed-type-name> ::= Ut [<nonnegative number>] _ [<abi-tag-seq>]
// ::= <closure-type-name>
//
// <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
//
// <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters
-
-template <class C>
const char*
-parse_unnamed_type_name(const char* first, const char* last, C& db)
+parse_unnamed_type_name(const char* first, const char* last, Db& db)
{
if (last - first > 2 && first[0] == 'U')
{
{
case 't':
{
- db.names.push_back(typename C::String("'unnamed"));
const char* t0 = first+2;
if (t0 == last)
- {
- db.names.pop_back();
return first;
- }
+ StringView count;
if (std::isdigit(*t0))
{
const char* t1 = t0 + 1;
while (t1 != last && std::isdigit(*t1))
++t1;
- db.names.back().first.append(t0, t1);
+ count = StringView(t0, t1);
t0 = t1;
}
- db.names.back().first.push_back('\'');
if (t0 == last || *t0 != '_')
- {
- db.names.pop_back();
return first;
- }
+ db.Names.push_back(db.make<UnnamedTypeName>(count));
first = t0 + 1;
+ first = parse_abi_tag_seq(first, last, db);
}
break;
case 'l':
{
- db.names.push_back(typename C::String("'lambda'("));
+ size_t begin_pos = db.Names.size();
const char* t0 = first+2;
+ NodeArray lambda_params;
if (first[2] == 'v')
{
- db.names.back().first += ')';
++t0;
}
else
{
- const char* t1 = parse_type(t0, last, db);
- if (t1 == t0)
- {
- if(!db.names.empty())
- db.names.pop_back();
- return first;
- }
- if (db.names.size() < 2)
- return first;
- auto tmp = db.names.back().move_full();
- db.names.pop_back();
- db.names.back().first.append(tmp);
- t0 = t1;
while (true)
{
- t1 = parse_type(t0, last, db);
+ const char* t1 = parse_type(t0, last, db);
if (t1 == t0)
break;
- if (db.names.size() < 2)
- return first;
- tmp = db.names.back().move_full();
- db.names.pop_back();
- if (!tmp.empty())
- {
- db.names.back().first.append(", ");
- db.names.back().first.append(tmp);
- }
t0 = t1;
}
- if(db.names.empty())
- return first;
- db.names.back().first.append(")");
+ if (db.Names.size() < begin_pos)
+ return first;
+ lambda_params = db.popTrailingNodeArray(begin_pos);
}
if (t0 == last || *t0 != 'E')
- {
- if(!db.names.empty())
- db.names.pop_back();
return first;
- }
++t0;
if (t0 == last)
- {
- if(!db.names.empty())
- db.names.pop_back();
return first;
- }
+ StringView count;
if (std::isdigit(*t0))
{
const char* t1 = t0 + 1;
while (t1 != last && std::isdigit(*t1))
++t1;
- db.names.back().first.insert(db.names.back().first.begin()+7, t0, t1);
+ count = StringView(t0, t1);
t0 = t1;
}
if (t0 == last || *t0 != '_')
- {
- if(!db.names.empty())
- db.names.pop_back();
return first;
- }
+ db.Names.push_back(db.make<LambdaTypeName>(lambda_params, count));
first = t0 + 1;
}
break;
// ::= <source-name>
// ::= <unnamed-type-name>
-template <class C>
const char*
-parse_unqualified_name(const char* first, const char* last, C& db)
+parse_unqualified_name(const char* first, const char* last, Db& db)
{
if (first != last)
{
// ::= St <unqualified-name> # ::std::
// extension ::= StL<unqualified-name>
-template <class C>
const char*
-parse_unscoped_name(const char* first, const char* last, C& db)
+parse_unscoped_name(const char* first, const char* last, Db& db)
{
if (last - first >= 2)
{
{
if (St)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "std::");
+ db.Names.back() =
+ db.make<StdQualifiedName>(db.Names.back());
}
first = t1;
}
// at <type> # alignof (a type)
-template <class C>
const char*
-parse_alignof_type(const char* first, const char* last, C& db)
+parse_alignof_type(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 'a' && first[1] == 't')
{
const char* t = parse_type(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first = "alignof (" + db.names.back().move_full() + ")";
+ db.Names.back() =
+ db.make<EnclosingExpr>("alignof (", db.Names.back(), ")");
first = t;
}
}
// az <expression> # alignof (a expression)
-template <class C>
const char*
-parse_alignof_expr(const char* first, const char* last, C& db)
+parse_alignof_expr(const char* first, const char* last, Db& db)
{
if (last - first >= 3 && first[0] == 'a' && first[1] == 'z')
{
const char* t = parse_expression(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first = "alignof (" + db.names.back().move_full() + ")";
+ db.Names.back() =
+ db.make<EnclosingExpr>("alignof (", db.Names.back(), ")");
first = t;
}
}
return first;
}
-template <class C>
const char*
-parse_noexcept_expression(const char* first, const char* last, C& db)
+parse_noexcept_expression(const char* first, const char* last, Db& db)
{
const char* t1 = parse_expression(first, last, db);
if (t1 != first)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first = "noexcept (" + db.names.back().move_full() + ")";
+ db.Names.back() =
+ db.make<EnclosingExpr>("noexcept (", db.Names.back(), ")");
first = t1;
}
return first;
}
-template <class C>
const char*
-parse_prefix_expression(const char* first, const char* last, const typename C::String& op, C& db)
+parse_prefix_expression(const char* first, const char* last, StringView op, Db& db)
{
const char* t1 = parse_expression(first, last, db);
if (t1 != first)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first = op + "(" + db.names.back().move_full() + ")";
+ db.Names.back() = db.make<PrefixExpr>(op, db.Names.back());
first = t1;
}
return first;
}
-template <class C>
const char*
-parse_binary_expression(const char* first, const char* last, const typename C::String& op, C& db)
+parse_binary_expression(const char* first, const char* last, StringView op, Db& db)
{
const char* t1 = parse_expression(first, last, db);
if (t1 != first)
const char* t2 = parse_expression(t1, last, db);
if (t2 != t1)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto op2 = db.names.back().move_full();
- db.names.pop_back();
- auto op1 = db.names.back().move_full();
- auto& nm = db.names.back().first;
- nm.clear();
- if (op == ">")
- nm += '(';
- nm += "(" + op1 + ") " + op + " (" + op2 + ")";
- if (op == ">")
- nm += ')';
+ auto op2 = db.Names.back();
+ db.Names.pop_back();
+ auto op1 = db.Names.back();
+ db.Names.back() = db.make<BinaryExpr>(op1, op, op2);
first = t2;
}
- else if(!db.names.empty())
- db.names.pop_back();
}
return first;
}
// # objectless nonstatic member reference
// ::= <expr-primary>
-template <class C>
const char*
-parse_expression(const char* first, const char* last, C& db)
+parse_expression(const char* first, const char* last, Db& db)
{
if (last - first >= 2)
{
const char* t1 = parse_expression(t+2, last, db);
if (t1 != t+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first = (parsed_gs ? typename C::String("::") : typename C::String()) +
- "delete[] " + db.names.back().move_full();
+ db.Names.back() = db.make<DeleteExpr>(
+ db.Names.back(), parsed_gs, /*is_array=*/true);
first = t1;
}
}
const char* t1 = parse_expression(t+2, last, db);
if (t1 != t+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first = (parsed_gs ? typename C::String("::") : typename C::String()) +
- "delete " + db.names.back().move_full();
+ db.Names.back() = db.make<DeleteExpr>(
+ db.Names.back(), parsed_gs, /*is_array=*/false);
first = t1;
}
}
const char* t2 = parse_expression(t1, last, db);
if (t2 != t1)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto op2 = db.names.back().move_full();
- db.names.pop_back();
- auto op1 = db.names.back().move_full();
- db.names.back() = "(" + op1 + ")[" + op2 + "]";
+ auto op2 = db.Names.back();
+ db.Names.pop_back();
+ auto op1 = db.Names.back();
+ db.Names.back() =
+ db.make<ArraySubscriptExpr>(op1, op2);
first = t2;
}
- else if (!db.names.empty())
- db.names.pop_back();
+ else if (!db.Names.empty())
+ db.Names.pop_back();
}
}
break;
const char* t1 = parse_expression(first+2, last, db);
if (t1 != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back() = "(" + db.names.back().move_full() + ")--";
+ db.Names.back() =
+ db.make<PostfixExpr>(db.Names.back(), "--");
first = t1;
}
}
const char* t1 = parse_expression(first+2, last, db);
if (t1 != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back() = "(" + db.names.back().move_full() + ")++";
+ db.Names.back() =
+ db.make<PostfixExpr>(db.Names.back(), "++");
first = t1;
}
}
const char* t3 = parse_expression(t2, last, db);
if (t3 != t2)
{
- if (db.names.size() < 3)
+ if (db.Names.size() < 3)
return first;
- auto op3 = db.names.back().move_full();
- db.names.pop_back();
- auto op2 = db.names.back().move_full();
- db.names.pop_back();
- auto op1 = db.names.back().move_full();
- db.names.back() = "(" + op1 + ") ? (" + op2 + ") : (" + op3 + ")";
+ auto op3 = db.Names.back();
+ db.Names.pop_back();
+ auto op2 = db.Names.back();
+ db.Names.pop_back();
+ auto op1 = db.Names.back();
+ db.Names.back() =
+ db.make<ConditionalExpr>(op1, op2, op3);
first = t3;
}
else
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- db.names.pop_back();
- db.names.pop_back();
+ db.Names.pop_back();
+ db.Names.pop_back();
}
}
- else if (!db.names.empty())
- db.names.pop_back();
+ else if (!db.Names.empty())
+ db.Names.pop_back();
}
}
break;
first = parse_typeid_expr(first, last, db);
break;
case 'r':
- db.names.push_back("throw");
+ db.Names.push_back(db.make<NameType>("throw"));
first += 2;
break;
case 'w':
// ::= J <template-arg>* E # argument pack
// ::= LZ <encoding> E # extension
-template <class C>
const char*
-parse_template_arg(const char* first, const char* last, C& db)
+parse_template_arg(const char* first, const char* last, Db& db)
{
if (first != last)
{
// <template-args> ::= I <template-arg>* E
// extension, the abi says <template-arg>+
-template <class C>
const char*
-parse_template_args(const char* first, const char* last, C& db)
+parse_template_args(const char* first, const char* last, Db& db)
{
if (last - first >= 2 && *first == 'I')
{
- if (db.tag_templates)
- db.template_param.back().clear();
+ if (db.TagTemplates)
+ db.TemplateParams.clear();
const char* t = first+1;
- typename C::String args("<");
+ size_t begin_idx = db.Names.size();
while (*t != 'E')
{
- if (db.tag_templates)
- db.template_param.emplace_back(db.names.get_allocator());
- size_t k0 = db.names.size();
- const char* t1 = parse_template_arg(t, last, db);
- size_t k1 = db.names.size();
- if (db.tag_templates)
- db.template_param.pop_back();
- if (t1 == t || t1 == last)
- return first;
- if (db.tag_templates)
+ if (db.TagTemplates)
{
- db.template_param.back().emplace_back(db.names.get_allocator());
+ auto TmpParams = std::move(db.TemplateParams);
+ size_t k0 = db.Names.size();
+ const char* t1 = parse_template_arg(t, last, db);
+ size_t k1 = db.Names.size();
+ db.TemplateParams = std::move(TmpParams);
+
+ if (t1 == t || t1 == last || k0 > k1)
+ return first;
+ db.TemplateParams.pushPack();
for (size_t k = k0; k < k1; ++k)
- db.template_param.back().back().push_back(db.names[k]);
- }
- for (size_t k = k0; k < k1; ++k)
- {
- if (args.size() > 1)
- args += ", ";
- args += db.names[k].move_full();
+ db.TemplateParams.pushSubstitutionIntoPack(db.Names[k]);
+ t = t1;
+ continue;
}
- for (; k1 > k0; --k1)
- if (!db.names.empty())
- db.names.pop_back();
+ size_t k0 = db.Names.size();
+ const char* t1 = parse_template_arg(t, last, db);
+ size_t k1 = db.Names.size();
+ if (t1 == t || t1 == last || k0 > k1)
+ return first;
t = t1;
}
+ if (begin_idx > db.Names.size())
+ return first;
first = t + 1;
- if (args.back() != '>')
- args += ">";
- else
- args += " >";
- db.names.push_back(std::move(args));
-
+ TemplateParams* tp = db.make<TemplateParams>(
+ db.popTrailingNodeArray(begin_idx));
+ db.Names.push_back(tp);
}
return first;
}
-// <nested-name> ::= N [<CV-
qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
-// ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
+// <nested-name> ::= N [<CV-
Qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
+// ::= N [<CV-Qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
//
// <prefix> ::= <prefix> <unqualified-name>
// ::= <template-prefix> <template-args>
// ::= <template-param>
// ::= <substitution>
-template <class C>
const char*
-parse_nested_name(const char* first, const char* last, C& db,
+parse_nested_name(const char* first, const char* last, Db& db,
bool* ends_with_template_args)
{
if (first != last && *first == 'N')
{
- unsigned cv;
+ Qualifiers cv;
const char* t0 = parse_cv_qualifiers(first+1, last, cv);
if (t0 == last)
return first;
- db.ref = 0;
+ db.RefQuals = FrefQualNone;
if (*t0 == 'R')
{
- db.ref = 1;
+ db.RefQuals = FrefQualLValue;
++t0;
}
else if (*t0 == 'O')
{
- db.ref = 2;
+ db.RefQuals = FrefQualRValue;
++t0;
}
- db.names.emplace_back();
+ db.Names.push_back(db.make<EmptyName>());
if (last - t0 >= 2 && t0[0] == 'S' && t0[1] == 't')
{
t0 += 2;
- db.names.back().first = "std";
+ db.Names.back() = db.make<NameType>("std");
}
if (t0 == last)
- {
- db.names.pop_back();
return first;
- }
bool pop_subs = false;
bool component_ends_with_template_args = false;
while (*t0 != 'E')
t1 = parse_substitution(t0, last, db);
if (t1 != t0 && t1 != last)
{
- auto name = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.empty())
+ if (db.Names.size() < 2)
return first;
- if (!db.names.back().first.empty())
+ auto name = db.Names.back();
+ db.Names.pop_back();
+ if (db.Names.back()->K != Node::KEmptyName)
{
- db.names.back().first += "::" + name;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Names.back() = db.make<QualifiedName>(
+ db.Names.back(), name);
+ db.Subs.pushSubstitution(db.Names.back());
}
else
- db.names.back().first = name;
+ db.Names.back() = name;
pop_subs = true;
t0 = t1;
}
t1 = parse_template_param(t0, last, db);
if (t1 != t0 && t1 != last)
{
- auto name = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.empty())
+ if (db.Names.size() < 2)
return first;
- if (!db.names.back().first.empty())
- db.names.back().first += "::" + name;
+ auto name = db.Names.back();
+ db.Names.pop_back();
+ if (db.Names.back()->K != Node::KEmptyName)
+ db.Names.back() =
+ db.make<QualifiedName>(db.Names.back(), name);
else
- db.names.back().first = name;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Names.back() = name;
+ db.Subs.pushSubstitution(db.Names.back());
pop_subs = true;
t0 = t1;
}
t1 = parse_decltype(t0, last, db);
if (t1 != t0 && t1 != last)
{
- auto name = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.empty())
+ if (db.Names.size() < 2)
return first;
- if (!db.names.back().first.empty())
- db.names.back().first += "::" + name;
+ auto name = db.Names.back();
+ db.Names.pop_back();
+ if (db.Names.back()->K != Node::KEmptyName)
+ db.Names.back() =
+ db.make<QualifiedName>(db.Names.back(), name);
else
- db.names.back().first = name;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Names.back() = name;
+ db.Subs.pushSubstitution(db.Names.back());
pop_subs = true;
t0 = t1;
}
t1 = parse_template_args(t0, last, db);
if (t1 != t0 && t1 != last)
{
- auto name = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.empty())
+ if (db.Names.size() < 2)
return first;
- db.names.back().first += name;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ auto name = db.Names.back();
+ db.Names.pop_back();
+ db.Names.back() = db.make<NameWithTemplateArgs>(
+ db.Names.back(), name);
+ db.Subs.pushSubstitution(db.Names.back());
t0 = t1;
component_ends_with_template_args = true;
}
t1 = parse_unqualified_name(t0, last, db);
if (t1 != t0 && t1 != last)
{
- auto name = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.empty())
+ if (db.Names.size() < 2)
return first;
- if (!db.names.back().first.empty())
- db.names.back().first += "::" + name;
+ auto name = db.Names.back();
+ db.Names.pop_back();
+ if (db.Names.back()->K != Node::KEmptyName)
+ db.Names.back() =
+ db.make<QualifiedName>(db.Names.back(), name);
else
- db.names.back().first = name;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Names.back() = name;
+ db.Subs.pushSubstitution(db.Names.back());
pop_subs = true;
t0 = t1;
}
}
}
first = t0 + 1;
- db.cv = cv;
- if (pop_subs && !db.subs.empty())
- db.subs.pop_back();
+ db.CV = cv;
+ if (pop_subs && !db.Subs.empty())
+ db.Subs.popPack();
if (ends_with_template_args)
*ends_with_template_args = component_ends_with_template_args;
}
// := Z <function encoding> E s [<discriminator>]
// := Z <function encoding> Ed [ <parameter number> ] _ <entity name>
-template <class C>
const char*
-parse_local_name(const char* first, const char* last, C& db,
+parse_local_name(const char* first, const char* last, Db& db,
bool* ends_with_template_args)
{
if (first != last && *first == 'Z')
{
case 's':
first = parse_discriminator(t+1, last);
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.append("::string literal");
+ db.Names.back() = db.make<QualifiedName>(
+ db.Names.back(), db.make<NameType>("string literal"));
break;
case 'd':
if (++t != last)
ends_with_template_args);
if (t1 != t)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto name = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.empty())
+ auto name = db.Names.back();
+ db.Names.pop_back();
+ if (db.Names.empty())
return first;
- db.names.back().first.append("::");
- db.names.back().first.append(name);
+ db.Names.back() =
+ db.make<QualifiedName>(db.Names.back(), name);
first = t1;
}
- else if (!db.names.empty())
- db.names.pop_back();
+ else if (!db.Names.empty())
+ db.Names.pop_back();
}
}
break;
{
// parse but ignore discriminator
first = parse_discriminator(t1, last);
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto name = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.empty())
+ auto name = db.Names.back();
+ db.Names.pop_back();
+ if (db.Names.empty())
return first;
- db.names.back().first.append("::");
- db.names.back().first.append(name);
+ db.Names.back() =
+ db.make<QualifiedName>(db.Names.back(), name);
}
- else if (!db.names.empty())
- db.names.pop_back();
+ else if (!db.Names.empty())
+ db.Names.pop_back();
}
break;
}
// <unscoped-template-name> ::= <unscoped-name>
// ::= <substitution>
-template <class C>
const char*
-parse_name(const char* first, const char* last, C& db,
+parse_name(const char* first, const char* last, Db& db,
bool* ends_with_template_args)
{
if (last - first >= 2)
{
if (t1 != last && *t1 == 'I') // <unscoped-template-name> <template-args>
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+ db.Subs.pushSubstitution(db.Names.back());
t0 = t1;
t1 = parse_template_args(t0, last, db);
if (t1 != t0)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto tmp = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.empty())
+ auto tmp = db.Names.back();
+ db.Names.pop_back();
+ if (db.Names.empty())
return first;
- db.names.back().first += tmp;
+ db.Names.back() =
+ db.make<NameWithTemplateArgs>(
+ db.Names.back(), tmp);
first = t1;
if (ends_with_template_args)
*ends_with_template_args = true;
t1 = parse_template_args(t0, last, db);
if (t1 != t0)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto tmp = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.empty())
+ auto tmp = db.Names.back();
+ db.Names.pop_back();
+ if (db.Names.empty())
return first;
- db.names.back().first += tmp;
+ db.Names.back() =
+ db.make<NameWithTemplateArgs>(
+ db.Names.back(), tmp);
first = t1;
if (ends_with_template_args)
*ends_with_template_args = true;
// # base is the nominal target function of thunk
// ::= GV <object name> # Guard variable for one-time initialization
// # No <type>
+// ::= TW <object name> # Thread-local wrapper
+// ::= TH <object name> # Thread-local initialization
// extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first
// extension ::= GR <object name> # reference temporary for object
-template <class C>
const char*
-parse_special_name(const char* first, const char* last, C& db)
+parse_special_name(const char* first, const char* last, Db& db)
{
if (last - first > 2)
{
t = parse_type(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "vtable for ");
+ db.Names.back() =
+ db.make<SpecialName>("vtable for ", db.Names.back());
first = t;
}
break;
t = parse_type(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "VTT for ");
+ db.Names.back() =
+ db.make<SpecialName>("VTT for ", db.Names.back());
first = t;
}
break;
t = parse_type(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "typeinfo for ");
+ db.Names.back() =
+ db.make<SpecialName>("typeinfo for ", db.Names.back());
first = t;
}
break;
t = parse_type(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "typeinfo name for ");
+ db.Names.back() =
+ db.make<SpecialName>("typeinfo name for ", db.Names.back());
first = t;
}
break;
t = parse_encoding(t1, last, db);
if (t != t1)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "covariant return thunk to ");
+ db.Names.back() =
+ db.make<SpecialName>("covariant return thunk to ",
+ db.Names.back());
first = t;
}
}
const char* t1 = parse_type(++t0, last, db);
if (t1 != t0)
{
- if (db.names.size() < 2)
+ if (db.Names.size() < 2)
return first;
- auto left = db.names.back().move_full();
- db.names.pop_back();
- if (db.names.empty())
+ auto left = db.Names.back();
+ db.Names.pop_back();
+ if (db.Names.empty())
return first;
- db.names.back().first = "construction vtable for " +
- std::move(left) + "-in-" +
- db.names.back().move_full();
+ db.Names.back() = db.make<CtorVtableSpecialName>(
+ left, db.Names.back());
first = t1;
}
}
}
break;
+ case 'W':
+ // TW <object name> # Thread-local wrapper
+ t = parse_name(first + 2, last, db);
+ if (t != first + 2)
+ {
+ if (db.Names.empty())
+ return first;
+ db.Names.back() =
+ db.make<SpecialName>("thread-local wrapper routine for ",
+ db.Names.back());
+ first = t;
+ }
+ break;
+ case 'H':
+ //TH <object name> # Thread-local initialization
+ t = parse_name(first + 2, last, db);
+ if (t != first + 2)
+ {
+ if (db.Names.empty())
+ return first;
+ db.Names.back() = db.make<SpecialName>(
+ "thread-local initialization routine for ", db.Names.back());
+ first = t;
+ }
+ break;
default:
// T <call-offset> <base encoding>
{
t = parse_encoding(t0, last, db);
if (t != t0)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
if (first[1] == 'v')
{
- db.names.back().first.insert(0, "virtual thunk to ");
+ db.Names.back() =
+ db.make<SpecialName>("virtual thunk to ",
+ db.Names.back());
first = t;
}
else
{
- db.names.back().first.insert(0, "non-virtual thunk to ");
+ db.Names.back() =
+ db.make<SpecialName>("non-virtual thunk to ",
+ db.Names.back());
first = t;
}
}
t = parse_name(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "guard variable for ");
+ db.Names.back() =
+ db.make<SpecialName>("guard variable for ", db.Names.back());
first = t;
}
break;
t = parse_name(first+2, last, db);
if (t != first+2)
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "reference temporary for ");
+ db.Names.back() =
+ db.make<SpecialName>("reference temporary for ",
+ db.Names.back());
first = t;
}
break;
// ::= <data name>
// ::= <special-name>
-template <class C>
const char*
-parse_encoding(const char* first, const char* last, C& db)
+parse_encoding(const char* first, const char* last, Db& db)
{
if (first != last)
{
- save_value<decltype(db.encoding_depth)> su(db.encoding_depth);
- ++db.encoding_depth;
- save_value<decltype(db.tag_templates)> sb(db.tag_templates);
- if (db.encoding_depth > 1)
- db.tag_templates = true;
+ save_value<decltype(db.EncodingDepth)> su(db.EncodingDepth);
+ ++db.EncodingDepth;
+ save_value<decltype(db.TagTemplates)> sb(db.TagTemplates);
+ if (db.EncodingDepth > 1)
+ db.TagTemplates = true;
+ save_value<decltype(db.ParsedCtorDtorCV)> sp(db.ParsedCtorDtorCV);
+ db.ParsedCtorDtorCV = false;
switch (*first)
{
case 'G':
bool ends_with_template_args = false;
const char* t = parse_name(first, last, db,
&ends_with_template_args);
- unsigned cv = db.cv;
- unsigned ref = db.ref;
+ if (db.Names.empty())
+ return first;
+ Qualifiers cv = db.CV;
+ FunctionRefQual ref = db.RefQuals;
if (t != first)
{
if (t != last && *t != 'E' && *t != '.')
{
- save_value<bool> sb2(db.tag_templates);
- db.tag_templates = false;
+ save_value<bool> sb2(db.TagTemplates);
+ db.TagTemplates = false;
const char* t2;
- typename C::String ret2;
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- const typename C::String& nm = db.names.back().first;
- if (nm.empty())
+ if (!db.Names.back())
return first;
- if (!db.parsed_ctor_dtor_cv && ends_with_template_args)
+ Node* return_type = nullptr;
+ if (!db.ParsedCtorDtorCV && ends_with_template_args)
{
t2 = parse_type(t, last, db);
if (t2 == t)
return first;
- if (db.names.size() < 2)
- return first;
- auto ret1 = std::move(db.names.back().first);
- ret2 = std::move(db.names.back().second);
- if (ret2.empty())
- ret1 += ' ';
- db.names.pop_back();
- if (db.names.empty())
+ if (db.Names.size() < 1)
return first;
-
- db.names.back().first.insert(0, ret1);
+ return_type = db.Names.back();
+ db.Names.pop_back();
t = t2;
}
- db.names.back().first += '(';
+
+ Node* result = nullptr;
+
if (t != last && *t == 'v')
{
++t;
+ if (db.Names.empty())
+ return first;
+ Node* name = db.Names.back();
+ db.Names.pop_back();
+ result = db.make<TopLevelFunctionDecl>(
+ return_type, name, NodeArray());
}
else
{
- bool first_arg = true;
+ size_t params_begin = db.Names.size();
while (true)
{
- size_t k0 = db.names.size();
t2 = parse_type(t, last, db);
- size_t k1 = db.names.size();
if (t2 == t)
break;
- if (k1 > k0)
- {
- typename C::String tmp;
- for (size_t k = k0; k < k1; ++k)
- {
- if (!tmp.empty())
- tmp += ", ";
- tmp += db.names[k].move_full();
- }
- for (size_t k = k0; k < k1; ++k) {
- if (db.names.empty())
- return first;
- db.names.pop_back();
- }
- if (!tmp.empty())
- {
- if (db.names.empty())
- return first;
- if (!first_arg)
- db.names.back().first += ", ";
- else
- first_arg = false;
- db.names.back().first += tmp;
- }
- }
t = t2;
}
+ if (db.Names.size() < params_begin)
+ return first;
+ NodeArray params =
+ db.popTrailingNodeArray(params_begin);
+ if (db.Names.empty())
+ return first;
+ Node* name = db.Names.back();
+ db.Names.pop_back();
+ result = db.make<TopLevelFunctionDecl>(
+ return_type, name, params);
}
- if (db.names.empty())
- return first;
- db.names.back().first += ')';
- if (cv & 1)
- db.names.back().first.append(" const");
- if (cv & 2)
- db.names.back().first.append(" volatile");
- if (cv & 4)
- db.names.back().first.append(" restrict");
- if (ref == 1)
- db.names.back().first.append(" &");
- else if (ref == 2)
- db.names.back().first.append(" &&");
- db.names.back().first += ret2;
+ if (ref != FrefQualNone)
+ result = db.make<FunctionRefQualType>(result, ref);
+ if (cv != QualNone)
+ result = db.make<FunctionQualType>(result, cv);
+ db.Names.push_back(result);
first = t;
}
else
// _block_invoke<decimal-digit>+
// _block_invoke_<decimal-digit>+
-template <class C>
const char*
-parse_block_invoke(const char* first, const char* last, C& db)
+parse_block_invoke(const char* first, const char* last, Db& db)
{
if (last - first >= 13)
{
+ // FIXME: strcmp?
const char test[] = "_block_invoke";
const char* t = first;
for (int i = 0; i < 13; ++i, ++t)
while (t != last && isdigit(*t))
++t;
}
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first.insert(0, "invocation function for block in ");
+ db.Names.back() =
+ db.make<SpecialName>("invocation function for block in ",
+ db.Names.back());
first = t;
}
return first;
// extension
// <dot-suffix> := .<anything and everything>
-template <class C>
const char*
-parse_dot_suffix(const char* first, const char* last, C& db)
+parse_dot_suffix(const char* first, const char* last, Db& db)
{
if (first != last && *first == '.')
{
- if (db.names.empty())
+ if (db.Names.empty())
return first;
- db.names.back().first += " (" + typename C::String(first, last) + ")";
+ db.Names.back() =
+ db.make<DotSuffix>(db.Names.back(), StringView(first, last));
first = last;
}
return first;
// <mangled-name> ::= _Z<encoding>
// ::= <type>
-template <class C>
void
-demangle(const char* first, const char* last, C& db, int& status)
+demangle(const char* first, const char* last, Db& db, int& status)
{
if (first >= last)
{
if (t != last)
status = invalid_mangled_name;
}
- if (status == success && db.names.empty())
+ if (status == success && db.Names.empty())
status = invalid_mangled_name;
}
-template <std::size_t N>
-class arena
-{
- static const std::size_t alignment = 16;
- alignas(alignment) char buf_[N];
- char* ptr_;
-
- std::size_t
- align_up(std::size_t n) noexcept
- {return (n + (alignment-1)) & ~(alignment-1);}
-
- bool
- pointer_in_buffer(char* p) noexcept
- {return buf_ <= p && p <= buf_ + N;}
-
-public:
- arena() noexcept : ptr_(buf_) {}
- ~arena() {ptr_ = nullptr;}
- arena(const arena&) = delete;
- arena& operator=(const arena&) = delete;
-
- char* allocate(std::size_t n);
- void deallocate(char* p, std::size_t n) noexcept;
-
- static constexpr std::size_t size() {return N;}
- std::size_t used() const {return static_cast<std::size_t>(ptr_ - buf_);}
- void reset() {ptr_ = buf_;}
-};
-
-template <std::size_t N>
-char*
-arena<N>::allocate(std::size_t n)
-{
- n = align_up(n);
- if (static_cast<std::size_t>(buf_ + N - ptr_) >= n)
- {
- char* r = ptr_;
- ptr_ += n;
- return r;
- }
- return static_cast<char*>(std::malloc(n));
-}
-
-template <std::size_t N>
-void
-arena<N>::deallocate(char* p, std::size_t n) noexcept
-{
- if (pointer_in_buffer(p))
- {
- n = align_up(n);
- if (p + n == ptr_)
- ptr_ = p;
- }
- else
- std::free(p);
-}
-
-template <class T, std::size_t N>
-class short_alloc
-{
- arena<N>& a_;
-public:
- typedef T value_type;
-
-public:
- template <class _Up> struct rebind {typedef short_alloc<_Up, N> other;};
-
- short_alloc(arena<N>& a) noexcept : a_(a) {}
- template <class U>
- short_alloc(const short_alloc<U, N>& a) noexcept
- : a_(a.a_) {}
- short_alloc(const short_alloc&) = default;
- short_alloc& operator=(const short_alloc&) = delete;
-
- T* allocate(std::size_t n)
- {
- return reinterpret_cast<T*>(a_.allocate(n*sizeof(T)));
- }
- void deallocate(T* p, std::size_t n) noexcept
- {
- a_.deallocate(reinterpret_cast<char*>(p), n*sizeof(T));
- }
-
- template <class T1, std::size_t N1, class U, std::size_t M>
- friend
- bool
- operator==(const short_alloc<T1, N1>& x, const short_alloc<U, M>& y) noexcept;
-
- template <class U, std::size_t M> friend class short_alloc;
-};
-
-template <class T, std::size_t N, class U, std::size_t M>
-inline
-bool
-operator==(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept
-{
- return N == M && &x.a_ == &y.a_;
-}
-
-template <class T, std::size_t N, class U, std::size_t M>
-inline
-bool
-operator!=(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept
-{
- return !(x == y);
-}
-
-template <class T>
-class malloc_alloc
-{
-public:
- typedef T value_type;
- typedef T& reference;
- typedef const T& const_reference;
- typedef T* pointer;
- typedef const T* const_pointer;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
-
- malloc_alloc() = default;
- template <class U> malloc_alloc(const malloc_alloc<U>&) noexcept {}
-
- T* allocate(std::size_t n)
- {
- return static_cast<T*>(std::malloc(n*sizeof(T)));
- }
- void deallocate(T* p, std::size_t) noexcept
- {
- std::free(p);
- }
-
- template <class U> struct rebind { using other = malloc_alloc<U>; };
- template <class U, class... Args>
- void construct(U* p, Args&&... args)
- {
- ::new ((void*)p) U(std::forward<Args>(args)...);
- }
- void destroy(T* p)
- {
- p->~T();
- }
-};
-
-template <class T, class U>
-inline
-bool
-operator==(const malloc_alloc<T>&, const malloc_alloc<U>&) noexcept
-{
- return true;
-}
-
-template <class T, class U>
-inline
-bool
-operator!=(const malloc_alloc<T>& x, const malloc_alloc<U>& y) noexcept
-{
- return !(x == y);
-}
-
-const size_t bs = 4 * 1024;
-template <class T> using Alloc = short_alloc<T, bs>;
-template <class T> using Vector = std::vector<T, Alloc<T>>;
-
-template <class StrT>
-struct string_pair
-{
- StrT first;
- StrT second;
-
- string_pair() = default;
- string_pair(StrT f) : first(std::move(f)) {}
- string_pair(StrT f, StrT s)
- : first(std::move(f)), second(std::move(s)) {}
- template <size_t N>
- string_pair(const char (&s)[N]) : first(s, N-1) {}
-
- size_t size() const {return first.size() + second.size();}
- StrT full() const {return first + second;}
- StrT move_full() {return std::move(first) + std::move(second);}
-};
-
-struct Db
-{
- typedef std::basic_string<char, std::char_traits<char>,
- malloc_alloc<char>> String;
- typedef Vector<string_pair<String>> sub_type;
- typedef Vector<sub_type> template_param_type;
- sub_type names;
- template_param_type subs;
- Vector<template_param_type> template_param;
- unsigned cv;
- unsigned ref;
- unsigned encoding_depth;
- bool parsed_ctor_dtor_cv;
- bool tag_templates;
- bool fix_forward_references;
- bool try_to_parse_template_args;
-
- template <size_t N>
- Db(arena<N>& ar) :
- names(ar),
- subs(0, names, ar),
- template_param(0, subs, ar)
- {}
-};
-
} // unnamed namespace
extern "C" _LIBCXXABI_FUNC_VIS char *
*status = invalid_args;
return nullptr;
}
+
size_t internal_size = buf != nullptr ? *n : 0;
- arena<bs> a;
- Db db(a);
- db.cv = 0;
- db.ref = 0;
- db.encoding_depth = 0;
- db.parsed_ctor_dtor_cv = false;
- db.tag_templates = true;
- db.template_param.emplace_back(a);
- db.fix_forward_references = false;
- db.try_to_parse_template_args = true;
+ Db db;
int internal_status = success;
size_t len = std::strlen(mangled_name);
demangle(mangled_name, mangled_name + len, db,
internal_status);
- if (internal_status == success && db.fix_forward_references &&
- !db.template_param.empty() && !db.template_param.front().empty())
+
+ if (internal_status == success && db.FixForwardReferences &&
+ !db.TemplateParams.empty())
{
- db.fix_forward_references = false;
- db.tag_templates = false;
- db.names.clear();
- db.subs.clear();
+ db.FixForwardReferences = false;
+ db.TagTemplates = false;
+ db.Names.clear();
+ db.Subs.clear();
demangle(mangled_name, mangled_name + len, db, internal_status);
- if (db.fix_forward_references)
+ if (db.FixForwardReferences)
internal_status = invalid_mangled_name;
}
+
if (internal_status == success)
{
- size_t sz = db.names.back().size() + 1;
- if (sz > internal_size)
+ if (!buf)
{
- char* newbuf = static_cast<char*>(std::realloc(buf, sz));
- if (newbuf == nullptr)
- {
- internal_status = memory_alloc_failure;
- buf = nullptr;
- }
- else
- {
- buf = newbuf;
- if (n != nullptr)
- *n = sz;
- }
+ internal_size = 1024;
+ buf = static_cast<char*>(std::malloc(internal_size));
}
- if (buf != nullptr)
+
+ if (buf)
{
- db.names.back().first += db.names.back().second;
- std::memcpy(buf, db.names.back().first.data(), sz-1);
- buf[sz-1] = char(0);
+ OutputStream s(buf, internal_size);
+ db.Names.back()->print(s);
+ s += '\0';
+ if (n) *n = s.getCurrentPosition();
+ buf = s.getBuffer();
}
+ else
+ internal_status = memory_alloc_failure;
}
else
buf = nullptr;
projects / openbsd / commitdiff