From 798f3bc2236ce81499b05662dc11e7c071e7cde8 Mon Sep 17 00:00:00 2001 From: jsmall-nvidia Date: Fri, 8 May 2020 14:31:40 -0400 Subject: AST nodes using C++ Extractor (#1341) * Extractor builds without any reference to syntax (as it will be helping to produce this!). * Change macros to include the super class. * WIP replacing defs files. * Added indexOf(const UnownedSubString& in) to UnownedSubString. Refactored extractor * Output a macro for each type with the extracted info - can be used during injection in class * Simplify the header file - as can get super type and last from macro now * Store the 'origin' of a definition * Some small tidy ups to the extractor. * Improve comments on the extractor options. * Made CPPExtractor own SourceOrigins * Small fixes around SourceOrigin. * Small tidy up around macroOrign * WIP Visitor seems now to work correctly. Split out types used by ast into slang-ast-support-types.h * Fix remaining problems with C++ extractor being used with AST nodes. Add CountOf to extractor type ids. Added ReflectClassInfo::getInfo to turn an ASTNodeType into a ReflectClassInfo * Fix compiling on linux. Fix typo in memset. * Small tidy up around comments/layout. Moved NodeBase casting to NodeBase. * Make premake generate project that builds with cpp-extractor for AST. * Get the source directory from the filter in premake. * Fix typo in source path * Explicitly set the source path for premake generation for AST. * Special case handling of override to apease Clang. * Use a more general way to find the slang-ast-reflect.h file to run the extractor. * Appveyor is not triggering slang-cpp-extractor - try putting dependson together. * Put building slang-cpp-extractor first. * Disable some project options to stop MSBuild producing internal compiler errors. * Try reordering the projects in premake5.lua * Hack to try and make slang-cpp-extractor built on appveyor. * Disable flags - not required for MSBuild on appveyor. * Disable flags not required for build on AppVeyor. * Updated Visual Studio projects with slang-cpp-extractor. * Added Visual Studio slang-cpp-extractor project. --- source/slang/slang-syntax.cpp | 196 ++++-------------------------------------- 1 file changed, 19 insertions(+), 177 deletions(-) (limited to 'source/slang/slang-syntax.cpp') diff --git a/source/slang/slang-syntax.cpp b/source/slang/slang-syntax.cpp index 2055c2422..cb75622bc 100644 --- a/source/slang/slang-syntax.cpp +++ b/source/slang/slang-syntax.cpp @@ -8,182 +8,11 @@ namespace Slang { - // We want this first, before the kClassInfo variables so it is constructed before anything else. - /* static*/ SyntaxClassBase::ClassInfo* SyntaxClassBase::ClassInfo::s_first = nullptr; - // BasicExpressionType - - bool BasicExpressionType::EqualsImpl(Type * type) - { - auto basicType = as(type); - return basicType && basicType->baseType == this->baseType; - } - - RefPtr BasicExpressionType::CreateCanonicalType() - { - // A basic type is already canonical, in our setup - return this; - } - - // Generate dispatch logic and other definitions for all syntax classes -#define SYNTAX_CLASS(NAME, BASE) /* empty */ -#include "slang-object-meta-begin.h" - -#include "slang-syntax-base-defs.h" -#undef SYNTAX_CLASS -#undef ABSTRACT_SYNTAX_CLASS - -#define ABSTRACT_SYNTAX_CLASS(NAME, BASE) \ - template<> \ - SyntaxClassBase::ClassInfo const SyntaxClassBase::Impl::kClassInfo(#NAME, nullptr, &SyntaxClassBase::Impl::kClassInfo); - -#define SYNTAX_CLASS(NAME, BASE) \ - template<> \ - void* SyntaxClassBase::Impl::createFunc() { return new NAME(); } \ - template<> \ - SyntaxClassBase::ClassInfo const SyntaxClassBase::Impl::kClassInfo( #NAME, &SyntaxClassBase::Impl::createFunc, &SyntaxClassBase::Impl::kClassInfo); \ - void NAME::accept(NAME::Visitor* visitor, void* extra) \ - { visitor->dispatch_##NAME(this, extra); } \ - const SyntaxClassBase::ClassInfo& NAME::getClassInfo() const { return SyntaxClassBase::Impl::kClassInfo; } - -template<> -SyntaxClassBase::ClassInfo const SyntaxClassBase::Impl::kClassInfo("RefObject", nullptr, nullptr); - -ABSTRACT_SYNTAX_CLASS(NodeBase, RefObject); -ABSTRACT_SYNTAX_CLASS(SyntaxNodeBase, NodeBase); -ABSTRACT_SYNTAX_CLASS(SyntaxNode, SyntaxNodeBase); -ABSTRACT_SYNTAX_CLASS(ModifiableSyntaxNode, SyntaxNode); -ABSTRACT_SYNTAX_CLASS(DeclBase, ModifiableSyntaxNode); -ABSTRACT_SYNTAX_CLASS(Decl, DeclBase); -ABSTRACT_SYNTAX_CLASS(Stmt, ModifiableSyntaxNode); -ABSTRACT_SYNTAX_CLASS(Val, NodeBase); -ABSTRACT_SYNTAX_CLASS(Type, Val); -ABSTRACT_SYNTAX_CLASS(Modifier, SyntaxNodeBase); -ABSTRACT_SYNTAX_CLASS(Expr, SyntaxNode); - -ABSTRACT_SYNTAX_CLASS(Substitutions, SyntaxNode); -ABSTRACT_SYNTAX_CLASS(GenericSubstitution, Substitutions); -ABSTRACT_SYNTAX_CLASS(ThisTypeSubstitution, Substitutions); -ABSTRACT_SYNTAX_CLASS(GlobalGenericParamSubstitution, Substitutions); - -#include "slang-expr-defs.h" -#include "slang-decl-defs.h" -#include "slang-modifier-defs.h" -#include "slang-stmt-defs.h" -#include "slang-type-defs.h" -#include "slang-val-defs.h" -#include "slang-object-meta-end.h" - - -SyntaxClassBase::ClassInfo::ClassInfo(const char* name, CreateFunc createFunc, const ClassInfo* superClass): - m_name(name), - m_createFunc(createFunc), - m_superClass(superClass), - m_next(s_first) -{ - m_classId = 0; - m_childrenEndClassId = 0; - - s_first = this; -} - - - -static uint32_t _calcRangeRec(const SyntaxClassBase::ClassInfo* classInfo, const Dictionary >& childMap, uint32_t index) -{ - classInfo->m_classId = index++; - // Do the calc range for all the children - auto list = childMap.TryGetValue(classInfo); +#define SLANG_CLASS_ACCEPT_IMPL(NAME, SUPER, ORIGIN, LAST, MARKER, TYPE, param) \ + void NAME::accept(NAME::Visitor* visitor, void* extra) { visitor->dispatch_##NAME(this, extra); } - if (list) - { - for (auto child : *list) - { - index = _calcRangeRec(child, childMap, index); - } - } - - classInfo->m_childrenEndClassId = index; - return index; -} - -bool SyntaxClassBase::ClassInfo::isSubClassOfSlow(const ThisType& super) const -{ - SyntaxClassBase::ClassInfo const* info = this; - while (info) - { - if (info == &super) - return true; - info = info->m_superClass; - } - return false; -} - -static bool _checkSubClassRange() -{ - typedef SyntaxClassBase::ClassInfo ClassInfo; - - List list; - for (const ClassInfo* type = ClassInfo::s_first; type; type = type->m_next) - { - list.add(type); - } - - for (Index i = 0; i < list.getCount(); ++i) - { - for (Index j = 0; j < list.getCount(); ++j) - { - auto a = list[i]; - auto b = list[j]; - if (a->isSubClassOf(*b) != a->isSubClassOfSlow(*b)) - { - return false; - } - } - } - - return true; -} - - -/* static */SlangResult SyntaxClassBase::ClassInfo::initRanges() -{ - // Remove the warning about not referenced - SLANG_UNUSED(&_checkSubClassRange); - - // TODO(JS): - // Note that the calculating of the ranges could be done more efficiently by adding to an array of struct { super, class }, sorting, by super classs - // and using a dictionary to map from class it's first in list of super class use. This works for now though. - - // We want to produce a map from a node that holds all of it's children - Dictionary > childMap; - - const List emptyList; - - { - for (const ThisType* type = s_first; type; type = type->m_next) - { - if (type->m_superClass) - { - // Add to that item - List* list = childMap.TryGetValueOrAdd(type->m_superClass, emptyList); - if (!list) - { - list = childMap.TryGetValue(type->m_superClass); - } - SLANG_ASSERT(list); - list->add(type); - } - } - } - - // We want to recursively work out a range - _calcRangeRec(&SyntaxClassBase::Impl::kClassInfo, childMap, 1); - - SLANG_ASSERT(_checkSubClassRange()); - - return SLANG_OK; -} +SLANG_ALL_ASTNode_NodeBase(SLANG_CLASS_ONLY, SLANG_CLASS_ACCEPT_IMPL) // !!!!!!!!!!!!!!!!!!!!!!!!!!!!! DiagnosticSink impls !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! @@ -225,10 +54,23 @@ SourceLoc const& getDiagnosticPos(TypeExp const& typeExp) return typeExp.exp->loc; } +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!! BasicExpressionType !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +bool BasicExpressionType::EqualsImpl(Type * type) +{ + auto basicType = as(type); + return basicType && basicType->baseType == this->baseType; +} + +RefPtr BasicExpressionType::CreateCanonicalType() +{ + // A basic type is already canonical, in our setup + return this; +} // !!!!!!!!!!!!!!!!!!!!!!!!!!!!! Free functions !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! -const RefPtr* adjustFilterCursorImpl(const SyntaxClassBase::ClassInfo& clsInfo, MemberFilterStyle filterStyle, const RefPtr* ptr, const RefPtr* end) +const RefPtr* adjustFilterCursorImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filterStyle, const RefPtr* ptr, const RefPtr* end) { switch (filterStyle) { @@ -273,7 +115,7 @@ const RefPtr* adjustFilterCursorImpl(const SyntaxClassBase::ClassInfo& cls return end; } -const RefPtr* getFilterCursorByIndexImpl(const SyntaxClassBase::ClassInfo& clsInfo, MemberFilterStyle filterStyle, const RefPtr* ptr, const RefPtr* end, Index index) +const RefPtr* getFilterCursorByIndexImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filterStyle, const RefPtr* ptr, const RefPtr* end, Index index) { switch (filterStyle) { @@ -330,7 +172,7 @@ const RefPtr* getFilterCursorByIndexImpl(const SyntaxClassBase::ClassInfo& return nullptr; } -Index getFilterCountImpl(const SyntaxClassBase::ClassInfo& clsInfo, MemberFilterStyle filterStyle, const RefPtr* ptr, const RefPtr* end) +Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filterStyle, const RefPtr* ptr, const RefPtr* end) { Index count = 0; switch (filterStyle) -- cgit v1.2.3