n_pcre.c

Go to the documentation of this file.

 
#include "nilorea/n_pcre.h"
#include "nilorea/n_log.h"
#include "strings.h"
 
#include "string.h"
 
 
N_PCRE *npcre_new( char *str, int max_cap, int flags )
{
                N_PCRE *pcre = NULL ;
                __n_assert( str, return NULL );
 
                Malloc( pcre, N_PCRE, 1 );
                __n_assert( pcre, return NULL );
 
                pcre -> captured = 0 ;
 
                if( max_cap <= 0 )
                {
                                max_cap = 1 ;
                }
                pcre -> match_list = NULL ;
 
                pcre -> regexp_str = strdup( str );
                __n_assert( str, npcre_delete( &pcre ); return NULL );
 
                pcre -> ovecount = max_cap ;
                Malloc( pcre -> ovector, int, 3 * max_cap );
                __n_assert( pcre -> ovector, npcre_delete( &pcre ); return NULL );
 
                const char *error = NULL ;
                int erroroffset = 0 ;
 
                pcre -> regexp = pcre_compile( str, flags,  &error, &erroroffset, NULL  ) ;
                if( !pcre -> regexp )
                {
                                n_log( LOG_ERR, " pcre compilation of %s failed at offset %d : %s", str, erroroffset, error );
                                npcre_delete( &pcre );
                                return FALSE ;
                }
                /* no flags for study = no JIT compilation */
                pcre -> extra = pcre_study( pcre -> regexp, 0, &error );
 
                return pcre ;
}/* npcre_new(...) */
 
 
 
int npcre_delete( N_PCRE ** pcre )
{
                __n_assert( pcre&&(*pcre), return FALSE );
 
                if( (*pcre) -> ovector )
                {
                                Free( (*pcre) -> ovector );
                }
                if( (*pcre) -> regexp )
                {
                                pcre_free( (*pcre) -> regexp );
                                (*pcre) -> regexp = NULL ;
                }
#ifdef __linux__
                pcre_free_study(  (*pcre) -> extra );
                (*pcre) -> extra = NULL ;
#else
                pcre_free( (*pcre) -> extra );
                (*pcre) -> extra = NULL ;
#endif
                if( (*pcre) -> captured > 0 )
                {
                                pcre_free_substring_list( (*pcre) -> match_list );
                }
                FreeNoLog( (*pcre) -> regexp_str );
                FreeNoLog( (*pcre) );
                return TRUE ;
} /* npcre_delete (...) */
 
 
 
 
int npcre_clean_match( N_PCRE *pcre )
{
                __n_assert( pcre, return FALSE );
                __n_assert( pcre -> match_list, return FALSE );
 
                if( pcre -> captured > 0 )
                {
                                pcre -> captured = 0 ;
                                pcre_free_substring_list( pcre -> match_list );
                }
 
                return TRUE ;
} /* npcre_clean_match */
 
 
int npcre_match( char *str, N_PCRE *pcre )
{
                __n_assert( str, return FALSE );
                __n_assert( pcre, return FALSE );
                __n_assert( pcre -> regexp_str, return FALSE );
                __n_assert( pcre -> regexp, return FALSE );
 
                int rc, len = 0;
                len = ( int )strlen( str ) ;
 
                rc = pcre_exec( pcre -> regexp, pcre -> extra, str, len, 0, 0, pcre -> ovector, pcre -> ovecount );
                if ( rc < 0 )
                {
                                switch( rc )
        {
            case PCRE_ERROR_NOMATCH      : /* n_log( LOG_DEBUG , "String did not match the pattern");*/   break;
            case PCRE_ERROR_NULL         : n_log( LOG_DEBUG , "Something was null");                      break;
            case PCRE_ERROR_BADOPTION    : n_log( LOG_DEBUG , "A bad option was passed");                 break;
            case PCRE_ERROR_BADMAGIC     : n_log( LOG_DEBUG , "Magic number bad (compiled re corrupt?)"); break;
            case PCRE_ERROR_UNKNOWN_NODE : n_log( LOG_DEBUG , "Something kooky in the compiled regexp");  break;
            case PCRE_ERROR_NOMEMORY     : n_log( LOG_DEBUG , "Ran out of memory");                       break;
            default                      : n_log( LOG_DEBUG , "Unknown error");                           break;
 
        }
        return FALSE ;
                }
                else if( rc == 0 )
                {
                                rc = pcre -> ovecount ;
                }
 
                if( rc > 0 )
                {
                                npcre_clean_match( pcre );
                                pcre -> captured = rc ;
                                pcre_get_substring_list( str, pcre -> ovector, rc, &pcre -> match_list );
                }
                return TRUE ;
}/* npcre_match(...) */