Regular expression and other patterns are used to identify motifs in molecular sequences.

AJAX library files for handling patterns are listed in the table (Table 6.7, “AJAX Library Files for Handling Patterns”). Library file documentation, including a complete description of datatypes and functions with usage notes is available at:

ajreg.h/c. Defines the regular expression object (AjPRegexp) and functions for handling of regular expressions.

ajpat.h/c. Defines the sequence pattern list object (AjPPatlistSeq) and general pattern list object (AjPPatlistRegex) and functions for handling lists of regular expression patterns. They contain static data structures and functions for handling sequence patterns at a low level.

You are unlikely to need the static data structures and functions unless you plan to implement code to extend the functionality of the libraries themselves.

In addition to the above library files, EMBOSS includes a library of functions to support regular expressions whose syntax and semantics are as close as possible to those of the Perl 5 language. The library files are:

pcre_config.h  
pcre_internal.h  
pcre.h           
pcre.c             
pcreposix.h  
pcreposix.c  
pcre_printint.c
pcre_chartables.c  
pcre_get.c     
pcre_study.c

They are not described here and you should see the online library documentation for further information.

There are two datatypes for handling pattern input:

Typical ACD definitions are shown below.

regexp: patterns 
[
    information: "Regular expression patterns"
    upper: "Y"
    minlength: "3"
    minlength: "10"
]

pattern: seqpatterns 
[
    information: "Sequence patterns"
    type: "nucleotide"
    pmismatch: "0"
]

The basic AJAX datatype for handling patterns is:

Two AJAX datatypes are provided for handling lists of patterns including input patterns defined in the ACD file. These are lists of individual patterns and regular expressions using the datatypes below.:

The following AJAX datatypes are provided for handling regular expressions at a low level beyond that provided by the static data structures and functions. You are unlikely to need to use these directly:

Datatypes and functions for handling pattern input via the ACD file are shown below (Table 6.8, “Datatypes and Functions for Pattern Input”).

Your application code will call embInit to process the ACD file and command line (see Section 6.3, “Handling ACD Files”). All values from the ACD file are read into memory and files are opened as necessary. You have a handle on the files and memory through the ajAcdGet* family of functions which return pointers to appropriate objects.

    AjPPatlistRegex patterns=NULL;

    patterns = ajAcdGetRegexp("patterns");

    AjPPatlistSeq seqpatterns=NULL;

    seqpatterns = ajAcdGetPattern("seqpatterns");

AjPRegexp     ajAcdGetRegexpSingle (const char *token);

    AjPRegexp regexp=NULL;

    regexp = ajAcdGetRegexpSingle("patterns");

These functions are used in ACD processing to convert a pattern qualifier value (a pattern or a filename reference) into a pattern or regular expressin list. They can be used to define patterns from strings or files:

/* Parses a file of regular expressions into a pattern list object. */
AjPPatlistRegex  ajPatlistRegexRead(const AjPStr patspec,
                                    const AjPStr patname,
                                    const AjPStr fmt,
                                    ajuint type, 
                                    AjBool upper, AjBool lower);

/* Parses a file into pattern list object. */
AjPPatlistSeq  ajPatlistSeqRead(const AjPStr patspec,
                                const AjPStr patname,
                                const AjPStr fmt,
                                AjBool protein, 
                                ajuint mismatches);

/* Resets the pattern list iteration. */
void  ajPatlistSeqRewind (AjPPatlistSeq thys);
void  ajPatlistRegexRewind (AjPPatlistRegex thys);

Applications work at the level of lists of patterns and regular expressions. For these, functions are available to return the number of items in the list, and to return the next item.

/* Gets next available pattern from list. */
AjBool  ajPatlistSeqGetNext (AjPPatlistSeq thys,
                             AjPPatternSeq* pattern);

/* Gets number of patterns from list. */
ajuint  ajPatlistSeqGetSize (const AjPPatlistSeq plist);

/* Gets number of patterns from list. */
ajuint  ajPatlistRegexGetSize (const AjPPatlistRegex plist);

/* Gets next available pattern from list. */
AjBool  ajPatlistRegexGetNext (AjPPatlistRegex thys,
                               AjPPatternRegex* pattern);

There are further functions to return elements of each ietm retrieved from a list:

/* Returns the name of the pattern. */
const AjPStr  ajPatternSeqGetName (const AjPPatternSeq thys);

/* Returns pattern in string format. */
const AjPStr  ajPatternSeqGetPattern (const AjPPatternSeq thys);

/* Returns void pointer to compiled pattern. */
AjPPatComp  ajPatternSeqGetCompiled (const AjPPatternSeq thys);

/* Returns true if the pattern is for a protein sequence. */
AjBool  ajPatternSeqGetProtein (const AjPPatternSeq thys);

/* Returns the mismatch of the pattern. */
ajuint  ajPatternSeqGetMismatch (const AjPPatternSeq thys);

/* Returns the name of the pattern */
const AjPStr  ajPatternRegexGetName (const AjPPatternRegex thys);

/* Returns pattern in string format. */
const AjPStr  ajPatternRegexGetPattern (const AjPPatternRegex thys);

/* Returns void pointer to compiled pattern. */
AjPRegexp  ajPatternRegexGetCompiled (const AjPPatternRegex thys);

/* Returns the type of the pattern. */
ajuint  ajPatternRegexGetType (const AjPPatternRegex thys);

There are no elements that should be set within the pattern list objects

These functions report the internals of pattern objects to the debug fiule when -debug is set on the command line.

void  ajPatternSeqDebug (const AjPPatternSeq pat);
void  ajPatternRegexDebug (const AjPPatternRegex pat);

These functions copy a list of patterns to a string for use in debugging:

ajuint  ajPatlistRegexDoc (AjPPatlistRegex thys, AjPStr* pdoc);

ajuint  ajPatlistSeqDoc (AjPPatlistSeq thys, AjPStr* pdoc);

There is also a function to return the type associated with a named type of regular expression:

ajuint  ajPatternRegexType (const AjPStr type);