(gawk.info.gz) Top

Info Catalog (dir) Top (gawk.info.gz) Foreword
 General Introduction
 This file documents `awk', a program that you can use to select
 particular records in a file and perform operations upon them.
    Copyright (C) 1989, 1991, 1992, 1993, 1996, 1997, 1998, 1999, 2000,
 2001, 2002, 2003, 2004, 2005, 2007, 2009, 2010, 2011, 2012 Free
 Software Foundation, Inc.
    This is Edition 4 of `GAWK: Effective AWK Programming: A User's
 Guide for GNU Awk', for the 4.0.2 (or later) version of the GNU
 implementation of AWK.
    Permission is granted to copy, distribute and/or modify this document
 under the terms of the GNU Free Documentation License, Version 1.3 or
 any later version published by the Free Software Foundation; with the
 Invariant Sections being "GNU General Public License", the Front-Cover
 texts being (a) (see below), and with the Back-Cover Texts being (b)
 (see below).  A copy of the license is included in the section entitled
 "GNU Free Documentation License".
   a. "A GNU Manual"
   b. "You have the freedom to copy and modify this GNU manual.  Buying
      copies from the FSF supports it in developing GNU and promoting
      software freedom."


* Foreword                       Some nice words about this
                                    Info file.
* Preface                        What this Info file is about; brief
                                    history and acknowledgments.
* Getting Started                A basic introduction to using
                                    `awk'. How to run an `awk'
                                    program. Command-line syntax.
* Invoking Gawk                  How to run `gawk'.
* Regexp                         All about matching things using regular
* Reading Files                  How to read files and manipulate fields.
* Printing                       How to print using `awk'. Describes
                                    the `print' and `printf'
                                    statements. Also describes redirection of
* Expressions                    Expressions are the basic building blocks
                                    of statements.
* Patterns and Actions           Overviews of patterns and actions.
* Arrays                         The description and use of arrays. Also
                                    includes array-oriented control statements.
* Functions                      Built-in and user-defined functions.
* Internationalization           Getting `gawk' to speak your
* Advanced Features              Stuff for advanced users, specific to
* Library Functions              A Library of `awk' Functions.
* Sample Programs                Many `awk' programs with complete
* Debugger                       The `dgawk' debugger.
* Language History               The evolution of the `awk'
* Installation                   Installing `gawk' under various
                                    operating systems.
* Notes                          Notes about `gawk' extensions and
                                    possible future work.
* Basic Concepts                 A very quick introduction to programming
* Glossary                       An explanation of some unfamiliar terms.
* Copying                        Your right to copy and distribute
* GNU Free Documentation License The license for this Info file.
* Index                          Concept and Variable Index.
* History                        The history of `gawk' and
* Names                          What name to use to find `awk'.
* This Manual                    Using this Info file. Includes
                                    sample input files that you can use.
* Conventions                    Typographical Conventions.
* Manual History                 Brief history of the GNU project and this
                                    Info file.
* How To Contribute              Helping to save the world.
* Acknowledgments                Acknowledgments.
* Running gawk                   How to run `gawk' programs;
                                    includes command-line syntax.
* One-shot                       Running a short throwaway `awk'
* Read Terminal                  Using no input files (input from terminal
* Long                           Putting permanent `awk' programs in
* Executable Scripts             Making self-contained `awk'
* Comments                       Adding documentation to `gawk'
* Quoting                        More discussion of shell quoting issues.
* DOS Quoting                    Quoting in Windows Batch Files.
* Sample Data Files              Sample data files for use in the
                                    `awk' programs illustrated in this
                                    Info file.
* Very Simple                    A very simple example.
* Two Rules                      A less simple one-line example using two
* More Complex                   A more complex example.
* Statements/Lines               Subdividing or combining statements into
* Other Features                 Other Features of `awk'.
* When                           When to use `gawk' and when to use
                                    other things.
* Command Line                   How to run `awk'.
* Options                        Command-line options and their meanings.
* Other Arguments                Input file names and variable assignments.
* Naming Standard Input          How to specify standard input with other
* Environment Variables          The environment variables `gawk'
* AWKPATH Variable               Searching directories for `awk'
* Other Environment Variables    The environment variables.
* Exit Status                    `gawk''s exit status.
* Include Files                  Including other files into your program.
* Obsolete                       Obsolete Options and/or features.
* Undocumented                   Undocumented Options and Features.
* Regexp Usage                   How to Use Regular Expressions.
* Escape Sequences               How to write nonprinting characters.
* Regexp Operators               Regular Expression Operators.
* Bracket Expressions            What can go between `[...]'.
* GNU Regexp Operators           Operators specific to GNU software.
* Case-sensitivity               How to do case-insensitive matching.
* Leftmost Longest               How much text matches.
* Computed Regexps               Using Dynamic Regexps.
* Records                        Controlling how data is split into records.
* Fields                         An introduction to fields.
* Nonconstant Fields             Nonconstant Field Numbers.
* Changing Fields                Changing the Contents of a Field.
* Field Separators               The field separator and how to change it.
* Default Field Splitting        How fields are normally separated.
* Regexp Field Splitting         Using regexps as the field separator.
* Single Character Fields        Making each character a separate field.
* Command Line Field Separator   Setting `FS' from the command-line.
* Field Splitting Summary        Some final points and a summary table.
* Constant Size                  Reading constant width data.
* Splitting By Content           Defining Fields By Content
* Multiple Line                  Reading multi-line records.
* Getline                        Reading files under explicit program
                                    control using the `getline' function.
