libc
/* $Id$ */
/* Copyright (c) 2012-2017 Pierre Pronchery <khorben@defora.org> */
/* This file is part of DeforaOS System libc */
/* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "regex.h"
#include "dlfcn.h"
#include "regex/pcre/pcre.h"
/* XXX */
#undef PACKAGE
#undef VERSION
#include "../config.h"
#ifndef PREFIX
# define PREFIX "/usr/local"
#endif
#ifndef LIBDIR
# define LIBDIR PREFIX "/lib"
#endif
/* private */
/* prototypes */
static int _pcre_init(void);
/* variables */
static struct
{
int error;
char const * message;
} _messages[] =
{
{ REG_NOMATCH, "No match" },
{ REG_BADPAT, "Invalid regular expression" },
{ REG_ECOLLATE, "Invalid collating element referenced" },
{ REG_ECTYPE, "Invalid character class type referenced" },
{ REG_EESCAPE, "Trailing '\\' in pattern" },
{ REG_ESUBREG, "Number in \\digit invalid or in error" },
{ REG_EBRACK, "\"[]\" imbalance" },
{ REG_EPAREN, "\"\\(\\)\" or \"()\" imbalance" },
{ REG_EBRACE, "\"\\{\\}\" imbalance" },
{ REG_BADBR, "Content of \"\\{\\}\" invalid" },
{ REG_ERANGE, "Invalid endpoint in range expression" },
{ REG_ESPACE, "Out of memory" },
{ REG_BADRPT, "'?', '*', or '+' not preceded by valid regular"
" expression" },
{ REG_ENOSYS, "Not implemented" }
};
static void * _pcre_handle = NULL;
static void * (*_pcre_compile2)(const char *, int, int *, const char **,
int *, const unsigned char *);
static int (*_pcre_exec)(const void *, const void *, const char *,
int, int, int, int *, int);
static int (*_pcre_fullinfo)(const void *, const void *, int,
void *);
/* public */
/* functions */
/* regcomp */
static int _regcomp_error(int error);
int regcomp(regex_t * regex, const char * pattern, int flags)
{
int pflags = 0;
int perror = 0;
const char * p;
int poffset;
int nsub;
if(_pcre_init() != 0)
return REG_ENOSYS;
/* XXX implement more flags */
if(flags & REG_ICASE)
pflags |= PCRE_CASELESS;
if(flags & REG_NEWLINE)
pflags |= PCRE_MULTILINE;
if((regex->re_pcre = _pcre_compile2(pattern, pflags, &perror, &p,
&poffset, NULL)) == NULL)
return _regcomp_error(perror);
_pcre_fullinfo(regex->re_pcre, NULL, PCRE_INFO_CAPTURECOUNT, &nsub);
regex->re_nsub = nsub;
return 0;
}
static int _regcomp_error(int error)
{
switch(error)
{
case 1:
case 2:
case 3:
return REG_EESCAPE;
case 4:
case 5:
return REG_BADBR;
case 8:
return REG_ERANGE;
default:
return REG_ENOSYS;
}
}
/* regerror */
size_t regerror(int error, const regex_t * regex, char * buf, size_t buf_cnt)
{
size_t i;
char const * message = "Unknown error";
int res;
(void) regex;
for(i = 0; i < sizeof(_messages) / sizeof(*_messages); i++)
if(_messages[i].error == error)
{
message = _messages[i].message;
break;
}
if((res = snprintf(buf, buf_cnt, "%s", message)) <= 0)
return 0;
return res + 1;
}
/* regexec */
static int _regexec_error(int error);
int regexec(const regex_t * regex, const char * string, size_t match_cnt,
regmatch_t match[], int flags)
{
int pflags = 0;
int * pmatch;
int res;
size_t i;
if(_pcre_init() != 0)
return REG_ENOSYS;
if(flags & REG_NOTBOL)
pflags |= PCRE_NOTBOL;
if(flags & REG_NOTEOL)
pflags |= PCRE_NOTEOL;
if(match_cnt > 0)
{
if((pmatch = malloc(sizeof(*pmatch) * match_cnt * 3)) == NULL)
return REG_ESPACE;
}
else
pmatch = NULL;
if((res = _pcre_exec(regex->re_pcre, NULL, string, strlen(string), 0,
pflags, pmatch, match_cnt * 3)) >= 0)
{
for(i = 0; i < match_cnt; i++)
{
match[i].rm_so = pmatch[i * 2];
match[i].rm_eo = pmatch[i * 2 + 1];
}
free(pmatch);
return 0;
}
free(pmatch);
return _regexec_error(res);
}
static int _regexec_error(int error)
{
switch(error)
{
case PCRE_ERROR_NOMATCH:
return REG_NOMATCH;
case PCRE_ERROR_MATCHLIMIT:
case PCRE_ERROR_NOMEMORY:
return REG_ESPACE;
default:
return REG_ENOSYS;
}
}
/* regfree */
void regfree(regex_t * regex)
{
free(regex->re_pcre);
}
/* private */
/* pcre_init */
static int _pcre_init(void)
{
if(_pcre_handle != NULL)
return 0;
if((_pcre_handle = __dlopen(LIBDIR "/libpcre.so", RTLD_NOW)) == NULL
&& (_pcre_handle = __dlopen(NULL, RTLD_NOW)) == NULL)
return -1;
if((_pcre_compile2 = __dlsym(_pcre_handle, "pcre_compile2")) == NULL
|| (_pcre_exec = __dlsym(_pcre_handle, "pcre_exec"))
== NULL
|| (_pcre_fullinfo = __dlsym(_pcre_handle,
"pcre_fullinfo")) == NULL)
{
__dlclose(_pcre_handle);
_pcre_handle = NULL;
return -1;
}
return 0;
}