dreg.txt

emboss的linux版本的源代码

                                   dreg 



Function

   Regular expression search of a nucleotide sequence

Description

   This searches for matches of a regular expression to a nucleic acid
   sequence.

   A regular expression is a way of specifying an ambiguous pattern to
   search for. Regular expressions are commonly used in some computer
   programming languages and may be more familiar to some users than to
   others.

   The following is a short guide to regular expressions in EMBOSS:

   ^
          use this at the start of a pattern to insist that the pattern
          can only match at the start of a sequence. (eg. '^AUG' matches
          a start codon at the start of the sequence)

   $
          use this at the end of a pattern to insist that the pattern can
          only match at the end of a sequence (eg. 'A+$' matches a poly-A
          sequence at the end of the sequence)

   ()
          groups a pattern. This is commonly used with '|' (eg.
          '(AUG)|(ATG)' matches either the DNA or RNA form of the
          initiation codon )

   |
          This is the OR operator to enable a match to be made to either
          one pattern OR another. There is no AND operator in this
          version of regular expressions.

   The following quantifier characters specify the number of time that
   the character before (in this case 'x') matches:

   x?
          matches 0 or 1 times (ie, '' or 'x')

   x*
          matches 0 or more times (ie, '' or 'x' or 'xx' or 'xxx', etc)

   x+
          matches 1 or more times (ie, 'x' or 'xx' or 'xxx', etc)

   {min,max}
          Braces can enclose the specification of the minimum and maximum
          number of matches. A match of 'x' of between 3 and 6 times is:
          'x{3,6}'

   Quantifiers can follow any of the following types of character
   specification:

   x
          any character (ie 'A')

   \x
          the character after the backslash is used instead of its normal
          regular expression meaning. This is commonly used to turn off
          the special meaning of the characters '^$()|?*+[]-.'. It may be
          especially useful when searching for gap characters in a
          sequence (eg '\.' matches only a dot character '.')

   [xy]
          match one of the characters 'x' or 'y'. You may have one or
          more characters in this set.

   [x-z]
          match any one of the set of characters starting with 'x' and
          ending in 'y' in ASCII order (eg '[A-G]' matches any one of:
          'A', 'B', 'C', 'D', 'E', 'F', 'G')

   [^x-z]
          matches anything except any one of the group of characters in
          ASCII order (eg '[^A-G]' matches anything EXCEPT any one of:
          'A', 'B', 'C', 'D', 'E', 'F', 'G')

   .
          the dot character matches any other character (eg: 'A.G'
          matches 'AAG', 'AaG', 'AZG', 'A-G' 'A G', etc.)

   Combining some of these features gives the example:
'([AGC]+GGG)|(TTTGGG)'

   which matches one or more of any one of 'A' or 'G' or 'C' followed by
   three 'G's or it matches just 'TTTGGG'.

   Regular expressions are case-sensitive. The pattern 'AAAA' will not
   match the sequence 'aaaa'. For this reason, both your pattern and the
   input sequences are converted to upper-case.

