xbmc/utils/RegExp.cpp

   1 /*
   2  *      Copyright (C) 2005-2008 Team XBMC
   3  *      http://www.xbmc.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with XBMC; see the file COPYING.  If not, write to
  17  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *  http://www.gnu.org/copyleft/gpl.html
  19  *
  20  */
  21
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include "RegExp.h"
  25 #include "StdString.h"
  26 #include "log.h"
  27
  28 using namespace PCRE;
  29
  30 CRegExp::CRegExp(bool caseless)
  31 {
  32   m_re          = NULL;
  33   m_iOptions    = PCRE_DOTALL;
  34   if(caseless)
  35     m_iOptions |= PCRE_CASELESS;
  36
  37   m_bMatched    = false;
  38   m_iMatchCount = 0;
  39 }
  40
  41 CRegExp::CRegExp(const CRegExp& re)
  42 {
  43   m_re = NULL;
  44   m_iOptions = re.m_iOptions;
  45   *this = re;
  46 }
  47
  48 const CRegExp& CRegExp::operator=(const CRegExp& re)
  49 {
  50   size_t size;
  51   Cleanup();
  52   m_pattern = re.m_pattern;
  53   if (re.m_re)
  54   {
  55     if (pcre_fullinfo(re.m_re, NULL, PCRE_INFO_SIZE, &size) >= 0)
  56     {
  57       if ((m_re = (pcre*)malloc(size)))
  58       {
  59         memcpy(m_re, re.m_re, size);
  60         memcpy(m_iOvector, re.m_iOvector, OVECCOUNT*sizeof(int));
  61         m_iMatchCount = re.m_iMatchCount;
  62         m_bMatched = re.m_bMatched;
  63         m_subject = re.m_subject;
  64         m_iOptions = re.m_iOptions;
  65       }
  66     }
  67   }
  68   return *this;
  69 }
  70
  71 CRegExp::~CRegExp()
  72 {
  73   Cleanup();
  74 }
  75
  76 CRegExp* CRegExp::RegComp(const char *re)
  77 {
  78   if (!re)
  79     return NULL;
  80
  81   m_bMatched         = false;
  82   m_iMatchCount      = 0;
  83   const char *errMsg = NULL;
  84   int errOffset      = 0;
  85
  86   Cleanup();
  87
  88   m_re = pcre_compile(re, m_iOptions, &errMsg, &errOffset, NULL);
  89   if (!m_re)
  90   {
  91     m_pattern.clear();
  92     CLog::Log(LOGERROR, "PCRE: %s. Compilation failed at offset %d in expression '%s'",
  93               errMsg, errOffset, re);
  94     return NULL;
  95   }
  96
  97   m_pattern = re;
  98
  99   return this;
 100 }
 101
 102 int CRegExp::RegFind(const char* str, int startoffset)
 103 {
 104   m_bMatched    = false;
 105   m_iMatchCount = 0;
 106
 107   if (!m_re)
 108   {
 109     CLog::Log(LOGERROR, "PCRE: Called before compilation");
 110     return -1;
 111   }
 112
 113   if (!str)
 114   {
 115     CLog::Log(LOGERROR, "PCRE: Called without a string to match");
 116     return -1;
 117   }
 118
 119   m_subject = str;
 120   int rc = pcre_exec(m_re, NULL, str, strlen(str), startoffset, 0, m_iOvector, OVECCOUNT);
 121
 122   if (rc<1)
 123   {
 124     switch(rc)
 125     {
 126     case PCRE_ERROR_NOMATCH:
 127       return -1;
 128
 129     case PCRE_ERROR_MATCHLIMIT:
 130       CLog::Log(LOGERROR, "PCRE: Match limit reached");
 131       return -1;
 132
 133     default:
 134       CLog::Log(LOGERROR, "PCRE: Unknown error: %d", rc);
 135       return -1;
 136     }
 137   }
 138   m_bMatched = true;
 139   m_iMatchCount = rc;
 140   return m_iOvector[0];
 141 }
 142
 143 int CRegExp::GetCaptureTotal()
 144 {
 145   int c = -1;
 146   if (m_re)
 147     pcre_fullinfo(m_re, NULL, PCRE_INFO_CAPTURECOUNT, &c);
 148   return c;
 149 }
 150
 151 char* CRegExp::GetReplaceString( const char* sReplaceExp )
 152 {
 153   char *src = (char *)sReplaceExp;
 154   char *buf;
 155   char c;
 156   int no;
 157   size_t len;
 158
 159   if( sReplaceExp == NULL || !m_bMatched )
 160     return NULL;
 161
 162
 163   // First compute the length of the string
 164   int replacelen = 0;
 165   while ((c = *src++) != '\0')
 166   {
 167     if (c == '&')
 168       no = 0;
 169     else if (c == '\\' && isdigit(*src))
 170       no = *src++ - '0';
 171     else
 172       no = -1;
 173
 174     if (no < 0)
 175     {
 176       // Ordinary character.
 177       if (c == '\\' && (*src == '\\' || *src == '&'))
 178         c = *src++;
 179       replacelen++;
 180     }
 181     else if (no < m_iMatchCount && (m_iOvector[no*2]>=0))
 182     {
 183       // Get tagged expression
 184       len = m_iOvector[no*2+1] - m_iOvector[no*2];
 185       replacelen += len;
 186     }
 187   }
 188
 189   // Now allocate buf
 190   buf = (char *)malloc((replacelen + 1)*sizeof(char));
 191   if( buf == NULL )
 192     return NULL;
 193
 194   char* sReplaceStr = buf;
 195
 196   // Add null termination
 197   buf[replacelen] = '\0';
 198
 199   // Now we can create the string
 200   src = (char *)sReplaceExp;
 201   while ((c = *src++) != '\0')
 202   {
 203     if (c == '&')
 204       no = 0;
 205     else if (c == '\\' && isdigit(*src))
 206       no = *src++ - '0';
 207     else
 208       no = -1;
 209
 210     if (no < 0)
 211     {
 212       // Ordinary character.
 213       if (c == '\\' && (*src == '\\' || *src == '&'))
 214         c = *src++;
 215       *buf++ = c;
 216     }
 217     else if (no < m_iMatchCount && (m_iOvector[no*2]>=0))
 218     {
 219       // Get tagged expression
 220       len = m_iOvector[no*2+1] - m_iOvector[no*2];
 221       strncpy(buf, m_subject.c_str()+m_iOvector[no*2], len);
 222       buf += len;
 223     }
 224   }
 225
 226   return sReplaceStr;
 227 }
 228
 229 std::string CRegExp::GetMatch(int iSub /* = 0 */)
 230 {
 231   if (iSub < 0 || iSub > m_iMatchCount)
 232     return "";
 233
 234   int pos = m_iOvector[(iSub*2)];
 235   int len = m_iOvector[(iSub*2)+1] - pos;
 236   return m_subject.substr(pos, len);
 237 }
 238
 239 bool CRegExp::GetNamedSubPattern(const char* strName, std::string& strMatch)
 240 {
 241   strMatch.clear();
 242   int iSub = pcre_get_stringnumber(m_re, strName);
 243   if (iSub < 0)
 244     return false;
 245   strMatch = GetMatch(iSub);
 246   return true;
 247 }
 248
 249 void CRegExp::DumpOvector(int iLog /* = LOGDEBUG */)
 250 {
 251   if (iLog < LOGDEBUG || iLog > LOGNONE)
 252     return;
 253
 254   CStdString str = "{";
 255   int size = GetSubCount(); // past the subpatterns is junk
 256   for (int i = 0; i <= size; i++)
 257   {
 258     CStdString t;
 259     t.Format("[%i,%i]", m_iOvector[(i*2)], m_iOvector[(i*2)+1]);
 260     if (i != size)
 261       t += ",";
 262     str += t;
 263   }
 264   str += "}";
 265   CLog::Log(iLog, "regexp ovector=%s", str.c_str());
 266 }