Annotation of libelwix/src/regex.c, revision 1.2

1.1       misho       1: /*************************************************************************
                      2: * (C) 2013 AITNET ltd - Sofia/Bulgaria - <misho@aitnet.org>
                      3: *  by Michael Pounov <misho@elwix.org>
                      4: *
                      5: * $Author: misho $
1.2     ! misho       6: * $Id: regex.c,v 1.1.1.1.34.1 2014/01/29 14:11:45 misho Exp $
1.1       misho       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: 
1.2     ! misho      15: Copyright 2004 - 2014
1.1       misho      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: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>