bool set(const char *loc) {
setlocale(LC_ALL, loc);
__super::reset(pcre_maketables());
#ifdef _DEBUG
if (operator !()) _RPT3(_CRT_ERROR, "%s(\"%s\"): %s() returned NULL\n",
__FUNCTION__, loc, "pcre_maketables");
#endif // _DEBUG
return get() != 0;
}
int mireSetLocale(/*@unused@*/ miRE mire, const char * locale)
{
const char * locale_from = NULL;
int rc = -1; /* assume failure */
/* XXX TODO: --locale jiggery-pokery should be done env LC_ALL=C rpmgrep */
if (locale == NULL) {
if (locale)
locale_from = "--locale";
else {
/*
* If a locale has not been provided as an option, see if the
* LC_CTYPE or LC_ALL environment variable is set, and if so,
* use it.
*/
/*@-dependenttrans -observertrans@*/
if ((locale = getenv("LC_ALL")) != NULL)
locale_from = "LC_ALL";
else if ((locale = getenv("LC_CTYPE")) != NULL)
locale_from = "LC_CTYPE";
/*@=dependenttrans =observertrans@*/
if (locale)
locale = xstrdup(locale);
}
}
/*
* If a locale has been provided, set it, and generate the tables PCRE
* needs. Otherwise, _mirePCREtables == NULL, which uses default tables.
*/
if (locale != NULL) {
const char * olocale = setlocale(LC_CTYPE, locale);
if (olocale == NULL) {
/*@-modfilesys@*/
fprintf(stderr,
_("%s: Failed to set locale %s (obtained from %s)\n"),
__progname, locale, locale_from);
/*@=modfilesys@*/
goto exit;
}
#if defined(WITH_PCRE)
/*@-evalorderuncon -onlytrans @*/
_mirePCREtables = pcre_maketables();
/*@=evalorderuncon =onlytrans @*/
#ifdef NOTYET
if (setlocale(LC_CTYPE, olocale) == NULL)
goto exit;
#endif
#endif
}
rc = 0;
exit:
return rc;
}
static
void init_pcre(void)
{
if (pcre_established == 0) {
pcre_malloc = n_malloc;
pcre_free = free;
pcre_chartable = pcre_maketables();
#if 0
if (pcre_chartable != NULL)
printf("pcre_chartable ON: %s\n", pcre_chartable);
#endif
pcre_established = 1;
}
}
SEXP _gregexpr(SEXP _pattern, SEXP _text, SEXP _subpattern)
{
SEXP ans;
pcre *re_pcre;
pcre_extra *re_pe;
int erroffset;
const char *errorptr;
//int options = 0;
const unsigned char* tables = pcre_maketables();
const char* spat = as_string(_pattern);
re_pcre = pcre_compile(spat, 0, &errorptr, &erroffset, tables);
if (!re_pcre)
{
if (errorptr)
Rprintf("PCRE pattern compilation error\n\t'%s'\n\tat '%s'\n",
errorptr, spat+erroffset);
Rprintf("invalid regular expression '%s'\n", spat);
}
re_pe = pcre_study(re_pcre, 0, &errorptr);
int n = LENGTH(_text);
SEXP elt;
PROTECT(ans = allocVector(VECSXP, n));
const void *vmax = vmaxget();
for (int i = 0 ; i < n ; i++) {
if (STRING_ELT(_text, i) == NA_STRING) {
elt = gregexpr_NAInputAns();
} else {
const char* s = as_string(_text,i);
elt = _pcre(spat, s, re_pcre, re_pe, *REAL(_subpattern));
}
SET_VECTOR_ELT(ans, i, elt);
vmaxset(vmax);
}
if (re_pe) pcre_free(re_pe);
pcre_free(re_pcre);
pcre_free((void *)tables);
UNPROTECT(1);
return ans;
}
static int compile_regex (lua_State *L, const TArgComp *argC, TPcre **pud) {
const char *error;
int erroffset;
TPcre *ud;
const unsigned char *tables = NULL;
ud = (TPcre*)lua_newuserdata (L, sizeof (TPcre));
memset (ud, 0, sizeof (TPcre)); /* initialize all members to 0 */
lua_pushvalue (L, LUA_ENVIRONINDEX);
lua_setmetatable (L, -2);
if (argC->locale) {
char old_locale[256];
strcpy (old_locale, setlocale (LC_CTYPE, NULL)); /* store the locale */
if (NULL == setlocale (LC_CTYPE, argC->locale)) /* set new locale */
return luaL_error (L, "cannot set locale");
ud->tables = tables = pcre_maketables (); /* make tables with new locale */
setlocale (LC_CTYPE, old_locale); /* restore the old locale */
}
else if (argC->tables) {
tables = argC->tables;
lua_pushinteger (L, INDEX_CHARTABLES_LINK);
lua_rawget (L, LUA_ENVIRONINDEX);
lua_pushvalue (L, -2);
lua_pushvalue (L, argC->tablespos);
lua_rawset (L, -3);
lua_pop (L, 1);
}
ud->pr = pcre_compile (argC->pattern, argC->cflags, &error, &erroffset, tables);
if (!ud->pr)
return luaL_error (L, "%s (pattern offset: %d)", error, erroffset + 1);
ud->extra = pcre_study (ud->pr, 0, &error);
if (error) return luaL_error (L, "%s", error);
pcre_fullinfo (ud->pr, ud->extra, PCRE_INFO_CAPTURECOUNT, &ud->ncapt);
/* need (2 ints per capture, plus one for substring match) * 3/2 */
ud->match = (int *) Lmalloc (L, (ALG_NSUB(ud) + 1) * 3 * sizeof (int));
if (pud) *pud = ud;
return 1;
}
int check_regexp_match(const char *str, const char *pattern)
{
int options = PCRE_UTF8;
const char *error;
int erroffset;
const unsigned char *tables = pcre_maketables();
pcre *re = pcre_compile(pattern, options, &error, &erroffset, tables);
if (!re)
{
log_message(ERROR, _("Can't compile regular expression '%s'"), pattern);
return FALSE;
}
int str_len = strlen(str);
int ovector[50];
int count = pcre_exec(re, NULL, str, str_len, 0, 0, ovector, 50);
if (count <= 0 && count != PCRE_ERROR_NOMATCH)
{
log_message(ERROR, _("Can't exec regular expression '%s', eror code %d"), pattern, count);
pcre_free(re);
pcre_free((void*)tables);
return FALSE;
}
pcre_free(re);
pcre_free((void*)tables);
if (count == PCRE_ERROR_NOMATCH)
return FALSE;
const char *pcre_string = NULL;
if(pcre_get_substring(str, ovector, count, 0, &pcre_string) < 0)
return FALSE;
//log_message(TRACE, _("Match word '%s' and PERL pattern '%s'"), str, pattern);
pcre_free_substring(pcre_string);
return TRUE;
}
static int fill_patterns(unsigned char (*replaces)[2])
{
const unsigned char *lc_tables = pcre_maketables();
int i;
const char *pcre_errptr;
int pcre_erroffset;
setlocale(LC_CTYPE, "en_US.UTF-8");
for (i=1, pcre_errptr = NULL; i < sizeof(patterns)/sizeof(patterns[0]); i++) {
patterns[i].repl_marker = i;
patterns[i].replaces = replaces;
patterns[i].compile =
pcre_compile(
patterns[i].regex,
PCRE_MULTILINE | PCRE_UTF8,
&pcre_errptr, &pcre_erroffset,
lc_tables
);
if ( !(patterns[i].compile) ) {
fprintf(stderr, "%s\n", pcre_errptr);
return 1;
}
patterns[i].extra = pcre_study(patterns[i].compile, 0, &pcre_errptr);
if (pcre_errptr) {
fprintf(stderr, "%s\n", pcre_errptr);
return 1;
} else if ( !(patterns[i].extra) ) {
if ( !(patterns[i].extra = (pcre_extra *)malloc(sizeof(pcre_extra))) ) {
fprintf(stderr, "In file %s, line %d ", __FILE__, __LINE__);
perror("error allocate memory");
exit(errno);
}
}
patterns[i].extra->flags |= PCRE_EXTRA_CALLOUT_DATA;
patterns[i].extra->callout_data = &patterns[i];
}
return 0;
}
void
myPCRE::compile(const std::string &pattern )
{
std::cout << "pattern: (" << pattern << ");" << std::endl;
const char *error;
int erroffset;
const unsigned char *tables = NULL;
if(re){
pcre_free(re);
}
// создание таблицы перекодировки для локали ru
setlocale (LC_CTYPE, (const char *) "ru.");
tables = pcre_maketables();
// компилирование регулярного выражения во внутреннее представление
int options = 0;
re = pcre_compile (pattern.c_str(), options, &error, &erroffset, NULL);
}
static void compile_pcre_regexp(struct grep_pat *p, const struct grep_opt *opt)
{
const char *error;
int erroffset;
int options = PCRE_MULTILINE;
if (opt->ignore_case) {
if (has_non_ascii(p->pattern))
p->pcre_tables = pcre_maketables();
options |= PCRE_CASELESS;
}
if (is_utf8_locale() && has_non_ascii(p->pattern))
options |= PCRE_UTF8;
p->pcre_regexp = pcre_compile(p->pattern, options, &error, &erroffset,
p->pcre_tables);
if (!p->pcre_regexp)
compile_regexp_failed(p, error);
p->pcre_extra_info = pcre_study(p->pcre_regexp, 0, &error);
if (!p->pcre_extra_info && error)
die("%s", error);
}
static void compile_pcre1_regexp(struct grep_pat *p, const struct grep_opt *opt)
{
const char *error;
int erroffset;
int options = PCRE_MULTILINE;
if (opt->ignore_case) {
if (has_non_ascii(p->pattern))
p->pcre1_tables = pcre_maketables();
options |= PCRE_CASELESS;
}
if (is_utf8_locale() && has_non_ascii(p->pattern))
options |= PCRE_UTF8;
p->pcre1_regexp = pcre_compile(p->pattern, options, &error, &erroffset,
p->pcre1_tables);
if (!p->pcre1_regexp)
compile_regexp_failed(p, error);
p->pcre1_extra_info = pcre_study(p->pcre1_regexp, PCRE_STUDY_JIT_COMPILE, &error);
if (!p->pcre1_extra_info && error)
die("%s", error);
#ifdef GIT_PCRE1_USE_JIT
pcre_config(PCRE_CONFIG_JIT, &p->pcre1_jit_on);
if (p->pcre1_jit_on == 1) {
p->pcre1_jit_stack = pcre_jit_stack_alloc(1, 1024 * 1024);
if (!p->pcre1_jit_stack)
die("Couldn't allocate PCRE JIT stack");
pcre_assign_jit_stack(p->pcre1_extra_info, NULL, p->pcre1_jit_stack);
} else if (p->pcre1_jit_on != 0) {
die("BUG: The pcre1_jit_on variable should be 0 or 1, not %d",
p->pcre1_jit_on);
}
#endif
}
bool Universe::Run()
{
bool continueFlag; //Continue game or not
char inPacket[256]; //Holds the input packet
char outPacket[256]; //Holds the output packet
int iResult; //The result of 'Receive' and 'Send'
continueFlag = true;
connectSocket = new ClientSocket(serverAddress, serverPort);
printf("Connected to the server\n");
CreatePacket(outPacket, LogIn, "%s%s", login, password);
connectSocket->Send(outPacket);
game = NULL;
currentCharacter = NULL;
ClientGUIInit();
//variables for camera
cameraY = 50.0f;
ISceneNode* camPos=render->smgr->addEmptySceneNode();
camPos->setPosition(vector3df(50.0f,cameraY,10.0f));
camera=render->smgr->addCameraSceneNode(NULL, vector3df(50.0f, 50.0f, 10.0f), vector3df(50.0f, 0.0f, 40.0f));
scene::ISceneNode* lnode;
lnode = render->smgr->addLightSceneNode(NULL, camPos->getPosition(), video::SColorf(1.0f, 1.0f, 1.0f, 1.0f), 800.0f);
render->smgr->setAmbientLight(video::SColor(0, 60, 60, 60));
state = Continue;
int lastUpdate = render->device->getTimer()->getTime();
while (render->device->run() && state == Continue)
{
//Receving packet from the server
iResult = connectSocket->Receive(inPacket);
if (iResult)
{
if (iResult > 0)
{ //Packet received
switch (GetPacketType(inPacket))
{
case LoggedIn:
char gameName[256];
int locationId;
ScanPacket(inPacket, "%s%i", gameName, &locationId);
game = new Game(gameName, Client);
printf("Game %s initialized\n", game->name);
currentLocation = game->data->GetLocation(locationId);
DrawScene();
break;
case NPCSpawned:
currentLocation->SpawnNPC(new CurrentNPC(inPacket));
break;
case StaticSpawned:
{
CurrentStatic* currentStatic = new CurrentStatic(inPacket);
currentLocation->SpawnStatic(currentStatic);
break;
}
case ItemSpawned:
char spawnType; //TODO: SpawnType as char
ScanPacket(inPacket, "%i%i%f%f%b", NULL, NULL, NULL, NULL, &spawnType);
switch(spawnType)
{
case Ground:
currentLocation->SpawnItem(new CurrentItem(inPacket));
break;
case Inventory:
currentCharacter->SpawnItem(new CurrentItem(inPacket));
break;
}
break;
case CharacterSpawned:
if (!currentCharacter)
{
currentCharacter = new CurrentCharacter(inPacket);
currentLocation->SpawnCharacter(currentCharacter);
}
else
{
currentLocation->SpawnCharacter(new CurrentCharacter(inPacket));
}
break;
case SkillSpawned:
currentCharacter->SpawnSkill(new CurrentSkill(inPacket));
break;
case NPCUnspawned:
currentLocation->UnSpawnNPC(currentLocation->GetNPC(PacketGetInt(inPacket, 1)));
break;
case StaticUnspawned:
currentLocation->UnSpawnStatic(currentLocation->GetStatic(PacketGetInt(inPacket, 1)));
break;
case ItemUnspawned:
switch(PacketGetByte(inPacket, 5))
{
case Ground:
currentLocation->UnSpawnItem(currentLocation->GetItem(PacketGetInt(inPacket, 1)));
break;
case Inventory:
//currentCharacter->UnSpawnItem(currentCharacter->GetItem(PacketGetInt(inPacket, 1)));
break;
}
break;
case CharacterUnspawned:
currentLocation->UnSpawnCharacter(currentLocation->GetCharacter(PacketGetInt(inPacket, 1)));
break;
case Say:
{
IGUIElement* eb = guienv->getRootGUIElement()->getElementFromId(ChatBox)->getElementFromId(ChatEditBox);
char messageType; //TODO: MessageType as char
int senderCurrentCharacterId;
wchar_t messageText[CHAT_MESSAGE_MAX_LENGTH];
ScanPacket(inPacket, "%b%i%ws", &messageType, &senderCurrentCharacterId, messageText);
CurrentCharacter* sender = game->data->GetCharacter(senderCurrentCharacterId);
wchar_t wLogin[64];
mbstowcs(wLogin, sender->login, 63);
int offset = wcslen(eb->getText()) + wcslen(wLogin) + wcslen(messageText) + 3 - (CHAT_MAX_LENGTH - 1);
if (offset < 0)
offset = 0;
else if (offset >= CHAT_MAX_LENGTH)
offset = CHAT_MAX_LENGTH - 1;
wchar_t wstr[CHAT_MAX_LENGTH];
swprintf(wstr, L"%ls\n%ls: %ls", eb->getText() + offset, wLogin, messageText);
eb->setText(wstr);
//delete wstr;
break;
}
case CharacterMoving:
{
int currentCharacterId;
f32 x, y;
ScanPacket(inPacket, "%i%f%f", ¤tCharacterId, &x, &y);
CurrentCharacter* movingCurrentCharacter = currentLocation->GetCharacter(currentCharacterId);
movingCurrentCharacter->setAnimation(EMAT_RUN);
render->moveNode(movingCurrentCharacter->node, vector3df(x * CELL_SIZE, 0, y * CELL_SIZE), movingCurrentCharacter->base->speed);
//TEST
movingCurrentCharacter->x = x;
movingCurrentCharacter->y = y;
break;
}
case HpChanged:
{
int characterId, changedHp;
CurrentCharacter *character;
ScanPacket(inPacket, "%i%i", &characterId, &changedHp);
if (character = currentLocation->GetCharacter(characterId))
character->hp = changedHp;
break;
}
case CharacterDied:
{
//okay
break;
}
case CharacterMoved:
{
int characterId;
f32 whereX, whereY;
ScanPacket(inPacket, "%i%f%f", &characterId, &whereX, &whereY);
printf("CLIENT CHAR ID: %d\n", characterId);
printf("CLIENT WHERE X: %.f\n", whereX);
printf("CLIENT WHERE Y: %.f\n", whereY);
CurrentCharacter *character = currentLocation->GetCharacter(characterId);
if (character)
{
printf("CLIENT TEST 1\n");
//character->node->setPosition(vector3df(whereX * CELL_SIZE, character->node->getPosition().Y, whereY * CELL_SIZE)); //TODO: Why setPosition is not working?!!
render->moveNode(character->node, vector3df(whereX * CELL_SIZE, character->node->getPosition().Y, whereY * CELL_SIZE), 1000000.0f);
printf("CLIENT TEST 2\n");
character->x = whereX;
character->y = whereY;
}
break;
}
case DialogOpened:
{
char title[256];
char text[4096];
wchar_t wstr[512];
//npcID = PacketGetInt(inPacket, 1);
//strcpy(title, PacketGetString(inPacket, 5));
sprintf(title, "[%d] %s", PacketGetInt(inPacket, 1), PacketGetString(inPacket, 5));
strcpy(text, PacketGetString(inPacket, strlen(PacketGetString(inPacket, 5)) + 5 + 1));
mbstowcs(wstr, title, 255);
IGUIWindow* wnd = guienv->addWindow(rect<s32>(256, 128, 256 + 256, 128 + 320), false, wstr, NULL, -1);
char patterns[][256] = {
"<p\\s+rect\\s*=\\s*\\\"(.*?);(.*?);(.*?);(.*?)\\\">(.*?)</p>",
"<button\\s+rect\\s*=\\s*\\\"(.*?);(.*?);(.*?);(.*?)\\\"\\s+onclick\\s*=\\s*\\\"(.*?)\\\">(.*?)</button>",
/*
"<p>(.*?)</p>",
"<p>(.*?)</p>",
"<p>(.*?)</p>",*/
};
char** result;
int patternsCount = 2;
const char *error;
int erroffset;
int count;
int ovector[30];
const unsigned char *tables = NULL;
tables = pcre_maketables();
for (int i = 0; i < patternsCount; i++)
{
pcre *re = pcre_compile ((char*)patterns[i], 0, &error, &erroffset, NULL);
count = pcre_exec(re, NULL, (char*)text, strlen(text), 0, NULL, ovector, 30);
if (count > 0)
{
result = new char*[count];
for (int c = 0; c < 2 * count; c += 2)
{
if (ovector[c] >= 0)
{
result[c / 2] = new char[ovector[c + 1] - ovector[c] + 1];
memcpy(result[c / 2], text + ovector[c], ovector[c + 1] - ovector[c]);
result[c / 2][ovector[c + 1] - ovector[c]] = '\0';
//printf("%d, %d\n", ovector[c], ovector[c + 1]);
//printf("%s\n", result[c / 2]);
}
else
{
result[c / 2] = NULL;
}
}
switch (i)
{
case 0: //p
{
wchar_t wstr[1024];
mbstowcs(wstr, result[5], 1023);
guienv->addStaticText(wstr, rect<s32>(atoi(result[1]), atoi(result[2]), atoi(result[1]) + atoi(result[3]), atoi(result[2]) + atoi(result[4])), false, true, wnd, DialogElement, false);
break;
}
case 1: //button
{
wchar_t wstr[256];
mbstowcs(wstr, result[6], 255);
guienv->addButton(rect<s32>(atoi(result[1]), atoi(result[2]), atoi(result[1]) + atoi(result[3]), atoi(result[2]) + atoi(result[4])), wnd, DialogElement + atoi(result[5]), wstr, NULL);
break;
}
}
for (int j = 0; j < count; j++)
if (result[j])
delete result[j];
delete result;
}
}
break;
}
case PlayEffect:
{
CurrentMapObject<MapObject>* currentMapObject;
int currentMapObjectId = PacketGetInt(inPacket, 2);
int skillId = PacketGetInt(inPacket, 6);
switch (PacketGetByte(inPacket, 1))
{
case 0: //NPC
currentMapObject = (CurrentMapObject<MapObject>*)currentLocation->GetNPC(currentMapObjectId);
break;
case 3: //Character
currentMapObject = (CurrentMapObject<MapObject>*)currentLocation->GetCharacter(currentMapObjectId);
break;
}
render->PlayEffect(currentMapObject->node, game->resources->GetSkill(skillId)->effectTextures);
break;
}
case PlayAdvancedEffect:
int skillId = PacketGetInt(inPacket, 1);
f32 xStart = PacketGetInt(inPacket, 5) * CELL_SIZE;
f32 yStart = PacketGetInt(inPacket, 9) * CELL_SIZE;
f32 xEnd = PacketGetInt(inPacket, 13) * CELL_SIZE;
f32 yEnd = PacketGetInt(inPacket, 17) * CELL_SIZE;
render->Effect2(vector3df(xStart, 5.0f, yStart), vector3df(xEnd, 5.0f, yEnd)); //TEST
break;
}
}
else if (iResult == -1)
{ //Disconnected from the server
printf("Disconnected from the server\n");
delete Universe::instance->login;
delete Universe::instance->password;
Universe::instance->login = NULL;
Universe::instance->password = NULL;
Universe::instance->state = NextLevel;
}
else
{ //Wrong packet from the client
printf("Warning! Wrong packet from server. Error code: %d\n", iResult);
}
}
//Drawing
if ((render->device->getTimer()->getTime() - lastUpdate) > 30)
{
lastUpdate = render->device->getTimer()->getTime();
if (game)
{
if (currentCharacter)
{
render->Km = camPos->getPosition();
render->Kt = camera->getTarget();
//Kt.X = currentCharacter->x * CELL_SIZE;
//Kt.Z = currentCharacter->y * CELL_SIZE;
vector3df pos = currentCharacter->node->getPosition();
render->Kt.X = pos.X;
render->Kt.Z = pos.Z;
render->Km.X = render->Kt.X;
render->Km.Z = render->Kt.Z - 30;
render->Km.Y = cameraY;
camera->setPosition(render->Km);
camera->setTarget(render->Kt);
//vector3df lPos = camera->getPosition();
vector3df lPos = currentCharacter->node->getPosition();
lPos.Y = 15;
//lPos.Z += 20;
lnode->setPosition(lPos);
}
render->driver->beginScene(true, true, SColor(255,100,101,140));
render->smgr->drawAll();
guienv->drawAll();
render->driver->endScene();
}
}
}
ClientGUIDestroy();
delete connectSocket;
if (game)
{
delete game;
render->smgr->clear();
}
if (state == NextLevel)
return false;
return true;
}
int
main (int argc, char **argv)
{
int
i,
socklen,
erroffset,
options = 0;
pfilter_info
pfi = NULL;
pattern *
p;
struct evconnlistener *
listener;
const char *
error;
const unsigned char *
re_tables = NULL;
if (argc < 3)
syntax ();
for (i = 1; i < argc; ++i)
{
if (!strcmp (argv[i], "-l"))
{
callback_info::logging = true;
++i;
if (i > argc)
{
syntax ();
break;
}
strncpy (logfile, argv[i], MY_MAX_PATH);
logfile[MY_MAX_PATH - 1] = '\0';
printf ("Logging to: %s enabled\n", logfile);
}
else if (!strcmp (argv[i], "-r"))
{
callback_info::filtering = true;
++i;
if (i > argc)
{
syntax ();
break;
}
strncpy (regexp, argv[i], MY_MAX_PATH);
regexp[MY_MAX_PATH - 1] = '\0';
printf ("Regexp: %s added to filter chain\n", regexp);
if (!pfi)
{
pfi = (pfilter_info) malloc (sizeof (filter_info));
callback_info::pfi = pfi;
pfi->patterns = new std::vector < ppattern >;
}
p = new pattern;
p->raw_pattern = regexp;
re_tables = pcre_maketables ();
p->re = pcre_compile (regexp, options, &error, &erroffset, NULL);
p->extra_re = pcre_study (p->re, 0, &error);
if (!p->re || !p->extra_re)
syntax ();
callback_info::pfi->patterns->push_back (p);
}
else
break;
}
if (i + 2 != argc)
syntax ();
#ifdef WIN32
WORD
wVersionRequested;
WSADATA
wsaData;
int
err;
wVersionRequested = MAKEWORD (2, 2);
err = WSAStartup (wVersionRequested, &wsaData);
if (err != 0)
{
printf ("WSAStartup failed with error: %d\n", err);
return 1;
}
#endif
memset (&listen_on_addr, 0, sizeof (listen_on_addr));
socklen = sizeof (listen_on_addr);
if (evutil_parse_sockaddr_port (argv[i],
(struct sockaddr *) &listen_on_addr,
&socklen) < 0)
{
int
p = atoi (argv[i]);
struct sockaddr_in *
sin = (struct sockaddr_in *) &listen_on_addr;
if (p < 1 || p > 65535)
syntax ();
sin->sin_port = htons (p);
sin->sin_addr.s_addr = htonl (0x7f000001);
sin->sin_family = AF_INET;
socklen = sizeof (struct sockaddr_in);
}
memset (&connect_to_addr, 0, sizeof (connect_to_addr));
connect_to_addrlen = sizeof (connect_to_addr);
if (evutil_parse_sockaddr_port (argv[i + 1],
(struct sockaddr *) &connect_to_addr,
&connect_to_addrlen) < 0)
syntax ();
if (callback_info::logging)
{
if (!(callback_info::fd_out = fopen (logfile, "wb")))
{
syntax ();
}
}
base = event_base_new ();
if (!base)
{
perror ("event_base_new()");
return 1;
}
listener = evconnlistener_new_bind (base, accept_cb, NULL,
LEV_OPT_CLOSE_ON_FREE |
LEV_OPT_CLOSE_ON_EXEC |
LEV_OPT_REUSEABLE, -1,
(struct sockaddr *) &listen_on_addr,
socklen);
event_base_dispatch (base);
if (callback_info::logging)
{
fclose (callback_info::fd_out);
}
if (callback_info::filtering)
{
callback_info::pfi->patterns->~vector ();
free (callback_info::pfi);
}
evconnlistener_free (listener);
event_base_free (base);
return 0;
}
int main(int argc, char **argv)
{
int i;
FILE *f;
const unsigned char *tables = pcre_maketables();
const unsigned char *base_of_tables = tables;
if (argc != 2)
{
fprintf(stderr, "dftables: one filename argument is required\n");
return 1;
}
f = fopen(argv[1], "wb");
if (f == NULL)
{
fprintf(stderr, "dftables: failed to open %s for writing\n", argv[1]);
return 1;
}
/* There are two fprintf() calls here, because gcc in pedantic mode complains
about the very long string otherwise. */
fprintf(f,
"/*************************************************\n"
"* Perl-Compatible Regular Expressions *\n"
"*************************************************/\n\n"
"/* This file is automatically written by the dftables auxiliary \n"
"program. If you edit it by hand, you might like to edit the Makefile to \n"
"prevent its ever being regenerated.\n\n");
fprintf(f,
"This file contains the default tables for characters with codes less than\n"
"128 (ASCII characters). These tables are used when no external tables are\n"
"passed to PCRE.\n\n");
fprintf(f,
"The following #include is present because without it gcc 4.x may remove\n"
"the array definition from the final binary if PCRE is built into a static\n"
"library and dead code stripping is activated. This leads to link errors.\n"
"Pulling in the header ensures that the array gets flagged as \"someone\n"
"outside this compilation unit might reference this\" and so it will always\n"
"be supplied to the linker. */\n\n"
"#include \"pcre_internal.h\"\n\n");
fprintf(f,
"const unsigned char _pcre_default_tables[] = {\n\n"
"/* This table is a lower casing table. */\n\n");
fprintf(f, " ");
for (i = 0; i < 256; i++)
{
if ((i & 7) == 0 && i != 0) fprintf(f, "\n ");
fprintf(f, "%3d", *tables++);
if (i != 255) fprintf(f, ",");
}
fprintf(f, ",\n\n");
fprintf(f, "/* This table is a case flipping table. */\n\n");
fprintf(f, " ");
for (i = 0; i < 256; i++)
{
if ((i & 7) == 0 && i != 0) fprintf(f, "\n ");
fprintf(f, "%3d", *tables++);
if (i != 255) fprintf(f, ",");
}
fprintf(f, ",\n\n");
fprintf(f,
"/* This table contains bit maps for various character classes.\n"
"Each map is 32 bytes long and the bits run from the least\n"
"significant end of each byte. The classes that have their own\n"
"maps are: space, xdigit, digit, upper, lower, word, graph\n"
"print, punct, and cntrl. Other classes are built from combinations. */\n\n");
fprintf(f, " ");
for (i = 0; i < cbit_length; i++)
{
if ((i & 7) == 0 && i != 0)
{
if ((i & 31) == 0) fprintf(f, "\n");
fprintf(f, "\n ");
}
fprintf(f, "0x%02x", *tables++);
if (i != cbit_length - 1) fprintf(f, ",");
}
fprintf(f, ",\n\n");
fprintf(f,
"/* This table identifies various classes of character by individual bits:\n"
" 0x%02x white space character\n"
" 0x%02x letter\n"
" 0x%02x decimal digit\n"
" 0x%02x hexadecimal digit\n"
" 0x%02x alphanumeric or '_'\n"
" 0x%02x regular expression metacharacter or binary zero\n*/\n\n",
ctype_space, ctype_letter, ctype_digit, ctype_xdigit, ctype_word,
ctype_meta);
fprintf(f, " ");
for (i = 0; i < 256; i++)
{
if ((i & 7) == 0 && i != 0)
{
fprintf(f, " /* ");
if (isprint(i-8)) fprintf(f, " %c -", i-8);
else fprintf(f, "%3d-", i-8);
if (isprint(i-1)) fprintf(f, " %c ", i-1);
else fprintf(f, "%3d", i-1);
fprintf(f, " */\n ");
}
fprintf(f, "0x%02x", *tables++);
if (i != 255) fprintf(f, ",");
}
fprintf(f, "};/* ");
if (isprint(i-8)) fprintf(f, " %c -", i-8);
else fprintf(f, "%3d-", i-8);
if (isprint(i-1)) fprintf(f, " %c ", i-1);
else fprintf(f, "%3d", i-1);
fprintf(f, " */\n\n/* End of chartables.c */\n");
fclose(f);
free((void *)base_of_tables);
return 0;
}
//PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(char *regex, int regex_len TSRMLS_DC)
pcre *compileRegex( char *regex , int regex_len , char *msg , int msglen )
{
pcre *re = NULL;
pcre_extra *extra;
int coptions = 0;
int soptions = 0;
const char *error;
int erroffset;
char delimiter;
char start_delimiter;
char end_delimiter;
char *p, *pp;
char *pattern;
int do_study = 0;
int poptions = 0;
unsigned const char *tables = NULL;
char buf[ 1024 ] ;
#if HAVE_SETLOCALE
char *locale = setlocale(LC_CTYPE, NULL);
#endif
//R.A.W.
//pcre_cache_entry *pce;
//pcre_cache_entry new_entry;
if( msglen )
{
*msg = '\0';
}
/* Try to lookup the cached regex entry, and if successful, just pass
back the compiled pattern, otherwise go on and compile it. */
regex_len = strlen(regex);
//R.A.W.
#if 0
if (zend_hash_find(&PCRE_G(pcre_cache), regex, regex_len+1, (void **)&pce) == SUCCESS) {
/*
* We use a quick pcre_info() check to see whether cache is corrupted, and if it
* is, we flush it and compile the pattern from scratch.
*/
if (pcre_info(pce->re, NULL, NULL) == PCRE_ERROR_BADMAGIC) {
zend_hash_clean(&PCRE_G(pcre_cache));
} else {
#if HAVE_SETLOCALE
if (!strcmp(pce->locale, locale)) {
#endif
return pce;
#if HAVE_SETLOCALE
}
#endif
}
}
#endif
p = regex;
/* Parse through the leading whitespace, and display a warning if we
get to the end without encountering a delimiter. */
while (isspace((int)*(unsigned char *)p)) p++;
if (*p == 0) {
// R.A.W.
//php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty regular expression");
strncpy(msg, "Empty regular expression" , msglen );
return NULL;
}
/* Get the delimiter and display a warning if it is alphanumeric
or a backslash. */
delimiter = *p++;
if (isalnum((int)*(unsigned char *)&delimiter) || delimiter == '\\') {
//php_error_docref(NULL TSRMLS_CC,E_WARNING, "Delimiter must not be alphanumeric or backslash");
strncpy( msg, "Delimiter must not be alphanumeric or backslash",msglen);
return NULL;
}
start_delimiter = delimiter;
if ((pp = strchr("([{< )]}> )]}>", delimiter)))
delimiter = pp[5];
end_delimiter = delimiter;
if (start_delimiter == end_delimiter) {
/* We need to iterate through the pattern, searching for the ending delimiter,
but skipping the backslashed delimiters. If the ending delimiter is not
found, display a warning. */
pp = p;
while (*pp != 0) {
if (*pp == '\\' && pp[1] != 0) pp++;
else if (*pp == delimiter)
break;
pp++;
}
if (*pp == 0) {
//php_error_docref(NULL TSRMLS_CC,E_WARNING, "No ending delimiter '%c' found", delimiter);
//R.A.W.
strncpy( msg, "No ending delimiter found" ,msglen ) ;
return NULL;
}
} else {
/* We iterate through the pattern, searching for the matching ending
* delimiter. For each matching starting delimiter, we increment nesting
* level, and decrement it for each matching ending delimiter. If we
* reach the end of the pattern without matching, display a warning.
*/
int brackets = 1; /* brackets nesting level */
pp = p;
while (*pp != 0) {
if (*pp == '\\' && pp[1] != 0) pp++;
else if (*pp == end_delimiter && --brackets <= 0)
break;
else if (*pp == start_delimiter)
brackets++;
pp++;
}
if (*pp == 0) {
//php_error_docref(NULL TSRMLS_CC,E_WARNING, "No ending matching delimiter '%c' found", end_delimiter);
strncpy( msg,"No ending matching delimiter found",msglen ) ;
return NULL;
}
}
/* Make a copy of the actual pattern. */
// R.A.W.
//pattern = strndup(p, pp-p);
// osx compile is complaining about strndup and since I have te
// other function anyway and since I'll someday rewrite this fn, just
// call that other function now :>)
pattern = ghstrndup( p,pp-p) ;
/* Move on to the options */
pp++;
/* Parse through the options, setting appropriate flags. Display
a warning if we encounter an unknown modifier. */
while (*pp != 0) {
switch (*pp++) {
/* Perl compatible options */
case 'i': coptions |= PCRE_CASELESS; break;
case 'm': coptions |= PCRE_MULTILINE; break;
case 's': coptions |= PCRE_DOTALL; break;
case 'x': coptions |= PCRE_EXTENDED; break;
/* PCRE specific options */
case 'A': coptions |= PCRE_ANCHORED; break;
case 'D': coptions |= PCRE_DOLLAR_ENDONLY;break;
case 'S': do_study = 1; break;
case 'U': coptions |= PCRE_UNGREEDY; break;
case 'X': coptions |= PCRE_EXTRA; break;
case 'u': coptions |= PCRE_UTF8; break;
// R.A.W.
/* Custom preg options */
//case 'e': poptions |= PREG_REPLACE_EVAL; break;
case ' ':
case '\n':
break;
default:
//php_error_docref(NULL TSRMLS_CC,E_WARNING, "Unknown modifier '%c'", pp[-1]);
strncpy( msg,"Unknown modifier",msglen ) ;
free(pattern);
return NULL;
}
}
//R.A.W.
tables = NULL ;
#if 0
#if HAVE_SETLOCALE
if (strcmp(locale, "C"))
tables = pcre_maketables();
#endif
#endif
/* Compile pattern and display a warning if compilation failed. */
re = pcre_compile(pattern,
coptions,
&error,
&erroffset,
tables);
if (re == NULL) {
//php_error_docref(NULL TSRMLS_CC,E_WARNING, "Compilation failed: %s at offset %d", error, erroffset);
// R.A.W.
sprintf(buf, "Compilation of /%s/ failed: %s at offset %d",pattern, error, erroffset);
//sprintf(buf, "Compilation failed: %s at offset %d",error, erroffset);
strncpy( msg, buf , msglen ) ;
free(pattern);
// R.A.W.
//if (tables) {
//pefree((void*)tables, 1);
//}
return NULL;
}
/* If study option was specified, study the pattern and
store the result in extra for passing to pcre_exec. */
if (do_study) {
extra = pcre_study(re, soptions, &error);
if (extra) {
extra->flags |= PCRE_EXTRA_MATCH_LIMIT | PCRE_EXTRA_MATCH_LIMIT_RECURSION;
}
if (error != NULL) {
strncpy( msg, "Error while studying pattern",msglen);
}
} else {
extra = NULL;
}
free(pattern);
//R.A.W.
#if 0
/*
* If we reached cache limit, clean out the items from the head of the list;
* these are supposedly the oldest ones (but not necessarily the least used
* ones).
*/
if (zend_hash_num_elements(&PCRE_G(pcre_cache)) == PCRE_CACHE_SIZE) {
int num_clean = PCRE_CACHE_SIZE / 8;
zend_hash_apply_with_argument(&PCRE_G(pcre_cache), pcre_clean_cache, &num_clean TSRMLS_CC);
}
/* Store the compiled pattern and extra info in the cache. */
new_entry.re = re;
new_entry.extra = extra;
new_entry.preg_options = poptions;
new_entry.compile_options = coptions;
#if HAVE_SETLOCALE
new_entry.locale = pestrdup(locale, 1);
new_entry.tables = tables;
#endif
zend_hash_update(&PCRE_G(pcre_cache), regex, regex_len+1, (void *)&new_entry,
sizeof(pcre_cache_entry), (void**)&pce);
#endif
// return pce;
//R.A.W.
return re ;
}
static int Lpcre_maketables (lua_State *L) {
*(const void**)lua_newuserdata (L, sizeof(void*)) = pcre_maketables();
push_chartables_meta (L);
lua_setmetatable (L, -2);
return 1;
}
int main(int argc, char **argv)
{
int i;
FILE *f;
const unsigned char *tables;
if (argc < 2)
{
fprintf(stderr, "dftables: one filename argument is required\n");
return 1;
}
f = fopen(argv[1], "w");
if (f == NULL)
{
fprintf(stderr, "dftables: failed to open %s for writing\n", argv[1]);
return 1;
}
if (argc > 2) {
setlocale( LC_ALL, argv[2]);
}
tables = pcre_maketables();
/* There are two fprintf() calls here, because gcc in pedantic mode complains
about the very long string otherwise. */
fprintf(f,
"/*************************************************\n"
"* Perl-Compatible Regular Expressions *\n"
"*************************************************/\n\n"
"/* This file is automatically written by the dftables auxiliary \n"
"program. If you edit it by hand, you might like to edit the Makefile to \n"
"prevent its ever being regenerated.\n\n"
"Generated with locale: CTYPE=%s COLLATE=%s\n\n"
, setlocale(LC_CTYPE , 0),setlocale(LC_COLLATE , 0));
fprintf(f,
"This file is #included in the compilation of pcre.c to build the default\n"
"character tables which are used when no tables are passed to the compile\n"
"function. */\n\n"
"static unsigned char pcre_default_tables[] = {\n\n"
"/* This table is a lower casing table. */\n\n");
fprintf(f, " ");
for (i = 0; i < 256; i++)
{
if ((i & 7) == 0 && i != 0) fprintf(f, "\n ");
fprintf(f, "%3d", *tables++);
if (i != 255) fprintf(f, ",");
}
fprintf(f, ",\n\n");
fprintf(f, "/* This table is a case flipping table. */\n\n");
fprintf(f, " ");
for (i = 0; i < 256; i++)
{
if ((i & 7) == 0 && i != 0) fprintf(f, "\n ");
fprintf(f, "%3d", *tables++);
if (i != 255) fprintf(f, ",");
}
fprintf(f, ",\n\n");
fprintf(f,
"/* This table contains bit maps for various character classes.\n"
"Each map is 32 bytes long and the bits run from the least\n"
"significant end of each byte. The classes that have their own\n"
"maps are: space, xdigit, digit, upper, lower, word, graph\n"
"print, punct, and cntrl. Other classes are built from combinations. */\n\n");
fprintf(f, " ");
for (i = 0; i < cbit_length; i++)
{
if ((i & 7) == 0 && i != 0)
{
if ((i & 31) == 0) fprintf(f, "\n");
fprintf(f, "\n ");
}
fprintf(f, "0x%02x", *tables++);
if (i != cbit_length - 1) fprintf(f, ",");
}
fprintf(f, ",\n\n");
fprintf(f,
"/* This table identifies various classes of character by individual bits:\n"
" 0x%02x white space character\n"
" 0x%02x letter\n"
" 0x%02x decimal digit\n"
" 0x%02x hexadecimal digit\n"
" 0x%02x alphanumeric or '_'\n"
" 0x%02x regular expression metacharacter or binary zero\n*/\n\n",
ctype_space, ctype_letter, ctype_digit, ctype_xdigit, ctype_word,
ctype_meta);
fprintf(f, " ");
for (i = 0; i < 256; i++)
{
if ((i & 7) == 0 && i != 0)
{
fprintf(f, " /* ");
if (isprint(i-8)) fprintf(f, " %c -", i-8);
else fprintf(f, "%3d-", i-8);
if (isprint(i-1)) fprintf(f, " %c ", i-1);
else fprintf(f, "%3d", i-1);
fprintf(f, " */\n ");
}
fprintf(f, "0x%02x", *tables++);
if (i != 255) fprintf(f, ",");
}
fprintf(f, "};/* ");
if (isprint(i-8)) fprintf(f, " %c -", i-8);
else fprintf(f, "%3d-", i-8);
if (isprint(i-1)) fprintf(f, " %c ", i-1);
else fprintf(f, "%3d", i-1);
fprintf(f, " */\n\n/* End of chartables.c */\n");
fclose(f);
return 0;
}
void reset_pattern_locale(void)
{
re_tables = pcre_maketables();
}
int main(int argc, char **argv)
{
FILE *f;
int i = 1;
const unsigned char *tables;
const unsigned char *base_of_tables;
/* By default, the default C locale is used rather than what the building user
happens to have set. However, if the -L option is given, set the locale from
the LC_xxx environment variables. */
if (argc > 1 && strcmp(argv[1], "-L") == 0)
{
setlocale(LC_ALL, ""); /* Set from environment variables */
i++;
}
if (argc < i + 1)
{
fprintf(stderr, "dftables: one filename argument is required\n");
return 1;
}
tables = pcre_maketables();
base_of_tables = tables;
f = fopen(argv[i], "wb");
if (f == NULL)
{
fprintf(stderr, "dftables: failed to open %s for writing\n", argv[1]);
return 1;
}
/* There are several fprintf() calls here, because gcc in pedantic mode
complains about the very long string otherwise. */
fprintf(f,
"/*************************************************\n"
"* Perl-Compatible Regular Expressions *\n"
"*************************************************/\n\n"
"/* This file was automatically written by the dftables auxiliary\n"
"program. It contains character tables that are used when no external\n"
"tables are passed to PCRE by the application that calls it. The tables\n"
"are used only for characters whose code values are less than 256.\n\n");
fprintf(f,
"The following #includes are present because without them gcc 4.x may remove\n"
"the array definition from the final binary if PCRE is built into a static\n"
"library and dead code stripping is activated. This leads to link errors.\n"
"Pulling in the header ensures that the array gets flagged as \"someone\n"
"outside this compilation unit might reference this\" and so it will always\n"
"be supplied to the linker. */\n\n"
"#ifdef HAVE_CONFIG_H\n"
"#include \"config.h\"\n"
"#endif\n\n"
"#include \"pcre_internal.h\"\n\n");
fprintf(f,
"const unsigned char _pcre_default_tables[] = {\n\n"
"/* This table is a lower casing table. */\n\n");
fprintf(f, " ");
for (i = 0; i < 256; i++)
{
if ((i & 7) == 0 && i != 0) fprintf(f, "\n ");
fprintf(f, "%3d", *tables++);
if (i != 255) fprintf(f, ",");
}
fprintf(f, ",\n\n");
fprintf(f, "/* This table is a case flipping table. */\n\n");
fprintf(f, " ");
for (i = 0; i < 256; i++)
{
if ((i & 7) == 0 && i != 0) fprintf(f, "\n ");
fprintf(f, "%3d", *tables++);
if (i != 255) fprintf(f, ",");
}
fprintf(f, ",\n\n");
fprintf(f,
"/* This table contains bit maps for various character classes.\n"
"Each map is 32 bytes long and the bits run from the least\n"
"significant end of each byte. The classes that have their own\n"
"maps are: space, xdigit, digit, upper, lower, word, graph\n"
"print, punct, and cntrl. Other classes are built from combinations. */\n\n");
fprintf(f, " ");
for (i = 0; i < cbit_length; i++)
{
if ((i & 7) == 0 && i != 0)
{
if ((i & 31) == 0) fprintf(f, "\n");
fprintf(f, "\n ");
}
fprintf(f, "0x%02x", *tables++);
if (i != cbit_length - 1) fprintf(f, ",");
}
fprintf(f, ",\n\n");
fprintf(f,
"/* This table identifies various classes of character by individual bits:\n"
" 0x%02x white space character\n"
" 0x%02x letter\n"
" 0x%02x decimal digit\n"
" 0x%02x hexadecimal digit\n"
" 0x%02x alphanumeric or '_'\n"
" 0x%02x regular expression metacharacter or binary zero\n*/\n\n",
ctype_space, ctype_letter, ctype_digit, ctype_xdigit, ctype_word,
ctype_meta);
fprintf(f, " ");
for (i = 0; i < 256; i++)
{
if ((i & 7) == 0 && i != 0)
{
fprintf(f, " /* ");
if (isprint(i-8)) fprintf(f, " %c -", i-8);
else fprintf(f, "%3d-", i-8);
if (isprint(i-1)) fprintf(f, " %c ", i-1);
else fprintf(f, "%3d", i-1);
fprintf(f, " */\n ");
}
fprintf(f, "0x%02x", *tables++);
if (i != 255) fprintf(f, ",");
}
fprintf(f, "};/* ");
if (isprint(i-8)) fprintf(f, " %c -", i-8);
else fprintf(f, "%3d-", i-8);
if (isprint(i-1)) fprintf(f, " %c ", i-1);
else fprintf(f, "%3d", i-1);
fprintf(f, " */\n\n/* End of pcre_chartables.c */\n");
fclose(f);
free((void *)base_of_tables);
return 0;
}
/* Executes a pattern match with runtime options, a regular expression, a
string offset, a string length, a subject string, a number of subgroup
offsets, an offset vector and an optional callout function */
CAMLprim value pcre_exec_stub(value v_opt, value v_rex, value v_ofs,
value v_subj, value v_subgroups2, value v_ovec,
value v_maybe_cof)
{
const int ofs = Int_val(v_ofs), len = caml_string_length(v_subj);
if (ofs > len || ofs < 0)
caml_invalid_argument("Pcre.pcre_exec_stub: illegal offset");
{
const pcre *code = (pcre *) Field(v_rex, 1); /* Compiled pattern */
const pcre_extra *extra = (pcre_extra *) Field(v_rex, 2); /* Extra info */
const char *ocaml_subj = String_val(v_subj); /* Subject string */
const int opt = Int_val(v_opt); /* Runtime options */
int subgroups2 = Int_val(v_subgroups2);
const int subgroups2_1 = subgroups2 - 1;
const int subgroups3 = (subgroups2 >> 1) + subgroups2;
/* Special case when no callout functions specified */
if (v_maybe_cof == None) {
int *ovec = (int *) &Field(v_ovec, 0);
/* Performs the match */
const int ret =
pcre_exec(code, extra, ocaml_subj, len, ofs, opt, ovec, subgroups3);
if (ret < 0) {
switch(ret) {
case PCRE_ERROR_NOMATCH : caml_raise_constant(*pcre_exc_Not_found);
case PCRE_ERROR_PARTIAL : caml_raise_constant(*pcre_exc_Partial);
case PCRE_ERROR_MATCHLIMIT :
caml_raise_constant(*pcre_exc_MatchLimit);
case PCRE_ERROR_BADPARTIAL :
caml_raise_constant(*pcre_exc_BadPartial);
case PCRE_ERROR_BADUTF8 : caml_raise_constant(*pcre_exc_BadUTF8);
case PCRE_ERROR_BADUTF8_OFFSET :
caml_raise_constant(*pcre_exc_BadUTF8Offset);
default :
caml_raise_with_string(*pcre_exc_InternalError, "pcre_exec_stub");
}
}
else {
const int *ovec_src = ovec + subgroups2_1;
long int *ovec_dst = (long int *) ovec + subgroups2_1;
/* Converts offsets from C-integers to OCaml-Integers
This is a bit tricky, because there are 32- and 64-bit platforms
around and OCaml chooses the larger possibility for representing
integers when available (also in arrays) - not so the PCRE */
while (subgroups2--) {
*ovec_dst = Val_int(*ovec_src);
--ovec_src; --ovec_dst;
}
}
}
/* There are callout functions */
else {
value v_cof = Field(v_maybe_cof, 0);
value v_substrings;
char *subj = caml_stat_alloc(sizeof(char) * len);
int *ovec = caml_stat_alloc(sizeof(int) * subgroups3);
int ret;
struct cod cod = { (value *) NULL, (value *) NULL, (value) NULL };
struct pcre_extra new_extra =
#ifdef PCRE_CONFIG_MATCH_LIMIT_RECURSION
{ PCRE_EXTRA_CALLOUT_DATA, NULL, 0, NULL, NULL, 0 };
#else
{ PCRE_EXTRA_CALLOUT_DATA, NULL, 0, NULL, NULL };
#endif
memcpy(subj, ocaml_subj, len);
Begin_roots3(v_rex, v_cof, v_substrings);
Begin_roots2(v_subj, v_ovec);
v_substrings = caml_alloc_small(2, 0);
End_roots();
Field(v_substrings, 0) = v_subj;
Field(v_substrings, 1) = v_ovec;
cod.v_substrings_p = &v_substrings;
cod.v_cof_p = &v_cof;
new_extra.callout_data = &cod;
if (extra == NULL) {
ret = pcre_exec(code, &new_extra, subj, len, ofs, opt, ovec,
subgroups3);
}
else {
new_extra.flags = PCRE_EXTRA_CALLOUT_DATA | extra->flags;
new_extra.study_data = extra->study_data;
new_extra.match_limit = extra->match_limit;
new_extra.tables = extra->tables;
#ifdef PCRE_CONFIG_MATCH_LIMIT_RECURSION
new_extra.match_limit_recursion = extra->match_limit_recursion;
#endif
ret = pcre_exec(code, &new_extra, subj, len, ofs, opt, ovec,
subgroups3);
}
free(subj);
End_roots();
if (ret < 0) {
free(ovec);
switch(ret) {
case PCRE_ERROR_NOMATCH : caml_raise_constant(*pcre_exc_Not_found);
case PCRE_ERROR_PARTIAL : caml_raise_constant(*pcre_exc_Partial);
case PCRE_ERROR_MATCHLIMIT :
caml_raise_constant(*pcre_exc_MatchLimit);
case PCRE_ERROR_BADPARTIAL :
caml_raise_constant(*pcre_exc_BadPartial);
case PCRE_ERROR_BADUTF8 : caml_raise_constant(*pcre_exc_BadUTF8);
case PCRE_ERROR_BADUTF8_OFFSET :
caml_raise_constant(*pcre_exc_BadUTF8Offset);
case PCRE_ERROR_CALLOUT : caml_raise(cod.v_exn);
default :
caml_raise_with_string(*pcre_exc_InternalError, "pcre_exec_stub");
}
}
else {
int *ovec_src = ovec + subgroups2_1;
long int *ovec_dst = &Field(v_ovec, 0) + subgroups2_1;
while (subgroups2--) {
*ovec_dst = Val_int(*ovec_src);
--ovec_src; --ovec_dst;
}
free(ovec);
}
}
}
return Val_unit;
}
/* Byte-code hook for pcre_exec_stub
Needed, because there are more than 5 arguments */
CAMLprim value pcre_exec_stub_bc(value *argv, int __unused argn)
{
return pcre_exec_stub(argv[0], argv[1], argv[2], argv[3],
argv[4], argv[5], argv[6]);
}
/* Generates a new set of chartables for the current locale (see man
page of PCRE */
CAMLprim value pcre_maketables_stub(value __unused v_unit)
{
/* GC will do a full cycle every 100 table set allocations
(one table set consumes 864 bytes -> maximum of 86400 bytes
unreclaimed table sets) */
const value v_res = caml_alloc_final(2, pcre_dealloc_tables, 864, 86400);
Field(v_res, 1) = (value) pcre_maketables();
return v_res;
}
/* Wraps around the isspace-function */
CAMLprim value pcre_isspace_stub(value v_c)
{
return Val_bool(isspace(Int_val(v_c)));
}
/* Returns number of substring associated with a name */
CAMLprim value pcre_get_stringnumber_stub(value v_rex, value v_name)
{
const int ret = pcre_get_stringnumber((pcre *) Field(v_rex, 1),
String_val(v_name));
if (ret == PCRE_ERROR_NOSUBSTRING)
caml_invalid_argument("Named string not found");
return Val_int(ret);
}
/* Returns array of names of named substrings in a regexp */
CAMLprim value pcre_names_stub(value v_rex)
{
CAMLparam0();
CAMLlocal1(v_res);
int name_count;
int entry_size;
const char *tbl_ptr;
int i;
int ret = pcre_fullinfo_stub(v_rex, PCRE_INFO_NAMECOUNT, &name_count);
if (ret != 0)
caml_raise_with_string(*pcre_exc_InternalError, "pcre_names_stub");
ret = pcre_fullinfo_stub(v_rex, PCRE_INFO_NAMEENTRYSIZE, &entry_size);
if (ret != 0)
caml_raise_with_string(*pcre_exc_InternalError, "pcre_names_stub");
ret = pcre_fullinfo_stub(v_rex, PCRE_INFO_NAMETABLE, &tbl_ptr);
if (ret != 0)
caml_raise_with_string(*pcre_exc_InternalError, "pcre_names_stub");
v_res = caml_alloc(name_count, 0);
for (i = 0; i < name_count; ++i) {
value v_name = caml_copy_string(tbl_ptr + 2);
Store_field(v_res, i, v_name);
tbl_ptr += entry_size;
}
CAMLreturn(v_res);
}
void f_pcre_create(INT32 args)
{
struct pike_string *regexp; /* Regexp pattern */
pcre_extra *extra = NULL; /* result from study, if enabled */
pcre *re = NULL; /* compiled regexp */
int opts = 0; /* Regexp compile options */
const char *errmsg; /* Error message pointer */
int erroffset; /* Error offset */
int do_study = 1; /* Study the regexp when it's compiled */
char *pp; /* Temporary char pointer */
unsigned const char *table = NULL; /* Translation table */
#if HAVE_SETLOCALE
char *locale = setlocale(LC_CTYPE, NULL); /* Get current locale for
* translation table. */
#endif
free_regexp(Pike_fp->current_object);
switch(args)
{
case 2:
switch(Pike_sp[-1].type) {
case T_STRING:
opts = parse_options(Pike_sp[-1].u.string->str, &do_study);
if(opts < 0)
Pike_error("PCRE.Regexp->create(): Unknown option modifier '%c'.\n", -opts);
break;
case T_INT:
if(Pike_sp[-1].u.integer == 0) {
break;
}
/* Fallthrough */
default:
Pike_error("Bad argument 2 to PCRE.Regexp->create() - expected string.\n");
break;
}
/* Fall through */
case 1:
if(Pike_sp[-args].type != T_STRING || Pike_sp[-args].u.string->size_shift > 0) {
Pike_error("PCRE.Regexp->create(): Invalid argument 1. Expected 8-bit string.\n");
}
regexp = Pike_sp[-args].u.string;
if((INT32)strlen(regexp->str) != regexp->len)
Pike_error("PCRE.Regexp->create(): Regexp pattern contains null characters. Use \\0 instead.\n");
break;
case 0: /* Regexp() compatibility */
return;
default:
Pike_error("PCRE.Regexp->create(): Invalid number of arguments. Expected 1 or 2.\n");
}
#if HAVE_SETLOCALE
if (strcmp(locale, "C"))
table = pcre_maketables();
#endif
/* Compile the pattern and handle errors */
re = pcre_compile(regexp->str, opts, &errmsg, &erroffset, table);
if(re == NULL) {
Pike_error("Failed to compile regexp: %s at offset %d\n", errmsg, erroffset);
}
/* If study option was specified, study the pattern and
store the result in extra for passing to pcre_exec. */
if (do_study) {
extra = pcre_study(re, 0, &errmsg);
if (errmsg != NULL) {
Pike_error("Error while studying pattern: %s", errmsg);
}
}
THIS->regexp = re;
THIS->extra = extra;
THIS->pattern = regexp;
add_ref(regexp);
pop_n_elems(args);
}
void
Pcompile (char const *pattern, size_t size)
{
#if !HAVE_LIBPCRE
error (EXIT_TROUBLE, 0, "%s",
_("support for the -P option is not compiled into "
"this --disable-perl-regexp binary"));
#else
int e;
char const *ep;
char *re = xnmalloc (4, size + 7);
int flags = (PCRE_MULTILINE
| (match_icase ? PCRE_CASELESS : 0)
| (using_utf8 () ? PCRE_UTF8 : 0));
char const *patlim = pattern + size;
char *n = re;
char const *p;
char const *pnul;
/* FIXME: Remove these restrictions. */
if (memchr (pattern, '\n', size))
error (EXIT_TROUBLE, 0, _("the -P option only supports a single pattern"));
*n = '\0';
if (match_lines)
strcpy (n, "^(?:");
if (match_words)
strcpy (n, "(?<!\\w)(?:");
n += strlen (n);
/* The PCRE interface doesn't allow NUL bytes in the pattern, so
replace each NUL byte in the pattern with the four characters
"\000", removing a preceding backslash if there are an odd
number of backslashes before the NUL.
FIXME: This method does not work with some multibyte character
encodings, notably Shift-JIS, where a multibyte character can end
in a backslash byte. */
for (p = pattern; (pnul = memchr (p, '\0', patlim - p)); p = pnul + 1)
{
memcpy (n, p, pnul - p);
n += pnul - p;
for (p = pnul; pattern < p && p[-1] == '\\'; p--)
continue;
n -= (pnul - p) & 1;
strcpy (n, "\\000");
n += 4;
}
memcpy (n, p, patlim - p);
n += patlim - p;
*n = '\0';
if (match_words)
strcpy (n, ")(?!\\w)");
if (match_lines)
strcpy (n, ")$");
cre = pcre_compile (re, flags, &ep, &e, pcre_maketables ());
if (!cre)
error (EXIT_TROUBLE, 0, "%s", ep);
extra = pcre_study (cre, PCRE_STUDY_JIT_COMPILE, &ep);
if (ep)
error (EXIT_TROUBLE, 0, "%s", ep);
# if PCRE_STUDY_JIT_COMPILE
if (pcre_fullinfo (cre, extra, PCRE_INFO_JIT, &e))
error (EXIT_TROUBLE, 0, _("internal error (should never happen)"));
if (e)
{
/* A 32K stack is allocated for the machine code by default, which
can grow to 512K if necessary. Since JIT uses far less memory
than the interpreter, this should be enough in practice. */
jit_stack = pcre_jit_stack_alloc (32 * 1024, 512 * 1024);
if (!jit_stack)
error (EXIT_TROUBLE, 0,
_("failed to allocate memory for the PCRE JIT stack"));
pcre_assign_jit_stack (extra, NULL, jit_stack);
}
# endif
free (re);
#endif /* HAVE_LIBPCRE */
}
int main(void)
{
int i;
unsigned const char *tables = pcre_maketables();
printf(
"/*************************************************\n"
"* Perl-Compatible Regular Expressions *\n"
"*************************************************/\n\n"
"/* This file is automatically written by the makechartables auxiliary \n"
"program. If you edit it by hand, you might like to edit the Makefile to \n"
"prevent its ever being regenerated.\n\n"
"This file is #included in the compilation of pcre.c to build the default\n"
"character tables which are used when no tables are passed to the compile\n"
"function. */\n\n"
"static unsigned char pcre_default_tables[] = {\n\n"
"/* This table is a lower casing table. */\n\n");
printf(" ");
for (i = 0; i < 256; i++)
{
if ((i & 7) == 0 && i != 0) printf("\n ");
printf("%3d", *tables++);
if (i != 255) printf(",");
}
printf(",\n\n");
printf("/* This table is a case flipping table. */\n\n");
printf(" ");
for (i = 0; i < 256; i++)
{
if ((i & 7) == 0 && i != 0) printf("\n ");
printf("%3d", *tables++);
if (i != 255) printf(",");
}
printf(",\n\n");
printf(
"/* This table contains bit maps for digits, 'word' chars, and white\n"
"space. Each map is 32 bytes long and the bits run from the least\n"
"significant end of each byte. */\n\n");
printf(" ");
for (i = 0; i < cbit_length; i++)
{
if ((i & 7) == 0 && i != 0)
{
if ((i & 31) == 0) printf("\n");
printf("\n ");
}
printf("0x%02x", *tables++);
if (i != cbit_length - 1) printf(",");
}
printf(" ,\n\n");
printf(
"/* This table identifies various classes of character by individual bits:\n"
" 0x%02x white space character\n"
" 0x%02x letter\n"
" 0x%02x decimal digit\n"
" 0x%02x hexadecimal digit\n"
" 0x%02x alphanumeric or '_'\n"
" 0x%02x regular expression metacharacter or binary zero\n*/\n\n",
ctype_space, ctype_letter, ctype_digit, ctype_xdigit, ctype_word,
ctype_meta);
printf(" ");
for (i = 0; i < 256; i++)
{
if ((i & 7) == 0 && i != 0)
{
printf(" /* ");
if (isprint(i-8)) printf(" %c -", i-8);
else printf("%3d-", i-8);
if (isprint(i-1)) printf(" %c ", i-1);
else printf("%3d", i-1);
printf(" */\n ");
}
printf("0x%02x", *tables++);
if (i != 255) printf(",");
}
printf("};/* ");
if (isprint(i-8)) printf(" %c -", i-8);
else printf("%3d-", i-8);
if (isprint(i-1)) printf(" %c ", i-1);
else printf("%3d", i-1);
printf(" */\n\n/* End of chartables.c */\n");
return 0;
}
void
Pcompile (char const *pattern, size_t size)
{
#if !HAVE_LIBPCRE
error (EXIT_TROUBLE, 0, "%s",
_("support for the -P option is not compiled into "
"this --disable-perl-regexp binary"));
#else
int e;
char const *ep;
char *re = xnmalloc (4, size + 7);
int flags = (PCRE_MULTILINE
| (match_icase ? PCRE_CASELESS : 0));
char const *patlim = pattern + size;
char *n = re;
char const *p;
char const *pnul;
if (using_utf8 ())
flags |= PCRE_UTF8;
else if (MB_CUR_MAX != 1)
error (EXIT_TROUBLE, 0, _("-P supports only unibyte and UTF-8 locales"));
/* FIXME: Remove these restrictions. */
if (memchr (pattern, '\n', size))
error (EXIT_TROUBLE, 0, _("the -P option only supports a single pattern"));
*n = '\0';
if (match_lines)
strcpy (n, "^(?:");
if (match_words)
strcpy (n, "(?<!\\w)(?:");
n += strlen (n);
/* The PCRE interface doesn't allow NUL bytes in the pattern, so
replace each NUL byte in the pattern with the four characters
"\000", removing a preceding backslash if there are an odd
number of backslashes before the NUL.
FIXME: This method does not work with some multibyte character
encodings, notably Shift-JIS, where a multibyte character can end
in a backslash byte. */
for (p = pattern; (pnul = memchr (p, '\0', patlim - p)); p = pnul + 1)
{
memcpy (n, p, pnul - p);
n += pnul - p;
for (p = pnul; pattern < p && p[-1] == '\\'; p--)
continue;
n -= (pnul - p) & 1;
strcpy (n, "\\000");
n += 4;
}
memcpy (n, p, patlim - p);
n += patlim - p;
*n = '\0';
if (match_words)
strcpy (n, ")(?!\\w)");
if (match_lines)
strcpy (n, ")$");
cre = pcre_compile (re, flags, &ep, &e, pcre_maketables ());
if (!cre)
error (EXIT_TROUBLE, 0, "%s", ep);
extra = pcre_study (cre, PCRE_STUDY_JIT_COMPILE, &ep);
if (ep)
error (EXIT_TROUBLE, 0, "%s", ep);
# if PCRE_STUDY_JIT_COMPILE
if (pcre_fullinfo (cre, extra, PCRE_INFO_JIT, &e))
error (EXIT_TROUBLE, 0, _("internal error (should never happen)"));
/* The PCRE documentation says that a 32 KiB stack is the default. */
if (e)
jit_stack_size = 32 << 10;
# endif
free (re);
int sub[NSUB];
empty_match[false] = pcre_exec (cre, extra, "", 0, 0,
PCRE_NOTBOL, sub, NSUB);
empty_match[true] = pcre_exec (cre, extra, "", 0, 0, 0, sub, NSUB);
#endif /* HAVE_LIBPCRE */
}
CAMLprim value pcre_exec_stub0(
intnat v_opt, value v_rex, intnat v_pos, intnat v_subj_start, value v_subj,
value v_ovec, value v_maybe_cof, value v_workspace)
{
int ret;
int is_dfa = v_workspace != (value) NULL;
long
pos = v_pos,
len = caml_string_length(v_subj),
subj_start = v_subj_start;
long ovec_len = Wosize_val(v_ovec);
if (pos > len || pos < subj_start)
caml_invalid_argument("Pcre.pcre_exec_stub: illegal position");
if (subj_start > len || subj_start < 0)
caml_invalid_argument("Pcre.pcre_exec_stub: illegal subject start");
pos -= subj_start;
len -= subj_start;
{
const pcre *code = get_rex(v_rex); /* Compiled pattern */
const pcre_extra *extra = get_extra(v_rex); /* Extra info */
const char *ocaml_subj =
String_val(v_subj) + subj_start; /* Subject string */
const int opt = v_opt; /* Runtime options */
/* Special case when no callout functions specified */
if (v_maybe_cof == None) {
int *ovec = (int *) &Field(v_ovec, 0);
/* Performs the match */
if (is_dfa)
ret =
pcre_dfa_exec(code, extra, ocaml_subj, len, pos, opt, ovec, ovec_len,
(int *) &Field(v_workspace, 0), Wosize_val(v_workspace));
else
ret = pcre_exec(code, extra, ocaml_subj, len, pos, opt, ovec, ovec_len);
if (ret < 0) handle_exec_error("pcre_exec_stub", ret);
else handle_pcre_exec_result(ovec, v_ovec, ovec_len, subj_start, ret);
}
/* There are callout functions */
else {
value v_cof = Field(v_maybe_cof, 0);
value v_substrings;
char *subj = caml_stat_alloc(sizeof(char) * len);
int *ovec = caml_stat_alloc(sizeof(int) * ovec_len);
int workspace_len;
int *workspace;
struct cod cod = { 0, (value *) NULL, (value *) NULL, (value) NULL };
struct pcre_extra new_extra =
#ifdef PCRE_EXTRA_MATCH_LIMIT_RECURSION
# ifdef PCRE_EXTRA_MARK
# ifdef PCRE_EXTRA_EXECUTABLE_JIT
{ PCRE_EXTRA_CALLOUT_DATA, NULL, 0, NULL, NULL, 0, NULL, NULL };
# else
{ PCRE_EXTRA_CALLOUT_DATA, NULL, 0, NULL, NULL, 0, NULL };
# endif
# else
{ PCRE_EXTRA_CALLOUT_DATA, NULL, 0, NULL, NULL, 0 };
# endif
#else
{ PCRE_EXTRA_CALLOUT_DATA, NULL, 0, NULL, NULL };
#endif
cod.subj_start = subj_start;
memcpy(subj, ocaml_subj, len);
Begin_roots4(v_rex, v_cof, v_substrings, v_ovec);
Begin_roots1(v_subj);
v_substrings = caml_alloc_small(2, 0);
End_roots();
Field(v_substrings, 0) = v_subj;
Field(v_substrings, 1) = v_ovec;
cod.v_substrings_p = &v_substrings;
cod.v_cof_p = &v_cof;
new_extra.callout_data = &cod;
if (extra != NULL) {
new_extra.flags = PCRE_EXTRA_CALLOUT_DATA | extra->flags;
new_extra.study_data = extra->study_data;
new_extra.match_limit = extra->match_limit;
new_extra.tables = extra->tables;
#ifdef PCRE_EXTRA_MATCH_LIMIT_RECURSION
new_extra.match_limit_recursion = extra->match_limit_recursion;
#endif
}
if (is_dfa) {
workspace_len = Wosize_val(v_workspace);
workspace = caml_stat_alloc(sizeof(int) * workspace_len);
ret =
pcre_dfa_exec(code, extra, subj, len, pos, opt, ovec, ovec_len,
(int *) &Field(v_workspace, 0), workspace_len);
} else
ret =
pcre_exec(code, &new_extra, subj, len, pos, opt, ovec, ovec_len);
caml_stat_free(subj);
End_roots();
if (ret < 0) {
if (is_dfa) caml_stat_free(workspace);
caml_stat_free(ovec);
if (ret == PCRE_ERROR_CALLOUT) caml_raise(cod.v_exn);
else handle_exec_error("pcre_exec_stub(callout)", ret);
} else {
handle_pcre_exec_result(ovec, v_ovec, ovec_len, subj_start, ret);
if (is_dfa) {
caml_int_ptr ocaml_workspace_dst =
(caml_int_ptr) &Field(v_workspace, 0);
const int *workspace_src = workspace;
const int *workspace_src_stop = workspace + workspace_len;
while (workspace_src != workspace_src_stop) {
*ocaml_workspace_dst = *workspace_src;
ocaml_workspace_dst++;
workspace_src++;
}
caml_stat_free(workspace);
}
caml_stat_free(ovec);
}
}
}
return Val_unit;
}
CAMLprim value pcre_exec_stub(
intnat v_opt, value v_rex, intnat v_pos, intnat v_subj_start, value v_subj,
value v_ovec, value v_maybe_cof)
{
return pcre_exec_stub0(v_opt, v_rex, v_pos, v_subj_start, v_subj,
v_ovec, v_maybe_cof, (value) NULL);
}
/* Byte-code hook for pcre_exec_stub
Needed, because there are more than 5 arguments */
CAMLprim value pcre_exec_stub_bc(value *argv, int __unused argn)
{
return
pcre_exec_stub0(
Int_val(argv[0]), argv[1], Int_val(argv[2]), Int_val(argv[3]),
argv[4], argv[5], argv[6], (value) NULL);
}
/* Byte-code hook for pcre_dfa_exec_stub
Needed, because there are more than 5 arguments */
CAMLprim value pcre_dfa_exec_stub_bc(value *argv, int __unused argn)
{
return
pcre_exec_stub0(
Int_val(argv[0]), argv[1], Int_val(argv[2]), Int_val(argv[3]),
argv[4], argv[5], argv[6], argv[7]);
}
static struct custom_operations tables_ops = {
"pcre_ocaml_tables",
pcre_dealloc_tables,
custom_compare_default,
custom_hash_default,
custom_serialize_default,
custom_deserialize_default,
custom_compare_ext_default
};
/* Generates a new set of chartables for the current locale (see man
page of PCRE */
CAMLprim value pcre_maketables_stub(value __unused v_unit)
{
/* GC will do a full cycle every 1_000_000 table set allocations (one
table set consumes 864 bytes -> maximum of 864_000_000 bytes unreclaimed
table sets) */
const value v_tables =
caml_alloc_custom(
&tables_ops, sizeof(struct pcre_ocaml_tables), 1, 1000000);
set_tables(v_tables, pcre_maketables());
return v_tables;
}
/* Wraps around the isspace-function */
CAMLprim value pcre_isspace_stub(value v_c)
{
return Val_bool(isspace(Int_val(v_c)));
}
/* Returns number of substring associated with a name */
CAMLprim intnat pcre_get_stringnumber_stub(value v_rex, value v_name)
{
const int ret = pcre_get_stringnumber(get_rex(v_rex), String_val(v_name));
if (ret == PCRE_ERROR_NOSUBSTRING)
caml_invalid_argument("Named string not found");
return ret;
}
CAMLprim value pcre_get_stringnumber_stub_bc(value v_rex, value v_name)
{
return Val_int(pcre_get_stringnumber_stub(v_rex, v_name));
}
/* Returns array of names of named substrings in a regexp */
CAMLprim value pcre_names_stub(value v_rex)
{
CAMLparam0();
CAMLlocal1(v_res);
int name_count;
int entry_size;
const char *tbl_ptr;
int i;
int ret = pcre_fullinfo_stub(v_rex, PCRE_INFO_NAMECOUNT, &name_count);
if (ret != 0) raise_internal_error("pcre_names_stub: namecount");
ret = pcre_fullinfo_stub(v_rex, PCRE_INFO_NAMEENTRYSIZE, &entry_size);
if (ret != 0) raise_internal_error("pcre_names_stub: nameentrysize");
ret = pcre_fullinfo_stub(v_rex, PCRE_INFO_NAMETABLE, &tbl_ptr);
if (ret != 0) raise_internal_error("pcre_names_stub: nametable");
v_res = caml_alloc(name_count, 0);
for (i = 0; i < name_count; ++i) {
value v_name = caml_copy_string(tbl_ptr + 2);
Store_field(v_res, i, v_name);
tbl_ptr += entry_size;
}
CAMLreturn(v_res);
}
/* Generic stub for getting integer results from pcre_config */
static inline int pcre_config_int(int what)
{
int ret;
pcre_config(what, (void *) &ret);
return ret;
}
/* Generic stub for getting long integer results from pcre_config */
static inline int pcre_config_long(int what)
{
long ret;
pcre_config(what, (void *) &ret);
return ret;
}
JNIEXPORT jlong JNICALL
Java_com_oracle_truffle_r_runtime_ffi_jni_JNI_1PCRE_nativeMaketables(JNIEnv *env, jclass c) {
return (jlong) pcre_maketables();
}
pcre_error_code pcre_private(char *INPUT_LINE, char *INPUT_PAT, int *Output_Start, int *Output_End, char*** _pstCapturedString, int* _piCapturedStringCount)
{
/* ALL strings are managed as UTF-8 by default */
int options = PCRE_UTF8;
int size_offsets = 45;
int size_offsets_max;
int *offsets = NULL;
int all_use_dfa = 0;
BOOL LOOP_PCRE_TST = FALSE;
/* These vectors store, end-to-end, a list of captured substring names. Assume
that 1024 is plenty long enough for the few names we'll be testing. */
char copynames[1024];
char getnames[1024];
char *copynamesptr = NULL;
char *getnamesptr = NULL;
int rc = 0;
(void)pcre_config(PCRE_CONFIG_UTF8, &rc);
if (rc != 1)
{
return UTF8_NOT_SUPPORTED;
}
/* bug 3891 */
/* backslash characters are not interpreted for input */
buffer = strsub(INPUT_LINE, "\\", "\\\\");
size_offsets_max = size_offsets;
offsets = (int *)MALLOC(size_offsets_max * sizeof(int));
if (offsets == NULL)
{
if (buffer)
{
FREE(buffer);
buffer = NULL;
}
return NOT_ENOUGH_MEMORY_FOR_VECTOR;
}
/* Main loop */
LOOP_PCRE_TST = FALSE;
while (!LOOP_PCRE_TST)
{
pcre *re = NULL;
pcre_extra *extra = NULL;
const char *error = NULL;
char *back_p = NULL;
char *p = NULL;
char *pp = NULL;
char *ppp = NULL;
const unsigned char *tables = NULL;
int do_G = 0;
int do_g = 0;
int erroroffset = 0, len = 0, delimiter;
LOOP_PCRE_TST = TRUE;
p = strdup(INPUT_PAT);
back_p = p;
while (isspace(*p))
{
p++;
}
if (*p == 0)
{
continue;
}
/* In-line pattern (the usual case). Get the delimiter and seek the end of
the pattern; if is isn't complete, read more. */
delimiter = *p++;
if (isalnum(delimiter) || delimiter == '\\')
{
if (buffer)
{
FREE(buffer);
buffer = NULL;
}
if (offsets)
{
FREE(offsets);
offsets = NULL;
}
if (back_p)
{
FREE(back_p);
back_p = NULL;
}
return DELIMITER_NOT_ALPHANUMERIC;
}
pp = p;
while (*pp != 0)
{
if (*pp == '\\' && pp[1] != 0)
{
pp++;
}
else if (*pp == delimiter)
{
break;
}
pp++;
}
/* If the delimiter can't be found, it's a syntax error */
if (*pp == 0)
{
if (buffer)
{
FREE(buffer);
buffer = NULL;
}
if (offsets)
{
FREE(offsets);
offsets = NULL;
}
if (back_p)
{
FREE(back_p);
back_p = NULL;
}
if (offsets)
{
FREE(offsets);
}
return CAN_NOT_COMPILE_PATTERN;
}
/* If the first character after the delimiter is backslash, make
the pattern end with backslash. This is purely to provide a way
of testing for the error message when a pattern ends with backslash. */
if (pp[1] == '\\')
{
*pp++ = '\\';
}
/* Terminate the pattern at the delimiter, and save a copy of the pattern
for callouts. */
*pp++ = 0;
/* Look for options after final delimiter */
//options = 8192;
while (*pp != 0)
{
switch (*pp++)
{
case 'f':
options |= PCRE_FIRSTLINE;
break;
case 'g':
do_g = 1;
break;
case 'i':
options |= PCRE_CASELESS;
break;
case 'm':
options |= PCRE_MULTILINE;
break;
case 's':
options |= PCRE_DOTALL;
break;
case 'x':
options |= PCRE_EXTENDED;
break;
case '+':
break;
case 'A':
options |= PCRE_ANCHORED;
break;
case 'B':
break;
case 'C':
options |= PCRE_AUTO_CALLOUT;
break;
case 'D':
break;
case 'E':
options |= PCRE_DOLLAR_ENDONLY;
break;
case 'F':
break;
case 'G':
do_G = 1;
break;
case 'I':
break;
case 'J':
options |= PCRE_DUPNAMES;
break;
case 'M':
break;
case 'N':
options |= PCRE_NO_AUTO_CAPTURE;
break;
case 'S':
break;
case 'U':
options |= PCRE_UNGREEDY;
break;
case 'X':
options |= PCRE_EXTRA;
break;
case 'Z':
break;
case '8':
{
int rc = 0;
(void)pcre_config(PCRE_CONFIG_UTF8, &rc);
if (rc != 1)
{
if (buffer)
{
FREE(buffer);
buffer = NULL;
}
if (offsets)
{
FREE(offsets);
}
return UTF8_NOT_SUPPORTED;
}
options |= PCRE_UTF8;
}
break;
case '?':
options |= PCRE_NO_UTF8_CHECK;
break;
case 'L':
ppp = pp;
/* The '\r' test here is so that it works on Windows. */
/* The '0' test is just in case this is an unterminated line. */
while (*ppp != 0 && *ppp != '\n' && *ppp != '\r' && *ppp != ' ')
{
ppp++;
}
*ppp = 0;
if (setlocale(LC_CTYPE, (const char *)pp) == NULL)
{
goto SKIP_DATA;
}
tables = pcre_maketables();
pp = ppp;
break;
case '>':
while (*pp != 0)
{
pp++;
}
while (isspace(pp[-1]))
{
pp--;
}
*pp = 0;
break;
case '<':
{
while (*pp++ != '>')
{
;
}
}
break;
case '\r': /* So that it works in Windows */
case '\n':
case ' ':
break;
default:
goto SKIP_DATA;
}
}
/* Handle compiling via the POSIX interface, which doesn't support the
timing, showing, or debugging options, nor the ability to pass over
local character tables. */
{
re = pcre_compile((char *)p, options, &error, &erroroffset, tables);
/* Compilation failed; go back for another re, skipping to blank line
if non-interactive. */
if (re == NULL)
{
SKIP_DATA:
if (buffer)
{
FREE(buffer);
buffer = NULL;
}
if (offsets)
{
FREE(offsets);
offsets = NULL;
}
if (tables)
{
(*pcre_free)((void*)tables);
tables = NULL;
}
if (extra)
{
FREE(extra);
extra = NULL;
}
if (back_p)
{
FREE(back_p);
back_p = NULL;
}
return CAN_NOT_COMPILE_PATTERN;
}
} /* End of non-POSIX compile */
/* Read data lines and test them */
{
char *q = NULL;
char *bptr = NULL;
int *use_offsets = offsets;
int use_size_offsets = size_offsets;
int callout_data = 0;
int callout_data_set = 0;
int count = 0;
int c = 0;
int copystrings = 0;
int find_match_limit = 0;
int getstrings = 0;
int gmatched = 0;
int start_offset = 0;
int g_notempty = 0;
int use_dfa = 0;
options = 0;
*copynames = 0;
*getnames = 0;
copynamesptr = copynames;
getnamesptr = getnames;
callout_count = 0;
callout_fail_count = 999999;
callout_fail_id = -1;
if (extra != NULL)
{
extra->flags &= ~(PCRE_EXTRA_MATCH_LIMIT | PCRE_EXTRA_MATCH_LIMIT_RECURSION);
}
p = buffer;
bptr = q = buffer;
while ((c = *p++) != 0)
{
int i = 0;
int n = 0;
if (c == '\\') switch ((c = *p++))
{
case 'a':
c = 7;
break;
case 'b':
c = '\b';
break;
case 'e':
c = 27;
break;
case 'f':
c = '\f';
break;
case 'n':
c = '\n';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case 'v':
c = '\v';
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
c -= '0';
while (i++ < 2 && isdigit(*p) && *p != '8' && *p != '9')
{
c = c * 8 + *p++ - '0';
}
break;
case 'x':
/* Ordinary \x */
c = 0;
while (i++ < 2 && isxdigit(*p))
{
c = c * 16 + tolower(*p) - ((isdigit(*p)) ? '0' : 'W');
p++;
}
break;
case 0: /* \ followed by EOF allows for an empty line */
p--;
continue;
case '>':
while (isdigit(*p))
{
start_offset = start_offset * 10 + *p++ - '0';
}
continue;
case 'A': /* Option setting */
options |= PCRE_ANCHORED;
continue;
case 'B':
options |= PCRE_NOTBOL;
continue;
case 'C':
if (isdigit(*p)) /* Set copy string */
{
while (isdigit(*p))
{
n = n * 10 + *p++ - '0';
}
copystrings |= 1 << n;
}
else if (isalnum(*p))
{
char *npp = copynamesptr;
while (isalnum(*p))
{
*npp++ = *p++;
}
*npp++ = 0;
*npp = 0;
pcre_get_stringnumber(re, (char *)copynamesptr);
copynamesptr = npp;
}
else if (*p == '+')
{
p++;
}
else if (*p == '-')
{
p++;
}
else if (*p == '!')
{
callout_fail_id = 0;
p++;
while (isdigit(*p))
{
callout_fail_id = callout_fail_id * 10 + *p++ - '0';
}
callout_fail_count = 0;
if (*p == '!')
{
p++;
while (isdigit(*p))
{
callout_fail_count = callout_fail_count * 10 + *p++ - '0';
}
}
}
else if (*p == '*')
{
int sign = 1;
callout_data = 0;
if (*(++p) == '-')
{
sign = -1;
p++;
}
while (isdigit(*p))
{
callout_data = callout_data * 10 + *p++ - '0';
}
callout_data *= sign;
callout_data_set = 1;
}
continue;
case 'G':
if (isdigit(*p))
{
while (isdigit(*p))
{
n = n * 10 + *p++ - '0';
}
getstrings |= 1 << n;
}
else if (isalnum(*p))
{
char *npp = getnamesptr;
while (isalnum(*p))
{
*npp++ = *p++;
}
*npp++ = 0;
*npp = 0;
pcre_get_stringnumber(re, (char *)getnamesptr);
getnamesptr = npp;
}
continue;
case 'L':
continue;
case 'M':
find_match_limit = 1;
continue;
case 'N':
options |= PCRE_NOTEMPTY;
continue;
case 'O':
while (isdigit(*p))
{
n = n * 10 + *p++ - '0';
}
if (n > size_offsets_max)
{
size_offsets_max = n;
if (offsets)
{
FREE(offsets);
}
use_offsets = offsets = (int *)MALLOC(size_offsets_max * sizeof(int));
}
use_size_offsets = n;
if (n == 0)
{
use_offsets = NULL; /* Ensures it can't write to it */
}
continue;
case 'P':
options |= PCRE_PARTIAL;
continue;
case 'Q':
while (isdigit(*p))
{
n = n * 10 + *p++ - '0';
}
if (extra == NULL)
{
extra = (pcre_extra *)MALLOC(sizeof(pcre_extra));
extra->flags = 0;
}
extra->flags |= PCRE_EXTRA_MATCH_LIMIT_RECURSION;
extra->match_limit_recursion = n;
continue;
case 'q':
while (isdigit(*p))
{
n = n * 10 + *p++ - '0';
}
if (extra == NULL)
{
extra = (pcre_extra *)MALLOC(sizeof(pcre_extra));
extra->flags = 0;
}
extra->flags |= PCRE_EXTRA_MATCH_LIMIT;
extra->match_limit = n;
continue;
#if !defined NODFA
case 'R':
options |= PCRE_DFA_RESTART;
continue;
#endif
case 'S':
continue;
case 'Z':
options |= PCRE_NOTEOL;
continue;
case '?':
options |= PCRE_NO_UTF8_CHECK;
continue;
case '<':
{
while (*p++ != '>')
{
;
}
}
continue;
}
*q++ = (char)c;
}
*q = 0;
len = (int)(q - buffer);
if ((all_use_dfa || use_dfa) && find_match_limit)
{
if (buffer)
{
FREE(buffer);
buffer = NULL;
}
if (offsets)
{
FREE(offsets);
offsets = NULL;
}
if (p)
{
FREE(p);
p = NULL;
}
if (re)
{
(*pcre_free)(re);
re = NULL;
}
if (tables)
{
(*pcre_free)((void*)tables);
tables = NULL;
}
if (extra)
{
FREE(extra);
extra = NULL;
}
return LIMIT_NOT_RELEVANT_FOR_DFA_MATCHING;
}
/* Handle matching via the POSIX interface, which does not
support timing or playing with the match limit or callout data. */
for (;; gmatched++) /* Loop for /g or /G */
{
/* If find_match_limit is set, we want to do repeated matches with
varying limits in order to find the minimum value for the match limit and
for the recursion limit. */
if (find_match_limit)
{
if (extra == NULL)
{
extra = (pcre_extra *)MALLOC(sizeof(pcre_extra));
extra->flags = 0;
}
(void)check_match_limit(re, extra, bptr, len, start_offset,
options | g_notempty, use_offsets, use_size_offsets,
PCRE_EXTRA_MATCH_LIMIT, &(extra->match_limit),
PCRE_ERROR_MATCHLIMIT);
count = check_match_limit(re, extra, bptr, len, start_offset,
options | g_notempty, use_offsets, use_size_offsets,
PCRE_EXTRA_MATCH_LIMIT_RECURSION, &(extra->match_limit_recursion),
PCRE_ERROR_RECURSIONLIMIT);
}
/* If callout_data is set, use the interface with additional data */
else if (callout_data_set)
{
if (extra == NULL)
{
extra = (pcre_extra *)MALLOC(sizeof(pcre_extra));
extra->flags = 0;
}
extra->flags |= PCRE_EXTRA_CALLOUT_DATA;
extra->callout_data = &callout_data;
count = pcre_exec(re, extra, (char *)bptr, len, start_offset,
options | g_notempty, use_offsets, use_size_offsets);
extra->flags &= ~PCRE_EXTRA_CALLOUT_DATA;
}
/* The normal case is just to do the match once, with the default
value of match_limit. */
else
{
count = pcre_exec(re, extra, (char *)bptr, len,
start_offset, options | g_notempty, use_offsets, use_size_offsets);
if (count == 0)
{
count = use_size_offsets / 3;
}
//to retrieve backref count and values
if (count > 0 && _pstCapturedString != NULL && _piCapturedStringCount != NULL)
{
int i = 0;
int iErr = 0;
iErr = pcre_fullinfo(re, extra, PCRE_INFO_CAPTURECOUNT, _piCapturedStringCount);
//sciprint("PCRE_INFO_CAPTURECOUNT %d\n", *_piCapturedStringCount);
if (*_piCapturedStringCount > 0)
{
*_pstCapturedString = (char**)MALLOC(sizeof(char*) * *_piCapturedStringCount);
for (i = 0 ; i < *_piCapturedStringCount ; i++)
{
char* pstSubstring = NULL;
pcre_get_substring(bptr, use_offsets, count, i + 1, &pstSubstring);
if (pstSubstring != NULL)
{
(*_pstCapturedString)[i] = strdup(pstSubstring);
}
pcre_free_substring(pstSubstring);
}
}
}
}
/* Matched */
if (count >= 0)
{
int i, maxcount;
maxcount = use_size_offsets / 3;
/* This is a check against a lunatic return value. */
if (count > maxcount)
{
if (buffer)
{
FREE(buffer);
buffer = NULL;
}
if (offsets)
{
FREE(offsets);
offsets = NULL;
}
if (re)
{
(*pcre_free)(re);
re = NULL;
}
if (tables)
{
(*pcre_free)((void*)tables);
tables = NULL;
}
if (extra)
{
FREE(extra);
extra = NULL;
}
if (back_p)
{
FREE(back_p);
back_p = NULL;
}
return TOO_BIG_FOR_OFFSET_SIZE;
}
for (i = 0; i < count * 2; i += 2)
{
if (use_offsets[i] >= 0)
{
*Output_Start = use_offsets[i];
*Output_End = use_offsets[i + 1];
if (buffer)
{
FREE(buffer);
}
/* use_offsets = offsets no need to free use_offsets if we free offsets */
if (offsets)
{
FREE(offsets);
}
/* "re" allocated by pcre_compile (better to use free function associated)*/
if (re)
{
(*pcre_free)(re);
}
if (extra)
{
FREE(extra);
}
if (tables)
{
/* "tables" allocated by pcre_maketables (better to use free function associated to pcre)*/
(*pcre_free)((void *)tables);
tables = NULL;
setlocale(LC_CTYPE, "C");
}
if (back_p)
{
FREE(back_p);
back_p = NULL;
}
return PCRE_FINISHED_OK;
}
}
for (copynamesptr = copynames; *copynamesptr != 0; copynamesptr += (int)strlen((char*)copynamesptr) + 1)
{
char copybuffer[256];
pcre_copy_named_substring(re, (char *)bptr, use_offsets, count, (char *)copynamesptr, copybuffer, sizeof(copybuffer));
}
for (i = 0; i < 32; i++)
{
if ((getstrings & (1 << i)) != 0)
{
const char *substring;
pcre_get_substring((char *)bptr, use_offsets, count, i, &substring);
}
}
for (getnamesptr = getnames; *getnamesptr != 0; getnamesptr += (int)strlen((char*)getnamesptr) + 1)
{
const char *substring;
pcre_get_named_substring(re, (char *)bptr, use_offsets, count, (char *)getnamesptr, &substring);
}
}
/* Failed to match. If this is a /g or /G loop and we previously set
g_notempty after a null match, this is not necessarily the end. We want
to advance the start offset, and continue. We won't be at the end of the
string - that was checked before setting g_notempty.
Complication arises in the case when the newline option is "any" or
"anycrlf". If the previous match was at the end of a line terminated by
CRLF, an advance of one character just passes the \r, whereas we should
prefer the longer newline sequence, as does the code in pcre_exec().
Fudge the offset value to achieve this.
Otherwise, in the case of UTF-8 matching, the advance must be one
character, not one byte. */
else
{
if (count == PCRE_ERROR_NOMATCH)
{
if (gmatched == 0)
{
if (tables)
{
(*pcre_free)((void *)tables);
tables = NULL;
}
if (re)
{
(*pcre_free)((void *)re);
re = NULL;
}
if (buffer)
{
FREE(buffer);
buffer = NULL;
}
if (offsets)
{
FREE(offsets);
}
if (p)
{
FREE(back_p);
back_p = NULL;
}
return NO_MATCH;
}
}
if (count == PCRE_ERROR_MATCHLIMIT )
{
if (tables)
{
(*pcre_free)((void *)tables);
tables = NULL;
}
if (re)
{
(*pcre_free)((void *)re);
re = NULL;
}
if (buffer)
{
FREE(buffer);
buffer = NULL;
}
if (offsets)
{
FREE(offsets);
offsets = NULL;
}
if (back_p)
{
FREE(back_p);
back_p = NULL;
}
return MATCH_LIMIT;
}
break; /* Out of loop */
}
/* If not /g or /G we are done */
if (!do_g && !do_G)
{
break;
}
/* If we have matched an empty string, first check to see if we are at
the end of the subject. If so, the /g loop is over. Otherwise, mimic
what Perl's /g options does. This turns out to be rather cunning. First
we set PCRE_NOTEMPTY and PCRE_ANCHORED and try the match again at the
same point. If this fails (picked up above) we advance to the next
character. */
g_notempty = 0;
if (use_offsets[0] == use_offsets[1])
{
if (use_offsets[0] == len)
{
break;
}
g_notempty = PCRE_NOTEMPTY | PCRE_ANCHORED;
}
/* For /g, update the start offset, leaving the rest alone */
if (do_g)
{
start_offset = use_offsets[1];
}
/* For /G, update the pointer and length */
else
{
bptr += use_offsets[1];
len -= use_offsets[1];
}
} /* End of loop for /g and /G */
if (re)
{
(*pcre_free)(re);
re = NULL;
}
if (extra)
{
FREE(extra);
extra = NULL;
}
if (tables)
{
(*pcre_free)((void *)tables);
tables = NULL;
}
FREE(back_p);
back_p = NULL;
continue;
} /* End of loop for data lines */
}
if (buffer)
{
FREE(buffer);
buffer = NULL;
}
if (offsets)
{
FREE(offsets);
offsets = NULL;
}
return PCRE_EXIT;
}
int main(int argc, char **argv)
{
FILE *infile = stdin;
int options = 0;
int study_options = 0;
int op = 1;
int timeit = 0;
int showinfo = 0;
int showstore = 0;
int size_offsets = 45;
int size_offsets_max;
int *offsets;
#if !defined NOPOSIX
int posix = 0;
#endif
int debug = 0;
int done = 0;
unsigned char buffer[30000];
unsigned char dbuffer[1024];
/* Static so that new_malloc can use it. */
outfile = stdout;
/* Scan options */
while (argc > 1 && argv[op][0] == '-')
{
char *endptr;
if (strcmp(argv[op], "-s") == 0 || strcmp(argv[op], "-m") == 0)
showstore = 1;
else if (strcmp(argv[op], "-t") == 0) timeit = 1;
else if (strcmp(argv[op], "-i") == 0) showinfo = 1;
else if (strcmp(argv[op], "-d") == 0) showinfo = debug = 1;
else if (strcmp(argv[op], "-o") == 0 && argc > 2 &&
((size_offsets = (int)strtoul(argv[op+1], &endptr, 10)), *endptr == 0))
{
op++;
argc--;
}
#if !defined NOPOSIX
else if (strcmp(argv[op], "-p") == 0) posix = 1;
#endif
else
{
printf("** Unknown or malformed option %s\n", argv[op]);
printf("Usage: pcretest [-d] [-i] [-o <n>] [-p] [-s] [-t] [<input> [<output>]]\n");
printf(" -d debug: show compiled code; implies -i\n"
" -i show information about compiled pattern\n"
" -o <n> set size of offsets vector to <n>\n");
#if !defined NOPOSIX
printf(" -p use POSIX interface\n");
#endif
printf(" -s output store information\n"
" -t time compilation and execution\n");
return 1;
}
op++;
argc--;
}
/* Get the store for the offsets vector, and remember what it was */
size_offsets_max = size_offsets;
offsets = malloc(size_offsets_max * sizeof(int));
if (offsets == NULL)
{
printf("** Failed to get %d bytes of memory for offsets vector\n",
size_offsets_max * sizeof(int));
return 1;
}
/* Sort out the input and output files */
if (argc > 1)
{
infile = fopen(argv[op], "r");
if (infile == NULL)
{
printf("** Failed to open %s\n", argv[op]);
return 1;
}
}
if (argc > 2)
{
outfile = fopen(argv[op+1], "w");
if (outfile == NULL)
{
printf("** Failed to open %s\n", argv[op+1]);
return 1;
}
}
/* Set alternative malloc function */
pcre_malloc = new_malloc;
/* Heading line, then prompt for first regex if stdin */
fprintf(outfile, "PCRE version %s\n\n", pcre_version());
/* Main loop */
while (!done)
{
pcre *re = NULL;
pcre_extra *extra = NULL;
#if !defined NOPOSIX /* There are still compilers that require no indent */
regex_t preg;
int do_posix = 0;
#endif
const char *error;
unsigned char *p, *pp, *ppp;
const unsigned char *tables = NULL;
int do_study = 0;
int do_debug = debug;
int do_G = 0;
int do_g = 0;
int do_showinfo = showinfo;
int do_showrest = 0;
int utf8 = 0;
int erroroffset, len, delimiter;
if (infile == stdin) printf(" re> ");
if (fgets((char *)buffer, sizeof(buffer), infile) == NULL) break;
if (infile != stdin) fprintf(outfile, "%s", (char *)buffer);
p = buffer;
while (isspace(*p)) p++;
if (*p == 0) continue;
/* Get the delimiter and seek the end of the pattern; if is isn't
complete, read more. */
delimiter = *p++;
if (isalnum(delimiter) || delimiter == '\\')
{
fprintf(outfile, "** Delimiter must not be alphameric or \\\n");
goto SKIP_DATA;
}
pp = p;
for(;;)
{
while (*pp != 0)
{
if (*pp == '\\' && pp[1] != 0) pp++;
else if (*pp == delimiter) break;
pp++;
}
if (*pp != 0) break;
len = sizeof(buffer) - (pp - buffer);
if (len < 256)
{
fprintf(outfile, "** Expression too long - missing delimiter?\n");
goto SKIP_DATA;
}
if (infile == stdin) printf(" > ");
if (fgets((char *)pp, len, infile) == NULL)
{
fprintf(outfile, "** Unexpected EOF\n");
done = 1;
goto CONTINUE;
}
if (infile != stdin) fprintf(outfile, "%s", (char *)pp);
}
/* If the first character after the delimiter is backslash, make
the pattern end with backslash. This is purely to provide a way
of testing for the error message when a pattern ends with backslash. */
if (pp[1] == '\\') *pp++ = '\\';
/* Terminate the pattern at the delimiter */
*pp++ = 0;
/* Look for options after final delimiter */
options = 0;
study_options = 0;
log_store = showstore; /* default from command line */
while (*pp != 0)
{
switch (*pp++)
{
case 'g': do_g = 1; break;
case 'i': options |= PCRE_CASELESS; break;
case 'm': options |= PCRE_MULTILINE; break;
case 's': options |= PCRE_DOTALL; break;
case 'x': options |= PCRE_EXTENDED; break;
case '+': do_showrest = 1; break;
case 'A': options |= PCRE_ANCHORED; break;
case 'D': do_debug = do_showinfo = 1; break;
case 'E': options |= PCRE_DOLLAR_ENDONLY; break;
case 'G': do_G = 1; break;
case 'I': do_showinfo = 1; break;
case 'M': log_store = 1; break;
#if !defined NOPOSIX
case 'P': do_posix = 1; break;
#endif
case 'S': do_study = 1; break;
case 'U': options |= PCRE_UNGREEDY; break;
case 'X': options |= PCRE_EXTRA; break;
case '8': options |= PCRE_UTF8; utf8 = 1; break;
case 'L':
ppp = pp;
while (*ppp != '\n' && *ppp != ' ') ppp++;
*ppp = 0;
if (setlocale(LC_CTYPE, (const char *)pp) == NULL)
{
fprintf(outfile, "** Failed to set locale \"%s\"\n", pp);
goto SKIP_DATA;
}
tables = pcre_maketables();
pp = ppp;
break;
case '\n': case ' ': break;
default:
fprintf(outfile, "** Unknown option '%c'\n", pp[-1]);
goto SKIP_DATA;
}
}
/* Handle compiling via the POSIX interface, which doesn't support the
timing, showing, or debugging options, nor the ability to pass over
local character tables. */
#if !defined NOPOSIX
if (posix || do_posix)
{
int rc;
int cflags = 0;
if ((options & PCRE_CASELESS) != 0) cflags |= REG_ICASE;
if ((options & PCRE_MULTILINE) != 0) cflags |= REG_NEWLINE;
rc = regcomp(&preg, (char *)p, cflags);
/* Compilation failed; go back for another re, skipping to blank line
if non-interactive. */
if (rc != 0)
{
(void)regerror(rc, &preg, (char *)buffer, sizeof(buffer));
fprintf(outfile, "Failed: POSIX code %d: %s\n", rc, buffer);
goto SKIP_DATA;
}
}
/* Handle compiling via the native interface */
else
#endif /* !defined NOPOSIX */
{
if (timeit)
{
register int i;
clock_t time_taken;
clock_t start_time = clock();
for (i = 0; i < LOOPREPEAT; i++)
{
re = pcre_compile((char *)p, options, &error, &erroroffset, tables);
if (re != NULL) free(re);
}
time_taken = clock() - start_time;
fprintf(outfile, "Compile time %.3f milliseconds\n",
((double)time_taken * 1000.0) /
((double)LOOPREPEAT * (double)CLOCKS_PER_SEC));
}
re = pcre_compile((char *)p, options, &error, &erroroffset, tables);
/* Compilation failed; go back for another re, skipping to blank line
if non-interactive. */
if (re == NULL)
{
fprintf(outfile, "Failed: %s at offset %d\n", error, erroroffset);
SKIP_DATA:
if (infile != stdin)
{
for (;;)
{
if (fgets((char *)buffer, sizeof(buffer), infile) == NULL)
{
done = 1;
goto CONTINUE;
}
len = (int)strlen((char *)buffer);
while (len > 0 && isspace(buffer[len-1])) len--;
if (len == 0) break;
}
fprintf(outfile, "\n");
}
goto CONTINUE;
}
/* Compilation succeeded; print data if required. There are now two
info-returning functions. The old one has a limited interface and
returns only limited data. Check that it agrees with the newer one. */
if (do_showinfo)
{
unsigned long int get_options;
int old_first_char, old_options, old_count;
int count, backrefmax, first_char, need_char;
size_t size;
if (do_debug) print_internals(re);
new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);
new_info(re, NULL, PCRE_INFO_SIZE, &size);
new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);
new_info(re, NULL, PCRE_INFO_BACKREFMAX, &backrefmax);
new_info(re, NULL, PCRE_INFO_FIRSTCHAR, &first_char);
new_info(re, NULL, PCRE_INFO_LASTLITERAL, &need_char);
old_count = pcre_info(re, &old_options, &old_first_char);
if (count < 0) fprintf(outfile,
"Error %d from pcre_info()\n", count);
else
{
if (old_count != count) fprintf(outfile,
"Count disagreement: pcre_fullinfo=%d pcre_info=%d\n", count,
old_count);
if (old_first_char != first_char) fprintf(outfile,
"First char disagreement: pcre_fullinfo=%d pcre_info=%d\n",
first_char, old_first_char);
if (old_options != (int)get_options) fprintf(outfile,
"Options disagreement: pcre_fullinfo=%ld pcre_info=%d\n",
get_options, old_options);
}
if (size != gotten_store) fprintf(outfile,
"Size disagreement: pcre_fullinfo=%d call to malloc for %d\n",
size, gotten_store);
fprintf(outfile, "Capturing subpattern count = %d\n", count);
if (backrefmax > 0)
fprintf(outfile, "Max back reference = %d\n", backrefmax);
if (get_options == 0) fprintf(outfile, "No options\n");
else fprintf(outfile, "Options:%s%s%s%s%s%s%s%s%s\n",
((get_options & PCRE_ANCHORED) != 0)? " anchored" : "",
((get_options & PCRE_CASELESS) != 0)? " caseless" : "",
((get_options & PCRE_EXTENDED) != 0)? " extended" : "",
((get_options & PCRE_MULTILINE) != 0)? " multiline" : "",
((get_options & PCRE_DOTALL) != 0)? " dotall" : "",
((get_options & PCRE_DOLLAR_ENDONLY) != 0)? " dollar_endonly" : "",
((get_options & PCRE_EXTRA) != 0)? " extra" : "",
((get_options & PCRE_UNGREEDY) != 0)? " ungreedy" : "",
((get_options & PCRE_UTF8) != 0)? " utf8" : "");
if (((((real_pcre *)re)->options) & PCRE_ICHANGED) != 0)
fprintf(outfile, "Case state changes\n");
if (first_char == -1)
{
fprintf(outfile, "First char at start or follows \\n\n");
}
else if (first_char < 0)
{
fprintf(outfile, "No first char\n");
}
else
{
if (isprint(first_char))
fprintf(outfile, "First char = \'%c\'\n", first_char);
else
fprintf(outfile, "First char = %d\n", first_char);
}
if (need_char < 0)
{
fprintf(outfile, "No need char\n");
}
else
{
if (isprint(need_char))
fprintf(outfile, "Need char = \'%c\'\n", need_char);
else
fprintf(outfile, "Need char = %d\n", need_char);
}
}
/* If /S was present, study the regexp to generate additional info to
help with the matching. */
if (do_study)
{
if (timeit)
{
register int i;
clock_t time_taken;
clock_t start_time = clock();
for (i = 0; i < LOOPREPEAT; i++)
extra = pcre_study(re, study_options, &error);
time_taken = clock() - start_time;
if (extra != NULL) free(extra);
fprintf(outfile, " Study time %.3f milliseconds\n",
((double)time_taken * 1000.0)/
((double)LOOPREPEAT * (double)CLOCKS_PER_SEC));
}
extra = pcre_study(re, study_options, &error);
if (error != NULL)
fprintf(outfile, "Failed to study: %s\n", error);
else if (extra == NULL)
fprintf(outfile, "Study returned NULL\n");
else if (do_showinfo)
{
uschar *start_bits = NULL;
new_info(re, extra, PCRE_INFO_FIRSTTABLE, &start_bits);
if (start_bits == NULL)
fprintf(outfile, "No starting character set\n");
else
{
int i;
int c = 24;
fprintf(outfile, "Starting character set: ");
for (i = 0; i < 256; i++)
{
if ((start_bits[i/8] & (1<<(i%8))) != 0)
{
if (c > 75)
{
fprintf(outfile, "\n ");
c = 2;
}
if (isprint(i) && i != ' ')
{
fprintf(outfile, "%c ", i);
c += 2;
}
else
{
fprintf(outfile, "\\x%02x ", i);
c += 5;
}
}
}
fprintf(outfile, "\n");
}
}
}
}
/* Read data lines and test them */
for (;;)
{
unsigned char *q;
unsigned char *bptr = dbuffer;
int *use_offsets = offsets;
int use_size_offsets = size_offsets;
int count, c;
int copystrings = 0;
int getstrings = 0;
int getlist = 0;
int gmatched = 0;
int start_offset = 0;
int g_notempty = 0;
options = 0;
if (infile == stdin) printf("data> ");
if (fgets((char *)buffer, sizeof(buffer), infile) == NULL)
{
done = 1;
goto CONTINUE;
}
if (infile != stdin) fprintf(outfile, "%s", (char *)buffer);
len = (int)strlen((char *)buffer);
while (len > 0 && isspace(buffer[len-1])) len--;
buffer[len] = 0;
if (len == 0) break;
p = buffer;
while (isspace(*p)) p++;
q = dbuffer;
while ((c = *p++) != 0)
{
int i = 0;
int n = 0;
if (c == '\\') switch ((c = *p++))
{
case 'a': c = 7; break;
case 'b': c = '\b'; break;
case 'e': c = 27; break;
case 'f': c = '\f'; break;
case 'n': c = '\n'; break;
case 'r': c = '\r'; break;
case 't': c = '\t'; break;
case 'v': c = '\v'; break;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
c -= '0';
while (i++ < 2 && isdigit(*p) && *p != '8' && *p != '9')
c = c * 8 + *p++ - '0';
break;
case 'x':
/* Handle \x{..} specially - new Perl thing for utf8 */
if (*p == '{')
{
unsigned char *pt = p;
c = 0;
while (isxdigit(*(++pt)))
c = c * 16 + tolower(*pt) - ((isdigit(*pt))? '0' : 'W');
if (*pt == '}')
{
unsigned char buffer[8];
int ii, utn;
utn = ord2utf8(c, buffer);
for (ii = 0; ii < utn - 1; ii++) *q++ = buffer[ii];
c = buffer[ii]; /* Last byte */
p = pt + 1;
break;
}
/* Not correct form; fall through */
}
/* Ordinary \x */
c = 0;
while (i++ < 2 && isxdigit(*p))
{
c = c * 16 + tolower(*p) - ((isdigit(*p))? '0' : 'W');
p++;
}
break;
case 0: /* Allows for an empty line */
p--;
continue;
case 'A': /* Option setting */
options |= PCRE_ANCHORED;
continue;
case 'B':
options |= PCRE_NOTBOL;
continue;
case 'C':
while(isdigit(*p)) n = n * 10 + *p++ - '0';
copystrings |= 1 << n;
continue;
case 'G':
while(isdigit(*p)) n = n * 10 + *p++ - '0';
getstrings |= 1 << n;
continue;
case 'L':
getlist = 1;
continue;
case 'N':
options |= PCRE_NOTEMPTY;
continue;
case 'O':
while(isdigit(*p)) n = n * 10 + *p++ - '0';
if (n > size_offsets_max)
{
size_offsets_max = n;
free(offsets);
use_offsets = offsets = malloc(size_offsets_max * sizeof(int));
if (offsets == NULL)
{
printf("** Failed to get %d bytes of memory for offsets vector\n",
size_offsets_max * sizeof(int));
return 1;
}
}
use_size_offsets = n;
if (n == 0) use_offsets = NULL;
continue;
case 'Z':
options |= PCRE_NOTEOL;
continue;
}
*q++ = c;
}
*q = 0;
len = q - dbuffer;
/* Handle matching via the POSIX interface, which does not
support timing. */
#if !defined NOPOSIX
if (posix || do_posix)
{
int rc;
int eflags = 0;
regmatch_t *pmatch = malloc(sizeof(regmatch_t) * use_size_offsets);
if ((options & PCRE_NOTBOL) != 0) eflags |= REG_NOTBOL;
if ((options & PCRE_NOTEOL) != 0) eflags |= REG_NOTEOL;
rc = regexec(&preg, (const char *)bptr, use_size_offsets, pmatch, eflags);
if (rc != 0)
{
(void)regerror(rc, &preg, (char *)buffer, sizeof(buffer));
fprintf(outfile, "No match: POSIX code %d: %s\n", rc, buffer);
}
else
{
size_t i;
for (i = 0; i < use_size_offsets; i++)
{
if (pmatch[i].rm_so >= 0)
{
fprintf(outfile, "%2d: ", (int)i);
pchars(dbuffer + pmatch[i].rm_so,
pmatch[i].rm_eo - pmatch[i].rm_so, utf8);
fprintf(outfile, "\n");
if (i == 0 && do_showrest)
{
fprintf(outfile, " 0+ ");
pchars(dbuffer + pmatch[i].rm_eo, len - pmatch[i].rm_eo, utf8);
fprintf(outfile, "\n");
}
}
}
}
free(pmatch);
}
/* Handle matching via the native interface - repeats for /g and /G */
else
#endif /* !defined NOPOSIX */
for (;; gmatched++) /* Loop for /g or /G */
{
if (timeit)
{
register int i;
clock_t time_taken;
clock_t start_time = clock();
for (i = 0; i < LOOPREPEAT; i++)
count = pcre_exec(re, extra, (char *)bptr, len,
start_offset, options | g_notempty, use_offsets, use_size_offsets);
time_taken = clock() - start_time;
fprintf(outfile, "Execute time %.3f milliseconds\n",
((double)time_taken * 1000.0)/
((double)LOOPREPEAT * (double)CLOCKS_PER_SEC));
}
count = pcre_exec(re, extra, (char *)bptr, len,
start_offset, options | g_notempty, use_offsets, use_size_offsets);
if (count == 0)
{
fprintf(outfile, "Matched, but too many substrings\n");
count = use_size_offsets/3;
}
/* Matched */
if (count >= 0)
{
int i;
for (i = 0; i < count * 2; i += 2)
{
if (use_offsets[i] < 0)
fprintf(outfile, "%2d: <unset>\n", i/2);
else
{
fprintf(outfile, "%2d: ", i/2);
pchars(bptr + use_offsets[i], use_offsets[i+1] - use_offsets[i], utf8);
fprintf(outfile, "\n");
if (i == 0)
{
if (do_showrest)
{
fprintf(outfile, " 0+ ");
pchars(bptr + use_offsets[i+1], len - use_offsets[i+1], utf8);
fprintf(outfile, "\n");
}
}
}
}
for (i = 0; i < 32; i++)
{
if ((copystrings & (1 << i)) != 0)
{
char copybuffer[16];
int rc = pcre_copy_substring((char *)bptr, use_offsets, count,
i, copybuffer, sizeof(copybuffer));
if (rc < 0)
fprintf(outfile, "copy substring %d failed %d\n", i, rc);
else
fprintf(outfile, "%2dC %s (%d)\n", i, copybuffer, rc);
}
}
for (i = 0; i < 32; i++)
{
if ((getstrings & (1 << i)) != 0)
{
const char *substring;
int rc = pcre_get_substring((char *)bptr, use_offsets, count,
i, &substring);
if (rc < 0)
fprintf(outfile, "get substring %d failed %d\n", i, rc);
else
{
fprintf(outfile, "%2dG %s (%d)\n", i, substring, rc);
/* free((void *)substring); */
pcre_free_substring(substring);
}
}
}
if (getlist)
{
const char **stringlist;
int rc = pcre_get_substring_list((char *)bptr, use_offsets, count,
&stringlist);
if (rc < 0)
fprintf(outfile, "get substring list failed %d\n", rc);
else
{
for (i = 0; i < count; i++)
fprintf(outfile, "%2dL %s\n", i, stringlist[i]);
if (stringlist[i] != NULL)
fprintf(outfile, "string list not terminated by NULL\n");
/* free((void *)stringlist); */
pcre_free_substring_list(stringlist);
}
}
}
/* Failed to match. If this is a /g or /G loop and we previously set
g_notempty after a null match, this is not necessarily the end.
We want to advance the start offset, and continue. Fudge the offset
values to achieve this. We won't be at the end of the string - that
was checked before setting g_notempty. */
else
{
if (g_notempty != 0)
{
use_offsets[0] = start_offset;
use_offsets[1] = start_offset + 1;
}
else
{
if (gmatched == 0) /* Error if no previous matches */
{
if (count == -1) fprintf(outfile, "No match\n");
else fprintf(outfile, "Error %d\n", count);
}
break; /* Out of the /g loop */
}
}
/* If not /g or /G we are done */
if (!do_g && !do_G) break;
/* If we have matched an empty string, first check to see if we are at
the end of the subject. If so, the /g loop is over. Otherwise, mimic
what Perl's /g options does. This turns out to be rather cunning. First
we set PCRE_NOTEMPTY and PCRE_ANCHORED and try the match again at the
same point. If this fails (picked up above) we advance to the next
character. */
g_notempty = 0;
if (use_offsets[0] == use_offsets[1])
{
if (use_offsets[0] == len) break;
g_notempty = PCRE_NOTEMPTY | PCRE_ANCHORED;
}
/* For /g, update the start offset, leaving the rest alone */
if (do_g) start_offset = use_offsets[1];
/* For /G, update the pointer and length */
else
{
bptr += use_offsets[1];
len -= use_offsets[1];
}
} /* End of loop for /g and /G */
} /* End of loop for data lines */
CONTINUE:
#if !defined NOPOSIX
if (posix || do_posix) regfree(&preg);
#endif
if (re != NULL) free(re);
if (extra != NULL) free(extra);
if (tables != NULL)
{
free((void *)tables);
setlocale(LC_CTYPE, "C");
}
}
fprintf(outfile, "\n");
return 0;
}
