summaryrefslogtreecommitdiffstats
path: root/source/slang
diff options
context:
space:
mode:
Diffstat (limited to 'source/slang')
-rw-r--r--source/slang/slang-ast-base.h2
-rw-r--r--source/slang/slang-ast-decl.h2
-rw-r--r--source/slang/slang-ast-dump.cpp613
-rw-r--r--source/slang/slang-ast-dump.h28
-rw-r--r--source/slang/slang-ast-reflect.h2
-rw-r--r--source/slang/slang-compiler.h2
-rw-r--r--source/slang/slang-options.cpp4
-rw-r--r--source/slang/slang.cpp21
-rw-r--r--source/slang/slang.vcxproj10
-rw-r--r--source/slang/slang.vcxproj.filters6
10 files changed, 686 insertions, 4 deletions
diff --git a/source/slang/slang-ast-base.h b/source/slang/slang-ast-base.h
index 1175f0288..522bdd817 100644
--- a/source/slang/slang-ast-base.h
+++ b/source/slang/slang-ast-base.h
@@ -118,6 +118,8 @@ class Type: public Val
{
SLANG_ABSTRACT_CLASS(Type)
+ friend struct ASTDumpAccess;
+
typedef ITypeVisitor Visitor;
virtual void accept(IValVisitor* visitor, void* extra) override;
diff --git a/source/slang/slang-ast-decl.h b/source/slang/slang-ast-decl.h
index 5020debfa..069f1ac11 100644
--- a/source/slang/slang-ast-decl.h
+++ b/source/slang/slang-ast-decl.h
@@ -441,6 +441,8 @@ class SyntaxDecl : public Decl
// What type of syntax node will be produced when parsing with this keyword?
SyntaxClass<RefObject> syntaxClass;
+ SLANG_UNREFLECTED
+
// Callback to invoke in order to parse syntax with this keyword.
SyntaxParseCallback parseCallback;
void* parseUserData;
diff --git a/source/slang/slang-ast-dump.cpp b/source/slang/slang-ast-dump.cpp
new file mode 100644
index 000000000..a6d947619
--- /dev/null
+++ b/source/slang/slang-ast-dump.cpp
@@ -0,0 +1,613 @@
+// slang-ast-dump.cpp
+#include "slang-ast-dump.h"
+#include <assert.h>
+
+#include "slang-compiler.h"
+
+#include "../core/slang-string.h"
+
+#include "slang-ast-generated-macro.h"
+
+namespace Slang {
+
+namespace { // anonymous
+
+struct Context
+{
+ struct ObjectInfo
+ {
+ const ReflectClassInfo* m_typeInfo;
+ RefObject* m_object;
+ bool m_isDumped;
+ };
+
+ struct ScopeWrite
+ {
+ ScopeWrite(Context* context):
+ m_context(context)
+ {
+ if (m_context->m_scopeWriteCount == 0)
+ {
+ m_context->m_buf.Clear();
+ }
+ m_context->m_scopeWriteCount++;
+ }
+
+ ~ScopeWrite()
+ {
+ if (--m_context->m_scopeWriteCount == 0)
+ {
+ m_context->m_writer->emit(m_context->m_buf);
+ }
+ }
+
+ StringBuilder& getBuf() { return m_context->m_buf; }
+
+ operator StringBuilder&() { return m_context->m_buf; }
+
+ Context* m_context;
+ };
+
+ void dumpObject(const ReflectClassInfo& type, RefObject* obj);
+
+ void dumpObjectFull(const ReflectClassInfo& type, RefObject* obj, Index objIndex);
+ void dumpObjectReference(const ReflectClassInfo& type, RefObject* obj, Index objIndex);
+
+ void dump(NodeBase* node)
+ {
+ if (node == nullptr)
+ {
+ dumpPtr(nullptr);
+ }
+ else
+ {
+ dumpObject(node->getClassInfo(), node);
+ }
+ }
+
+ void dump(Substitutions* subs)
+ {
+ if (subs == nullptr)
+ {
+ dumpPtr(nullptr);
+ }
+ else
+ {
+ dumpObject(subs->getClassInfo(), subs);
+ }
+ }
+
+ void dump(const Name* name)
+ {
+ if (name == nullptr)
+ {
+ dumpPtr(nullptr);
+ }
+ else
+ {
+ dump(name->text);
+ }
+ }
+
+ void dump(const RefObject* obj)
+ {
+ if (obj == nullptr)
+ {
+ dumpPtr(nullptr);
+ }
+ else
+ {
+ // We don't know what this is!
+ ScopeWrite(this).getBuf() << "Unknown@" << size_t(obj);
+ }
+ }
+
+ template <typename T>
+ void dump(const List<T>& list)
+ {
+ m_writer->emit(" { \n");
+ m_writer->indent();
+ for (Index i = 0; i < list.getCount(); ++i)
+ {
+ dump(list[i]);
+ if (i < list.getCount() - 1)
+ {
+ m_writer->emit(",\n");
+ }
+ else
+ {
+ m_writer->emit("\n");
+ }
+ }
+ m_writer->dedent();
+ m_writer->emit("}");
+ }
+
+ void dump(SourceLoc sourceLoc)
+ {
+ SourceManager* manager = m_writer->getSourceManager();
+
+ {
+ ScopeWrite(this).getBuf() << "SourceLoc(" << sourceLoc.getRaw() << ")";
+ }
+
+ if (manager && sourceLoc.isValid())
+ {
+ HumaneSourceLoc humaneLoc = manager->getHumaneLoc(sourceLoc);
+ ScopeWrite(this).getBuf() << " " << humaneLoc.pathInfo.foundPath << ":" << humaneLoc.line;
+ }
+ }
+
+ static char _getHexDigit(UInt v)
+ {
+ return (v < 10) ? char(v + '0') : char('a' + v - 10);
+ }
+
+ void dump(const UnownedStringSlice& slice)
+ {
+ m_writer->emitChar('\"');
+
+ {
+ ScopeWrite scope(this);
+ auto& buf = scope.getBuf();
+ for (const char c : slice)
+ {
+ if (c < 0x20 || c >= 0x80)
+ {
+ buf << "\\0x" << _getHexDigit(UInt32(c) >> 4) << _getHexDigit(c & 0xf);
+ }
+ else
+ {
+ buf << c;
+ }
+ }
+ }
+ m_writer->emitChar('\"');
+ }
+
+ void dump(const Token& token)
+ {
+ ScopeWrite(this).getBuf() << " { " << TokenTypeToString(token.type) << ", ";
+ dump(token.loc);
+ dump(token.getContent());
+ m_writer->emit(" }");
+ }
+
+ Index getObjectIndex(const ReflectClassInfo& typeInfo, RefObject* obj)
+ {
+ Index* indexPtr = m_objectMap.TryGetValueOrAdd(obj, m_objects.getCount());
+ if (indexPtr)
+ {
+ return *indexPtr;
+ }
+
+ ObjectInfo info;
+ info.m_isDumped = false;
+ info.m_object = obj;
+ info.m_typeInfo = &typeInfo;
+
+ m_objects.add(info);
+ return m_objects.getCount() - 1;
+ }
+
+ void dump(uint32_t v)
+ {
+ m_writer->emit(UInt(v));
+ }
+ void dump(int32_t v)
+ {
+ m_writer->emit(v);
+ }
+ void dump(FloatingPointLiteralValue v)
+ {
+ m_writer->emit(v);
+ }
+
+ void dump(IntegerLiteralValue v)
+ {
+ m_writer->emit(v);
+ }
+
+
+ void dump(const SemanticVersion& version)
+ {
+ ScopeWrite(this).getBuf() << UInt(version.m_major) << "." << UInt(version.m_minor) << "." << UInt(version.m_patch);
+ }
+ void dump(const NameLoc& nameLoc)
+ {
+ m_writer->emit("NameLoc{");
+ if (nameLoc.name)
+ {
+ dump(nameLoc.name->text.getUnownedSlice());
+ }
+ else
+ {
+ dumpPtr(nullptr);
+ }
+ m_writer->emit(", ");
+ dump(nameLoc.loc);
+ m_writer->emit(" }");
+ }
+ void dump(BaseType baseType)
+ {
+ m_writer->emit(BaseTypeInfo::asText(baseType));
+ }
+ void dump(Stage stage)
+ {
+ m_writer->emit(getStageName(stage));
+ }
+ void dump(ImageFormat imageFormat)
+ {
+ m_writer->emit(getGLSLNameForImageFormat(imageFormat));
+ }
+
+ void dump(const String& string)
+ {
+ dump(string.getUnownedSlice());
+ }
+
+ void dump(const DiagnosticInfo* info)
+ {
+ ScopeWrite(this).getBuf() << "DiagnosticInfo {" << info->id << "}";
+ }
+ void dump(const Layout* layout)
+ {
+ ScopeWrite(this).getBuf() << "Layout@" << size_t(layout);
+ }
+
+ void dump(const Modifiers& modifiers)
+ {
+ auto& nonConstModifiers = const_cast<Modifiers&>(modifiers);
+
+ m_writer->emit(" { \n");
+ m_writer->indent();
+
+ for (const auto& mod : nonConstModifiers)
+ {
+ dump(mod);
+ m_writer->emit("\n");
+ }
+
+ m_writer->dedent();
+ m_writer->emit("}");
+ }
+
+ template <typename T>
+ void dump(const SyntaxClass<T>& cls)
+ {
+ m_writer->emit(cls.classInfo->m_name);
+ }
+
+ template <typename KEY, typename VALUE>
+ void dump(const Dictionary<KEY, VALUE>& dict)
+ {
+ m_writer->emit(" { \n");
+ m_writer->indent();
+
+ for (auto iter : dict)
+ {
+ const auto& key = iter.Key;
+ const auto& value = iter.Value;
+
+ dump(key);
+ m_writer->emit(" : ");
+ dump(value);
+
+ m_writer->emit("\n");
+ }
+
+ m_writer->dedent();
+ m_writer->emit("}");
+ }
+
+ void dump(const DeclCheckStateExt& extState)
+ {
+ auto state = extState.getState();
+
+ ScopeWrite(this).getBuf() << "DeclCheckStateExt{" << extState.isBeingChecked() << ", " << Index(state) << "}";
+ }
+
+ void dump(TextureFlavor texFlavor)
+ {
+ m_buf.Clear();
+ m_buf << "TextureFlavor{" << Index(texFlavor.flavor) << "}";
+ m_writer->emit(m_buf);
+ }
+
+ void dump(SamplerStateFlavor flavor)
+ {
+ switch (flavor)
+ {
+ case SamplerStateFlavor::SamplerState: m_writer->emit("sampler"); break;
+ case SamplerStateFlavor::SamplerComparisonState: m_writer->emit("samplerComparison"); break;
+ default: m_writer->emit("unknown"); break;
+ }
+ }
+
+ void dump(const QualType& qualType)
+ {
+ if (qualType.IsLeftValue)
+ {
+ m_writer->emit("left ");
+ }
+ else
+ {
+ m_writer->emit("right ");
+ }
+ dump(qualType.type);
+ }
+
+ void dumpPtr(const void* ptr)
+ {
+ if (ptr)
+ {
+ ScopeWrite(this).getBuf() << "Unknown@" << size_t(ptr);
+ }
+ else
+ {
+ m_writer->emit("null");
+ }
+ }
+
+ void dump(SyntaxParseCallback callback) { dumpPtr((const void*)callback); }
+
+ template <typename T, int SIZE>
+ void dump(const T (&in)[SIZE])
+ {
+ m_writer->emit(" { \n");
+ m_writer->indent();
+
+ for (Index i = 0; i < Index(SIZE); ++i)
+ {
+ dump(in[i]);
+ if (i < Index(SIZE) - 1)
+ {
+ m_writer->emit(", ");
+ }
+ m_writer->emit("\n");
+ }
+
+ m_writer->dedent();
+ m_writer->emit("}");
+ }
+
+ //void dump(const void* ptr) { dumpPtr(ptr); }
+
+ void dump(const LookupResult& result)
+ {
+ auto& nonConstResult = const_cast<LookupResult&>(result);
+
+ m_writer->emit(" { \n");
+ m_writer->indent();
+
+ for (auto item : nonConstResult)
+ {
+ // TODO(JS):
+ m_writer->emit("...\n");
+ }
+
+ m_writer->dedent();
+ m_writer->emit("}");
+ }
+ void dump(const GlobalGenericParamSubstitution::ConstraintArg& arg)
+ {
+ m_writer->emit(" { \n");
+ m_writer->indent();
+
+ dump(arg.decl);
+ m_writer->emit(",\n");
+ dump(arg.val);
+ m_writer->emit("\n");
+
+ m_writer->dedent();
+ m_writer->emit("}");
+ }
+ void dump(const TypeExp& exp)
+ {
+ m_writer->emit(" { \n");
+ m_writer->indent();
+
+ dump(exp.exp);
+ m_writer->emit(",\n");
+ dump(exp.type);
+ m_writer->emit("\n");
+
+ m_writer->dedent();
+ m_writer->emit("}");
+ }
+ void dump(const ExpandedSpecializationArg& arg)
+ {
+ dump(arg.witness);
+ }
+
+ void dump(const TransparentMemberInfo& memInfo)
+ {
+ dump(memInfo.decl);
+ }
+
+ void dumpRemaining()
+ {
+ // Have to keep checking count, as dumping objects can add objects
+ for (Index i = 0; i < m_objects.getCount(); ++i)
+ {
+ ObjectInfo& info = m_objects[i];
+ if (!info.m_isDumped)
+ {
+ dumpObjectFull(*info.m_typeInfo, info.m_object, i);
+ }
+ }
+ }
+
+ template <typename T>
+ void dumpField(const char* name, const T& value)
+ {
+ m_writer->emit(name);
+ m_writer->emit(" : ");
+ dump(value);
+ m_writer->emit("\n");
+ }
+
+ void dumpObjectFull(NodeBase* node);
+ void dumpObjectFull(Substitutions* subs);
+
+ Context(SourceWriter* writer, ASTDumpUtil::Style dumpStyle):
+ m_writer(writer),
+ m_scopeWriteCount(0),
+ m_dumpStyle(dumpStyle)
+ {
+ }
+
+ ASTDumpUtil::Style m_dumpStyle;
+
+ Index m_scopeWriteCount;
+
+ // Using the SourceWriter, for automatic indentation.
+ SourceWriter* m_writer;
+
+ Dictionary<RefObject*, Index> m_objectMap; ///< Object index
+ List<ObjectInfo> m_objects;
+
+ StringBuilder m_buf;
+};
+
+} // anonymous
+
+// Lets generate functions one for each that attempts to write out *it's* fields.
+// We can write out the Super types fields by looking that up
+
+struct ASTDumpAccess
+{
+#define SLANG_AST_DUMP_FIELD(FIELD_NAME, TYPE, param) context.dumpField(#FIELD_NAME, node->FIELD_NAME);
+
+#define SLANG_AST_DUMP_FIELDS_IMPL(NAME, SUPER, ORIGIN, LAST, MARKER, TYPE, param) \
+static void dumpFields_##NAME(NAME* node, Context& context) \
+{ \
+ SLANG_UNUSED(node); \
+ SLANG_UNUSED(context); \
+ SLANG_FIELDS_ASTNode_##NAME(SLANG_AST_DUMP_FIELD, _) \
+}
+
+SLANG_ALL_ASTNode_Substitutions(SLANG_AST_DUMP_FIELDS_IMPL, _)
+SLANG_ALL_ASTNode_NodeBase(SLANG_AST_DUMP_FIELDS_IMPL, _)
+
+};
+
+#define SLANG_AST_GET_DUMP_FUNC(NAME, SUPER, ORIGIN, LAST, MARKER, TYPE, param) m_funcs[Index(ASTNodeType::NAME)] = (DumpFieldsFunc)&ASTDumpAccess::dumpFields_##NAME;
+
+typedef void (*DumpFieldsFunc)(RefObject* obj, Context& context);
+
+struct DumpFieldFuncs
+{
+ DumpFieldFuncs()
+ {
+ memset(m_funcs, 0, sizeof(m_funcs));
+ SLANG_ALL_ASTNode_Substitutions(SLANG_AST_GET_DUMP_FUNC, _)
+ SLANG_ALL_ASTNode_NodeBase(SLANG_AST_GET_DUMP_FUNC, _)
+ }
+
+ DumpFieldsFunc m_funcs[Index(ASTNodeType::CountOf)];
+};
+
+static const DumpFieldFuncs s_funcs;
+
+void Context::dumpObjectReference(const ReflectClassInfo& type, RefObject* obj, Index objIndex)
+{
+ SLANG_UNUSED(obj);
+ ScopeWrite(this).getBuf() << type.m_name << "@" << objIndex;
+}
+
+void Context::dumpObjectFull(const ReflectClassInfo& type, RefObject* obj, Index objIndex)
+{
+ ObjectInfo& info = m_objects[objIndex];
+ SLANG_ASSERT(info.m_isDumped == false);
+ info.m_isDumped = true;
+
+ // We need to dump the fields.
+
+ ScopeWrite(this).getBuf() << type.m_name << "(" << objIndex << ") {\n";
+ m_writer->indent();
+
+ List<const ReflectClassInfo*> allTypes;
+ {
+ const ReflectClassInfo* curType = &type;
+ do
+ {
+ allTypes.add(curType);
+ curType = curType->m_superClass;
+ } while (curType);
+ }
+
+ // Okay we go backwards so we output in the 'normal' order
+ for (Index i = allTypes.getCount() - 1; i >= 0; --i)
+ {
+ const ReflectClassInfo* curType = allTypes[i];
+ DumpFieldsFunc func = s_funcs.m_funcs[Index(curType->m_classId)];
+ if (func)
+ {
+ func(obj, *this);
+ }
+ }
+
+ m_writer->dedent();
+ m_writer->emit("}\n");
+}
+
+void Context::dumpObject(const ReflectClassInfo& typeInfo, RefObject* obj)
+{
+ Index index = getObjectIndex(typeInfo, obj);
+
+ ObjectInfo& info = m_objects[index];
+ if (info.m_isDumped || m_dumpStyle == ASTDumpUtil::Style::Flat)
+ {
+ dumpObjectReference(typeInfo, obj, index);
+ }
+ else
+ {
+ dumpObjectFull(typeInfo, obj, index);
+ }
+}
+
+void Context::dumpObjectFull(NodeBase* node)
+{
+ if (!node)
+ {
+ dumpPtr(nullptr);
+ }
+ else
+ {
+ const ReflectClassInfo& typeInfo = node->getClassInfo();
+ Index index = getObjectIndex(typeInfo, node);
+ dumpObjectFull(typeInfo, node, index);
+ }
+}
+
+void Context::dumpObjectFull(Substitutions* subs)
+{
+ if (!subs)
+ {
+ dumpPtr(nullptr);
+ }
+ else
+ {
+ const ReflectClassInfo& typeInfo = subs->getClassInfo();
+ Index index = getObjectIndex(typeInfo, subs);
+ dumpObjectFull(typeInfo, subs, index);
+ }
+}
+
+/* static */void ASTDumpUtil::dump(NodeBase* node, Style style, SourceWriter* writer)
+{
+ Context context(writer, style);
+ context.dumpObjectFull(node);
+ context.dumpRemaining();
+}
+
+/* static */void ASTDumpUtil::dump(Substitutions* subs, Style style, SourceWriter* writer)
+{
+ Context context(writer, style);
+ context.dumpObjectFull(subs);
+ context.dumpRemaining();
+
+}
+
+} // namespace Slang
diff --git a/source/slang/slang-ast-dump.h b/source/slang/slang-ast-dump.h
new file mode 100644
index 000000000..71df8aafc
--- /dev/null
+++ b/source/slang/slang-ast-dump.h
@@ -0,0 +1,28 @@
+// slang-ast-dump.h
+#ifndef SLANG_AST_DUMP_H
+#define SLANG_AST_DUMP_H
+
+#include "slang-syntax.h"
+
+#include "slang-emit-source-writer.h"
+
+namespace Slang
+{
+
+struct ASTDumpAccess;
+
+struct ASTDumpUtil
+{
+ enum class Style
+ {
+ Hierachical,
+ Flat,
+ };
+
+ static void dump(NodeBase* node, Style style, SourceWriter* writer);
+ static void dump(Substitutions* subs, Style style, SourceWriter* writer);
+};
+
+} // namespace Slang
+
+#endif
diff --git a/source/slang/slang-ast-reflect.h b/source/slang/slang-ast-reflect.h
index 9c93d0621..0c57dc757 100644
--- a/source/slang/slang-ast-reflect.h
+++ b/source/slang/slang-ast-reflect.h
@@ -53,5 +53,7 @@
// Does nothing - just a mark to the C++ extractor
#define SLANG_REFLECT_BASE_CLASS(NAME)
+#define SLANG_REFLECTED
+#define SLANG_UNREFLECTED
#endif // SLANG_AST_REFLECT_H
diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h
index fb13ab146..852898de6 100644
--- a/source/slang/slang-compiler.h
+++ b/source/slang/slang-compiler.h
@@ -1449,6 +1449,8 @@ namespace Slang
bool shouldDumpIR = false;
bool shouldValidateIR = false;
+ bool shouldDumpAST = false;
+
protected:
CompileRequestBase(
Linkage* linkage,
diff --git a/source/slang/slang-options.cpp b/source/slang/slang-options.cpp
index c642c196a..8100fab4f 100644
--- a/source/slang/slang-options.cpp
+++ b/source/slang/slang-options.cpp
@@ -465,6 +465,10 @@ struct OptionsParser
requestImpl->getFrontEndReq()->shouldDumpIR = true;
requestImpl->getBackEndReq()->shouldDumpIR = true;
}
+ else if (argStr == "-dump-ast")
+ {
+ requestImpl->getFrontEndReq()->shouldDumpAST = true;
+ }
else if (argStr == "-dump-repro")
{
SLANG_RETURN_ON_FAIL(tryReadCommandLineArgument(sink, arg, &argCursor, argEnd, requestImpl->dumpRepro));
diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp
index 34f1402b5..82bc5e478 100644
--- a/source/slang/slang.cpp
+++ b/source/slang/slang.cpp
@@ -14,6 +14,8 @@
#include "slang-reflection.h"
#include "slang-type-layout.h"
+#include "slang-ast-dump.h"
+
#include "slang-state-serialize.h"
#include "slang-file-system.h"
@@ -996,6 +998,25 @@ void FrontEndCompileRequest::parseTranslationUnit(
tokens,
getSink(),
languageScope);
+
+ // Let's try dumping
+
+ if (shouldDumpAST)
+ {
+ StringBuilder buf;
+ SourceWriter writer(linkage->getSourceManager(), LineDirectiveMode::None);
+
+ ASTDumpUtil::dump(translationUnit->getModuleDecl(), ASTDumpUtil::Style::Flat, &writer);
+
+ const String& path = sourceFile->getPathInfo().foundPath;
+ if (path.getLength())
+ {
+ String fileName = Path::getFileNameWithoutExt(path);
+ fileName.append(".slang-ast");
+
+ File::writeAllText(fileName, writer.getContent());
+ }
+ }
}
}
diff --git a/source/slang/slang.vcxproj b/source/slang/slang.vcxproj
index cf5a81499..1b391cac0 100644
--- a/source/slang/slang.vcxproj
+++ b/source/slang/slang.vcxproj
@@ -192,6 +192,7 @@
<ClInclude Include="slang-ast-all.h" />
<ClInclude Include="slang-ast-base.h" />
<ClInclude Include="slang-ast-decl.h" />
+ <ClInclude Include="slang-ast-dump.h" />
<ClInclude Include="slang-ast-expr.h" />
<ClInclude Include="slang-ast-generated-macro.h" />
<ClInclude Include="slang-ast-generated.h" />
@@ -271,6 +272,7 @@
<ClInclude Include="slang-visitor.h" />
</ItemGroup>
<ItemGroup>
+ <ClCompile Include="slang-ast-dump.cpp" />
<ClCompile Include="slang-ast-reflect.cpp" />
<ClCompile Include="slang-check-conformance.cpp" />
<ClCompile Include="slang-check-constraint.cpp" />
@@ -382,10 +384,10 @@
<Natvis Include="slang.natvis" />
<CustomBuild Include="slang-ast-reflect.h">
<FileType>Document</FileType>
- <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"../../bin/windows-x86/debug/slang-cpp-extractor" -d %(RootDir)%(Directory)/ slang-ast-base.h slang-ast-decl.h slang-ast-expr.h slang-ast-modifier.h slang-ast-stmt.h slang-ast-type.h slang-ast-val.h -strip-prefix slang-ast- -o slang-ast-generated</Command>
- <Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">"../../bin/windows-x64/debug/slang-cpp-extractor" -d %(RootDir)%(Directory)/ slang-ast-base.h slang-ast-decl.h slang-ast-expr.h slang-ast-modifier.h slang-ast-stmt.h slang-ast-type.h slang-ast-val.h -strip-prefix slang-ast- -o slang-ast-generated</Command>
- <Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"../../bin/windows-x86/release/slang-cpp-extractor" -d %(RootDir)%(Directory)/ slang-ast-base.h slang-ast-decl.h slang-ast-expr.h slang-ast-modifier.h slang-ast-stmt.h slang-ast-type.h slang-ast-val.h -strip-prefix slang-ast- -o slang-ast-generated</Command>
- <Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">"../../bin/windows-x64/release/slang-cpp-extractor" -d %(RootDir)%(Directory)/ slang-ast-base.h slang-ast-decl.h slang-ast-expr.h slang-ast-modifier.h slang-ast-stmt.h slang-ast-type.h slang-ast-val.h -strip-prefix slang-ast- -o slang-ast-generated</Command>
+ <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"../../bin/windows-x86/debug/slang-cpp-extractor" -d %(RootDir)%(Directory)/ slang-ast-base.h slang-ast-decl.h slang-ast-expr.h slang-ast-modifier.h slang-ast-stmt.h slang-ast-type.h slang-ast-val.h -strip-prefix slang-ast- -o slang-ast-generated -output-fields</Command>
+ <Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">"../../bin/windows-x64/debug/slang-cpp-extractor" -d %(RootDir)%(Directory)/ slang-ast-base.h slang-ast-decl.h slang-ast-expr.h slang-ast-modifier.h slang-ast-stmt.h slang-ast-type.h slang-ast-val.h -strip-prefix slang-ast- -o slang-ast-generated -output-fields</Command>
+ <Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"../../bin/windows-x86/release/slang-cpp-extractor" -d %(RootDir)%(Directory)/ slang-ast-base.h slang-ast-decl.h slang-ast-expr.h slang-ast-modifier.h slang-ast-stmt.h slang-ast-type.h slang-ast-val.h -strip-prefix slang-ast- -o slang-ast-generated -output-fields</Command>
+ <Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">"../../bin/windows-x64/release/slang-cpp-extractor" -d %(RootDir)%(Directory)/ slang-ast-base.h slang-ast-decl.h slang-ast-expr.h slang-ast-modifier.h slang-ast-stmt.h slang-ast-type.h slang-ast-val.h -strip-prefix slang-ast- -o slang-ast-generated -output-fields</Command>
<Outputs>%(RootDir)%(Directory)/slang-ast-generated.h;%(RootDir)%(Directory)/slang-ast-generated-macro.h</Outputs>
<Message>slang-cpp-extractor AST %(Identity)</Message>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../bin/windows-x86/debug/slang-cpp-extractor.exe;%(RootDir)%(Directory)/slang-ast-base.h;%(RootDir)%(Directory)/slang-ast-decl.h;%(RootDir)%(Directory)/slang-ast-expr.h;%(RootDir)%(Directory)/slang-ast-modifier.h;%(RootDir)%(Directory)/slang-ast-stmt.h;%(RootDir)%(Directory)/slang-ast-type.h;%(RootDir)%(Directory)/slang-ast-val.h</AdditionalInputs>
diff --git a/source/slang/slang.vcxproj.filters b/source/slang/slang.vcxproj.filters
index 4060a6019..c2c9268dc 100644
--- a/source/slang/slang.vcxproj.filters
+++ b/source/slang/slang.vcxproj.filters
@@ -27,6 +27,9 @@
<ClInclude Include="slang-ast-decl.h">
<Filter>Header Files</Filter>
</ClInclude>
+ <ClInclude Include="slang-ast-dump.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
<ClInclude Include="slang-ast-expr.h">
<Filter>Header Files</Filter>
</ClInclude>
@@ -260,6 +263,9 @@
</ClInclude>
</ItemGroup>
<ItemGroup>
+ <ClCompile Include="slang-ast-dump.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
<ClCompile Include="slang-ast-reflect.cpp">
<Filter>Source Files</Filter>
</ClCompile>
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-02 21:55:51 +0000