public static OptTableBuilder AddOptions(OptTableBuilder builder)
{
return(builder
.AddUnknown(Opt.Unknown)
.AddInput(Opt.Input)
.AddFlag(Opt.help, "-", "help", "Display available options")
.AddFlag(Opt.QuestionMark, "-", "?", aliasId: Opt.help)
.AddFlag(Opt.version, "-", "version", "Display version")
.AddJoined(Opt.schema_eq, "-", "schema:", "Path to eventman.xsd", metaVar: "<path>")
.AddJoined(Opt.winmeta_eq, "-", "winmeta:", "Path to winmeta.xml", metaVar: "<path>")
.AddSeparate(Opt.dump_msg, "-", "dump-msg", "Dump message table", metaVar: "<file>")
.AddSeparate(Opt.dump_wevt, "-", "dump-wevt", "Dump WEVT template", metaVar: "<file>")
.AddSeparate(Opt.gen_manifest, "-", "gen-manifest", "Generate event manifest from binary provider and write to <file>", metaVar: "<file>")
.AddFlag(Opt.verify, "-", "verify", "Only parse and check inputs.")
.AddGroup(Opt.O_group, "<O group>", "Output")
.AddJoined(Opt.out_eq, "-", "out:", "Base output filename", metaVar: "<file>", groupId: Opt.O_group)
.AddJoined(Opt.resgen_manifest_eq, "-", "resgen-manifest:", "Manifest which is only used for resource generation", metaVar: "<file>")
.AddFlag(Opt.res, "-", "res")
.AddFlag(Opt.no_res, "-", "no-res", "Do not generate resources")
.AddSeparate(Opt.m, "-", "m", metaVar: "<file>", groupId: Opt.O_group, aliasId: Opt.msg_file_eq)
.AddSeparate(Opt.w, "-", "w", metaVar: "<file>", groupId: Opt.O_group, aliasId: Opt.wevt_file_eq)
.AddSeparate(Opt.r, "-", "r", metaVar: "<file>", groupId: Opt.O_group, aliasId: Opt.rc_file_eq)
.AddJoined(Opt.header_file_eq, "-", "header-file:", "Generated header filename", metaVar: "<file>", groupId: Opt.O_group)
.AddJoined(Opt.msg_file_eq, "-", "msg-file:", "Write message table to <file>", metaVar: "<file>", groupId: Opt.O_group)
.AddJoined(Opt.wevt_file_eq, "-", "wevt-file:", "Write ETW binary template to <file>", metaVar: "<file>", groupId: Opt.O_group)
.AddJoined(Opt.rc_file_eq, "-", "rc-file:", "Write resource includes to <file>", metaVar: "<file>", groupId: Opt.O_group)
.AddFlag(Opt.code, "-", "code")
.AddFlag(Opt.no_code, "-", "no-code", "Do not generate logging code")
.AddSeparate(Opt.h, "-", "h", metaVar: "<file>", groupId: Opt.O_group, aliasId: Opt.header_file_eq)
.AddGroup(Opt.G_group, "<G group>", "CodeGen Options")
.AddJoined(Opt.generator_eq, "-", "generator:", "Code generator to use (cxx, mc)", groupId: Opt.G_group)
.AddJoined(Opt.g_eq, "-", "g:", aliasId: Opt.generator_eq)
.AddJoined(Opt.compat_eq, "-", "compat:", "Binary compatibility with specified mc.exe version (Supported values: 8.1)", groupId: Opt.G_group, metaVar: "<version>")
.AddJoined(Opt.ext_eq, "-", "ext:", "Assembly path to discover custom code generators", groupId: Opt.G_group, metaVar: "<path>"));
}
private static IEnumerable <Option> GetOptions()
{
var builder = new OptTableBuilder();
EmcOptTable.AddOptions(builder);
builder
.AddFlag(ExtOpt.cuse_prefix, "-", "cuse-prefix", "Use a prefix for generated logging functions", groupId: Opt.G_group)
.AddJoined(ExtOpt.cprefix_eq, "-", "cprefix:", "Prefix for generated logging functions", groupId: Opt.G_group)
.AddJoined(ExtOpt.clog_ns_eq, "-", "clog-ns:", "Namespace where generated code is placed. Use '.' as separator (e.g. Company.Product.Tracing)", groupId: Opt.G_group)
.AddJoined(ExtOpt.cetw_ns_eq, "-", "cetw-ns:", "Namespace where common ETW code is placed. Use '.' as separator (e.g. Company.Product.ETW)", groupId: Opt.G_group)
.AddFlag(ExtOpt.cdefines, "-", "cdefines", "Generate code definitions for non-essential resources", groupId: Opt.G_group)
.AddFlag(ExtOpt.cno_defines, "-", "cno-defines", "Do not generate definitions", groupId: Opt.G_group);
return(builder.GetList());
}
public void ParseRemainingArgs(string prefix, string name)
{
OptTable optTable = new OptTableBuilder()
.AddRemainingArgs(1, prefix, name)
.CreateTable();
var args = new[] { prefix + name, prefix + name, "value", "-flag" };
IArgumentList al = optTable.ParseArgs(args, out var missing);
Assert.Equal(0, missing.ArgIndex);
Assert.Equal(0, missing.ArgCount);
Assert.Equal(1, al.Count);
Assert.Equal(optTable.MakeArg(1, prefix + name, 0, prefix + name, "value", "-flag"), al[0], argComparer);
}
public void ParseMultiArg(string prefix, string name, string[] extraArgs)
{
OptTable optTable = new OptTableBuilder()
.AddMultiArg(1, prefix, name, extraArgs.Length)
.CreateTable();
var args = new[] { prefix + name }.Concat(extraArgs).ToArray();
IArgumentList al = optTable.ParseArgs(args, out var missing);
Assert.Equal(0, missing.ArgIndex);
Assert.Equal(0, missing.ArgCount);
Assert.Equal(1, al.Count);
Assert.Equal(optTable.MakeArg(1, prefix + name, 0, extraArgs), al[0], argComparer);
}
public void ParseSeparateMissingArg()
{
OptTable optTable = new OptTableBuilder()
.AddSeparate(1, "-", "opt")
.CreateTable();
var args = new[] { "-opt", "v1", "-opt" };
IArgumentList al = optTable.ParseArgs(args, out var missing);
Assert.Equal(2, missing.ArgIndex);
Assert.Equal(1, missing.ArgCount);
Assert.Equal(1, al.Count);
Assert.Equal(optTable.MakeArg(1, "-opt", 0, "v1"), al[0], argComparer);
}
public void ParseSeparate(string prefix, string name, string arg)
{
OptTable optTable = new OptTableBuilder()
.AddSeparate(1, prefix, name)
.CreateTable();
var args = new[] { prefix + name, arg };
IArgumentList al = optTable.ParseArgs(args, out var missing);
Assert.Equal(0, missing.ArgIndex);
Assert.Equal(0, missing.ArgCount);
Assert.Equal(1, al.Count);
Assert.Equal(optTable.MakeArg(1, prefix + name, 0, arg), al[0], argComparer);
}
public void ParseOption(string prefix, string name, int argCount)
{
var opt = new StubOption(1, prefix, name);
OptTable optTable = new OptTableBuilder()
.Add(opt)
.CreateTable();
var args = Enumerable.Repeat(prefix + name, argCount).ToList();
IArgumentList al = optTable.ParseArgs(args, out var missing);
Assert.Equal(new MissingArgs(), missing);
Assert.Equal(args.Count, al.Count);
Assert.Equal(opt.CreatedArgs, al);
}
public void ParseMultiArgMissingArgs(
string prefix, string name, int argCount, string[] preArgs, string[] postArgs)
{
OptTable optTable = new OptTableBuilder()
.AddUnknown(1)
.AddMultiArg(2, prefix, name, argCount)
.CreateTable();
var args = preArgs.Concat(new[] { prefix + name }).Concat(postArgs).ToArray();
IArgumentList al = optTable.ParseArgs(args, out var missing);
Assert.Equal(preArgs.Length, missing.ArgIndex);
Assert.Equal(argCount - postArgs.Length, missing.ArgCount);
Assert.Equal(preArgs.Length, al.Count);
Assert.True(al.All(a => a.Option.Id == 1));
}
public void ParseJoinedMultiplePrefixes()
{
OptTable optTable = new OptTableBuilder()
.AddJoined(1, new[] { "-", "--", "/" }, "opt=")
.CreateTable();
var args = new[] { "--opt=value1", "/opt=value2", "-opt=value3" };
IArgumentList al = optTable.ParseArgs(args, out var missing);
Assert.Equal(0, missing.ArgIndex);
Assert.Equal(0, missing.ArgCount);
Assert.Equal(3, al.Count);
Assert.Equal(optTable.MakeArg(1, "--opt=", 0, "value1"), al[0], argComparer);
Assert.Equal(optTable.MakeArg(1, "/opt=", 1, "value2"), al[1], argComparer);
Assert.Equal(optTable.MakeArg(1, "-opt=", 2, "value3"), al[2], argComparer);
}
public void ParseFlagMultiplePrefixes()
{
OptTable optTable = new OptTableBuilder()
.AddFlag(1, new[] { "-", "--", "/" }, "opt")
.CreateTable();
var args = new[] { "--opt", "/opt", "-opt" };
IArgumentList al = optTable.ParseArgs(args, out var missing);
Assert.Equal(0, missing.ArgIndex);
Assert.Equal(0, missing.ArgCount);
Assert.Equal(3, al.Count);
Assert.Equal(optTable.MakeArg(1, "--opt", 0), al[0], argComparer);
Assert.Equal(optTable.MakeArg(1, "/opt", 1), al[1], argComparer);
Assert.Equal(optTable.MakeArg(1, "-opt", 2), al[2], argComparer);
}
public void ParseMixed()
{
OptTable optTable = new OptTableBuilder()
.AddFlag(1, "-", "a")
.AddJoined(2, "-", "a=")
.CreateTable();
var args = new[] { "-a=123", "-a" };
IArgumentList al = optTable.ParseArgs(args, out var missing);
Assert.Equal(0, missing.ArgIndex);
Assert.Equal(0, missing.ArgCount);
Assert.Equal(2, al.Count);
Assert.Equal(optTable.MakeArg(2, "-a=", 0, "123"), al[0], argComparer);
Assert.Equal(optTable.MakeArg(1, "-a", 1), al[1], argComparer);
}
public void Verb()
{
var table = new OptTableBuilder()
.Add(new VerbOption(1, "action", helpText: "Action", metaVar: "<action>"))
.Add(new SeparateOption(2, "-", "name", helpText: "Name", metaVar: "foo"))
.Add(new SeparateOption(3, "-", "foo", helpText: "Bar", metaVar: "foo"))
.Add(new InputOption(4, metaVar: "foo"))
.CreateTable();
var al = table.ParseArgs(new[] { "bar", "-name", "n" }, out var _);
output.WriteLine("Help: {0}", table.GetHelp());
output.WriteLine("{0}", al.Count);
output.WriteLine("{0}", al[0]);
output.WriteLine("{0}", al[1]);
}
private OptTable ReflectOptTable(Type optionType)
{
if (optionType is null)
{
return(null);
}
int optIdx = 0;
var groupId = Opt.custom + optIdx++;
var builder = new OptTableBuilder()
.AddUnknown(Opt.Unknown)
.AddGroup(groupId, name, helpText: $"CodeGen Options (Generator {name})");
foreach (var property in optionType.GetTypeInfo().DeclaredProperties)
{
var optionAttribute = property.GetCustomAttributes <OptionAttribute>().FirstOrDefault();
if (optionAttribute is null)
{
continue;
}
var helpText = optionAttribute.HelpText ?? optionAttribute.Name;
var optionId = Opt.custom + optIdx++;
switch (optionAttribute)
{
case JoinedOptionAttribute x:
builder.AddJoined(optionId, "-", $"c{optionAttribute.Name}:", helpText: helpText, groupId: groupId);
infos.Add(new JoinedOptionInfo(x, optionId, property));
break;
case FlagOptionAttribute x:
builder.AddFlag(optionId, "-", $"c{optionAttribute.Name}", helpText: helpText, groupId: groupId);
infos.Add(new FlagOptionInfo(x, optionId, property));
break;
}
}
return(builder.CreateTable());
}
public void ParseJoinedMultiple()
{
OptTable optTable = new OptTableBuilder()
.AddJoined(1, "-", "aaaa")
.AddJoined(2, new[] { "-", "--" }, "aaa")
.AddJoined(3, "-", "a")
.AddJoined(4, "--", "aa")
.CreateTable();
var args = new[] { "--aaa1", "--aa2", "-aaaaa", "-a4", "-aaa5" };
IArgumentList al = optTable.ParseArgs(args, out var missing);
Assert.Equal(0, missing.ArgIndex);
Assert.Equal(0, missing.ArgCount);
Assert.Equal(5, al.Count);
Assert.Equal(optTable.MakeArg(2, "--aaa", 0, "1"), al[0], argComparer);
Assert.Equal(optTable.MakeArg(4, "--aa", 1, "2"), al[1], argComparer);
Assert.Equal(optTable.MakeArg(1, "-aaaa", 2, "a"), al[2], argComparer);
Assert.Equal(optTable.MakeArg(3, "-a", 3, "4"), al[3], argComparer);
Assert.Equal(optTable.MakeArg(2, "-aaa", 4, "5"), al[4], argComparer);
}
public void ParseFlagMultiple()
{
OptTable optTable = new OptTableBuilder()
.AddFlag(1, "-", "aaaa")
.AddFlag(2, new[] { "-", "--" }, "aaa")
.AddFlag(3, "-", "a")
.AddFlag(4, "--", "aa")
.CreateTable();
var args = new[] { "--aaa", "--aa", "-aaaa", "-a", "-aaa" };
IArgumentList al = optTable.ParseArgs(args, out MissingArgs missing);
Assert.Equal(0, missing.ArgIndex);
Assert.Equal(0, missing.ArgCount);
Assert.Equal(5, al.Count);
Assert.Equal(optTable.MakeArg(2, "--aaa", 0), al[0], argComparer);
Assert.Equal(optTable.MakeArg(4, "--aa", 1), al[1], argComparer);
Assert.Equal(optTable.MakeArg(1, "-aaaa", 2), al[2], argComparer);
Assert.Equal(optTable.MakeArg(3, "-a", 3), al[3], argComparer);
Assert.Equal(optTable.MakeArg(2, "-aaa", 4), al[4], argComparer);
}
public override void AddOption(int optionId, OptTableBuilder builder)
{
builder.AddInput(optionId);
}
public OptTableBuilderTest()
{
builder = new OptTableBuilder();
}
public OptionSet()
{
builder = new OptTableBuilder();
builder.AddUnknown(UnknownId);
builder.AddInput(InputId);
}
public abstract void AddOption(int optionId, OptTableBuilder builder);
public override void AddOption(int optionId, OptTableBuilder builder)
{
builder.AddJoinedOrSeparate(optionId, Prefixes, Name, HelpText);
}
public override void AddOption(int optionId, OptTableBuilder builder)
{
builder.AddCommaJoined(optionId, Prefixes, Name, HelpText);
}
