Basic Guide for Regular Expressions
http://en.wikipedia.org/wiki/Regular_expression

The "basic" Unix regular expression syntax is now defined as obsolete by POSIX,
but is still widely used for the purposes of backwards compatibility. Most
regular-expression.aware Unix utilities, for example grep and sed, use it by default.

In this syntax, most characters are treated as literals.they match only themselves
("a" matches "a", "(bc" matches "(bc", etc). The exceptions are called metacharacters:
. 	Matches any single character
[ ] 	Matches a single character that is contained within the brackets. For example,
	[abc] matches "a", "b", or "c". [a-z] matches any lowercase letter. These can
	be mixed: [abcq-z] matches a, b, c, q, r, s, t, u, v, w, x, y, z, and so does [a-cq-z].

The '-' character should be literal only if it is the last or the first character
within the brackets: [abc-] or [-abc]. To match an '[' or ']' character, the
easiest way is to make sure the closing bracket is first in the enclosing square
brackets: [][ab] matches ']', '[', 'a' or 'b'.

[^ ] 	Matches a single character that is not contained within the brackets. For example,
	[^abc] matches any character other than "a", "b", or "c". [^a-z] matches any single
	character that is not a lowercase letter. As above, these can be mixed.
^ 	Matches the start of the line (or any line, when applied in multiline mode)
$ 	Matches the end of the line (or any line, when applied in multiline mode)
\( \) 	Define a "marked subexpression". What the enclosed expression matched can be
	recalled later. See the next entry, \n. Note that a "marked subexpression" is also a "block"
\n 	Where n is a digit from 1 to 9; matches what the nth marked subexpression matched.
	This construct is theoretically irregular and has not been adopted in the
	extended regular expression syntax.
* 	

    * A single character expression followed by "*" matches zero or more copies of the
	expression. For example, "[xyz]*" matches "", "x", "y", "zx", "zyx", and so on.
    * \n*, where n is a digit from 1 to 9, matches zero or more iterations of what the
	nth marked subexpression matched. For example, "\(a.\)c\1*" matches "abcab" and "abcaba" but not "abcac".
    * An expression enclosed in "\(" and "\)" followed by "*" is deemed to be invalid.
	In some cases (e.g. /usr/bin/xpg4/grep of SunOS 5.8), it matches zero or more
	iterations of the string that the enclosed expression matches. In other cases
	(e.g. /usr/bin/grep of SunOS 5.8), it matches what the enclosed expression matches, followed by a literal "*".

\{x,y\} 	Match the last "block" at least x and not more than y times. For example,
	"a\{3,5\}" matches "aaa", "aaaa" or "aaaaa". Note that this is not found in some instances of regex.

Note that particular implementations of regular expressions interpret backslash
differently in front of some of the metacharacters. For example, egrep and Perl
interpret unbackslashed parentheses and vertical bars as metacharacters, reserving
the backslashed versions to mean the literal characters themselves.

Old versions of grep did not support the alternation operator "|". Examples:

    ".at" matches any three-character string like hat, cat or bat
    "[hc]at" matches hat and cat
    "[^b]at" matches all the matched strings from the regex ".at" except bat
    "^[hc]at" matches hat and cat but only at the beginning of a line
    "[hc]at$" matches hat and cat but only at the end of a line