* Plain Getline                  Using `getline' with no arguments.
* Getline/Variable               Using `getline' into a variable.
* Getline/File                   Using `getline' from a file.
* Getline/Variable/File          Using `getline' into a variable from a
* Getline/Pipe                   Using `getline' from a pipe.
* Getline/Variable/Pipe          Using `getline' into a variable from a
* Getline/Coprocess              Using `getline' from a coprocess.
* Getline/Variable/Coprocess     Using `getline' into a variable from a
* Getline Notes                  Important things to know about
* Getline Summary                Summary of `getline' Variants.
* Command line directories       What happens if you put a directory on the
                                    command line.
* Print                          The `print' statement.
* Print Examples                 Simple examples of `print' statements.
* Output Separators              The output separators and how to change
* OFMT                           Controlling Numeric Output With
* Printf                         The `printf' statement.
* Basic Printf                   Syntax of the `printf' statement.
* Control Letters                Format-control letters.
* Format Modifiers               Format-specification modifiers.
* Printf Examples                Several examples.
* Redirection                    How to redirect output to multiple files
                                    and pipes.
* Special Files                  File name interpretation in `gawk'.
                                    `gawk' allows access to inherited
                                    file descriptors.
* Special FD                     Special files for I/O.
* Special Network                Special files for network communications.
* Special Caveats                Things to watch out for.
* Close Files And Pipes          Closing Input and Output Files and Pipes.
* Values                         Constants, Variables, and Regular
* Constants                      String, numeric and regexp constants.
* Scalar Constants               Numeric and string constants.
* Nondecimal-numbers             What are octal and hex numbers.
* Regexp Constants               Regular Expression constants.
* Using Constant Regexps         When and how to use a regexp constant.
* Variables                      Variables give names to values for later
* Using Variables                Using variables in your programs.
* Assignment Options             Setting variables on the command-line and a
                                    summary of command-line syntax. This is an
                                    advanced method of input.
* Conversion                     The conversion of strings to numbers and
                                    vice versa.
* All Operators                  `gawk''s operators.
* Arithmetic Ops                 Arithmetic operations (`+', `-',
* Concatenation                  Concatenating strings.
* Assignment Ops                 Changing the value of a variable or a
* Increment Ops                  Incrementing the numeric value of a
* Truth Values and Conditions    Testing for true and false.
* Truth Values                   What is ``true'' and what is ``false''.
* Typing and Comparison          How variables acquire types and how this
                                    affects comparison of numbers and strings
                                    with `<', etc.
* Variable Typing                String type versus numeric type.
* Comparison Operators           The comparison operators.
* POSIX String Comparison        String comparison with POSIX rules.
* Boolean Ops                    Combining comparison expressions using
                                    boolean operators `||' (``or''),
                                    `&&' (``and'') and `!' (``not'').
* Conditional Exp                Conditional expressions select between two
                                    subexpressions under control of a third
* Function Calls                 A function call is an expression.
* Precedence                     How various operators nest.
* Locales                        How the locale affects things.
* Pattern Overview               What goes into a pattern.
* Regexp Patterns                Using regexps as patterns.
* Expression Patterns            Any expression can be used as a pattern.
* Ranges                         Pairs of patterns specify record ranges.
* BEGIN/END                      Specifying initialization and cleanup
* Using BEGIN/END                How and why to use BEGIN/END rules.
* I/O And BEGIN/END              I/O issues in BEGIN/END rules.
* BEGINFILE/ENDFILE              Two special patterns for advanced control.
* Empty                          The empty pattern, which matches every
* Using Shell Variables          How to use shell variables with
* Action Overview                What goes into an action.
* Statements                     Describes the various control statements in
* If Statement                   Conditionally execute some `awk'
* While Statement                Loop until some condition is satisfied.
* Do Statement                   Do specified action while looping until
                                    some condition is satisfied.
* For Statement                  Another looping statement, that provides
                                    initialization and increment clauses.
* Switch Statement               Switch/case evaluation for conditional
                                    execution of statements based on a value.
* Break Statement                Immediately exit the innermost enclosing
* Continue Statement             Skip to the end of the innermost enclosing
* Next Statement                 Stop processing the current input record.
* Nextfile Statement             Stop processing the current file.
* Exit Statement                 Stop execution of `awk'.
* Built-in Variables             Summarizes the built-in variables.
* User-modified                  Built-in variables that you change to
                                    control `awk'.
* Auto-set                       Built-in variables where `awk'
                                    gives you information.
* ARGC and ARGV                  Ways to use `ARGC' and `ARGV'.
* Array Basics                   The basics of arrays.
* Array Intro                    Introduction to Arrays
* Reference to Elements          How to examine one element of an array.
* Assigning Elements             How to change an element of an array.
* Array Example                  Basic Example of an Array
* Scanning an Array              A variation of the `for' statement. It
                                    loops through the indices of an array's
                                    existing elements.
* Controlling Scanning           Controlling the order in which arrays are
* Delete                         The `delete' statement removes an
                                    element from an array.
* Numeric Array Subscripts       How to use numbers as subscripts in
* Uninitialized Subscripts       Using Uninitialized variables as
* Multi-dimensional              Emulating multidimensional arrays in
* Multi-scanning                 Scanning multidimensional arrays.
* Arrays of Arrays               True multidimensional arrays.
* Built-in                       Summarizes the built-in functions.
* Calling Built-in               How to call built-in functions.
* Numeric Functions              Functions that work with numbers, including
                                    `int()', `sin()' and
* String Functions               Functions for string manipulation, such as
                                    `split()', `match()' and
* Gory Details                   More than you want to know about `\'
                                    and `&' with `sub()',
                                    `gsub()', and `gensub()'.
* I/O Functions                  Functions for files and shell commands.
* Time Functions                 Functions for dealing with timestamps.
* Bitwise Functions              Functions for bitwise operations.
* Type Functions                 Functions for type information.
* I18N Functions                 Functions for string translation.
* User-defined                   Describes User-defined functions in detail.
* Definition Syntax              How to write definitions and what they
* Function Example               An example function definition and what it
* Function Caveats               Things to watch out for.
* Calling A Function             Don't use spaces.
* Variable Scope                 Controlling variable scope.
* Pass By Value/Reference        Passing parameters.
* Return Statement               Specifying the value a function returns.
* Dynamic Typing                 How variable types can change at runtime.
* Indirect Calls                 Choosing the function to call at runtime.
* I18N and L10N                  Internationalization and Localization.
* Explaining gettext             How GNU `gettext' works.
* Programmer i18n                Features for the programmer.
* Translator i18n                Features for the translator.
* String Extraction              Extracting marked strings.
* Printf Ordering                Rearranging `printf' arguments.
* I18N Portability               `awk'-level portability issues.
* I18N Example                   A simple i18n example.
* Gawk I18N                      `gawk' is also internationalized.
* Nondecimal Data                Allowing nondecimal input data.
* Array Sorting                  Facilities for controlling array traversal
                                    and sorting arrays.
* Controlling Array Traversal    How to use PROCINFO["sorted_in"].
* Array Sorting Functions        How to use `asort()' and
* Two-way I/O                    Two-way communications with another
* TCP/IP Networking              Using `gawk' for network
* Profiling                      Profiling your `awk' programs.
* Library Names                  How to best name private global variables
                                    in library functions.
* General Functions              Functions that are of general use.
* Strtonum Function              A replacement for the built-in
                                    `strtonum()' function.
* Assert Function                A function for assertions in `awk'
* Round Function                 A function for rounding if `sprintf()'
                                    does not do it correctly.
* Cliff Random Function          The Cliff Random Number Generator.
* Ordinal Functions              Functions for using characters as numbers
                                    and vice versa.
* Join Function                  A function to join an array into a string.
* Gettimeofday Function          A function to get formatted times.
* Data File Management           Functions for managing command-line data
* Filetrans Function             A function for handling data file
* Rewind Function                A function for rereading the current file.
* File Checking                  Checking that data files are readable.
* Empty Files                    Checking for zero-length files.
* Ignoring Assigns               Treating assignments as file names.
* Getopt Function                A function for processing command-line
* Passwd Functions               Functions for getting user information.
* Group Functions                Functions for getting group information.
* Walking Arrays                 A function to walk arrays of arrays.
* Running Examples               How to run these examples.
* Clones                         Clones of common utilities.
* Cut Program                    The `cut' utility.
* Egrep Program                  The `egrep' utility.
* Id Program                     The `id' utility.
* Split Program                  The `split' utility.
* Tee Program                    The `tee' utility.
* Uniq Program                   The `uniq' utility.
* Wc Program                     The `wc' utility.
* Miscellaneous Programs         Some interesting `awk' programs.
* Dupword Program                Finding duplicated words in a document.
* Alarm Program                  An alarm clock.
* Translate Program              A program similar to the `tr'
* Labels Program                 Printing mailing labels.
* Word Sorting                   A program to produce a word usage count.
* History Sorting                Eliminating duplicate entries from a
                                    history file.
* Extract Program                Pulling out programs from Texinfo source
* Simple Sed                     A Simple Stream Editor.
* Igawk Program                  A wrapper for `awk' that includes
* Anagram Program                Finding anagrams from a dictionary.
* Signature Program              People do amazing things with too much time
                                    on their hands.
* Debugging                      Introduction to `dgawk'.
* Debugging Concepts             Debugging In General.
* Debugging Terms                Additional Debugging Concepts.
* Awk Debugging                  Awk Debugging.
* Sample dgawk session           Sample `dgawk' session.
* dgawk invocation               `dgawk' Invocation.
* Finding The Bug                Finding The Bug.
* List of Debugger Commands      Main `dgawk' Commands.
* Breakpoint Control             Control of breakpoints.
* Dgawk Execution Control        Control of execution.
* Viewing And Changing Data      Viewing and changing data.
* Dgawk Stack                    Dealing with the stack.
* Dgawk Info                     Obtaining information about the program and
                                    the debugger state.
* Miscellaneous Dgawk Commands   Miscellaneous Commands.
* Readline Support               Readline Support.
* Dgawk Limitations              Limitations and future plans.
* V7/SVR3.1                      The major changes between V7 and System V
                                    Release 3.1.
* SVR4                           Minor changes between System V Releases 3.1
                                    and 4.
* POSIX                          New features from the POSIX standard.
* BTL                            New features from Brian Kernighan's version
                                    of `awk'.
* POSIX/GNU                      The extensions in `gawk' not in
                                    POSIX `awk'.
* Common Extensions              Common Extensions Summary.
* Ranges and Locales             How locales used to affect regexp ranges.
* Contributors                   The major contributors to `gawk'.
* Gawk Distribution              What is in the `gawk' distribution.
* Getting                        How to get the distribution.
* Extracting                     How to extract the distribution.
* Distribution contents          What is in the distribution.
* Unix Installation              Installing `gawk' under various
                                    versions of Unix.
* Quick Installation             Compiling `gawk' under Unix.
* Additional Configuration Options Other compile-time options.
* Configuration Philosophy       How it's all supposed to work.
* Non-Unix Installation          Installation on Other Operating Systems.
* PC Installation                Installing and Compiling `gawk' on
                                    MS-DOS and OS/2.
* PC Binary Installation         Installing a prepared distribution.
* PC Compiling                   Compiling `gawk' for MS-DOS,
                                    Windows32, and OS/2.
* PC Testing                     Testing `gawk' on PC systems.
* PC Using                       Running `gawk' on MS-DOS, Windows32
                                    and OS/2.
* Cygwin                         Building and running `gawk' for
* MSYS                           Using `gawk' In The MSYS
* VMS Installation               Installing `gawk' on VMS.
* VMS Compilation                How to compile `gawk' under VMS.
* VMS Installation Details       How to install `gawk' under VMS.
* VMS Running                    How to run `gawk' under VMS.
* VMS Old Gawk                   An old version comes with some VMS systems.
* Bugs                           Reporting Problems and Bugs.
* Other Versions                 Other freely available `awk'
* Compatibility Mode             How to disable certain `gawk'
* Additions                      Making Additions To `gawk'.
* Accessing The Source           Accessing the Git repository.
* Adding Code                    Adding code to the main body of
* New Ports                      Porting `gawk' to a new operating
* Dynamic Extensions             Adding new built-in functions to
* Internals                      A brief look at some `gawk'
* Plugin License                 A note about licensing.
* Sample Library                 A example of new functions.
* Internal File Description      What the new functions will do.
* Internal File Ops              The code for internal file operations.
* Using Internal File Ops        How to use an external extension.
* Future Extensions              New features that may be implemented one
* Basic High Level               The high level view.
* Basic Data Typing              A very quick intro to data types.
* Floating Point Issues          Stuff to know about floating-point numbers.
* String Conversion Precision    The String Value Can Lie.
* Unexpected Results             Floating Point Numbers Are Not Abstract
* POSIX Floating Point Problems  Standards Versus Existing Practice.
                   To Miriam, for making me complete.
                   To Chana, for the joy you bring us.
                 To Rivka, for the exponential increase.
                   To Nachum, for the added dimension.
                    To Malka, for the new beginning.
Info Catalog (dir) Top (gawk.info.gz) Foreword
automatically generated by info2html