using System.Collections.Generic; using SabreTools.Library.Data; using SabreTools.Library.Help; namespace SabreTools { public partial class SabreTools { #region Private Flag features private static Feature addBlankFilesFlag { get { return new Feature( new List() { "-ab", "--add-blank-files" }, "Output blank files for folders", FeatureType.Flag, null); } } private static Feature addDateFlag { get { return new Feature( new List() { "-ad", "--add-date" }, "Add dates to items, where posible", FeatureType.Flag, null); } } private static Feature againstFlag { get { return new Feature( new List() { "-ag", "--against" }, "Diff all inputs against a set of base DATs", FeatureType.Flag, null); } } private static Feature allStatsFlag { get { return new Feature( new List() { "-as", "--all-stats" }, "Write all statistics to all available formats", FeatureType.Flag, null); } } private static Feature archivesAsFilesFlag { get { return new Feature( new List() { "-f", "--archives-as-files" }, "Treat archives as files", FeatureType.Flag, null); } } private static Feature baddumpColumnFlag { get { return new Feature( new List() { "-bc", "--baddump-column" }, "Add baddump stats to output", FeatureType.Flag, null); } } private static Feature baseFlag { get { return new Feature( new List() { "-ba", "--base" }, "Use source DAT as base name for outputs", FeatureType.Flag, null); } } private static Feature baseReplaceFlag { get { return new Feature( new List() { "-br", "--base-replace" }, "Replace from base DATs in order", FeatureType.Flag, null); } } private static Feature cascadeFlag { get { return new Feature( new List() { "-c", "--cascade" }, "Enable cascaded diffing", FeatureType.Flag, null); } } private static Feature chdsAsFilesFlag { get { return new Feature( new List() { "-ic", "--chds-as-files" }, "Treat CHDs as regular files", FeatureType.Flag, null); } } private static Feature cleanFlag { get { return new Feature( new List() { "-clean", "--clean" }, "Clean game names according to WoD standards", FeatureType.Flag, null); } } private static Feature copyFilesFlag { get { return new Feature( new List() { "-cf", "--copy-files" }, "Copy files to the temp directory before parsing", FeatureType.Flag, null); } } private static Feature csvFlag { get { return new Feature( new List() { "-csv", "--csv" }, "Output in Comma-Separated Value format", FeatureType.Flag, null); } } private static Feature datDeviceNonMergedFlag { get { return new Feature( new List() { "-dnd", "--dat-device-non-merged" }, "Create device non-merged sets", FeatureType.Flag, null); } } private static Feature datFullNonMergedFlag { get { return new Feature( new List() { "-df", "--dat-full-non-merged" }, "Force creating fully non-merged sets", FeatureType.Flag, null); } } private static Feature datMergedFlag { get { return new Feature( new List() { "-dm", "--dat-merged" }, "Force creating merged sets", FeatureType.Flag, null); } } private static Feature datNonMergedFlag { get { return new Feature( new List() { "-dnm", "--dat-non-merged" }, "Force creating non-merged sets", FeatureType.Flag, null); } } private static Feature datSplitFlag { get { return new Feature( new List() { "-ds", "--dat-split" }, "Force creating split sets", FeatureType.Flag, null); } } private static Feature dedupFlag { get { return new Feature( new List() { "-dd", "--dedup" }, "Enable deduping in the created DAT", FeatureType.Flag, null); } } private static Feature deleteFlag { get { return new Feature( new List() { "-del", "--delete" }, "Delete fully rebuilt input files", FeatureType.Flag, null); } } private static Feature depotFlag { get { return new Feature( new List() { "-dep", "--depot" }, "Assume directories are romba depots", FeatureType.Flag, null); } } private static Feature descriptionAsNameFlag { get { return new Feature( new List() { "-dan", "--description-as-name" }, "Use description instead of machine name", FeatureType.Flag, null); } } private static Feature diffFlag { get { return new Feature( new List() { "-di", "--diff" }, "Create diffdats from inputs (all outputs)", FeatureType.Flag, null); } } private static Feature diffDuFlag { get { return new Feature( new List() { "-did", "--diff-du" }, "Create diffdat containing just duplicates", FeatureType.Flag, null); } } private static Feature diffInFlag { get { return new Feature( new List() { "-dii", "--diff-in" }, "Create diffdats for individual DATs", FeatureType.Flag, null); } } private static Feature diffNdFlag { get { return new Feature( new List() { "-din", "--diff-nd" }, "Create diffdat containing no duplicates", FeatureType.Flag, null); } } private static Feature excludeOfFlag { get { return new Feature( new List() { "-xof", "--exclude-of" }, "Exclude romof, cloneof, sampleof tags", FeatureType.Flag, null); } } private static Feature extensionFlag { get { return new Feature( new List() { "-es", "--extension" }, "Split DAT(s) by two file extensions", FeatureType.Flag, null); } } private static Feature gameDedupFlag { get { return new Feature( new List() { "-gdd", "--game-dedup" }, "Enable in-game deduping in the created DAT", FeatureType.Flag, null); } } private static Feature gamePrefixFlag { get { return new Feature( new List() { "-gp", "--game-prefix" }, "Add game name as a prefix", FeatureType.Flag, null); } } private static Feature hashFlag { get { return new Feature( new List() { "-hs", "--hash" }, "Split DAT(s) or folder by best-available hashes", FeatureType.Flag, null); } } private static Feature hashOnlyFlag { get { return new Feature( new List() { "-ho", "--hash-only" }, "Check files by hash only", FeatureType.Flag, null); } } private static Feature htmlFlag { get { return new Feature( new List() { "-html", "--html" }, "Output in HTML format", FeatureType.Flag, null); } } private static Feature individualFlag { get { return new Feature( new List() { "-ind", "--individual" }, "Show individual statistics", FeatureType.Flag, null); } } private static Feature inplaceFlag { get { return new Feature( new List() { "-ip", "--inplace" }, "Write to the input directories, where possible", FeatureType.Flag, null); } } private static Feature inverseFlag { get { return new Feature( new List() { "-in", "--inverse" }, "Rebuild only files not in DAT", FeatureType.Flag, null); } } private static Feature levelFlag { get { return new Feature( new List() { "-ls", "--level" }, "Split a SuperDAT or folder by internal path", FeatureType.Flag, null); } } private static Feature mergeFlag { get { return new Feature( new List() { "-m", "--merge" }, "Merge the input DATs", FeatureType.Flag, null); } } private static Feature noAutomaticDateFlag { get { return new Feature( new List() { "-b", "--no-automatic-date" }, "Don't include date in automatic name", FeatureType.Flag, null); } } private static Feature nodumpColumnFlag { get { return new Feature( new List() { "-nc", "--nodump-column" }, "Add nodump stats to output", FeatureType.Flag, null); } } private static Feature noStoreHeaderFlag { get { return new Feature( new List() { "-nsh", "--no-store-header" }, "Don't store the extracted header", FeatureType.Flag, null); } } private static Feature notRunnableFlag { get { return new Feature( new List() { "-nrun", "--not-runnable" }, "Include only items that are marked unrunnable", FeatureType.Flag, null); } } private static Feature matchOfTagsFlag { get { return new Feature( new List() { "-ofg", "--match-of-tags" }, "Allow cloneof and romof tags to match game name filters", FeatureType.Flag, null); } } private static Feature outputAllFlag { get { return new Feature( new List() { "-oa", "--output-all" }, "Output in all formats", FeatureType.Flag, null); } } private static Feature outputAttractmodeFlag { get { return new Feature( new List() { "-oam", "--output-attractmode" }, "Output in AttractMode format", FeatureType.Flag, null); } } private static Feature outputCmpFlag { get { return new Feature( new List() { "-oc", "--output-cmp" }, "Output in CMP format", FeatureType.Flag, null); } } private static Feature outputCsvFlag { get { return new Feature( new List() { "-ocsv", "--output-csv" }, "Output in CSV format", FeatureType.Flag, null); } } private static Feature outputDoscenterFlag { get { return new Feature( new List() { "-od", "--output-doscenter" }, "Output in DOSCenter format", FeatureType.Flag, null); } } private static Feature outputListromFlag { get { return new Feature( new List() { "-olr", "--output-listrom" }, "Output in MAME Listrom format", FeatureType.Flag, null); } } private static Feature outputMd5Flag { get { return new Feature( new List() { "-omd5", "--output-md5" }, "Output in MD5 format", FeatureType.Flag, null); } } private static Feature outputMissFlag { get { return new Feature( new List() { "-om", "--output-miss" }, "Output in Missfile format", FeatureType.Flag, new List() { "", "Prefix and postfix can include certain fields from the", "items by including %blah% in the input.", "A list of features that can be used are:", " game, name, crc, md5, sha1, sha256, sha384, sha512, size", }); } } private static Feature outputOfflinelistFlag { get { return new Feature( new List() { "-ool", "--output-offlinelist" }, "Output in OfflineList format", FeatureType.Flag, null); } } private static Feature outputRomcenterFlag { get { return new Feature( new List() { "-or", "--output-romcenter" }, "Output in RomCenter format", FeatureType.Flag, null); } } private static Feature outputSabredatFlag { get { return new Feature( new List() { "-os", "--output-sabredat" }, "Output in SabreDat format", FeatureType.Flag, null); } } private static Feature outputSfvFlag { get { return new Feature( new List() { "-osfv", "--output-sfv" }, "Output in SFV format", FeatureType.Flag, null); } } private static Feature outputSha1Flag { get { return new Feature( new List() { "-osha1", "--output-sha1" }, "Output in SHA-1 format", FeatureType.Flag, null); } } private static Feature outputSha256Flag { get { return new Feature( new List() { "-osha256", "--output-sha256" }, "Output in SHA-256 format", FeatureType.Flag, null); } } private static Feature outputSha384Flag { get { return new Feature( new List() { "-osha384", "--output-sha384" }, "Output in SHA-256 format", FeatureType.Flag, null); } } private static Feature outputSha512Flag { get { return new Feature( new List() { "-osha512", "--output-sha512" }, "Output in SHA-256 format", FeatureType.Flag, null); } } private static Feature outputSoftwarelistFlag { get { return new Feature( new List() { "-osl", "--output-softwarelist" }, "Output in Softwarelist format", FeatureType.Flag, null); } } private static Feature outputTsvFlag { get { return new Feature( new List() { "-otsv", "--output-tsv" }, "Output in TSV format", FeatureType.Flag, null); } } private static Feature outputXmlFlag { get { return new Feature( new List() { "-ox", "--output-xml" }, "Output in Logiqx XML format [default]", FeatureType.Flag, null); } } private static Feature quickFlag { get { return new Feature( new List() { "-qs", "--quick" }, "Enable quick scanning of archives", FeatureType.Flag, null); } } private static Feature quotesFlag { get { return new Feature( new List() { "-q", "--quotes" }, "Put double-quotes around each item", FeatureType.Flag, null); } } private static Feature removeExtensionsFlag { get { return new Feature( new List() { "-rme", "--remove-extensions" }, "Remove all extensions from each item", FeatureType.Flag, null); } } private static Feature removeMd5Flag { get { return new Feature( new List() { "-rmd5", "--remove-md5" }, "Remove MD5 hashes from the output", FeatureType.Flag, null); } } private static Feature removeSha1Flag { get { return new Feature( new List() { "-rsha1", "--remove-sha1" }, "Remove SHA-1 hashes from the output", FeatureType.Flag, null); } } private static Feature removeSha256Flag { get { return new Feature( new List() { "-rsha256", "--remove-sha256" }, "Remove SHA-256 hashes from the output", FeatureType.Flag, null); } } private static Feature removeSha384Flag { get { return new Feature( new List() { "-rsha384", "--remove-sha384" }, "Remove SHA-384 hashes from the output", FeatureType.Flag, null); } } private static Feature removeSha512Flag { get { return new Feature( new List() { "-rsha512", "--remove-sha512" }, "Remove SHA-512 hashes from the output", FeatureType.Flag, null); } } private static Feature removeUnicodeFlag { get { return new Feature( new List() { "-ru", "--remove-unicode" }, "Remove unicode characters from names", FeatureType.Flag, null); } } private static Feature reverseBaseReplaceFlag { get { return new Feature( new List() { "-rbr", "--reverse-base-replace" }, "Replace item names from base DATs in reverse", FeatureType.Flag, null); } } private static Feature reverseCascadeFlag { get { return new Feature( new List() { "-rc", "--reverse-cascade" }, "Enable reverse cascaded diffing", FeatureType.Flag, null); } } private static Feature rombaFlag { get { return new Feature( new List() { "-ro", "--romba" }, "Treat like a Romba depot (requires SHA-1)", FeatureType.Flag, null); } } private static Feature romsFlag { get { return new Feature( new List() { "-r", "--roms" }, "Output roms to miss instead of sets", FeatureType.Flag, null); } } private static Feature runnableFlag { get { return new Feature( new List() { "-run", "--runnable" }, "Include only items that are marked runnable", FeatureType.Flag, null); } } private static Feature scanAllFlag { get { return new Feature( new List() { "-sa", "--scan-all" }, "Set scanning levels for all archives to 0", FeatureType.Flag, null); } } private static Feature sceneDateStripFlag { get { return new Feature( new List() { "-sds", "--scene-date-strip" }, "Remove date from scene-named sets", FeatureType.Flag, null); } } private static Feature shortFlag { get { return new Feature( new List() { "-s", "--short" }, "Use short output names", FeatureType.Flag, null); } } private static Feature singleSetFlag { get { return new Feature( new List() { "-si", "--single-set" }, "All game names replaced by '!'", FeatureType.Flag, null); } } private static Feature sizeFlag { get { return new Feature( new List() { "-szs", "--size" }, "Split DAT(s) or folder by file sizes", FeatureType.Flag, null); } } private static Feature skipFirstOutputFlag { get { return new Feature( new List() { "-sf", "--skip-first-output" }, "Skip output of first DAT", FeatureType.Flag, null); } } private static Feature skipArchivesFlag { get { return new Feature( new List() { "-ska", "--skip-archives" }, "Skip any files that are treated like archives", FeatureType.Flag, null); } } private static Feature skipFilesFlag { get { return new Feature( new List() { "-skf", "--skip-files" }, "Skip any files that are not treated like archives", FeatureType.Flag, null); } } private static Feature skipMd5Flag { get { return new Feature( new List() { "-nm", "--skip-md5" }, "Don't include MD5 in output", FeatureType.Flag, null); } } private static Feature skipSha1Flag { get { return new Feature( new List() { "-ns", "--skip-sha1" }, "Don't include SHA1 in output", FeatureType.Flag, null); } } private static Feature skipSha256Flag { get { return new Feature( new List() { "-ns256", "--skip-sha256" }, "Include SHA-256 in output", // TODO: Invert this later FeatureType.Flag, null); } } private static Feature skipSha384Flag { get { return new Feature( new List() { "-ns384", "--skip-sha384" }, "Include SHA-384 in output", // TODO: Invert this later FeatureType.Flag, null); } } private static Feature skipSha512Flag { get { return new Feature( new List() { "-ns512", "--skip-sha512" }, "Include SHA-512 in output", // TODO: Invert this later FeatureType.Flag, null); } } private static Feature superdatFlag { get { return new Feature( new List() { "-sd", "--superdat" }, "Enable SuperDAT creation", FeatureType.Flag, null); } } private static Feature tarFlag { get { return new Feature( new List() { "-tar", "--tar" }, "Enable TAR output", FeatureType.Flag, null); } } private static Feature textFlag { get { return new Feature( new List() { "-txt", "--text" }, "Output in generic text format", FeatureType.Flag, null); } } private static Feature torrent7zipFlag { get { return new Feature( new List() { "-t7z", "--torrent-7zip" }, "Enable Torrent7z output", FeatureType.Flag, null); } } private static Feature torrentGzipFlag { get { return new Feature( new List() { "-tgz", "--torrent-gzip" }, "Enable TorrentGZ output", FeatureType.Flag, null); } } private static Feature torrentLrzipFlag { get { return new Feature( new List() { "-tlrz", "--torrent-lrzip" }, "Enable TorrentLRZ output", FeatureType.Flag, null); } } private static Feature torrentLz4Flag { get { return new Feature( new List() { "-tlz4", "--torrent-lz4" }, "Enable TorrentLZ4 output", FeatureType.Flag, null); } } private static Feature torrentRarFlag { get { return new Feature( new List() { "-trar", "--torrent-rar" }, "Enable TorrentRAR output", FeatureType.Flag, null); } } private static Feature torrentXzFlag { get { return new Feature( new List() { "-txz", "--torrent-xz" }, "Enable TorrentXZ output", FeatureType.Flag, null); } } private static Feature torrentZipFlag { get { return new Feature( new List() { "-tzip", "--torrent-zip" }, "Enable TorrentZip output", FeatureType.Flag, null); } } private static Feature torrentZpaqFlag { get { return new Feature( new List() { "-tzpaq", "--torrent-zpaq" }, "Enable TorrentZPAQ output", FeatureType.Flag, null); } } private static Feature torrentZstdFlag { get { return new Feature( new List() { "-tzstd", "--torrent-zstd" }, "Enable TorrentZstd output", FeatureType.Flag, null); } } private static Feature trimFlag { get { return new Feature( new List() { "-trim", "--trim" }, "Trim file names to fit NTFS length", FeatureType.Flag, null); } } private static Feature tsvFlag { get { return new Feature( new List() { "-tsv", "--tsv" }, "Output in Tab-Separated Value format", FeatureType.Flag, null); } } private static Feature typeFlag { get { return new Feature( new List() { "-ts", "--type" }, "Split DAT(s) or folder by file types (rom/disk)", FeatureType.Flag, null); } } private static Feature updateDatFlag { get { return new Feature( new List() { "-ud", "--update-dat" }, "Output updated DAT to output directory", FeatureType.Flag, null); } } private static Feature updateDescriptionFlag { get { return new Feature( new List() { "-udd", "--update-description" }, "Update machine descriptions from base DATs", FeatureType.Flag, null); } } private static Feature updateHashesFlag { get { return new Feature( new List() { "-uh", "--update-hashes" }, "Update hashes from base DATs", FeatureType.Flag, null); } } private static Feature updateManufacturerFlag { get { return new Feature( new List() { "-um", "--update-manufacturer" }, "Update machine manufacturers from base DATs", FeatureType.Flag, null); } } private static Feature updateNamesFlag { get { return new Feature( new List() { "-un", "--update-names" }, "Update item names from base DATs", FeatureType.Flag, null); } } private static Feature updateYearFlag { get { return new Feature( new List() { "-uy", "--update-year" }, "Update machine years from base DATs", FeatureType.Flag, null); } } #endregion #region Private Int32 features private static Feature gzInt32Input { get { return new Feature( new List() { "-gz", "--gz" }, "Set scanning level for GZip archives (default 1)", FeatureType.Int32, null); } } private static Feature rarInt32Input { get { return new Feature( new List() { "-rar", "--rar" }, "Set scanning level for RAR archives (default 1)", FeatureType.Int32, null); } } private static Feature sevenZipInt32Input { get { return new Feature( new List() { "-7z", "--7z" }, "Set scanning level for 7z archives (default 1)", FeatureType.Int32, null); } } private static Feature threadsInt32Input { get { return new Feature( new List() { "-mt", "--threads" }, "Amount of threads to use (default = # cores, -1 unlimted)", FeatureType.Int32, null); } } private static Feature zipInt32Input { get { return new Feature( new List() { "-zip", "--zip" }, "Set scanning level for ZIP archives (default 1)", FeatureType.Int32, null); } } #endregion #region Private Int64 features private static Feature radixInt64Input { get { return new Feature( new List() { "-rad", "--radix" }, "Set the midpoint to split at", FeatureType.Int64, null); } } #endregion #region Private List features private static Feature baseDatListInput { get { return new Feature( new List() { "-bd", "--base-dat" }, "Add a base DAT for processing", FeatureType.List, null); } } private static Feature crcListInput { get { return new Feature( new List() { "-crc", "--crc" }, "Filter by CRC hash", FeatureType.List, null); } } private static Feature datListInput { get { return new Feature( new List() { "-dat", "--dat" }, "Input DAT", FeatureType.List, null); } } private static Feature extaListInput { get { return new Feature( new List() { "-exta", "--exta" }, "First extension (multiple allowed)", FeatureType.List, null); } } private static Feature extbListInput { get { return new Feature( new List() { "-extb", "--extb" }, "Second extension (multiple allowed)", FeatureType.List, null); } } private static Feature gameNameListInput { get { return new Feature( new List() { "-gn", "--game-name" }, "Filter by game name", FeatureType.List, null); } } private static Feature gameTypeListInput { get { return new Feature( new List() { "-gt", "--game-type" }, "Include only games with a given type", FeatureType.List, new List() { " Supported values are:", " None, Bios, Device, Mechanical", }); } } private static Feature itemNameListInput { get { return new Feature( new List() { "-rn", "--item-name" }, "Filter by item name", FeatureType.List, null); } } private static Feature itemTypeListInput { get { return new Feature( new List() { "-rt", "--item-type" }, "Filter by item type", FeatureType.List, null); } } private static Feature md5ListInput { get { return new Feature( new List() { "-md5", "--md5" }, "Filter by MD5 hash", FeatureType.List, null); } } private static Feature notCrcListInput { get { return new Feature( new List() { "-ncrc", "--not-crc" }, "Filter by not CRC hash", FeatureType.List, null); } } private static Feature notGameNameListInput { get { return new Feature( new List() { "-ngn", "--not-game-name" }, "Filter by not game name", FeatureType.List, null); } } private static Feature notGameTypeListInput { get { return new Feature( new List() { "-ngt", "--not-game-type" }, "Exclude only games with a given type", FeatureType.List, new List() { " Supported values are:", " None, Bios, Device, Mechanical", }); } } private static Feature notItemNameListInput { get { return new Feature( new List() { "-nrn", "--not-item-name" }, "Filter by not rom name", FeatureType.List, null); } } private static Feature notItemTypeListInput { get { return new Feature( new List() { "-nrt", "--not-item-type" }, "Filter by not item type", FeatureType.List, null); } } private static Feature notMd5ListInput { get { return new Feature( new List() { "-nmd5", "--not-md5" }, "Filter by not MD5 hash", FeatureType.List, null); } } private static Feature notSha1ListInput { get { return new Feature( new List() { "-nsha1", "--not-sha1" }, "Filter by not SHA-1 hash", FeatureType.List, null); } } private static Feature notSha256ListInput { get { return new Feature( new List() { "-nsha256", "--not-sha256" }, "Filter by not SHA-256 hash", FeatureType.List, null); } } private static Feature notSha384ListInput { get { return new Feature( new List() { "-nsha384", "--not-sha384" }, "Filter by not SHA-384 hash", FeatureType.List, null); } } private static Feature notSha512ListInput { get { return new Feature( new List() { "-nsha512", "--not-sha512" }, "Filter by not SHA-512 hash", FeatureType.List, null); } } private static Feature notStatusListInput { get { return new Feature( new List() { "-nis", "--not-status" }, "Exclude only items with a given status", FeatureType.List, new List() { " Supported values are:", " None, Good, BadDump, Nodump, Verified", }); } } private static Feature sha1ListInput { get { return new Feature( new List() { "-sha1", "--sha1" }, "Filter by SHA-1 hash", FeatureType.List, null); } } private static Feature sha256ListInput { get { return new Feature( new List() { "-sha256", "--sha256" }, "Filter by SHA-256 hash", FeatureType.List, null); } } private static Feature sha384ListInput { get { return new Feature( new List() { "-sha384", "--sha384" }, "Filter by SHA-384 hash", FeatureType.List, null); } } private static Feature sha512ListInput { get { return new Feature( new List() { "-sha512", "--sha512" }, "Filter by SHA-512 hash", FeatureType.List, null); } } private static Feature statusListInput { get { return new Feature( new List() { "-is", "--status" }, "Include only items with a given status", FeatureType.List, new List() { " Supported values are:", " None, Good, BadDump, Nodump, Verified", }); } } #endregion #region Private String features private static Feature addExtensionStringInput { get { return new Feature( new List() { "-ae", "--add-extension" }, "Add an extension to each item", FeatureType.String, null); } } private static Feature authorStringInput { get { return new Feature( new List() { "-au", "--author" }, "Set the author of the DAT", FeatureType.String, null); } } private static Feature categoryStringInput { get { return new Feature( new List() { "-c", "--category" }, "Set the category of the DAT", FeatureType.String, null); } } private static Feature commentStringInput { get { return new Feature( new List() { "-co", "--comment" }, "Set a new comment of the DAT", FeatureType.String, null); } } private static Feature dateStringInput { get { return new Feature( new List() { "-da", "--date" }, "Set a new date", FeatureType.String, null); } } private static Feature descriptionStringInput { get { return new Feature( new List() { "-de", "--description" }, "Set the description of the DAT", FeatureType.String, null); } } private static Feature emailStringInput { get { return new Feature( new List() { "-em", "--email" }, "Set a new email of the DAT", FeatureType.String, null); } } private static Feature equalStringInput { get { return new Feature( new List() { "-seq", "--equal" }, "Filter by size ==", FeatureType.String, null); } } private static Feature filenameStringInput { get { return new Feature( new List() { "-f", "--filename" }, "Set the external name of the DAT", FeatureType.String, null); } } private static Feature forcemergingStringInput { get { return new Feature( new List() { "-fm", "--forcemerging" }, "Set force merging", FeatureType.String, new List() { " Supported values are:", " None, Split, Merged, Nonmerged, Full", }); } } private static Feature forcenodumpStringInput { get { return new Feature( new List() { "-fn", "--forcenodump" }, "Set force nodump", FeatureType.String, new List() { " Supported values are:", " None, Obsolete, Required, Ignore", }); } } private static Feature forcepackingStringInput { get { return new Feature( new List() { "-fp", "--forcepacking" }, "Set force packing", FeatureType.String, new List() { "Supported values are:", " None, Zip, Unzip", }); } } private static Feature greaterStringInput { get { return new Feature( new List() { "-sgt", "--greater" }, "Filter by size >=", FeatureType.String, null); } } private static Feature headerStringInput { get { return new Feature( new List() { "-h", "--header" }, "Set a header skipper to use, blank means all", FeatureType.String, null); } } private static Feature homepageStringInput { get { return new Feature( new List() { "-hp", "--homepage" }, "Set a new homepage of the DAT", FeatureType.String, null); } } private static Feature lessStringInput { get { return new Feature( new List() { "-slt", "--less" }, "Filter by size =<", FeatureType.String, null); } } private static Feature nameStringInput { get { return new Feature( new List() { "-n", "--name" }, "Set the internal name of the DAT", FeatureType.String, null); } } private static Feature outputDirStringInput { get { return new Feature( new List() { "-out", "--output-dir" }, "Output directory", FeatureType.String, null); } } private static Feature postfixStringInput { get { return new Feature( new List() { "-post", "--postfix" }, "Set postfix for all lines", FeatureType.String, null); } } private static Feature prefixStringInput { get { return new Feature( new List() { "-pre", "--prefix" }, "Set prefix for all lines", FeatureType.String, null); } } private static Feature replaceExtensionStringInput { get { return new Feature( new List() { "-rep", "--replace-extension" }, "Replace all extensions with specified", FeatureType.String, null); } } private static Feature rootStringInput { get { return new Feature( new List() { "-r", "--root" }, "Set a new rootdir", FeatureType.String, null); } } private static Feature rootDirFeature { get { return new Feature( new List() { "-rd", "--root-dir" }, "Set the root directory for calc", FeatureType.String, null); } } private static Feature tempFeature { get { return new Feature( new List() { "-t", "--temp" }, "Set the temporary directory to use", FeatureType.String, null); } } private static Feature urlFeature { get { return new Feature( new List() { "-u", "--url" }, "Set a new URL of the DAT", FeatureType.String, null); } } private static Feature versionFeature { get { return new Feature( new List() { "-v", "--version" }, "Set the version of the DAT", FeatureType.String, null); } } #endregion public static Help RetrieveHelp() { // Create and add the header to the Help object string barrier = "-----------------------------------------"; List helpHeader = new List() { "SabreTools - Manipulate, convert, and use DAT files", barrier, "Usage: SabreTools [option] [flags] [filename|dirname] ...", "" }; Help help = new Help(helpHeader); #region Help Feature helpFeature = new Feature( new List() { "-?", "-h", "--help" }, "Show this help", FeatureType.Flag, null); #endregion #region Script Feature script = new Feature( "--script", "Enable script mode (no clear screen)", FeatureType.Flag, null); #endregion #region DATFromDir Feature datFromDir = new Feature( new List() { "-d", "--d2d", "--dfd" }, "Create DAT(s) from an input directory", FeatureType.Flag, null); datFromDir.AddFeature("skip-md5", skipMd5Flag); datFromDir.AddFeature("skip-sha1", skipSha1Flag); datFromDir.AddFeature("skip-sha256", skipSha256Flag); datFromDir.AddFeature("skip-sha384", skipSha384Flag); datFromDir.AddFeature("skip-sha512", skipSha512Flag); datFromDir.AddFeature("no-automatic-date", noAutomaticDateFlag); datFromDir.AddFeature("forcepacking", forcepackingStringInput); datFromDir.AddFeature("archives-as-files", archivesAsFilesFlag); datFromDir.AddFeature("output-all", outputAllFlag); datFromDir.AddFeature("output-attractmode", outputAttractmodeFlag); datFromDir.AddFeature("output-cmp", outputCmpFlag); datFromDir.AddFeature("output-csv", outputCsvFlag); datFromDir.AddFeature("output-doscenter", outputDoscenterFlag); datFromDir.AddFeature("output-listrom", outputListromFlag); datFromDir.AddFeature("output-miss", outputMissFlag); datFromDir.AddFeature("output-md5", outputMd5Flag); datFromDir.AddFeature("output-offlinelist", outputOfflinelistFlag); datFromDir.AddFeature("output-romcenter", outputRomcenterFlag); datFromDir.AddFeature("output-sabredat", outputSabredatFlag); datFromDir.AddFeature("output-sfv", outputSfvFlag); datFromDir.AddFeature("output-sha1", outputSha1Flag); datFromDir.AddFeature("output-sha256", outputSha256Flag); datFromDir.AddFeature("output-sha384", outputSha384Flag); datFromDir.AddFeature("output-sha512", outputSha512Flag); datFromDir.AddFeature("output-softwarelist", outputSoftwarelistFlag); datFromDir.AddFeature("output-tsv", outputTsvFlag); datFromDir.AddFeature("output-xml", outputXmlFlag); datFromDir.AddFeature("romba", rombaFlag); datFromDir.AddFeature("skip-archives", skipArchivesFlag); datFromDir.AddFeature("skip-files", skipFilesFlag); datFromDir.AddFeature("filename", filenameStringInput); datFromDir.AddFeature("name", nameStringInput); datFromDir.AddFeature("description", descriptionStringInput); datFromDir.AddFeature("category", categoryStringInput); datFromDir.AddFeature("version", versionFeature); datFromDir.AddFeature("author", authorStringInput); datFromDir.AddFeature("email", emailStringInput); datFromDir.AddFeature("homepage", homepageStringInput); datFromDir.AddFeature("url", urlFeature); datFromDir.AddFeature("comment", commentStringInput); datFromDir.AddFeature("superdat", superdatFlag); datFromDir.AddFeature("exclude-of", excludeOfFlag); datFromDir.AddFeature("scene-date-strip", sceneDateStripFlag); datFromDir.AddFeature("add-blank-files", addBlankFilesFlag); datFromDir.AddFeature("add-date", addDateFlag); datFromDir.AddFeature("copy-files", copyFilesFlag); datFromDir.AddFeature("header", headerStringInput); datFromDir.AddFeature("chds-as-files", chdsAsFilesFlag); datFromDir.AddFeature("temp", tempFeature); datFromDir.AddFeature("output-dir", outputDirStringInput); datFromDir.AddFeature("threads", threadsInt32Input); #endregion #region Extract Feature extract = new Feature( new List() { "-ex", "--extract" }, "Extract and remove copier headers", FeatureType.Flag, null); extract.AddFeature("output-dir", outputDirStringInput); extract.AddFeature("no-store-header", noStoreHeaderFlag); #endregion #region Restore Feature restore = new Feature( new List() { "-re", "--restore" }, "Restore header to file based on SHA-1", FeatureType.Flag, null); restore.AddFeature("output-dir", outputDirStringInput); #endregion #region Sort Feature sort = new Feature( new List() { "-ss", "--sort" }, "Sort inputs by a set of DATs", FeatureType.Flag, new List() { "", "Archive scanning levels:", " 0 Hash archive and contents", " 1 Only hash contents", " 2 Only hash archive", }); sort.AddFeature("dat", datListInput); sort.AddFeature("output-dir", outputDirStringInput); sort.AddFeature("depot", depotFlag); sort.AddFeature("delete", deleteFlag); sort.AddFeature("inverse", inverseFlag); sort.AddFeature("quick", quickFlag); sort.AddFeature("chds-as-files", chdsAsFilesFlag); sort.AddFeature("add-date", addDateFlag); sort.AddFeature("torrent-7zip", torrent7zipFlag); sort.AddFeature("tar", tarFlag); sort.AddFeature("torrent-gzip", torrentGzipFlag); sort["tgz"].AddFeature("romba", rombaFlag); //sort.AddFeature("torrent-lrzip", tlrzFeature); //sort.AddFeature("torrent-lz4", tlz4Feature); //sort.AddFeature("torrent-rar", trarFeature); //sort.AddFeature("torrent-xz", txzFeature); sort.AddFeature("torrent-zip", torrentZipFlag); //sort.AddFeature("torrent-zpaq", tzpaqFeature); //sort.AddFeature("torrent-zstd", tzstdFeature); sort.AddFeature("header", headerStringInput); sort.AddFeature("7z", sevenZipInt32Input); sort.AddFeature("gz", gzInt32Input); sort.AddFeature("rar", rarInt32Input); sort.AddFeature("zip", zipInt32Input); sort.AddFeature("scan-all", scanAllFlag); sort.AddFeature("dat-merged", datMergedFlag); sort.AddFeature("dat-split", datSplitFlag); sort.AddFeature("dat-non-merged", datNonMergedFlag); sort.AddFeature("dat-device-non-merged", datDeviceNonMergedFlag); sort.AddFeature("dat-full-non-merged", datFullNonMergedFlag); sort.AddFeature("update-dat", updateDatFlag); sort.AddFeature("threads", threadsInt32Input); #endregion #region Split Feature split = new Feature( new List() { "-sp", "--split" }, "Split input DATs by a given criteria", FeatureType.Flag, null); split.AddFeature("output-all", outputAllFlag); split.AddFeature("output-attractmode", outputAttractmodeFlag); split.AddFeature("output-cmp", outputCmpFlag); split.AddFeature("output-csv", outputCsvFlag); split.AddFeature("output-doscenter", outputDoscenterFlag); split.AddFeature("output-listrom", outputListromFlag); split.AddFeature("output-miss", outputMissFlag); split.AddFeature("output-md5", outputMd5Flag); split.AddFeature("output-offlinelist", outputOfflinelistFlag); split.AddFeature("output-romcenter", outputRomcenterFlag); split.AddFeature("output-sabredat", outputSabredatFlag); split.AddFeature("output-sfv", outputSfvFlag); split.AddFeature("output-sha1", outputSha1Flag); split.AddFeature("output-sha256", outputSha256Flag); split.AddFeature("output-sha384", outputSha384Flag); split.AddFeature("output-sha512", outputSha512Flag); split.AddFeature("output-softwarelist", outputSoftwarelistFlag); split.AddFeature("output-tsv", outputTsvFlag); split.AddFeature("output-xml", outputXmlFlag); split.AddFeature("output-dir", outputDirStringInput); split.AddFeature("inplace", inplaceFlag); split.AddFeature("extension", extensionFlag); split["ext"].AddFeature("exta", extaListInput); split["ext"].AddFeature("extb", extbListInput); split.AddFeature("hash", hashFlag); split.AddFeature("level", levelFlag); split["level"].AddFeature("short", shortFlag); split["level"].AddFeature("base", baseFlag); split.AddFeature("size", sizeFlag); split["size"].AddFeature("radix", radixInt64Input); split.AddFeature("type", typeFlag); #endregion #region Stats Feature stats = new Feature( new List() { "-st", "--stats" }, "Get statistics on all input DATs", FeatureType.Flag, null); stats.AddFeature("all-stats", allStatsFlag); stats.AddFeature("baddump-column", baddumpColumnFlag); stats.AddFeature("csv", csvFlag); stats.AddFeature("filename", filenameStringInput); stats.AddFeature("output-dir", outputDirStringInput); stats.AddFeature("html", htmlFlag); stats.AddFeature("nodump-col", nodumpColumnFlag); stats.AddFeature("individual", individualFlag); stats.AddFeature("tsv", tsvFlag); stats.AddFeature("text", textFlag); #endregion #region Update Feature update = new Feature( new List() { "-ud", "--update" }, "Update and manipulate DAT file(s)", FeatureType.Flag, new List() { "", "Filter parameters game name, rom name, all hashes can", "be matched using full C#-style regex.", "", "Filter parameters for size can use postfixes for inputs:", " e.g. 8kb => 8000 or 8kib => 8192", "", "Most of the filter parameters allow for multiple inputs:", " e.g. --game-name=foo --game-name=bar", }); update.AddFeature("output-all", outputAllFlag); update.AddFeature("output-attractmode", outputAttractmodeFlag); update.AddFeature("output-cmp", outputCmpFlag); update.AddFeature("output-csv", outputCsvFlag); update["output-csv"].AddFeature("prefix", prefixStringInput); update["output-csv"].AddFeature("postfix", postfixStringInput); update["output-csv"].AddFeature("quotes", quotesFlag); update.AddFeature("output-doscenter", outputDoscenterFlag); update.AddFeature("output-listrom", outputListromFlag); update.AddFeature("output-miss", outputMissFlag); update["output-miss"].AddFeature("roms", romsFlag); update["output-miss"].AddFeature("game-prefix", gamePrefixFlag); update["output-miss"].AddFeature("prefix", prefixStringInput); update["output-miss"].AddFeature("postfix", postfixStringInput); update["output-miss"].AddFeature("quotes", quotesFlag); update["output-miss"].AddFeature("add-extension", addExtensionStringInput); update["output-miss"].AddFeature("replace-extension", replaceExtensionStringInput); update["output-miss"].AddFeature("remove-extensions", removeExtensionsFlag); update["output-miss"].AddFeature("romba", rombaFlag); update.AddFeature("output-md5", outputMd5Flag); update["output-md5"].AddFeature("game-prefix", gamePrefixFlag); update.AddFeature("output-offlinelist", outputOfflinelistFlag); update.AddFeature("output-romcenter", outputRomcenterFlag); update.AddFeature("output-sabredat", outputSabredatFlag); update.AddFeature("output-sfv", outputSfvFlag); update["output-sfv"].AddFeature("game-prefix", gamePrefixFlag); update.AddFeature("output-sha1", outputSha1Flag); update["output-sha1"].AddFeature("game-prefix", gamePrefixFlag); update.AddFeature("output-sha256", outputSha256Flag); update["output-sha256"].AddFeature("game-prefix", gamePrefixFlag); update.AddFeature("output-sha384", outputSha384Flag); update["output-sha384"].AddFeature("game-prefix", gamePrefixFlag); update.AddFeature("output-sha512", outputSha512Flag); update["output-sha512"].AddFeature("game-prefix", gamePrefixFlag); update.AddFeature("output-softwarelist", outputSoftwarelistFlag); update.AddFeature("output-tsv", outputTsvFlag); update["output-tsv"].AddFeature("prefix", prefixStringInput); update["output-tsv"].AddFeature("postfix", postfixStringInput); update["output-tsv"].AddFeature("quotes", quotesFlag); update.AddFeature("output-xml", outputXmlFlag); update.AddFeature("filename", filenameStringInput); update.AddFeature("name", nameStringInput); update.AddFeature("description", descriptionStringInput); update.AddFeature("rootdir", rootStringInput); update.AddFeature("category", categoryStringInput); update.AddFeature("version", versionFeature); update.AddFeature("date", dateStringInput); update.AddFeature("author", authorStringInput); update.AddFeature("email", emailStringInput); update.AddFeature("homepage", homepageStringInput); update.AddFeature("url", urlFeature); update.AddFeature("comment", commentStringInput); update.AddFeature("header", headerStringInput); update.AddFeature("superdat", superdatFlag); update.AddFeature("forcemerging", forcemergingStringInput); update.AddFeature("forcenodump", forcenodumpStringInput); update.AddFeature("forcepacking", forcepackingStringInput); update.AddFeature("exclude-of", excludeOfFlag); update.AddFeature("scene-date-strip", sceneDateStripFlag); update.AddFeature("clean", cleanFlag); update.AddFeature("remove-uni", removeUnicodeFlag); update.AddFeature("remove-md5", removeMd5Flag); update.AddFeature("remove-sha1", removeSha1Flag); update.AddFeature("remove-sha256", removeSha256Flag); update.AddFeature("remove-sha384", removeSha384Flag); update.AddFeature("remove-sha512", removeSha512Flag); update.AddFeature("description-as-name", descriptionAsNameFlag); update.AddFeature("dat-merged", datMergedFlag); update.AddFeature("dat-split", datSplitFlag); update.AddFeature("dat-non-merged", datNonMergedFlag); update.AddFeature("dat-device-non-merged", datDeviceNonMergedFlag); update.AddFeature("dat-full-non-merged", datFullNonMergedFlag); update.AddFeature("trim", trimFlag); update["trim"].AddFeature("root-dir", rootDirFeature); update.AddFeature("single-set", singleSetFlag); update.AddFeature("dedup", dedupFlag); update.AddFeature("game-dedup", gameDedupFlag); update.AddFeature("merge", mergeFlag); update["merge"].AddFeature("no-automatic-date", noAutomaticDateFlag); update.AddFeature("diff", diffFlag); update["diff"].AddFeature("against", againstFlag); update["diff"]["against"].AddFeature("base-dat", baseDatListInput); update["diff"].AddFeature("no-automatic-date", noAutomaticDateFlag); update["diff"].AddFeature("cascade", cascadeFlag); update["diff"]["cascade"].AddFeature("skip-first-output", skipFirstOutputFlag); update["diff"].AddFeature("reverse-cascade", reverseCascadeFlag); update["diff"]["rev-cascade"].AddFeature("skip-first-output", skipFirstOutputFlag); update.AddFeature("diff-du", diffDuFlag); update["diff-du"].AddFeature("no-automatic-date", noAutomaticDateFlag); update.AddFeature("diff-in", diffInFlag); update["diff-in"].AddFeature("no-automatic-date", noAutomaticDateFlag); update.AddFeature("diff-nd", diffNdFlag); update["diff-nd"].AddFeature("no-automatic-date", noAutomaticDateFlag); update.AddFeature("base-replace", baseReplaceFlag); update["base-replace"].AddFeature("base-dat", baseDatListInput); update["base-replace"].AddFeature("update-names", updateNamesFlag); update["base-replace"].AddFeature("update-hashes", updateHashesFlag); update["base-replace"].AddFeature("update-description", updateDescriptionFlag); update["base-replace"].AddFeature("update-year", updateYearFlag); update["base-replace"].AddFeature("update-manufacturer", updateManufacturerFlag); update.AddFeature("reverse-base-replace", reverseBaseReplaceFlag); update["reverse-base-replace"].AddFeature("base-dat", baseDatListInput); update["reverse-base-replace"].AddFeature("update-names", updateNamesFlag); update["reverse-base-replace"].AddFeature("update-hashes", updateHashesFlag); update["reverse-base-replace"].AddFeature("update-description", updateDescriptionFlag); update["reverse-base-replace"].AddFeature("update-year", updateYearFlag); update["reverse-base-replace"].AddFeature("update-manufacturer", updateManufacturerFlag); update.AddFeature("game-name", gameNameListInput); update.AddFeature("not-game-name", notGameNameListInput); update.AddFeature("match-of-tags", matchOfTagsFlag); update.AddFeature("rom-name", itemNameListInput); update.AddFeature("not-rom-name", notItemNameListInput); update.AddFeature("rom-type", itemTypeListInput); update.AddFeature("not-type", notItemTypeListInput); update.AddFeature("greater", greaterStringInput); update.AddFeature("less", lessStringInput); update.AddFeature("equal", equalStringInput); update.AddFeature("crc", crcListInput); update.AddFeature("not-crc", notCrcListInput); update.AddFeature("md5", md5ListInput); update.AddFeature("not-md5", notMd5ListInput); update.AddFeature("sha1", sha1ListInput); update.AddFeature("not-sha1", notSha1ListInput); update.AddFeature("sha256", sha256ListInput); update.AddFeature("not-sha256", notSha256ListInput); update.AddFeature("sha384", sha384ListInput); update.AddFeature("not-sha384", notSha384ListInput); update.AddFeature("sha512", sha512ListInput); update.AddFeature("not-sha512", notSha512ListInput); update.AddFeature("status", statusListInput); update.AddFeature("not-status", notStatusListInput); update.AddFeature("game-type", gameTypeListInput); update.AddFeature("not-game-type", notGameTypeListInput); update.AddFeature("runnable", runnableFlag); update.AddFeature("not-runnable", notRunnableFlag); update.AddFeature("output-dir", outputDirStringInput); update.AddFeature("inplace", inplaceFlag); update.AddFeature("threads", threadsInt32Input); #endregion #region Verify Feature verify = new Feature( new List() { "-ve", "--verify" }, "Verify a folder against DATs", FeatureType.Flag, null); verify.AddFeature("dat", datListInput); verify.AddFeature("depot", depotFlag); verify.AddFeature("temp", tempFeature); verify.AddFeature("hash-only", hashOnlyFlag); verify.AddFeature("quick", quickFlag); verify.AddFeature("header", headerStringInput); verify.AddFeature("chds-as-files", chdsAsFilesFlag); verify.AddFeature("dat-merged", datMergedFlag); verify.AddFeature("dat-split", datSplitFlag); verify.AddFeature("dat-device-non-merged", datDeviceNonMergedFlag); verify.AddFeature("dat-non-merged", datNonMergedFlag); verify.AddFeature("dat-full-non-merged", datFullNonMergedFlag); #endregion // Now, add all of the main features to the Help object help.Add("Help", helpFeature); help.Add("Script", script); help.Add("DATFromDir", datFromDir); help.Add("Extract", extract); help.Add("Restore", restore); help.Add("Sort", sort); help.Add("Split", split); help.Add("Stats", stats); help.Add("Update", update); help.Add("Verify", verify); return help; } } }