{
    "mode": "info",
    "parameter": "grep",
    "section": "",
    "url": "https://www.chedong.com/phpMan.php/info/grep/json",
    "generated": "2026-11-11T06:00:27Z",
    "sections": {
        "File: grep.info,  Node: Top,  Next: Introduction,  Up: (dir)": {
            "content": "",
            "subsections": []
        },
        "grep": {
            "content": "'grep' prints lines that contain a match for one or more patterns.\n\nThis manual is for version 3.11 of GNU Grep.\n\nThis manual is for 'grep', a pattern matching engine.\n\nCopyright (C) 1999-2002, 2005, 2008-2023 Free Software Foundation, Inc.\n\nPermission is granted to copy, distribute and/or modify this\ndocument under the terms of the GNU Free Documentation License,\nVersion 1.3 or any later version published by the Free Software\nFoundation; with no Invariant Sections, with no Front-Cover Texts,\nand with no Back-Cover Texts.  A copy of the license is included in\nthe section entitled \"GNU Free Documentation License\".\n\n* Menu:\n\n* Introduction::                Introduction.\n* Invoking::                    Command-line options, environment, exit status.\n* Regular Expressions::         Regular Expressions.\n* Usage::                       Examples.\n* Performance::                 Performance tuning.\n* Reporting Bugs::              Reporting Bugs.\n* Copying::                     License terms for this manual.\n* Index::                       Combined index.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Introduction,  Next: Invoking,  Prev: Top,  Up: Top": {
            "content": "",
            "subsections": []
        },
        "1 Introduction": {
            "content": "",
            "subsections": []
        },
        "Given one or more patterns, 'grep' searches input files for matches to": {
            "content": "the patterns.  When it finds a match in a line, it copies the line to\nstandard output (by default), or produces whatever other sort of output\nyou have requested with options.\n\nThough 'grep' expects to do the matching on text, it has no limits on\ninput line length other than available memory, and it can match\narbitrary characters within a line.  If the final byte of an input file\nis not a newline, 'grep' silently supplies one.  Since newline is also a\nseparator for the list of patterns, there is no way to match newline\ncharacters in a text.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Invoking,  Next: Regular Expressions,  Prev: Introduction,  Up: Top": {
            "content": "",
            "subsections": []
        },
        "2 Invoking 'grep'": {
            "content": "",
            "subsections": []
        },
        "The general synopsis of the 'grep' command line is": {
            "content": "grep [OPTION...] [PATTERNS] [FILE...]\n",
            "subsections": []
        },
        "There can be zero or more OPTION arguments, and zero or more FILE": {
            "content": "arguments.  The PATTERNS argument contains one or more patterns\nseparated by newlines, and is omitted when patterns are given via the\n'-e PATTERNS' or '-f FILE' options.  Typically PATTERNS should be quoted\nwhen 'grep' is used in a shell command.\n\n* Menu:\n\n* Command-line Options::        Short and long names, grouped by category.\n* Environment Variables::       POSIX, GNU generic, and GNU grep specific.\n* Exit Status::                 Exit status returned by 'grep'.\n* grep Programs::               'grep' programs.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Command-line Options,  Next: Environment Variables,  Up: Invoking": {
            "content": "",
            "subsections": [
                {
                    "name": "2.1 Command-line Options",
                    "content": "'grep' comes with a rich set of options: some from POSIX and some being\nGNU extensions.  Long option names are always a GNU extension, even for\noptions that are from POSIX specifications.  Options that are specified\nby POSIX, under their short names, are explicitly marked as such to\nfacilitate POSIX-portable programming.  A few option names are provided\nfor compatibility with older or more exotic implementations.\n\n* Menu:\n\n* Generic Program Information::\n* Matching Control::\n* General Output Control::\n* Output Line Prefix Control::\n* Context Line Control::\n* File and Directory Selection::\n* Other Options::\n\nSeveral additional options control which variant of the 'grep'\nmatching engine is used.  *Note grep Programs::.\n"
                }
            ]
        },
        "File: grep.info,  Node: Generic Program Information,  Next: Matching Control,  Up: Command-line Options": {
            "content": "'--help'\nPrint a usage message briefly summarizing the command-line options\nand the bug-reporting address, then exit.\n\n'-V'\n'--version'\nPrint the version number of 'grep' to the standard output stream.\nThis version number should be included in all bug reports.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Matching Control,  Next: General Output Control,  Prev: Generic Program Information,  Up: Command-line Options": {
            "content": "'-e PATTERNS'\n'--regexp=PATTERNS'\nUse PATTERNS as one or more patterns; newlines within PATTERNS\nseparate each pattern from the next.  If this option is used\nmultiple times or is combined with the '-f' ('--file') option,\nsearch for all patterns given.  Typically PATTERNS should be quoted\nwhen 'grep' is used in a shell command.  ('-e' is specified by\nPOSIX.)\n\n'-f FILE'\n'--file=FILE'\nObtain patterns from FILE, one per line.  If this option is used\nmultiple times or is combined with the '-e' ('--regexp') option,\nsearch for all patterns given.  When FILE is '-', read patterns\nfrom standard input.  The empty file contains zero patterns, and\ntherefore matches nothing.  ('-f' is specified by POSIX.)\n\n'-i'\n'-y'\n'--ignore-case'\nIgnore case distinctions in patterns and input data, so that\ncharacters that differ only in case match each other.  Although\nthis is straightforward when letters differ in case only via\nlowercase-uppercase pairs, the behavior is unspecified in other\nsituations.  For example, uppercase \"S\" has an unusual lowercase\ncounterpart \"??\" (Unicode character U+017F, LATIN SMALL LETTER LONG\nS) in many locales, and it is unspecified whether this unusual\ncharacter matches \"S\" or \"s\" even though uppercasing it yields \"S\".\nAnother example: the lowercase German letter \"ss\" (U+00DF, LATIN\nSMALL LETTER SHARP S) is normally capitalized as the two-character\nstring \"SS\" but it does not match \"SS\", and it might not match the\nuppercase letter \"???\" (U+1E9E, LATIN CAPITAL LETTER SHARP S) even\nthough lowercasing the latter yields the former.\n\n'-y' is an obsolete synonym that is provided for compatibility.\n('-i' is specified by POSIX.)\n\n'--no-ignore-case'\nDo not ignore case distinctions in patterns and input data.  This\nis the default.  This option is useful for passing to shell scripts\nthat already use '-i', in order to cancel its effects because the\ntwo options override each other.\n\n'-v'\n'--invert-match'\nInvert the sense of matching, to select non-matching lines.  ('-v'\nis specified by POSIX.)\n\n'-w'\n'--word-regexp'\nSelect only those lines containing matches that form whole words.\nThe test is that the matching substring must either be at the\nbeginning of the line, or preceded by a non-word constituent\ncharacter.  Similarly, it must be either at the end of the line or\nfollowed by a non-word constituent character.  Word constituent\ncharacters are letters, digits, and the underscore.  This option\nhas no effect if '-x' is also specified.\n\nBecause the '-w' option can match a substring that does not begin\nand end with word constituents, it differs from surrounding a\nregular expression with '\\<' and '\\>'.  For example, although 'grep\n-w @' matches a line containing only '@', 'grep '\\<@\\>'' cannot\nmatch any line because '@' is not a word constituent.  *Note\nSpecial Backslash Expressions::.\n\n'-x'\n'--line-regexp'\nSelect only those matches that exactly match the whole line.  For\nregular expression patterns, this is like parenthesizing each\npattern and then surrounding it with '^' and '$'.  ('-x' is\nspecified by POSIX.)\n",
            "subsections": []
        },
        "File: grep.info,  Node: General Output Control,  Next: Output Line Prefix Control,  Prev: Matching Control,  Up: Command-line Options": {
            "content": "'-c'\n'--count'\nSuppress normal output; instead print a count of matching lines for\neach input file.  With the '-v' ('--invert-match') option, count\nnon-matching lines.  ('-c' is specified by POSIX.)\n\n'--color[=WHEN]'\n'--colour[=WHEN]'\nSurround matched non-empty strings, matching lines, context lines,\nfile names, line numbers, byte offsets, and separators (for fields\nand groups of context lines) with escape sequences to display them\nin color on the terminal.  The colors are defined by the\nenvironment variable 'GREPCOLORS' and default to\n'ms=01;31:mc=01;31:sl=:cx=:fn=35:ln=32:bn=32:se=36' for bold red\nmatched text, magenta file names, green line numbers, green byte\noffsets, cyan separators, and default terminal colors otherwise.\n*Note Environment Variables::.\n\nWHEN is 'always' to use colors, 'never' to not use colors, or\n'auto' to use colors if standard output is associated with a\nterminal device and the 'TERM' environment variable's value\nsuggests that the terminal supports colors.  Plain '--color' is\ntreated like '--color=auto'; if no '--color' option is given, the\ndefault is '--color=never'.\n\n'-L'\n'--files-without-match'\nSuppress normal output; instead print the name of each input file\nfrom which no output would normally have been printed.\n\n'-l'\n'--files-with-matches'\nSuppress normal output; instead print the name of each input file\nfrom which output would normally have been printed.  Scanning each\ninput file stops upon first match.  ('-l' is specified by POSIX.)\n\n'-m NUM'\n'--max-count=NUM'\nStop after the first NUM selected lines.  If NUM is zero, 'grep'\nstops right away without reading input.  A NUM of -1 is treated as\ninfinity and 'grep' does not stop; this is the default.\n\nIf the input is standard input from a regular file, and NUM\nselected lines are output, 'grep' ensures that the standard input\nis positioned just after the last selected line before exiting,\nregardless of the presence of trailing context lines.  This enables\na calling process to resume a search.  For example, the following\nshell script makes use of it:\n\nwhile grep -m 1 'PATTERN'\ndo\necho xxxx\ndone < FILE\n\nBut the following probably will not work because a pipe is not a\nregular file:\n\n# This probably will not work.\ncat FILE |\nwhile grep -m 1 'PATTERN'\ndo\necho xxxx\ndone\n\nWhen 'grep' stops after NUM selected lines, it outputs any trailing\ncontext lines.  When the '-c' or '--count' option is also used,\n'grep' does not output a count greater than NUM.  When the '-v' or\n'--invert-match' option is also used, 'grep' stops after outputting\nNUM non-matching lines.\n\n'-o'\n'--only-matching'\nPrint only the matched non-empty parts of matching lines, with each\nsuch part on a separate output line.  Output lines use the same\ndelimiters as input, and delimiters are null bytes if '-z'\n('--null-data') is also used (*note Other Options::).\n\n'-q'\n'--quiet'\n'--silent'\nQuiet; do not write anything to standard output.  Exit immediately\nwith zero status if any match is found, even if an error was\ndetected.  Also see the '-s' or '--no-messages' option.\nPortability note: Solaris 10 'grep' lacks '-q'; portable shell\nscripts typically can redirect standard output to '/dev/null'\ninstead of using '-q'.  ('-q' is specified by POSIX.)\n\n'-s'\n'--no-messages'\nSuppress error messages about nonexistent or unreadable files.\n('-s' is specified by POSIX.)\n",
            "subsections": []
        },
        "File: grep.info,  Node: Output Line Prefix Control,  Next: Context Line Control,  Prev: General Output Control,  Up: Command-line Options": {
            "content": "",
            "subsections": []
        },
        "When several prefix fields are to be output, the order is always file": {
            "content": "name, line number, and byte offset, regardless of the order in which\nthese options were specified.\n\n'-b'\n'--byte-offset'\nPrint the 0-based byte offset within the input file before each\nline of output.  If '-o' ('--only-matching') is specified, print\nthe offset of the matching part itself.\n\n'-H'\n'--with-filename'\nPrint the file name for each match.  This is the default when there\nis more than one file to search.\n\n'-h'\n'--no-filename'\nSuppress the prefixing of file names on output.  This is the\ndefault when there is only one file (or only standard input) to\nsearch.\n\n'--label=LABEL'\nDisplay input actually coming from standard input as input coming\nfrom file LABEL.  This can be useful for commands that transform a\nfile's contents before searching; e.g.:\n\ngzip -cd foo.gz | grep --label=foo -H 'some pattern'\n\n'-n'\n'--line-number'\nPrefix each line of output with the 1-based line number within its\ninput file.  ('-n' is specified by POSIX.)\n\n'-T'\n'--initial-tab'\nMake sure that the first character of actual line content lies on a\ntab stop, so that the alignment of tabs looks normal.  This is\nuseful with options that prefix their output to the actual content:\n'-H', '-n', and '-b'.  This may also prepend spaces to output line\nnumbers and byte offsets so that lines from a single file all start\nat the same column.\n\n'-Z'\n'--null'\nOutput a zero byte (the ASCII NUL character) instead of the\ncharacter that normally follows a file name.  For example, 'grep\n-lZ' outputs a zero byte after each file name instead of the usual\nnewline.  This option makes the output unambiguous, even in the\npresence of file names containing unusual characters like newlines.\nThis option can be used with commands like 'find -print0', 'perl\n-0', 'sort -z', and 'xargs -0' to process arbitrary file names,\neven those that contain newline characters.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Context Line Control,  Next: File and Directory Selection,  Prev: Output Line Prefix Control,  Up: Command-line Options": {
            "content": "\"Context lines\" are non-matching lines that are near a matching line.\nThey are output only if one of the following options are used.",
            "subsections": []
        },
        "Regardless of how these options are set, 'grep' never outputs any given": {
            "content": "line more than once.  If the '-o' ('--only-matching') option is\nspecified, these options have no effect and a warning is given upon\ntheir use.\n\n'-A NUM'\n'--after-context=NUM'\nPrint NUM lines of trailing context after matching lines.\n\n'-B NUM'\n'--before-context=NUM'\nPrint NUM lines of leading context before matching lines.\n\n'-C NUM'\n'-NUM'\n'--context=NUM'\nPrint NUM lines of leading and trailing output context.\n\n'--group-separator=STRING'\nWhen '-A', '-B' or '-C' are in use, print STRING instead of '--'\nbetween groups of lines.\n\n'--no-group-separator'\nWhen '-A', '-B' or '-C' are in use, do not print a separator\nbetween groups of lines.\n\nHere are some points about how 'grep' chooses the separator to print\nbetween prefix fields and line content:\n\n* Matching lines normally use ':' as a separator between prefix\nfields and actual line content.\n\n* Context (i.e., non-matching) lines use '-' instead.\n\n* When context is not specified, matching lines are simply output one\nright after another.\n\n* When context is specified, lines that are adjacent in the input\nform a group and are output one right after another, while by\ndefault a separator appears between non-adjacent groups.\n\n* The default separator is a '--' line; its presence and appearance\ncan be changed with the options above.\n\n* Each group may contain several matching lines when they are close\nenough to each other that two adjacent groups connect and can merge\ninto a single contiguous one.\n",
            "subsections": []
        },
        "File: grep.info,  Node: File and Directory Selection,  Next: Other Options,  Prev: Context Line Control,  Up: Command-line Options": {
            "content": "'-a'\n'--text'\nProcess a binary file as if it were text; this is equivalent to the\n'--binary-files=text' option.\n\n'--binary-files=TYPE'\nIf a file's data or metadata indicate that the file contains binary\ndata, assume that the file is of type TYPE.  Non-text bytes\nindicate binary data; these are either output bytes that are\nimproperly encoded for the current locale (*note Environment\nVariables::), or null input bytes when the '-z' ('--null-data')\noption is not given (*note Other Options::).\n\nBy default, TYPE is 'binary', and 'grep' suppresses output after\nnull input binary data is discovered, and suppresses output lines\nthat contain improperly encoded data.  When some output is\nsuppressed, 'grep' follows any output with a message to standard\nerror saying that a binary file matches.\n\nIf TYPE is 'without-match', when 'grep' discovers null input binary\ndata it assumes that the rest of the file does not match; this is\nequivalent to the '-I' option.\n\nIf TYPE is 'text', 'grep' processes binary data as if it were text;\nthis is equivalent to the '-a' option.\n\nWhen TYPE is 'binary', 'grep' may treat non-text bytes as line\nterminators even without the '-z' ('--null-data') option.  This\nmeans choosing 'binary' versus 'text' can affect whether a pattern\nmatches a file.  For example, when TYPE is 'binary' the pattern\n'q$' might match 'q' immediately followed by a null byte, even\nthough this is not matched when TYPE is 'text'.  Conversely, when\nTYPE is 'binary' the pattern '.' (period) might not match a null\nbyte.\n\nWarning: The '-a' ('--binary-files=text') option might output\nbinary garbage, which can have nasty side effects if the output is\na terminal and if the terminal driver interprets some of it as\ncommands.  On the other hand, when reading files whose text\nencodings are unknown, it can be helpful to use '-a' or to set\n'LCALL='C'' in the environment, in order to find more matches even\nif the matches are unsafe for direct display.\n\n'-D ACTION'\n'--devices=ACTION'\nIf an input file is a device, FIFO, or socket, use ACTION to\nprocess it.  If ACTION is 'read', all devices are read just as if\nthey were ordinary files.  If ACTION is 'skip', devices, FIFOs, and\nsockets are silently skipped.  By default, devices are read if they\nare on the command line or if the '-R' ('--dereference-recursive')\noption is used, and are skipped if they are encountered recursively\nand the '-r' ('--recursive') option is used.  This option has no\neffect on a file that is read via standard input.\n\n'-d ACTION'\n'--directories=ACTION'\nIf an input file is a directory, use ACTION to process it.  By\ndefault, ACTION is 'read', which means that directories are read\njust as if they were ordinary files (some operating systems and\nfile systems disallow this, and will cause 'grep' to print error\nmessages for every directory or silently skip them).  If ACTION is\n'skip', directories are silently skipped.  If ACTION is 'recurse',\n'grep' reads all files under each directory, recursively, following\ncommand-line symbolic links and skipping other symlinks; this is\nequivalent to the '-r' option.\n\n'--exclude=GLOB'\nSkip any command-line file with a name suffix that matches the\npattern GLOB, using wildcard matching; a name suffix is either the\nwhole name, or a trailing part that starts with a non-slash\ncharacter immediately after a slash ('/') in the name.  When\nsearching recursively, skip any subfile whose base name matches\nGLOB; the base name is the part after the last slash.  A pattern\ncan use '*', '?', and '['...']'  as wildcards, and '\\' to quote a\nwildcard or backslash character literally.\n\n'--exclude-from=FILE'\nSkip files whose name matches any of the patterns read from FILE\n(using wildcard matching as described under '--exclude').\n\n'--exclude-dir=GLOB'\nSkip any command-line directory with a name suffix that matches the\npattern GLOB.  When searching recursively, skip any subdirectory\nwhose base name matches GLOB.  Ignore any redundant trailing\nslashes in GLOB.\n\n'-I'\nProcess a binary file as if it did not contain matching data; this\nis equivalent to the '--binary-files=without-match' option.\n\n'--include=GLOB'\nSearch only files whose name matches GLOB, using wildcard matching\nas described under '--exclude'.  If contradictory '--include' and\n'--exclude' options are given, the last matching one wins.  If no\n'--include' or '--exclude' options match, a file is included unless\nthe first such option is '--include'.\n\n'-r'\n'--recursive'\nFor each directory operand, read and process all files in that\ndirectory, recursively.  Follow symbolic links on the command line,\nbut skip symlinks that are encountered recursively.  Note that if\nno file operand is given, grep searches the working directory.\nThis is the same as the '--directories=recurse' option.\n\n'-R'\n'--dereference-recursive'\nFor each directory operand, read and process all files in that\ndirectory, recursively, following all symbolic links.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Other Options,  Prev: File and Directory Selection,  Up: Command-line Options": {
            "content": "'--'\nDelimit the option list.  Later arguments, if any, are treated as\noperands even if they begin with '-'.  For example, 'grep PAT --\n-file1 file2' searches for the pattern PAT in the files named\n'-file1' and 'file2'.\n\n'--line-buffered'\nUse line buffering for standard output, regardless of output\ndevice.  By default, standard output is line buffered for\ninteractive devices, and is fully buffered otherwise.  With full\nbuffering, the output buffer is flushed when full; with line\nbuffering, the buffer is also flushed after every output line.  The\nbuffer size is system dependent.\n\n'-U'\n'--binary'\nOn platforms that distinguish between text and binary I/O, use the\nlatter when reading and writing files other than the user's\nterminal, so that all input bytes are read and written as-is.  This\noverrides the default behavior where 'grep' follows the operating\nsystem's advice whether to use text or binary I/O.  On MS-Windows\nwhen 'grep' uses text I/O it reads a carriage return-newline pair\nas a newline and a Control-Z as end-of-file, and it writes a\nnewline as a carriage return-newline pair.\n\nWhen using text I/O '--byte-offset' ('-b') counts and\n'--binary-files' heuristics apply to input data after text-I/O\nprocessing.  Also, the '--binary-files' heuristics need not agree\nwith the '--binary' option; that is, they may treat the data as\ntext even if '--binary' is given, or vice versa.  *Note File and\nDirectory Selection::.\n\nThis option has no effect on GNU and other POSIX-compatible\nplatforms, which do not distinguish text from binary I/O.\n\n'-z'\n'--null-data'\nTreat input and output data as sequences of lines, each terminated\nby a zero byte (the ASCII NUL character) instead of a newline.\nLike the '-Z' or '--null' option, this option can be used with\ncommands like 'sort -z' to process arbitrary file names.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Environment Variables,  Next: Exit Status,  Prev: Command-line Options,  Up: Invoking": {
            "content": "",
            "subsections": [
                {
                    "name": "2.2 Environment Variables",
                    "content": ""
                }
            ]
        },
        "The behavior of 'grep' is affected by several environment variables, the": {
            "content": "most important of which control the locale, which specifies how 'grep'\ninterprets characters in its patterns and data.\n\nThe locale for category 'LCFOO' is specified by examining the three\nenvironment variables 'LCALL', 'LCFOO', and 'LANG', in that order.",
            "subsections": []
        },
        "The first of these variables that is set specifies the locale.  For": {
            "content": "example, if 'LCALL' is not set, but 'LCCOLLATE' is set to\n'ptBR.UTF-8', then a Brazilian Portuguese locale is used for the\n'LCCOLLATE' category.  As a special case for 'LCMESSAGES' only, the\nenvironment variable 'LANGUAGE' can contain a colon-separated list of\nlanguages that overrides the three environment variables that ordinarily\nspecify the 'LCMESSAGES' category.  The 'C' locale is used if none of\nthese environment variables are set, if the locale catalog is not\ninstalled, or if 'grep' was not compiled with national language support\n(NLS). The shell command 'locale -a' lists locales that are currently\navailable.\n\nThe following environment variables affect the behavior of 'grep'.\n\n'GREPCOLOR'\nThis obsolescent variable interacts with 'GREPCOLORS' confusingly,\nand 'grep' warns if it is set and is not overridden by\n'GREPCOLORS'.  Instead of 'GREPCOLOR='COLOR'', you can use\n'GREPCOLORS='mt=COLOR''.\n\n'GREPCOLORS'\nThis variable controls how the '--color' option highlights output.\nIts value is a colon-separated list of 'terminfo' capabilities that\ndefaults to 'ms=01;31:mc=01;31:sl=:cx=:fn=35:ln=32:bn=32:se=36'\nwith the 'rv' and 'ne' boolean capabilities omitted (i.e., false).\nThe two-letter capability names refer to terminal \"capabilities,\"\nthe ability of a terminal to highlight text, or change its color,\nand so on.  These capabilities are stored in an online database and\naccessed by the 'terminfo' library.  Non-empty capability values\ncontrol highlighting using Select Graphic Rendition (SGR) commands\ninterpreted by the terminal or terminal emulator.  (See the section\nin the documentation of your text terminal for permitted values and\ntheir meanings as character attributes.)  These substring values\nare integers in decimal representation and can be concatenated with\nsemicolons.  'grep' takes care of assembling the result into a\ncomplete SGR sequence ('\\33['...'m').  Common values to concatenate\ninclude '1' for bold, '4' for underline, '5' for blink, '7' for\ninverse, '39' for default foreground color, '30' to '37' for\nforeground colors, '90' to '97' for 16-color mode foreground\ncolors, '38;5;0' to '38;5;255' for 88-color and 256-color modes\nforeground colors, '49' for default background color, '40' to '47'\nfor background colors, '100' to '107' for 16-color mode background\ncolors, and '48;5;0' to '48;5;255' for 88-color and 256-color modes\nbackground colors.\n\nSupported capabilities are as follows.\n\n'sl='\nSGR substring for whole selected lines (i.e., matching lines\nwhen the '-v' command-line option is omitted, or non-matching\nlines when '-v' is specified).  If however the boolean 'rv'\ncapability and the '-v' command-line option are both\nspecified, it applies to context matching lines instead.  The\ndefault is empty (i.e., the terminal's default color pair).\n\n'cx='\nSGR substring for whole context lines (i.e., non-matching\nlines when the '-v' command-line option is omitted, or\nmatching lines when '-v' is specified).  If however the\nboolean 'rv' capability and the '-v' command-line option are\nboth specified, it applies to selected non-matching lines\ninstead.  The default is empty (i.e., the terminal's default\ncolor pair).\n\n'rv'\nBoolean value that reverses (swaps) the meanings of the 'sl='\nand 'cx=' capabilities when the '-v' command-line option is\nspecified.  The default is false (i.e., the capability is\nomitted).\n\n'mt=01;31'\nSGR substring for matching non-empty text in any matching line\n(i.e., a selected line when the '-v' command-line option is\nomitted, or a context line when '-v' is specified).  Setting\nthis is equivalent to setting both 'ms=' and 'mc=' at once to\nthe same value.  The default is a bold red text foreground\nover the current line background.\n\n'ms=01;31'\nSGR substring for matching non-empty text in a selected line.\n(This is used only when the '-v' command-line option is\nomitted.)  The effect of the 'sl=' (or 'cx=' if 'rv')\ncapability remains active when this takes effect.  The default\nis a bold red text foreground over the current line\nbackground.\n\n'mc=01;31'\nSGR substring for matching non-empty text in a context line.\n(This is used only when the '-v' command-line option is\nspecified.)  The effect of the 'cx=' (or 'sl=' if 'rv')\ncapability remains active when this takes effect.  The default\nis a bold red text foreground over the current line\nbackground.\n\n'fn=35'\nSGR substring for file names prefixing any content line.  The\ndefault is a magenta text foreground over the terminal's\ndefault background.\n\n'ln=32'\nSGR substring for line numbers prefixing any content line.\nThe default is a green text foreground over the terminal's\ndefault background.\n\n'bn=32'\nSGR substring for byte offsets prefixing any content line.\nThe default is a green text foreground over the terminal's\ndefault background.\n\n'se=36'\nSGR substring for separators that are inserted between\nselected line fields (':'), between context line fields ('-'),\nand between groups of adjacent lines when nonzero context is\nspecified ('--').  The default is a cyan text foreground over\nthe terminal's default background.\n\n'ne'\nBoolean value that prevents clearing to the end of line using\nErase in Line (EL) to Right ('\\33[K') each time a colorized\nitem ends.  This is needed on terminals on which EL is not\nsupported.  It is otherwise useful on terminals for which the\n'backcolorerase' ('bce') boolean 'terminfo' capability does\nnot apply, when the chosen highlight colors do not affect the\nbackground, or when EL is too slow or causes too much flicker.\nThe default is false (i.e., the capability is omitted).\n\nNote that boolean capabilities have no '='...  part.  They are\nomitted (i.e., false) by default and become true when specified.\n\n'LCALL'\n'LCCOLLATE'\n'LANG'\nThese variables specify the locale for the 'LCCOLLATE' category,\nwhich might affect how range expressions like 'a-z' are\ninterpreted.\n\n'LCALL'\n'LCCTYPE'\n'LANG'\nThese variables specify the locale for the 'LCCTYPE' category,\nwhich determines the type of characters, e.g., which characters are\nwhitespace.  This category also determines the character encoding.\n*Note Character Encoding::.\n\n'LANGUAGE'\n'LCALL'\n'LCMESSAGES'\n'LANG'\nThese variables specify the locale for the 'LCMESSAGES' category,\nwhich determines the language that 'grep' uses for messages.  The\ndefault 'C' locale uses American English messages.\n\n'POSIXLYCORRECT'\nIf set, 'grep' behaves as POSIX requires; otherwise, 'grep' behaves\nmore like other GNU programs.  POSIX requires that options that\nfollow file names must be treated as file names; by default, such\noptions are permuted to the front of the operand list and are\ntreated as options.\n\n'TERM'\nThis variable specifies the output terminal type, which can affect\nwhat the '--color' option does.  *Note General Output Control::.\n\nThe 'GREPOPTIONS' environment variable of 'grep' 2.20 and earlier is\nno longer supported, as it caused problems when writing portable\nscripts.  To make arbitrary changes to how 'grep' works, you can use an\nalias or script instead.  For example, if 'grep' is in the directory\n'/usr/bin' you can prepend '$HOME/bin' to your 'PATH' and create an\nexecutable script '$HOME/bin/grep' containing the following:\n\n#! /bin/sh\nexport PATH=/usr/bin\nexec grep --color=auto --devices=skip \"$@\"\n",
            "subsections": []
        },
        "File: grep.info,  Node: Exit Status,  Next: grep Programs,  Prev: Environment Variables,  Up: Invoking": {
            "content": "",
            "subsections": [
                {
                    "name": "2.3 Exit Status",
                    "content": ""
                }
            ]
        },
        "Normally the exit status is 0 if a line is selected, 1 if no lines were": {
            "content": "selected, and 2 if an error occurred.  However, if the '-q' or '--quiet'\nor '--silent' option is used and a line is selected, the exit status is\n0 even if an error occurred.  Other 'grep' implementations may exit with\nstatus greater than 2 on error.\n",
            "subsections": []
        },
        "File: grep.info,  Node: grep Programs,  Prev: Exit Status,  Up: Invoking": {
            "content": "",
            "subsections": [
                {
                    "name": "2.4 'grep' Programs",
                    "content": "'grep' searches the named input files for lines containing a match to\nthe given patterns.  By default, 'grep' prints the matching lines.  A\nfile named '-' stands for standard input.  If no input is specified,\n'grep' searches the working directory '.' if given a command-line option\nspecifying recursion; otherwise, 'grep' searches standard input.  There\nare four major variants of 'grep', controlled by the following options.\n\n'-G'\n'--basic-regexp'\nInterpret patterns as basic regular expressions (BREs).  This is\nthe default.\n\n'-E'\n'--extended-regexp'\nInterpret patterns as extended regular expressions (EREs).  ('-E'\nis specified by POSIX.)\n\n'-F'\n'--fixed-strings'\nInterpret patterns as fixed strings, not regular expressions.\n('-F' is specified by POSIX.)\n\n'-P'\n'--perl-regexp'\nInterpret patterns as Perl-compatible regular expressions (PCREs).\nPCRE support is here to stay, but consider this option experimental\nwhen combined with the '-z' ('--null-data') option, and note that\n'grep -P' may warn of unimplemented features.  *Note Other\nOptions::.\n\nFor documentation, refer to <https://www.pcre.org/>, with these\ncaveats:\n* '\\d' matches only the ten ASCII digits (and '\\D' matches the\ncomplement), regardless of locale.  Use '\\p{Nd}' to also match\nnon-ASCII digits.  (The behavior of '\\d' and '\\D' is\nunspecified after in-regexp directives like '(?aD)'.)\n\n* Although PCRE tracks the syntax and semantics of Perl's\nregular expressions, the match is not always exact.  For\nexample, Perl evolves and a Perl installation may predate or\npostdate the PCRE2 installation on the same host, or their\nUnicode versions may differ, or Perl and PCRE2 may disagree\nabout an obscure construct.\n\n* By default, 'grep' applies each regexp to a line at a time, so\nthe '(?s)' directive (making '.' match line breaks) is\ngenerally ineffective.  However, with '-z' ('--null-data') it\ncan work:\n$ printf 'a\\nb\\n' |grep -zP '(?s)a.b'\na\nb\nBut beware: with the '-z' ('--null-data') and a file\ncontaining no NUL byte, grep must read the entire file into\nmemory before processing any of it.  Thus, it will exhaust\nmemory and fail for some large files.\n"
                }
            ]
        },
        "File: grep.info,  Node: Regular Expressions,  Next: Usage,  Prev: Invoking,  Up: Top": {
            "content": "",
            "subsections": []
        },
        "3 Regular Expressions": {
            "content": "A \"regular expression\" is a pattern that describes a set of strings.",
            "subsections": []
        },
        "Regular expressions are constructed analogously to arithmetic": {
            "content": "expressions, by using various operators to combine smaller expressions.\n'grep' understands three different versions of regular expression\nsyntax: basic (BRE), extended (ERE), and Perl-compatible (PCRE). In GNU\n'grep', basic and extended regular expressions are merely different\nnotations for the same pattern-matching functionality.  In other\nimplementations, basic regular expressions are ordinarily less powerful\nthan extended, though occasionally it is the other way around.  The\nfollowing description applies to extended regular expressions;\ndifferences for basic regular expressions are summarized afterwards.",
            "subsections": []
        },
        "Perl-compatible regular expressions have different functionality, and": {
            "content": "are documented in the pcre2syntax(3) and pcre2pattern(3) manual pages,\nbut work only if PCRE is available in the system.\n\n* Menu:\n\n* Fundamental Structure::\n* Character Classes and Bracket Expressions::\n* Special Backslash Expressions::\n* Anchoring::\n* Back-references and Subexpressions::\n* Basic vs Extended::\n* Problematic Expressions::\n* Character Encoding::\n* Matching Non-ASCII::\n",
            "subsections": []
        },
        "File: grep.info,  Node: Fundamental Structure,  Next: Character Classes and Bracket Expressions,  Up: Regular Expressions": {
            "content": "",
            "subsections": [
                {
                    "name": "3.1 Fundamental Structure",
                    "content": "In regular expressions, the characters '.?*+{|()[\\^$' are \"special\ncharacters\" and have uses described below.  All other characters are\n\"ordinary characters\", and each ordinary character is a regular\nexpression that matches itself.\n\nThe period '.' matches any single character.  It is unspecified\nwhether '.' matches an encoding error.\n\nA regular expression may be followed by one of several repetition\noperators; the operators beginning with '{' are called \"interval\nexpressions\".\n\n'?'\nThe preceding item is optional and is matched at most once.\n\n'*'\nThe preceding item is matched zero or more times.\n\n'+'\nThe preceding item is matched one or more times.\n\n'{N}'\nThe preceding item is matched exactly N times.\n\n'{N,}'\nThe preceding item is matched N or more times.\n\n'{,M}'\nThe preceding item is matched at most M times.  This is a GNU\nextension.\n\n'{N,M}'\nThe preceding item is matched at least N times, but not more than M\ntimes.\n\nThe empty regular expression matches the empty string.  Two regular\nexpressions may be concatenated; the resulting regular expression\nmatches any string formed by concatenating two substrings that\nrespectively match the concatenated expressions.\n\nTwo regular expressions may be joined by the infix operator '|'.  The\nresulting regular expression matches any string matching either of the\ntwo expressions, which are called \"alternatives\".\n\nRepetition takes precedence over concatenation, which in turn takes\nprecedence over alternation.  A whole expression may be enclosed in\nparentheses to override these precedence rules and form a subexpression.\nAn unmatched ')' matches just itself.\n\nNot every character string is a valid regular expression.  *Note\nProblematic Expressions::.\n"
                }
            ]
        },
        "File: grep.info,  Node: Character Classes and Bracket Expressions,  Next: Special Backslash Expressions,  Prev: Fundamental Structure,  Up: Regular Expressions": {
            "content": "",
            "subsections": [
                {
                    "name": "3.2 Character Classes and Bracket Expressions",
                    "content": "A \"bracket expression\" is a list of characters enclosed by '[' and ']'."
                }
            ]
        },
        "It matches any single character in that list.  If the first character of": {
            "content": "the list is the caret '^', then it matches any character *not* in the\nlist, and it is unspecified whether it matches an encoding error.  For\nexample, the regular expression '[0123456789]' matches any single digit,\nwhereas '[^()]' matches any single character that is not an opening or\nclosing parenthesis, and might or might not match an encoding error.\n\nWithin a bracket expression, a \"range expression\" consists of two\ncharacters separated by a hyphen.  It matches any single character that\nsorts between the two characters, inclusive.  In the default C locale,\nthe sorting sequence is the native character order; for example, '[a-d]'\nis equivalent to '[abcd]'.  In other locales, the sorting sequence is\nnot specified, and '[a-d]' might be equivalent to '[abcd]' or to\n'[aBbCcDd]', or it might fail to match any character, or the set of\ncharacters that it matches might be erratic, or it might be invalid.  To\nobtain the traditional interpretation of bracket expressions, you can\nuse the 'C' locale by setting the 'LCALL' environment variable to the\nvalue 'C'.\n\nFinally, certain named classes of characters are predefined within\nbracket expressions, as follows.  Their interpretation depends on the\n'LCCTYPE' locale; for example, '[[:alnum:]]' means the character class\nof numbers and letters in the current locale.\n\n'[:alnum:]'\nAlphanumeric characters: '[:alpha:]' and '[:digit:]'; in the 'C'\nlocale and ASCII character encoding, this is the same as\n'[0-9A-Za-z]'.\n\n'[:alpha:]'\nAlphabetic characters: '[:lower:]' and '[:upper:]'; in the 'C'\nlocale and ASCII character encoding, this is the same as\n'[A-Za-z]'.\n\n'[:blank:]'\nBlank characters: space and tab.\n\n'[:cntrl:]'\nControl characters.  In ASCII, these characters have octal codes\n000 through 037, and 177 (DEL). In other character sets, these are\nthe equivalent characters, if any.\n\n'[:digit:]'\nDigits: '0 1 2 3 4 5 6 7 8 9'.\n\n'[:graph:]'\nGraphical characters: '[:alnum:]' and '[:punct:]'.\n\n'[:lower:]'\nLower-case letters; in the 'C' locale and ASCII character encoding,\nthis is 'a b c d e f g h i j k l m n o p q r s t u v w x y z'.\n\n'[:print:]'\nPrintable characters: '[:alnum:]', '[:punct:]', and space.\n\n'[:punct:]'\nPunctuation characters; in the 'C' locale and ASCII character\nencoding, this is '! \" # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \\\n] ^  ` { | } ~'.\n\n'[:space:]'\nSpace characters: in the 'C' locale, this is tab, newline, vertical\ntab, form feed, carriage return, and space.  *Note Usage::, for\nmore discussion of matching newlines.\n\n'[:upper:]'\nUpper-case letters: in the 'C' locale and ASCII character encoding,\nthis is 'A B C D E F G H I J K L M N O P Q R S T U V W X Y Z'.\n\n'[:xdigit:]'\nHexadecimal digits: '0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f'.\n\nNote that the brackets in these class names are part of the symbolic\nnames, and must be included in addition to the brackets delimiting the\nbracket expression.\n\nIf you mistakenly omit the outer brackets, and search for say,\n'[:upper:]', GNU 'grep' prints a diagnostic and exits with status 2, on\nthe assumption that you did not intend to search for the regular\nexpression '[:epru]'.\n\nSpecial characters lose their special meaning inside bracket\nexpressions.\n\n']'\nends the bracket expression if it's not the first list item.  So,\nif you want to make the ']' character a list item, you must put it\nfirst.\n\n'[.'\nrepresents the open collating symbol.\n\n'.]'\nrepresents the close collating symbol.\n\n'[='\nrepresents the open equivalence class.\n\n'=]'\nrepresents the close equivalence class.\n\n'[:'\nrepresents the open character class symbol, and should be followed\nby a valid character class name.\n\n':]'\nrepresents the close character class symbol.\n\n'-'\nrepresents the range if it's not first or last in a list or the\nending point of a range.  To make the '-' a list item, it is best\nto put it last.\n\n'^'\nrepresents the characters not in the list.  If you want to make the\n'^' character a list item, place it anywhere but first.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Special Backslash Expressions,  Next: Anchoring,  Prev: Character Classes and Bracket Expressions,  Up: Regular Expressions": {
            "content": "",
            "subsections": [
                {
                    "name": "3.3 Special Backslash Expressions",
                    "content": "The '\\' character followed by a special character is a regular\nexpression that matches the special character.  The '\\' character, when\nfollowed by certain ordinary characters, takes a special meaning:\n\n'\\b'\nMatch the empty string at the edge of a word.\n\n'\\B'\nMatch the empty string provided it's not at the edge of a word.\n\n'\\<'\nMatch the empty string at the beginning of a word.\n\n'\\>'\nMatch the empty string at the end of a word.\n\n'\\w'\nMatch word constituent, it is a synonym for '[[:alnum:]]'.\n\n'\\W'\nMatch non-word constituent, it is a synonym for '[^[:alnum:]]'.\n\n'\\s'\nMatch whitespace, it is a synonym for '[[:space:]]'.\n\n'\\S'\nMatch non-whitespace, it is a synonym for '[^[:space:]]'.\n\n'\\]'\nMatch ']'.\n\n'\\}'\nMatch '}'.\n\nFor example, '\\brat\\b' matches the separate word 'rat', '\\Brat\\B'\nmatches 'crate' but not 'furry rat'.\n\nThe behavior of 'grep' is unspecified if a unescaped backslash is not\nfollowed by a special character, a nonzero digit, or a character in the\nabove list.  Although 'grep' might issue a diagnostic and/or give the\nbackslash an interpretation now, its behavior may change if the syntax\nof regular expressions is extended in future versions.\n"
                }
            ]
        },
        "File: grep.info,  Node: Anchoring,  Next: Back-references and Subexpressions,  Prev: Special Backslash Expressions,  Up: Regular Expressions": {
            "content": "",
            "subsections": [
                {
                    "name": "3.4 Anchoring",
                    "content": "The caret '^' and the dollar sign '$' are special characters that\nrespectively match the empty string at the beginning and end of a line.\nThey are termed \"anchors\", since they force the match to be \"anchored\"\nto beginning or end of a line, respectively.\n"
                }
            ]
        },
        "File: grep.info,  Node: Back-references and Subexpressions,  Next: Basic vs Extended,  Prev: Anchoring,  Up: Regular Expressions": {
            "content": "",
            "subsections": [
                {
                    "name": "3.5 Back-references and Subexpressions",
                    "content": "The back-reference '\\N', where N is a single nonzero digit, matches the\nsubstring previously matched by the Nth parenthesized subexpression of\nthe regular expression.  For example, '(a)\\1' matches 'aa'.  If the\nparenthesized subexpression does not participate in the match, the\nback-reference makes the whole match fail; for example, '(a)*\\1' fails\nto match 'a'.  If the parenthesized subexpression matches more than one\nsubstring, the back-reference refers to the last matched substring; for\nexample, '^(ab*)*\\1$' matches 'ababbabb' but not 'ababbab'.  When\nmultiple regular expressions are given with '-e' or from a file ('-f\nFILE'), back-references are local to each expression.\n\n*Note Known Bugs::, for some known problems with back-references.\n"
                }
            ]
        },
        "File: grep.info,  Node: Basic vs Extended,  Next: Problematic Expressions,  Prev: Back-references and Subexpressions,  Up: Regular Expressions": {
            "content": "",
            "subsections": [
                {
                    "name": "3.6 Basic vs Extended Regular Expressions",
                    "content": ""
                }
            ]
        },
        "Basic regular expressions differ from extended regular expressions in": {
            "content": "the following ways:\n\n* The characters '?', '+', '{', '|', '(', and ')' lose their special\nmeaning; instead use the backslashed versions '\\?', '\\+', '\\{',\n'\\|', '\\(', and '\\)'.  Also, a backslash is needed before an\ninterval expression's closing '}'.\n\n* An unmatched '\\)' is invalid.\n\n* If an unescaped '^' appears neither first, nor directly after '\\('\nor '\\|', it is treated like an ordinary character and is not an\nanchor.\n\n* If an unescaped '$' appears neither last, nor directly before '\\|'\nor '\\)', it is treated like an ordinary character and is not an\nanchor.\n\n* If an unescaped '*' appears first, or appears directly after '\\('\nor '\\|' or anchoring '^', it is treated like an ordinary character\nand is not a repetition operator.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Problematic Expressions,  Next: Character Encoding,  Prev: Basic vs Extended,  Up: Regular Expressions": {
            "content": "",
            "subsections": [
                {
                    "name": "3.7 Problematic Regular Expressions",
                    "content": "Some strings are \"invalid regular expressions\" and cause 'grep' to issue\na diagnostic and fail.  For example, 'xy\\1' is invalid because there is\nno parenthesized subexpression for the back-reference '\\1' to refer to.\n\nAlso, some regular expressions have \"unspecified behavior\" and should\nbe avoided even if 'grep' does not currently diagnose them.  For\nexample, 'xy\\0' has unspecified behavior because '0' is not a special\ncharacter and '\\0' is not a special backslash expression (*note Special"
                }
            ]
        },
        "Backslash Expressions::).  Unspecified behavior can be particularly": {
            "content": "problematic because the set of matched strings might be only partially\nspecified, or not be specified at all, or the expression might even be\ninvalid.\n\nThe following regular expression constructs are invalid on all\nplatforms conforming to POSIX, so portable scripts can assume that\n'grep' rejects these constructs:\n\n* A basic regular expression containing a back-reference '\\N'\npreceded by fewer than N closing parentheses.  For example,\n'\\(a\\)\\2' is invalid.\n\n* A bracket expression containing '[:' that does not start a\ncharacter class; and similarly for '[=' and '[.'.  For example,\n'[a[:b]' and '[a[:ouch:]b]' are invalid.\n\nGNU 'grep' treats the following constructs as invalid.  However,\nother 'grep' implementations might allow them, so portable scripts\nshould not rely on their being invalid:\n\n* Unescaped '\\' at the end of a regular expression.\n\n* Unescaped '[' that does not start a bracket expression.\n\n* A '\\{' in a basic regular expression that does not start an\ninterval expression.\n\n* A basic regular expression with unbalanced '\\(' or '\\)', or an\nextended regular expression with unbalanced '('.\n\n* In the POSIX locale, a range expression like 'z-a' that represents\nzero elements.  A non-GNU 'grep' might treat it as a valid range\nthat never matches.\n\n* An interval expression with a repetition count greater than 32767.\n(The portable POSIX limit is 255, and even interval expressions\nwith smaller counts can be impractically slow on all known\nimplementations.)\n\n* A bracket expression that contains at least three elements, the\nfirst and last of which are both ':', or both '.', or both '='.\nFor example, a non-GNU 'grep' might treat '[:alpha:]' like\n'[[:alpha:]]', or like '[:ahlp]'.\n\nThe following constructs have well-defined behavior in GNU 'grep'.",
            "subsections": []
        },
        "However, they have unspecified behavior elsewhere, so portable scripts": {
            "content": "should avoid them:\n\n* Special backslash expressions like '\\b', '\\<', and '\\]'.  *Note\nSpecial Backslash Expressions::.\n\n* A basic regular expression that uses '\\?', '\\+', or '\\|'.\n\n* An extended regular expression that uses back-references.\n\n* An empty regular expression, subexpression, or alternative.  For\nexample, '(a|bc|)' is not portable; a portable equivalent is\n'(a|bc)?'.\n\n* In a basic regular expression, an anchoring '^' that appears\ndirectly after '\\(', or an anchoring '$' that appears directly\nbefore '\\)'.\n\n* In a basic regular expression, a repetition operator that directly\nfollows another repetition operator.\n\n* In an extended regular expression, unescaped '{' that does not\nbegin a valid interval expression.  GNU 'grep' treats the '{' as an\nordinary character.\n\n* A null character or an encoding error in either pattern or input\ndata.  *Note Character Encoding::.\n\n* An input file that ends in a non-newline character, where GNU\n'grep' silently supplies a newline.\n\nThe following constructs have unspecified behavior, in both GNU and\nother 'grep' implementations.  Scripts should avoid them whenever\npossible.\n\n* A backslash escaping an ordinary character, unless it is a\nback-reference like '\\1' or a special backslash expression like\n'\\<' or '\\b'.  *Note Special Backslash Expressions::.  For example,\n'\\x' has unspecified behavior now, and a future version of 'grep'\nmight specify '\\x' to have a new behavior.\n\n* A repetition operator that appears directly after an anchor, or at\nthe start of a complete regular expression, parenthesized\nsubexpression, or alternative.  For example, '+|^*(+a|?-b)' has\nunspecified behavior, whereas '\\+|^\\*(\\+a|\\?-b)' is portable.\n\n* A range expression outside the POSIX locale.  For example, in some\nlocales '[a-z]' might match some characters that are not lowercase\nletters, or might not match some lowercase letters, or might be\ninvalid.  With GNU 'grep' it is not documented whether these range\nexpressions use native code points, or use the collating sequence\nspecified by the 'LCCOLLATE' category, or have some other\ninterpretation.  Outside the POSIX locale, it is portable to use\n'[[:lower:]]' to match a lower-case letter, or\n'[abcdefghijklmnopqrstuvwxyz]' to match an ASCII lower-case letter.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Character Encoding,  Next: Matching Non-ASCII,  Prev: Problematic Expressions,  Up: Regular Expressions": {
            "content": "",
            "subsections": [
                {
                    "name": "3.8 Character Encoding",
                    "content": ""
                }
            ]
        },
        "The 'LCCTYPE' locale specifies the encoding of characters in patterns": {
            "content": "and data, that is, whether text is encoded in UTF-8, ASCII, or some\nother encoding.  *Note Environment Variables::.\n\nIn the 'C' or 'POSIX' locale, every character is encoded as a single\nbyte and every byte is a valid character.  In more-complex encodings\nsuch as UTF-8, a sequence of multiple bytes may be needed to represent a\ncharacter, and some bytes may be encoding errors that do not contribute\nto the representation of any character.  POSIX does not specify the\nbehavior of 'grep' when patterns or input data contain encoding errors\nor null characters, so portable scripts should avoid such usage.  As an\nextension to POSIX, GNU 'grep' treats null characters like any other\ncharacter.  However, unless the '-a' ('--binary-files=text') option is\nused, the presence of null characters in input or of encoding errors in\noutput causes GNU 'grep' to treat the file as binary and suppress\ndetails about matches.  *Note File and Directory Selection::.\n\nRegardless of locale, the 103 characters in the POSIX Portable",
            "subsections": []
        },
        "Character Set (a subset of ASCII) are always encoded as a single byte,": {
            "content": "and the 128 ASCII characters have their usual single-byte encodings on\nall but oddball platforms.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Matching Non-ASCII,  Prev: Character Encoding,  Up: Regular Expressions": {
            "content": "",
            "subsections": [
                {
                    "name": "3.9 Matching Non-ASCII and Non-printable Characters",
                    "content": ""
                }
            ]
        },
        "In a regular expression, non-ASCII and non-printable characters other": {
            "content": "than newline are not special, and represent themselves.  For example, in\na locale using UTF-8 the command 'grep '?? ??'' (where the white space\nbetween '??' and the '??' is a tab character) searches for '??' (Unicode\ncharacter U+039B GREEK CAPITAL LETTER LAMBDA), followed by a tab (U+0009\nTAB), followed by '??' (U+03C9 GREEK SMALL LETTER OMEGA).\n\nSuppose you want to limit your pattern to only printable characters\n(or even only printable ASCII characters) to keep your script readable\nor portable, but you also want to match specific non-ASCII or non-null\nnon-printable characters.  If you are using the '-P' ('--perl-regexp')\noption, PCREs give you several ways to do this.  Otherwise, if you are\nusing Bash, the GNU project's shell, you can represent these characters\nvia ANSI-C quoting.  For example, the Bash commands 'grep $'??\\t??'' and\n'grep $'\\u039B\\t\\u03C9'' both search for the same three-character string\n'?? ??' mentioned earlier.  However, because Bash translates ANSI-C\nquoting before 'grep' sees the pattern, this technique should not be\nused to match printable ASCII characters; for example, 'grep $'\\u005E''\nis equivalent to 'grep '^'' and matches any line, not just lines\ncontaining the character '^' (U+005E CIRCUMFLEX ACCENT).\n\nSince PCREs and ANSI-C quoting are GNU extensions to POSIX, portable\nshell scripts written in ASCII should use other methods to match\nspecific non-ASCII characters.  For example, in a UTF-8 locale the\ncommand 'grep \"$(printf '\\316\\233\\t\\317\\211\\n')\"' is a portable albeit\nhard-to-read alternative to Bash's 'grep $'??\\t??''.  However, none of\nthese techniques will let you put a null character directly into a\ncommand-line pattern; null characters can appear only in a pattern\nspecified via the '-f' ('--file') option.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Usage,  Next: Performance,  Prev: Regular Expressions,  Up: Top": {
            "content": "",
            "subsections": []
        },
        "4 Usage": {
            "content": "Here is an example command that invokes GNU 'grep':\n\ngrep -i 'hello.*world' menu.h main.c\n",
            "subsections": []
        },
        "This lists all lines in the files 'menu.h' and 'main.c' that contain the": {
            "content": "string 'hello' followed by the string 'world'; this is because '.*'\nmatches zero or more characters within a line.  *Note Regular",
            "subsections": []
        },
        "Expressions::.  The '-i' option causes 'grep' to ignore case, causing it": {
            "content": "to match the line 'Hello, world!', which it would not otherwise match.\n\nHere is a more complex example, showing the location and contents of\nany line containing 'f' and ending in '.c', within all files in the\ncurrent directory whose names start with non-'.', contain 'g', and end\nin '.h'.  The '-n' option outputs line numbers, the '--' argument treats\nany later arguments as file names not options even if '*g*.h' expands to\na file name that starts with '-', and the empty file '/dev/null' causes\nfile names to be output even if only one file name happens to be of the\nform '*g*.h'.\n\ngrep -n -- 'f.*\\.c$' *g*.h /dev/null\n",
            "subsections": []
        },
        "Note that the regular expression syntax used in the pattern differs from": {
            "content": "the globbing syntax that the shell uses to match file names.\n\n*Note Invoking::, for more details about how to invoke 'grep'.\n\nHere are some common questions and answers about 'grep' usage.\n\n1. How can I list just the names of matching files?\n\ngrep -l 'main' test-*.c\n\nlists names of 'test-*.c' files in the current directory whose\ncontents mention 'main'.\n\n2. How do I search directories recursively?\n\ngrep -r 'hello' /home/gigi\n\nsearches for 'hello' in all files under the '/home/gigi' directory.\nFor more control over which files are searched, use 'find' and\n'grep'.  For example, the following command searches only C files:\n\nfind /home/gigi -name '*.c' ! -type d \\\n-exec grep -H 'hello' '{}' +\n\nThis differs from the command:\n\ngrep -H 'hello' /home/gigi/*.c\n\nwhich merely looks for 'hello' in non-hidden C files in\n'/home/gigi' whose names end in '.c'.  The 'find' command line\nabove is more similar to the command:\n\ngrep -r --include='*.c' 'hello' /home/gigi\n\n3. What if a pattern or file has a leading '-'?  For example:\n\ngrep \"$pattern\" *\n\ncan behave unexpectedly if the value of 'pattern' begins with '-',\nor if the '*' expands to a file name with leading '-'.  To avoid\nthe problem, you can use '-e' for patterns and leading './' for\nfiles:\n\ngrep -e \"$pattern\" ./*\n\nsearches for all lines matching the pattern in all the working\ndirectory's files whose names do not begin with '.'.  Without the\n'-e', 'grep' might treat the pattern as an option if it begins with\n'-'.  Without the './', there might be similar problems with file\nnames beginning with '-'.\n\nAlternatively, you can use '--' before the pattern and file names:\n\ngrep -- \"$pattern\" *\n\nThis also fixes the problem, except that if there is a file named\n'-', 'grep' misinterprets the '-' as standard input.\n\n4. Suppose I want to search for a whole word, not a part of a word?\n\ngrep -w 'hello' test*.log\n\nsearches only for instances of 'hello' that are entire words; it\ndoes not match 'Othello'.  For more control, use '\\<' and '\\>' to\nmatch the start and end of words.  For example:\n\ngrep 'hello\\>' test*.log\n\nsearches only for words ending in 'hello', so it matches the word\n'Othello'.\n\n5. How do I output context around the matching lines?\n\ngrep -C 2 'hello' test*.log\n\nprints two lines of context around each matching line.\n\n6. How do I force 'grep' to print the name of the file?\n\nAppend '/dev/null':\n\ngrep 'eli' /etc/passwd /dev/null\n\ngets you:\n\n/etc/passwd:eli:x:2098:1000:Eli Smith:/home/eli:/bin/bash\n\nAlternatively, use '-H', which is a GNU extension:\n\ngrep -H 'eli' /etc/passwd\n\n7. Why do people use strange regular expressions on 'ps' output?\n\nps -ef | grep '[c]ron'\n\nIf the pattern had been written without the square brackets, it\nwould have matched not only the 'ps' output line for 'cron', but\nalso the 'ps' output line for 'grep'.  Note that on some platforms,\n'ps' limits the output to the width of the screen; 'grep' does not\nhave any limit on the length of a line except the available memory.\n\n8. Why does 'grep' report \"Binary file matches\"?\n\nIf 'grep' listed all matching \"lines\" from a binary file, it would\nprobably generate output that is not useful, and it might even muck\nup your display.  So GNU 'grep' suppresses output from files that\nappear to be binary files.  To force GNU 'grep' to output lines\neven from files that appear to be binary, use the '-a' or\n'--binary-files=text' option.  To eliminate the \"Binary file\nmatches\" messages, use the '-I' or '--binary-files=without-match'\noption.\n\n9. Why doesn't 'grep -lv' print non-matching file names?\n\n'grep -lv' lists the names of all files containing one or more\nlines that do not match.  To list the names of all files that\ncontain no matching lines, use the '-L' or '--files-without-match'\noption.\n\n10. I can do \"OR\" with '|', but what about \"AND\"?\n\ngrep 'paul' /etc/motd | grep 'franc,ois'\n\nfinds all lines that contain both 'paul' and 'franc,ois'.\n\n11. Why does the empty pattern match every input line?\n\nThe 'grep' command searches for lines that contain strings that\nmatch a pattern.  Every line contains the empty string, so an empty\npattern causes 'grep' to find a match on each line.  It is not the\nonly such pattern: '^', '$', and many other patterns cause 'grep'\nto match every line.\n\nTo match empty lines, use the pattern '^$'.  To match blank lines,\nuse the pattern '^[[:blank:]]*$'.  To match no lines at all, use an\nextended regular expression like 'a^' or '$a'.  To match every\nline, a portable script should use a pattern like '^' instead of\nthe empty pattern, as POSIX does not specify the behavior of the\nempty pattern.\n\n12. How can I search in both standard input and in files?\n\nUse the special file name '-':\n\ncat /etc/passwd | grep 'alain' - /etc/motd\n\n13. Why can't I combine the shell's 'set -e' with 'grep'?\n\nThe 'grep' command follows the convention of programs like 'cmp'\nand 'diff' where an exit status of 1 is not an error.  The shell\ncommand 'set -e' causes the shell to exit if any subcommand exits\nwith nonzero status, and this will cause the shell to exit merely\nbecause 'grep' selected no lines, which is ordinarily not what you\nwant.\n\nThere is a related problem with Bash's 'set -e -o pipefail'.  Since\n'grep' does not always read all its input, a command outputting to\na pipe read by 'grep' can fail when 'grep' exits before reading all\nits input, and the command's failure can cause Bash to exit.\n\n14. Why is this back-reference failing?\n\necho 'ba' | grep -E '(a)\\1|b\\1'\n\nThis outputs an error message, because the second '\\1' has nothing\nto refer back to, meaning it will never match anything.\n\n15. How can I match across lines?\n\nStandard grep cannot do this, as it is fundamentally line-based.\nTherefore, merely using the '[:space:]' character class does not\nmatch newlines in the way you might expect.\n\nWith the GNU 'grep' option '-z' ('--null-data'), each input and\noutput \"line\" is null-terminated; *note Other Options::.  Thus, you\ncan match newlines in the input, but typically if there is a match\nthe entire input is output, so this usage is often combined with\noutput-suppressing options like '-q', e.g.:\n\nprintf 'foo\\nbar\\n' | grep -z -q 'foo[[:space:]]\\+bar'\n\nIf this does not suffice, you can transform the input before giving\nit to 'grep', or turn to 'awk', 'sed', 'perl', or many other\nutilities that are designed to operate across lines.\n\n16. What do 'grep', '-E', and '-F' stand for?\n\nThe name 'grep' comes from the way line editing was done on Unix.\nFor example, 'ed' uses the following syntax to print a list of\nmatching lines on the screen:\n\nglobal/regular expression/print\ng/re/p\n\nThe '-E' option stands for Extended 'grep'.  The '-F' option stands\nfor Fixed 'grep';\n\n17. What happened to 'egrep' and 'fgrep'?\n\n7th Edition Unix had commands 'egrep' and 'fgrep' that were the\ncounterparts of the modern 'grep -E' and 'grep -F'.  Although\nbreaking up 'grep' into three programs was perhaps useful on the\nsmall computers of the 1970s, 'egrep' and 'fgrep' were deemed\nobsolescent by POSIX in 1992, removed from POSIX in 2001,\ndeprecated by GNU Grep 2.5.3 in 2007, and changed to issue\nobsolescence warnings by GNU Grep 3.8 in 2022; eventually, they are\nplanned to be removed entirely.\n\nIf you prefer the old names, you can use your own substitutes, such\nas a shell script named 'egrep' with the following contents:\n\n#!/bin/sh\nexec grep -E \"$@\"\n",
            "subsections": []
        },
        "File: grep.info,  Node: Performance,  Next: Reporting Bugs,  Prev: Usage,  Up: Top": {
            "content": "",
            "subsections": []
        },
        "5 Performance": {
            "content": "",
            "subsections": []
        },
        "Typically 'grep' is an efficient way to search text.  However, it can be": {
            "content": "quite slow in some cases, and it can search large files where even minor\nperformance tweaking can help significantly.  Although the algorithm\nused by 'grep' is an implementation detail that can change from release\nto release, understanding its basic strengths and weaknesses can help\nyou improve its performance.\n\nThe 'grep' command operates partly via a set of automata that are\ndesigned for efficiency, and partly via a slower matcher that takes over\nwhen the fast matchers run into unusual features like back-references.",
            "subsections": []
        },
        "When feasible, the Boyer-Moore fast string searching algorithm is used": {
            "content": "to match a single fixed pattern, and the Aho-Corasick algorithm is used\nto match multiple fixed patterns.\n\nGenerally speaking 'grep' operates more efficiently in single-byte\nlocales, since it can avoid the special processing needed for multi-byte\ncharacters.  If your patterns will work just as well that way, setting\n'LCALL' to a single-byte locale can help performance considerably.\nSetting 'LCALL='C'' can be particularly efficient, as 'grep' is tuned\nfor that locale.\n\nOutside the 'C' locale, case-insensitive search, and search for\nbracket expressions like '[a-z]' and '[[=a=]b]', can be surprisingly\ninefficient due to difficulties in fast portable access to concepts like\nmulti-character collating elements.\n\nInterval expressions may be implemented internally via repetition.\nFor example, '^(a|bc){2,4}$' might be implemented as\n'^(a|bc)(a|bc)((a|bc)(a|bc)?)?$'.  A large repetition count may exhaust\nmemory or greatly slow matching.  Even small counts can cause problems\nif cascaded; for example, 'grep -E \".*{10,}{10,}{10,}{10,}{10,}\"' is\nlikely to overflow a stack.  Fortunately, regular expressions like these\nare typically artificial, and cascaded repetitions do not conform to\nPOSIX so cannot be used in portable programs anyway.\n\nA back-reference such as '\\1' can hurt performance significantly in\nsome cases, since back-references cannot in general be implemented via a\nfinite state automaton, and instead trigger a backtracking algorithm\nthat can be quite inefficient.  For example, although the pattern\n'^(.*)\\1{14}(.*)\\2{13}$' matches only lines whose lengths can be written\nas a sum 15x + 14y for nonnegative integers x and y, the pattern matcher\ndoes not perform linear Diophantine analysis and instead backtracks\nthrough all possible matching strings, using an algorithm that is\nexponential in the worst case.\n\nOn some operating systems that support files with holes--large\nregions of zeros that are not physically present on secondary\nstorage--'grep' can skip over the holes efficiently without needing to\nread the zeros.  This optimization is not available if the '-a'\n('--binary-files=text') option is used (*note File and Directory\nSelection::), unless the '-z' ('--null-data') option is also used (*note\nOther Options::).\n\nFor efficiency 'grep' does not always read all its input.  For\nexample, the shell command 'sed '/^...$/d' | grep -q X' can cause 'grep'\nto exit immediately after reading a line containing 'X', without\nbothering to read the rest of its input data.  This in turn can cause\n'sed' to exit with a nonzero status because 'sed' cannot write to its\noutput pipe after 'grep' exits.\n\nFor more about the algorithms used by 'grep' and about related string\nmatching algorithms, see:\n\n* Aho AV. Algorithms for finding patterns in strings. In: van Leeuwen\nJ. Handbook of Theoretical Computer Science, vol. A. New York:\nElsevier; 1990. p. 255-300. This surveys classic string matching\nalgorithms, some of which are used by 'grep'.\n\n* Aho AV, Corasick MJ. Efficient string matching: an aid to\nbibliographic search. CACM. 1975;18(6):333-40.\n<https://doi.org/10.1145/360825.360855>. This introduces the\nAho-Corasick algorithm.\n\n* Boyer RS, Moore JS. A fast string searching algorithm. CACM.\n1977;20(10):762-72. <https://doi.org/10.1145/359842.359859>. This\nintroduces the Boyer-Moore algorithm.\n\n* Faro S, Lecroq T. The exact online string matching problem: a\nreview of the most recent results. ACM Comput Surv.\n2013;45(2):13. <https://doi.org/10.1145/2431211.2431212>. This\nsurveys string matching algorithms that might help improve the\nperformance of 'grep' in the future.\n\n* Hakak SI, Kamsin A, Shivakumara P, Gilkar GA, Khan WZ, Imran M.\nExact string matching algorithms: survey issues, and future\nresearch directions. IEEE Access. 2019;7:69614-37.\n<https://doi.org/10.1109/ACCESS.2019.2914071>. This survey is more\nrecent than Faro & Lecroq, and focuses on taxonomy instead of\nperformance.\n\n* Hume A, Sunday D. Fast string search. Software Pract Exper.\n1991;21(11):1221-48. <https://doi.org/10.1002/spe.4380211105>. This\nexcellent albeit now-dated survey aided the initial development of\n'grep'.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Reporting Bugs,  Next: Copying,  Prev: Performance,  Up: Top": {
            "content": "",
            "subsections": []
        },
        "6 Reporting bugs": {
            "content": "",
            "subsections": []
        },
        "Bug reports can be found at the GNU bug report logs for 'grep'": {
            "content": "(https://debbugs.gnu.org/cgi/pkgreport.cgi?package=grep).  If you find a\nbug not listed there, please email it to <bug-grep@gnu.org> to create a\nnew bug report.\n\n* Menu:\n\n* Known Bugs::\n",
            "subsections": []
        },
        "File: grep.info,  Node: Known Bugs,  Up: Reporting Bugs": {
            "content": "",
            "subsections": [
                {
                    "name": "6.1 Known Bugs",
                    "content": "Large repetition counts in the '{n,m}' construct may cause 'grep' to use\nlots of memory.  In addition, certain other obscure regular expressions\nrequire exponential time and space, and may cause 'grep' to run out of\nmemory.\n\nBack-references can greatly slow down matching, as they can generate\nexponentially many matching possibilities that can consume both time and\nmemory to explore.  Also, the POSIX specification for back-references is\nat times unclear.  Furthermore, many regular expression implementations\nhave back-reference bugs that can cause programs to return incorrect\nanswers or even crash, and fixing these bugs has often been\nlow-priority: for example, as of 2021 the GNU C library bug database\n(https://sourceware.org/bugzilla/) contained back-reference bugs 52,\n10844, 11053, 24269 and 25322, with little sign of forthcoming fixes."
                }
            ]
        },
        "Luckily, back-references are rarely useful and it should be little": {
            "content": "trouble to avoid them in practical applications.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Copying,  Next: Index,  Prev: Reporting Bugs,  Up: Top": {
            "content": "",
            "subsections": []
        },
        "7 Copying": {
            "content": "GNU 'grep' is licensed under the GNU GPL, which makes it \"free\nsoftware\".\n\nThe \"free\" in \"free software\" refers to liberty, not price.  As some\nGNU project advocates like to point out, think of \"free speech\" rather\nthan \"free beer\".  In short, you have the right (freedom) to run and\nchange 'grep' and distribute it to other people, and--if you\nwant--charge money for doing either.  The important restriction is that\nyou have to grant your recipients the same rights and impose the same\nrestrictions.\n\nThis general method of licensing software is sometimes called \"open\nsource\".  The GNU project prefers the term \"free software\" for reasons\noutlined at\n<https://www.gnu.org/philosophy/open-source-misses-the-point.html>.\n\nThis manual is free documentation in the same sense.  The\ndocumentation license is included below.  The license for the program is\navailable with the source code, or at\n<https://www.gnu.org/licenses/gpl.html>.\n\n* Menu:\n\n* GNU Free Documentation License::\n",
            "subsections": []
        },
        "File: grep.info,  Node: GNU Free Documentation License,  Up: Copying": {
            "content": "",
            "subsections": [
                {
                    "name": "7.1 GNU Free Documentation License",
                    "content": "Version 1.3, 3 November 2008\n\nCopyright (C) 2000-2002, 2007-2008, 2023 Free Software Foundation,\nInc.\n<https://fsf.org/>\n\nEveryone is permitted to copy and distribute verbatim copies\nof this license document, but changing it is not allowed.\n\n0. PREAMBLE\n\nThe purpose of this License is to make a manual, textbook, or other\nfunctional and useful document \"free\" in the sense of freedom: to\nassure everyone the effective freedom to copy and redistribute it,\nwith or without modifying it, either commercially or\nnoncommercially.  Secondarily, this License preserves for the\nauthor and publisher a way to get credit for their work, while not\nbeing considered responsible for modifications made by others.\n\nThis License is a kind of \"copyleft\", which means that derivative\nworks of the document must themselves be free in the same sense.\nIt complements the GNU General Public License, which is a copyleft\nlicense designed for free software.\n\nWe have designed this License in order to use it for manuals for\nfree software, because free software needs free documentation: a\nfree program should come with manuals providing the same freedoms\nthat the software does.  But this License is not limited to\nsoftware manuals; it can be used for any textual work, regardless\nof subject matter or whether it is published as a printed book.  We\nrecommend this License principally for works whose purpose is\ninstruction or reference.\n\n1. APPLICABILITY AND DEFINITIONS\n\nThis License applies to any manual or other work, in any medium,\nthat contains a notice placed by the copyright holder saying it can\nbe distributed under the terms of this License.  Such a notice\ngrants a world-wide, royalty-free license, unlimited in duration,\nto use that work under the conditions stated herein.  The\n\"Document\", below, refers to any such manual or work.  Any member\nof the public is a licensee, and is addressed as \"you\".  You accept\nthe license if you copy, modify or distribute the work in a way\nrequiring permission under copyright law.\n\nA \"Modified Version\" of the Document means any work containing the\nDocument or a portion of it, either copied verbatim, or with\nmodifications and/or translated into another language.\n\nA \"Secondary Section\" is a named appendix or a front-matter section\nof the Document that deals exclusively with the relationship of the\npublishers or authors of the Document to the Document's overall\nsubject (or to related matters) and contains nothing that could\nfall directly within that overall subject.  (Thus, if the Document\nis in part a textbook of mathematics, a Secondary Section may not\nexplain any mathematics.)  The relationship could be a matter of\nhistorical connection with the subject or with related matters, or\nof legal, commercial, philosophical, ethical or political position\nregarding them.\n\nThe \"Invariant Sections\" are certain Secondary Sections whose\ntitles are designated, as being those of Invariant Sections, in the\nnotice that says that the Document is released under this License.\nIf a section does not fit the above definition of Secondary then it\nis not allowed to be designated as Invariant.  The Document may\ncontain zero Invariant Sections.  If the Document does not identify\nany Invariant Sections then there are none.\n\nThe \"Cover Texts\" are certain short passages of text that are\nlisted, as Front-Cover Texts or Back-Cover Texts, in the notice\nthat says that the Document is released under this License.  A\nFront-Cover Text may be at most 5 words, and a Back-Cover Text may\nbe at most 25 words.\n\nA \"Transparent\" copy of the Document means a machine-readable copy,\nrepresented in a format whose specification is available to the\ngeneral public, that is suitable for revising the document\nstraightforwardly with generic text editors or (for images composed\nof pixels) generic paint programs or (for drawings) some widely\navailable drawing editor, and that is suitable for input to text\nformatters or for automatic translation to a variety of formats\nsuitable for input to text formatters.  A copy made in an otherwise\nTransparent file format whose markup, or absence of markup, has\nbeen arranged to thwart or discourage subsequent modification by\nreaders is not Transparent.  An image format is not Transparent if\nused for any substantial amount of text.  A copy that is not\n\"Transparent\" is called \"Opaque\".\n\nExamples of suitable formats for Transparent copies include plain\nASCII without markup, Texinfo input format, LaTeX input format,\nSGML or XML using a publicly available DTD, and standard-conforming\nsimple HTML, PostScript or PDF designed for human modification.\nExamples of transparent image formats include PNG, XCF and JPG.\nOpaque formats include proprietary formats that can be read and\nedited only by proprietary word processors, SGML or XML for which\nthe DTD and/or processing tools are not generally available, and\nthe machine-generated HTML, PostScript or PDF produced by some word\nprocessors for output purposes only.\n\nThe \"Title Page\" means, for a printed book, the title page itself,\nplus such following pages as are needed to hold, legibly, the\nmaterial this License requires to appear in the title page.  For\nworks in formats which do not have any title page as such, \"Title\nPage\" means the text near the most prominent appearance of the\nwork's title, preceding the beginning of the body of the text.\n\nThe \"publisher\" means any person or entity that distributes copies\nof the Document to the public.\n\nA section \"Entitled XYZ\" means a named subunit of the Document\nwhose title either is precisely XYZ or contains XYZ in parentheses\nfollowing text that translates XYZ in another language.  (Here XYZ\nstands for a specific section name mentioned below, such as\n\"Acknowledgements\", \"Dedications\", \"Endorsements\", or \"History\".)\nTo \"Preserve the Title\" of such a section when you modify the\nDocument means that it remains a section \"Entitled XYZ\" according\nto this definition.\n\nThe Document may include Warranty Disclaimers next to the notice\nwhich states that this License applies to the Document.  These\nWarranty Disclaimers are considered to be included by reference in\nthis License, but only as regards disclaiming warranties: any other\nimplication that these Warranty Disclaimers may have is void and\nhas no effect on the meaning of this License.\n\n2. VERBATIM COPYING\n\nYou may copy and distribute the Document in any medium, either\ncommercially or noncommercially, provided that this License, the\ncopyright notices, and the license notice saying this License\napplies to the Document are reproduced in all copies, and that you\nadd no other conditions whatsoever to those of this License.  You\nmay not use technical measures to obstruct or control the reading\nor further copying of the copies you make or distribute.  However,\nyou may accept compensation in exchange for copies.  If you\ndistribute a large enough number of copies you must also follow the\nconditions in section 3.\n\nYou may also lend copies, under the same conditions stated above,\nand you may publicly display copies.\n\n3. COPYING IN QUANTITY\n\nIf you publish printed copies (or copies in media that commonly\nhave printed covers) of the Document, numbering more than 100, and\nthe Document's license notice requires Cover Texts, you must\nenclose the copies in covers that carry, clearly and legibly, all\nthese Cover Texts: Front-Cover Texts on the front cover, and\nBack-Cover Texts on the back cover.  Both covers must also clearly\nand legibly identify you as the publisher of these copies.  The\nfront cover must present the full title with all words of the title\nequally prominent and visible.  You may add other material on the\ncovers in addition.  Copying with changes limited to the covers, as\nlong as they preserve the title of the Document and satisfy these\nconditions, can be treated as verbatim copying in other respects.\n\nIf the required texts for either cover are too voluminous to fit\nlegibly, you should put the first ones listed (as many as fit\nreasonably) on the actual cover, and continue the rest onto\nadjacent pages.\n\nIf you publish or distribute Opaque copies of the Document\nnumbering more than 100, you must either include a machine-readable\nTransparent copy along with each Opaque copy, or state in or with\neach Opaque copy a computer-network location from which the general\nnetwork-using public has access to download using public-standard\nnetwork protocols a complete Transparent copy of the Document, free\nof added material.  If you use the latter option, you must take\nreasonably prudent steps, when you begin distribution of Opaque\ncopies in quantity, to ensure that this Transparent copy will\nremain thus accessible at the stated location until at least one\nyear after the last time you distribute an Opaque copy (directly or\nthrough your agents or retailers) of that edition to the public.\n\nIt is requested, but not required, that you contact the authors of\nthe Document well before redistributing any large number of copies,\nto give them a chance to provide you with an updated version of the\nDocument.\n\n4. MODIFICATIONS\n\nYou may copy and distribute a Modified Version of the Document\nunder the conditions of sections 2 and 3 above, provided that you\nrelease the Modified Version under precisely this License, with the\nModified Version filling the role of the Document, thus licensing\ndistribution and modification of the Modified Version to whoever\npossesses a copy of it.  In addition, you must do these things in\nthe Modified Version:\n\nA. Use in the Title Page (and on the covers, if any) a title\ndistinct from that of the Document, and from those of previous\nversions (which should, if there were any, be listed in the\nHistory section of the Document).  You may use the same title\nas a previous version if the original publisher of that\nversion gives permission.\n\nB. List on the Title Page, as authors, one or more persons or\nentities responsible for authorship of the modifications in\nthe Modified Version, together with at least five of the\nprincipal authors of the Document (all of its principal\nauthors, if it has fewer than five), unless they release you\nfrom this requirement.\n\nC. State on the Title page the name of the publisher of the\nModified Version, as the publisher.\n\nD. Preserve all the copyright notices of the Document.\n\nE. Add an appropriate copyright notice for your modifications\nadjacent to the other copyright notices.\n\nF. Include, immediately after the copyright notices, a license\nnotice giving the public permission to use the Modified\nVersion under the terms of this License, in the form shown in\nthe Addendum below.\n\nG. Preserve in that license notice the full lists of Invariant\nSections and required Cover Texts given in the Document's\nlicense notice.\n\nH. Include an unaltered copy of this License.\n\nI. Preserve the section Entitled \"History\", Preserve its Title,\nand add to it an item stating at least the title, year, new\nauthors, and publisher of the Modified Version as given on the\nTitle Page.  If there is no section Entitled \"History\" in the\nDocument, create one stating the title, year, authors, and\npublisher of the Document as given on its Title Page, then add\nan item describing the Modified Version as stated in the\nprevious sentence.\n\nJ. Preserve the network location, if any, given in the Document\nfor public access to a Transparent copy of the Document, and\nlikewise the network locations given in the Document for\nprevious versions it was based on.  These may be placed in the\n\"History\" section.  You may omit a network location for a work\nthat was published at least four years before the Document\nitself, or if the original publisher of the version it refers\nto gives permission.\n\nK. For any section Entitled \"Acknowledgements\" or \"Dedications\",\nPreserve the Title of the section, and preserve in the section\nall the substance and tone of each of the contributor\nacknowledgements and/or dedications given therein.\n\nL. Preserve all the Invariant Sections of the Document, unaltered\nin their text and in their titles.  Section numbers or the\nequivalent are not considered part of the section titles.\n\nM. Delete any section Entitled \"Endorsements\".  Such a section\nmay not be included in the Modified Version.\n\nN. Do not retitle any existing section to be Entitled\n\"Endorsements\" or to conflict in title with any Invariant\nSection.\n\nO. Preserve any Warranty Disclaimers.\n\nIf the Modified Version includes new front-matter sections or\nappendices that qualify as Secondary Sections and contain no\nmaterial copied from the Document, you may at your option designate\nsome or all of these sections as invariant.  To do this, add their\ntitles to the list of Invariant Sections in the Modified Version's\nlicense notice.  These titles must be distinct from any other\nsection titles.\n\nYou may add a section Entitled \"Endorsements\", provided it contains\nnothing but endorsements of your Modified Version by various\nparties--for example, statements of peer review or that the text\nhas been approved by an organization as the authoritative\ndefinition of a standard.\n\nYou may add a passage of up to five words as a Front-Cover Text,\nand a passage of up to 25 words as a Back-Cover Text, to the end of\nthe list of Cover Texts in the Modified Version.  Only one passage\nof Front-Cover Text and one of Back-Cover Text may be added by (or\nthrough arrangements made by) any one entity.  If the Document\nalready includes a cover text for the same cover, previously added\nby you or by arrangement made by the same entity you are acting on\nbehalf of, you may not add another; but you may replace the old\none, on explicit permission from the previous publisher that added\nthe old one.\n\nThe author(s) and publisher(s) of the Document do not by this\nLicense give permission to use their names for publicity for or to\nassert or imply endorsement of any Modified Version.\n\n5. COMBINING DOCUMENTS\n\nYou may combine the Document with other documents released under\nthis License, under the terms defined in section 4 above for\nmodified versions, provided that you include in the combination all\nof the Invariant Sections of all of the original documents,\nunmodified, and list them all as Invariant Sections of your\ncombined work in its license notice, and that you preserve all\ntheir Warranty Disclaimers.\n\nThe combined work need only contain one copy of this License, and\nmultiple identical Invariant Sections may be replaced with a single\ncopy.  If there are multiple Invariant Sections with the same name\nbut different contents, make the title of each such section unique\nby adding at the end of it, in parentheses, the name of the\noriginal author or publisher of that section if known, or else a\nunique number.  Make the same adjustment to the section titles in\nthe list of Invariant Sections in the license notice of the\ncombined work.\n\nIn the combination, you must combine any sections Entitled\n\"History\" in the various original documents, forming one section\nEntitled \"History\"; likewise combine any sections Entitled\n\"Acknowledgements\", and any sections Entitled \"Dedications\".  You\nmust delete all sections Entitled \"Endorsements.\"\n\n6. COLLECTIONS OF DOCUMENTS\n\nYou may make a collection consisting of the Document and other\ndocuments released under this License, and replace the individual\ncopies of this License in the various documents with a single copy\nthat is included in the collection, provided that you follow the\nrules of this License for verbatim copying of each of the documents\nin all other respects.\n\nYou may extract a single document from such a collection, and\ndistribute it individually under this License, provided you insert\na copy of this License into the extracted document, and follow this\nLicense in all other respects regarding verbatim copying of that\ndocument.\n\n7. AGGREGATION WITH INDEPENDENT WORKS\n\nA compilation of the Document or its derivatives with other\nseparate and independent documents or works, in or on a volume of a\nstorage or distribution medium, is called an \"aggregate\" if the\ncopyright resulting from the compilation is not used to limit the\nlegal rights of the compilation's users beyond what the individual\nworks permit.  When the Document is included in an aggregate, this\nLicense does not apply to the other works in the aggregate which\nare not themselves derivative works of the Document.\n\nIf the Cover Text requirement of section 3 is applicable to these\ncopies of the Document, then if the Document is less than one half\nof the entire aggregate, the Document's Cover Texts may be placed\non covers that bracket the Document within the aggregate, or the\nelectronic equivalent of covers if the Document is in electronic\nform.  Otherwise they must appear on printed covers that bracket\nthe whole aggregate.\n\n8. TRANSLATION\n\nTranslation is considered a kind of modification, so you may\ndistribute translations of the Document under the terms of section\n4.  Replacing Invariant Sections with translations requires special\npermission from their copyright holders, but you may include\ntranslations of some or all Invariant Sections in addition to the\noriginal versions of these Invariant Sections.  You may include a\ntranslation of this License, and all the license notices in the\nDocument, and any Warranty Disclaimers, provided that you also\ninclude the original English version of this License and the\noriginal versions of those notices and disclaimers.  In case of a\ndisagreement between the translation and the original version of\nthis License or a notice or disclaimer, the original version will\nprevail.\n\nIf a section in the Document is Entitled \"Acknowledgements\",\n\"Dedications\", or \"History\", the requirement (section 4) to\nPreserve its Title (section 1) will typically require changing the\nactual title.\n\n9. TERMINATION\n\nYou may not copy, modify, sublicense, or distribute the Document\nexcept as expressly provided under this License.  Any attempt\notherwise to copy, modify, sublicense, or distribute it is void,\nand will automatically terminate your rights under this License.\n\nHowever, if you cease all violation of this License, then your\nlicense from a particular copyright holder is reinstated (a)\nprovisionally, unless and until the copyright holder explicitly and\nfinally terminates your license, and (b) permanently, if the\ncopyright holder fails to notify you of the violation by some\nreasonable means prior to 60 days after the cessation.\n\nMoreover, your license from a particular copyright holder is\nreinstated permanently if the copyright holder notifies you of the\nviolation by some reasonable means, this is the first time you have\nreceived notice of violation of this License (for any work) from\nthat copyright holder, and you cure the violation prior to 30 days\nafter your receipt of the notice.\n\nTermination of your rights under this section does not terminate\nthe licenses of parties who have received copies or rights from you\nunder this License.  If your rights have been terminated and not\npermanently reinstated, receipt of a copy of some or all of the\nsame material does not give you any rights to use it.\n\n10. FUTURE REVISIONS OF THIS LICENSE\n\nThe Free Software Foundation may publish new, revised versions of\nthe GNU Free Documentation License from time to time.  Such new\nversions will be similar in spirit to the present version, but may\ndiffer in detail to address new problems or concerns.  See\n<https://www.gnu.org/licenses/>.\n\nEach version of the License is given a distinguishing version\nnumber.  If the Document specifies that a particular numbered\nversion of this License \"or any later version\" applies to it, you\nhave the option of following the terms and conditions either of\nthat specified version or of any later version that has been\npublished (not as a draft) by the Free Software Foundation.  If the\nDocument does not specify a version number of this License, you may\nchoose any version ever published (not as a draft) by the Free\nSoftware Foundation.  If the Document specifies that a proxy can\ndecide which future versions of this License can be used, that\nproxy's public statement of acceptance of a version permanently\nauthorizes you to choose that version for the Document.\n\n11. RELICENSING\n\n\"Massive Multiauthor Collaboration Site\" (or \"MMC Site\") means any\nWorld Wide Web server that publishes copyrightable works and also\nprovides prominent facilities for anybody to edit those works.  A\npublic wiki that anybody can edit is an example of such a server.\nA \"Massive Multiauthor Collaboration\" (or \"MMC\") contained in the\nsite means any set of copyrightable works thus published on the MMC\nsite.\n\n\"CC-BY-SA\" means the Creative Commons Attribution-Share Alike 3.0\nlicense published by Creative Commons Corporation, a not-for-profit\ncorporation with a principal place of business in San Francisco,\nCalifornia, as well as future copyleft versions of that license\npublished by that same organization.\n\n\"Incorporate\" means to publish or republish a Document, in whole or\nin part, as part of another Document.\n\nAn MMC is \"eligible for relicensing\" if it is licensed under this\nLicense, and if all works that were first published under this\nLicense somewhere other than this MMC, and subsequently\nincorporated in whole or in part into the MMC, (1) had no cover\ntexts or invariant sections, and (2) were thus incorporated prior\nto November 1, 2008.\n\nThe operator of an MMC Site may republish an MMC contained in the\nsite under CC-BY-SA on the same site at any time before August 1,\n2009, provided the MMC is eligible for relicensing.\n"
                },
                {
                    "name": "ADDENDUM: How to use this License for your documents",
                    "content": ""
                }
            ]
        },
        "To use this License in a document you have written, include a copy of": {
            "content": "the License in the document and put the following copyright and license\nnotices just after the title page:\n\nCopyright (C)  YEAR  YOUR NAME.\nPermission is granted to copy, distribute and/or modify this document\nunder the terms of the GNU Free Documentation License, Version 1.3\nor any later version published by the Free Software Foundation;\nwith no Invariant Sections, no Front-Cover Texts, and no Back-Cover\nTexts.  A copy of the license is included in the section entitled ``GNU\nFree Documentation License''.\n\nIf you have Invariant Sections, Front-Cover Texts and Back-Cover\nTexts, replace the \"with...Texts.\" line with this:\n\nwith the Invariant Sections being LIST THEIR TITLES, with\nthe Front-Cover Texts being LIST, and with the Back-Cover Texts\nbeing LIST.\n\nIf you have Invariant Sections without Cover Texts, or some other\ncombination of the three, merge those two alternatives to suit the\nsituation.\n\nIf your document contains nontrivial examples of program code, we\nrecommend releasing these examples in parallel under your choice of free\nsoftware license, such as the GNU General Public License, to permit\ntheir use in free software.\n",
            "subsections": []
        },
        "File: grep.info,  Node: Index,  Prev: Copying,  Up: Top": {
            "content": "",
            "subsections": []
        },
        "Index": {
            "content": "* Menu:\n\n* --:                                    Other Options.       (line   7)\n* --after-context:                       Context Line Control.\n(line  15)\n* --basic-regexp:                        grep Programs.       (line  15)\n* --before-context:                      Context Line Control.\n(line  19)\n* --binary:                              Other Options.       (line  22)\n* --binary-files:                        File and Directory Selection.\n(line  12)\n* --byte-offset:                         Output Line Prefix Control.\n(line  12)\n* --color:                               General Output Control.\n(line  14)\n* --colour:                              General Output Control.\n(line  14)\n* --context:                             Context Line Control.\n(line  24)\n* --count:                               General Output Control.\n(line   8)\n* --dereference-recursive:               File and Directory Selection.\n(line 113)\n* --devices:                             File and Directory Selection.\n(line  51)\n* --directories:                         File and Directory Selection.\n(line  62)\n* --exclude:                             File and Directory Selection.\n(line  73)\n* --exclude-dir:                         File and Directory Selection.\n(line  87)\n* --exclude-from:                        File and Directory Selection.\n(line  83)\n* --extended-regexp:                     grep Programs.       (line  20)\n* --file:                                Matching Control.    (line  17)\n* --files-with-matches:                  General Output Control.\n(line  38)\n* --files-without-match:                 General Output Control.\n(line  33)\n* --fixed-strings:                       grep Programs.       (line  25)\n* --group-separator:                     Context Line Control.\n(line  27)\n* --group-separator <1>:                 Context Line Control.\n(line  31)\n* --help:                                Generic Program Information.\n(line   7)\n* --ignore-case:                         Matching Control.    (line  26)\n* --include:                             File and Directory Selection.\n(line  97)\n* --initial-tab:                         Output Line Prefix Control.\n(line  41)\n* --invert-match:                        Matching Control.    (line  51)\n* --label:                               Output Line Prefix Control.\n(line  28)\n* --line-buffered:                       Other Options.       (line  13)\n* --line-number:                         Output Line Prefix Control.\n(line  36)\n* --line-regexp:                         Matching Control.    (line  73)\n* --max-count:                           General Output Control.\n(line  44)\n* --no-filename:                         Output Line Prefix Control.\n(line  23)\n* --no-ignore-case:                      Matching Control.    (line  44)\n* --no-messages:                         General Output Control.\n(line  95)\n* --null:                                Output Line Prefix Control.\n(line  50)\n* --null-data:                           Other Options.       (line  43)\n* --only-matching:                       General Output Control.\n(line  78)\n* --perl-regexp:                         grep Programs.       (line  30)\n* --quiet:                               General Output Control.\n(line  86)\n* --recursive:                           File and Directory Selection.\n(line 105)\n* --regexp=PATTERNS:                     Matching Control.    (line   8)\n* --silent:                              General Output Control.\n(line  86)\n* --text:                                File and Directory Selection.\n(line   8)\n* --version:                             Generic Program Information.\n(line  12)\n* --with-filename:                       Output Line Prefix Control.\n(line  18)\n* --word-regexp:                         Matching Control.    (line  56)\n* -A:                                    Context Line Control.\n(line  15)\n* -a:                                    File and Directory Selection.\n(line   8)\n* -b:                                    Output Line Prefix Control.\n(line  12)\n* -B:                                    Context Line Control.\n(line  19)\n* -c:                                    General Output Control.\n(line   8)\n* -C:                                    Context Line Control.\n(line  24)\n* -D:                                    File and Directory Selection.\n(line  51)\n* -d:                                    File and Directory Selection.\n(line  62)\n* -e:                                    Matching Control.    (line   8)\n* -E:                                    grep Programs.       (line  20)\n* -f:                                    Matching Control.    (line  17)\n* -F:                                    grep Programs.       (line  25)\n* -G:                                    grep Programs.       (line  15)\n* -H:                                    Output Line Prefix Control.\n(line  18)\n* -h:                                    Output Line Prefix Control.\n(line  23)\n* -i:                                    Matching Control.    (line  26)\n* -L:                                    General Output Control.\n(line  33)\n* -l:                                    General Output Control.\n(line  38)\n* -m:                                    General Output Control.\n(line  44)\n* -n:                                    Output Line Prefix Control.\n(line  36)\n* -NUM:                                  Context Line Control.\n(line  24)\n* -o:                                    General Output Control.\n(line  78)\n* -P:                                    grep Programs.       (line  30)\n* -q:                                    General Output Control.\n(line  86)\n* -r:                                    File and Directory Selection.\n(line 105)\n* -R:                                    File and Directory Selection.\n(line 113)\n* -s:                                    General Output Control.\n(line  95)\n* -T:                                    Output Line Prefix Control.\n(line  41)\n* -U:                                    Other Options.       (line  22)\n* -V:                                    Generic Program Information.\n(line  12)\n* -v:                                    Matching Control.    (line  51)\n* -w:                                    Matching Control.    (line  56)\n* -x:                                    Matching Control.    (line  73)\n* -y:                                    Matching Control.    (line  26)\n* -Z:                                    Output Line Prefix Control.\n(line  50)\n* -z:                                    Other Options.       (line  43)\n* ?:                                     Fundamental Structure.\n(line  19)\n* .:                                     Fundamental Structure.\n(line  11)\n* {,M}:                                  Fundamental Structure.\n(line  34)\n* {N,}:                                  Fundamental Structure.\n(line  31)\n* {N,M}:                                 Fundamental Structure.\n(line  38)\n* {N}:                                   Fundamental Structure.\n(line  28)\n* *:                                     Fundamental Structure.\n(line  22)\n* +:                                     Fundamental Structure.\n(line  25)\n* after context:                         Context Line Control.\n(line  15)\n* alnum character class:                 Character Classes and Bracket Expressions.\n(line  32)\n* alpha character class:                 Character Classes and Bracket Expressions.\n(line  37)\n* alphabetic characters:                 Character Classes and Bracket Expressions.\n(line  37)\n* alphanumeric characters:               Character Classes and Bracket Expressions.\n(line  32)\n* alternatives in regular expressions:   Fundamental Structure.\n(line  46)\n* anchoring:                             Anchoring.           (line   6)\n* asterisk:                              Fundamental Structure.\n(line  22)\n* back-reference:                        Back-references and Subexpressions.\n(line   6)\n* back-references:                       Performance.         (line  41)\n* backslash:                             Special Backslash Expressions.\n(line   6)\n* basic regular expressions:             Basic vs Extended.   (line   6)\n* before context:                        Context Line Control.\n(line  19)\n* binary files:                          File and Directory Selection.\n(line   8)\n* binary files <1>:                      File and Directory Selection.\n(line  12)\n* binary I/O:                            Other Options.       (line  22)\n* blank character class:                 Character Classes and Bracket Expressions.\n(line  42)\n* blank characters:                      Character Classes and Bracket Expressions.\n(line  42)\n* bn GREPCOLORS capability:             Environment Variables.\n(line 117)\n* braces, first argument omitted:        Fundamental Structure.\n(line  34)\n* braces, one argument:                  Fundamental Structure.\n(line  28)\n* braces, second argument omitted:       Fundamental Structure.\n(line  31)\n* braces, two arguments:                 Fundamental Structure.\n(line  38)\n* bracket expression:                    Character Classes and Bracket Expressions.\n(line   6)\n* Bugs, known:                           Known Bugs.          (line   6)\n* bugs, reporting:                       Reporting Bugs.      (line   6)\n* byte offset:                           Output Line Prefix Control.\n(line  12)\n* case insensitive search:               Matching Control.    (line  26)\n* case insensitive search <1>:           Performance.         (line  27)\n* changing name of standard input:       Output Line Prefix Control.\n(line  28)\n* character class:                       Character Classes and Bracket Expressions.\n(line   6)\n* character classes:                     Character Classes and Bracket Expressions.\n(line  31)\n* character encoding:                    Character Encoding.  (line   6)\n* character type:                        Environment Variables.\n(line 144)\n* classes of characters:                 Character Classes and Bracket Expressions.\n(line  31)\n* cntrl character class:                 Character Classes and Bracket Expressions.\n(line  45)\n* context lines:                         General Output Control.\n(line  70)\n* context lines <1>:                     Context Line Control.\n(line   6)\n* context lines <2>:                     Context Line Control.\n(line  24)\n* context lines, after match:            Context Line Control.\n(line  15)\n* context lines, before match:           Context Line Control.\n(line  19)\n* control characters:                    Character Classes and Bracket Expressions.\n(line  45)\n* copying:                               Copying.             (line   6)\n* counting lines:                        General Output Control.\n(line   8)\n* cx GREPCOLORS capability:             Environment Variables.\n(line  68)\n* device search:                         File and Directory Selection.\n(line  51)\n* digit character class:                 Character Classes and Bracket Expressions.\n(line  50)\n* digit characters:                      Character Classes and Bracket Expressions.\n(line  50)\n* directory search:                      File and Directory Selection.\n(line  62)\n* dot:                                   Fundamental Structure.\n(line  11)\n* encoding error:                        Environment Variables.\n(line 151)\n* environment variables:                 Environment Variables.\n(line  24)\n* exclude directories:                   File and Directory Selection.\n(line  87)\n* exclude files:                         File and Directory Selection.\n(line  73)\n* exclude files <1>:                     File and Directory Selection.\n(line  83)\n* exit status:                           Exit Status.         (line   6)\n* FAQ about grep usage:                  Usage.               (line  32)\n* files which don't match:               General Output Control.\n(line  33)\n* fn GREPCOLORS capability:             Environment Variables.\n(line 107)\n* fn GREPCOLORS capability <1>:         Environment Variables.\n(line 122)\n* graph character class:                 Character Classes and Bracket Expressions.\n(line  53)\n* graphic characters:                    Character Classes and Bracket Expressions.\n(line  53)\n* grep programs:                         grep Programs.       (line   6)\n* GREPCOLOR environment variable:       Environment Variables.\n(line  27)\n* GREPCOLORS environment variable:      Environment Variables.\n(line  33)\n* group separator:                       Context Line Control.\n(line  27)\n* group separator <1>:                   Context Line Control.\n(line  31)\n* hexadecimal digits:                    Character Classes and Bracket Expressions.\n(line  77)\n* highlight markers:                     Environment Variables.\n(line  27)\n* highlight markers <1>:                 Environment Variables.\n(line  33)\n* highlight, color, colour:              General Output Control.\n(line  14)\n* holes in files:                        Performance.         (line  51)\n* include files:                         File and Directory Selection.\n(line  97)\n* interval expressions:                  Fundamental Structure.\n(line  14)\n* interval expressions <1>:              Performance.         (line  32)\n* invalid regular expressions:           Problematic Expressions.\n(line   6)\n* invert matching:                       Matching Control.    (line  51)\n* LANG environment variable:             Environment Variables.\n(line  10)\n* LANG environment variable <1>:         Environment Variables.\n(line 144)\n* LANG environment variable <2>:         Environment Variables.\n(line 151)\n* LANG environment variable <3>:         Environment Variables.\n(line 160)\n* LANGUAGE environment variable:         Environment Variables.\n(line  10)\n* LANGUAGE environment variable <1>:     Environment Variables.\n(line 160)\n* language of messages:                  Environment Variables.\n(line 160)\n* LCALL environment variable:           Environment Variables.\n(line  10)\n* LCALL environment variable <1>:       Environment Variables.\n(line 144)\n* LCALL environment variable <2>:       Environment Variables.\n(line 151)\n* LCALL environment variable <3>:       Environment Variables.\n(line 160)\n* LCCOLLATE environment variable:       Environment Variables.\n(line 144)\n* LCCTYPE environment variable:         Environment Variables.\n(line 151)\n* LCMESSAGES environment variable:      Environment Variables.\n(line  10)\n* LCMESSAGES environment variable <1>:  Environment Variables.\n(line 160)\n* line buffering:                        Other Options.       (line  13)\n* line numbering:                        Output Line Prefix Control.\n(line  36)\n* ln GREPCOLORS capability:             Environment Variables.\n(line 112)\n* locales:                               Performance.         (line  20)\n* lower character class:                 Character Classes and Bracket Expressions.\n(line  56)\n* lower-case letters:                    Character Classes and Bracket Expressions.\n(line  56)\n* match expression at most M times:      Fundamental Structure.\n(line  34)\n* match expression at most once:         Fundamental Structure.\n(line  19)\n* match expression from N to M times:    Fundamental Structure.\n(line  38)\n* match expression N or more times:      Fundamental Structure.\n(line  31)\n* match expression N times:              Fundamental Structure.\n(line  28)\n* match expression one or more times:    Fundamental Structure.\n(line  25)\n* match expression zero or more times:   Fundamental Structure.\n(line  22)\n* match the whole line:                  Matching Control.    (line  73)\n* matching basic regular expressions:    grep Programs.       (line  15)\n* matching extended regular expressions: grep Programs.       (line  20)\n* matching fixed strings:                grep Programs.       (line  25)\n* matching Perl-compatible regular expressions: grep Programs.\n(line  30)\n* matching whole words:                  Matching Control.    (line  56)\n* max-count:                             General Output Control.\n(line  44)\n* mc GREPCOLORS capability:             Environment Variables.\n(line  99)\n* message language:                      Environment Variables.\n(line 160)\n* ms GREPCOLORS capability:             Environment Variables.\n(line  91)\n* MS-Windows binary I/O:                 Other Options.       (line  22)\n* mt GREPCOLORS capability:             Environment Variables.\n(line  83)\n* names of matching files:               General Output Control.\n(line  38)\n* national language support:             Environment Variables.\n(line 144)\n* national language support <1>:         Environment Variables.\n(line 160)\n* ne GREPCOLORS capability:             Environment Variables.\n(line 129)\n* NLS:                                   Environment Variables.\n(line 144)\n* no filename prefix:                    Output Line Prefix Control.\n(line  23)\n* non-ASCII matching:                    Matching Non-ASCII.  (line   6)\n* non-printable matching:                Matching Non-ASCII.  (line   6)\n* null character:                        Environment Variables.\n(line 151)\n* numeric characters:                    Character Classes and Bracket Expressions.\n(line  50)\n* only matching:                         General Output Control.\n(line  78)\n* option delimiter:                      Other Options.       (line   7)\n* ordinary characters:                   Fundamental Structure.\n(line   6)\n* patterns from file:                    Matching Control.    (line  17)\n* patterns option:                       Matching Control.    (line   8)\n* performance:                           Performance.         (line   6)\n* period:                                Fundamental Structure.\n(line  11)\n* pipelines and reading:                 Performance.         (line  59)\n* plus sign:                             Fundamental Structure.\n(line  25)\n* POSIXLYCORRECT environment variable:  Environment Variables.\n(line 165)\n* print character class:                 Character Classes and Bracket Expressions.\n(line  60)\n* print non-matching lines:              Matching Control.    (line  51)\n* printable characters:                  Character Classes and Bracket Expressions.\n(line  60)\n* punct character class:                 Character Classes and Bracket Expressions.\n(line  63)\n* punctuation characters:                Character Classes and Bracket Expressions.\n(line  63)\n* question mark:                         Fundamental Structure.\n(line  19)\n* quiet, silent:                         General Output Control.\n(line  86)\n* range expression:                      Character Classes and Bracket Expressions.\n(line  14)\n* recursive search:                      File and Directory Selection.\n(line 105)\n* recursive search <1>:                  File and Directory Selection.\n(line 113)\n* regular expressions:                   Regular Expressions. (line   6)\n* return status:                         Exit Status.         (line   6)\n* rv GREPCOLORS capability:             Environment Variables.\n(line  77)\n* searching directory trees:             File and Directory Selection.\n(line  73)\n* searching directory trees <1>:         File and Directory Selection.\n(line  83)\n* searching directory trees <2>:         File and Directory Selection.\n(line  97)\n* searching directory trees <3>:         File and Directory Selection.\n(line 105)\n* searching directory trees <4>:         File and Directory Selection.\n(line 113)\n* searching for patterns:                Introduction.        (line   6)\n* sl GREPCOLORS capability:             Environment Variables.\n(line  60)\n* space character class:                 Character Classes and Bracket Expressions.\n(line  68)\n* space characters:                      Character Classes and Bracket Expressions.\n(line  68)\n* special characters:                    Fundamental Structure.\n(line   6)\n* subexpression:                         Back-references and Subexpressions.\n(line   6)\n* suppress binary data:                  File and Directory Selection.\n(line   8)\n* suppress error messages:               General Output Control.\n(line  95)\n* symbolic links:                        File and Directory Selection.\n(line  62)\n* symbolic links <1>:                    File and Directory Selection.\n(line 105)\n* symbolic links <2>:                    File and Directory Selection.\n(line 113)\n* tab-aligned content lines:             Output Line Prefix Control.\n(line  41)\n* TERM environment variable:             Environment Variables.\n(line 172)\n* translation of message language:       Environment Variables.\n(line 160)\n* unspecified behavior in regular expressions: Problematic Expressions.\n(line   6)\n* upper character class:                 Character Classes and Bracket Expressions.\n(line  73)\n* upper-case letters:                    Character Classes and Bracket Expressions.\n(line  73)\n* usage summary, printing:               Generic Program Information.\n(line   7)\n* usage, examples:                       Usage.               (line   6)\n* using grep, Q&A:                       Usage.               (line  32)\n* variants of grep:                      grep Programs.       (line   6)\n* version, printing:                     Generic Program Information.\n(line  12)\n* whitespace characters:                 Character Classes and Bracket Expressions.\n(line  68)\n* with filename prefix:                  Output Line Prefix Control.\n(line  18)\n* xdigit character class:                Character Classes and Bracket Expressions.\n(line  77)\n* xdigit class:                          Character Classes and Bracket Expressions.\n(line  77)\n* zero-terminated file names:            Output Line Prefix Control.\n(line  50)\n* zero-terminated lines:                 Other Options.       (line  43)\n\n",
            "subsections": []
        }
    },
    "flags": [],
    "examples": [],
    "see_also": []
}