Return to regex.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / libelwix / src

version 2.7

    1: /*************************************************************************
    2: * (C) 2013 AITNET ltd - Sofia/Bulgaria - <misho@aitnet.org>
    3: *  by Michael Pounov <misho@elwix.org>
    4: *
    5: * $Author: misho $
    6: * $Id: regex.c,v 1.2 2014/01/29 14:16:54 misho Exp $
    7: *
    8: **************************************************************************
    9: The ELWIX and AITNET software is distributed under the following
   10: terms:
   11: 
   12: All of the documentation and software included in the ELWIX and AITNET
   13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   14: 
   15: Copyright 2004 - 2014
   16: 	by Michael Pounov <misho@elwix.org>.  All rights reserved.
   17: 
   18: Redistribution and use in source and binary forms, with or without
   19: modification, are permitted provided that the following conditions
   20: are met:
   21: 1. Redistributions of source code must retain the above copyright
   22:    notice, this list of conditions and the following disclaimer.
   23: 2. Redistributions in binary form must reproduce the above copyright
   24:    notice, this list of conditions and the following disclaimer in the
   25:    documentation and/or other materials provided with the distribution.
   26: 3. All advertising materials mentioning features or use of this software
   27:    must display the following acknowledgement:
   28: This product includes software developed by Michael Pounov <misho@elwix.org>
   29: ELWIX - Embedded LightWeight unIX and its contributors.
   30: 4. Neither the name of AITNET nor the names of its contributors
   31:    may be used to endorse or promote products derived from this software
   32:    without specific prior written permission.
   33: 
   34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
   35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   37: ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   44: SUCH DAMAGE.
   45: */
   46: #include "global.h"
   47: 
   48: 
   49: /*
   50:  * regex_Verify() - Function for verify data match in regex expression
   51:  *
   52:  * @csRegex = Regulare expression pattern
   53:  * @csData = Data for check and verify
   54:  * @startPos = Return start positions
   55:  * @endPos = Return end positions
   56:  * return: NULL not match or error; !=NULL begin of matched data
   57:  */
   58: const char *
   59: regex_Verify(const char *csRegex, const char *csData, int *startPos, int *endPos)
   60: {
   61: 	regex_t re;
   62: 	regmatch_t match;
   63: 	char szErr[STRSIZ];
   64: 	int ret, flg;
   65: 	const char *pos;
   66: 
   67: 	if (!csRegex || !csData)
   68: 		return NULL;
   69: 
   70: 	if ((ret = regcomp(&re, csRegex, REG_EXTENDED))) {
   71: 		regerror(ret, &re, szErr, STRSIZ);
   72: 		elwix_SetErr(ret, "%s", szErr);
   73: 		regfree(&re);
   74: 		return NULL;
   75: 	}
   76: 
   77: 	for (ret = flg = 0, pos = csData; !(ret = regexec(&re, pos, 1, &match, flg)); 
   78: 			pos += match.rm_eo, flg = REG_NOTBOL) {
   79: 		if (startPos)
   80: 			*startPos = match.rm_so;
   81: 		if (endPos)
   82: 			*endPos = match.rm_eo;
   83: 
   84: 		pos += match.rm_so;
   85: 		break;
   86: 	}
   87: 
   88: 	if (ret) {
   89: 		regerror(ret, &re, szErr, STRSIZ);
   90: 		elwix_SetErr(ret, "%s", szErr);
   91: 		pos = NULL;
   92: 	}
   93: 
   94: 	regfree(&re);
   95: 	return pos;
   96: }
   97: 
   98: /*
   99:  * regex_Get() - Function for get data match in regex expression
  100:  *
  101:  * @csRegex = Regulare expression pattern
  102:  * @csData = Data from get
  103:  * @psString = Returned string if match
  104:  * @strLen = Length of string
  105:  * return: 0 not match; >0 count of returned chars
  106:  */
  107: int
  108: regex_Get(const char *csRegex, const char *csData, char * __restrict psString, int strLen)
  109: {
  110: 	int sp, ep, len;
  111: 	const char *str;
  112: 
  113: 	if (!csRegex || !csData)
  114: 		return -1;
  115: 
  116: 	str = regex_Verify(csRegex, csData, &sp, &ep);
  117: 	if (!str)
  118: 		return 0;
  119: 
  120: 	len = ep - sp;
  121: 	if (psString && strLen) {
  122: 		memset(psString, 0, strLen);
  123: 		strncpy(psString, str, strLen <= len ? strLen - 1 : len);
  124: 	}
  125: 
  126: 	return len;
  127: }
  128: 
  129: /*
  130:  * regex_Replace() - Function for replace data match in regex expression with newdata
  131:  *
  132:  * @csRegex = Regulare expression pattern
  133:  * @csData = Source data
  134:  * @csNew = Data for replace
  135:  * return: NULL not match or error; !=NULL allocated new string, must be e_free after use!
  136:  */
  137: char *
  138: regex_Replace(const char *csRegex, const char *csData, const char *csNew)
  139: {
  140: 	int sp, ep, len;
  141: 	char *tmp, *str = NULL;
  142: 
  143: 	if (!csRegex || !csData)
  144: 		return NULL;
  145: 
  146: 	if (!regex_Verify(csRegex, csData, &sp, &ep))
  147: 		return NULL;
  148: 
  149: 	// ___ before match
  150: 	len = sp + 1;
  151: 	str = e_malloc(len);
  152: 	if (!str)
  153: 		return NULL;
  154: 	else
  155: 		strlcpy(str, csData, len);
  156: 	// * replace match *
  157: 	if (csNew) {
  158: 		len += strlen(csNew);
  159: 		tmp = e_realloc(str, len);
  160: 		if (!tmp) {
  161: 			e_free(str);
  162: 			return NULL;
  163: 		} else {
  164: 			str = tmp;
  165: 			strlcat(str, csNew, len);
  166: 		}
  167: 	}
  168: 	// after match ___
  169: 	len += strlen(csData) - ep;
  170: 	tmp = e_realloc(str, len);
  171: 	if (!tmp) {
  172: 		e_free(str);
  173: 		return NULL;
  174: 	} else {
  175: 		str = tmp;
  176: 		strlcat(str, csData + ep, len);
  177: 	}
  178: 
  179: 	return str;
  180: }