#!/usr/bin/gawk -f
{
        ## spaces to underscores:
        gsub(" ","_")

        ## some html escapes:
        gsub(">",">")
        gsub("&lt;","<")
        gsub("&quot;","\"")
        gsub("&amp;","\\&")

        ## square brackets into round brackets:
        gsub("\\[","(")
        gsub("\\]",")")

        ## double-quotes into apostrophes:
        gsub("\"","'")

        ## sanitize the rest:
        gsub("[^- 'a-zA-Z0-9_$+&<>]*","")

        ## dump it to stdout
        print
}

NASTYNAME="whatever.. "
GOODNAME=`echo "$NASTYNAME" | sanitize.awk`

   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....
       [^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.
       (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.
                  Interval expressions are only available if either --posix or --re-interval is specified
                  on the command line.

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

       \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 below)  are  also  valid  in  regular
       expressions.

        ## backquotes become apostrophes:
        gsub("`","'")

        ## backslashes become dashes:
        gsub("\\\\","-")

        ## slashes, question marks, carats, dollarsigns become underscores:
        gsub("[/?^$]","_")

   String Constants
       String constants in AWK are sequences of characters enclosed between double  quotes  (").   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 ANSI
            C, all following hexadecimal digits are considered part of the escape sequence.   (This  fea‐
            ture 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) character.
       \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/.

       [:space:]  Space characters (such as space, tab, and formfeed, to name a few).