n      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  NoneCV z"Any value, with a Data dictionary.       None%0 !"#None1CV% [This type represents an annotated value. The type of the underlying value is not specified. Construct a field, fieldname := value. Add annotations to a field. )The result of capturing some annotations.Many values collapsed ( or )#An annotation attached to a value ( or )A value (just a value, or )A missing field (a $ exception, or missing from )!A constructor (a constructor, or )"Return the value inside a capture.KRemove all Missing values by using any previous instances as default values#Collapse multiple values in to one.hCapture a value. Note that if the value is evaluated more than once the result may be different, i.e. capture x /= capture xAdd an annotation to a value.&It is recommended that anyone making use of this function redefine it with a more restrictive type signature to control the type of the annotation (the second argument). Any redefinitions of this function should add an INLINE pragma, to reduce the chance of incorrect optimisations.Add an annotation to a value.)Collapse many annotated values in to one.#Lift a pure value to an annotation.Create a constructor/record. The first argument should be the type of field, the second should be a list of fields constructed originally defined by := or :=+.sThis operation is not type safe, and may raise an exception at runtime if any field has the wrong type or label.0Capture the annotations from an annotated value.    %&  '()*  322Safe(!Class for default values."!Provide a default value, such as (), False, 0, [], Nothing.!"!"<;:9876543210/.-,+*)('&%$#!" Safe"#/u=Expand @: directives in a list of arguments, usually obtained from getArgs#. As an example, given the file test.txt with the lines hello and world: 7expandArgsAt ["@test.txt","!"] == ["hello","world","!"]Any @k directives in the files will be recursively expanded (raising an error if there is infinite recursion). To supress @ expansion, pass any @ arguments after --.= Safe"#5n>Given a sequence of arguments, join them together in a manner that could be used on the command line, giving preference to the Windows cmd shell quoting conventions.vFor an alternative version, intended for actual running the result in a shell, see "System.Process.showCommandForUser"?CGiven a string, split into the available arguments. The inverse of >.>?+,-.Safevt5@>Like functor, but where the the argument isn't just covariant.AConvert between two values.B0An unnamed argument. Anything not starting with -* is considered an argument, apart from "-"( which is considered to be the argument "-"!, and any arguments following "--". For example: 7programname arg1 -j - --foo arg3 -- -arg4 --arg5=1 arg6Would have the arguments: -["arg1","-","arg3","-arg4","--arg5=1","arg6"]D!A way of processing the argument.E4The type of data for the argument, i.e. FILE/DIR/EXTFWIs at least one of these arguments required, the command line will fail if none are setGAA flag, consisting of a list of flag names and other information.IThe names for the flag.J%Information about a flag's arguments.KThe way of processing a flag.L9The type of data for the flag argument, i.e. FILE/DIR/EXTM+The help message associated with this flag.NRA function to take a string, and a value, and either produce an error message (Left), or a modified value (Right).OThe O type has the following meaning:  FlagReq FlagOpt FlagOptRare/FlagNone -xfoo -x=foo -x=foo -x -foo -x foo -x=foo -x foo -x foo -x=foo -x=foo -x=foo -x=foo --xx foo --xx=foo --xx foo --xx foo --xx=foo --xx=foo --xx=foo --xx=fooPRequired argumentQOptional argumentR5Optional argument that requires an = before the valueS No argumentTA mode. Do not use the T& constructor directly, instead use r to construct the T? and then record updates. Each mode has three main features:A list of submodes (V)A list of flags (_) Optionally an unnamed argument (^)7To produce the help information for a mode, either use helpText or /.VThe available sub-modesWZThe names assigned to this mode (for the root mode, this name is used as the program name)XValue to start withYICheck the value reprsented by a mode is correct, after applying all flagsZ3Given a value, try to generate the input arguments.[Expand @ arguments with  expandArgsAt, defaults to 0, only applied if using an 1' processing function. Only the root Ts value will be used.\ Help text]+A longer help suffix displayed after a mode^`The unnamed arguments, a series of arguments, followed optionally by one for all remaining slots_Groups of flags`A group of items (modes or flags). The items are treated as a list, but the group structure is used when displaying the help message.b Normal items.c:Items that are hidden (not displayed in the help message).dEItems that have been grouped, along with a description of each group.eThe type of a flag, i.e. --foo=TYPE.f6A help message that goes with either a flag or a mode.g#A name, either the name of a flag (--foo) or the name of a mode.h8Parse a boolean, accepts as True: true yes on enabled 1.iConvert a group into a list.j3Convert a list into a group, placing all fields in b.kExtract the modes from a TlExtract the flags from a Tm Extract the value from inside a Q or R, or raises an error.n!Check that a mode is well formed.oRestricted version of A! where the values are isomorphic.p Version of A for the N type alias.q%Create an empty mode specifying only XE. All other fields will usually be populated using record updates.rrCreate a mode with a name, an initial value, some help text, a way of processing arguments and a list of flags.sbCreate a list of modes, with a program name, an initial value, some help text and the child modes.tlCreate a flag taking no argument value, with a list of flag names, an update function and some help text.uCreate a flag taking an optional argument value, with an optional value, a list of flag names, an update function, the type of the argument and some help text.vCreate a flag taking a required argument value, with a list of flag names, an update function, the type of the argument and some help text.wNCreate an argument flag, with an update function and the type of the argument.xXCreate a boolean flag, with a list of flag names, an update function and some help text.A Embed a value/Extract the mode and give a way of re-embedding9@ABCFEDGHMLKJINOSRQPTU_^]\[YXWVZ`adcbefghijklmnopqrstuvwx@ABCDEFGHIJKLMOPQRST UVWXYZ[\]^_`abcdSafe"#{[y/Process a list of flags (usually obtained from getArgs/ expandArgsAt) with a mode. Returns Left= and an error message if the command line fails to parse, or Right and the associated value.y23456789:;Safez.How to complete a command line option. The <5 instance is suitable for parsing from shell scripts.{Complete to a particular value| Complete to a prefix, and a file}%Complete to a prefix, and a directory~ZGiven a current state, return the set of commands you could type now, in preference order.=AGiven a mode and some arguments, try and drill down into the mode>RFollow args deals with all seen arguments, then calls on to deal with the next one~+Mode specifying which arguments are allowed$Arguments the user has already typedV0-based index of the argument they are currently on, and the position in that argumentz{|}~?@z{|}None"#;=A3Never generated, only used for reading in bad cases9Unknown value, representing the values stored within the Tc structure. While the values are not observable, they behave identically to the original values. Run a remote command line entry..Receive information about the mode to display.eSend a reply with either an error, or a list of flags to use. This function exits the helper program.[Send a comment which will be displayed on the calling console, mainly useful for debugging.!Name of the command to run, e.g.  echo argument, cmdargs-browserMode to run remotely@Initial set of command line flags (not supported by all helpers)2Either an error message, or a list of flags to useBCDEFGHIJKLMNAOPQRSTSafe1DThe general type of annotations that can be associated with a value.UVWXYZ[\]^_`abcdefcfdeba`_^]\[ZYXWVUSafeЂLFlag: "I want users to be able to omit the value associated with this flag."&Make the value of a flag optional. If --flag$ is given, it will be treated as --flag= this_argument. @{hello = def &= opt "foo"} -h --hello[=VALUE] (default=foo)rNote that all flags in CmdArgs are optional, and if omitted will use their default value. Those annotated with optQ also allow the flag to be present without an associated value. As an example: %{hello = "DEFAULT" &= opt "OPTIONAL"} e$ main {hello = "DEFAULT"} $ main --hello {hello = "OPTIONAL"} $ main --hello=VALUE {hello = "VALUE"}?Flag: "For this flag, users need to give something of type ..."qThe the type of a flag's value, usually upper case. Only used for the help message. Commonly the type will be FILE () or DIR (). 3{hello = def &= typ "MESSAGE"} -h --hello=MESSAGE5Flag: "Users must give a file for this flag's value." Alias for  FILE.:Flag: "Users must give a directory for this flag's value." Alias for  DIR.$Flag/Mode: "The help message is ...")Descriptive text used in the help output. I{hello = def &= help "Help message"} -h --hello=VALUE Help message*Flag: "Use this flag name for this field."$Add flags which trigger this option. 4{hello = def &= name "foo"} -h --hello --foo=VALUE$Flag: "Put non-flag arguments here."#All argument flags not captured by  are returned by . {hello = def &= args}+Flag: "Put the nth non-flag argument here."OThis field should be used to store a particular argument position (0-based). {hello = def &= argPos 0}DFlag/Mode: "Give these flags/modes a group name in the help output."HThis mode will be used for all following modes/flags, until the next  groupname. A{hello = def &= groupname "Welcomes"} Welcomes -h --hello=VALUE0Mode: "A longer description of this mode is ..."'Suffix to be added to the help message. ESample{..} &= details ["More details on the website www.example.org"]1Modes: "My program name/version/copyright is ..."=One line summary of the entire program, the first line of --help and the only line of  --versionI. If the string contains a version number component will also provide --numeric-version. <Sample{..} &= summary "CmdArgs v0.0, (C) Neil Mitchell 1981"6Mode: "If the user doesn't give a mode, use this one."This mode is the default. If no mode is specified and a mode has this attribute then that mode is selected, otherwise an error is raised. /modes [Mode1{..}, Mode2{..} &= auto, Mode3{..}]+Modes: "My program executable is named ..."oThis is the name of the program executable. Only used in the help message. Defaults to the type of the mode. Sample{..} &= program "sample"-Flag: "Don't guess any names for this field."^A field should not have any flag names guessed for it. All flag names must be specified by flag. 5{hello = def &= explicit &= name "foo"} --foo=VALUE:Flag/Mode: "Ignore this field, don't let the user set it."-A mode or field is not dealt with by CmdArgs. 4{hello = def, extra = def &= ignore} --hello=VALUE*Modes: "My program needs verbosity flags."Add  --verbose and --quiet flags.%Modes: "Customise the help argument.".Add extra options to a help argument, such as , ,  or . *Sample{..} &= helpArg [explicit, name "h"](Modes: "Customise the version argument."1Add extra options to a version argument, such as , , ,  or . !Sample{..} &= versionArg [ignore]+Modes: "Customise the verbosity arguments.",Add extra options to a verbosity arguments ( --verbose and --quiet), such as , ,  or C. The verbose options come first, followed by the quiet options. >Sample{..} &= verbosityArgs [ignore] [name "silent", explicit] Program: "Turn off @ expansion."Usually arguments starting with @ are treated as a file containing a set of arguments. This annotation turns off that behaviour. Sample{..} &= noAtExpandSafe݁8The data type representing some text, typically used as [Text]$. The formatting is described by:K values represent a paragraph of text, and may be wrapped depending on the  . If a F value is wrapped then all leading space will be treated as an indent.. values represent columns of text. Within any [Text] all columns of the same length are grouped in tabs, with the final column being wrapped if necessary. All columns are placed adjacent with no space between them - for this reason most columns will start with a space.How to output the text.Display as HTML.0Display as text wrapped at a certain width (see ).-Wrap with the default width of 80 characters.*Show some text using the given formatting.g:Split the text into strips of no-more than the given widthSafe &Specify the format to output the help.Equivalent to * if there is not too much text, otherwise .Display only the first mode.Display all modes.Bash completion informationZ shell completion informationkGenerate a help message from a mode. The first argument is a prefix, which is prepended when not using  or .hHelp text for all modes S<program> [OPTIONS] <file_args> <options> <program> MODE [SUBMODE] [OPTIONS] [FLAG]iHelp text for only this mode J<program> [OPTIONS] <file_args> <options> <program> MODE [FLAGS] <options>None1- The verbosity data type1Only output essential messages (typically errors)6Output normal messages (typically errors and warnings)GOutput lots of messages (typically errors, warnings and status updates)Set the global verbosity.$Get the global verbosity. Initially Normal before any calls to .:Used to test if warnings should be output to the user. True if the verbosity is set to  or  (when --quiet is not specified).@Used to test if status updates should be output to the user. True if the verbosity is set to  (when  --verbose is specified).DAn action to perform if the verbosity is normal or higher, based on .8An action to perform if the verbosity is loud, based on . None1j+The number of arguments that have been seen5A structure to store the additional data relating to --help,  --version, --quiet and  --verbose.#The underlying value being wrapped.Just if --helpQ is given, then gives the help message for display, including a trailing newline.Just if  --versionT is given, then gives the version message for display, including a trailing newline.Just if --quiet or  --verbose+ is given, then gives the verbosity to use.2Private: Only exported due to Haddock limitations. klmnopkjNoneVProcess the flags obtained by q and = with a mode. Displays an error and exits with failure if the command line fails to parse, or returns the associated value. Implemented in terms of yD. This function makes use of the following environment variables:$CMDARGS_COMPLETE3 - causes the program to produce completions using ~7, then exit. Completions are based on the result of q5, the index of the current argument is taken from $CMDARGS_COMPLETE (set it to -U to complete the last argument), and the index within that argument is taken from $CMDARGS_COMPLETE_POS (if set).$CMDARGS_HELPER/$CMDARGS_HELPER_PROGS - uses the helper mechanism for entering command line programs as described in System.Console.CmdArgs.Helper./Process a list of flags (usually obtained from q and =) with a mode. Throws an error if the command line fails to parse, or returns the associated value. Implemeneted in terms of y^. This function does not take account of any environment variables that may be set (see ).If you are in 1; you will probably get a better user experience by calling .Like 7 but on failure prints to stderr and exits the program. Create a help flag triggered by -?/--help. Create a help flag triggered by -?/--helpK. The user may optionally modify help by specifying the format, such as: --help=all - help for all modes --help=html - help in HTML format --help=100 - wrap the text at 100 characters --help=100,one - full text wrapped at 100 characters#Create a version flag triggered by -V/ --version.#Create a version flag triggered by --numeric-version.$Create verbosity flags triggered by -v/ --verbose and -q/--quietQ=>?@ABCDEFGHIJKLMNOPQRSTUZVWXY[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Qygfeh`abcdijTUVWXYZ[\]^_klOPQRSmNGHIJKLMBCDEFn@Aopqrstuvwx=?>z{|}~NonerstuvwxyrstuvwxNonez*Find numbers starting after space/comma, v,{|}~{|} ~ None"#NNone"#"A mode devoid of all it's contents)A mode whose help hides all it's contentsNone"#PD XTake impurely annotated records and run the corresponding command line. Shortcut for  . .To use + with custom command line arguments see .VTake purely annotated records and run the corresponding command line. Shortcut for  . .To use + with custom command line arguments see .6Take impurely annotated records and turn them in to a T$ value, that can make use of the System.Console.CmdArgs.Explicit functions (i.e. process).Annotated records are impure, and will only contain annotations on their first use. The result of this function is pure, and can be reused.4Take purely annotated records and turn them in to a T$ value, that can make use of the System.Console.CmdArgs.Explicit functions (i.e. process).eRun a Mode structure. This function reads the command line arguments and then performs as follows:PIf invalid arguments are given, it will display the error message and exit.If --help5 is given, it will display the help message and exit.If  --version0 is given, it will display the version and exit.;In all other circumstances the program will return a value.Additionally, if either --quiet or  --verbose is given (see &) it will set the verbosity (see ).,Perform the necessary actions dictated by a  structure.If  is Just,, it will display the help message and exit.If  is Just', it will display the version and exit.2In all other circumstances it will return a value.Additionally, if  is Just (see &) it will set the verbosity (see ).Produce command line arguments that would generate the given value. This function is useful for taking a value resulting from a command line, modifying it (perhaps changing the value of a flag) and generating fresh command line arguments. forall mode values constructed by cmdArgsMode/cmdArgsMode: forall args which successfully parse with mode let x = processValue mode args processValue mode (cmdArgsReform mode $ fromRight x) == xCModes: "I want a program with multiple modes, like darcs or cabal."Takes a list of modes, and creates a mode which includes them all. If you want one of the modes to be chosen by default, see . Tdata Modes = Mode1 | Mode2 | Mode3 deriving Data cmdArgs $ modes [Mode1,Mode2,Mode3]QFlag: "I want several different flags to set this one field to different values."This annotation takes a type which is an enumeration, and provides multiple separate flags to set the field to each value. The first element in the list is used as the value of the field. data State = On | Off deriving Data data Mode = Mode {state :: State} cmdArgs $ Mode {state = enum [On &= help "Turn on",Off &= help "Turn off"]} --on Turn on --off Turn offCThis annotation can be used to allow multiple flags within a field: data Mode = Mode {state :: [State]} cmdArgs $ Mode {state = enum [[] &= ignore, [On] &= help "Turn on", [Off] &= help "Turn off"]}Now  --on --off would produce  Mode [On,Off].Add an annotation to a value. Note that if the value is evaluated more than once the annotation will only be available the first time.Like !, but using the pure annotations.Like !, but using the pure annotations.; !"T/ T NoneD]  Version of  without a ! context, only to be used within . Version of  without a ! context, only to be used within . Version of  without a ! context, only to be used within . Version of  without a ! context, only to be used within . Version of  without a ! context, only to be used within .0Quotation function to turn an impure version of System.Console.CmdArgs.Implicit% into a pure one. For details see System.Console.CmdArgs.Quote.Apply the rewrite rules[Move from the old names to the new names, sufficient for where that is the full translation>Simplify the syntax tree - things like application of a lambdaYEvaluate through all locally defined functions and let expressions, at most once per defnNone^O; !"TNonen.What to do with options following non-options.Changes: Only  is allowed, both  RequireOrder and  ReturnInOrder have been removed.Return a string describing the usage of a command, derived from the header (first argument) and the options described by the second argument.sProcess the command-line, and return the list of values that matched (and those that didn't). The arguments are:The order requirements (see )The option descriptions (see )<The actual command line arguments (presumably got from ).m returns a triple consisting of the option arguments, a list of non-options, and a list of error messages.Changes:y The list of errors will contain at most one entry, and if an error is present then the other two lists will be empty.Changes: This is exactly the same as J, but the 3rd element of the tuple (second last) will be an empty list.@Given a help text and a list of option descriptions, generate a T.   !"#"$"%"&"'"( ) )*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ ] ^ _`abbcdeffghijklmnopqrrstuvwxyz{|}}~/7                             ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;<=>>?@AB C D E FGHIJKIJLMNOPQQRSTGUVWXYZ[\]^^_2`abcde00ffghijklmnopqrstuvwxyz{{|}~    &cmdargs-0.10.20-3DzlSKAwyH03LL6CI1b6gcSystem.Console.CmdArgs.ImplicitSystem.Console.CmdArgs.GetOptSystem.Console.CmdArgs.AnnotateSystem.Console.CmdArgs.DefaultSystem.Console.CmdArgs.ExplicitSystem.Console.CmdArgs.HelperSystem.Console.CmdArgs.Text System.Console.CmdArgs.VerbositySystem.Console.CmdArgs.QuoteData.Generics.AnyData.Generics.Any.Prelude,System.Console.CmdArgs.Explicit.ExpandArgsAt)System.Console.CmdArgs.Explicit.SplitJoin$System.Console.CmdArgs.Explicit.Type'System.Console.CmdArgs.Explicit.Process(System.Console.CmdArgs.Explicit.Complete#System.Console.CmdArgs.Implicit.Ann"System.Console.CmdArgs.Implicit.UI$System.Console.CmdArgs.Explicit.Help$System.Console.CmdArgs.Implicit.Type&System.Console.CmdArgs.Implicit.Reader%System.Console.CmdArgs.Implicit.Local&System.Console.CmdArgs.Implicit.Reform&System.Console.CmdArgs.Implicit.GlobalSystem.EnvironmentwithArgsSystem.Console.CmdArgsgetArgsbase Data.DataDataData.Typeable.InternalTypeableSystem.Console.GetOptOptionOptDescrOptArgReqArgNoArgArgDescrAnyAnnotate:=:=+CaptureManyAnnValueMissingCtor fromCapturedefaultMissingmanycapture&=+=many_atomrecordcapture_$fFunctorCapture$fExceptionExceptionInt $fShowCapture$fShowExceptionIntDefaultdef$fDefault(,,,,,,,,,)$fDefault(,,,,,,,,)$fDefault(,,,,,,,)$fDefault(,,,,,,)$fDefault(,,,,,)$fDefault(,,,,)$fDefault(,,,) $fDefault(,,) $fDefault(,)$fDefaultWord64$fDefaultWord32$fDefaultWord16$fDefaultWord8 $fDefaultWord$fDefaultInt64$fDefaultInt32$fDefaultInt16 $fDefaultInt8$fDefaultMaybe $fDefault[]$fDefaultDouble$fDefaultFloat$fDefaultInteger $fDefaultInt $fDefaultBool $fDefault() expandArgsAtjoinArgs splitArgsRemapremapArgargValueargType argRequireFlag flagNamesflagInfo flagValueflagTypeflagHelpUpdateFlagInfoFlagReqFlagOpt FlagOptRareFlagNoneModemodeGroupModes modeNames modeValue modeCheck modeReform modeExpandAtmodeHelpmodeHelpSuffixmodeArgsmodeGroupFlagsGroup groupUnnamed groupHidden groupNamedFlagHelpHelpName parseBool fromGrouptoGroup modeModes modeFlags fromFlagOpt checkModeremap2 remapUpdate modeEmptymodemodesflagNoneflagOptflagReqflagArgflagBoolprocessComplete CompleteValue CompleteFile CompleteDircompleteUnknownexecutereceivereplycomment $fReadNoShow $fShowNoShow$fPackerFlagInfo $fPackerArg $fPackerFlag $fPackerMode $fPackerGroup $fPackerBool$fPackerEither $fPackerMaybe $fPacker(,) $fPackerInt $fPackerChar $fPackerValue $fPacker(->) $fPacker[] $fShowPack $fReadPackopttyptypFiletypDirhelpnameargsargPos groupnamedetailssummaryautoprogramexplicitignore verbosityhelpArg versionArg verbosityArgs noAtExpandTextLineCols TextFormatHTMLWrap defaultWrapshowText$fDefaultTextFormat $fShowText$fReadTextFormat$fShowTextFormat$fEqTextFormat$fOrdTextFormat HelpFormatHelpFormatDefault HelpFormatOne HelpFormatAllHelpFormatBash HelpFormatZshhelpText VerbosityQuietNormalLoud setVerbosity getVerbosityisNormalisLoud whenNormalwhenLoud $fEqVerbosity$fOrdVerbosity$fBoundedVerbosity$fEnumVerbosity$fShowVerbosity$fReadVerbosity$fDataVerbosityCmdArgs cmdArgsValue cmdArgsHelpcmdArgsVersioncmdArgsVerbositycmdArgsPrivate processArgs processValueprocessValueIOflagHelpSimpleflagHelpFormat flagVersionflagNumericVersionflagsVerbositycmdArgscmdArgs_ cmdArgsMode cmdArgsMode_ cmdArgsRun cmdArgsApplyenumenum_modes_&=#modes# cmdArgsMode#cmdArgs#enum# cmdArgsQuoteArgOrderPermute usageInfogetOptgetOpt'convert$fFunctorArgOrderAnyT FieldNameCtorName readTupleTypetry1fromAnycasttoConstrtypeOf dataTypeOf isAlgType typeShell typeShellFulltypeNamectorfieldschildrencompose0 recomposectors decomposearitycomposegetFieldsetFieldheadtailconsunconsnulljust_nil_list_appendreverseisStringisListisMaybeisTuplefromList fromMaybe fromTupleunittupleControl.Exception.Base RecConError ExceptionIntAAnnAManyAAtomACtorStateInitNormQuotGHC.Showshowghc-prim GHC.TypesTrueIO LookupNameNotFound AmbiguousFoundSval argsCounterrsShow followModes followArgs completeBash completeZshNonePackerpackunpackNoShowPackListCharIntFuncFuncIdStringIOMap fromUnknownProgNoAtExpandProgVerbosityArgsProgVersionArg ProgHelpArg ProgVerbosity ProgProgram ProgSummaryModeHelpSuffix ModeDefaultFlagType FlagArgPosFlagArgs FlagOptional GroupNameExplicitIgnorewrap helpTextAll helpTextOneCmdArgsPrivatecmdArgsHasValueembedreembed incArgsSeen getArgsSeenReader readerHelp readerBool readerParts readerFixup readerReadreader parseVersionFixupFlag_Arg_ flagFieldflagFlag flagExplicit flagGroupflagEnum flagFixupflagArg_ flagArgPos flagArgOptMode_ modeFlags_modeMode modeDefault modeGroup modeExplicitBuiltin_builtinSummary builtinNamesbuiltinExplicit builtinHelp builtinGroupProg_ progModes progSummary progProgramprogHelpprogVerbosityArgs progHelpArgprogVersionArgprogNoAtExpandprogHelpOutputprogVersionOutputprogNumericVersionOutputisFlag_errlocalreform emptyModezeroModeglobalNameshavewant_cmdArgsReform translaterenamesimplifyinline