Différences

Ci-dessous, les différences entre deux révisions de la page.

--- man_de_awk [2015/12/21 21:52] – créée simon
+++ man_de_awk [2026/08/23 07:49] (Version actuelle) – supprimée - modification externe (Date inconnue) 127.0.0.1
@@ Ligne 1: / Ligne 1: @@
-==== Man de la commande "awk" ====
-<code>
-GAWK(1)                                                     Utility Commands                                                     GAWK(1)
-NAME
-       gawk - pattern scanning and processing language
-SYNOPSIS
-       gawk [ POSIX or GNU style options ] -f program-file [ -- ] file ...
-       gawk [ POSIX or GNU style options ] [ -- ] program-text file ...
-DESCRIPTION
-       Gawk  is  the GNU Project's implementation of the AWK programming language.  It conforms to the definition of the language in the
-       POSIX 1003.1 Standard.  This version in turn is based on the description in The AWK Programming Language, by Aho, Kernighan,  and
-       Weinberger.  Gawk provides the additional features found in the current version of Brian Kernighan's awk and a number of GNU-spe‐
-       cific extensions.
-       The command line consists of options to gawk itself, the AWK program text (if not supplied via the -f  or  --file  options),  and
-       values to be made available in the ARGC and ARGV pre-defined AWK variables.
-       When gawk is invoked with the --profile option, it starts gathering profiling statistics from the execution of the program.  Gawk
-       runs more slowly in this mode, and automatically produces an execution profile in the file awkprof.out when done.  See the --pro‐
-       file option, below.
-       Gawk also has an integrated debugger. An interactive debugging session can be started by supplying the --debug option to the com‐
-       mand line. In this mode of execution, gawk loads the AWK source code and then prompts for  debugging  commands.   Gawk  can  only
-       debug AWK program source provided with the -f option.  The debugger is documented in GAWK: Effective AWK Programming.
-OPTION FORMAT
-       Gawk  options  may  be  either traditional POSIX-style one letter options, or GNU-style long options.  POSIX options start with a
-       single “-”, while long options start with “--”.  Long options are provided for both GNU-specific features and for  POSIX-mandated
-       features.
-       Gawk-specific  options are typically used in long-option form.  Arguments to long options are either joined with the option by an
-       = sign, with no intervening spaces, or they may be provided in the next command line argument.  Long options may be  abbreviated,
-       as long as the abbreviation remains unique.
-       Additionally,  every  long option has a corresponding short option, so that the option's functionality may be used from within #!
-       executable scripts.
-OPTIONS
-       Gawk accepts the following options.  Standard options are listed first, followed by options for gawk extensions, listed alphabet‐
-       ically by short option.
-       -f program-file
-       --file program-file
-              Read  the AWK program source from the file program-file, instead of from the first command line argument.  Multiple -f (or
-              --file) options may be used.
-       -F fs
-       --field-separator fs
-              Use fs for the input field separator (the value of the FS predefined variable).
-       -v var=val
-       --assign var=val
-              Assign the value val to the variable var, before execution of the program begins.  Such variable values are  available  to
-              the BEGIN rule of an AWK program.
-       -b
-       --characters-as-bytes
-              Treat  all  input  data  as single-byte characters. In other words, don't pay any attention to the locale information when
-              attempting to process strings as multibyte characters.  The --posix option overrides this one.
-       -c
-       --traditional
-              Run in compatibility mode.  In compatibility mode, gawk behaves identically to Brian Kernighan's awk; none of the GNU-spe‐
-              cific extensions are recognized.  See GNU EXTENSIONS, below, for more information.
-       -C
-       --copyright
-              Print the short version of the GNU copyright information message on the standard output and exit successfully.
-       -d[file]
-       --dump-variables[=file]
-              Print  a  sorted list of global variables, their types and final values to file.  If no file is provided, gawk uses a file
-              named awkvars.out in the current directory.
-              Having a list of all the global variables is a good way to look for typographical errors in your programs.  You would also
-              use  this  option  if  you have a large program with a lot of functions, and you want to be sure that your functions don't
-              inadvertently use global variables that you meant to be local.  (This is a particularly easy mistake to make  with  simple
-              variable names like i, j, and so on.)
-       -D[file]
-       --debug[=file]
-              Enable  debugging of AWK programs.  By default, the debugger reads commands interactively from the terminal.  The optional
-              file argument specifies a file with a list of commands for the debugger to execute non-interactively.
-       -e program-text
-       --source program-text
-              Use program-text as AWK program source code.  This option allows the easy intermixing of library functions (used  via  the
-              -f  and  --file  options)  with source code entered on the command line.  It is intended primarily for medium to large AWK
-              programs used in shell scripts.
-       -E file
-       --exec file
-              Similar to -f, however, this is option is the last one processed.  This should be used with #!  scripts, particularly  for
-              CGI  applications,  to  avoid  passing in options or source code (!) on the command line from a URL.  This option disables
-              command-line variable assignments.
-       -g
-       --gen-pot
-              Scan and parse the AWK program, and generate a GNU .pot (Portable Object Template) format file  on  standard  output  with
-              entries for all localizable strings in the program.  The program itself is not executed.  See the GNU gettext distribution
-              for more information on .pot files.
-       -h
-       --help Print a relatively short summary of the available options on the standard output.  (Per the GNU  Coding  Standards,  these
-              options cause an immediate, successful exit.)
-       -i include-file
-       --include include-file
-              Load  an awk source library.  This searches for the library using the AWKPATH environment variable.  If the initial search
-              fails, another attempt will be made after appending the .awk suffix.  The file will be loaded only once (i.e.,  duplicates
-              are eliminated), and the code does not constitute the main program source.
-       -l lib
-       --load lib
-              Load  a  shared  library  lib.   This  searches for the library using the AWKLIBPATH environment variable.  If the initial
-              search fails, another attempt will be made after appending the default  shared  library  suffix  for  the  platform.   The
-              library initialization routine is expected to be named dl_load().
-       -L [value]
-       --lint[=value]
-              Provide  warnings  about constructs that are dubious or non-portable to other AWK implementations.  With an optional argu‐
-              ment of fatal, lint warnings become fatal errors.  This may be drastic, but its use will certainly encourage the  develop‐
-              ment  of cleaner AWK programs.  With an optional argument of invalid, only warnings about things that are actually invalid
-              are issued. (This is not fully implemented yet.)
-       -M
-       --bignum
-              Force arbitrary precision arithmetic on numbers. This option has no effect if gawk is not compiled to use the GNU MPFR and
-              MP libraries.
-       -n
-       --non-decimal-data
-              Recognize octal and hexadecimal values in input data.  Use this option with great caution!
-       -N
-       --use-lc-numeric
-              This  forces  gawk  to  use  the  locale's  decimal  point character when parsing input data.  Although the POSIX standard
-              requires this behavior, and gawk does so when --posix is in effect, the default is to follow traditional behavior and  use
-              a period as the decimal point, even in locales where the period is not the decimal point character.  This option overrides
-              the default behavior, without the full draconian strictness of the --posix option.
-       -o[file]
-       --pretty-print[=file]
-              Output a pretty printed version of the program to file.  If no file is provided, gawk uses a file named awkprof.out in the
-              current directory.
-       -O
-       --optimize
-              Enable  optimizations  upon the internal representation of the program.  Currently, this includes simple constant-folding,
-              and tail call elimination for recursive functions. The gawk maintainer hopes to add additional optimizations over time.
-       -p[prof-file]
-       --profile[=prof-file]
-              Start a profiling session, and send the profiling data to prof-file.  The default is awkprof.out.   The  profile  contains
-              execution  counts of each statement in the program in the left margin and function call counts for each user-defined func‐
-              tion.
-       -P
-       --posix
-              This turns on compatibility mode, with the following additional restrictions:
-              · \x escape sequences are not recognized.
-              · Only space and tab act as field separators when FS is set to a single space, newline does not.
-              · You cannot continue lines after ?  and :.
-              · The synonym func for the keyword function is not recognized.
-              · The operators ** and **= cannot be used in place of ^ and ^=.
-       -r
-       --re-interval
-              Enable the use of interval expressions in regular expression matching (see Regular Expressions, below).  Interval  expres‐
-              sions  were not traditionally available in the AWK language.  The POSIX standard added them, to make awk and egrep consis‐
-              tent with each other.  They are enabled by default, but this option remains for use with --traditional.
-       -S
-       --sandbox
-              Runs gawk in sandbox mode, disabling the system() function, input redirection with getline, output redirection with  print
-              and  printf,  and  loading  dynamic extensions.  Command execution (through pipelines) is also disabled.  This effectively
-              blocks a script from accessing local resources (except for the files specified on the command line).
-       -t
-       --lint-old
-              Provide warnings about constructs that are not portable to the original version of UNIX awk.
-       -V
-       --version
-              Print version information for this particular copy of gawk on the standard output.  This is useful mainly for  knowing  if
-              the  current copy of gawk on your system is up to date with respect to whatever the Free Software Foundation is distribut‐
-              ing.  This is also useful when reporting bugs.  (Per the GNU Coding Standards, these options cause an immediate,  success‐
-              ful exit.)
-       --     Signal  the end of options. This is useful to allow further arguments to the AWK program itself to start with a “-”.  This
-              provides consistency with the argument parsing convention used by most other POSIX programs.
-       In compatibility mode, any other options are flagged as invalid, but are otherwise ignored.  In normal operation, as long as pro‐
-       gram text has been supplied, unknown options are passed on to the AWK program in the ARGV array for processing.  This is particu‐
-       larly useful for running AWK programs via the “#!” executable interpreter mechanism.
-       For POSIX compatibility, the -W option may be used, followed by the name of a long option.
-AWK PROGRAM EXECUTION
-       An AWK program consists of a sequence of pattern-action statements and optional function definitions.
-              @include "filename"
-              @load "filename"
-              pattern   { action statements }
-              function name(parameter list) { statements }
-       Gawk first reads the program source from the program-file(s) if specified, from arguments to --source, or  from  the  first  non-
-       option argument on the command line.  The -f and --source options may be used multiple times on the command line.  Gawk reads the
-       program text as if all the program-files and command line source texts had been concatenated together.  This is useful for build‐
-       ing  libraries  of  AWK  functions,  without having to include them in each new AWK program that uses them.  It also provides the
-       ability to mix library functions with command line programs.
-       In addition, lines beginning with @include may be used to include other source files into your program, making library  use  even
-       easier.  This is equivalent to using the -i option.
-       Lines beginning with @load may be used to load shared libraries into your program.  This is equivalent to using the -l option.
-       The  environment  variable AWKPATH specifies a search path to use when finding source files named with the -f and -i options.  If
-       this variable does not exist, the default path is ".:/usr/local/share/awk".  (The actual directory may vary, depending  upon  how
-       gawk was built and installed.)  If a file name given to the -f option contains a “/” character, no path search is performed.
-       The  environment  variable AWKLIBPATH specifies a search path to use when finding source files named with the -l option.  If this
-       variable does not exist, the default path is ".:/usr/local/lib/gawk".  (The actual directory may vary, depending  upon  how  gawk
-       was built and installed.)
-       Gawk  executes  AWK  programs in the following order.  First, all variable assignments specified via the -v option are performed.
-       Next, gawk compiles the program into an internal form.  Then, gawk executes the code in the BEGIN rule(s) (if any), and then pro‐
-       ceeds  to read each file named in the ARGV array (up to ARGV[ARGC]).  If there are no files named on the command line, gawk reads
-       the standard input.
-       If a filename on the command line has the form var=val it is treated as a variable assignment.  The variable var will be assigned
-       the value val.  (This happens after any BEGIN rule(s) have been run.)  Command line variable assignment is most useful for dynam‐
-       ically assigning values to the variables AWK uses to control how input is broken into fields and records.  It is also useful  for
-       controlling state if multiple passes are needed over a single data file.
-       If the value of a particular element of ARGV is empty (""), gawk skips over it.
-       For  each  input  file, if a BEGINFILE rule exists, gawk executes the associated code before processing the contents of the file.
-       Similarly, gawk executes the code associated with ENDFILE after processing the file.
-       For each record in the input, gawk tests to see if it matches any pattern in the AWK program.  For each pattern that  the  record
-       matches, gawk executes the associated action.  The patterns are tested in the order they occur in the program.
-       Finally, after all the input is exhausted, gawk executes the code in the END rule(s) (if any).
-   Command Line Directories
-       According to POSIX, files named on the awk command line must be text files.  The behavior is ``undefined'' if they are not.  Most
-       versions of awk treat a directory on the command line as a fatal error.
-       Starting with version 4.0 of gawk, a directory on the command line produces a warning, but is otherwise skipped.   If  either  of
-       the --posix or --traditional options is given, then gawk reverts to treating directories on the command line as a fatal error.
-VARIABLES, RECORDS AND FIELDS
-       AWK  variables are dynamic; they come into existence when they are first used.  Their values are either floating-point numbers or
-       strings, or both, depending upon how they are used.  AWK also has one dimensional arrays; arrays with multiple dimensions may  be
-       simulated.   Gawk  provides  true  arrays of arrays; see Arrays, below.  Several pre-defined variables are set as a program runs;
-       these are described as needed and summarized below.
-   Records
-       Normally, records are separated by newline characters.  You can control how records are separated  by  assigning  values  to  the
-       built-in  variable  RS.  If RS is any single character, that character separates records.  Otherwise, RS is a regular expression.
-       Text in the input that matches this regular expression separates the record.  However, in  compatibility  mode,  only  the  first
-       character  of  its  string  value is used for separating records.  If RS is set to the null string, then records are separated by
-       blank lines.  When RS is set to the null string, the newline character always acts as a field separator, in addition to  whatever
-       value FS may have.
-   Fields
-       As  each input record is read, gawk splits the record into fields, using the value of the FS variable as the field separator.  If
-       FS is a single character, fields are separated by that character.  If FS is the  null  string,  then  each  individual  character
-       becomes  a  separate  field.  Otherwise, FS is expected to be a full regular expression.  In the special case that FS is a single
-       space, fields are separated by runs of spaces and/or tabs and/or newlines.  (But see the  section  POSIX  COMPATIBILITY,  below).
-       NOTE:  The value of IGNORECASE (see below) also affects how fields are split when FS is a regular expression, and how records are
-       separated when RS is a regular expression.
-       If the FIELDWIDTHS variable is set to a space separated list of numbers, each field is expected to have  fixed  width,  and  gawk
-       splits  up the record using the specified widths.  The value of FS is ignored.  Assigning a new value to FS or FPAT overrides the
-       use of FIELDWIDTHS.
-       Similarly, if the FPAT variable is set to a string representing a regular expression, each field is made up of text that  matches
-       that regular expression. In this case, the regular expression describes the fields themselves, instead of the text that separates
-       the fields.  Assigning a new value to FS or FIELDWIDTHS overrides the use of FPAT.
-       Each field in the input record may be referenced by its position: $1, $2, and so on.  $0 is the whole record.  Fields need not be
-       referenced by constants:
-              n = 5
-              print $n
-       prints the fifth field in the input record.
-       The variable NF is set to the total number of fields in the input record.
-       References  to  non-existent fields (i.e., fields after $NF) produce the null-string.  However, assigning to a non-existent field
-       (e.g., $(NF+2) = 5) increases the value of NF, creates any intervening fields with the null string as their  values,  and  causes
-       the  value  of  $0 to be recomputed, with the fields being separated by the value of OFS.  References to negative numbered fields
-       cause a fatal error.  Decrementing NF causes the values of fields past the new value to be lost, and the value of $0 to be recom‐
-       puted, with the fields being separated by the value of OFS.
-       Assigning a value to an existing field causes the whole record to be rebuilt when $0 is referenced.  Similarly, assigning a value
-       to $0 causes the record to be resplit, creating new values for the fields.
-   Built-in Variables
-       Gawk's built-in variables are:
-       ARGC        The number of command line arguments (does not include options to gawk, or the program source).
-       ARGIND      The index in ARGV of the current file being processed.
-       ARGV        Array of command line arguments.  The array is indexed from 0 to ARGC - 1.  Dynamically changing the contents of ARGV
-                   can control the files used for data.
-       BINMODE     On  non-POSIX  systems,  specifies use of “binary” mode for all file I/O.  Numeric values of 1, 2, or 3, specify that
-                   input files, output files, or all files, respectively, should use binary I/O.  String values of "r", or  "w"  specify
-                   that  input  files, or output files, respectively, should use binary I/O.  String values of "rw" or "wr" specify that
-                   all files should use binary I/O.  Any other string value is treated as "rw", but generates a warning message.
-       CONVFMT     The conversion format for numbers, "%.6g", by default.
-       ENVIRON     An array containing the values of the current environment.  The array is indexed by the environment  variables,  each
-                   element  being  the value of that variable (e.g., ENVIRON["HOME"] might be "/home/arnold").  Changing this array does
-                   not affect the environment seen by programs which gawk spawns via redirection or the system() function.
-       ERRNO       If a system error occurs either doing a redirection for getline, during a read for getline, or during a close(), then
-                   ERRNO will contain a string describing the error.  The value is subject to translation in non-English locales.
-       FIELDWIDTHS A  whitespace separated list of field widths.  When set, gawk parses the input into fields of fixed width, instead of
-                   using the value of the FS variable as the field separator.  See Fields, above.
-       FILENAME    The name of the current input file.  If no files are specified on the command line, the value  of  FILENAME  is  “-”.
-                   However, FILENAME is undefined inside the BEGIN rule (unless set by getline).
-       FNR         The input record number in the current input file.
-       FPAT        A regular expression describing the contents of the fields in a record.  When set, gawk parses the input into fields,
-                   where the fields match the regular expression, instead of using the value of the FS variable as the field  separator.
-                   See Fields, above.
-       FS          The input field separator, a space by default.  See Fields, above.
-       FUNCTAB     An  array  whose indices and corresponding values are the names of all the user-defined or extension functions in the
-                   program.  NOTE: You may not use the delete statement with the FUNCTAB array.
-       IGNORECASE  Controls the case-sensitivity of all regular expression and string operations.  If IGNORECASE has a  non-zero  value,
-                   then  string  comparisons and pattern matching in rules, field splitting with FS and FPAT, record separating with RS,
-                   regular expression matching with ~ and !~, and the gensub(), gsub(), index(), match(), patsplit(), split(), and sub()
-                   built-in  functions  all  ignore  case  when  doing  regular  expression operations.  NOTE: Array subscripting is not
-                   affected.  However, the asort() and asorti() functions are affected.
-                   Thus, if IGNORECASE is not equal to zero, /aB/ matches all of the strings "ab", "aB", "Ab", and "AB".   As  with  all
-                   AWK  variables, the initial value of IGNORECASE is zero, so all regular expression and string operations are normally
-                   case-sensitive.
-       LINT        Provides dynamic control of the --lint option from within an AWK program.  When true, gawk prints lint warnings. When
-                   false,  it  does  not.   When  assigned  the  string  value  "fatal", lint warnings become fatal errors, exactly like
-                   --lint=fatal.  Any other true value just prints warnings.
-       NF          The number of fields in the current input record.
-       NR          The total number of input records seen so far.
-       OFMT        The output format for numbers, "%.6g", by default.
-       OFS         The output field separator, a space by default.
-       ORS         The output record separator, by default a newline.
-       PREC        The working precision of arbitrary precision floating-point numbers, 53 by default.
-       PROCINFO    The elements of this array provide access to information about the running AWK program.  On some systems,  there  may
-                   be  elements in the array, "group1" through "groupn" for some n, which is the number of supplementary groups that the
-                   process has.  Use the in operator to test for these elements.  The following elements are guaranteed to be available:
-                   PROCINFO["egid"]    The value of the getegid(2) system call.
-                   PROCINFO["strftime"]
-                                       The default time format string for strftime().
-                   PROCINFO["euid"]    The value of the geteuid(2) system call.
-                   PROCINFO["FS"]      "FS" if field splitting with FS is in effect, "FPAT" if field splitting with FPAT is  in  effect,
-                                       or "FIELDWIDTHS" if field splitting with FIELDWIDTHS is in effect.
-                   PROCINFO["identifiers"]
-                                       A  subarray,  indexed  by  the names of all identifiers used in the text of the AWK program.  The
-                                       values indicate what gawk knows about the identifiers after it has finished parsing the  program;
-                                       they  are  not  updated while the program runs.  For each identifier, the value of the element is
-                                       one of the following:
-                                       "array"
-                                              The identifier is an array.
-                                       "extension"
-                                              The identifier is an extension function loaded via @load.
-                                       "scalar"
-                                              The identifier is a scalar.
-                                       "untyped"
-                                              The identifier is untyped (could be used as a scalar or array, gawk doesn't know yet).
-                                       "user" The identifier is a user-defined function.
-                   PROCINFO["gid"]     The value of the getgid(2) system call.
-                   PROCINFO["pgrpid"]  The process group ID of the current process.
-                   PROCINFO["pid"]     The process ID of the current process.
-                   PROCINFO["ppid"]    The parent process ID of the current process.
-                   PROCINFO["uid"]     The value of the getuid(2) system call.
-                   PROCINFO["sorted_in"]
-                                       If this element exists in PROCINFO, then its value controls the order in which array elements are
-                                       traversed  in  for  loops.  Supported values are "@ind_str_asc", "@ind_num_asc", "@val_type_asc",
-                                       "@val_str_asc",    "@val_num_asc",    "@ind_str_desc",     "@ind_num_desc",     "@val_type_desc",
-                                       "@val_str_desc", "@val_num_desc", and "@unsorted".  The value can also be the name of any compar‐
-                                       ison function defined as follows:
-                                            function cmp_func(i1, v1, i2, v2)
-                                       where i1 and i2 are the indices, and v1 and v2 are the corresponding values of the  two  elements
-                                       being  compared.   It should return a number less than, equal to, or greater than 0, depending on
-                                       how the elements of the array are to be ordered.
-                   PROCINFO["input", "READ_TIMEOUT"]
-                                       The timeout in milliseconds for reading data from input, where input is a redirection string or a
-                                       filename. A value of zero or less than zero means no timeout.
-                   PROCINFO["mpfr_version"]
-                                       The  version  of  the GNU MPFR library used for arbitrary precision number support in gawk.  This
-                                       entry is not present if MPFR support is not compiled into gawk.
-                   PROCINFO["gmp_version"]
-                                       The version of the GNU MP library used for arbitrary precision  number  support  in  gawk.   This
-                                       entry is not present if MPFR support is not compiled into gawk.
-                   PROCINFO["prec_max"]
-                                       The  maximum  precision  supported by the GNU MPFR library for arbitrary precision floating-point
-                                       numbers.  This entry is not present if MPFR support is not compiled into gawk.
-                   PROCINFO["prec_min"]
-                                       The minimum precision allowed by the GNU MPFR library for arbitrary precision floating-point num‐
-                                       bers.  This entry is not present if MPFR support is not compiled into gawk.
-                   PROCINFO["api_major"]
-                                       The  major version of the extension API.  This entry is not present if loading dynamic extensions
-                                       is not available.
-                   PROCINFO["api_minor"]
-                                       The minor version of the extension API.  This entry is not present if loading dynamic  extensions
-                                       is not available.
-                   PROCINFO["version"] the version of gawk.
-       ROUNDMODE   The  rounding  mode  to  use  for arbitrary precision arithmetic on numbers, by default "N" (IEEE-754 roundTiesToEven
-                   mode).  The accepted values are "N" or "n" for roundTiesToEven, "U" or "u" for roundTowardPositive, "D"  or  "d"  for
-                   roundTowardNegative,  "Z" or "z" for roundTowardZero, and if your version of GNU MPFR library supports it, "A" or "a"
-                   for roundTiesToAway.
-       RS          The input record separator, by default a newline.
-       RT          The record terminator.  Gawk sets RT to the input text that matched the character or regular expression specified  by
-                   RS.
-       RSTART      The  index  of  the first character matched by match(); 0 if no match.  (This implies that character indices start at
-                   one.)
-       RLENGTH     The length of the string matched by match(); -1 if no match.
-       SUBSEP      The character used to separate multiple subscripts in array elements, by default "\034".
-       SYMTAB      An array whose indices are the names of all currently defined global variables and arrays in the program.  The  array
-                   may be used for indirect access to read or write the value of a variable:
-                        foo = 5
-                        SYMTAB["foo"] = 4
-                        print foo    # prints 4
-                   The isarray() function may be used to test if an element in SYMTAB is an array.  You may not use the delete statement
-                   with the SYMTAB array.
-       TEXTDOMAIN  The text domain of the AWK program; used to find the localized translations for the program's strings.
-   Arrays
-       Arrays are subscripted with an expression between square brackets ([ and ]).  If the expression is an expression list (expr, expr
-       ...)  then the array subscript is a string consisting of the concatenation of the (string) value of each expression, separated by
-       the value of the SUBSEP variable.  This facility is used to simulate multiply dimensioned arrays.  For example:
-              i = "A"; j = "B"; k = "C"
-              x[i, j, k] = "hello, world\n"
-       assigns the string "hello, world\n" to the element of the array x which is indexed by the string "A\034B\034C".   All  arrays  in
-       AWK are associative, i.e., indexed by string values.
-       The special operator in may be used to test if an array has an index consisting of a particular value:
-              if (val in array)
-                   print array[val]
-       If the array has multiple subscripts, use (i, j) in array.
-       The  in construct may also be used in a for loop to iterate over all the elements of an array.  However, the (i, j) in array con‐
-       struct only works in tests, not in for loops.
-       An element may be deleted from an array using the delete statement.  The delete statement may also be used to delete  the  entire
-       contents of an array, just by specifying the array name without a subscript.
-       gawk supports true multidimensional arrays. It does not require that such arrays be ``rectangular'' as in C or C++.  For example:
-              a[1] = 5
-              a[2][1] = 6
-              a[2][2] = 7
-       NOTE:  You  may need to tell gawk that an array element is really a subarray in order to use it where gawk expects an array (such
-       as in the second argument to split()).  You can do this by creating an element in the subarray and  then  deleting  it  with  the
-       delete statement.
-   Variable Typing And Conversion
-       Variables  and  fields  may be (floating point) numbers, or strings, or both.  How the value of a variable is interpreted depends
-       upon its context.  If used in a numeric expression, it will be treated as a number; if used as a string it will be treated  as  a
-       string.
-       To  force  a variable to be treated as a number, add 0 to it; to force it to be treated as a string, concatenate it with the null
-       string.
-       Uninitialized variables have the numeric value 0 and the string value "" (the null, or empty, string).
-       When a string must be converted to a number, the conversion is accomplished using strtod(3).  A number is converted to  a  string
-       by  using  the  value of CONVFMT as a format string for sprintf(3), with the numeric value of the variable as the argument.  How‐
-       ever, even though all numbers in AWK are floating-point, integral values are always converted as integers.  Thus, given
-              CONVFMT = "%2.2f"
-              a = 12
-              b = a ""
-       the variable b has a string value of "12" and not "12.00".
-       NOTE: When operating in POSIX mode (such as with the --posix option), beware that locale settings may interfere with the way dec‐
-       imal  numbers  are  treated:  the decimal separator of the numbers you are feeding to gawk must conform to what your locale would
-       expect, be it a comma (,) or a period (.).
-       Gawk performs comparisons as follows: If two variables are numeric, they are compared numerically.  If one value is  numeric  and
-       the  other  has  a  string  value that is a “numeric string,” then comparisons are also done numerically.  Otherwise, the numeric
-       value is converted to a string and a string comparison is performed.  Two strings are compared, of course, as strings.
-       Note that string constants, such as "57", are not numeric strings, they are string constants.  The idea of “numeric string”  only
-       applies  to  fields,  getline input, FILENAME, ARGV elements, ENVIRON elements and the elements of an array created by split() or
-       patsplit() that are numeric strings.  The basic idea is that user input, and only user  input,  that  looks  numeric,  should  be
-       treated that way.
-   Octal and Hexadecimal Constants
-       You  may  use C-style octal and hexadecimal constants in your AWK program source code.  For example, the octal value 011 is equal
-       to decimal 9, and the hexadecimal value 0x11 is equal to decimal 17.
-   String Constants
-       String constants in AWK are sequences of characters enclosed between double  quotes  (like  "value").   Within  strings,  certain
-       escape sequences are recognized, as in C.  These are:
-       \\   A literal backslash.
-       \a   The “alert” character; usually the ASCII BEL character.
-       \b   Backspace.
-       \f   Form-feed.
-       \n   Newline.
-       \r   Carriage return.
-       \t   Horizontal tab.
-       \v   Vertical tab.
-       \xhex digits
-            The character represented by the string of hexadecimal digits following the \x.  As in ISO C, all following hexadecimal dig‐
-            its are considered part of the escape sequence.  (This feature should tell us something about language design by committee.)
-            E.g., "\x1B" is the ASCII ESC (escape) character.
-       \ddd The  character represented by the 1-, 2-, or 3-digit sequence of octal digits.  E.g., "\033" is the ASCII ESC (escape) char‐
-            acter.
-       \c   The literal character c.
-       The escape sequences may also be used inside constant regular expressions (e.g., /[ \t\f\n\r\v]/ matches whitespace characters).
-       In compatibility mode, the characters represented by octal and hexadecimal escape sequences are treated literally  when  used  in
-       regular expression constants.  Thus, /a\52b/ is equivalent to /a\*b/.
-PATTERNS AND ACTIONS
-       AWK  is  a  line-oriented  language.   The  pattern comes first, and then the action.  Action statements are enclosed in { and }.
-       Either the pattern may be missing, or the action may be missing, but, of course, not both.  If the pattern is missing, the action
-       is executed for every single record of input.  A missing action is equivalent to
-              { print }
-       which prints the entire record.
-       Comments  begin  with  the  # character, and continue until the end of the line.  Blank lines may be used to separate statements.
-       Normally, a statement ends with a newline, however, this is not the case for lines ending in a comma, {, ?, :, &&, or ||.   Lines
-       ending  in  do  or  else also have their statements automatically continued on the following line.  In other cases, a line can be
-       continued by ending it with a “\”, in which case the newline is ignored.
-       Multiple statements may be put on one line by separating them with a “;”.  This applies to both the statements within the  action
-       part of a pattern-action pair (the usual case), and to the pattern-action statements themselves.
-   Patterns
-       AWK patterns may be one of the following:
-              BEGIN
-              END
-              BEGINFILE
-              ENDFILE
-              /regular expression/
-              relational expression
-              pattern && pattern
-              pattern || pattern
-              pattern ? pattern : pattern
-              (pattern)
-              ! pattern
-              pattern1, pattern2
-       BEGIN  and  END are two special kinds of patterns which are not tested against the input.  The action parts of all BEGIN patterns
-       are merged as if all the statements had been written in a single BEGIN rule.  They are executed before any of the input is  read.
-       Similarly,  all  the  END rules are merged, and executed when all the input is exhausted (or when an exit statement is executed).
-       BEGIN and END patterns cannot be combined with other patterns in pattern expressions.  BEGIN and END patterns cannot have missing
-       action parts.
-       BEGINFILE  and  ENDFILE are additional special patterns whose bodies are executed before reading the first record of each command
-       line input file and after reading the last record of each file.  Inside the BEGINFILE rule, the value of ERRNO will be the  empty
-       string  if  the file was opened successfully.  Otherwise, there is some problem with the file and the code should use nextfile to
-       skip it. If that is not done, gawk produces its usual fatal error for files that cannot be opened.
-       For /regular expression/ patterns, the associated statement is executed for each input record that matches  the  regular  expres‐
-       sion.  Regular expressions are the same as those in egrep(1), and are summarized below.
-       A  relational expression may use any of the operators defined below in the section on actions.  These generally test whether cer‐
-       tain fields match certain regular expressions.
-       The &&, ||, and !  operators are logical AND, logical OR, and logical NOT, respectively, as in C.  They do short-circuit  evalua‐
-       tion, also as in C, and are used for combining more primitive pattern expressions.  As in most languages, parentheses may be used
-       to change the order of evaluation.
-       The ?: operator is like the same operator in C.  If the first pattern is true then the pattern used for  testing  is  the  second
-       pattern, otherwise it is the third.  Only one of the second and third patterns is evaluated.
-       The pattern1, pattern2 form of an expression is called a range pattern.  It matches all input records starting with a record that
-       matches pattern1, and continuing until a record that matches pattern2, inclusive.  It does not combine with  any  other  sort  of
-       pattern expression.
-   Regular Expressions
-       Regular expressions are the extended kind found in egrep.  They are composed of characters as follows:
-       c          Matches the non-metacharacter c.
-       \c         Matches the literal character c.
-       .          Matches any character including newline.
-       ^          Matches the beginning of a string.
-       $          Matches the end of a string.
-       [abc...]   A character list: matches any of the characters abc....  You may include a range of characters by separating them with
-                  a dash.
-       [^abc...]  A negated character list: matches any character except abc....
-       r1|r2      Alternation: matches either r1 or r2.
-       r1r2       Concatenation: matches r1, and then r2.
-       r+         Matches one or more r's.
-       r*         Matches zero or more r's.
-       r?         Matches zero or one r's.
-       (r)        Grouping: matches r.
-       r{n}
-       r{n,}
-       r{n,m}     One or two numbers inside braces denote an interval expression.  If there is one number in the braces,  the  preceding
-                  regular  expression r is repeated n times.  If there are two numbers separated by a comma, r is repeated n to m times.
-                  If there is one number followed by a comma, then r is repeated at least n times.
-       \y         Matches the empty string at either the beginning or the end of a word.
-       \B         Matches the empty string within a word.
-       \<         Matches the empty string at the beginning of a word.
-       \>         Matches the empty string at the end of a word.
-       \s         Matches any whitespace character.
-       \S         Matches any nonwhitespace character.
-       \w         Matches any word-constituent character (letter, digit, or underscore).
-       \W         Matches any character that is not word-constituent.
-       \`         Matches the empty string at the beginning of a buffer (string).
-       \'         Matches the empty string at the end of a buffer.
-       The escape sequences that are valid in string constants (see String Constants) are also valid in regular expressions.
-       Character classes are a feature introduced in the POSIX standard.  A character class is a special notation for  describing  lists
-       of  characters that have a specific attribute, but where the actual characters themselves can vary from country to country and/or
-       from character set to character set.  For example, the notion of what is an alphabetic  character  differs  in  the  USA  and  in
-       France.
-       A  character  class  is only valid in a regular expression inside the brackets of a character list.  Character classes consist of
-       [:, a keyword denoting the class, and :].  The character classes defined by the POSIX standard are:
-       [:alnum:]  Alphanumeric characters.
-       [:alpha:]  Alphabetic characters.
-       [:blank:]  Space or tab characters.
-       [:cntrl:]  Control characters.
-       [:digit:]  Numeric characters.
-       [:graph:]  Characters that are both printable and visible.  (A space is printable, but not visible, while an a is both.)
-       [:lower:]  Lowercase alphabetic characters.
-       [:print:]  Printable characters (characters that are not control characters.)
-       [:punct:]  Punctuation characters (characters that are not letter, digits, control characters, or space characters).
-       [:space:]  Space characters (such as space, tab, and formfeed, to name a few).
-       [:upper:]  Uppercase alphabetic characters.
-       [:xdigit:] Characters that are hexadecimal digits.
-       For example, before the POSIX standard, to match alphanumeric characters, you would have had to  write  /[A-Za-z0-9]/.   If  your
-       character  set  had  other alphabetic characters in it, this would not match them, and if your character set collated differently
-       from ASCII, this might not even match the ASCII alphanumeric characters.   With  the  POSIX  character  classes,  you  can  write
-       /[[:alnum:]]/, and this matches the alphabetic and numeric characters in your character set, no matter what it is.
-       Two  additional  special sequences can appear in character lists.  These apply to non-ASCII character sets, which can have single
-       symbols (called collating elements) that are represented with more than one character, as well as  several  characters  that  are
-       equivalent for collating, or sorting, purposes.  (E.g., in French, a plain “e” and a grave-accented “`” are equivalent.)
-       Collating Symbols
-              A  collating symbol is a multi-character collating element enclosed in [.  and .].  For example, if ch is a collating ele‐
-              ment, then [[.ch.]]  is a regular expression that matches this collating element, while [ch] is a regular expression  that
-              matches either c or h.
-       Equivalence Classes
-              An  equivalence  class is a locale-specific name for a list of characters that are equivalent.  The name is enclosed in [=
-              and =].  For example, the name e might be used to represent all of “e,” “´,” and “`.”  In this case, [[=e=]] is a  regular
-              expression that matches any of e, ´, or `.
-       These  features  are  very valuable in non-English speaking locales.  The library functions that gawk uses for regular expression
-       matching currently only recognize POSIX character classes; they do not recognize collating symbols or equivalence classes.
-       The \y, \B, \<, \>, \s, \S, \w, \W, \`, and \' operators are specific to gawk; they are extensions based on facilities in the GNU
-       regular expression libraries.
-       The various command line options control how gawk interprets characters in regular expressions.
-       No options
-              In  the  default case, gawk provides all the facilities of POSIX regular expressions and the GNU regular expression opera‐
-              tors described above.
-       --posix
-              Only POSIX regular expressions are supported, the GNU operators are not special.  (E.g., \w matches a literal w).
-       --traditional
-              Traditional UNIX awk regular expressions are matched.  The GNU operators are not special, and interval expressions are not
-              available.   Characters  described by octal and hexadecimal escape sequences are treated literally, even if they represent
-              regular expression metacharacters.
-       --re-interval
-              Allow interval expressions in regular expressions, even if --traditional has been provided.
-   Actions
-       Action statements are enclosed in braces, { and }.  Action statements consist of the usual assignment, conditional,  and  looping
-       statements found in most languages.  The operators, control statements, and input/output statements available are patterned after
-       those in C.
-   Operators
-       The operators in AWK, in order of decreasing precedence, are:
-       (...)       Grouping
-       $           Field reference.
-       ++ --       Increment and decrement, both prefix and postfix.
-       ^           Exponentiation (** may also be used, and **= for the assignment operator).
-       + - !       Unary plus, unary minus, and logical negation.
-       * / %       Multiplication, division, and modulus.
-       + -         Addition and subtraction.
-       space       String concatenation.
-       |   |&      Piped I/O for getline, print, and printf.
-       < > <= >= != ==
-                   The regular relational operators.
-       ~ !~        Regular expression match, negated match.  NOTE: Do not use a constant regular expression  (/foo/)  on  the  left-hand
-                   side  of  a ~ or !~.  Only use one on the right-hand side.  The expression /foo/ ~ exp has the same meaning as (($0 ~
-                   /foo/) ~ exp).  This is usually not what you want.
-       in          Array membership.
-       &&          Logical AND.
-       ||          Logical OR.
-       ?:          The C conditional expression.  This has the form expr1 ? expr2 : expr3.  If expr1 is true, the value of  the  expres‐
-                   sion is expr2, otherwise it is expr3.  Only one of expr2 and expr3 is evaluated.
-       = += -= *= /= %= ^=
-                   Assignment.  Both absolute assignment (var = value) and operator-assignment (the other forms) are supported.
-   Control Statements
-       The control statements are as follows:
-              if (condition) statement [ else statement ]
-              while (condition) statement
-              do statement while (condition)
-              for (expr1; expr2; expr3) statement
-              for (var in array) statement
-              break
-              continue
-              delete array[index]
-              delete array
-              exit [ expression ]
-              { statements }
-              switch (expression) {
-              case value|regex : statement
-              ...
-              [ default: statement ]
-              }
-   I/O Statements
-       The input/output statements are as follows:
-       close(file [, how])   Close  file,  pipe  or  co-process.  The optional how should only be used when closing one end of a two-way
-                             pipe to a co-process.  It must be a string value, either "to" or "from".
-       getline               Set $0 from next input record; set NF, NR, FNR, RT.
-       getline <file         Set $0 from next record of file; set NF, RT.
-       getline var           Set var from next input record; set NR, FNR, RT.
-       getline var <file     Set var from next record of file, RT.
-       command | getline [var]
-                             Run command piping the output either into $0 or var, as above, and RT.
-       command |& getline [var]
-                             Run command as a co-process piping the output either into $0 or var, as above, and RT.  Co-processes are  a
-                             gawk extension.  (command can also be a socket.  See the subsection Special File Names, below.)
-       next                  Stop  processing  the  current input record.  The next input record is read and processing starts over with
-                             the first pattern in the AWK program.  Upon reaching the end of the  input  data,  gawk  executes  any  END
-                             rule(s).
-       nextfile              Stop  processing the current input file.  The next input record read comes from the next input file.  FILE‐
-                             NAME and ARGIND are updated, FNR is reset to 1, and processing starts over with the first  pattern  in  the
-                             AWK program.  Upon reaching the end of the input data, gawk executes any END rule(s).
-       print                 Print the current record.  The output record is terminated with the value of ORS.
-       print expr-list       Print expressions.  Each expression is separated by the value of OFS.  The output record is terminated with
-                             the value of ORS.
-       print expr-list >file Print expressions on file.  Each expression is separated by the value of OFS.  The output record is  termi‐
-                             nated with the value of ORS.
-       printf fmt, expr-list Format and print.  See The printf Statement, below.
-       printf fmt, expr-list >file
-                             Format and print on file.
-       system(cmd-line)      Execute  the  command  cmd-line,  and return the exit status.  (This may not be available on non-POSIX sys‐
-                             tems.)
-       fflush([file])        Flush any buffers associated with the open output file or pipe file.  If file is missing or if  it  is  the
-                             null string, then flush all open output files and pipes.
-       Additional output redirections are allowed for print and printf.
-       print ... >> file
-              Appends output to the file.
-       print ... | command
-              Writes on a pipe.
-       print ... |& command
-              Sends data to a co-process or socket.  (See also the subsection Special File Names, below.)
-       The getline command returns 1 on success, 0 on end of file, and -1 on an error.  Upon an error, ERRNO is set to a string describ‐
-       ing the problem.
-       NOTE: Failure in opening a two-way socket results in a non-fatal error being returned to the calling function. If using  a  pipe,
-       co-process, or socket to getline, or from print or printf within a loop, you must use close() to create new instances of the com‐
-       mand or socket.  AWK does not automatically close pipes, sockets, or co-processes when they return EOF.
-   The printf Statement
-       The AWK versions of the printf statement and sprintf() function (see below) accept the following  conversion  specification  for‐
-       mats:
-       %c      A  single  character.   If the argument used for %c is numeric, it is treated as a character and printed.  Otherwise, the
-               argument is assumed to be a string, and the only first character of that string is printed.
-       %d, %i  A decimal number (the integer part).
-       %e, %E  A floating point number of the form [-]d.dddddde[+-]dd.  The %E format uses E instead of e.
-       %f, %F  A floating point number of the form [-]ddd.dddddd.  If the system library supports it, %F is available as well.  This  is
-               like %f, but uses capital letters for special “not a number” and “infinity” values. If %F is not available, gawk uses %f.
-       %g, %G  Use  %e  or  %f conversion, whichever is shorter, with nonsignificant zeros suppressed.  The %G format uses %E instead of
-               %e.
-       %o      An unsigned octal number (also an integer).
-       %u      An unsigned decimal number (again, an integer).
-       %s      A character string.
-       %x, %X  An unsigned hexadecimal number (an integer).  The %X format uses ABCDEF instead of abcdef.
-       %%      A single % character; no argument is converted.
-       Optional, additional parameters may lie between the % and the control letter:
-       count$ Use the count'th argument at this point in the formatting.  This is called a positional specifier and is intended  primar‐
-              ily for use in translated versions of format strings, not in the original text of an AWK program.  It is a gawk extension.
-       -      The expression should be left-justified within its field.
-       space  For numeric conversions, prefix positive values with a space, and negative values with a minus sign.
-       +      The  plus  sign, used before the width modifier (see below), says to always supply a sign for numeric conversions, even if
-              the data to be formatted is positive.  The + overrides the space modifier.
-       #      Use an “alternate form” for certain control letters.  For %o, supply a leading zero.  For %x, and %X, supply a leading  0x
-              or  0X for a nonzero result.  For %e, %E, %f and %F, the result always contains a decimal point.  For %g, and %G, trailing
-              zeros are not removed from the result.
-      A leading 0 (zero) acts as a flag, that indicates output should be padded with zeroes instead  of  spaces.   This  applies
-              only  to  the  numeric  output  formats.   This flag only has an effect when the field width is wider than the value to be
-              printed.
-       '      A single quote character instructs gawk to insert the locale's thousands-separator character into decimal numbers, and  to
-              also  use the locale's decimal point character with floating point formats.  This requires correct locale support in the C
-              library and in the definition of the current locale.
-       width  The field should be padded to this width.  The field is normally padded with spaces.  With the 0 flag, it is  padded  with
-              zeroes.
-       .prec  A number that specifies the precision to use when printing.  For the %e, %E, %f and %F, formats, this specifies the number
-              of digits you want printed to the right of the decimal point.  For the %g, and %G formats, it specifies the maximum number
-              of  significant  digits.   For the %d, %i, %o, %u, %x, and %X formats, it specifies the minimum number of digits to print.
-              For %s, it specifies the maximum number of characters from the string that should be printed.
-       The dynamic width and prec capabilities of the ISO C printf() routines are supported.  A * in place of either the width  or  prec
-       specifications causes their values to be taken from the argument list to printf or sprintf().  To use a positional specifier with
-       a dynamic width or precision, supply the count$ after the * in the format string.  For example, "%3$*2$.*1$s".
-   Special File Names
-       When doing I/O redirection from either print or printf into a file, or via getline from a file, gawk recognizes  certain  special
-       filenames  internally.   These  filenames allow access to open file descriptors inherited from gawk's parent process (usually the
-       shell).  These file names may also be used on the command line to name data files.  The filenames are:
-       -           The standard input.
-       /dev/stdin  The standard input.
-       /dev/stdout The standard output.
-       /dev/stderr The standard error output.
-       /dev/fd/n   The file associated with the open file descriptor n.
-       These are particularly useful for error messages.  For example:
-              print "You blew it!" > "/dev/stderr"
-       whereas you would otherwise have to use
-              print "You blew it!" | "cat 1>&2"
-       The following special filenames may be used with the |& co-process operator for creating TCP/IP network connections:
-       /inet/tcp/lport/rhost/rport
-       /inet4/tcp/lport/rhost/rport
-       /inet6/tcp/lport/rhost/rport
-              Files for a TCP/IP connection on local port lport to remote host rhost on remote port rport.  Use a port of 0 to have  the
-              system pick a port.  Use /inet4 to force an IPv4 connection, and /inet6 to force an IPv6 connection.  Plain /inet uses the
-              system default (most likely IPv4).
-       /inet/udp/lport/rhost/rport
-       /inet4/udp/lport/rhost/rport
-       /inet6/udp/lport/rhost/rport
-              Similar, but use UDP/IP instead of TCP/IP.
-   Numeric Functions
-       AWK has the following built-in arithmetic functions:
-       atan2(y, x)   Return the arctangent of y/x in radians.
-       cos(expr)     Return the cosine of expr, which is in radians.
-       exp(expr)     The exponential function.
-       int(expr)     Truncate to integer.
-       log(expr)     The natural logarithm function.
-       rand()        Return a random number N, between 0 and 1, such that 0 ≤ N < 1.
-       sin(expr)     Return the sine of expr, which is in radians.
-       sqrt(expr)    Return the square root of expr.
-       srand([expr]) Use expr as the new seed for the random number generator.  If no expr is provided, use the time of day.  Return the
-                     previous seed for the random number generator.
-   String Functions
-       Gawk has the following built-in string functions:
-       asort(s [, d [, how] ]) Return  the  number  of elements in the source array s.  Sort the contents of s using gawk's normal rules
-                               for comparing values, and replace the indices of the sorted values s with  sequential  integers  starting
-                               with  1.  If  the  optional  destination array d is specified, first duplicate s into d, and then sort d,
-                               leaving the indices of the source array s unchanged. The optional string how controls the  direction  and
-                               the  comparison  mode.   Valid values for how are any of the strings valid for PROCINFO["sorted_in"].  It
-                               can also be the name of a user-defined comparison function as described in PROCINFO["sorted_in"].
-       asorti(s [, d [, how] ])
-                               Return the number of elements in the source array s.  The behavior is the same as that of asort(), except
-                               that  the  array  indices  are  used  for sorting, not the array values.  When done, the array is indexed
-                               numerically, and the values are those of the original indices.  The original values are lost;  thus  pro‐
-                               vide  a second array if you wish to preserve the original.  The purpose of the optional string how is the
-                               same as described in asort() above.
-       gensub(r, s, h [, t])   Search the target string t for matches of the regular expression r.  If h is a string beginning with g or
-                               G,  then  replace  all  matches  of  r  with  s.  Otherwise, h is a number indicating which match of r to
-                               replace.  If t is not supplied, use $0 instead.  Within the replacement text s, the sequence \n, where  n
-                               is  a digit from 1 to 9, may be used to indicate just the text that matched the n'th parenthesized subex‐
-                               pression.  The sequence \0 represents the entire matched text, as does the character &.  Unlike sub() and
-                               gsub(),  the modified string is returned as the result of the function, and the original target string is
-                               not changed.
-       gsub(r, s [, t])        For each substring matching the regular expression r in the string t, substitute the string s, and return
-                               the  number  of  substitutions.   If t is not supplied, use $0.  An & in the replacement text is replaced
-                               with the text that was actually matched.  Use \& to get a literal &.  (This must be typed as  "\\&";  see
-                               GAWK:  Effective  AWK  Programming  for  a  fuller discussion of the rules for &'s and backslashes in the
-                               replacement text of sub(), gsub(), and gensub().)
-       index(s, t)             Return the index of the string t in the string s, or 0 if t is not present.  (This implies that character
-                               indices start at one.)  It is a fatal error to use a regexp constant for t.
-       length([s])             Return  the  length  of the string s, or the length of $0 if s is not supplied.  As a non-standard exten‐
-                               sion, with an array argument, length() returns the number of elements in the array.
-       match(s, r [, a])       Return the position in s where the regular expression r occurs, or 0 if r is not  present,  and  set  the
-                               values  of RSTART and RLENGTH.  Note that the argument order is the same as for the ~ operator: str ~ re.
-                               If array a is provided, a is cleared and then elements 1 through n are filled with the portions of s that
-                               match  the corresponding parenthesized subexpression in r.  The 0'th element of a contains the portion of
-                               s matched by the entire regular expression r.  Subscripts a[n, "start"], and a[n, "length"]  provide  the
-                               starting index in the string and length respectively, of each matching substring.
-       patsplit(s, a [, r [, seps] ])
-                               Split the string s into the array a and the separators array seps on the regular expression r, and return
-                               the number of fields.  Element values are the portions of s that matched r.  The value of seps[i] is  the
-                               separator  that  appeared  in  front of a[i+1].  If r is omitted, FPAT is used instead.  The arrays a and
-                               seps are cleared first.  Splitting behaves identically to field splitting with FPAT, described above.
-       split(s, a [, r [, seps] ])
-                               Split the string s into the array a and the separators array seps on the regular expression r, and return
-                               the  number  of  fields.   If r is omitted, FS is used instead.  The arrays a and seps are cleared first.
-                               seps[i] is the field separator matched by r between a[i] and a[i+1].  If r is a single space, then  lead‐
-                               ing whitespace in s goes into the extra array element seps[0] and trailing whitespace goes into the extra
-                               array element seps[n], where n is the return value of split(s, a, r, seps).   Splitting  behaves  identi‐
-                               cally to field splitting, described above.
-       sprintf(fmt, expr-list) Print expr-list according to fmt, and return the resulting string.
-       strtonum(str)           Examine  str, and return its numeric value.  If str begins with a leading 0, treat it as an octal number.
-                               If str begins with a leading 0x or 0X, treat it as a hexadecimal number.  Otherwise, assume it is a deci‐
-                               mal number.
-       sub(r, s [, t])         Just like gsub(), but replace only the first matching substring.
-       substr(s, i [, n])      Return the at most n-character substring of s starting at i.  If n is omitted, use the rest of s.
-       tolower(str)            Return a copy of the string str, with all the uppercase characters in str translated to their correspond‐
-                               ing lowercase counterparts.  Non-alphabetic characters are left unchanged.
-       toupper(str)            Return a copy of the string str, with all the lowercase characters in str translated to their correspond‐
-                               ing uppercase counterparts.  Non-alphabetic characters are left unchanged.
-       Gawk is multibyte aware.  This means that index(), length(), substr() and match() all work in terms of characters, not bytes.
-   Time Functions
-       Since one of the primary uses of AWK programs is processing log files that contain time stamp information, gawk provides the fol‐
-       lowing functions for obtaining time stamps and formatting them.
-       mktime(datespec)
-                 Turn datespec into a time stamp of the same form as returned by systime(), and return the result.  The  datespec  is  a
-                 string of the form YYYY MM DD HH MM SS[ DST].  The contents of the string are six or seven numbers representing respec‐
-                 tively the full year including century, the month from 1 to 12, the day of the month from 1 to 31, the hour of the  day
-                 from  0  to  23, the minute from 0 to 59, the second from 0 to 60, and an optional daylight saving flag.  The values of
-                 these numbers need not be within the ranges specified; for example, an hour of -1 means 1 hour  before  midnight.   The
-                 origin-zero  Gregorian  calendar  is  assumed,  with year 0 preceding year 1 and year -1 preceding year 0.  The time is
-                 assumed to be in the local timezone.  If the daylight saving flag is positive, the time is assumed to be daylight  sav‐
-                 ing  time; if zero, the time is assumed to be standard time; and if negative (the default), mktime() attempts to deter‐
-                 mine whether daylight saving time is in effect for the specified time.  If datespec does not contain enough elements or
-                 if the resulting time is out of range, mktime() returns -1.
-       strftime([format [, timestamp[, utc-flag]]])
-                 Format  timestamp  according  to  the specification in format.  If utc-flag is present and is non-zero or non-null, the
-                 result is in UTC, otherwise the result is in local time.  The timestamp should be of the same form as returned by  sys‐
-                 time().   If  timestamp is missing, the current time of day is used.  If format is missing, a default format equivalent
-                 to the output of date(1) is used.  The default format is available in PROCINFO["strftime"].  See the specification  for
-                 the strftime() function in ISO C for the format conversions that are guaranteed to be available.
-       systime() Return the current time of day as the number of seconds since the Epoch (1970-01-01 00:00:00 UTC on POSIX systems).
-   Bit Manipulations Functions
-       Gawk  supplies the following bit manipulation functions.  They work by converting double-precision floating point values to uint‐
-       max_t integers, doing the operation, and then converting the result back to floating point.  The functions are:
-       and(v1, v2 [, ...]) Return the bitwise AND of the values provided in the argument list.  There must be at least two.
-       compl(val)          Return the bitwise complement of val.
-       lshift(val, count)  Return the value of val, shifted left by count bits.
-       or(v1, v2 [, ...])  Return the bitwise OR of the values provided in the argument list.  There must be at least two.
-       rshift(val, count)  Return the value of val, shifted right by count bits.
-       xor(v1, v2 [, ...]) Return the bitwise XOR of the values provided in the argument list.  There must be at least two.
-   Type Function
-       The following function is for use with multidimensional arrays.
-       isarray(x)
-              Return true if x is an array, false otherwise.
-   Internationalization Functions
-       The following functions may be used from within your AWK program for translating strings at  run-time.   For  full  details,  see
-       GAWK: Effective AWK Programming.
-       bindtextdomain(directory [, domain])
-              Specify  the  directory where gawk looks for the .gmo files, in case they will not or cannot be placed in the ``standard''
-              locations (e.g., during testing).  It returns the directory where domain is ``bound.''
-              The default domain is the value of TEXTDOMAIN.  If directory is the null string (""), then  bindtextdomain()  returns  the
-              current binding for the given domain.
-       dcgettext(string [, domain [, category]])
-              Return  the translation of string in text domain domain for locale category category.  The default value for domain is the
-              current value of TEXTDOMAIN.  The default value for category is "LC_MESSAGES".
-              If you supply a value for category, it must be a string equal to one of the known locale  categories  described  in  GAWK:
-              Effective AWK Programming.  You must also supply a text domain.  Use TEXTDOMAIN if you want to use the current domain.
-       dcngettext(string1, string2, number [, domain [, category]])
-              Return the plural form used for number of the translation of string1 and string2 in text domain domain for locale category
-              category.  The default value for domain is the current value of TEXTDOMAIN.  The default value for  category  is  "LC_MES‐
-              SAGES".
-              If  you  supply  a  value for category, it must be a string equal to one of the known locale categories described in GAWK:
-              Effective AWK Programming.  You must also supply a text domain.  Use TEXTDOMAIN if you want to use the current domain.
-USER-DEFINED FUNCTIONS
-       Functions in AWK are defined as follows:
-              function name(parameter list) { statements }
-       Functions are executed when they are called from within expressions in either patterns or actions.  Actual parameters supplied in
-       the  function call are used to instantiate the formal parameters declared in the function.  Arrays are passed by reference, other
-       variables are passed by value.
-       Since functions were not originally part of the AWK language, the provision for  local  variables  is  rather  clumsy:  They  are
-       declared  as extra parameters in the parameter list.  The convention is to separate local variables from real parameters by extra
-       spaces in the parameter list.  For example:
-              function  f(p, q,     a, b)   # a and b are local
-              {
-                   ...
-              }
-              /abc/     { ... ; f(1, 2) ; ... }
-       The left parenthesis in a function call is required to immediately follow the function name, without any intervening  whitespace.
-       This  avoids  a  syntactic  ambiguity with the concatenation operator.  This restriction does not apply to the built-in functions
-       listed above.
-       Functions may call each other and may be recursive.  Function parameters used as local variables  are  initialized  to  the  null
-       string and the number zero upon function invocation.
-       Use  return  expr  to  return a value from a function.  The return value is undefined if no value is provided, or if the function
-       returns by “falling off” the end.
-       As a gawk extension, functions may be called indirectly. To do this, assign the name of the function to be called, as  a  string,
-       to a variable.  Then use the variable as if it were the name of a function, prefixed with an @ sign, like so:
-              function  myfunc()
-              {
-                   print "myfunc called"
-                   ...
-              }
-              {    ...
-                   the_func = "myfunc"
-                   @the_func()    # call through the_func to myfunc
-                   ...
-              }
-       If  --lint  has  been  provided, gawk warns about calls to undefined functions at parse time, instead of at run time.  Calling an
-       undefined function at run time is a fatal error.
-       The word func may be used in place of function, although this is deprecated.
-DYNAMICALLY LOADING NEW FUNCTIONS
-       You can dynamically add new built-in functions to the running gawk interpreter with the @load statement.  The  full  details  are
-       beyond the scope of this manual page; see GAWK: Effective AWK Programming.
-SIGNALS
-       The gawk profiler accepts two signals.  SIGUSR1 causes it to dump a profile and function call stack to the profile file, which is
-       either awkprof.out, or whatever file was named with the --profile option.  It then continues to run.  SIGHUP causes gawk to  dump
-       the profile and function call stack and then exit.
-INTERNATIONALIZATION
-       String  constants are sequences of characters enclosed in double quotes.  In non-English speaking environments, it is possible to
-       mark strings in the AWK program as requiring translation to the local natural language. Such strings are marked in the  AWK  pro‐
-       gram with a leading underscore (“_”).  For example,
-              gawk 'BEGIN { print "hello, world" }'
-       always prints hello, world.  But,
-              gawk 'BEGIN { print _"hello, world" }'
-       might print bonjour, monde in France.
-       There are several steps involved in producing and running a localizable AWK program.
-.  Add  a  BEGIN  action to assign a value to the TEXTDOMAIN variable to set the text domain to a name associated with your pro‐
-           gram:
-                BEGIN { TEXTDOMAIN = "myprog" }
-           This allows gawk to find the .gmo file associated with your program.  Without this step, gawk uses the messages text  domain,
-           which likely does not contain translations for your program.
-.  Mark all strings that should be translated with leading underscores.
-.  If necessary, use the dcgettext() and/or bindtextdomain() functions in your program, as appropriate.
-.  Run gawk --gen-pot -f myprog.awk > myprog.pot to generate a .pot file for your program.
-.  Provide appropriate translations, and build and install the corresponding .gmo files.
-       The internationalization features are described in full detail in GAWK: Effective AWK Programming.
-POSIX COMPATIBILITY
-       A  primary  goal  for gawk is compatibility with the POSIX standard, as well as with the latest version of Brian Kernighan's awk.
-       To this end, gawk incorporates the following user visible features which are not described in the AWK book, but are part  of  the
-       Brian Kernighan's version of awk, and are in the POSIX standard.
-       The  book  indicates that command line variable assignment happens when awk would otherwise open the argument as a file, which is
-       after the BEGIN rule is executed.  However, in earlier implementations, when such an assignment appeared before any  file  names,
-       the  assignment would happen before the BEGIN rule was run.  Applications came to depend on this “feature.”  When awk was changed
-       to match its documentation, the -v option for assigning variables before program execution was added to accommodate  applications
-       that depended upon the old behavior.  (This feature was agreed upon by both the Bell Laboratories and the GNU developers.)
-       When  processing  arguments,  gawk  uses the special option “--” to signal the end of arguments.  In compatibility mode, it warns
-       about but otherwise ignores undefined options.  In normal operation, such arguments are passed on to the AWK program  for  it  to
-       process.
-       The AWK book does not define the return value of srand().  The POSIX standard has it return the seed it was using, to allow keep‐
-       ing track of random number sequences.  Therefore srand() in gawk also returns its current seed.
-       Other new features are: The use of multiple -f options (from MKS awk); the ENVIRON array; the \a, and \v escape  sequences  (done
-       originally  in  gawk  and  fed back into the Bell Laboratories version); the tolower() and toupper() built-in functions (from the
-       Bell Laboratories version); and the ISO C conversion specifications in printf (done first in the Bell Laboratories version).
-HISTORICAL FEATURES
-       There is one feature of historical AWK implementations that gawk supports: It is possible to call the length() built-in  function
-       not only with no argument, but even without parentheses!  Thus,
-              a = length     # Holy Algol 60, Batman!
-       is the same as either of
-              a = length()
-              a = length($0)
-       Using this feature is poor practice, and gawk issues a warning about its use if --lint is specified on the command line.
-GNU EXTENSIONS
-       Gawk  has  a too-large number of extensions to POSIX awk.  They are described in this section.  All the extensions described here
-       can be disabled by invoking gawk with the --traditional or --posix options.
-       The following features of gawk are not available in POSIX awk.
-       · No path search is performed for files named via the -f option.  Therefore the AWKPATH environment variable is not special.
-       · There is no facility for doing file inclusion (gawk's @include mechanism).
-       · There is no facility for dynamically adding new functions written in C (gawk's @load mechanism).
-       · The \x escape sequence.  (Disabled with --posix.)
-       · The ability to continue lines after ?  and :.  (Disabled with --posix.)
-       · Octal and hexadecimal constants in AWK programs.
-       · The ARGIND, BINMODE, ERRNO, LINT, RT and TEXTDOMAIN variables are not special.
-       · The IGNORECASE variable and its side-effects are not available.
-       · The FIELDWIDTHS variable and fixed-width field splitting.
-       · The FPAT variable and field splitting based on field values.
-       · The PROCINFO array is not available.
-       · The use of RS as a regular expression.
-       · The special file names available for I/O redirection are not recognized.
-       · The |& operator for creating co-processes.
-       · The BEGINFILE and ENDFILE special patterns are not available.
-       · The ability to split out individual characters using the null string as the value of FS, and as the third argument to split().
-       · An optional fourth argument to split() to receive the separator texts.
-       · The optional second argument to the close() function.
-       · The optional third argument to the match() function.
-       · The ability to use positional specifiers with printf and sprintf().
-       · The ability to pass an array to length().
-       · The and(), asort(), asorti(), bindtextdomain(), compl(), dcgettext(), dcngettext(), gensub(), lshift(),  mktime(),  or(),  pat‐
-         split(), rshift(), strftime(), strtonum(), systime() and xor() functions.
-       · Localizable strings.
-       The  AWK  book  does  not  define  the return value of the close() function.  Gawk's close() returns the value from fclose(3), or
-       pclose(3), when closing an output file or pipe, respectively.  It returns the process's exit status when closing an  input  pipe.
-       The return value is -1 if the named file, pipe or co-process was not opened with a redirection.
-       When gawk is invoked with the --traditional option, if the fs argument to the -F option is “t”, then FS is set to the tab charac‐
-       ter.  Note that typing gawk -F\t ...  simply causes the shell to quote the “t,” and does not pass “\t” to the -F  option.   Since
-       this is a rather ugly special case, it is not the default behavior.  This behavior also does not occur if --posix has been speci‐
-       fied.  To really get a tab character as the field separator, it is best to use single quotes: gawk -F'\t' ....
-ENVIRONMENT VARIABLES
-       The AWKPATH environment variable can be used to provide a list of directories that gawk searches when looking for files named via
-       the  -f,  --file,  -i and --include options.  If the initial search fails, the path is searched again after appending .awk to the
-       filename.
-       The AWKLIBPATH environment variable can be used to provide a list of directories that gawk searches when looking for files  named
-       via the -l and --load options.
-       The  GAWK_READ_TIMEOUT  environment  variable can be used to specify a timeout in milliseconds for reading input from a terminal,
-       pipe or two-way communication including sockets.
-       For connection to a remote host via socket, GAWK_SOCK_RETRIES controls the number of retries, and GAWK_MSEC_SLEEP and the  inter‐
-       val  between  retries.   The interval is in milliseconds. On systems that do not support usleep(3), the value is rounded up to an
-       integral number of seconds.
-       If POSIXLY_CORRECT exists in the environment, then gawk behaves exactly as if --posix had been specified on the command line.  If
-       --lint has been specified, gawk issues a warning message to this effect.
-EXIT STATUS
-       If the exit statement is used with a value, then gawk exits with the numeric value given to it.
-       Otherwise, if there were no problems during execution, gawk exits with the value of the C constant EXIT_SUCCESS.  This is usually
-       zero.
-       If an error occurs, gawk exits with the value of the C constant EXIT_FAILURE.  This is usually one.
-       If gawk exits because of a fatal error, the exit status is 2.  On non-POSIX systems, this value may be mapped to EXIT_FAILURE.
-VERSION INFORMATION
-       This man page documents gawk, version 4.1.
-AUTHORS
-       The original version of UNIX awk was designed and implemented by Alfred Aho, Peter Weinberger, and Brian Kernighan of Bell  Labo‐
-       ratories.  Brian Kernighan continues to maintain and enhance it.
-       Paul  Rubin and Jay Fenlason, of the Free Software Foundation, wrote gawk, to be compatible with the original version of awk dis‐
-       tributed in Seventh Edition UNIX.  John Woods contributed a number of bug fixes.  David Trueman, with contributions  from  Arnold
-       Robbins, made gawk compatible with the new version of UNIX awk.  Arnold Robbins is the current maintainer.
-       See GAWK: Effective AWK Programming for a full list of the contributors to gawk and its documentation.
-       See  the  README  file  in  the gawk distribution for up-to-date information about maintainers and which ports are currently sup‐
-       ported.
-BUG REPORTS
-       If you find a bug in gawk, please send electronic mail to bug-gawk@gnu.org.  Please include your operating system and  its  revi‐
-       sion, the version of gawk (from gawk --version), which C compiler you used to compile it, and a test program and data that are as
-       small as possible for reproducing the problem.
-       Before sending a bug report, please do the following things.  First, verify that you have the latest version of gawk.  Many  bugs
-       (usually  subtle ones) are fixed at each release, and if yours is out of date, the problem may already have been solved.  Second,
-       please see if setting the environment variable LC_ALL to LC_ALL=C causes things to behave as you expect. If  so,  it's  a  locale
-       issue, and may or may not really be a bug.  Finally, please read this man page and the reference manual carefully to be sure that
-       what you think is a bug really is, instead of just a quirk in the language.
-       Whatever you do, do NOT post a bug report in comp.lang.awk.  While the gawk developers occasionally read this newsgroup,  posting
-       bug reports there is an unreliable way to report bugs.  Instead, please use the electronic mail addresses given above.  Really.
-       If  you're using a GNU/Linux or BSD-based system, you may wish to submit a bug report to the vendor of your distribution.  That's
-       fine, but please send a copy to the official email address as well, since there's no guarantee that the bug report will  be  for‐
-       warded to the gawk maintainer.
-BUGS
-       The -F option is not necessary given the command line variable assignment feature; it remains only for backwards compatibility.
-       Syntactically  invalid  single  character programs tend to overflow the parse stack, generating a rather unhelpful message.  Such
-       programs are surprisingly difficult to diagnose in the completely general case, and the effort to do so really is not worth it.
-SEE ALSO
-       egrep(1), sed(1), getpid(2), getppid(2), getpgrp(2), getuid(2), geteuid(2), getgid(2), getegid(2), getgroups(2), usleep(3)
-       The AWK Programming Language, Alfred V. Aho, Brian W. Kernighan, Peter J. Weinberger, Addison-Wesley, 1988.  ISBN 0-201-07981-X.
-       GAWK: Effective AWK Programming, Edition 4.1, shipped with the gawk source.  The current version of this  document  is  available
-       online at http://www.gnu.org/software/gawk/manual.
-EXAMPLES
-       Print and sort the login names of all users:
-            BEGIN     { FS = ":" }
-                 { print $1 | "sort" }
-       Count lines in a file:
-                 { nlines++ }
-            END  { print nlines }
-       Precede each line by its number in the file:
-            { print FNR, $0 }
-       Concatenate and line number (a variation on a theme):
-            { print NR, $0 }
-       Run an external command for particular lines of data:
-            tail -f access_log |
-            awk '/myhome.html/ { system("nmap " $1 ">> logdir/myhome.html") }'
-ACKNOWLEDGEMENTS
-       Brian Kernighan provided valuable assistance during testing and debugging.  We thank him.
-COPYING PERMISSIONS
-       Copyright  ©  1989,  1991,  1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002, 2003, 2004, 2005, 2007, 2009, 2010, 2011,
-, 2013, 2014 Free Software Foundation, Inc.
-       Permission is granted to make and distribute verbatim copies of this manual page provided the copyright notice and  this  permis‐
-       sion notice are preserved on all copies.
-       Permission  is  granted  to  copy and distribute modified versions of this manual page under the conditions for verbatim copying,
-       provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.
-       Permission is granted to copy and distribute translations of this manual page into another language, under the  above  conditions
-       for modified versions, except that this permission notice may be stated in a translation approved by the Foundation.
-Free Software Foundation                                       Mar 08 2014                                                       GAWK(1)
-</code>