summaryrefslogtreecommitdiff
path: root/tools/slang-cpp-extractor
diff options
context:
space:
mode:
Diffstat (limited to 'tools/slang-cpp-extractor')
-rw-r--r--tools/slang-cpp-extractor/cpp-extractor-main.cpp402
-rw-r--r--tools/slang-cpp-extractor/macro-writer.cpp452
-rw-r--r--tools/slang-cpp-extractor/macro-writer.h41
3 files changed, 0 insertions, 895 deletions
diff --git a/tools/slang-cpp-extractor/cpp-extractor-main.cpp b/tools/slang-cpp-extractor/cpp-extractor-main.cpp
deleted file mode 100644
index bd7787162..000000000
--- a/tools/slang-cpp-extractor/cpp-extractor-main.cpp
+++ /dev/null
@@ -1,402 +0,0 @@
-// main.cpp
-
-#include "compiler-core/slang-diagnostic-sink.h"
-#include "compiler-core/slang-doc-extractor.h"
-#include "compiler-core/slang-lexer.h"
-#include "compiler-core/slang-name-convention-util.h"
-#include "compiler-core/slang-name.h"
-#include "compiler-core/slang-source-loc.h"
-#include "core/slang-file-system.h"
-#include "core/slang-io.h"
-#include "core/slang-list.h"
-#include "core/slang-secure-crt.h"
-#include "core/slang-string-slice-pool.h"
-#include "core/slang-string-util.h"
-#include "core/slang-string.h"
-#include "core/slang-writer.h"
-#include "macro-writer.h"
-#include "slang-com-helper.h"
-#include "slang-cpp-parser/diagnostics.h"
-#include "slang-cpp-parser/file-util.h"
-#include "slang-cpp-parser/node.h"
-#include "slang-cpp-parser/options.h"
-#include "slang-cpp-parser/parser.h"
-#include "slang-cpp-parser/unit-test.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-/*
-Some command lines:
-
--d source/slang slang-ast-support-types.h 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- -o
-slang-generated -output-fields -mark-suffix _CLASS
-*/
-
-namespace CppExtract
-{
-
-using namespace Slang;
-
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! App !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-class App
-{
-public:
- SlangResult execute(const Options& options);
-
- /// Execute
- SlangResult executeWithArgs(int argc, const char* const* argv);
-
- const Options& getOptions() const { return m_options; }
-
- App(DiagnosticSink* sink, SourceManager* sourceManager, RootNamePool* rootNamePool)
- : m_sink(sink), m_sourceManager(sourceManager), m_slicePool(StringSlicePool::Style::Default)
- {
- m_namePool.setRootNamePool(rootNamePool);
- }
-
-protected:
- SlangResult _extractDoc(NodeTree* nodeTree);
-
- NamePool m_namePool;
-
- Options m_options;
- DiagnosticSink* m_sink;
- SourceManager* m_sourceManager;
-
- StringSlicePool m_slicePool;
-};
-
-
-// Work out an appropriate search type for a node type.
-//
-// TODO(JS):
-// NOTE! Currently extractor doesn't extract callable types and so doesn't extract callable types
-// parameters
-static DocMarkupExtractor::SearchStyle _getSearchStyle(Node* node)
-{
- typedef DocMarkupExtractor::SearchStyle SearchStyle;
-
- if (!node->getSourceLoc().isValid())
- {
- return SearchStyle::None;
- }
-
- switch (node->m_kind)
- {
- case Node::Kind::Invalid:
- {
- return SearchStyle::None;
- }
- case Node::Kind::Field:
- {
- return SearchStyle::Variable;
- }
- case Node::Kind::EnumCase:
- {
- return SearchStyle::EnumCase;
- }
- case Node::Kind::TypeDef:
- {
- return SearchStyle::Variable;
- }
- case Node::Kind::Callable:
- {
- return SearchStyle::Before;
- }
- default:
- break;
- }
-
- // Default is to only allow before.
- return SearchStyle::Before;
-}
-
-SlangResult App::_extractDoc(NodeTree* nodeTree)
-{
- // Find all of the nodes
- List<Node*> nodes;
- // Add the root
- nodes.add(nodeTree->getRootNode());
-
- // Traverse all nodes
- for (Index startIndex = 0; startIndex < nodes.getCount(); ++startIndex)
- {
- Node* node = nodes[startIndex];
-
- ScopeNode* scopeNode = as<ScopeNode>(node);
-
- if (scopeNode)
- {
- for (Node* child : scopeNode->m_children)
- {
- nodes.add(child);
- }
- }
- }
-
- // Find out what to find
-
- List<DocMarkupExtractor::SearchItemInput> inputItems;
-
- for (Node* node : nodes)
- {
- auto searchStyle = _getSearchStyle(node);
-
- DocMarkupExtractor::SearchItemInput inputItem;
- inputItem.searchStyle = searchStyle;
- inputItem.sourceLoc = node->getSourceLoc();
-
- inputItems.add(inputItem);
- }
-
- List<DocMarkupExtractor::SearchItemOutput> outputItems;
-
- List<SourceView*> views;
-
- DocMarkupExtractor extractor;
-
- SLANG_RETURN_ON_FAIL(extractor.extract(
- inputItems.getBuffer(),
- inputItems.getCount(),
- m_sourceManager,
- m_sink,
- views,
- outputItems));
-
- // Put what was extracted into the nodes
- {
- const Index count = inputItems.getCount();
- SLANG_ASSERT(count == outputItems.getCount() && count == nodes.getCount());
-
- for (Index i = 0; i < count; ++i)
- {
- const auto& outputItem = outputItems[i];
-
- // We need to use the index used for input, because in output they can be reordered.
- const auto inputIndex = outputItem.inputIndex;
- const auto& inputItem = inputItems[inputIndex];
-
- if (inputItem.searchStyle != DocMarkupExtractor::SearchStyle::None &&
- outputItem.text.getLength())
- {
- Node* node = nodes[inputIndex];
-
- node->m_markup = outputItem.text;
- node->m_markupVisibility = outputItem.visibilty;
- }
- }
- }
-
- return SLANG_OK;
-}
-
-SlangResult App::execute(const Options& options)
-{
- m_options = options;
-
- if (options.m_runUnitTests)
- {
- SLANG_RETURN_ON_FAIL(UnitTestUtil::run());
- }
-
- IdentifierLookup identifierLookup;
- identifierLookup.initDefault(options.m_markPrefix.getUnownedSlice());
-
- NodeTree tree(&m_slicePool, &m_namePool, &identifierLookup);
-
- // Read in each of the input files
- for (Index i = 0; i < m_options.m_inputPaths.getCount(); ++i)
- {
- String inputPath;
-
- if (m_options.m_inputDirectory.getLength())
- {
- inputPath = Path::combine(m_options.m_inputDirectory, m_options.m_inputPaths[i]);
- }
- else
- {
- inputPath = m_options.m_inputPaths[i];
- }
-
- // Read the input file
- String contents;
- SLANG_RETURN_ON_FAIL(FileUtil::readAllText(inputPath, m_sink, contents));
-
- PathInfo pathInfo = PathInfo::makeFromString(inputPath);
-
- SourceFile* sourceFile = m_sourceManager->createSourceFileWithString(pathInfo, contents);
-
- SourceOrigin* sourceOrigin = tree.addSourceOrigin(sourceFile, options);
-
- Parser parser(&tree, m_sink);
- SLANG_RETURN_ON_FAIL(parser.parse(sourceOrigin, &m_options));
- }
-
- SLANG_RETURN_ON_FAIL(tree.calcDerivedTypes(m_sink));
-
- // Okay let's check out the typeSets
- {
- for (TypeSet* typeSet : tree.getTypeSets())
- {
- // The macro name is in upper snake, so split it
- List<UnownedStringSlice> slices;
- NameConventionUtil::split(typeSet->m_macroName, slices);
-
- if (typeSet->m_fileMark.getLength() == 0)
- {
- StringBuilder buf;
- // Let's guess a 'fileMark' (it becomes part of the filename) based on the macro
- // name. Use lower kabab.
- NameConventionUtil::join(
- slices.getBuffer(),
- slices.getCount(),
- NameConvention::LowerKabab,
- buf);
- typeSet->m_fileMark = buf.produceString();
- }
-
- if (typeSet->m_typeName.getLength() == 0)
- {
- // Let's guess a typename if not set -> go with upper camel
- StringBuilder buf;
- NameConventionUtil::join(
- slices.getBuffer(),
- slices.getCount(),
- NameConvention::UpperCamel,
- buf);
- typeSet->m_typeName = buf.produceString();
- }
- }
- }
-
- if (options.m_extractDoc)
- {
- SLANG_RETURN_ON_FAIL(_extractDoc(&tree));
- }
-
- // Dump out the tree
- if (options.m_dump)
- {
- {
- StringBuilder buf;
- tree.getRootNode()->dump(0, buf);
- m_sink->writer->write(buf.getBuffer(), buf.getLength());
- }
-
- for (TypeSet* typeSet : tree.getTypeSets())
- {
- const List<ClassLikeNode*>& baseTypes = typeSet->m_baseTypes;
-
- for (ClassLikeNode* baseType : baseTypes)
- {
- StringBuilder buf;
- baseType->dumpDerived(0, buf);
- m_sink->writer->write(buf.getBuffer(), buf.getLength());
- }
- }
- }
-
- if (options.m_defs)
- {
- MacroWriter macroWriter(m_sink, &m_options);
- SLANG_RETURN_ON_FAIL(macroWriter.writeDefs(&tree));
- }
-
- if (options.m_outputPath.getLength())
- {
- MacroWriter macroWriter(m_sink, &m_options);
- SLANG_RETURN_ON_FAIL(macroWriter.writeOutput(&tree));
- }
-
- return SLANG_OK;
-}
-
-/// Execute
-SlangResult App::executeWithArgs(int argc, const char* const* argv)
-{
- Options options;
- OptionsParser optionsParser;
- SLANG_RETURN_ON_FAIL(optionsParser.parse(argc, argv, m_sink, options));
- SLANG_RETURN_ON_FAIL(execute(options));
- return SLANG_OK;
-}
-
-} // namespace CppExtract
-
-
-/*
-The typical command line for producing generated slang files. Can be determined by setting
-`dumpCommandLine` belong and compiling.
-
-```
--d E:\git\slang-jsmall-nvidia\source\slang\ slang-ast-support-types.h 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- -o slang-generated -output-fields -mark-suffix _CLASS
-```
-
-A command line to try and parse the slang.h
-
-```
--d E:\git\slang-jsmall-nvidia slang.h -mark-suffix _CLASS -dump -unmarked -unit-test
-```
-*/
-
-int main(int argc, const char* const* argv)
-{
- using namespace CppExtract;
- using namespace Slang;
-
- {
- ComPtr<ISlangWriter> writer(new FileWriter(stderr, WriterFlag::AutoFlush));
-
- RootNamePool rootNamePool;
-
- SourceManager sourceManager;
- sourceManager.initialize(nullptr, nullptr);
-
- DiagnosticSink sink(&sourceManager, Lexer::sourceLocationLexer);
- sink.writer = writer;
-
- // Set to true to see command line that initiated C++ extractor. Helpful when finding issues
- // from solution building failing, and then so being able to repeat the issue
- bool dumpCommandLine = false;
-
- if (dumpCommandLine)
- {
- StringBuilder builder;
-
- for (Index i = 1; i < argc; ++i)
- {
- builder << argv[i] << " ";
- }
-
- sink.diagnose(SourceLoc(), CPPDiagnostics::commandLine, builder);
- }
-
- App app(&sink, &sourceManager, &rootNamePool);
-
- try
- {
- if (SLANG_FAILED(app.executeWithArgs(argc - 1, argv + 1)))
- {
- sink.diagnose(SourceLoc(), CPPDiagnostics::extractorFailed);
- return 1;
- }
- if (sink.getErrorCount())
- {
- sink.diagnose(SourceLoc(), CPPDiagnostics::extractorFailed);
- return 1;
- }
- }
- catch (...)
- {
- sink.diagnose(SourceLoc(), CPPDiagnostics::internalError);
- return 1;
- }
- }
- return 0;
-}
diff --git a/tools/slang-cpp-extractor/macro-writer.cpp b/tools/slang-cpp-extractor/macro-writer.cpp
deleted file mode 100644
index 324a48efd..000000000
--- a/tools/slang-cpp-extractor/macro-writer.cpp
+++ /dev/null
@@ -1,452 +0,0 @@
-#include "macro-writer.h"
-
-#include "compiler-core/slang-diagnostic-sink.h"
-#include "core/slang-io.h"
-#include "core/slang-list.h"
-#include "core/slang-string.h"
-#include "core/slang-writer.h"
-#include "slang-com-helper.h"
-#include "slang-cpp-parser/diagnostics.h"
-#include "slang-cpp-parser/file-util.h"
-#include "slang-cpp-parser/node-tree.h"
-#include "slang-cpp-parser/options.h"
-
-namespace CppExtract
-{
-using namespace Slang;
-using namespace CppParse;
-
-SLANG_FORCE_INLINE static void _indent(Index indentCount, StringBuilder& out)
-{
- return FileUtil::indent(indentCount, out);
-}
-
-SlangResult MacroWriter::calcDef(NodeTree* tree, SourceOrigin* origin, StringBuilder& out)
-{
- for (Node* node : origin->m_nodes)
- {
- if (node->isReflected())
- {
- if (auto classLikeNode = as<ClassLikeNode>(node))
- {
- if (classLikeNode->m_marker.getContent().indexOf(
- UnownedStringSlice::fromLiteral("ABSTRACT")) >= 0)
- {
- out << "ABSTRACT_";
- }
-
- out << "SYNTAX_CLASS(" << node->m_name.getContent() << ", "
- << classLikeNode->m_super.getContent() << ")\n";
- out << "END_SYNTAX_CLASS()\n\n";
- }
- }
- }
- return SLANG_OK;
-}
-
-SlangResult MacroWriter::calcChildrenHeader(NodeTree* tree, TypeSet* typeSet, StringBuilder& out)
-{
- const List<ClassLikeNode*>& baseTypes = typeSet->m_baseTypes;
- const String& reflectTypeName = typeSet->m_typeName;
-
- out << "#pragma once\n\n";
- out << "// Do not edit this file is generated from slang-cpp-extractor tool\n\n";
-
- List<ClassLikeNode*> classNodes;
- for (Index i = 0; i < baseTypes.getCount(); ++i)
- {
- ClassLikeNode* baseType = baseTypes[i];
- baseType->calcDerivedDepthFirst(classNodes);
- }
-
- // Node::filter(Node::isClassLike, nodes);
-
- List<ClassLikeNode*> derivedTypes;
-
- out << "\n\n /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!! CHILDREN !!!!!!!!!!!!!!!!!!!!!!!!!!!! */ \n\n";
-
- // Now the children
- for (ClassLikeNode* classNode : classNodes)
- {
- classNode->getReflectedDerivedTypes(derivedTypes);
-
- // Define the derived types
- out << "#define " << m_options->m_markPrefix << "CHILDREN_" << reflectTypeName << "_"
- << classNode->m_name.getContent() << "(x, param)";
-
- if (derivedTypes.getCount())
- {
- out << " \\\n";
- for (Index j = 0; j < derivedTypes.getCount(); ++j)
- {
- Node* derivedType = derivedTypes[j];
- _indent(1, out);
- out << m_options->m_markPrefix << "ALL_" << reflectTypeName << "_"
- << derivedType->m_name.getContent() << "(x, param)";
- if (j < derivedTypes.getCount() - 1)
- {
- out << "\\\n";
- }
- }
- }
- out << "\n\n";
- }
-
- out << "\n\n /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!! ALL !!!!!!!!!!!!!!!!!!!!!!!!!!!! */\n\n";
-
- for (ClassLikeNode* classNode : classNodes)
- {
- // Define the derived types
- out << "#define " << m_options->m_markPrefix << "ALL_" << reflectTypeName << "_"
- << classNode->m_name.getContent() << "(x, param) \\\n";
- _indent(1, out);
- out << m_options->m_markPrefix << reflectTypeName << "_" << classNode->m_name.getContent()
- << "(x, param)";
-
- // If has derived types output them
- if (classNode->hasReflectedDerivedType())
- {
- out << " \\\n";
- _indent(1, out);
- out << m_options->m_markPrefix << "CHILDREN_" << reflectTypeName << "_"
- << classNode->m_name.getContent() << "(x, param)";
- }
- out << "\n\n";
- }
-
- if (m_options->m_outputFields)
- {
- out << "\n\n /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!! FIELDS !!!!!!!!!!!!!!!!!!!!!!!!!!!! */\n\n";
-
- for (ClassLikeNode* classNode : classNodes)
- {
- // Define the derived types
- out << "#define " << m_options->m_markPrefix << "FIELDS_" << reflectTypeName << "_"
- << classNode->m_name.getContent() << "(_x_, _param_)";
-
- // Find all of the instance fields fields
- List<FieldNode*> fields;
- for (Node* child : classNode->m_children)
- {
- if (auto field = as<FieldNode>(child))
- {
- if (!field->m_isStatic)
- {
- fields.add(field);
- }
- }
- }
-
- if (fields.getCount() > 0)
- {
- out << "\\\n";
-
- const Index fieldsCount = fields.getCount();
- bool previousField = false;
- for (Index j = 0; j < fieldsCount; ++j)
- {
- const FieldNode* field = fields[j];
-
- if (field->isReflected())
- {
- if (previousField)
- {
- out << "\\\n";
- }
-
- _indent(1, out);
-
- // NOTE! We put the type field in brackets, such that there is no issue with
- // templates containing a comma. If stringified
- out << "_x_(" << field->m_name.getContent() << ", (" << field->m_fieldType
- << "), _param_)";
- previousField = true;
- }
- }
- }
-
- out << "\n\n";
- }
- }
-
- return SLANG_OK;
-}
-
-SlangResult MacroWriter::calcOriginHeader(NodeTree* tree, StringBuilder& out)
-{
- // Do macros by origin
-
- out << "// Origin macros\n\n";
-
- for (SourceOrigin* origin : tree->getSourceOrigins())
- {
- out << "#define " << m_options->m_markPrefix << "ORIGIN_" << origin->m_macroOrigin
- << "(x, param) \\\n";
-
- for (Node* node : origin->m_nodes)
- {
- if (!(node->isReflected() && node->isClassLike()))
- {
- continue;
- }
-
- _indent(1, out);
- out << "x(" << node->m_name.getContent() << ", param) \\\n";
- }
- out << "/* */\n\n";
- }
-
- return SLANG_OK;
-}
-
-SlangResult MacroWriter::calcTypeHeader(NodeTree* tree, TypeSet* typeSet, StringBuilder& out)
-{
- const List<ClassLikeNode*>& baseTypes = typeSet->m_baseTypes;
- const String& reflectTypeName = typeSet->m_typeName;
-
- out << "#pragma once\n\n";
- out << "// Do not edit this file is generated from slang-cpp-extractor tool\n\n";
-
- if (baseTypes.getCount() == 0)
- {
- return SLANG_OK;
- }
-
- // Set up the scope
- List<Node*> baseScopePath;
- baseTypes[0]->calcScopePath(baseScopePath);
-
- // Remove the global scope
- baseScopePath.removeAt(0);
- // Remove the type itself
- baseScopePath.removeLast();
-
- for (Node* scopeNode : baseScopePath)
- {
- SLANG_ASSERT(scopeNode->m_kind == Node::Kind::Namespace);
- out << "namespace " << scopeNode->m_name.getContent() << " {\n";
- }
-
- // Add all the base types, with in order traversals
- List<ClassLikeNode*> nodes;
- for (Index i = 0; i < baseTypes.getCount(); ++i)
- {
- ClassLikeNode* baseType = baseTypes[i];
- baseType->calcDerivedDepthFirst(nodes);
- }
-
- Node::filter(Node::isClassLikeAndReflected, nodes);
-
- // Write out the types
- {
- out << "\n";
- out << "enum class " << reflectTypeName << "Type\n";
- out << "{\n";
-
- Index typeIndex = 0;
- for (ClassLikeNode* node : nodes)
- {
- // Okay first we are going to output the enum values
- const Index depth = node->calcDerivedDepth() - 1;
- _indent(depth, out);
- out << node->m_name.getContent() << " = " << typeIndex << ",\n";
- typeIndex++;
- }
-
- _indent(1, out);
- out << "CountOf\n";
-
- out << "};\n\n";
- }
-
- // TODO(JS):
- // Strictly speaking if we wanted the types to be in different scopes, we would have to
- // change the namespaces here
-
- // Predeclare the classes
- {
- out << "// Predeclare\n\n";
- for (ClassLikeNode* node : nodes)
- {
- // If it's not reflected we don't output, in the enum list
- if (node->isReflected())
- {
- const char* type = (node->m_kind == Node::Kind::ClassType) ? "class" : "struct";
- out << type << " " << node->m_name.getContent() << ";\n";
- }
- }
- }
-
- // Do the macros for each of the types
-
- {
- out << "// Type macros\n\n";
-
- out << "// Order is (NAME, SUPER, ORIGIN, LAST, MARKER, TYPE, param) \n";
- out << "// NAME - is the class name\n";
- out << "// SUPER - is the super class name (or NO_SUPER)\n";
- out << "// ORIGIN - where the definition was found\n";
- out << "// LAST - is the class name for the last in the range (or NO_LAST)\n";
- out << "// MARKER - is the text inbetween in the prefix/postix (like ABSTRACT). If no "
- "inbetween text is is 'NONE'\n";
- out << "// TYPE - Can be BASE, INNER or LEAF for the overall base class, an INNER class, "
- "or a LEAF class\n";
- out << "// param is a user defined parameter that can be parsed to the invoked x macro\n\n";
-
- // Output all of the definitions for each type
- for (ClassLikeNode* node : nodes)
- {
- out << "#define " << m_options->m_markPrefix << reflectTypeName << "_"
- << node->m_name.getContent() << "(x, param) ";
-
- // Output the X macro part
- _indent(1, out);
- out << "x(" << node->m_name.getContent() << ", ";
-
- if (node->m_superNode)
- {
- out << node->m_superNode->m_name.getContent() << ", ";
- }
- else
- {
- out << "NO_SUPER, ";
- }
-
- // Output the (file origin)
- out << node->m_origin->m_macroOrigin;
- out << ", ";
-
- // The last type
- Node* lastDerived = node->findLastDerived();
- if (lastDerived)
- {
- out << lastDerived->m_name.getContent() << ", ";
- }
- else
- {
- out << "NO_LAST, ";
- }
-
- // Output any specifics of the markup
- UnownedStringSlice marker = node->m_marker.getContent();
- // Need to extract the name
- if (marker.getLength() >
- m_options->m_markPrefix.getLength() + m_options->m_markSuffix.getLength())
- {
- marker = UnownedStringSlice(
- marker.begin() + m_options->m_markPrefix.getLength(),
- marker.end() - m_options->m_markSuffix.getLength());
- }
- else
- {
- marker = UnownedStringSlice::fromLiteral("NONE");
- }
- out << marker << ", ";
-
- if (node->m_superNode == nullptr)
- {
- out << "BASE, ";
- }
- else if (node->hasReflectedDerivedType())
- {
- out << "INNER, ";
- }
- else
- {
- out << "LEAF, ";
- }
- out << "param)\n";
- }
- }
-
- // Now pop the scope in revers
- for (Index j = baseScopePath.getCount() - 1; j >= 0; j--)
- {
- Node* scopeNode = baseScopePath[j];
- out << "} // namespace " << scopeNode->m_name.getContent() << "\n";
- }
-
- return SLANG_OK;
-}
-
-SlangResult MacroWriter::writeDefs(NodeTree* tree)
-{
- const auto& origins = tree->getSourceOrigins();
-
- for (SourceOrigin* origin : origins)
- {
- const String path = origin->m_sourceFile->getPathInfo().foundPath;
-
- // We need to work out the name of the def file
-
- String ext = Path::getPathExt(path);
- String pathWithoutExt = Path::getPathWithoutExt(path);
-
- // The output path
-
- StringBuilder outPath;
- outPath << pathWithoutExt << "-defs." << ext;
-
- StringBuilder content;
- SLANG_RETURN_ON_FAIL(calcDef(tree, origin, content));
-
- // Write the defs file
- SLANG_RETURN_ON_FAIL(FileUtil::writeAllText(outPath, m_sink, content.getUnownedSlice()));
- }
-
- return SLANG_OK;
-}
-
-SlangResult MacroWriter::writeOutput(NodeTree* tree)
-{
- String path;
- if (m_options->m_inputDirectory.getLength())
- {
- path = Path::combine(m_options->m_inputDirectory, m_options->m_outputPath);
- }
- else
- {
- path = m_options->m_outputPath;
- }
-
- // Get the ext
- String ext = Path::getPathExt(path);
- if (ext.getLength() == 0)
- {
- // Default to .h if not specified
- ext = "h";
- }
-
- // Strip the extension if set
- path = Path::getPathWithoutExt(path);
-
- for (TypeSet* typeSet : tree->getTypeSets())
- {
- {
- /// Calculate the header
- StringBuilder header;
- SLANG_RETURN_ON_FAIL(calcTypeHeader(tree, typeSet, header));
-
- // Write it out
-
- StringBuilder headerPath;
- headerPath << path << "-" << typeSet->m_fileMark << "." << ext;
- SLANG_RETURN_ON_FAIL(
- FileUtil::writeAllText(headerPath, m_sink, header.getUnownedSlice()));
- }
-
- {
- StringBuilder childrenHeader;
- SLANG_RETURN_ON_FAIL(calcChildrenHeader(tree, typeSet, childrenHeader));
-
- StringBuilder headerPath;
- headerPath << path << "-" << typeSet->m_fileMark << "-macro." + ext;
- SLANG_RETURN_ON_FAIL(
- FileUtil::writeAllText(headerPath, m_sink, childrenHeader.getUnownedSlice()));
- }
- }
-
- return SLANG_OK;
-}
-
-} // namespace CppExtract
diff --git a/tools/slang-cpp-extractor/macro-writer.h b/tools/slang-cpp-extractor/macro-writer.h
deleted file mode 100644
index aa23c96ef..000000000
--- a/tools/slang-cpp-extractor/macro-writer.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-#include "compiler-core/slang-diagnostic-sink.h"
-#include "slang-cpp-parser/diagnostics.h"
-#include "slang-cpp-parser/node-tree.h"
-#include "slang-cpp-parser/options.h"
-
-namespace CppExtract
-{
-using namespace Slang;
-using namespace CppParse;
-
-/* A class that writes out macros that define type hierarchies, as well as fields of types */
-class MacroWriter
-{
-public:
- /// Write output
- SlangResult writeOutput(NodeTree* tree);
-
- /// Write def files
- SlangResult writeDefs(NodeTree* tree);
-
- /// Calculate the header
- SlangResult calcTypeHeader(NodeTree* tree, TypeSet* typeSet, StringBuilder& out);
- SlangResult calcChildrenHeader(NodeTree* tree, TypeSet* typeSet, StringBuilder& out);
- SlangResult calcOriginHeader(NodeTree* tree, StringBuilder& out);
-
- SlangResult calcDef(NodeTree* tree, SourceOrigin* origin, StringBuilder& out);
-
- /// Ctor.
- MacroWriter(DiagnosticSink* sink, const Options* options)
- : m_sink(sink), m_options(options)
- {
- }
-
-protected:
- const Options* m_options = nullptr;
- DiagnosticSink* m_sink;
-};
-
-} // namespace CppExtract
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-27 09:20:39 +0000