private CommandLineParser.CommandLineParser InitIgnoreCase()
{
var commandLineParser = new CommandLineParser.CommandLineParser();
commandLineParser.IgnoreCase = true;
commandLineParser.ShowUsageOnEmptyCommandline = true;
SwitchArgument showArgument = new SwitchArgument('s', "show", "Set whether show or not", true);
SwitchArgument hideArgument = new SwitchArgument('h', "hide", "Set whether hid or not", false);
ValueArgument <string> level = new ValueArgument <string>('l', "level", "Set the level");
ValueArgument <decimal> version = new ValueArgument <decimal>('v', "version", "Set desired version");
ValueArgument <Point> point = new ValueArgument <Point>('p', "point", "specify the point");
BoundedValueArgument <int> optimization = new BoundedValueArgument <int>('o', "optimization", 0, 3);
EnumeratedValueArgument <string> color = new EnumeratedValueArgument <string>('c', "color", new[] { "red", "green", "blue" });
FileArgument inputFile = new FileArgument('i', "input", "Input file");
inputFile.FileMustExist = false;
FileArgument outputFile = new FileArgument('x', "output", "Output file");
outputFile.FileMustExist = false;
DirectoryArgument inputDirectory = new DirectoryArgument('d', "directory", "Input directory");
inputDirectory.DirectoryMustExist = false;
point.ConvertValueHandler = delegate(string stringValue)
{
if (stringValue.StartsWith("[") && stringValue.EndsWith("]"))
{
string[] parts =
stringValue.Substring(1, stringValue.Length - 2).Split(';', ',');
Point p = new Point();
p.x = int.Parse(parts[0]);
p.y = int.Parse(parts[1]);
return(p);
}
throw new CommandLineArgumentException("Bad point format", "point");
};
commandLineParser.Arguments.Add(showArgument);
commandLineParser.Arguments.Add(hideArgument);
commandLineParser.Arguments.Add(level);
commandLineParser.Arguments.Add(version);
commandLineParser.Arguments.Add(point);
commandLineParser.Arguments.Add(optimization);
commandLineParser.Arguments.Add(color);
commandLineParser.Arguments.Add(inputFile);
commandLineParser.Arguments.Add(outputFile);
commandLineParser.Arguments.Add(inputDirectory);
return(commandLineParser);
}
/// <summary>
/// Entry point of the CLI.
/// </summary>
/// <param name="args">Command line arguments.</param>
private static void Main(string[] args)
{
var cliParser = new CommandLineParser.CommandLineParser();
var directoryArgument = new DirectoryArgument('d', "directory", "The directory containing the files to match.")
{
DirectoryMustExist = true, Optional = true, DefaultValue = new DirectoryInfo(Environment.CurrentDirectory)
};
var fileExtensionArgument = new ValueArgument <string>('x', "extension", "The file extension (without dot) to match as a regular expression pattern, e.g. \"^(pdf|jpe?g)$\" or \"db$\". Matches all extensions if omitted.")
{
Optional = true, DefaultValue = string.Empty
};
var startDateArgument = new ValueArgument <DateTime>('s', "start-date", "The range start date (YYYY-MM-DD).")
{
Optional = false
};
var endDateArgument = new ValueArgument <DateTime>('e', "end-date", "The range end date (YYYY-MM-DD).")
{
Optional = false
};
cliParser.ShowUsageHeader = "Check if a directory containing files with named date ranges is missing any dates from a given range.";
cliParser.Arguments.Add(directoryArgument);
cliParser.Arguments.Add(fileExtensionArgument);
cliParser.Arguments.Add(startDateArgument);
cliParser.Arguments.Add(endDateArgument);
cliParser.ShowUsageOnEmptyCommandline = true;
try
{
cliParser.ParseCommandLine(args);
}
catch (CommandLineException cle)
{
Console.WriteLine(cle.Message);
cliParser.ShowUsage();
return;
}
catch (DirectoryNotFoundException dnfe)
{
Console.WriteLine(dnfe.Message.EndsWith(" and DirectoryMustExist flag is set to true.")
? dnfe.Message.Substring(0, dnfe.Message.Length - 44)
: dnfe.Message);
return;
}
if (!cliParser.ParsingSucceeded)
{
return;
}
if (startDateArgument.Value > endDateArgument.Value)
{
Console.WriteLine("The start date of the range cannot be later than the end date.");
return;
}
Console.BackgroundColor = ConsoleColor.Black;
if (HasMissingRanges(directoryArgument.Value, fileExtensionArgument.Value, (startDateArgument.Value, endDateArgument.Value), out (DateTime, DateTime)[] missingRanges))
static void Main(string[] args)
{
CommandLineParser.CommandLineParser parser = new CommandLineParser.CommandLineParser();
SwitchArgument debugFlag = new SwitchArgument('d', "debug", "Enable debug mode", false);
FileArgument definitionFile = new FileArgument('f', "file", "Path to skin definition file");
definitionFile.Optional = false;
DirectoryArgument steamDirectory = new DirectoryArgument('s', "steam", "Path to Steam directory");
steamDirectory.Optional = false;
DirectoryArgument baseDirectory = new DirectoryArgument('b', "base", "Path to directory containing skin bases. Defaults to %STEAM_FOLDER%/skins/");
SwitchArgument nobackupFlag = new SwitchArgument('n', "nobackup", "Backup old skin folder before writing new one", false);
SwitchArgument activateSkinFlag = new SwitchArgument('a', "activate", "Activate skin after compilation", false);
//dumbResponse = Array.Exists(args, el => el == "--dumb") || Array.Exists(args, el => el == "-q");
parser.Arguments.Add(debugFlag);
parser.Arguments.Add(definitionFile);
parser.Arguments.Add(steamDirectory);
parser.Arguments.Add(baseDirectory);
parser.Arguments.Add(nobackupFlag);
parser.Arguments.Add(activateSkinFlag);
#if !DEBUG
try
{
#endif
parser.ParseCommandLine(args);
#if !DEBUG
try
{
#endif
Core.backupEnabled = !nobackupFlag.Value;
Core.debugMode = debugFlag.Value;
Core.activateSkin = activateSkinFlag.Value;
Core.Compile(definitionFile.Value, steamDirectory.Value, baseDirectory.Value);
#if !DEBUG
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Environment.Exit(2);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Environment.Exit(1);
}
#endif
#if DEBUG
Console.ReadKey();
#endif
}
static void Main(string[] args)
{
CommandLineParser.CommandLineParser parser = new CommandLineParser.CommandLineParser();
SwitchArgument debugFlag = new SwitchArgument('d', "debug", "Enable debug mode", false);
FileArgument definitionFile = new FileArgument('f', "file", "Path to skin definition file");
definitionFile.Optional = false;
DirectoryArgument steamDirectory = new DirectoryArgument('s', "steam", "Path to Steam directory");
steamDirectory.Optional = false;
DirectoryArgument baseDirectory = new DirectoryArgument('b', "base", "Path to directory containing skin bases. Defaults to %STEAM_FOLDER%/skins/");
SwitchArgument nobackupFlag = new SwitchArgument('n', "nobackup", "Backup old skin folder before writing new one", false);
SwitchArgument activateSkinFlag = new SwitchArgument('a', "activate", "Activate skin after compilation", false);
//dumbResponse = Array.Exists(args, el => el == "--dumb") || Array.Exists(args, el => el == "-q");
parser.Arguments.Add(debugFlag);
parser.Arguments.Add(definitionFile);
parser.Arguments.Add(steamDirectory);
parser.Arguments.Add(baseDirectory);
parser.Arguments.Add(nobackupFlag);
parser.Arguments.Add(activateSkinFlag);
#if !DEBUG
try
{
#endif
parser.ParseCommandLine(args);
#if !DEBUG
try
{
#endif
Core.backupEnabled = !nobackupFlag.Value;
Core.debugMode = debugFlag.Value;
Core.activateSkin = activateSkinFlag.Value;
Core.Compile(definitionFile.Value, steamDirectory.Value, baseDirectory.Value);
#if !DEBUG
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Environment.Exit(2);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Environment.Exit(1);
}
#endif
#if DEBUG
Console.ReadKey();
#endif
}
static void Main(string[] args)
{
CommandLineParser.CommandLineParser parser = new CommandLineParser.CommandLineParser()
{
CheckMandatoryArguments = true,
ShowUsageOnEmptyCommandline = true
};
DirectoryArgument schemaDirArg = new DirectoryArgument('s', "schema", "json schema source directory")
{
Optional = false,
DirectoryMustExist = true
};
DirectoryArgument typeScriptDirArg = new DirectoryArgument('t', "typescript", "typescript target directory")
{
Optional = true,
DirectoryMustExist = false
};
DirectoryArgument cSharpDirArg = new DirectoryArgument('c', "csharp", "c# target directory")
{
Optional = true,
DirectoryMustExist = false
};
SwitchArgument interactive = new SwitchArgument('i', "interactive", "interactive yes/no to continue", false);
SwitchArgument recursive = new SwitchArgument('r', "recursive", "recursive parsing from source directory", false);
parser.Arguments.Add(schemaDirArg);
parser.Arguments.Add(typeScriptDirArg);
parser.Arguments.Add(cSharpDirArg);
//parser.Arguments.Add(interactive);
//parser.Arguments.Add(recursive);
try
{
parser.ParseCommandLine(args);
//parser.ShowParsedArguments();
if (!parser.ParsingSucceeded)
{
return;
}
}
catch (Exception e)
{
System.Console.WriteLine("Exception parsing arguments:");
System.Console.WriteLine(e.Message);
parser.PrintUsage(System.Console.Out);
System.Console.WriteLine("press any key to continue");
System.Console.ReadKey();
return;
}
if (typeScriptDirArg.DirectoryInfo == null &&
cSharpDirArg.DirectoryInfo == null)
{
System.Console.WriteLine("TypeScript and/or C# target directory missing");
System.Console.WriteLine("press any key to continue");
System.Console.ReadKey();
return;
}
var sDirInfo = schemaDirArg.DirectoryInfo;
var tDirInfo = typeScriptDirArg.DirectoryInfo;
var cDirInfo = cSharpDirArg.DirectoryInfo;
if (tDirInfo != null && !tDirInfo.Exists)
{
tDirInfo.Create();
}
if (cDirInfo != null && !cDirInfo.Exists)
{
cDirInfo.Create();
}
//get only .json files
var schemasFiles = sDirInfo.GetFiles().ToList().Where((f) => f.Extension.ToLower().Equals(".json")).ToList();
System.Console.WriteLine("found {0} json schema files", schemasFiles.Count());
foreach (FileInfo schemafile in schemasFiles)
{
System.Console.WriteLine("generating from {0} to", schemafile.Name);
try
{
var schema = JsonSchema4.FromFile(schemafile.FullName);
//typescript
if (tDirInfo != null)
{
var generator = new TypeScriptGenerator(schema);
var typeScript = generator.GenerateFile();
Save(sDirInfo, tDirInfo, schemafile, typeScript, ".ts");
}
//c#
if (cDirInfo != null)
{
var generator = new CSharpGenerator(schema);
var cSharp = generator.GenerateFile();
Save(sDirInfo, cDirInfo, schemafile, cSharp, ".cs");
}
}
catch (Exception ex)
{
System.Console.WriteLine("Exception: {0} ", ex.Message);
System.Console.WriteLine("Overstep and continue generating remaining?");
if (!GetYesOrNoUserInput())
{
return;
}
}
}
//exit
System.Console.WriteLine("Done!");
System.Console.WriteLine("Press any key to exit.");
System.Console.ReadKey();
}
static void Main(string[] args)
{
var commandLineParser = new CommandLineParser.CommandLineParser();
var compilerPath = new FileArgument('c', "compiler", "Path to compiler")
{
Optional = false
};
var testsDirectory = new DirectoryArgument('t', "test-dir", "Path to tests directory")
{
Optional = false
};
var testLexer = new SwitchArgument('l', "lexer", "Test lexer", false);
var testParser = new SwitchArgument('p', "parser", "Test parser", false);
var testSemantics = new SwitchArgument('s', "semantics", "Test parser with semantics", false);
var testCodeGen = new SwitchArgument('g', "codegen", "Test code generation", false);
var testAll = new SwitchArgument('a', "all", "Launch all tests", false);
commandLineParser.Arguments.Add(compilerPath);
commandLineParser.Arguments.Add(testsDirectory);
commandLineParser.Arguments.Add(testLexer);
commandLineParser.Arguments.Add(testParser);
commandLineParser.Arguments.Add(testSemantics);
commandLineParser.Arguments.Add(testCodeGen);
commandLineParser.Arguments.Add(testAll);
var testGroupCertification = new ArgumentGroupCertification("a,p,l,s,g", EArgumentGroupCondition.AtLeastOneUsed);
commandLineParser.Certifications.Add(testGroupCertification);
try {
commandLineParser.ParseCommandLine(args);
}
catch (CommandLineException) {
commandLineParser.ShowUsageHeader = "dotnet Tester.dll [pathToCompiler] [pathToTestsRoot]";
commandLineParser.ShowUsage();
}
if (testLexer.Value || testAll.Value)
{
TestLexer(compilerPath.Value.FullName, testsDirectory.Value.FullName);
}
if (testParser.Value || testAll.Value)
{
TestParser(compilerPath.Value.FullName, testsDirectory.Value.FullName, "parser");
}
if (testSemantics.Value || testAll.Value)
{
TestParser(compilerPath.Value.FullName, testsDirectory.Value.FullName, "semantics", true);
}
if (testCodeGen.Value || testAll.Value)
{
string nasmPath;
string gccPath;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
//todo: remove hardcode?
nasmPath = @"C:\Program Files\NASM\nasm.exe";
gccPath = @"C:\Users\Alexey\dev\toolchains\mingw-w64\x86_64-8.1.0-win32-seh-rt_v6-rev0\mingw64\bin\gcc.exe";
}
else
{
nasmPath = "nasm";
gccPath = "gcc";
}
TestCodeGen(compilerPath.Value.FullName, nasmPath, gccPath, testsDirectory.Value.FullName, "codegen");
}
}
static void Main(string[] args)
{
// process args
CommandLineParser.CommandLineParser parser =
new CommandLineParser.CommandLineParser();
var helpArgument = new SwitchArgument(
'h', "help", "Display usage help", false);
var configArgument = new SwitchArgument(
'c', "config", "Only generate config file.", false);
var inputArgument = new DirectoryArgument(
'i', "input", "Path to the input folder. The folder must contain ApiDefinitions.cs and StructsAndEnums.cs");
var outputArgument = new DirectoryArgument(
'o', "output", "Path to the output folder");
outputArgument.DirectoryMustExist = false;
var namespaceArgument = new ValueArgument <string>(
'n', "namespace", "Namespace for the individual objects");
parser.Arguments.Add(helpArgument);
parser.Arguments.Add(configArgument);
parser.Arguments.Add(inputArgument);
parser.Arguments.Add(outputArgument);
parser.Arguments.Add(namespaceArgument);
try
{
parser.ParseCommandLine(args);
if (helpArgument.Parsed && helpArgument.Value)
{
parser.ShowUsage();
Console.WriteLine(@"First step is to generate a config file:
dotnet run -- -i ../Bindings/ -o ../MaterialComponents.Parsed/ -c
Second step is to edit the config file and set EnableBinding and EnableXFWrapper for desired components.
Third step is to generate separated ObjC wrappers and Xamarin Forms wrappers/renderers:
dotnet run -- -i ../Bindings/ -o ../MaterialComponents.Parsed/ -n MaterialComponents");
}
}
catch (CommandLineException e)
{
Console.WriteLine(e.Message);
return;
}
catch (System.IO.DirectoryNotFoundException e)
{
Console.WriteLine(e.Message);
return;
}
// load input files - ApiDefinitions.cs StructsAndEnums.cs
var sharpieParser = new SharpieParser();
var inputFolder = inputArgument.Parsed ? inputArgument.Value : new DirectoryInfo(DefaultInputFolder);
try
{
sharpieParser.ParseInputFolder(inputFolder.FullName);
}
catch (ArgumentException e)
{
Console.WriteLine(e.Message);
return;
}
// output each interface/delegate/enum into separate files, add usings, and namespace
var outputFolder = outputArgument.Parsed ? outputArgument.Value : new DirectoryInfo(DefaultOutputFolder);
var ns = namespaceArgument.Parsed ? namespaceArgument.Value : DefaultNamespace;
var cfgOnly = configArgument.Parsed ? configArgument.Value : false;
// Create or update JSON config file that lists all components we are interested in generating.
sharpieParser.UpdateOrCreateConfig(outputFolder.FullName, DefaultConfigName);
if (!cfgOnly)
{
// Using JSON config create bindings
sharpieParser.WriteOutput(outputFolder.FullName + "/Components/", ns);
sharpieParser.WriteProject(outputFolder.FullName + "/Components/", DefaultProject);
// Using JSON config generates XF wrappers
sharpieParser.WriteXFWrappers(outputFolder.FullName,
DefaultConfigName,
DefaultXfFolder,
DefaultIOSFolder,
DefaultAndroidFolder,
DefaultNamespace);
}
}