# pcre2_dfa_match

## NAME



           PCRE2 - Perl-compatible regular expressions (revised API)
    


## SYNOPSIS



    
           **#include <pcre2.h>**
    
           **int pcre2_dfa_match(const pcre2_code ***_code_**, PCRE2_SPTR** _subject_**,**
             **PCRE2_SIZE** _length_**, PCRE2_SIZE** _startoffset_**,**
             **uint32_t** _options_**, pcre2_match_data ***_match_data_**,**
             **pcre2_match_context ***_mcontext_**,**
             **int ***_workspace_**, PCRE2_SIZE** _wscount_**);**
    


## DESCRIPTION



    
           This function matches a compiled regular expression against a
           given subject string, using an alternative matching algorithm that
           scans the subject string just once (except when processing
           lookaround assertions). This function is _not_ Perl-compatible (the
           Perl-compatible matching function is **pcre2_match()**). The arguments
           for this function are:
    
             _code_         Points to the compiled pattern
             _subject_      Points to the subject string
             _length_       Length of the subject string
             _startoffset_  Offset in the subject at which to start matching
             _options_      Option bits
             _match_data_   Points to a match data block, for results
             _mcontext_     Points to a match context, or is NULL
             _workspace_    Points to a vector of ints used as working space
             _wscount_      Number of elements in the vector
    
           The size of output vector needed to contain all the results
           depends on the number of simultaneous matches, not on the number
           of parentheses in the pattern. Using
           **pcre2_match_data_create_from_pattern()** to create the match data
           block is therefore not advisable when using this function.
    
           A match context is needed only if you want to set up a callout
           function or specify the heap limit or the match or the recursion
           depth limits. The _length_ and _startoffset_ values are code units,
           not characters. The options are:
    
             PCRE2_ANCHORED          Match only at the first position
             PCRE2_COPY_MATCHED_SUBJECT
                                     On success, make a private subject copy
             PCRE2_ENDANCHORED       Pattern can match only at end of subject
             PCRE2_NOTBOL            Subject is not the beginning of a line
             PCRE2_NOTEOL            Subject is not the end of a line
             PCRE2_NOTEMPTY          An empty string is not a valid match
             PCRE2_NOTEMPTY_ATSTART  An empty string at the start of the
           subject
                                      is not a valid match
             PCRE2_NO_UTF_CHECK      Do not check the subject for UTF
                                      validity (only relevant if PCRE2_UTF
                                      was set at compile time)
             PCRE2_PARTIAL_HARD      Return PCRE2_ERROR_PARTIAL for a partial
                                      match even if there is a full match
             PCRE2_PARTIAL_SOFT      Return PCRE2_ERROR_PARTIAL for a partial
                                      match if no full matches are found
             PCRE2_DFA_RESTART       Restart after a partial match
             PCRE2_DFA_SHORTEST      Return only the shortest match
    
           There are restrictions on what may appear in a pattern when using
           this matching function. Details are given in the **pcre2matching**
           documentation. For details of partial matching, see the
           **pcre2partial** page. There is a complete description of the PCRE2
           native API in the **pcre2api** page and a description of the POSIX API
           in the **pcre2posix** page.
    


* * *