The syntax in detail

   EMBOSS uses the publicly available PCRE code library to do regular
   expressions.

   The full documentation of the PCRE system can be seen at
   http://www.pcre.org/pcre.txt

   A condensed description of the syntax of PCRE follows, without
   features that are thought not to be required for searching for
   patterns in sequences (e.g. matching non-printing characters, atomic
   grouping, back-references, assertion, conditional sub-patterns,
   recursive patterns, subpatterns as subroutines, callouts). If you do
   neot see a required function described below, please see the full
   description on the PCRE web site.

  PCRE REGULAR EXPRESSION DETAILS

   The syntax and semantics of the regular expressions supported by PCRE
   are described below. Regular expressions are also described in the
   Perl documentation and in a number of other books, some of which have
   copious examples. Jeffrey Friedl's "Mastering Regular Expressions",
   published by O'Reilly, covers them in great detail. The description
   here is intended as reference documentation.

   A regular expression is a pattern that is matched against a subject
   string from left to right. Most characters stand for themselves in a
   pattern, and match the corresponding characters in the subject. As a
   trivial example, the pattern

   The quick brown fox

   matches a portion of a subject string that is identical to itself. The
   power of regular expressions comes from the ability to include
   alternatives and repetitions in the pattern. These are encoded in the
   pattern by the use of meta-characters, which do not stand for
   themselves but instead are interpreted in some special way.

   There are two different sets of meta-characters: those that are
   recognized anywhere in the pattern except within square brackets, and
   those that are recognized in square brackets. Outside square brackets,
   the meta-characters are as follows:

       \      general escape character with several uses
       ^      assert start of string (or line, in multiline mode)
       $      assert end of string (or line, in multiline mode)
       .      match any character except newline (by default)
       [      start character class definition
       |      start of alternative branch
       (      start subpattern
       )      end subpattern
       ?      extends the meaning of (
              also 0 or 1 quantifier
              also quantifier minimizer
       *      0 or more quantifier
       +      1 or more quantifier
              also "possessive quantifier"
       {      start min/max quantifier

   Part of a pattern that is in square brackets is called a "character
   class". In a character class the only meta-characters are:

       \      general escape character
       ^      negate the class, but only if the first character
       -      indicates character range
       [      POSIX character class (only if followed by POSIX
                syntax)
       ]      terminates the character class

   The following sections describe the use of each of the
   meta-characters.

    BACKSLASH

   The backslash character has several uses. Firstly, if it is followed
   by a non-alphameric character, it takes away any special meaning that
   character may have. This use of backslash as an escape character
   applies both inside and outside character classes.

   For example, if you want to match a * character, you write \* in the
   pattern. This escaping action applies whether or not the following
   character would otherwise be interpreted as a meta-character, so it is
   always safe to precede a nonalphameric with backslash to specify that
   it stands for itself. In particular, if you want to match a backslash,
   you write \\.

   The third use of backslash is for specifying generic character types:

       \d     any decimal digit
       \D     any character that is not a decimal digit
       \s     any whitespace character
       \S     any character that is not a whitespace character
       \w     any "word" character
       W     any "non-word" character

   Each pair of escape sequences partitions the complete set of
   characters into two disjoint sets. Any given character matches one,
   and only one, of each pair.

   A "word" character is any letter or digit or the underscore character,
   that is, any character which can be part of a Perl "word". The
   definition of letters and digits is controlled by PCRE's character
   tables, and may vary if locale- specific matching is taking place (see
   "Locale support" in the pcreapi page). For example, in the "fr"
   (French) locale, some character codes greater than 128 are used for
   accented letters, and these are matched by \w.

   These character type sequences can appear both inside and outside
   character classes. They each match one character of the appropriate
   type. If the current matching point is at the end of the subject
   string, all of them fail, since there is no character to match.

   The fourth use of backslash is for certain simple assertions. An
   assertion specifies a condition that has to be met at a particular
   point in a match, without consuming any characters from the subject
   string. The use of subpatterns for more complicated assertions is
   described below. The backslashed assertions are

       \b     matches at a word boundary
       \B     matches when not at a word boundary
       \A     matches at start of subject
       \Z     matches at end of subject or before newline at end
       \z     matches at end of subject
       \G     matches at first matching position in subject

   These assertions may not appear in character classes (but note that \b
   has a different meaning, namely the backspace character, inside a
   character class).

   A word boundary is a position in the subject string where the current
   character and the previous character do not both match \w or \W (i.e.
   one matches \w and the other matches \W), or the start or end of the
   string if the first or last character matches \w, respectively. The
   \A, \Z, and \z assertions differ from the traditional circumflex and
   dollar (described below) in that they only ever match at the very
   start and end of the subject string, whatever options are set. Thus,
   they are independent of multiline mode.

    CIRCUMFLEX AND DOLLAR

   Outside a character class, in the default matching mode, the
   circumflex character is an assertion which is true only if the current
   matching point is at the start of the subject string. Inside a
   character class, circumflex has an entirely different meaning (see
   below).

   Circumflex need not be the first character of the pattern if a number
   of alternatives are involved, but it should be the first thing in each
   alternative in which it appears if the pattern is ever to match that
   branch. If all possible alternatives start with a circumflex, that is,
   if the pattern is constrained to match only at the start of the
   subject, it is said to be an "anchored" pattern. (There are also other
   constructs that can cause a pattern to be anchored.)

   A dollar character is an assertion which is true only if the current
   matching point is at the end of the subject string, or immediately
   before a newline character that is the last character in the string
   (by default). Dollar need not be the last character of the pattern if
   a number of alternatives are involved, but it should be the last item
   in any branch in which it appears. Dollar has no special meaning in a
   character class.

    FULL STOP (PERIOD, DOT)

   Outside a character class, a dot in the pattern matches any one
   character in the subject, including a non-printing character, but not
   (by default) newline. The handling of dot is entirely independent of
   the handling of circumflex and dollar, the only relationship being
   that they both involve newline characters. Dot has no special meaning
   in a character class.

    SQUARE BRACKETS

   An opening square bracket introduces a character class, terminated by
   a closing square bracket. A closing square bracket on its own is not
   special. If a closing square bracket is required as a member of the
   class, it should be the first data character in the class (after an
   initial circumflex, if present) or escaped with a backslash.

   A character class matches a single character in the subject. A matched
   character must be in the set of characters defined by the class,
   unless the first character in the class definition is a circumflex, in
   which case the subject character must not be in the set defined by the
   class. If a circumflex is actually required as a member of the class,
   ensure it is not the first character, or escape it with a backslash.

   For example, the character class [aeiou] matches any lower case vowel,
   while [^aeiou] matches any character that is not a lower case vowel.
   Note that a circumflex is just a convenient notation for specifying
   the characters which are in the class by enumerating those that are
   not. It is not an assertion: it still consumes a character from the
   subject string, and fails if the current pointer is at the end of the
   string.

   When caseless matching is set, any letters in a class represent both
   their upper case and lower case versions, so for example, a caseless
   [aeiou] matches "A" as well as "a", and a caseless [^aeiou] does not
   match "A", whereas a caseful version would. PCRE does not support the
   concept of case for characters with values greater than 255. A class
   such as [^a] will always match a newline.

   The minus (hyphen) character can be used to specify a range of
   characters in a character class. For example, [d-m] matches any letter
   between d and m, inclusive. If a minus character is required in a
   class, it must be escaped with a backslash or appear in a position
   where it cannot be interpreted as indicating a range, typically as the
   first or last character in the class.

   It is not possible to have the literal character "]" as the end
   character of a range. A pattern such as [W-]46] is interpreted as a
   class of two characters ("W" and "-") followed by a literal string
   "46]", so it would match "W46]" or "-46]". However, if the "]" is
   escaped with a backslash it is interpreted as the end of range, so
   [W-\]46] is interpreted as a single class containing a range followed
   by two separate characters. The octal or hexadecimal representation of
   "]" can also be used to end a range.

   The character types \d, \D, \s, \S, \w, and \W may also appear in a
   character class, and add the characters that they match to the class.
   For example, [\dABCDEF] matches any hexadecimal digit. A circumflex
   can conveniently be used with the upper case character types to
   specify a more restricted set of characters than the matching lower
   case type. For example, the class [^\W_] matches any letter or digit,