summaryrefslogtreecommitdiffstats
path: root/tools/render-test/options.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tools/render-test/options.cpp')
-rw-r--r--tools/render-test/options.cpp213
1 files changed, 84 insertions, 129 deletions
diff --git a/tools/render-test/options.cpp b/tools/render-test/options.cpp
index dcf0b77b1..5d3560351 100644
--- a/tools/render-test/options.cpp
+++ b/tools/render-test/options.cpp
@@ -15,6 +15,10 @@
#include "../../source/core/slang-type-text-util.h"
+#include "../../source/compiler-core/slang-command-line-args.h"
+
+#include "diagnostics.h"
+
namespace renderer_test {
using namespace Slang;
@@ -34,173 +38,135 @@ static gfx::DeviceType _toRenderType(Slang::RenderApiType apiType)
}
}
-static SlangResult _setRendererType(DeviceType type, const char* arg, Slang::WriterHelper stdError, Options& ioOptions)
-{
- if (ioOptions.deviceType != DeviceType::Unknown)
- {
- stdError.print("Already has renderer option set. Found '%s'\n", arg);
- return SLANG_FAIL;
- }
- ioOptions.deviceType = type;
- return SLANG_OK;
-}
-
/* static */SlangResult Options::parse(int argc, const char*const* argv, Slang::WriterHelper stdError, Options& outOptions)
{
using namespace Slang;
+ RefPtr<CommandLineContext> cmdLineContext(new CommandLineContext);
+
+ DiagnosticSink sink(cmdLineContext->getSourceManager(), nullptr);
+ sink.writer = stdError.getWriter();
+ sink.setFlag(DiagnosticSink::Flag::SourceLocationLine);
+
outOptions = Options();
- List<const char*> positionalArgs;
+ CommandLineArgs args(cmdLineContext);
- typedef Options::ShaderProgramType ShaderProgramType;
- typedef Options::InputLanguageID InputLanguageID;
+ if (argc > 0)
+ {
+ // first argument is the application name
+ outOptions.appName = argv[0];
+ args.setArgs(argv + 1, argc - 1);
+ }
+ else
+ {
+ args.setArgs(argv, argc);
+ }
- //int argCount = argc;
+ SLANG_RETURN_ON_FAIL(outOptions.downstreamArgs.stripDownstreamArgs(args, 0, &sink));
- char const* const* argCursor = argv;
- char const* const* argEnd = argCursor + argc;
+ CommandLineReader reader(&args, &sink);
- // first argument is the application name
- if( argCursor != argEnd )
- {
- outOptions.appName = *argCursor++;
- }
+ List<CommandLineArg> positionalArgs;
+
+ typedef Options::ShaderProgramType ShaderProgramType;
+ typedef Options::InputLanguageID InputLanguageID;
// now iterate over arguments to collect options
- while(argCursor != argEnd)
+ while (reader.hasArg())
{
- char const* arg = *argCursor++;
- if( arg[0] != '-' )
+ CommandLineArg arg = reader.getArgAndAdvance();
+ const auto& argValue = arg.value;
+
+ if(!argValue.startsWith("-"))
{
positionalArgs.add(arg);
continue;
}
- if( strcmp(arg, "--") == 0 )
+ if (argValue == "--")
{
- while(argCursor != argEnd)
+ while (reader.hasArg())
{
- positionalArgs.add(*argCursor++);
+ positionalArgs.add(reader.getArgAndAdvance());
}
break;
}
- else if( strcmp(arg, "-o") == 0 )
+ else if(argValue == "-o")
{
- if( argCursor == argEnd )
- {
- stdError.print("expected argument for '%s' option\n", arg);
- return SLANG_FAIL;
- }
- outOptions.outputPath = *argCursor++;
+ SLANG_RETURN_ON_FAIL(reader.expectArg(outOptions.outputPath));
}
- else if (strcmp(arg, "-profile") == 0)
+ else if (argValue == "-profile")
{
- if (argCursor == argEnd)
- {
- stdError.print("expected argument for '%s' option\n", arg);
- return SLANG_FAIL;
- }
- outOptions.profileName = *argCursor++;
+ SLANG_RETURN_ON_FAIL(reader.expectArg(outOptions.profileName));
}
- else if (strcmp(arg, "-render-features") == 0 || strcmp(arg, "-render-feature") == 0)
+ else if (argValue == "-render-features" || argValue == "-render-feature")
{
- if (argCursor == argEnd)
- {
- stdError.print("expected argument for '%s' option\n", arg);
- return SLANG_FAIL;
- }
- const char* value = *argCursor++;
+ String features;
+ SLANG_RETURN_ON_FAIL(reader.expectArg(features));
List<UnownedStringSlice> values;
- StringUtil::split(UnownedStringSlice(value), ',', values);
+ StringUtil::split(features.getUnownedSlice(), ',', values);
for (const auto& value : values)
{
outOptions.renderFeatures.add(value);
}
}
- else if( strcmp(arg, "-xslang") == 0 )
+ else if( argValue == "-xslang" || argValue == "-compile-arg")
{
+ // This is legacy support, should use -Xslang now
// This is an option that we want to pass along to Slang
-
- if( argCursor == argEnd )
- {
- stdError.print("expected argument for '%s' option\n", arg);
- return SLANG_FAIL;
- }
- if( outOptions.slangArgCount == Options::kMaxSlangArgs )
- {
- stdError.print("maximum number of '%s' options exceeded (%d)\n", arg, Options::kMaxSlangArgs);
- return SLANG_FAIL;
- }
- outOptions.slangArgs[outOptions.slangArgCount++] = *argCursor++;
+ CommandLineArg slangArg;
+ SLANG_RETURN_ON_FAIL(reader.expectArg(slangArg));
+ outOptions.downstreamArgs.getArgsByName("slang").add(slangArg);
}
- else if (strcmp(arg, "-compute") == 0)
+ else if (argValue == "-compute")
{
outOptions.shaderType = ShaderProgramType::Compute;
}
- else if (strcmp(arg, "-graphics") == 0)
+ else if (argValue == "-graphics")
{
outOptions.shaderType = ShaderProgramType::Graphics;
}
- else if (strcmp(arg, "-gcompute") == 0)
+ else if (argValue == "-gcompute")
{
outOptions.shaderType = ShaderProgramType::GraphicsCompute;
}
- else if (strcmp(arg, "-rt") == 0)
+ else if (argValue == "-rt")
{
outOptions.shaderType = ShaderProgramType::RayTracing;
}
- else if( strcmp(arg, "-use-dxil") == 0 )
+ else if(argValue == "-use-dxil")
{
outOptions.useDXIL = true;
}
- else if (strcmp(arg, "-only-startup") == 0)
+ else if (argValue == "-only-startup")
{
outOptions.onlyStartup = true;
}
- else if (strcmp(arg, "-compile-arg") == 0)
- {
- if (argCursor == argEnd)
- {
- stdError.print("expected argument for '%s' option\n", arg);
- return SLANG_FAIL;
- }
-
- const char* compileArg = *argCursor++;
- outOptions.compileArgs.add(compileArg);
- }
- else if (strcmp(arg, "-performance-profile") == 0)
+ else if (argValue == "-performance-profile")
{
outOptions.performanceProfile = true;
}
- else if (strcmp(arg, "-adapter") == 0)
+ else if (argValue == "-adapter")
{
- if (argCursor == argEnd)
- {
- stdError.print("expected argument for '%s' option\n", arg);
- return SLANG_FAIL;
- }
-
- outOptions.adapter = *argCursor++;
+ SLANG_RETURN_ON_FAIL(reader.expectArg(outOptions.adapter));
}
- else if (strcmp(arg, "-output-using-type") == 0)
+ else if (argValue == "-output-using-type")
{
outOptions.outputUsingType = true;
}
- else if (strcmp(arg, "-compute-dispatch") == 0)
+ else if (argValue == "-compute-dispatch")
{
- if (argCursor == argEnd)
- {
- stdError.print("error: expecting a comma separated compute dispatch size for '%s'\n", arg);
- return SLANG_FAIL;
- }
+ CommandLineArg dispatchSize;
+ SLANG_RETURN_ON_FAIL(reader.expectArg(dispatchSize));
+
List<UnownedStringSlice> slices;
- StringUtil::split(UnownedStringSlice(*argCursor++), ',', slices);
+ StringUtil::split(dispatchSize.value.getUnownedSlice(), ',', slices);
if (slices.getCount() != 3)
{
- stdError.print("error: expected 3 comma separated integers for compute dispatch size for '%s'\n", arg);
+ sink.diagnose(dispatchSize.loc, RenderTestDiagnostics::expectingCommaComputeDispatch);
return SLANG_FAIL;
}
@@ -211,45 +177,35 @@ static SlangResult _setRendererType(DeviceType type, const char* arg, Slang::Wri
int v = StringToInt(string);
if (v < 1)
{
- stdError.print("error: expected 3 comma positive integers for compute dispatch size for '%s'\n", arg);
+ sink.diagnose(dispatchSize.loc, RenderTestDiagnostics::expectingPositiveComputeDispatch);
return SLANG_FAIL;
}
outOptions.computeDispatchSize[i] = v;
}
}
- else if (strcmp(arg, "-source-language") == 0)
+ else if (argValue == "-source-language")
{
- if (argCursor == argEnd)
- {
- stdError.print("error: expecting a source language name for '%s'\n", arg);
- return SLANG_FAIL;
- }
- UnownedStringSlice sourceLanguageText(*argCursor++);
-
- SlangSourceLanguage sourceLanguage = TypeTextUtil::findSourceLanguage(sourceLanguageText);
+ CommandLineArg sourceLanguageName;
+ SLANG_RETURN_ON_FAIL(reader.expectArg(sourceLanguageName));
+
+ const SlangSourceLanguage sourceLanguage = TypeTextUtil::findSourceLanguage(sourceLanguageName.value.getUnownedSlice());
if (sourceLanguage == SLANG_SOURCE_LANGUAGE_UNKNOWN)
{
- stdError.print("error: expecting unknown source language name '%s' for '%s'\n", String(sourceLanguageText).getBuffer(), arg);
+ sink.diagnose(sourceLanguageName.loc, RenderTestDiagnostics::unknownSourceLanguage);
return SLANG_FAIL;
}
outOptions.sourceLanguage = sourceLanguage;
}
- else if( strcmp(arg, "-no-default-entry-point") == 0 )
+ else if(argValue == "-no-default-entry-point")
{
outOptions.dontAddDefaultEntryPoints = true;
}
- else if (strcmp(arg, "-nvapi-slot") == 0)
+ else if (argValue == "-nvapi-slot")
{
- if (argCursor == argEnd)
- {
- stdError.print("error: expecting a register name for '%s'\n", arg);
- return SLANG_FAIL;
- }
-
- outOptions.nvapiExtnSlot = (*argCursor++);
+ SLANG_RETURN_ON_FAIL(reader.expectArg(outOptions.nvapiExtnSlot));
}
- else if (strcmp(arg, "-shaderobj") == 0)
+ else if (argValue == "-shaderobj")
{
// Note: We ignore this option because it is always enabled now.
//
@@ -258,11 +214,11 @@ static SlangResult _setRendererType(DeviceType type, const char* arg, Slang::Wri
else
{
// Lookup
- Slang::UnownedStringSlice argSlice(arg);
+ Slang::UnownedStringSlice argSlice = arg.value.getUnownedSlice();
if (argSlice.getLength() && argSlice[0] == '-')
{
// Look up the rendering API if set
- UnownedStringSlice argName = UnownedStringSlice(argSlice.begin() + 1, argSlice.end());
+ UnownedStringSlice argName = argSlice.tail(1);
DeviceType deviceType = _toRenderType(RenderApiUtil::findApiTypeByName(argName));
if (deviceType != DeviceType::Unknown)
@@ -272,17 +228,16 @@ static SlangResult _setRendererType(DeviceType type, const char* arg, Slang::Wri
}
// Lookup the target language type
- DeviceType languageRenderType =
- _toRenderType(RenderApiUtil::findImplicitLanguageRenderApiType(argName));
- if (languageRenderType != DeviceType::Unknown)
+ DeviceType targetLanguageDeviceType = _toRenderType(RenderApiUtil::findImplicitLanguageRenderApiType(argName));
+
+ if (targetLanguageDeviceType != DeviceType::Unknown)
{
- outOptions.targetLanguageDeviceType = languageRenderType;
+ outOptions.targetLanguageDeviceType = targetLanguageDeviceType;
outOptions.inputLanguageID = (argName == "hlsl" || argName == "glsl" || argName == "cpp" || argName == "cxx" || argName == "c") ? InputLanguageID::Native : InputLanguageID::Slang;
continue;
}
}
-
- stdError.print("unknown option '%s'\n", arg);
+ sink.diagnose(arg.loc, RenderTestDiagnostics::unknownCommandLineOption, arg.value);
return SLANG_FAIL;
}
}
@@ -295,14 +250,14 @@ static SlangResult _setRendererType(DeviceType type, const char* arg, Slang::Wri
// first positional argument is source shader path
if(positionalArgs.getCount())
{
- outOptions.sourcePath = positionalArgs[0];
+ outOptions.sourcePath = positionalArgs[0].value;
positionalArgs.removeAt(0);
}
// any remaining arguments represent an error
if(positionalArgs.getCount() != 0)
{
- stdError.print("unexpected arguments\n");
+ sink.diagnose(positionalArgs[0].loc, RenderTestDiagnostics::unexpectedPositionalArg);
return SLANG_FAIL;
}
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-01 16:01:07 +0000