Web Hosting Web Hosting, web hosting, JSP, Servlets, Tomcat, website hosting, web site hosting
Web Hosting, web hosting, JSP, Servlets, Tomcat, website hosting, web site hosting
Web Hosting, web hosting, JSP, Servlets, Tomcat, website hosting, web site hosting

Alden Hosting provides professional, efficient, and reliable business-class Web hosting and Website Design services.


Call Us Toll-Free
(877) 256-0328

Outside USA
1 - (201) 505-0430


Site Map

LINUX Web Hosting Commands and tools awk


       gawk [ POSIX or GNU style options ] -f program-file [ -- ]
       file ...
       gawk [ POSIX or GNU style options ] [  --  ]  program-text
       file ...

       pgawk  [ POSIX or GNU style options ] -f program-file [ --
       ] file ...
       pgawk [ POSIX or GNU style options ] [ --  ]  program-text
       file ...


       Gawk  is  the GNU Project's implementation of the AWK pro-
       gramming language.  It conforms to the definition  of  the
       language  in  the POSIX 1003.2 Command Language And Utili-
       ties Standard.  This version  in  turn  is  based  on  the
       description  in  The  AWK  Programming  Language,  by Aho,
       Kernighan, and Weinberger, with  the  additional  features
       found in the System V Release 4 version of UNIX awk.  Gawk
       also provides more recent  Bell  Laboratories  awk  exten-
       sions, and a number of GNU-specific extensions.

       Pgawk  is  the profiling version of gawk.  It is identical
       in every way  to  gawk,  except  that  programs  run  more
       slowly, and it automatically produces an execution profile
       in the file awkprof.out  when  done.   See  the  --profile
       option, below.

       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.


       Gawk options may be either traditional  POSIX  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.

       Following the POSIX standard,  gawk-specific  options  are
       supplied  via  arguments  to  the  -W option.  Multiple -W
       options may be supplied Each -W option has a corresponding
       long option, as detailed below.  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.


       Gawk accepts the following options, listed alphabetically.

              Read the AWK program source from the file  program-
              file,  instead of from the first command line argu-
              ment.  Multiple -f (or --file) options may be used.

       -mf NNN
       -mr NNN
              Set  various memory limits to the value NNN.  The f
              flag sets the maximum number of fields, and  the  r
              flag sets the maximum record size.  These two flags
              and the -m option are from  the  Bell  Laboratories
              research  version of UNIX awk.  They are ignored by
              gawk, since gawk has no pre-defined limits.

       -W compat
       -W traditional
              Run in compatibility mode.  In compatibility  mode,
              gawk  behaves  identically to UNIX awk; none of the
              GNU-specific extensions are recognized.  The use of
              --traditional  is preferred over the other forms of
              this option.  See GNU EXTENSIONS, below,  for  more

       -W copyleft
       -W copyright
              Print the short version of the GNU copyright infor-
              mation message on the standard output and exit suc-

       -W dump-variables[=file]
              Print  a  sorted  list  of  global variables, their
              types and final values to file.  If no file is pro-
              vided,  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 pro-
              grams.  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  inadver-
              tently  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

       -W help
       -W usage
       -W lint-old
              Provide warnings  about  constructs  that  are  not
              portable to the original version of Unix awk.

       -W gen-po
              Scan  and parse the AWK program, and generate a GNU
              .po format file on standard output with entries for
              all  localizable  strings in the program.  The pro-
              gram itself is not executed.  See the  GNU  gettext
              distribution for more information on .po files.

       -W non-decimal-data
              Recognize  octal  and  hexadecimal  values in input
              data.  Use this option with great caution!

       -W posix
              This turns on compatibility mode, with the  follow-
              ing additional restrictions:

              o \x escape sequences are not recognized.

              o Only  space  and tab act as field separators when
                FS is set to a single space, newline does not.

              o You cannot continue lines after ?  and :.

              o The synonym func for the keyword function is  not

              o The  operators ** and **= cannot be used in place
                of ^ and ^=.

              o The fflush() function is not available.

       -W profile[=prof_file]
              Send profiling data to prof_file.  The  default  is
              awkprof.out.   When  run  with gawk, the profile is
              just a "pretty printed"  version  of  the  program.
              When run with pgawk, the profile contains execution
              counts of each statement in the program in the left
              margin  and  function  call  counts  for each user-
              defined function.

       -W re-interval
              Enable the use of interval expressions  in  regular
              expression   matching   (see  Regular  Expressions,
              intended primarily for medium to large AWK programs
              used in shell scripts.

       -W 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 distributing.  This
              is also useful when reporting bugs.  (Per  the  GNU
              Coding Standards, these options cause an immediate,
              successful exit.)

       --     Signal the end of options. This is useful to  allow
              further  arguments  to  the  AWK  program itself to
              start with a "-".  This is mainly  for  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 program text has been supplied, unknown options
       are  passed  on  to  the AWK program in the ARGV array for
       processing.  This is particularly useful for  running  AWK
       programs via the "#!" executable interpreter mechanism.


       An  AWK  program  consists of a sequence of pattern-action
       statements and optional function definitions.
              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 con-
       catenated together.  This is useful for building 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 pro-
       The environment variable AWKPATH specifies a  search  path
       to use when finding source files named with the -f option.
       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.
       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 inter-
       nal  form.   Then,  gawk  executes  the  code in the BEGIN
       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,  the associated action is exe-
       cuted.  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 block(s) (if any).


       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.   Several  pre-
       defined variables are set as a program runs; these will be
       described as needed and summarized below.
       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 new-
       line character always acts as a field separator, in  addi-
       tion to whatever value FS may have.
       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 sepa-
       rated by that character.  If FS is the null  string,  then
       each  individual character becomes a separate field.  Oth-
       erwise, 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  discussion  of --posix, 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 overrides the use of FIELDWIDTHS, and restores
       the default behavior.
       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

       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
       ARGIND      The index in ARGV of the  current  file  being
       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 val-
                   ues 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
       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  pro-
                   grams which gawk spawns via redirection or the
                   system() function.
       ERRNO       If a system error occurs either doing a  redi-
                   rection  for  getline,  during a read for get-
                   line, or during a  close(),  then  ERRNO  will
                   contain  a  string  describing the error.  The
                   value is subject to translation in non-English
       FIELDWIDTHS A  white-space  separated list of fieldwidths.
                   When set, gawk parses the input into fields of
                   fixed width, instead of using the value of the
                   FS variable as the field separator.
       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 block (unless
                   set by getline).
       FNR         The input record number in the  current  input
                   matches  all  of the strings "ab", "aB", "Ab",
                   and "AB".  As with all AWK variables, the ini-
                   tial value of IGNORECASE is zero, so all regu-
                   lar expression and string operations are  nor-
                   mally  case-sensitive.   Under  Unix, the full
                   ISO 8859-1 Latin-1 character set is used  when
                   ignoring case.
       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
       NR          The total number of input records seen so far.
       OFMT        The  output  format  for  numbers,  "%.6g", by
       OFS         The  output  field  separator,  a   space   by
       ORS         The output record separator, by default a new-
       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  ele-
                   ments are guaranteed to be available:
                   PROCINFO["egid"]   the value of the getegid(2)
                                      system call.
                   PROCINFO["euid"]   the value of the geteuid(2)
                                      system call.
                   PROCINFO["FS"]     "FS"   if  field  splitting
                                      with FS is  in  effect,  or
                                      "FIELDWIDTHS"    if   field
                                      splitting with  FIELDWIDTHS
                                      is in effect.
                   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 cur-
                                      rent process.
                   PROCINFO["ppid"]   the parent  process  ID  of
                                      the current process.
                   PROCINFO["uid"]    the  value of the getuid(2)
                                      system call.
       RS          The input record separator, by default a  new-

       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 multi-
       ply 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 val-
       The special operator in may be used  in  an  if  or  while
       statement  to see 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.
       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.
   Variable Typing And Conversion
       Variables  and  fields may be (floating point) numbers, or
       strings, or both.  How the value of a variable  is  inter-
       preted  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.
       When  a  string must be converted to a number, the conver-
       sion is accomplished using strtod(3).  A  number  is  con-
       verted to a string by using the value of CONVFMT as a for-
       mat string for sprintf(3), with the numeric value  of  the
       variable  as  the argument.  However, even though all num-
       bers 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".
       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 numeri-
       cally.  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 the  POSIX
       standard  applies  the  concept of "numeric string" every-
       octal and hexadecimal constants in your AWK program source
       code.   For example, the octal value 011 is equal to deci-
       mal 9, and the hexadecimal value 0x11 is equal to  decimal
   String Constants
       String  constants  in  AWK  are  sequences  of  characters
       enclosed between double quotes (").  Within strings,  cer-
       tain escape sequences are recognized, as in C.  These are:
       \\   A literal backslash.
       \a   The "alert" character; usually the ASCII BEL  charac-
       \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 hexadeci-
            mal digits following the \x.  As in ANSI C, all  fol-
            lowing  hexadecimal digits are considered part of the
            escape sequence.  (This feature should tell us  some-
            thing  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) character.
       \c   The literal character c.
       The escape sequences may also be used inside constant reg-
       ular expressions (e.g., /[ \t\f\n\r\v]/ matches whitespace
       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/.


       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 ",",
       {, ?, :, &&, 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 will be ignored.
              ! 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 block.  They  are  executed
       before  any  of the input is read.  Similarly, all the END
       blocks 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.
       For /regular expression/ patterns, the  associated  state-
       ment  is  executed  for each input record that matches the
       regular expression.  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 certain fields match certain regular expres-
       The &&, ||, and !  operators are logical AND, logical  OR,
       and  logical  NOT,  respectively, as in C.  They do short-
       circuit evaluation, also as in C, and are used for combin-
       ing  more  primitive pattern expressions.  As in most lan-
       guages, parentheses may be used to  change  the  order  of
       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 com-
       bine 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...]   character  list,  matches any of the characters
       [^abc...]  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.
       \y         matches  the  empty string at either the begin-
                  ning or the end of a word.

       \B         matches the empty string within a word.

       \<         matches the empty string at the beginning of  a

       \>         matches  the empty string at the end of a word.

       \w         matches any word-constituent character (letter,
                  digit, or underscore).

       \W         matches  any  character  that  is not word-con-

       \`         matches the empty string at the beginning of  a
                  buffer (string).

       \'         matches  the  empty  string  at  the  end  of a

       The escape sequences that are valid  in  string  constants
       (see below) are also valid in regular expressions.

       Character  classes  are  a  new  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

       [: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.)

       [:xdigit:] Characters that are hexadecimal digits.

       For  example, before the POSIX standard, to match alphanu-
       meric  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.

       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  sev-
       eral  characters  that  are  equivalent  for collating, or
       sorting, purposes.  (E.g., in French, a plain  "e"  and  a
       grave-accented e` are equivalent.)

       Collating Symbols
              A  collating  symbol is a multi-character collating
              element enclosed in [.  and .].  For example, if ch
              is a collating element, 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 charac-
       ter classes; they do not recognize  collating  symbols  or
       equivalence classes.

       The  \y, \B, \<, \>, \w, \W, \`, and \' operators are spe-
       cific to gawk; they are extensions based on facilities  in
       the GNU regular expression libraries.

       The  various  command line options control how gawk inter-
       prets characters in regular expressions.

       No options
              In the default case, gawk provide all  the  facili-
              on).  Characters described by octal and hexadecimal
              escape sequences are  treated  literally,  even  if
              they represent regular expression metacharacters.

              Allow  interval expressions in regular expressions,
              even if --traditional has been provided.

       Action statements are enclosed in braces, { and }.  Action
       statements  consist  of the usual assignment, conditional,
       and looping statements found in most languages.  The oper-
       ators,  control  statements,  and  input/output statements
       available are patterned after those in C.

       The operators in AWK, in order of  decreasing  precedence,

       (...)       Grouping

       $           Field reference.

       ++ --       Increment and decrement, both prefix and post-

       ^           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.

       < >
       <= >=
       != ==       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 was intended.

       in          Array membership.

   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
              delete array[index]
              delete array
              exit [ expression ]
              { statements }

   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.

       getline <file         Set $0 from next record of file; set

       getline var           Set  var from next input record; set
                             NR, FNR.

       getline var <file     Set var from next record of file.

       command | getline [var]
                             Run command piping the output either
                             into $0 or var, as above.

       command |& getline [var]
                             Run  command  as a co-process piping
                             the output either into $0 or var, as
                             above.    Co-processes  are  a  gawk

       next                  Stop processing  the  current  input
                             record.   The  next  input record is
                             read and processing starts over with
                             the  first  pattern  in the AWK pro-
                             gram.  If the end of the input  data
                             put  record  is  terminated with the
                             value of the ORS variable.

       print expr-list       Prints expressions.  Each expression
                             is separated by the value of the OFS
                             variable.  The output record is ter-
                             minated  with  the  value of the ORS

       print expr-list >file Prints expressions  on  file.   Each
                             expression is separated by the value
                             of the  OFS  variable.   The  output
                             record  is terminated with the value
                             of the ORS variable.

       printf fmt, expr-list Format and print.

       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-

       fflush([file])        Flush  any  buffers  associated with
                             the open output file or  pipe  file.
                             If  file  is  missing, then standard
                             output is flushed.  If file  is  the
                             null  string,  then  all open output
                             files and pipes have  their  buffers

       Additional  output  redirections are allowed for print and

       print ... >> file
              appends output to the file.

       print ... | command
              writes on a pipe.

       print ... |& command
              sends data to a co-process.

       The getline command returns 0 on end of file and -1 on  an
       error.   Upon an error, ERRNO contains a string describing
       the problem.

       NOTE: If using a pipe or co-process to  getline,  or  from
       print  or  printf  within  a loop, you must use close() to
       create new instances of the command.  AWK does  not  auto-
       %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      A floating point number of the form [-]ddd.dddddd.

       %g ,  %G
               Use  %e  or  %f  conversion, whichever is shorter,
               with nonsignificant zeros suppressed.  The %G for-
               mat 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 for-
              matting.  This is called a positional specifier and
              is  intended  primarily  for use in translated ver-
              sions 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

       space  For numeric  conversions,  prefix  positive  values
              with  a  space,  and  negative  values with a minus

       +      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 let-
              ters.  For %o, supply a leading zero.  For %x,  and
              %X, supply a leading 0x or 0X for a nonzero result.
              For %e, %E, and %f, the result  always  contains  a
              decimal  point.  For %g, and %G, trailing zeros are
              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 signif-
              icant digits.  For the %d, %o, %i, %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

       The dynamic width and prec  capabilities  of  the  ANSI  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  preci-
       sion,  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:

       /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

              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 connec-

       /inet/tcp/lport/rhost/rport  File for TCP/IP connection on
                                    local  port  lport  to remote
                                    host  rhost  on  remote  port
                                    rport.   Use  a  port of 0 to

                   with a newline.

       /dev/ppid   Reading  this  file returns the parent process
                   ID of the current process, in decimal,  termi-
                   nated with a newline.

       /dev/pgrpid Reading this file returns the process group ID
                   of the current process, in decimal, terminated
                   with a newline.

       /dev/user   Reading this file returns a single record ter-
                   minated with a newline.  The fields are  sepa-
                   rated  with  spaces.   $1  is the value of the
                   getuid(2) system call, $2 is the value of  the
                   geteuid(2) system call, $3 is the value of the
                   getgid(2) system call, and $4 is the value  of
                   the  getegid(2) system call.  If there are any
                   additional fields,  they  are  the  group  IDs
                   returned by getgroups(2).  Multiple groups may
                   not be supported on all systems.

   Numeric Functions
       AWK has the following built-in arithmetic functions:

       atan2(y, x)   Returns the arctangent of y/x in radians.

       cos(expr)     Returns the cosine  of  expr,  which  is  in

       exp(expr)     The exponential function.

       int(expr)     Truncates to integer.

       log(expr)     The natural logarithm function.

       rand()        Returns a random number between 0 and 1.

       sin(expr)     Returns  the sine of expr, which is in radi-

       sqrt(expr)    The square root function.

       srand([expr]) Uses expr as a new seed for the random  num-
                     ber  generator.  If no expr is provided, the
                     time of day is used.  The  return  value  is
                     the previous seed for the random number gen-

   String Functions
       Gawk has the following built-in string functions:

       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 sup-
                               plied, $0 is used instead.  Within
                               the   replacement   text   s,  the
                               sequence \n, where n  is  a  digit
                               from  1 to 9, may be used to indi-
                               cate just the  text  that  matched
                               the  n'th parenthesized subexpres-
                               sion.  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  substitu-
                               tions.  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  discus-
                               sion  of  the  rules  for  &'s and
                               backslashes  in  the   replacement
                               text  of  sub(),  gsub(), and gen-

       index(s, t)             Returns the index of the string  t
                               in  the string s, or 0 if t is not

       length([s])             Returns the length of  the  string
                               s, or the length of $0 if s is not

       match(s, r [, a])       Returns the position  in  s  where
                               the  regular  expression r occurs,
                               or 0 if r is not present, and sets
                               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,
                               Splitting  behaves  identically to
                               field splitting, described  above.

       sprintf(fmt, expr-list) Prints expr-list according to fmt,
                               and returns the resulting  string.

       strtonum(str)           Examines   str,  and  returns  its
                               numeric value.  If str begins with
                               a  leading  0,  strtonum() assumes
                               that str is an octal  number.   If
                               str  begins  with  a leading 0x or
                               0X, strtonum() assumes that str is
                               a hexadecimal number.

       sub(r, s [, t])         Just  like  gsub(),  but  only the
                               first   matching   substring    is

       substr(s, i [, n])      Returns  the  at  most n-character
                               substring of s starting at i.   If
                               n  is  omitted,  the  rest of s is

       tolower(str)            Returns a copy of the string  str,
                               with all the upper-case characters
                               in str translated to their  corre-
                               sponding  lower-case counterparts.
                               Non-alphabetic characters are left

       toupper(str)            Returns  a copy of the string str,
                               with all the lower-case characters
                               in  str translated to their corre-
                               sponding upper-case  counterparts.
                               Non-alphabetic characters are left

   Time Functions
       Since one of the primary uses of AWK programs is  process-
       ing  log  files  that contain time stamp information, gawk
       provides the following functions for obtaining time stamps
       and formatting them.

                 Rurns  datespec  into  a  time stamp of the same
                 form as returned by systime().  The datespec  is
                 a  string of the form YYYY MM DD HH MM SS[ DST].
                 The contents of the string are six or seven num-
                 bers  representing  respectively  the  full year
                 including century, the month from 1 to  12,  the
                 day  of  the month from 1 to 31, the hour of the
                 fied time.  If datespec does not contain  enough
                 elements  or  if  the  resulting  time is out of
                 range, mktime() returns -1.

       strftime([format [, timestamp]])
                 Formats timestamp according to the specification
                 in  format.  The timestamp should be of the same
                 form as returned by systime().  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.  See the spec-
                 ification for the strftime() function in ANSI  C
                 for  the  format conversions that are guaranteed
                 to be available.   A  public-domain  version  of
                 strftime(3)  and  a  man  page  for it come with
                 gawk; if that version was used  to  build  gawk,
                 then  all  of  the conversions described in that
                 man page are available to gawk.

       systime() Returns 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
       Starting with version  3.1  of  gawk,  the  following  bit
       manipulation  functions  are available.  They work by con-
       verting double-precision floating point values to unsigned
       long  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 by v1 and v2.

       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 by v1 and v2.

       rshift(val, count)  Return the value of val, shifted right
                           by count bits.

       xor(v1, v2)         Return  the  bitwise XOR of the values
                           provided by v1 and v2.

   Internationalization Functions
       Starting with version 3.1 of gawk, the following functions
       may  be  used from within your AWK program for translating
       strings at run-time.  For full details, see  GAWK:  Effec-
              Returns the translation of string  in  text  domain
              domain  for  locale category category.  The default
              value for domain is the current  value  of  TEXTDO-
              MAIN.   The  default value for category is "LC_MES-
              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.


       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 parame-
       ters 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

       Since  functions  were not originally part of the AWK lan-
       guage, 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 inter-
       vening white space.  This is to avoid a syntactic  ambigu-
       ity  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.  Func-
       tion parameters used as local variables are initialized to
       the null string and the number zero upon function  invoca-

       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.

       extension(object, function)
               Dynamically link the shared object file  named  by
               object,  and  invoke  function  in that object, to
               perform initialization.  These should both be pro-
               vided  as  strings.  Returns the value returned by

       This function is provided and documented in  GAWK:  Effec-
       tive AWK Programming, but everything about this feature is
       likely to change in the next release.  We STRONGLY  recom-
       mend  that  you  do not use this feature for anything that
       you aren't willing to redo.


       pgawk 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 it to dump the profile and function call stack  and
       then exit.


       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 }


       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 requir-
       ing translation  to  the  native  natural  language.  Such
       strings  are  marked  in  the  AWK  program with a leading
       underscore ("_").  For example,

              gawk 'BEGIN { print "hello, world" }'

       always prints hello, world.  But,
           This  allows gawk to find the .mo file associated with
           your program.  Without this step, gawk uses  the  mes-
           sages  text  domain,  which  likely  does  not contain
           translations for your program.

       2.  Mark all strings that should be translated with  lead-
           ing underscores.

       3.  If  necessary,  use the dcgettext() and/or bindtextdo-
           main() functions in your program, as appropriate.

       4.  Run gawk --gen-po -f myprog.awk > myprog.po to  gener-
           ate a .po file for your program.

       5.  Provide   appropriate   translations,  and  build  and
           install a corresponding .mo file.

       The internationalization features are  described  in  full
       detail in GAWK: Effective AWK Programming.


       A  primary  goal  for gawk is compatibility with the POSIX
       standard, as well as with the latest version of UNIX  awk.
       To  this end, gawk incorporates the following user visible
       features which are not described in the AWK book, but  are
       part  of  the Bell Laboratories 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 block  is  executed.   How-
       ever,  in earlier implementations, when such an assignment
       appeared before any file names, the assignment would  hap-
       pen  before the BEGIN block 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 applica-
       tions  that depended upon the old behavior.  (This feature
       was agreed upon by both the Bell Laboratories and the  GNU

       The -W option for implementation specific features is from
       the POSIX standard.

       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
       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)

       This feature is marked as "deprecated" in the POSIX  stan-
       dard, and gawk issues a warning about its use if --lint is
       specified on the command line.

       The other feature is the use of either the continue or the
       break  statements  outside the body of a while, for, or do
       loop.  Traditional AWK implementations have  treated  such
       usage  as equivalent to the next statement.  Gawk supports
       this usage if --traditional has been specified.


       Gawk has a 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  --tradi-
       tional option.

       The  following features of gawk are not available in POSIX

       o No path search is performed for files named via  the  -f
         option.   Therefore  the AWKPATH environment variable is
         not special.

       o The \x escape sequence.  (Disabled with --posix.)

       o The fflush() function.  (Disabled with --posix.)

       o The ability to continue lines after ?  and :.  (Disabled
         with --posix.)

       o Octal and hexadecimal constants in AWK programs.

         variables are not special.

       o The IGNORECASE variable and  its  side-effects  are  not

       o The  FIELDWIDTHS  variable  and fixed-width field split-

       o The PROCINFO array is not available.
       o The optional third argument to the match() function.

       o The ability to use positional specifiers with printf and

       o The use of delete array to delete the entire contents of
         an array.

       o The use of nextfile to abandon processing of the current
         input file.

       o The and(), asort(),  bindtextdomain(),  compl(),  dcget-
         text(),  gensub(),  lshift(),  mktime(), or(), rshift(),
         strftime(), strtonum(), systime() and xor() functions.

       o Localizable strings.

       o Adding  new  built-in  functions  dynamically  with  the
         extension() function.

       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 redi-

       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  character.   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 specified.  To really
       get a tab character as the field separator, it is best  to
       use single quotes: gawk -F'\t' ....


       The  AWKPATH environment variable can be used to provide a
       list of directories that gawk searches  when  looking  for
       files named via the -f and --file options.

       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.


       egrep(1), getpid(2),  getppid(2),  getpgrp(2),  getuid(2),
       geteuid(2), getgid(2), getegid(2), getgroups(2)

       message.  Such  programs  are  surprisingly  difficult  to
       diagnose in the completely general case, and the effort to
       do so really is not worth it.


       The original version of UNIX awk was designed  and  imple-
       mented   by   Alfred  Aho,  Peter  Weinberger,  and  Brian
       Kernighan of Bell Laboratories.  Brian Kernighan continues
       to maintain and enhance it.

       Paul  Rubin and Jay Fenlason, of the Free Software Founda-
       tion, wrote gawk, to be compatible with the original  ver-
       sion  of  awk  distributed  in Seventh Edition UNIX.  John
       Woods contributed a number of bug fixes.   David  Trueman,
       with contributions from Arnold Robbins, made gawk compati-
       ble with the new version of UNIX awk.  Arnold  Robbins  is
       the current maintainer.

       The  initial  DOS  port  was done by Conrad Kwok and Scott
       Garfinkle.  Scott Deifik is the  current  DOS  maintainer.
       Pat  Rankin did the port to VMS, and Michal Jaegermann did
       the port to the Atari ST.  The port to OS/2  was  done  by
       Kai  Uwe  Rommel,  with contributions and help from Darrel
       Hankerson.  Fred Fish  supplied  support  for  the  Amiga,
       Stephen  Davies provided the Tandem port, and Martin Brown
       provided the BeOS port.


       This man page documents gawk, version 3.1.0.


       If you find a bug in gawk, please send electronic mail  to
       bug-gawk@gnu.org.   Please  include  your operating system
       and its revision, the version of gawk  (from  gawk  --ver-
       sion),  what C compiler you used to compile it, and a test
       program and data that are as small as possible for  repro-
       ducing the problem.

       Before sending a bug report, please do two 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 read this man page and the refer-
       ence 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 unre-
       liable way to report bugs.  Instead, please use the  elec-
       tronic mail addresses given above.

       tim  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 permis-
       sion notice may be stated in a translation approved by the

Free Software Foundation   May 29 2001                    GAWK(1)

Web Hosting, web hosting, JSP, Servlets, Tomcat, website hosting, web site hosting
Add to My Yahoo!

XML icon

Add to Google












JSP at alden-servlet-Hosting.com
Servlets at alden-servlet-Hosting.com
Servlet at alden-servlet-Hosting.com
Tomcat at alden-servlet-Hosting.com
MySQL at alden-servlet-Hosting.com
Java at alden-servlet-Hosting.com
sFTP at alden-servlet-Hosting.com
JSP at alden-tomcat-Hosting.com
Servlets at alden-tomcat-Hosting.com
Servlet at alden-tomcat-Hosting.com
Tomcat at alden-tomcat-Hosting.com
MySQL at alden-tomcat-Hosting.com
Java at alden-tomcat-Hosting.com
sFTP at alden-tomcat-Hosting.com
JSP at alden-sftp-Hosting.com
Servlets at alden-sftp-Hosting.com
Servlet at alden-sftp-Hosting.com
Tomcat at alden-sftp-Hosting.com
MySQL at alden-sftp-Hosting.com
Java at alden-sftp-Hosting.com
sFTP at alden-sftp-Hosting.com
JSP at alden-jsp-Hosting.com
Servlets at alden-jsp-Hosting.com
Servlet at alden-jsp-Hosting.com
Tomcat at alden-jsp-Hosting.com
MySQL at alden-jsp-Hosting.com
Java at alden-jsp-Hosting.com
sFTP at alden-jsp-Hosting.com
JSp at alden-java-Hosting.com
Servlets at alden-java-Hosting.com
Servlet at alden-java-Hosting.com
Tomcat at alden-java-Hosting.com
MySQL at alden-java-Hosting.com
Java at alden-java-Hosting.com
sFTP at alden-java-Hosting.com
JSP Servlets Tomcat mysql Java JSP Servlets Tomcat mysql Java JSP Servlets Tomcat mysql Java JSP Servlets Tomcat mysql Java JSP at JSP.aldenWEBhosting.com Servlets at servlets.aldenWEBhosting.com Tomcat at Tomcat.aldenWEBhosting.com mysql at mysql.aldenWEBhosting.com Java at Java.aldenWEBhosting.com Web Hosts Portal Web Links Web Links JSP Web Links servlet Tomcat Docs Web Links Web Links JSP Web Links servlet Web Hosting Tomcat Docs JSP Solutions Web Links JSP Solutions Web Hosting Servlets Solutions Web Links Servlets Solutions Web Hosting Web Links Web Links . .
. .
. . . . jsp hosting servlets hosting web hosting web sites designed cheap web hosting web site hosting myspace web hosting